1218887Sdim//===--- ItaniumMangle.cpp - Itanium C++ Name Mangling ----------*- C++ -*-===// 2218887Sdim// 3218887Sdim// The LLVM Compiler Infrastructure 4218887Sdim// 5218887Sdim// This file is distributed under the University of Illinois Open Source 6218887Sdim// License. See LICENSE.TXT for details. 7218887Sdim// 8218887Sdim//===----------------------------------------------------------------------===// 9218887Sdim// 10218887Sdim// Implements C++ name mangling according to the Itanium C++ ABI, 11218887Sdim// which is used in GCC 3.2 and newer (and many compilers that are 12218887Sdim// ABI-compatible with GCC): 13218887Sdim// 14218887Sdim// http://www.codesourcery.com/public/cxx-abi/abi.html 15218887Sdim// 16218887Sdim//===----------------------------------------------------------------------===// 17218887Sdim#include "clang/AST/Mangle.h" 18218887Sdim#include "clang/AST/ASTContext.h" 19249423Sdim#include "clang/AST/Attr.h" 20218887Sdim#include "clang/AST/Decl.h" 21218887Sdim#include "clang/AST/DeclCXX.h" 22218887Sdim#include "clang/AST/DeclObjC.h" 23218887Sdim#include "clang/AST/DeclTemplate.h" 24218887Sdim#include "clang/AST/ExprCXX.h" 25224145Sdim#include "clang/AST/ExprObjC.h" 26221345Sdim#include "clang/AST/TypeLoc.h" 27218887Sdim#include "clang/Basic/ABI.h" 28218887Sdim#include "clang/Basic/SourceManager.h" 29218887Sdim#include "clang/Basic/TargetInfo.h" 30218887Sdim#include "llvm/ADT/StringExtras.h" 31249423Sdim#include "llvm/Support/ErrorHandling.h" 32218887Sdim#include "llvm/Support/raw_ostream.h" 33218887Sdim 34218887Sdim#define MANGLE_CHECKER 0 35218887Sdim 36218887Sdim#if MANGLE_CHECKER 37218887Sdim#include <cxxabi.h> 38218887Sdim#endif 39218887Sdim 40218887Sdimusing namespace clang; 41218887Sdim 42218887Sdimnamespace { 43218887Sdim 44234353Sdim/// \brief Retrieve the declaration context that should be used when mangling 45234353Sdim/// the given declaration. 46234353Sdimstatic const DeclContext *getEffectiveDeclContext(const Decl *D) { 47234353Sdim // The ABI assumes that lambda closure types that occur within 48234353Sdim // default arguments live in the context of the function. However, due to 49234353Sdim // the way in which Clang parses and creates function declarations, this is 50234353Sdim // not the case: the lambda closure type ends up living in the context 51234353Sdim // where the function itself resides, because the function declaration itself 52234353Sdim // had not yet been created. Fix the context here. 53234353Sdim if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 54234353Sdim if (RD->isLambda()) 55234353Sdim if (ParmVarDecl *ContextParam 56234353Sdim = dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl())) 57234353Sdim return ContextParam->getDeclContext(); 58234353Sdim } 59263508Sdim 60263508Sdim // Perform the same check for block literals. 61263508Sdim if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) { 62263508Sdim if (ParmVarDecl *ContextParam 63263508Sdim = dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl())) 64263508Sdim return ContextParam->getDeclContext(); 65263508Sdim } 66234353Sdim 67263508Sdim const DeclContext *DC = D->getDeclContext(); 68263508Sdim if (const CapturedDecl *CD = dyn_cast<CapturedDecl>(DC)) 69263508Sdim return getEffectiveDeclContext(CD); 70263508Sdim 71263508Sdim return DC; 72234353Sdim} 73234353Sdim 74234353Sdimstatic const DeclContext *getEffectiveParentContext(const DeclContext *DC) { 75234353Sdim return getEffectiveDeclContext(cast<Decl>(DC)); 76234353Sdim} 77263508Sdim 78263508Sdimstatic bool isLocalContainerContext(const DeclContext *DC) { 79263508Sdim return isa<FunctionDecl>(DC) || isa<ObjCMethodDecl>(DC) || isa<BlockDecl>(DC); 80263508Sdim} 81263508Sdim 82263508Sdimstatic const RecordDecl *GetLocalClassDecl(const Decl *D) { 83263508Sdim const DeclContext *DC = getEffectiveDeclContext(D); 84218887Sdim while (!DC->isNamespace() && !DC->isTranslationUnit()) { 85263508Sdim if (isLocalContainerContext(DC)) 86263508Sdim return dyn_cast<RecordDecl>(D); 87263508Sdim D = cast<Decl>(DC); 88263508Sdim DC = getEffectiveDeclContext(D); 89218887Sdim } 90218887Sdim return 0; 91218887Sdim} 92218887Sdim 93221345Sdimstatic const FunctionDecl *getStructor(const FunctionDecl *fn) { 94221345Sdim if (const FunctionTemplateDecl *ftd = fn->getPrimaryTemplate()) 95221345Sdim return ftd->getTemplatedDecl(); 96218887Sdim 97221345Sdim return fn; 98221345Sdim} 99218887Sdim 100221345Sdimstatic const NamedDecl *getStructor(const NamedDecl *decl) { 101221345Sdim const FunctionDecl *fn = dyn_cast_or_null<FunctionDecl>(decl); 102221345Sdim return (fn ? getStructor(fn) : decl); 103218887Sdim} 104234353Sdim 105218887Sdimstatic const unsigned UnknownArity = ~0U; 106218887Sdim 107263508Sdimclass ItaniumMangleContextImpl : public ItaniumMangleContext { 108218887Sdim llvm::DenseMap<const TagDecl *, uint64_t> AnonStructIds; 109263508Sdim typedef std::pair<const DeclContext*, IdentifierInfo*> DiscriminatorKeyTy; 110263508Sdim llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator; 111218887Sdim llvm::DenseMap<const NamedDecl*, unsigned> Uniquifier; 112218887Sdim 113218887Sdimpublic: 114263508Sdim explicit ItaniumMangleContextImpl(ASTContext &Context, 115263508Sdim DiagnosticsEngine &Diags) 116263508Sdim : ItaniumMangleContext(Context, Diags) {} 117218887Sdim 118218887Sdim uint64_t getAnonymousStructId(const TagDecl *TD) { 119218887Sdim std::pair<llvm::DenseMap<const TagDecl *, 120218887Sdim uint64_t>::iterator, bool> Result = 121218887Sdim AnonStructIds.insert(std::make_pair(TD, AnonStructIds.size())); 122218887Sdim return Result.first->second; 123218887Sdim } 124218887Sdim 125218887Sdim /// @name Mangler Entry Points 126218887Sdim /// @{ 127218887Sdim 128263508Sdim bool shouldMangleCXXName(const NamedDecl *D); 129263508Sdim void mangleCXXName(const NamedDecl *D, raw_ostream &); 130218887Sdim void mangleThunk(const CXXMethodDecl *MD, 131218887Sdim const ThunkInfo &Thunk, 132226633Sdim raw_ostream &); 133218887Sdim void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type, 134218887Sdim const ThisAdjustment &ThisAdjustment, 135226633Sdim raw_ostream &); 136218887Sdim void mangleReferenceTemporary(const VarDecl *D, 137226633Sdim raw_ostream &); 138218887Sdim void mangleCXXVTable(const CXXRecordDecl *RD, 139226633Sdim raw_ostream &); 140218887Sdim void mangleCXXVTT(const CXXRecordDecl *RD, 141226633Sdim raw_ostream &); 142218887Sdim void mangleCXXCtorVTable(const CXXRecordDecl *RD, int64_t Offset, 143218887Sdim const CXXRecordDecl *Type, 144226633Sdim raw_ostream &); 145226633Sdim void mangleCXXRTTI(QualType T, raw_ostream &); 146226633Sdim void mangleCXXRTTIName(QualType T, raw_ostream &); 147263508Sdim void mangleTypeName(QualType T, raw_ostream &); 148218887Sdim void mangleCXXCtor(const CXXConstructorDecl *D, CXXCtorType Type, 149226633Sdim raw_ostream &); 150218887Sdim void mangleCXXDtor(const CXXDestructorDecl *D, CXXDtorType Type, 151226633Sdim raw_ostream &); 152218887Sdim 153263508Sdim void mangleStaticGuardVariable(const VarDecl *D, raw_ostream &); 154263508Sdim void mangleDynamicInitializer(const VarDecl *D, raw_ostream &Out); 155263508Sdim void mangleDynamicAtExitDestructor(const VarDecl *D, raw_ostream &Out); 156251662Sdim void mangleItaniumThreadLocalInit(const VarDecl *D, raw_ostream &); 157251662Sdim void mangleItaniumThreadLocalWrapper(const VarDecl *D, raw_ostream &); 158218887Sdim 159218887Sdim bool getNextDiscriminator(const NamedDecl *ND, unsigned &disc) { 160263508Sdim // Lambda closure types are already numbered. 161234353Sdim if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(ND)) 162263508Sdim if (RD->isLambda()) 163234353Sdim return false; 164263508Sdim 165263508Sdim // Anonymous tags are already numbered. 166263508Sdim if (const TagDecl *Tag = dyn_cast<TagDecl>(ND)) { 167263508Sdim if (Tag->getName().empty() && !Tag->getTypedefNameForAnonDecl()) 168263508Sdim return false; 169263508Sdim } 170263508Sdim 171263508Sdim // Use the canonical number for externally visible decls. 172263508Sdim if (ND->isExternallyVisible()) { 173263508Sdim unsigned discriminator = getASTContext().getManglingNumber(ND); 174263508Sdim if (discriminator == 1) 175263508Sdim return false; 176263508Sdim disc = discriminator - 2; 177263508Sdim return true; 178263508Sdim } 179263508Sdim 180263508Sdim // Make up a reasonable number for internal decls. 181218887Sdim unsigned &discriminator = Uniquifier[ND]; 182263508Sdim if (!discriminator) { 183263508Sdim const DeclContext *DC = getEffectiveDeclContext(ND); 184263508Sdim discriminator = ++Discriminator[std::make_pair(DC, ND->getIdentifier())]; 185263508Sdim } 186218887Sdim if (discriminator == 1) 187218887Sdim return false; 188218887Sdim disc = discriminator-2; 189218887Sdim return true; 190218887Sdim } 191218887Sdim /// @} 192218887Sdim}; 193218887Sdim 194218887Sdim/// CXXNameMangler - Manage the mangling of a single name. 195218887Sdimclass CXXNameMangler { 196263508Sdim ItaniumMangleContextImpl &Context; 197226633Sdim raw_ostream &Out; 198218887Sdim 199221345Sdim /// The "structor" is the top-level declaration being mangled, if 200221345Sdim /// that's not a template specialization; otherwise it's the pattern 201221345Sdim /// for that specialization. 202221345Sdim const NamedDecl *Structor; 203218887Sdim unsigned StructorType; 204218887Sdim 205218887Sdim /// SeqID - The next subsitution sequence number. 206218887Sdim unsigned SeqID; 207218887Sdim 208221345Sdim class FunctionTypeDepthState { 209221345Sdim unsigned Bits; 210221345Sdim 211221345Sdim enum { InResultTypeMask = 1 }; 212221345Sdim 213221345Sdim public: 214221345Sdim FunctionTypeDepthState() : Bits(0) {} 215221345Sdim 216221345Sdim /// The number of function types we're inside. 217221345Sdim unsigned getDepth() const { 218221345Sdim return Bits >> 1; 219221345Sdim } 220221345Sdim 221221345Sdim /// True if we're in the return type of the innermost function type. 222221345Sdim bool isInResultType() const { 223221345Sdim return Bits & InResultTypeMask; 224221345Sdim } 225221345Sdim 226221345Sdim FunctionTypeDepthState push() { 227221345Sdim FunctionTypeDepthState tmp = *this; 228221345Sdim Bits = (Bits & ~InResultTypeMask) + 2; 229221345Sdim return tmp; 230221345Sdim } 231221345Sdim 232221345Sdim void enterResultType() { 233221345Sdim Bits |= InResultTypeMask; 234221345Sdim } 235221345Sdim 236221345Sdim void leaveResultType() { 237221345Sdim Bits &= ~InResultTypeMask; 238221345Sdim } 239221345Sdim 240221345Sdim void pop(FunctionTypeDepthState saved) { 241221345Sdim assert(getDepth() == saved.getDepth() + 1); 242221345Sdim Bits = saved.Bits; 243221345Sdim } 244221345Sdim 245221345Sdim } FunctionTypeDepth; 246221345Sdim 247218887Sdim llvm::DenseMap<uintptr_t, unsigned> Substitutions; 248218887Sdim 249218887Sdim ASTContext &getASTContext() const { return Context.getASTContext(); } 250218887Sdim 251218887Sdimpublic: 252263508Sdim CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_, 253221345Sdim const NamedDecl *D = 0) 254221345Sdim : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(0), 255221345Sdim SeqID(0) { 256221345Sdim // These can't be mangled without a ctor type or dtor type. 257221345Sdim assert(!D || (!isa<CXXDestructorDecl>(D) && 258221345Sdim !isa<CXXConstructorDecl>(D))); 259221345Sdim } 260263508Sdim CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_, 261218887Sdim const CXXConstructorDecl *D, CXXCtorType Type) 262218887Sdim : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type), 263221345Sdim SeqID(0) { } 264263508Sdim CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_, 265218887Sdim const CXXDestructorDecl *D, CXXDtorType Type) 266218887Sdim : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type), 267221345Sdim SeqID(0) { } 268218887Sdim 269218887Sdim#if MANGLE_CHECKER 270218887Sdim ~CXXNameMangler() { 271218887Sdim if (Out.str()[0] == '\01') 272218887Sdim return; 273218887Sdim 274218887Sdim int status = 0; 275218887Sdim char *result = abi::__cxa_demangle(Out.str().str().c_str(), 0, 0, &status); 276218887Sdim assert(status == 0 && "Could not demangle mangled name!"); 277218887Sdim free(result); 278218887Sdim } 279218887Sdim#endif 280226633Sdim raw_ostream &getStream() { return Out; } 281218887Sdim 282226633Sdim void mangle(const NamedDecl *D, StringRef Prefix = "_Z"); 283218887Sdim void mangleCallOffset(int64_t NonVirtual, int64_t Virtual); 284218887Sdim void mangleNumber(const llvm::APSInt &I); 285218887Sdim void mangleNumber(int64_t Number); 286218887Sdim void mangleFloat(const llvm::APFloat &F); 287218887Sdim void mangleFunctionEncoding(const FunctionDecl *FD); 288218887Sdim void mangleName(const NamedDecl *ND); 289218887Sdim void mangleType(QualType T); 290218887Sdim void mangleNameOrStandardSubstitution(const NamedDecl *ND); 291218887Sdim 292218887Sdimprivate: 293218887Sdim bool mangleSubstitution(const NamedDecl *ND); 294218887Sdim bool mangleSubstitution(QualType T); 295218887Sdim bool mangleSubstitution(TemplateName Template); 296218887Sdim bool mangleSubstitution(uintptr_t Ptr); 297218887Sdim 298224145Sdim void mangleExistingSubstitution(QualType type); 299224145Sdim void mangleExistingSubstitution(TemplateName name); 300224145Sdim 301218887Sdim bool mangleStandardSubstitution(const NamedDecl *ND); 302218887Sdim 303218887Sdim void addSubstitution(const NamedDecl *ND) { 304218887Sdim ND = cast<NamedDecl>(ND->getCanonicalDecl()); 305218887Sdim 306218887Sdim addSubstitution(reinterpret_cast<uintptr_t>(ND)); 307218887Sdim } 308218887Sdim void addSubstitution(QualType T); 309218887Sdim void addSubstitution(TemplateName Template); 310218887Sdim void addSubstitution(uintptr_t Ptr); 311218887Sdim 312221345Sdim void mangleUnresolvedPrefix(NestedNameSpecifier *qualifier, 313221345Sdim NamedDecl *firstQualifierLookup, 314221345Sdim bool recursive = false); 315221345Sdim void mangleUnresolvedName(NestedNameSpecifier *qualifier, 316221345Sdim NamedDecl *firstQualifierLookup, 317221345Sdim DeclarationName name, 318218887Sdim unsigned KnownArity = UnknownArity); 319218887Sdim 320218887Sdim void mangleName(const TemplateDecl *TD, 321218887Sdim const TemplateArgument *TemplateArgs, 322218887Sdim unsigned NumTemplateArgs); 323218887Sdim void mangleUnqualifiedName(const NamedDecl *ND) { 324218887Sdim mangleUnqualifiedName(ND, ND->getDeclName(), UnknownArity); 325218887Sdim } 326218887Sdim void mangleUnqualifiedName(const NamedDecl *ND, DeclarationName Name, 327218887Sdim unsigned KnownArity); 328218887Sdim void mangleUnscopedName(const NamedDecl *ND); 329218887Sdim void mangleUnscopedTemplateName(const TemplateDecl *ND); 330218887Sdim void mangleUnscopedTemplateName(TemplateName); 331218887Sdim void mangleSourceName(const IdentifierInfo *II); 332263508Sdim void mangleLocalName(const Decl *D); 333263508Sdim void mangleBlockForPrefix(const BlockDecl *Block); 334263508Sdim void mangleUnqualifiedBlock(const BlockDecl *Block); 335234353Sdim void mangleLambda(const CXXRecordDecl *Lambda); 336218887Sdim void mangleNestedName(const NamedDecl *ND, const DeclContext *DC, 337218887Sdim bool NoFunction=false); 338218887Sdim void mangleNestedName(const TemplateDecl *TD, 339218887Sdim const TemplateArgument *TemplateArgs, 340218887Sdim unsigned NumTemplateArgs); 341221345Sdim void manglePrefix(NestedNameSpecifier *qualifier); 342218887Sdim void manglePrefix(const DeclContext *DC, bool NoFunction=false); 343223017Sdim void manglePrefix(QualType type); 344263508Sdim void mangleTemplatePrefix(const TemplateDecl *ND, bool NoFunction=false); 345218887Sdim void mangleTemplatePrefix(TemplateName Template); 346218887Sdim void mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity); 347218887Sdim void mangleQualifiers(Qualifiers Quals); 348218887Sdim void mangleRefQualifier(RefQualifierKind RefQualifier); 349218887Sdim 350218887Sdim void mangleObjCMethodName(const ObjCMethodDecl *MD); 351218887Sdim 352218887Sdim // Declare manglers for every type class. 353218887Sdim#define ABSTRACT_TYPE(CLASS, PARENT) 354218887Sdim#define NON_CANONICAL_TYPE(CLASS, PARENT) 355218887Sdim#define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T); 356218887Sdim#include "clang/AST/TypeNodes.def" 357218887Sdim 358218887Sdim void mangleType(const TagType*); 359218887Sdim void mangleType(TemplateName); 360218887Sdim void mangleBareFunctionType(const FunctionType *T, 361218887Sdim bool MangleReturnType); 362218887Sdim void mangleNeonVectorType(const VectorType *T); 363263508Sdim void mangleAArch64NeonVectorType(const VectorType *T); 364218887Sdim 365218887Sdim void mangleIntegerLiteral(QualType T, const llvm::APSInt &Value); 366221345Sdim void mangleMemberExpr(const Expr *base, bool isArrow, 367221345Sdim NestedNameSpecifier *qualifier, 368221345Sdim NamedDecl *firstQualifierLookup, 369221345Sdim DeclarationName name, 370221345Sdim unsigned knownArity); 371218887Sdim void mangleExpression(const Expr *E, unsigned Arity = UnknownArity); 372218887Sdim void mangleCXXCtorType(CXXCtorType T); 373218887Sdim void mangleCXXDtorType(CXXDtorType T); 374218887Sdim 375226633Sdim void mangleTemplateArgs(const ASTTemplateArgumentListInfo &TemplateArgs); 376243830Sdim void mangleTemplateArgs(const TemplateArgument *TemplateArgs, 377218887Sdim unsigned NumTemplateArgs); 378243830Sdim void mangleTemplateArgs(const TemplateArgumentList &AL); 379243830Sdim void mangleTemplateArg(TemplateArgument A); 380218887Sdim 381218887Sdim void mangleTemplateParameter(unsigned Index); 382221345Sdim 383221345Sdim void mangleFunctionParam(const ParmVarDecl *parm); 384218887Sdim}; 385218887Sdim 386218887Sdim} 387218887Sdim 388263508Sdimbool ItaniumMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) { 389218887Sdim const FunctionDecl *FD = dyn_cast<FunctionDecl>(D); 390249423Sdim if (FD) { 391249423Sdim LanguageLinkage L = FD->getLanguageLinkage(); 392249423Sdim // Overloadable functions need mangling. 393249423Sdim if (FD->hasAttr<OverloadableAttr>()) 394249423Sdim return true; 395218887Sdim 396249423Sdim // "main" is not mangled. 397249423Sdim if (FD->isMain()) 398249423Sdim return false; 399249423Sdim 400249423Sdim // C++ functions and those whose names are not a simple identifier need 401249423Sdim // mangling. 402249423Sdim if (!FD->getDeclName().isIdentifier() || L == CXXLanguageLinkage) 403249423Sdim return true; 404249423Sdim 405249423Sdim // C functions are not mangled. 406249423Sdim if (L == CLanguageLinkage) 407249423Sdim return false; 408249423Sdim } 409249423Sdim 410218887Sdim // Otherwise, no mangling is done outside C++ mode. 411234353Sdim if (!getASTContext().getLangOpts().CPlusPlus) 412218887Sdim return false; 413218887Sdim 414249423Sdim const VarDecl *VD = dyn_cast<VarDecl>(D); 415249423Sdim if (VD) { 416249423Sdim // C variables are not mangled. 417249423Sdim if (VD->isExternC()) 418249423Sdim return false; 419249423Sdim 420249423Sdim // Variables at global scope with non-internal linkage are not mangled 421234353Sdim const DeclContext *DC = getEffectiveDeclContext(D); 422218887Sdim // Check for extern variable declared locally. 423218887Sdim if (DC->isFunctionOrMethod() && D->hasLinkage()) 424218887Sdim while (!DC->isNamespace() && !DC->isTranslationUnit()) 425234353Sdim DC = getEffectiveParentContext(DC); 426263508Sdim if (DC->isTranslationUnit() && D->getFormalLinkage() != InternalLinkage && 427263508Sdim !isa<VarTemplateSpecializationDecl>(D)) 428218887Sdim return false; 429218887Sdim } 430218887Sdim 431218887Sdim return true; 432218887Sdim} 433218887Sdim 434226633Sdimvoid CXXNameMangler::mangle(const NamedDecl *D, StringRef Prefix) { 435218887Sdim // <mangled-name> ::= _Z <encoding> 436218887Sdim // ::= <data name> 437218887Sdim // ::= <special-name> 438218887Sdim Out << Prefix; 439218887Sdim if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 440218887Sdim mangleFunctionEncoding(FD); 441218887Sdim else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 442218887Sdim mangleName(VD); 443263508Sdim else if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(D)) 444263508Sdim mangleName(IFD->getAnonField()); 445218887Sdim else 446218887Sdim mangleName(cast<FieldDecl>(D)); 447218887Sdim} 448218887Sdim 449218887Sdimvoid CXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD) { 450218887Sdim // <encoding> ::= <function name> <bare-function-type> 451218887Sdim mangleName(FD); 452218887Sdim 453218887Sdim // Don't mangle in the type if this isn't a decl we should typically mangle. 454218887Sdim if (!Context.shouldMangleDeclName(FD)) 455218887Sdim return; 456218887Sdim 457218887Sdim // Whether the mangling of a function type includes the return type depends on 458218887Sdim // the context and the nature of the function. The rules for deciding whether 459218887Sdim // the return type is included are: 460218887Sdim // 461218887Sdim // 1. Template functions (names or types) have return types encoded, with 462218887Sdim // the exceptions listed below. 463218887Sdim // 2. Function types not appearing as part of a function name mangling, 464218887Sdim // e.g. parameters, pointer types, etc., have return type encoded, with the 465218887Sdim // exceptions listed below. 466218887Sdim // 3. Non-template function names do not have return types encoded. 467218887Sdim // 468218887Sdim // The exceptions mentioned in (1) and (2) above, for which the return type is 469218887Sdim // never included, are 470218887Sdim // 1. Constructors. 471218887Sdim // 2. Destructors. 472218887Sdim // 3. Conversion operator functions, e.g. operator int. 473218887Sdim bool MangleReturnType = false; 474218887Sdim if (FunctionTemplateDecl *PrimaryTemplate = FD->getPrimaryTemplate()) { 475218887Sdim if (!(isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD) || 476218887Sdim isa<CXXConversionDecl>(FD))) 477218887Sdim MangleReturnType = true; 478218887Sdim 479218887Sdim // Mangle the type of the primary template. 480218887Sdim FD = PrimaryTemplate->getTemplatedDecl(); 481218887Sdim } 482218887Sdim 483224145Sdim mangleBareFunctionType(FD->getType()->getAs<FunctionType>(), 484224145Sdim MangleReturnType); 485218887Sdim} 486218887Sdim 487218887Sdimstatic const DeclContext *IgnoreLinkageSpecDecls(const DeclContext *DC) { 488218887Sdim while (isa<LinkageSpecDecl>(DC)) { 489234353Sdim DC = getEffectiveParentContext(DC); 490218887Sdim } 491218887Sdim 492218887Sdim return DC; 493218887Sdim} 494218887Sdim 495218887Sdim/// isStd - Return whether a given namespace is the 'std' namespace. 496218887Sdimstatic bool isStd(const NamespaceDecl *NS) { 497234353Sdim if (!IgnoreLinkageSpecDecls(getEffectiveParentContext(NS)) 498234353Sdim ->isTranslationUnit()) 499218887Sdim return false; 500218887Sdim 501218887Sdim const IdentifierInfo *II = NS->getOriginalNamespace()->getIdentifier(); 502218887Sdim return II && II->isStr("std"); 503218887Sdim} 504218887Sdim 505218887Sdim// isStdNamespace - Return whether a given decl context is a toplevel 'std' 506218887Sdim// namespace. 507218887Sdimstatic bool isStdNamespace(const DeclContext *DC) { 508218887Sdim if (!DC->isNamespace()) 509218887Sdim return false; 510218887Sdim 511218887Sdim return isStd(cast<NamespaceDecl>(DC)); 512218887Sdim} 513218887Sdim 514218887Sdimstatic const TemplateDecl * 515218887SdimisTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs) { 516218887Sdim // Check if we have a function template. 517218887Sdim if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)){ 518218887Sdim if (const TemplateDecl *TD = FD->getPrimaryTemplate()) { 519218887Sdim TemplateArgs = FD->getTemplateSpecializationArgs(); 520218887Sdim return TD; 521218887Sdim } 522218887Sdim } 523218887Sdim 524218887Sdim // Check if we have a class template. 525218887Sdim if (const ClassTemplateSpecializationDecl *Spec = 526218887Sdim dyn_cast<ClassTemplateSpecializationDecl>(ND)) { 527218887Sdim TemplateArgs = &Spec->getTemplateArgs(); 528218887Sdim return Spec->getSpecializedTemplate(); 529218887Sdim } 530218887Sdim 531263508Sdim // Check if we have a variable template. 532263508Sdim if (const VarTemplateSpecializationDecl *Spec = 533263508Sdim dyn_cast<VarTemplateSpecializationDecl>(ND)) { 534263508Sdim TemplateArgs = &Spec->getTemplateArgs(); 535263508Sdim return Spec->getSpecializedTemplate(); 536263508Sdim } 537263508Sdim 538218887Sdim return 0; 539218887Sdim} 540218887Sdim 541234353Sdimstatic bool isLambda(const NamedDecl *ND) { 542234353Sdim const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(ND); 543234353Sdim if (!Record) 544234353Sdim return false; 545234353Sdim 546234353Sdim return Record->isLambda(); 547234353Sdim} 548234353Sdim 549218887Sdimvoid CXXNameMangler::mangleName(const NamedDecl *ND) { 550218887Sdim // <name> ::= <nested-name> 551218887Sdim // ::= <unscoped-name> 552218887Sdim // ::= <unscoped-template-name> <template-args> 553218887Sdim // ::= <local-name> 554218887Sdim // 555234353Sdim const DeclContext *DC = getEffectiveDeclContext(ND); 556218887Sdim 557218887Sdim // If this is an extern variable declared locally, the relevant DeclContext 558218887Sdim // is that of the containing namespace, or the translation unit. 559234353Sdim // FIXME: This is a hack; extern variables declared locally should have 560234353Sdim // a proper semantic declaration context! 561263508Sdim if (isLocalContainerContext(DC) && ND->hasLinkage() && !isLambda(ND)) 562218887Sdim while (!DC->isNamespace() && !DC->isTranslationUnit()) 563234353Sdim DC = getEffectiveParentContext(DC); 564218887Sdim else if (GetLocalClassDecl(ND)) { 565218887Sdim mangleLocalName(ND); 566218887Sdim return; 567218887Sdim } 568218887Sdim 569234353Sdim DC = IgnoreLinkageSpecDecls(DC); 570218887Sdim 571218887Sdim if (DC->isTranslationUnit() || isStdNamespace(DC)) { 572218887Sdim // Check if we have a template. 573218887Sdim const TemplateArgumentList *TemplateArgs = 0; 574218887Sdim if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { 575218887Sdim mangleUnscopedTemplateName(TD); 576243830Sdim mangleTemplateArgs(*TemplateArgs); 577218887Sdim return; 578218887Sdim } 579218887Sdim 580218887Sdim mangleUnscopedName(ND); 581218887Sdim return; 582218887Sdim } 583218887Sdim 584263508Sdim if (isLocalContainerContext(DC)) { 585218887Sdim mangleLocalName(ND); 586218887Sdim return; 587218887Sdim } 588218887Sdim 589218887Sdim mangleNestedName(ND, DC); 590218887Sdim} 591218887Sdimvoid CXXNameMangler::mangleName(const TemplateDecl *TD, 592218887Sdim const TemplateArgument *TemplateArgs, 593218887Sdim unsigned NumTemplateArgs) { 594234353Sdim const DeclContext *DC = IgnoreLinkageSpecDecls(getEffectiveDeclContext(TD)); 595218887Sdim 596218887Sdim if (DC->isTranslationUnit() || isStdNamespace(DC)) { 597218887Sdim mangleUnscopedTemplateName(TD); 598243830Sdim mangleTemplateArgs(TemplateArgs, NumTemplateArgs); 599218887Sdim } else { 600218887Sdim mangleNestedName(TD, TemplateArgs, NumTemplateArgs); 601218887Sdim } 602218887Sdim} 603218887Sdim 604218887Sdimvoid CXXNameMangler::mangleUnscopedName(const NamedDecl *ND) { 605218887Sdim // <unscoped-name> ::= <unqualified-name> 606218887Sdim // ::= St <unqualified-name> # ::std:: 607234353Sdim 608234353Sdim if (isStdNamespace(IgnoreLinkageSpecDecls(getEffectiveDeclContext(ND)))) 609218887Sdim Out << "St"; 610218887Sdim 611218887Sdim mangleUnqualifiedName(ND); 612218887Sdim} 613218887Sdim 614218887Sdimvoid CXXNameMangler::mangleUnscopedTemplateName(const TemplateDecl *ND) { 615218887Sdim // <unscoped-template-name> ::= <unscoped-name> 616218887Sdim // ::= <substitution> 617218887Sdim if (mangleSubstitution(ND)) 618218887Sdim return; 619218887Sdim 620218887Sdim // <template-template-param> ::= <template-param> 621218887Sdim if (const TemplateTemplateParmDecl *TTP 622218887Sdim = dyn_cast<TemplateTemplateParmDecl>(ND)) { 623218887Sdim mangleTemplateParameter(TTP->getIndex()); 624218887Sdim return; 625218887Sdim } 626218887Sdim 627218887Sdim mangleUnscopedName(ND->getTemplatedDecl()); 628218887Sdim addSubstitution(ND); 629218887Sdim} 630218887Sdim 631218887Sdimvoid CXXNameMangler::mangleUnscopedTemplateName(TemplateName Template) { 632218887Sdim // <unscoped-template-name> ::= <unscoped-name> 633218887Sdim // ::= <substitution> 634218887Sdim if (TemplateDecl *TD = Template.getAsTemplateDecl()) 635218887Sdim return mangleUnscopedTemplateName(TD); 636218887Sdim 637218887Sdim if (mangleSubstitution(Template)) 638218887Sdim return; 639218887Sdim 640218887Sdim DependentTemplateName *Dependent = Template.getAsDependentTemplateName(); 641218887Sdim assert(Dependent && "Not a dependent template name?"); 642224145Sdim if (const IdentifierInfo *Id = Dependent->getIdentifier()) 643224145Sdim mangleSourceName(Id); 644224145Sdim else 645224145Sdim mangleOperatorName(Dependent->getOperator(), UnknownArity); 646218887Sdim 647218887Sdim addSubstitution(Template); 648218887Sdim} 649218887Sdim 650221345Sdimvoid CXXNameMangler::mangleFloat(const llvm::APFloat &f) { 651221345Sdim // ABI: 652221345Sdim // Floating-point literals are encoded using a fixed-length 653221345Sdim // lowercase hexadecimal string corresponding to the internal 654221345Sdim // representation (IEEE on Itanium), high-order bytes first, 655221345Sdim // without leading zeroes. For example: "Lf bf800000 E" is -1.0f 656221345Sdim // on Itanium. 657234353Sdim // The 'without leading zeroes' thing seems to be an editorial 658234353Sdim // mistake; see the discussion on cxx-abi-dev beginning on 659234353Sdim // 2012-01-16. 660221345Sdim 661239462Sdim // Our requirements here are just barely weird enough to justify 662234353Sdim // using a custom algorithm instead of post-processing APInt::toString(). 663221345Sdim 664234353Sdim llvm::APInt valueBits = f.bitcastToAPInt(); 665234353Sdim unsigned numCharacters = (valueBits.getBitWidth() + 3) / 4; 666234353Sdim assert(numCharacters != 0); 667234353Sdim 668234353Sdim // Allocate a buffer of the right number of characters. 669249423Sdim SmallVector<char, 20> buffer; 670234353Sdim buffer.set_size(numCharacters); 671234353Sdim 672234353Sdim // Fill the buffer left-to-right. 673234353Sdim for (unsigned stringIndex = 0; stringIndex != numCharacters; ++stringIndex) { 674234353Sdim // The bit-index of the next hex digit. 675234353Sdim unsigned digitBitIndex = 4 * (numCharacters - stringIndex - 1); 676234353Sdim 677234353Sdim // Project out 4 bits starting at 'digitIndex'. 678234353Sdim llvm::integerPart hexDigit 679234353Sdim = valueBits.getRawData()[digitBitIndex / llvm::integerPartWidth]; 680234353Sdim hexDigit >>= (digitBitIndex % llvm::integerPartWidth); 681234353Sdim hexDigit &= 0xF; 682234353Sdim 683234353Sdim // Map that over to a lowercase hex digit. 684234353Sdim static const char charForHex[16] = { 685234353Sdim '0', '1', '2', '3', '4', '5', '6', '7', 686234353Sdim '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' 687234353Sdim }; 688234353Sdim buffer[stringIndex] = charForHex[hexDigit]; 689234353Sdim } 690234353Sdim 691234353Sdim Out.write(buffer.data(), numCharacters); 692218887Sdim} 693218887Sdim 694218887Sdimvoid CXXNameMangler::mangleNumber(const llvm::APSInt &Value) { 695218887Sdim if (Value.isSigned() && Value.isNegative()) { 696218887Sdim Out << 'n'; 697243830Sdim Value.abs().print(Out, /*signed*/ false); 698243830Sdim } else { 699243830Sdim Value.print(Out, /*signed*/ false); 700243830Sdim } 701218887Sdim} 702218887Sdim 703218887Sdimvoid CXXNameMangler::mangleNumber(int64_t Number) { 704218887Sdim // <number> ::= [n] <non-negative decimal integer> 705218887Sdim if (Number < 0) { 706218887Sdim Out << 'n'; 707218887Sdim Number = -Number; 708218887Sdim } 709218887Sdim 710218887Sdim Out << Number; 711218887Sdim} 712218887Sdim 713218887Sdimvoid CXXNameMangler::mangleCallOffset(int64_t NonVirtual, int64_t Virtual) { 714218887Sdim // <call-offset> ::= h <nv-offset> _ 715218887Sdim // ::= v <v-offset> _ 716218887Sdim // <nv-offset> ::= <offset number> # non-virtual base override 717218887Sdim // <v-offset> ::= <offset number> _ <virtual offset number> 718218887Sdim // # virtual base override, with vcall offset 719218887Sdim if (!Virtual) { 720218887Sdim Out << 'h'; 721218887Sdim mangleNumber(NonVirtual); 722218887Sdim Out << '_'; 723218887Sdim return; 724218887Sdim } 725218887Sdim 726218887Sdim Out << 'v'; 727218887Sdim mangleNumber(NonVirtual); 728218887Sdim Out << '_'; 729218887Sdim mangleNumber(Virtual); 730218887Sdim Out << '_'; 731218887Sdim} 732218887Sdim 733223017Sdimvoid CXXNameMangler::manglePrefix(QualType type) { 734221345Sdim if (const TemplateSpecializationType *TST = 735221345Sdim type->getAs<TemplateSpecializationType>()) { 736221345Sdim if (!mangleSubstitution(QualType(TST, 0))) { 737221345Sdim mangleTemplatePrefix(TST->getTemplateName()); 738221345Sdim 739221345Sdim // FIXME: GCC does not appear to mangle the template arguments when 740221345Sdim // the template in question is a dependent template name. Should we 741221345Sdim // emulate that badness? 742243830Sdim mangleTemplateArgs(TST->getArgs(), TST->getNumArgs()); 743221345Sdim addSubstitution(QualType(TST, 0)); 744221345Sdim } 745221345Sdim } else if (const DependentTemplateSpecializationType *DTST 746221345Sdim = type->getAs<DependentTemplateSpecializationType>()) { 747221345Sdim TemplateName Template 748221345Sdim = getASTContext().getDependentTemplateName(DTST->getQualifier(), 749221345Sdim DTST->getIdentifier()); 750221345Sdim mangleTemplatePrefix(Template); 751221345Sdim 752221345Sdim // FIXME: GCC does not appear to mangle the template arguments when 753221345Sdim // the template in question is a dependent template name. Should we 754221345Sdim // emulate that badness? 755243830Sdim mangleTemplateArgs(DTST->getArgs(), DTST->getNumArgs()); 756221345Sdim } else { 757221345Sdim // We use the QualType mangle type variant here because it handles 758221345Sdim // substitutions. 759221345Sdim mangleType(type); 760221345Sdim } 761221345Sdim} 762221345Sdim 763221345Sdim/// Mangle everything prior to the base-unresolved-name in an unresolved-name. 764221345Sdim/// 765221345Sdim/// \param firstQualifierLookup - the entity found by unqualified lookup 766221345Sdim/// for the first name in the qualifier, if this is for a member expression 767221345Sdim/// \param recursive - true if this is being called recursively, 768221345Sdim/// i.e. if there is more prefix "to the right". 769221345Sdimvoid CXXNameMangler::mangleUnresolvedPrefix(NestedNameSpecifier *qualifier, 770221345Sdim NamedDecl *firstQualifierLookup, 771221345Sdim bool recursive) { 772221345Sdim 773221345Sdim // x, ::x 774221345Sdim // <unresolved-name> ::= [gs] <base-unresolved-name> 775221345Sdim 776221345Sdim // T::x / decltype(p)::x 777221345Sdim // <unresolved-name> ::= sr <unresolved-type> <base-unresolved-name> 778221345Sdim 779221345Sdim // T::N::x /decltype(p)::N::x 780221345Sdim // <unresolved-name> ::= srN <unresolved-type> <unresolved-qualifier-level>+ E 781221345Sdim // <base-unresolved-name> 782221345Sdim 783221345Sdim // A::x, N::y, A<T>::z; "gs" means leading "::" 784221345Sdim // <unresolved-name> ::= [gs] sr <unresolved-qualifier-level>+ E 785221345Sdim // <base-unresolved-name> 786221345Sdim 787221345Sdim switch (qualifier->getKind()) { 788218887Sdim case NestedNameSpecifier::Global: 789221345Sdim Out << "gs"; 790221345Sdim 791221345Sdim // We want an 'sr' unless this is the entire NNS. 792221345Sdim if (recursive) 793221345Sdim Out << "sr"; 794221345Sdim 795221345Sdim // We never want an 'E' here. 796221345Sdim return; 797221345Sdim 798218887Sdim case NestedNameSpecifier::Namespace: 799221345Sdim if (qualifier->getPrefix()) 800221345Sdim mangleUnresolvedPrefix(qualifier->getPrefix(), firstQualifierLookup, 801221345Sdim /*recursive*/ true); 802221345Sdim else 803221345Sdim Out << "sr"; 804221345Sdim mangleSourceName(qualifier->getAsNamespace()->getIdentifier()); 805218887Sdim break; 806219077Sdim case NestedNameSpecifier::NamespaceAlias: 807221345Sdim if (qualifier->getPrefix()) 808221345Sdim mangleUnresolvedPrefix(qualifier->getPrefix(), firstQualifierLookup, 809221345Sdim /*recursive*/ true); 810221345Sdim else 811221345Sdim Out << "sr"; 812221345Sdim mangleSourceName(qualifier->getAsNamespaceAlias()->getIdentifier()); 813219077Sdim break; 814221345Sdim 815218887Sdim case NestedNameSpecifier::TypeSpec: 816218887Sdim case NestedNameSpecifier::TypeSpecWithTemplate: { 817223017Sdim const Type *type = qualifier->getAsType(); 818218887Sdim 819223017Sdim // We only want to use an unresolved-type encoding if this is one of: 820223017Sdim // - a decltype 821223017Sdim // - a template type parameter 822223017Sdim // - a template template parameter with arguments 823223017Sdim // In all of these cases, we should have no prefix. 824223017Sdim if (qualifier->getPrefix()) { 825223017Sdim mangleUnresolvedPrefix(qualifier->getPrefix(), firstQualifierLookup, 826223017Sdim /*recursive*/ true); 827223017Sdim } else { 828223017Sdim // Otherwise, all the cases want this. 829223017Sdim Out << "sr"; 830224145Sdim } 831221345Sdim 832224145Sdim // Only certain other types are valid as prefixes; enumerate them. 833224145Sdim switch (type->getTypeClass()) { 834224145Sdim case Type::Builtin: 835224145Sdim case Type::Complex: 836263508Sdim case Type::Decayed: 837224145Sdim case Type::Pointer: 838224145Sdim case Type::BlockPointer: 839224145Sdim case Type::LValueReference: 840224145Sdim case Type::RValueReference: 841224145Sdim case Type::MemberPointer: 842224145Sdim case Type::ConstantArray: 843224145Sdim case Type::IncompleteArray: 844224145Sdim case Type::VariableArray: 845224145Sdim case Type::DependentSizedArray: 846224145Sdim case Type::DependentSizedExtVector: 847224145Sdim case Type::Vector: 848224145Sdim case Type::ExtVector: 849224145Sdim case Type::FunctionProto: 850224145Sdim case Type::FunctionNoProto: 851224145Sdim case Type::Enum: 852224145Sdim case Type::Paren: 853224145Sdim case Type::Elaborated: 854224145Sdim case Type::Attributed: 855224145Sdim case Type::Auto: 856224145Sdim case Type::PackExpansion: 857224145Sdim case Type::ObjCObject: 858224145Sdim case Type::ObjCInterface: 859224145Sdim case Type::ObjCObjectPointer: 860226633Sdim case Type::Atomic: 861224145Sdim llvm_unreachable("type is illegal as a nested name specifier"); 862221345Sdim 863224145Sdim case Type::SubstTemplateTypeParmPack: 864224145Sdim // FIXME: not clear how to mangle this! 865224145Sdim // template <class T...> class A { 866224145Sdim // template <class U...> void foo(decltype(T::foo(U())) x...); 867224145Sdim // }; 868224145Sdim Out << "_SUBSTPACK_"; 869224145Sdim break; 870224145Sdim 871224145Sdim // <unresolved-type> ::= <template-param> 872224145Sdim // ::= <decltype> 873224145Sdim // ::= <template-template-param> <template-args> 874224145Sdim // (this last is not official yet) 875224145Sdim case Type::TypeOfExpr: 876224145Sdim case Type::TypeOf: 877224145Sdim case Type::Decltype: 878224145Sdim case Type::TemplateTypeParm: 879224145Sdim case Type::UnaryTransform: 880224145Sdim case Type::SubstTemplateTypeParm: 881224145Sdim unresolvedType: 882224145Sdim assert(!qualifier->getPrefix()); 883224145Sdim 884224145Sdim // We only get here recursively if we're followed by identifiers. 885224145Sdim if (recursive) Out << 'N'; 886224145Sdim 887224145Sdim // This seems to do everything we want. It's not really 888224145Sdim // sanctioned for a substituted template parameter, though. 889224145Sdim mangleType(QualType(type, 0)); 890224145Sdim 891224145Sdim // We never want to print 'E' directly after an unresolved-type, 892224145Sdim // so we return directly. 893224145Sdim return; 894224145Sdim 895224145Sdim case Type::Typedef: 896224145Sdim mangleSourceName(cast<TypedefType>(type)->getDecl()->getIdentifier()); 897224145Sdim break; 898224145Sdim 899224145Sdim case Type::UnresolvedUsing: 900224145Sdim mangleSourceName(cast<UnresolvedUsingType>(type)->getDecl() 901224145Sdim ->getIdentifier()); 902224145Sdim break; 903224145Sdim 904224145Sdim case Type::Record: 905224145Sdim mangleSourceName(cast<RecordType>(type)->getDecl()->getIdentifier()); 906224145Sdim break; 907224145Sdim 908224145Sdim case Type::TemplateSpecialization: { 909224145Sdim const TemplateSpecializationType *tst 910224145Sdim = cast<TemplateSpecializationType>(type); 911224145Sdim TemplateName name = tst->getTemplateName(); 912224145Sdim switch (name.getKind()) { 913224145Sdim case TemplateName::Template: 914224145Sdim case TemplateName::QualifiedTemplate: { 915224145Sdim TemplateDecl *temp = name.getAsTemplateDecl(); 916224145Sdim 917224145Sdim // If the base is a template template parameter, this is an 918224145Sdim // unresolved type. 919224145Sdim assert(temp && "no template for template specialization type"); 920224145Sdim if (isa<TemplateTemplateParmDecl>(temp)) goto unresolvedType; 921224145Sdim 922224145Sdim mangleSourceName(temp->getIdentifier()); 923224145Sdim break; 924223017Sdim } 925224145Sdim 926224145Sdim case TemplateName::OverloadedTemplate: 927224145Sdim case TemplateName::DependentTemplate: 928224145Sdim llvm_unreachable("invalid base for a template specialization type"); 929224145Sdim 930224145Sdim case TemplateName::SubstTemplateTemplateParm: { 931224145Sdim SubstTemplateTemplateParmStorage *subst 932224145Sdim = name.getAsSubstTemplateTemplateParm(); 933224145Sdim mangleExistingSubstitution(subst->getReplacement()); 934224145Sdim break; 935224145Sdim } 936224145Sdim 937224145Sdim case TemplateName::SubstTemplateTemplateParmPack: { 938224145Sdim // FIXME: not clear how to mangle this! 939224145Sdim // template <template <class U> class T...> class A { 940224145Sdim // template <class U...> void foo(decltype(T<U>::foo) x...); 941224145Sdim // }; 942224145Sdim Out << "_SUBSTPACK_"; 943224145Sdim break; 944224145Sdim } 945224145Sdim } 946224145Sdim 947243830Sdim mangleTemplateArgs(tst->getArgs(), tst->getNumArgs()); 948224145Sdim break; 949223017Sdim } 950223017Sdim 951224145Sdim case Type::InjectedClassName: 952224145Sdim mangleSourceName(cast<InjectedClassNameType>(type)->getDecl() 953224145Sdim ->getIdentifier()); 954224145Sdim break; 955223017Sdim 956224145Sdim case Type::DependentName: 957224145Sdim mangleSourceName(cast<DependentNameType>(type)->getIdentifier()); 958224145Sdim break; 959224145Sdim 960224145Sdim case Type::DependentTemplateSpecialization: { 961224145Sdim const DependentTemplateSpecializationType *tst 962224145Sdim = cast<DependentTemplateSpecializationType>(type); 963223017Sdim mangleSourceName(tst->getIdentifier()); 964243830Sdim mangleTemplateArgs(tst->getArgs(), tst->getNumArgs()); 965224145Sdim break; 966223017Sdim } 967224145Sdim } 968223017Sdim break; 969221345Sdim } 970221345Sdim 971221345Sdim case NestedNameSpecifier::Identifier: 972221345Sdim // Member expressions can have these without prefixes. 973221345Sdim if (qualifier->getPrefix()) { 974221345Sdim mangleUnresolvedPrefix(qualifier->getPrefix(), firstQualifierLookup, 975221345Sdim /*recursive*/ true); 976221345Sdim } else if (firstQualifierLookup) { 977221345Sdim 978221345Sdim // Try to make a proper qualifier out of the lookup result, and 979221345Sdim // then just recurse on that. 980221345Sdim NestedNameSpecifier *newQualifier; 981221345Sdim if (TypeDecl *typeDecl = dyn_cast<TypeDecl>(firstQualifierLookup)) { 982221345Sdim QualType type = getASTContext().getTypeDeclType(typeDecl); 983221345Sdim 984221345Sdim // Pretend we had a different nested name specifier. 985221345Sdim newQualifier = NestedNameSpecifier::Create(getASTContext(), 986221345Sdim /*prefix*/ 0, 987221345Sdim /*template*/ false, 988221345Sdim type.getTypePtr()); 989221345Sdim } else if (NamespaceDecl *nspace = 990221345Sdim dyn_cast<NamespaceDecl>(firstQualifierLookup)) { 991221345Sdim newQualifier = NestedNameSpecifier::Create(getASTContext(), 992221345Sdim /*prefix*/ 0, 993221345Sdim nspace); 994221345Sdim } else if (NamespaceAliasDecl *alias = 995221345Sdim dyn_cast<NamespaceAliasDecl>(firstQualifierLookup)) { 996221345Sdim newQualifier = NestedNameSpecifier::Create(getASTContext(), 997221345Sdim /*prefix*/ 0, 998221345Sdim alias); 999221345Sdim } else { 1000221345Sdim // No sensible mangling to do here. 1001221345Sdim newQualifier = 0; 1002218887Sdim } 1003221345Sdim 1004221345Sdim if (newQualifier) 1005221345Sdim return mangleUnresolvedPrefix(newQualifier, /*lookup*/ 0, recursive); 1006221345Sdim 1007218887Sdim } else { 1008221345Sdim Out << "sr"; 1009218887Sdim } 1010221345Sdim 1011221345Sdim mangleSourceName(qualifier->getAsIdentifier()); 1012218887Sdim break; 1013218887Sdim } 1014221345Sdim 1015221345Sdim // If this was the innermost part of the NNS, and we fell out to 1016221345Sdim // here, append an 'E'. 1017221345Sdim if (!recursive) 1018221345Sdim Out << 'E'; 1019218887Sdim} 1020218887Sdim 1021221345Sdim/// Mangle an unresolved-name, which is generally used for names which 1022221345Sdim/// weren't resolved to specific entities. 1023221345Sdimvoid CXXNameMangler::mangleUnresolvedName(NestedNameSpecifier *qualifier, 1024221345Sdim NamedDecl *firstQualifierLookup, 1025221345Sdim DeclarationName name, 1026221345Sdim unsigned knownArity) { 1027221345Sdim if (qualifier) mangleUnresolvedPrefix(qualifier, firstQualifierLookup); 1028221345Sdim mangleUnqualifiedName(0, name, knownArity); 1029218887Sdim} 1030218887Sdim 1031218887Sdimstatic const FieldDecl *FindFirstNamedDataMember(const RecordDecl *RD) { 1032218887Sdim assert(RD->isAnonymousStructOrUnion() && 1033218887Sdim "Expected anonymous struct or union!"); 1034218887Sdim 1035218887Sdim for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end(); 1036218887Sdim I != E; ++I) { 1037239462Sdim if (I->getIdentifier()) 1038239462Sdim return *I; 1039218887Sdim 1040239462Sdim if (const RecordType *RT = I->getType()->getAs<RecordType>()) 1041218887Sdim if (const FieldDecl *NamedDataMember = 1042218887Sdim FindFirstNamedDataMember(RT->getDecl())) 1043218887Sdim return NamedDataMember; 1044218887Sdim } 1045218887Sdim 1046218887Sdim // We didn't find a named data member. 1047218887Sdim return 0; 1048218887Sdim} 1049218887Sdim 1050218887Sdimvoid CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, 1051218887Sdim DeclarationName Name, 1052218887Sdim unsigned KnownArity) { 1053218887Sdim // <unqualified-name> ::= <operator-name> 1054218887Sdim // ::= <ctor-dtor-name> 1055218887Sdim // ::= <source-name> 1056218887Sdim switch (Name.getNameKind()) { 1057218887Sdim case DeclarationName::Identifier: { 1058218887Sdim if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) { 1059218887Sdim // We must avoid conflicts between internally- and externally- 1060221345Sdim // linked variable and function declaration names in the same TU: 1061221345Sdim // void test() { extern void foo(); } 1062221345Sdim // static void foo(); 1063221345Sdim // This naming convention is the same as that followed by GCC, 1064221345Sdim // though it shouldn't actually matter. 1065263508Sdim if (ND && ND->getFormalLinkage() == InternalLinkage && 1066234353Sdim getEffectiveDeclContext(ND)->isFileContext()) 1067218887Sdim Out << 'L'; 1068218887Sdim 1069218887Sdim mangleSourceName(II); 1070218887Sdim break; 1071218887Sdim } 1072218887Sdim 1073218887Sdim // Otherwise, an anonymous entity. We must have a declaration. 1074218887Sdim assert(ND && "mangling empty name without declaration"); 1075218887Sdim 1076218887Sdim if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) { 1077218887Sdim if (NS->isAnonymousNamespace()) { 1078218887Sdim // This is how gcc mangles these names. 1079218887Sdim Out << "12_GLOBAL__N_1"; 1080218887Sdim break; 1081218887Sdim } 1082218887Sdim } 1083218887Sdim 1084218887Sdim if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) { 1085218887Sdim // We must have an anonymous union or struct declaration. 1086218887Sdim const RecordDecl *RD = 1087218887Sdim cast<RecordDecl>(VD->getType()->getAs<RecordType>()->getDecl()); 1088218887Sdim 1089218887Sdim // Itanium C++ ABI 5.1.2: 1090218887Sdim // 1091218887Sdim // For the purposes of mangling, the name of an anonymous union is 1092218887Sdim // considered to be the name of the first named data member found by a 1093218887Sdim // pre-order, depth-first, declaration-order walk of the data members of 1094218887Sdim // the anonymous union. If there is no such data member (i.e., if all of 1095218887Sdim // the data members in the union are unnamed), then there is no way for 1096218887Sdim // a program to refer to the anonymous union, and there is therefore no 1097218887Sdim // need to mangle its name. 1098218887Sdim const FieldDecl *FD = FindFirstNamedDataMember(RD); 1099218887Sdim 1100218887Sdim // It's actually possible for various reasons for us to get here 1101218887Sdim // with an empty anonymous struct / union. Fortunately, it 1102218887Sdim // doesn't really matter what name we generate. 1103218887Sdim if (!FD) break; 1104218887Sdim assert(FD->getIdentifier() && "Data member name isn't an identifier!"); 1105218887Sdim 1106218887Sdim mangleSourceName(FD->getIdentifier()); 1107218887Sdim break; 1108218887Sdim } 1109251662Sdim 1110251662Sdim // Class extensions have no name as a category, and it's possible 1111251662Sdim // for them to be the semantic parent of certain declarations 1112251662Sdim // (primarily, tag decls defined within declarations). Such 1113251662Sdim // declarations will always have internal linkage, so the name 1114251662Sdim // doesn't really matter, but we shouldn't crash on them. For 1115251662Sdim // safety, just handle all ObjC containers here. 1116251662Sdim if (isa<ObjCContainerDecl>(ND)) 1117251662Sdim break; 1118218887Sdim 1119218887Sdim // We must have an anonymous struct. 1120218887Sdim const TagDecl *TD = cast<TagDecl>(ND); 1121221345Sdim if (const TypedefNameDecl *D = TD->getTypedefNameForAnonDecl()) { 1122218887Sdim assert(TD->getDeclContext() == D->getDeclContext() && 1123218887Sdim "Typedef should not be in another decl context!"); 1124218887Sdim assert(D->getDeclName().getAsIdentifierInfo() && 1125218887Sdim "Typedef was not named!"); 1126218887Sdim mangleSourceName(D->getDeclName().getAsIdentifierInfo()); 1127218887Sdim break; 1128218887Sdim } 1129218887Sdim 1130234353Sdim // <unnamed-type-name> ::= <closure-type-name> 1131234353Sdim // 1132234353Sdim // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ 1133234353Sdim // <lambda-sig> ::= <parameter-type>+ # Parameter types or 'v' for 'void'. 1134234353Sdim if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) { 1135234353Sdim if (Record->isLambda() && Record->getLambdaManglingNumber()) { 1136234353Sdim mangleLambda(Record); 1137234353Sdim break; 1138234353Sdim } 1139234353Sdim } 1140249423Sdim 1141263508Sdim if (TD->isExternallyVisible()) { 1142263508Sdim unsigned UnnamedMangle = getASTContext().getManglingNumber(TD); 1143249423Sdim Out << "Ut"; 1144263508Sdim if (UnnamedMangle > 1) 1145263508Sdim Out << llvm::utostr(UnnamedMangle - 2); 1146249423Sdim Out << '_'; 1147249423Sdim break; 1148249423Sdim } 1149249423Sdim 1150218887Sdim // Get a unique id for the anonymous struct. 1151218887Sdim uint64_t AnonStructId = Context.getAnonymousStructId(TD); 1152218887Sdim 1153218887Sdim // Mangle it as a source name in the form 1154218887Sdim // [n] $_<id> 1155218887Sdim // where n is the length of the string. 1156234353Sdim SmallString<8> Str; 1157218887Sdim Str += "$_"; 1158218887Sdim Str += llvm::utostr(AnonStructId); 1159218887Sdim 1160218887Sdim Out << Str.size(); 1161218887Sdim Out << Str.str(); 1162218887Sdim break; 1163218887Sdim } 1164218887Sdim 1165218887Sdim case DeclarationName::ObjCZeroArgSelector: 1166218887Sdim case DeclarationName::ObjCOneArgSelector: 1167218887Sdim case DeclarationName::ObjCMultiArgSelector: 1168226633Sdim llvm_unreachable("Can't mangle Objective-C selector names here!"); 1169218887Sdim 1170218887Sdim case DeclarationName::CXXConstructorName: 1171218887Sdim if (ND == Structor) 1172218887Sdim // If the named decl is the C++ constructor we're mangling, use the type 1173218887Sdim // we were given. 1174218887Sdim mangleCXXCtorType(static_cast<CXXCtorType>(StructorType)); 1175218887Sdim else 1176218887Sdim // Otherwise, use the complete constructor name. This is relevant if a 1177218887Sdim // class with a constructor is declared within a constructor. 1178218887Sdim mangleCXXCtorType(Ctor_Complete); 1179218887Sdim break; 1180218887Sdim 1181218887Sdim case DeclarationName::CXXDestructorName: 1182218887Sdim if (ND == Structor) 1183218887Sdim // If the named decl is the C++ destructor we're mangling, use the type we 1184218887Sdim // were given. 1185218887Sdim mangleCXXDtorType(static_cast<CXXDtorType>(StructorType)); 1186218887Sdim else 1187218887Sdim // Otherwise, use the complete destructor name. This is relevant if a 1188218887Sdim // class with a destructor is declared within a destructor. 1189218887Sdim mangleCXXDtorType(Dtor_Complete); 1190218887Sdim break; 1191218887Sdim 1192218887Sdim case DeclarationName::CXXConversionFunctionName: 1193218887Sdim // <operator-name> ::= cv <type> # (cast) 1194218887Sdim Out << "cv"; 1195224145Sdim mangleType(Name.getCXXNameType()); 1196218887Sdim break; 1197218887Sdim 1198218887Sdim case DeclarationName::CXXOperatorName: { 1199218887Sdim unsigned Arity; 1200218887Sdim if (ND) { 1201218887Sdim Arity = cast<FunctionDecl>(ND)->getNumParams(); 1202218887Sdim 1203218887Sdim // If we have a C++ member function, we need to include the 'this' pointer. 1204218887Sdim // FIXME: This does not make sense for operators that are static, but their 1205218887Sdim // names stay the same regardless of the arity (operator new for instance). 1206218887Sdim if (isa<CXXMethodDecl>(ND)) 1207218887Sdim Arity++; 1208218887Sdim } else 1209218887Sdim Arity = KnownArity; 1210218887Sdim 1211218887Sdim mangleOperatorName(Name.getCXXOverloadedOperator(), Arity); 1212218887Sdim break; 1213218887Sdim } 1214218887Sdim 1215218887Sdim case DeclarationName::CXXLiteralOperatorName: 1216218887Sdim // FIXME: This mangling is not yet official. 1217218887Sdim Out << "li"; 1218218887Sdim mangleSourceName(Name.getCXXLiteralIdentifier()); 1219218887Sdim break; 1220218887Sdim 1221218887Sdim case DeclarationName::CXXUsingDirective: 1222226633Sdim llvm_unreachable("Can't mangle a using directive name!"); 1223218887Sdim } 1224218887Sdim} 1225218887Sdim 1226218887Sdimvoid CXXNameMangler::mangleSourceName(const IdentifierInfo *II) { 1227218887Sdim // <source-name> ::= <positive length number> <identifier> 1228218887Sdim // <number> ::= [n] <non-negative decimal integer> 1229218887Sdim // <identifier> ::= <unqualified source code identifier> 1230218887Sdim Out << II->getLength() << II->getName(); 1231218887Sdim} 1232218887Sdim 1233218887Sdimvoid CXXNameMangler::mangleNestedName(const NamedDecl *ND, 1234218887Sdim const DeclContext *DC, 1235218887Sdim bool NoFunction) { 1236218887Sdim // <nested-name> 1237218887Sdim // ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E 1238218887Sdim // ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> 1239218887Sdim // <template-args> E 1240218887Sdim 1241218887Sdim Out << 'N'; 1242218887Sdim if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND)) { 1243263508Sdim Qualifiers MethodQuals = 1244263508Sdim Qualifiers::fromCVRMask(Method->getTypeQualifiers()); 1245263508Sdim // We do not consider restrict a distinguishing attribute for overloading 1246263508Sdim // purposes so we must not mangle it. 1247263508Sdim MethodQuals.removeRestrict(); 1248263508Sdim mangleQualifiers(MethodQuals); 1249218887Sdim mangleRefQualifier(Method->getRefQualifier()); 1250218887Sdim } 1251218887Sdim 1252218887Sdim // Check if we have a template. 1253218887Sdim const TemplateArgumentList *TemplateArgs = 0; 1254218887Sdim if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { 1255263508Sdim mangleTemplatePrefix(TD, NoFunction); 1256243830Sdim mangleTemplateArgs(*TemplateArgs); 1257218887Sdim } 1258218887Sdim else { 1259218887Sdim manglePrefix(DC, NoFunction); 1260218887Sdim mangleUnqualifiedName(ND); 1261218887Sdim } 1262218887Sdim 1263218887Sdim Out << 'E'; 1264218887Sdim} 1265218887Sdimvoid CXXNameMangler::mangleNestedName(const TemplateDecl *TD, 1266218887Sdim const TemplateArgument *TemplateArgs, 1267218887Sdim unsigned NumTemplateArgs) { 1268218887Sdim // <nested-name> ::= N [<CV-qualifiers>] <template-prefix> <template-args> E 1269218887Sdim 1270218887Sdim Out << 'N'; 1271218887Sdim 1272218887Sdim mangleTemplatePrefix(TD); 1273243830Sdim mangleTemplateArgs(TemplateArgs, NumTemplateArgs); 1274218887Sdim 1275218887Sdim Out << 'E'; 1276218887Sdim} 1277218887Sdim 1278263508Sdimvoid CXXNameMangler::mangleLocalName(const Decl *D) { 1279218887Sdim // <local-name> := Z <function encoding> E <entity name> [<discriminator>] 1280218887Sdim // := Z <function encoding> E s [<discriminator>] 1281234353Sdim // <local-name> := Z <function encoding> E d [ <parameter number> ] 1282234353Sdim // _ <entity name> 1283218887Sdim // <discriminator> := _ <non-negative number> 1284263508Sdim assert(isa<NamedDecl>(D) || isa<BlockDecl>(D)); 1285263508Sdim const RecordDecl *RD = GetLocalClassDecl(D); 1286263508Sdim const DeclContext *DC = getEffectiveDeclContext(RD ? RD : D); 1287223017Sdim 1288218887Sdim Out << 'Z'; 1289218887Sdim 1290263508Sdim if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(DC)) 1291263508Sdim mangleObjCMethodName(MD); 1292263508Sdim else if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) 1293263508Sdim mangleBlockForPrefix(BD); 1294263508Sdim else 1295263508Sdim mangleFunctionEncoding(cast<FunctionDecl>(DC)); 1296218887Sdim 1297263508Sdim Out << 'E'; 1298263508Sdim 1299263508Sdim if (RD) { 1300234353Sdim // The parameter number is omitted for the last parameter, 0 for the 1301234353Sdim // second-to-last parameter, 1 for the third-to-last parameter, etc. The 1302234353Sdim // <entity name> will of course contain a <closure-type-name>: Its 1303234353Sdim // numbering will be local to the particular argument in which it appears 1304234353Sdim // -- other default arguments do not affect its encoding. 1305263508Sdim const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD); 1306263508Sdim if (CXXRD->isLambda()) { 1307234353Sdim if (const ParmVarDecl *Parm 1308263508Sdim = dyn_cast_or_null<ParmVarDecl>(CXXRD->getLambdaContextDecl())) { 1309234353Sdim if (const FunctionDecl *Func 1310234353Sdim = dyn_cast<FunctionDecl>(Parm->getDeclContext())) { 1311234353Sdim Out << 'd'; 1312234353Sdim unsigned Num = Func->getNumParams() - Parm->getFunctionScopeIndex(); 1313234353Sdim if (Num > 1) 1314234353Sdim mangleNumber(Num - 2); 1315234353Sdim Out << '_'; 1316234353Sdim } 1317234353Sdim } 1318234353Sdim } 1319234353Sdim 1320218887Sdim // Mangle the name relative to the closest enclosing function. 1321263508Sdim // equality ok because RD derived from ND above 1322263508Sdim if (D == RD) { 1323263508Sdim mangleUnqualifiedName(RD); 1324263508Sdim } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) { 1325263508Sdim manglePrefix(getEffectiveDeclContext(BD), true /*NoFunction*/); 1326263508Sdim mangleUnqualifiedBlock(BD); 1327263508Sdim } else { 1328263508Sdim const NamedDecl *ND = cast<NamedDecl>(D); 1329263508Sdim mangleNestedName(ND, getEffectiveDeclContext(ND), true /*NoFunction*/); 1330263508Sdim } 1331263508Sdim } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) { 1332263508Sdim // Mangle a block in a default parameter; see above explanation for 1333263508Sdim // lambdas. 1334263508Sdim if (const ParmVarDecl *Parm 1335263508Sdim = dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl())) { 1336263508Sdim if (const FunctionDecl *Func 1337263508Sdim = dyn_cast<FunctionDecl>(Parm->getDeclContext())) { 1338263508Sdim Out << 'd'; 1339263508Sdim unsigned Num = Func->getNumParams() - Parm->getFunctionScopeIndex(); 1340263508Sdim if (Num > 1) 1341263508Sdim mangleNumber(Num - 2); 1342263508Sdim Out << '_'; 1343234353Sdim } 1344218887Sdim } 1345263508Sdim 1346263508Sdim mangleUnqualifiedBlock(BD); 1347263508Sdim } else { 1348263508Sdim mangleUnqualifiedName(cast<NamedDecl>(D)); 1349263508Sdim } 1350263508Sdim 1351263508Sdim if (const NamedDecl *ND = dyn_cast<NamedDecl>(RD ? RD : D)) { 1352263508Sdim unsigned disc; 1353263508Sdim if (Context.getNextDiscriminator(ND, disc)) { 1354263508Sdim if (disc < 10) 1355263508Sdim Out << '_' << disc; 1356263508Sdim else 1357263508Sdim Out << "__" << disc << '_'; 1358263508Sdim } 1359263508Sdim } 1360263508Sdim} 1361263508Sdim 1362263508Sdimvoid CXXNameMangler::mangleBlockForPrefix(const BlockDecl *Block) { 1363263508Sdim if (GetLocalClassDecl(Block)) { 1364263508Sdim mangleLocalName(Block); 1365218887Sdim return; 1366218887Sdim } 1367263508Sdim const DeclContext *DC = getEffectiveDeclContext(Block); 1368263508Sdim if (isLocalContainerContext(DC)) { 1369263508Sdim mangleLocalName(Block); 1370263508Sdim return; 1371263508Sdim } 1372263508Sdim manglePrefix(getEffectiveDeclContext(Block)); 1373263508Sdim mangleUnqualifiedBlock(Block); 1374263508Sdim} 1375218887Sdim 1376263508Sdimvoid CXXNameMangler::mangleUnqualifiedBlock(const BlockDecl *Block) { 1377263508Sdim if (Decl *Context = Block->getBlockManglingContextDecl()) { 1378263508Sdim if ((isa<VarDecl>(Context) || isa<FieldDecl>(Context)) && 1379263508Sdim Context->getDeclContext()->isRecord()) { 1380263508Sdim if (const IdentifierInfo *Name 1381263508Sdim = cast<NamedDecl>(Context)->getIdentifier()) { 1382263508Sdim mangleSourceName(Name); 1383263508Sdim Out << 'M'; 1384263508Sdim } 1385263508Sdim } 1386263508Sdim } 1387263508Sdim 1388263508Sdim // If we have a block mangling number, use it. 1389263508Sdim unsigned Number = Block->getBlockManglingNumber(); 1390263508Sdim // Otherwise, just make up a number. It doesn't matter what it is because 1391263508Sdim // the symbol in question isn't externally visible. 1392263508Sdim if (!Number) 1393263508Sdim Number = Context.getBlockId(Block, false); 1394263508Sdim Out << "Ub"; 1395263508Sdim if (Number > 1) 1396263508Sdim Out << Number - 2; 1397263508Sdim Out << '_'; 1398218887Sdim} 1399218887Sdim 1400234353Sdimvoid CXXNameMangler::mangleLambda(const CXXRecordDecl *Lambda) { 1401234353Sdim // If the context of a closure type is an initializer for a class member 1402234353Sdim // (static or nonstatic), it is encoded in a qualified name with a final 1403234353Sdim // <prefix> of the form: 1404234353Sdim // 1405234353Sdim // <data-member-prefix> := <member source-name> M 1406234353Sdim // 1407234353Sdim // Technically, the data-member-prefix is part of the <prefix>. However, 1408234353Sdim // since a closure type will always be mangled with a prefix, it's easier 1409234353Sdim // to emit that last part of the prefix here. 1410234353Sdim if (Decl *Context = Lambda->getLambdaContextDecl()) { 1411234353Sdim if ((isa<VarDecl>(Context) || isa<FieldDecl>(Context)) && 1412234353Sdim Context->getDeclContext()->isRecord()) { 1413234353Sdim if (const IdentifierInfo *Name 1414234353Sdim = cast<NamedDecl>(Context)->getIdentifier()) { 1415234353Sdim mangleSourceName(Name); 1416234353Sdim Out << 'M'; 1417234353Sdim } 1418234353Sdim } 1419234353Sdim } 1420234353Sdim 1421234353Sdim Out << "Ul"; 1422243830Sdim const FunctionProtoType *Proto = Lambda->getLambdaTypeInfo()->getType()-> 1423243830Sdim getAs<FunctionProtoType>(); 1424234353Sdim mangleBareFunctionType(Proto, /*MangleReturnType=*/false); 1425234353Sdim Out << "E"; 1426234353Sdim 1427234353Sdim // The number is omitted for the first closure type with a given 1428234353Sdim // <lambda-sig> in a given context; it is n-2 for the nth closure type 1429234353Sdim // (in lexical order) with that same <lambda-sig> and context. 1430234353Sdim // 1431234353Sdim // The AST keeps track of the number for us. 1432234353Sdim unsigned Number = Lambda->getLambdaManglingNumber(); 1433234353Sdim assert(Number > 0 && "Lambda should be mangled as an unnamed class"); 1434234353Sdim if (Number > 1) 1435234353Sdim mangleNumber(Number - 2); 1436234353Sdim Out << '_'; 1437234353Sdim} 1438234353Sdim 1439221345Sdimvoid CXXNameMangler::manglePrefix(NestedNameSpecifier *qualifier) { 1440221345Sdim switch (qualifier->getKind()) { 1441221345Sdim case NestedNameSpecifier::Global: 1442221345Sdim // nothing 1443221345Sdim return; 1444221345Sdim 1445221345Sdim case NestedNameSpecifier::Namespace: 1446221345Sdim mangleName(qualifier->getAsNamespace()); 1447221345Sdim return; 1448221345Sdim 1449221345Sdim case NestedNameSpecifier::NamespaceAlias: 1450221345Sdim mangleName(qualifier->getAsNamespaceAlias()->getNamespace()); 1451221345Sdim return; 1452221345Sdim 1453221345Sdim case NestedNameSpecifier::TypeSpec: 1454221345Sdim case NestedNameSpecifier::TypeSpecWithTemplate: 1455223017Sdim manglePrefix(QualType(qualifier->getAsType(), 0)); 1456221345Sdim return; 1457221345Sdim 1458221345Sdim case NestedNameSpecifier::Identifier: 1459221345Sdim // Member expressions can have these without prefixes, but that 1460221345Sdim // should end up in mangleUnresolvedPrefix instead. 1461221345Sdim assert(qualifier->getPrefix()); 1462221345Sdim manglePrefix(qualifier->getPrefix()); 1463221345Sdim 1464221345Sdim mangleSourceName(qualifier->getAsIdentifier()); 1465221345Sdim return; 1466221345Sdim } 1467221345Sdim 1468221345Sdim llvm_unreachable("unexpected nested name specifier"); 1469221345Sdim} 1470221345Sdim 1471218887Sdimvoid CXXNameMangler::manglePrefix(const DeclContext *DC, bool NoFunction) { 1472218887Sdim // <prefix> ::= <prefix> <unqualified-name> 1473218887Sdim // ::= <template-prefix> <template-args> 1474218887Sdim // ::= <template-param> 1475218887Sdim // ::= # empty 1476218887Sdim // ::= <substitution> 1477218887Sdim 1478234353Sdim DC = IgnoreLinkageSpecDecls(DC); 1479218887Sdim 1480218887Sdim if (DC->isTranslationUnit()) 1481218887Sdim return; 1482218887Sdim 1483263508Sdim if (NoFunction && isLocalContainerContext(DC)) 1484218887Sdim return; 1485263508Sdim 1486263508Sdim assert(!isLocalContainerContext(DC)); 1487263508Sdim 1488234353Sdim const NamedDecl *ND = cast<NamedDecl>(DC); 1489234353Sdim if (mangleSubstitution(ND)) 1490218887Sdim return; 1491234353Sdim 1492218887Sdim // Check if we have a template. 1493218887Sdim const TemplateArgumentList *TemplateArgs = 0; 1494234353Sdim if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { 1495218887Sdim mangleTemplatePrefix(TD); 1496243830Sdim mangleTemplateArgs(*TemplateArgs); 1497263508Sdim } else { 1498234353Sdim manglePrefix(getEffectiveDeclContext(ND), NoFunction); 1499234353Sdim mangleUnqualifiedName(ND); 1500218887Sdim } 1501218887Sdim 1502234353Sdim addSubstitution(ND); 1503218887Sdim} 1504218887Sdim 1505218887Sdimvoid CXXNameMangler::mangleTemplatePrefix(TemplateName Template) { 1506218887Sdim // <template-prefix> ::= <prefix> <template unqualified-name> 1507218887Sdim // ::= <template-param> 1508218887Sdim // ::= <substitution> 1509218887Sdim if (TemplateDecl *TD = Template.getAsTemplateDecl()) 1510218887Sdim return mangleTemplatePrefix(TD); 1511218887Sdim 1512218887Sdim if (QualifiedTemplateName *Qualified = Template.getAsQualifiedTemplateName()) 1513221345Sdim manglePrefix(Qualified->getQualifier()); 1514218887Sdim 1515218887Sdim if (OverloadedTemplateStorage *Overloaded 1516218887Sdim = Template.getAsOverloadedTemplate()) { 1517218887Sdim mangleUnqualifiedName(0, (*Overloaded->begin())->getDeclName(), 1518218887Sdim UnknownArity); 1519218887Sdim return; 1520218887Sdim } 1521218887Sdim 1522218887Sdim DependentTemplateName *Dependent = Template.getAsDependentTemplateName(); 1523218887Sdim assert(Dependent && "Unknown template name kind?"); 1524221345Sdim manglePrefix(Dependent->getQualifier()); 1525218887Sdim mangleUnscopedTemplateName(Template); 1526218887Sdim} 1527218887Sdim 1528263508Sdimvoid CXXNameMangler::mangleTemplatePrefix(const TemplateDecl *ND, 1529263508Sdim bool NoFunction) { 1530218887Sdim // <template-prefix> ::= <prefix> <template unqualified-name> 1531218887Sdim // ::= <template-param> 1532218887Sdim // ::= <substitution> 1533218887Sdim // <template-template-param> ::= <template-param> 1534218887Sdim // <substitution> 1535218887Sdim 1536218887Sdim if (mangleSubstitution(ND)) 1537218887Sdim return; 1538218887Sdim 1539218887Sdim // <template-template-param> ::= <template-param> 1540218887Sdim if (const TemplateTemplateParmDecl *TTP 1541218887Sdim = dyn_cast<TemplateTemplateParmDecl>(ND)) { 1542218887Sdim mangleTemplateParameter(TTP->getIndex()); 1543218887Sdim return; 1544218887Sdim } 1545218887Sdim 1546263508Sdim manglePrefix(getEffectiveDeclContext(ND), NoFunction); 1547218887Sdim mangleUnqualifiedName(ND->getTemplatedDecl()); 1548218887Sdim addSubstitution(ND); 1549218887Sdim} 1550218887Sdim 1551218887Sdim/// Mangles a template name under the production <type>. Required for 1552218887Sdim/// template template arguments. 1553218887Sdim/// <type> ::= <class-enum-type> 1554218887Sdim/// ::= <template-param> 1555218887Sdim/// ::= <substitution> 1556218887Sdimvoid CXXNameMangler::mangleType(TemplateName TN) { 1557218887Sdim if (mangleSubstitution(TN)) 1558218887Sdim return; 1559218887Sdim 1560218887Sdim TemplateDecl *TD = 0; 1561218887Sdim 1562218887Sdim switch (TN.getKind()) { 1563218887Sdim case TemplateName::QualifiedTemplate: 1564218887Sdim TD = TN.getAsQualifiedTemplateName()->getTemplateDecl(); 1565218887Sdim goto HaveDecl; 1566218887Sdim 1567218887Sdim case TemplateName::Template: 1568218887Sdim TD = TN.getAsTemplateDecl(); 1569218887Sdim goto HaveDecl; 1570218887Sdim 1571218887Sdim HaveDecl: 1572218887Sdim if (isa<TemplateTemplateParmDecl>(TD)) 1573218887Sdim mangleTemplateParameter(cast<TemplateTemplateParmDecl>(TD)->getIndex()); 1574218887Sdim else 1575218887Sdim mangleName(TD); 1576218887Sdim break; 1577218887Sdim 1578218887Sdim case TemplateName::OverloadedTemplate: 1579218887Sdim llvm_unreachable("can't mangle an overloaded template name as a <type>"); 1580218887Sdim 1581218887Sdim case TemplateName::DependentTemplate: { 1582218887Sdim const DependentTemplateName *Dependent = TN.getAsDependentTemplateName(); 1583218887Sdim assert(Dependent->isIdentifier()); 1584218887Sdim 1585218887Sdim // <class-enum-type> ::= <name> 1586218887Sdim // <name> ::= <nested-name> 1587221345Sdim mangleUnresolvedPrefix(Dependent->getQualifier(), 0); 1588218887Sdim mangleSourceName(Dependent->getIdentifier()); 1589218887Sdim break; 1590218887Sdim } 1591218887Sdim 1592224145Sdim case TemplateName::SubstTemplateTemplateParm: { 1593224145Sdim // Substituted template parameters are mangled as the substituted 1594224145Sdim // template. This will check for the substitution twice, which is 1595224145Sdim // fine, but we have to return early so that we don't try to *add* 1596224145Sdim // the substitution twice. 1597224145Sdim SubstTemplateTemplateParmStorage *subst 1598224145Sdim = TN.getAsSubstTemplateTemplateParm(); 1599224145Sdim mangleType(subst->getReplacement()); 1600224145Sdim return; 1601224145Sdim } 1602224145Sdim 1603218887Sdim case TemplateName::SubstTemplateTemplateParmPack: { 1604224145Sdim // FIXME: not clear how to mangle this! 1605224145Sdim // template <template <class> class T...> class A { 1606224145Sdim // template <template <class> class U...> void foo(B<T,U> x...); 1607224145Sdim // }; 1608224145Sdim Out << "_SUBSTPACK_"; 1609218887Sdim break; 1610218887Sdim } 1611218887Sdim } 1612218887Sdim 1613218887Sdim addSubstitution(TN); 1614218887Sdim} 1615218887Sdim 1616218887Sdimvoid 1617218887SdimCXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity) { 1618218887Sdim switch (OO) { 1619218887Sdim // <operator-name> ::= nw # new 1620218887Sdim case OO_New: Out << "nw"; break; 1621218887Sdim // ::= na # new[] 1622218887Sdim case OO_Array_New: Out << "na"; break; 1623218887Sdim // ::= dl # delete 1624218887Sdim case OO_Delete: Out << "dl"; break; 1625218887Sdim // ::= da # delete[] 1626218887Sdim case OO_Array_Delete: Out << "da"; break; 1627218887Sdim // ::= ps # + (unary) 1628218887Sdim // ::= pl # + (binary or unknown) 1629218887Sdim case OO_Plus: 1630218887Sdim Out << (Arity == 1? "ps" : "pl"); break; 1631218887Sdim // ::= ng # - (unary) 1632218887Sdim // ::= mi # - (binary or unknown) 1633218887Sdim case OO_Minus: 1634218887Sdim Out << (Arity == 1? "ng" : "mi"); break; 1635218887Sdim // ::= ad # & (unary) 1636218887Sdim // ::= an # & (binary or unknown) 1637218887Sdim case OO_Amp: 1638218887Sdim Out << (Arity == 1? "ad" : "an"); break; 1639218887Sdim // ::= de # * (unary) 1640218887Sdim // ::= ml # * (binary or unknown) 1641218887Sdim case OO_Star: 1642218887Sdim // Use binary when unknown. 1643218887Sdim Out << (Arity == 1? "de" : "ml"); break; 1644218887Sdim // ::= co # ~ 1645218887Sdim case OO_Tilde: Out << "co"; break; 1646218887Sdim // ::= dv # / 1647218887Sdim case OO_Slash: Out << "dv"; break; 1648218887Sdim // ::= rm # % 1649218887Sdim case OO_Percent: Out << "rm"; break; 1650218887Sdim // ::= or # | 1651218887Sdim case OO_Pipe: Out << "or"; break; 1652218887Sdim // ::= eo # ^ 1653218887Sdim case OO_Caret: Out << "eo"; break; 1654218887Sdim // ::= aS # = 1655218887Sdim case OO_Equal: Out << "aS"; break; 1656218887Sdim // ::= pL # += 1657218887Sdim case OO_PlusEqual: Out << "pL"; break; 1658218887Sdim // ::= mI # -= 1659218887Sdim case OO_MinusEqual: Out << "mI"; break; 1660218887Sdim // ::= mL # *= 1661218887Sdim case OO_StarEqual: Out << "mL"; break; 1662218887Sdim // ::= dV # /= 1663218887Sdim case OO_SlashEqual: Out << "dV"; break; 1664218887Sdim // ::= rM # %= 1665218887Sdim case OO_PercentEqual: Out << "rM"; break; 1666218887Sdim // ::= aN # &= 1667218887Sdim case OO_AmpEqual: Out << "aN"; break; 1668218887Sdim // ::= oR # |= 1669218887Sdim case OO_PipeEqual: Out << "oR"; break; 1670218887Sdim // ::= eO # ^= 1671218887Sdim case OO_CaretEqual: Out << "eO"; break; 1672218887Sdim // ::= ls # << 1673218887Sdim case OO_LessLess: Out << "ls"; break; 1674218887Sdim // ::= rs # >> 1675218887Sdim case OO_GreaterGreater: Out << "rs"; break; 1676218887Sdim // ::= lS # <<= 1677218887Sdim case OO_LessLessEqual: Out << "lS"; break; 1678218887Sdim // ::= rS # >>= 1679218887Sdim case OO_GreaterGreaterEqual: Out << "rS"; break; 1680218887Sdim // ::= eq # == 1681218887Sdim case OO_EqualEqual: Out << "eq"; break; 1682218887Sdim // ::= ne # != 1683218887Sdim case OO_ExclaimEqual: Out << "ne"; break; 1684218887Sdim // ::= lt # < 1685218887Sdim case OO_Less: Out << "lt"; break; 1686218887Sdim // ::= gt # > 1687218887Sdim case OO_Greater: Out << "gt"; break; 1688218887Sdim // ::= le # <= 1689218887Sdim case OO_LessEqual: Out << "le"; break; 1690218887Sdim // ::= ge # >= 1691218887Sdim case OO_GreaterEqual: Out << "ge"; break; 1692218887Sdim // ::= nt # ! 1693218887Sdim case OO_Exclaim: Out << "nt"; break; 1694218887Sdim // ::= aa # && 1695218887Sdim case OO_AmpAmp: Out << "aa"; break; 1696218887Sdim // ::= oo # || 1697218887Sdim case OO_PipePipe: Out << "oo"; break; 1698218887Sdim // ::= pp # ++ 1699218887Sdim case OO_PlusPlus: Out << "pp"; break; 1700218887Sdim // ::= mm # -- 1701218887Sdim case OO_MinusMinus: Out << "mm"; break; 1702218887Sdim // ::= cm # , 1703218887Sdim case OO_Comma: Out << "cm"; break; 1704218887Sdim // ::= pm # ->* 1705218887Sdim case OO_ArrowStar: Out << "pm"; break; 1706218887Sdim // ::= pt # -> 1707218887Sdim case OO_Arrow: Out << "pt"; break; 1708218887Sdim // ::= cl # () 1709218887Sdim case OO_Call: Out << "cl"; break; 1710218887Sdim // ::= ix # [] 1711218887Sdim case OO_Subscript: Out << "ix"; break; 1712218887Sdim 1713218887Sdim // ::= qu # ? 1714218887Sdim // The conditional operator can't be overloaded, but we still handle it when 1715218887Sdim // mangling expressions. 1716218887Sdim case OO_Conditional: Out << "qu"; break; 1717218887Sdim 1718218887Sdim case OO_None: 1719218887Sdim case NUM_OVERLOADED_OPERATORS: 1720226633Sdim llvm_unreachable("Not an overloaded operator"); 1721218887Sdim } 1722218887Sdim} 1723218887Sdim 1724218887Sdimvoid CXXNameMangler::mangleQualifiers(Qualifiers Quals) { 1725218887Sdim // <CV-qualifiers> ::= [r] [V] [K] # restrict (C99), volatile, const 1726218887Sdim if (Quals.hasRestrict()) 1727218887Sdim Out << 'r'; 1728218887Sdim if (Quals.hasVolatile()) 1729218887Sdim Out << 'V'; 1730218887Sdim if (Quals.hasConst()) 1731218887Sdim Out << 'K'; 1732218887Sdim 1733218887Sdim if (Quals.hasAddressSpace()) { 1734263508Sdim // Address space extension: 1735218887Sdim // 1736263508Sdim // <type> ::= U <target-addrspace> 1737263508Sdim // <type> ::= U <OpenCL-addrspace> 1738263508Sdim // <type> ::= U <CUDA-addrspace> 1739263508Sdim 1740234353Sdim SmallString<64> ASString; 1741263508Sdim unsigned AS = Quals.getAddressSpace(); 1742263508Sdim 1743263508Sdim if (Context.getASTContext().addressSpaceMapManglingFor(AS)) { 1744263508Sdim // <target-addrspace> ::= "AS" <address-space-number> 1745263508Sdim unsigned TargetAS = Context.getASTContext().getTargetAddressSpace(AS); 1746263508Sdim ASString = "AS" + llvm::utostr_32(TargetAS); 1747263508Sdim } else { 1748263508Sdim switch (AS) { 1749263508Sdim default: llvm_unreachable("Not a language specific address space"); 1750263508Sdim // <OpenCL-addrspace> ::= "CL" [ "global" | "local" | "constant" ] 1751263508Sdim case LangAS::opencl_global: ASString = "CLglobal"; break; 1752263508Sdim case LangAS::opencl_local: ASString = "CLlocal"; break; 1753263508Sdim case LangAS::opencl_constant: ASString = "CLconstant"; break; 1754263508Sdim // <CUDA-addrspace> ::= "CU" [ "device" | "constant" | "shared" ] 1755263508Sdim case LangAS::cuda_device: ASString = "CUdevice"; break; 1756263508Sdim case LangAS::cuda_constant: ASString = "CUconstant"; break; 1757263508Sdim case LangAS::cuda_shared: ASString = "CUshared"; break; 1758263508Sdim } 1759263508Sdim } 1760218887Sdim Out << 'U' << ASString.size() << ASString; 1761218887Sdim } 1762218887Sdim 1763226633Sdim StringRef LifetimeName; 1764224145Sdim switch (Quals.getObjCLifetime()) { 1765224145Sdim // Objective-C ARC Extension: 1766224145Sdim // 1767224145Sdim // <type> ::= U "__strong" 1768224145Sdim // <type> ::= U "__weak" 1769224145Sdim // <type> ::= U "__autoreleasing" 1770224145Sdim case Qualifiers::OCL_None: 1771224145Sdim break; 1772224145Sdim 1773224145Sdim case Qualifiers::OCL_Weak: 1774224145Sdim LifetimeName = "__weak"; 1775224145Sdim break; 1776224145Sdim 1777224145Sdim case Qualifiers::OCL_Strong: 1778224145Sdim LifetimeName = "__strong"; 1779224145Sdim break; 1780224145Sdim 1781224145Sdim case Qualifiers::OCL_Autoreleasing: 1782224145Sdim LifetimeName = "__autoreleasing"; 1783224145Sdim break; 1784224145Sdim 1785224145Sdim case Qualifiers::OCL_ExplicitNone: 1786224145Sdim // The __unsafe_unretained qualifier is *not* mangled, so that 1787224145Sdim // __unsafe_unretained types in ARC produce the same manglings as the 1788224145Sdim // equivalent (but, naturally, unqualified) types in non-ARC, providing 1789224145Sdim // better ABI compatibility. 1790224145Sdim // 1791224145Sdim // It's safe to do this because unqualified 'id' won't show up 1792224145Sdim // in any type signatures that need to be mangled. 1793224145Sdim break; 1794224145Sdim } 1795224145Sdim if (!LifetimeName.empty()) 1796224145Sdim Out << 'U' << LifetimeName.size() << LifetimeName; 1797218887Sdim} 1798218887Sdim 1799218887Sdimvoid CXXNameMangler::mangleRefQualifier(RefQualifierKind RefQualifier) { 1800218887Sdim // <ref-qualifier> ::= R # lvalue reference 1801218887Sdim // ::= O # rvalue-reference 1802218887Sdim switch (RefQualifier) { 1803218887Sdim case RQ_None: 1804218887Sdim break; 1805218887Sdim 1806218887Sdim case RQ_LValue: 1807218887Sdim Out << 'R'; 1808218887Sdim break; 1809218887Sdim 1810218887Sdim case RQ_RValue: 1811218887Sdim Out << 'O'; 1812218887Sdim break; 1813218887Sdim } 1814218887Sdim} 1815218887Sdim 1816218887Sdimvoid CXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) { 1817218887Sdim Context.mangleObjCMethodName(MD, Out); 1818218887Sdim} 1819218887Sdim 1820224145Sdimvoid CXXNameMangler::mangleType(QualType T) { 1821224145Sdim // If our type is instantiation-dependent but not dependent, we mangle 1822224145Sdim // it as it was written in the source, removing any top-level sugar. 1823224145Sdim // Otherwise, use the canonical type. 1824224145Sdim // 1825224145Sdim // FIXME: This is an approximation of the instantiation-dependent name 1826224145Sdim // mangling rules, since we should really be using the type as written and 1827224145Sdim // augmented via semantic analysis (i.e., with implicit conversions and 1828224145Sdim // default template arguments) for any instantiation-dependent type. 1829224145Sdim // Unfortunately, that requires several changes to our AST: 1830224145Sdim // - Instantiation-dependent TemplateSpecializationTypes will need to be 1831224145Sdim // uniqued, so that we can handle substitutions properly 1832224145Sdim // - Default template arguments will need to be represented in the 1833224145Sdim // TemplateSpecializationType, since they need to be mangled even though 1834224145Sdim // they aren't written. 1835224145Sdim // - Conversions on non-type template arguments need to be expressed, since 1836224145Sdim // they can affect the mangling of sizeof/alignof. 1837224145Sdim if (!T->isInstantiationDependentType() || T->isDependentType()) 1838224145Sdim T = T.getCanonicalType(); 1839224145Sdim else { 1840224145Sdim // Desugar any types that are purely sugar. 1841224145Sdim do { 1842224145Sdim // Don't desugar through template specialization types that aren't 1843224145Sdim // type aliases. We need to mangle the template arguments as written. 1844224145Sdim if (const TemplateSpecializationType *TST 1845224145Sdim = dyn_cast<TemplateSpecializationType>(T)) 1846224145Sdim if (!TST->isTypeAlias()) 1847224145Sdim break; 1848218887Sdim 1849224145Sdim QualType Desugared 1850224145Sdim = T.getSingleStepDesugaredType(Context.getASTContext()); 1851224145Sdim if (Desugared == T) 1852224145Sdim break; 1853224145Sdim 1854224145Sdim T = Desugared; 1855224145Sdim } while (true); 1856224145Sdim } 1857224145Sdim SplitQualType split = T.split(); 1858234353Sdim Qualifiers quals = split.Quals; 1859234353Sdim const Type *ty = split.Ty; 1860218887Sdim 1861224145Sdim bool isSubstitutable = quals || !isa<BuiltinType>(T); 1862224145Sdim if (isSubstitutable && mangleSubstitution(T)) 1863218887Sdim return; 1864218887Sdim 1865218887Sdim // If we're mangling a qualified array type, push the qualifiers to 1866218887Sdim // the element type. 1867224145Sdim if (quals && isa<ArrayType>(T)) { 1868224145Sdim ty = Context.getASTContext().getAsArrayType(T); 1869218887Sdim quals = Qualifiers(); 1870218887Sdim 1871224145Sdim // Note that we don't update T: we want to add the 1872224145Sdim // substitution at the original type. 1873218887Sdim } 1874218887Sdim 1875218887Sdim if (quals) { 1876218887Sdim mangleQualifiers(quals); 1877218887Sdim // Recurse: even if the qualified type isn't yet substitutable, 1878218887Sdim // the unqualified type might be. 1879218887Sdim mangleType(QualType(ty, 0)); 1880218887Sdim } else { 1881218887Sdim switch (ty->getTypeClass()) { 1882218887Sdim#define ABSTRACT_TYPE(CLASS, PARENT) 1883218887Sdim#define NON_CANONICAL_TYPE(CLASS, PARENT) \ 1884218887Sdim case Type::CLASS: \ 1885218887Sdim llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \ 1886218887Sdim return; 1887218887Sdim#define TYPE(CLASS, PARENT) \ 1888218887Sdim case Type::CLASS: \ 1889218887Sdim mangleType(static_cast<const CLASS##Type*>(ty)); \ 1890218887Sdim break; 1891218887Sdim#include "clang/AST/TypeNodes.def" 1892218887Sdim } 1893218887Sdim } 1894218887Sdim 1895218887Sdim // Add the substitution. 1896218887Sdim if (isSubstitutable) 1897224145Sdim addSubstitution(T); 1898218887Sdim} 1899218887Sdim 1900218887Sdimvoid CXXNameMangler::mangleNameOrStandardSubstitution(const NamedDecl *ND) { 1901218887Sdim if (!mangleStandardSubstitution(ND)) 1902218887Sdim mangleName(ND); 1903218887Sdim} 1904218887Sdim 1905218887Sdimvoid CXXNameMangler::mangleType(const BuiltinType *T) { 1906218887Sdim // <type> ::= <builtin-type> 1907218887Sdim // <builtin-type> ::= v # void 1908218887Sdim // ::= w # wchar_t 1909218887Sdim // ::= b # bool 1910218887Sdim // ::= c # char 1911218887Sdim // ::= a # signed char 1912218887Sdim // ::= h # unsigned char 1913218887Sdim // ::= s # short 1914218887Sdim // ::= t # unsigned short 1915218887Sdim // ::= i # int 1916218887Sdim // ::= j # unsigned int 1917218887Sdim // ::= l # long 1918218887Sdim // ::= m # unsigned long 1919218887Sdim // ::= x # long long, __int64 1920218887Sdim // ::= y # unsigned long long, __int64 1921218887Sdim // ::= n # __int128 1922218887Sdim // UNSUPPORTED: ::= o # unsigned __int128 1923218887Sdim // ::= f # float 1924218887Sdim // ::= d # double 1925218887Sdim // ::= e # long double, __float80 1926218887Sdim // UNSUPPORTED: ::= g # __float128 1927218887Sdim // UNSUPPORTED: ::= Dd # IEEE 754r decimal floating point (64 bits) 1928218887Sdim // UNSUPPORTED: ::= De # IEEE 754r decimal floating point (128 bits) 1929218887Sdim // UNSUPPORTED: ::= Df # IEEE 754r decimal floating point (32 bits) 1930226633Sdim // ::= Dh # IEEE 754r half-precision floating point (16 bits) 1931218887Sdim // ::= Di # char32_t 1932218887Sdim // ::= Ds # char16_t 1933218887Sdim // ::= Dn # std::nullptr_t (i.e., decltype(nullptr)) 1934218887Sdim // ::= u <source-name> # vendor extended type 1935218887Sdim switch (T->getKind()) { 1936218887Sdim case BuiltinType::Void: Out << 'v'; break; 1937218887Sdim case BuiltinType::Bool: Out << 'b'; break; 1938218887Sdim case BuiltinType::Char_U: case BuiltinType::Char_S: Out << 'c'; break; 1939218887Sdim case BuiltinType::UChar: Out << 'h'; break; 1940218887Sdim case BuiltinType::UShort: Out << 't'; break; 1941218887Sdim case BuiltinType::UInt: Out << 'j'; break; 1942218887Sdim case BuiltinType::ULong: Out << 'm'; break; 1943218887Sdim case BuiltinType::ULongLong: Out << 'y'; break; 1944218887Sdim case BuiltinType::UInt128: Out << 'o'; break; 1945218887Sdim case BuiltinType::SChar: Out << 'a'; break; 1946218887Sdim case BuiltinType::WChar_S: 1947218887Sdim case BuiltinType::WChar_U: Out << 'w'; break; 1948218887Sdim case BuiltinType::Char16: Out << "Ds"; break; 1949218887Sdim case BuiltinType::Char32: Out << "Di"; break; 1950218887Sdim case BuiltinType::Short: Out << 's'; break; 1951218887Sdim case BuiltinType::Int: Out << 'i'; break; 1952218887Sdim case BuiltinType::Long: Out << 'l'; break; 1953218887Sdim case BuiltinType::LongLong: Out << 'x'; break; 1954218887Sdim case BuiltinType::Int128: Out << 'n'; break; 1955226633Sdim case BuiltinType::Half: Out << "Dh"; break; 1956218887Sdim case BuiltinType::Float: Out << 'f'; break; 1957218887Sdim case BuiltinType::Double: Out << 'd'; break; 1958218887Sdim case BuiltinType::LongDouble: Out << 'e'; break; 1959218887Sdim case BuiltinType::NullPtr: Out << "Dn"; break; 1960218887Sdim 1961234353Sdim#define BUILTIN_TYPE(Id, SingletonId) 1962234353Sdim#define PLACEHOLDER_TYPE(Id, SingletonId) \ 1963234353Sdim case BuiltinType::Id: 1964234353Sdim#include "clang/AST/BuiltinTypes.def" 1965218887Sdim case BuiltinType::Dependent: 1966221345Sdim llvm_unreachable("mangling a placeholder type"); 1967218887Sdim case BuiltinType::ObjCId: Out << "11objc_object"; break; 1968218887Sdim case BuiltinType::ObjCClass: Out << "10objc_class"; break; 1969218887Sdim case BuiltinType::ObjCSel: Out << "13objc_selector"; break; 1970249423Sdim case BuiltinType::OCLImage1d: Out << "11ocl_image1d"; break; 1971249423Sdim case BuiltinType::OCLImage1dArray: Out << "16ocl_image1darray"; break; 1972249423Sdim case BuiltinType::OCLImage1dBuffer: Out << "17ocl_image1dbuffer"; break; 1973249423Sdim case BuiltinType::OCLImage2d: Out << "11ocl_image2d"; break; 1974249423Sdim case BuiltinType::OCLImage2dArray: Out << "16ocl_image2darray"; break; 1975249423Sdim case BuiltinType::OCLImage3d: Out << "11ocl_image3d"; break; 1976249423Sdim case BuiltinType::OCLSampler: Out << "11ocl_sampler"; break; 1977249423Sdim case BuiltinType::OCLEvent: Out << "9ocl_event"; break; 1978218887Sdim } 1979218887Sdim} 1980218887Sdim 1981218887Sdim// <type> ::= <function-type> 1982239462Sdim// <function-type> ::= [<CV-qualifiers>] F [Y] 1983239462Sdim// <bare-function-type> [<ref-qualifier>] E 1984218887Sdimvoid CXXNameMangler::mangleType(const FunctionProtoType *T) { 1985239462Sdim // Mangle CV-qualifiers, if present. These are 'this' qualifiers, 1986239462Sdim // e.g. "const" in "int (A::*)() const". 1987239462Sdim mangleQualifiers(Qualifiers::fromCVRMask(T->getTypeQuals())); 1988239462Sdim 1989218887Sdim Out << 'F'; 1990239462Sdim 1991218887Sdim // FIXME: We don't have enough information in the AST to produce the 'Y' 1992218887Sdim // encoding for extern "C" function types. 1993218887Sdim mangleBareFunctionType(T, /*MangleReturnType=*/true); 1994239462Sdim 1995239462Sdim // Mangle the ref-qualifier, if present. 1996239462Sdim mangleRefQualifier(T->getRefQualifier()); 1997239462Sdim 1998218887Sdim Out << 'E'; 1999218887Sdim} 2000218887Sdimvoid CXXNameMangler::mangleType(const FunctionNoProtoType *T) { 2001218887Sdim llvm_unreachable("Can't mangle K&R function prototypes"); 2002218887Sdim} 2003218887Sdimvoid CXXNameMangler::mangleBareFunctionType(const FunctionType *T, 2004218887Sdim bool MangleReturnType) { 2005218887Sdim // We should never be mangling something without a prototype. 2006218887Sdim const FunctionProtoType *Proto = cast<FunctionProtoType>(T); 2007218887Sdim 2008221345Sdim // Record that we're in a function type. See mangleFunctionParam 2009221345Sdim // for details on what we're trying to achieve here. 2010221345Sdim FunctionTypeDepthState saved = FunctionTypeDepth.push(); 2011221345Sdim 2012218887Sdim // <bare-function-type> ::= <signature type>+ 2013221345Sdim if (MangleReturnType) { 2014221345Sdim FunctionTypeDepth.enterResultType(); 2015218887Sdim mangleType(Proto->getResultType()); 2016221345Sdim FunctionTypeDepth.leaveResultType(); 2017221345Sdim } 2018218887Sdim 2019218887Sdim if (Proto->getNumArgs() == 0 && !Proto->isVariadic()) { 2020218887Sdim // <builtin-type> ::= v # void 2021218887Sdim Out << 'v'; 2022221345Sdim 2023221345Sdim FunctionTypeDepth.pop(saved); 2024218887Sdim return; 2025218887Sdim } 2026218887Sdim 2027218887Sdim for (FunctionProtoType::arg_type_iterator Arg = Proto->arg_type_begin(), 2028218887Sdim ArgEnd = Proto->arg_type_end(); 2029218887Sdim Arg != ArgEnd; ++Arg) 2030224145Sdim mangleType(Context.getASTContext().getSignatureParameterType(*Arg)); 2031218887Sdim 2032221345Sdim FunctionTypeDepth.pop(saved); 2033221345Sdim 2034218887Sdim // <builtin-type> ::= z # ellipsis 2035218887Sdim if (Proto->isVariadic()) 2036218887Sdim Out << 'z'; 2037218887Sdim} 2038218887Sdim 2039218887Sdim// <type> ::= <class-enum-type> 2040218887Sdim// <class-enum-type> ::= <name> 2041218887Sdimvoid CXXNameMangler::mangleType(const UnresolvedUsingType *T) { 2042218887Sdim mangleName(T->getDecl()); 2043218887Sdim} 2044218887Sdim 2045218887Sdim// <type> ::= <class-enum-type> 2046218887Sdim// <class-enum-type> ::= <name> 2047218887Sdimvoid CXXNameMangler::mangleType(const EnumType *T) { 2048218887Sdim mangleType(static_cast<const TagType*>(T)); 2049218887Sdim} 2050218887Sdimvoid CXXNameMangler::mangleType(const RecordType *T) { 2051218887Sdim mangleType(static_cast<const TagType*>(T)); 2052218887Sdim} 2053218887Sdimvoid CXXNameMangler::mangleType(const TagType *T) { 2054218887Sdim mangleName(T->getDecl()); 2055218887Sdim} 2056218887Sdim 2057218887Sdim// <type> ::= <array-type> 2058218887Sdim// <array-type> ::= A <positive dimension number> _ <element type> 2059218887Sdim// ::= A [<dimension expression>] _ <element type> 2060218887Sdimvoid CXXNameMangler::mangleType(const ConstantArrayType *T) { 2061218887Sdim Out << 'A' << T->getSize() << '_'; 2062218887Sdim mangleType(T->getElementType()); 2063218887Sdim} 2064218887Sdimvoid CXXNameMangler::mangleType(const VariableArrayType *T) { 2065218887Sdim Out << 'A'; 2066218887Sdim // decayed vla types (size 0) will just be skipped. 2067218887Sdim if (T->getSizeExpr()) 2068218887Sdim mangleExpression(T->getSizeExpr()); 2069218887Sdim Out << '_'; 2070218887Sdim mangleType(T->getElementType()); 2071218887Sdim} 2072218887Sdimvoid CXXNameMangler::mangleType(const DependentSizedArrayType *T) { 2073218887Sdim Out << 'A'; 2074218887Sdim mangleExpression(T->getSizeExpr()); 2075218887Sdim Out << '_'; 2076218887Sdim mangleType(T->getElementType()); 2077218887Sdim} 2078218887Sdimvoid CXXNameMangler::mangleType(const IncompleteArrayType *T) { 2079218887Sdim Out << "A_"; 2080218887Sdim mangleType(T->getElementType()); 2081218887Sdim} 2082218887Sdim 2083218887Sdim// <type> ::= <pointer-to-member-type> 2084218887Sdim// <pointer-to-member-type> ::= M <class type> <member type> 2085218887Sdimvoid CXXNameMangler::mangleType(const MemberPointerType *T) { 2086218887Sdim Out << 'M'; 2087218887Sdim mangleType(QualType(T->getClass(), 0)); 2088218887Sdim QualType PointeeType = T->getPointeeType(); 2089218887Sdim if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(PointeeType)) { 2090218887Sdim mangleType(FPT); 2091218887Sdim 2092218887Sdim // Itanium C++ ABI 5.1.8: 2093218887Sdim // 2094218887Sdim // The type of a non-static member function is considered to be different, 2095218887Sdim // for the purposes of substitution, from the type of a namespace-scope or 2096218887Sdim // static member function whose type appears similar. The types of two 2097218887Sdim // non-static member functions are considered to be different, for the 2098218887Sdim // purposes of substitution, if the functions are members of different 2099218887Sdim // classes. In other words, for the purposes of substitution, the class of 2100218887Sdim // which the function is a member is considered part of the type of 2101218887Sdim // function. 2102218887Sdim 2103239462Sdim // Given that we already substitute member function pointers as a 2104239462Sdim // whole, the net effect of this rule is just to unconditionally 2105239462Sdim // suppress substitution on the function type in a member pointer. 2106218887Sdim // We increment the SeqID here to emulate adding an entry to the 2107239462Sdim // substitution table. 2108218887Sdim ++SeqID; 2109218887Sdim } else 2110218887Sdim mangleType(PointeeType); 2111218887Sdim} 2112218887Sdim 2113218887Sdim// <type> ::= <template-param> 2114218887Sdimvoid CXXNameMangler::mangleType(const TemplateTypeParmType *T) { 2115218887Sdim mangleTemplateParameter(T->getIndex()); 2116218887Sdim} 2117218887Sdim 2118218887Sdim// <type> ::= <template-param> 2119218887Sdimvoid CXXNameMangler::mangleType(const SubstTemplateTypeParmPackType *T) { 2120224145Sdim // FIXME: not clear how to mangle this! 2121224145Sdim // template <class T...> class A { 2122224145Sdim // template <class U...> void foo(T(*)(U) x...); 2123224145Sdim // }; 2124224145Sdim Out << "_SUBSTPACK_"; 2125218887Sdim} 2126218887Sdim 2127218887Sdim// <type> ::= P <type> # pointer-to 2128218887Sdimvoid CXXNameMangler::mangleType(const PointerType *T) { 2129218887Sdim Out << 'P'; 2130218887Sdim mangleType(T->getPointeeType()); 2131218887Sdim} 2132218887Sdimvoid CXXNameMangler::mangleType(const ObjCObjectPointerType *T) { 2133218887Sdim Out << 'P'; 2134218887Sdim mangleType(T->getPointeeType()); 2135218887Sdim} 2136218887Sdim 2137218887Sdim// <type> ::= R <type> # reference-to 2138218887Sdimvoid CXXNameMangler::mangleType(const LValueReferenceType *T) { 2139218887Sdim Out << 'R'; 2140218887Sdim mangleType(T->getPointeeType()); 2141218887Sdim} 2142218887Sdim 2143218887Sdim// <type> ::= O <type> # rvalue reference-to (C++0x) 2144218887Sdimvoid CXXNameMangler::mangleType(const RValueReferenceType *T) { 2145218887Sdim Out << 'O'; 2146218887Sdim mangleType(T->getPointeeType()); 2147218887Sdim} 2148218887Sdim 2149218887Sdim// <type> ::= C <type> # complex pair (C 2000) 2150218887Sdimvoid CXXNameMangler::mangleType(const ComplexType *T) { 2151218887Sdim Out << 'C'; 2152218887Sdim mangleType(T->getElementType()); 2153218887Sdim} 2154218887Sdim 2155218887Sdim// ARM's ABI for Neon vector types specifies that they should be mangled as 2156218887Sdim// if they are structs (to match ARM's initial implementation). The 2157218887Sdim// vector type must be one of the special types predefined by ARM. 2158218887Sdimvoid CXXNameMangler::mangleNeonVectorType(const VectorType *T) { 2159218887Sdim QualType EltType = T->getElementType(); 2160218887Sdim assert(EltType->isBuiltinType() && "Neon vector element not a BuiltinType"); 2161218887Sdim const char *EltName = 0; 2162218887Sdim if (T->getVectorKind() == VectorType::NeonPolyVector) { 2163218887Sdim switch (cast<BuiltinType>(EltType)->getKind()) { 2164218887Sdim case BuiltinType::SChar: EltName = "poly8_t"; break; 2165218887Sdim case BuiltinType::Short: EltName = "poly16_t"; break; 2166218887Sdim default: llvm_unreachable("unexpected Neon polynomial vector element type"); 2167218887Sdim } 2168218887Sdim } else { 2169218887Sdim switch (cast<BuiltinType>(EltType)->getKind()) { 2170218887Sdim case BuiltinType::SChar: EltName = "int8_t"; break; 2171218887Sdim case BuiltinType::UChar: EltName = "uint8_t"; break; 2172218887Sdim case BuiltinType::Short: EltName = "int16_t"; break; 2173218887Sdim case BuiltinType::UShort: EltName = "uint16_t"; break; 2174218887Sdim case BuiltinType::Int: EltName = "int32_t"; break; 2175218887Sdim case BuiltinType::UInt: EltName = "uint32_t"; break; 2176218887Sdim case BuiltinType::LongLong: EltName = "int64_t"; break; 2177218887Sdim case BuiltinType::ULongLong: EltName = "uint64_t"; break; 2178218887Sdim case BuiltinType::Float: EltName = "float32_t"; break; 2179263508Sdim case BuiltinType::Half: EltName = "float16_t";break; 2180263508Sdim default: 2181263508Sdim llvm_unreachable("unexpected Neon vector element type"); 2182218887Sdim } 2183218887Sdim } 2184218887Sdim const char *BaseName = 0; 2185218887Sdim unsigned BitSize = (T->getNumElements() * 2186218887Sdim getASTContext().getTypeSize(EltType)); 2187218887Sdim if (BitSize == 64) 2188218887Sdim BaseName = "__simd64_"; 2189218887Sdim else { 2190218887Sdim assert(BitSize == 128 && "Neon vector type not 64 or 128 bits"); 2191218887Sdim BaseName = "__simd128_"; 2192218887Sdim } 2193218887Sdim Out << strlen(BaseName) + strlen(EltName); 2194218887Sdim Out << BaseName << EltName; 2195218887Sdim} 2196218887Sdim 2197263508Sdimstatic StringRef mangleAArch64VectorBase(const BuiltinType *EltType) { 2198263508Sdim switch (EltType->getKind()) { 2199263508Sdim case BuiltinType::SChar: 2200263508Sdim return "Int8"; 2201263508Sdim case BuiltinType::Short: 2202263508Sdim return "Int16"; 2203263508Sdim case BuiltinType::Int: 2204263508Sdim return "Int32"; 2205263508Sdim case BuiltinType::LongLong: 2206263508Sdim return "Int64"; 2207263508Sdim case BuiltinType::UChar: 2208263508Sdim return "Uint8"; 2209263508Sdim case BuiltinType::UShort: 2210263508Sdim return "Uint16"; 2211263508Sdim case BuiltinType::UInt: 2212263508Sdim return "Uint32"; 2213263508Sdim case BuiltinType::ULongLong: 2214263508Sdim return "Uint64"; 2215263508Sdim case BuiltinType::Half: 2216263508Sdim return "Float16"; 2217263508Sdim case BuiltinType::Float: 2218263508Sdim return "Float32"; 2219263508Sdim case BuiltinType::Double: 2220263508Sdim return "Float64"; 2221263508Sdim default: 2222263508Sdim llvm_unreachable("Unexpected vector element base type"); 2223263508Sdim } 2224263508Sdim} 2225263508Sdim 2226263508Sdim// AArch64's ABI for Neon vector types specifies that they should be mangled as 2227263508Sdim// the equivalent internal name. The vector type must be one of the special 2228263508Sdim// types predefined by ARM. 2229263508Sdimvoid CXXNameMangler::mangleAArch64NeonVectorType(const VectorType *T) { 2230263508Sdim QualType EltType = T->getElementType(); 2231263508Sdim assert(EltType->isBuiltinType() && "Neon vector element not a BuiltinType"); 2232263508Sdim unsigned BitSize = 2233263508Sdim (T->getNumElements() * getASTContext().getTypeSize(EltType)); 2234263508Sdim (void)BitSize; // Silence warning. 2235263508Sdim 2236263508Sdim assert((BitSize == 64 || BitSize == 128) && 2237263508Sdim "Neon vector type not 64 or 128 bits"); 2238263508Sdim 2239263508Sdim StringRef EltName; 2240263508Sdim if (T->getVectorKind() == VectorType::NeonPolyVector) { 2241263508Sdim switch (cast<BuiltinType>(EltType)->getKind()) { 2242263508Sdim case BuiltinType::UChar: 2243263508Sdim EltName = "Poly8"; 2244263508Sdim break; 2245263508Sdim case BuiltinType::UShort: 2246263508Sdim EltName = "Poly16"; 2247263508Sdim break; 2248263508Sdim case BuiltinType::ULongLong: 2249263508Sdim EltName = "Poly64"; 2250263508Sdim break; 2251263508Sdim default: 2252263508Sdim llvm_unreachable("unexpected Neon polynomial vector element type"); 2253263508Sdim } 2254263508Sdim } else 2255263508Sdim EltName = mangleAArch64VectorBase(cast<BuiltinType>(EltType)); 2256263508Sdim 2257263508Sdim std::string TypeName = 2258263508Sdim ("__" + EltName + "x" + llvm::utostr(T->getNumElements()) + "_t").str(); 2259263508Sdim Out << TypeName.length() << TypeName; 2260263508Sdim} 2261263508Sdim 2262218887Sdim// GNU extension: vector types 2263218887Sdim// <type> ::= <vector-type> 2264218887Sdim// <vector-type> ::= Dv <positive dimension number> _ 2265218887Sdim// <extended element type> 2266218887Sdim// ::= Dv [<dimension expression>] _ <element type> 2267218887Sdim// <extended element type> ::= <element type> 2268218887Sdim// ::= p # AltiVec vector pixel 2269243830Sdim// ::= b # Altivec vector bool 2270218887Sdimvoid CXXNameMangler::mangleType(const VectorType *T) { 2271218887Sdim if ((T->getVectorKind() == VectorType::NeonVector || 2272218887Sdim T->getVectorKind() == VectorType::NeonPolyVector)) { 2273263508Sdim if (getASTContext().getTargetInfo().getTriple().getArch() == 2274263508Sdim llvm::Triple::aarch64) 2275263508Sdim mangleAArch64NeonVectorType(T); 2276263508Sdim else 2277263508Sdim mangleNeonVectorType(T); 2278218887Sdim return; 2279218887Sdim } 2280218887Sdim Out << "Dv" << T->getNumElements() << '_'; 2281218887Sdim if (T->getVectorKind() == VectorType::AltiVecPixel) 2282218887Sdim Out << 'p'; 2283218887Sdim else if (T->getVectorKind() == VectorType::AltiVecBool) 2284218887Sdim Out << 'b'; 2285218887Sdim else 2286218887Sdim mangleType(T->getElementType()); 2287218887Sdim} 2288218887Sdimvoid CXXNameMangler::mangleType(const ExtVectorType *T) { 2289218887Sdim mangleType(static_cast<const VectorType*>(T)); 2290218887Sdim} 2291218887Sdimvoid CXXNameMangler::mangleType(const DependentSizedExtVectorType *T) { 2292218887Sdim Out << "Dv"; 2293218887Sdim mangleExpression(T->getSizeExpr()); 2294218887Sdim Out << '_'; 2295218887Sdim mangleType(T->getElementType()); 2296218887Sdim} 2297218887Sdim 2298218887Sdimvoid CXXNameMangler::mangleType(const PackExpansionType *T) { 2299218887Sdim // <type> ::= Dp <type> # pack expansion (C++0x) 2300218887Sdim Out << "Dp"; 2301218887Sdim mangleType(T->getPattern()); 2302218887Sdim} 2303218887Sdim 2304218887Sdimvoid CXXNameMangler::mangleType(const ObjCInterfaceType *T) { 2305218887Sdim mangleSourceName(T->getDecl()->getIdentifier()); 2306218887Sdim} 2307218887Sdim 2308218887Sdimvoid CXXNameMangler::mangleType(const ObjCObjectType *T) { 2309263508Sdim if (!T->qual_empty()) { 2310263508Sdim // Mangle protocol qualifiers. 2311263508Sdim SmallString<64> QualStr; 2312263508Sdim llvm::raw_svector_ostream QualOS(QualStr); 2313263508Sdim QualOS << "objcproto"; 2314263508Sdim ObjCObjectType::qual_iterator i = T->qual_begin(), e = T->qual_end(); 2315263508Sdim for ( ; i != e; ++i) { 2316263508Sdim StringRef name = (*i)->getName(); 2317263508Sdim QualOS << name.size() << name; 2318263508Sdim } 2319263508Sdim QualOS.flush(); 2320263508Sdim Out << 'U' << QualStr.size() << QualStr; 2321263508Sdim } 2322218887Sdim mangleType(T->getBaseType()); 2323218887Sdim} 2324218887Sdim 2325218887Sdimvoid CXXNameMangler::mangleType(const BlockPointerType *T) { 2326218887Sdim Out << "U13block_pointer"; 2327218887Sdim mangleType(T->getPointeeType()); 2328218887Sdim} 2329218887Sdim 2330218887Sdimvoid CXXNameMangler::mangleType(const InjectedClassNameType *T) { 2331218887Sdim // Mangle injected class name types as if the user had written the 2332218887Sdim // specialization out fully. It may not actually be possible to see 2333218887Sdim // this mangling, though. 2334218887Sdim mangleType(T->getInjectedSpecializationType()); 2335218887Sdim} 2336218887Sdim 2337218887Sdimvoid CXXNameMangler::mangleType(const TemplateSpecializationType *T) { 2338218887Sdim if (TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl()) { 2339218887Sdim mangleName(TD, T->getArgs(), T->getNumArgs()); 2340218887Sdim } else { 2341218887Sdim if (mangleSubstitution(QualType(T, 0))) 2342218887Sdim return; 2343218887Sdim 2344218887Sdim mangleTemplatePrefix(T->getTemplateName()); 2345218887Sdim 2346218887Sdim // FIXME: GCC does not appear to mangle the template arguments when 2347218887Sdim // the template in question is a dependent template name. Should we 2348218887Sdim // emulate that badness? 2349243830Sdim mangleTemplateArgs(T->getArgs(), T->getNumArgs()); 2350218887Sdim addSubstitution(QualType(T, 0)); 2351218887Sdim } 2352218887Sdim} 2353218887Sdim 2354218887Sdimvoid CXXNameMangler::mangleType(const DependentNameType *T) { 2355218887Sdim // Typename types are always nested 2356218887Sdim Out << 'N'; 2357221345Sdim manglePrefix(T->getQualifier()); 2358218887Sdim mangleSourceName(T->getIdentifier()); 2359218887Sdim Out << 'E'; 2360218887Sdim} 2361218887Sdim 2362218887Sdimvoid CXXNameMangler::mangleType(const DependentTemplateSpecializationType *T) { 2363221345Sdim // Dependently-scoped template types are nested if they have a prefix. 2364218887Sdim Out << 'N'; 2365218887Sdim 2366218887Sdim // TODO: avoid making this TemplateName. 2367218887Sdim TemplateName Prefix = 2368218887Sdim getASTContext().getDependentTemplateName(T->getQualifier(), 2369218887Sdim T->getIdentifier()); 2370218887Sdim mangleTemplatePrefix(Prefix); 2371218887Sdim 2372218887Sdim // FIXME: GCC does not appear to mangle the template arguments when 2373218887Sdim // the template in question is a dependent template name. Should we 2374218887Sdim // emulate that badness? 2375243830Sdim mangleTemplateArgs(T->getArgs(), T->getNumArgs()); 2376218887Sdim Out << 'E'; 2377218887Sdim} 2378218887Sdim 2379218887Sdimvoid CXXNameMangler::mangleType(const TypeOfType *T) { 2380218887Sdim // FIXME: this is pretty unsatisfactory, but there isn't an obvious 2381218887Sdim // "extension with parameters" mangling. 2382218887Sdim Out << "u6typeof"; 2383218887Sdim} 2384218887Sdim 2385218887Sdimvoid CXXNameMangler::mangleType(const TypeOfExprType *T) { 2386218887Sdim // FIXME: this is pretty unsatisfactory, but there isn't an obvious 2387218887Sdim // "extension with parameters" mangling. 2388218887Sdim Out << "u6typeof"; 2389218887Sdim} 2390218887Sdim 2391218887Sdimvoid CXXNameMangler::mangleType(const DecltypeType *T) { 2392218887Sdim Expr *E = T->getUnderlyingExpr(); 2393218887Sdim 2394218887Sdim // type ::= Dt <expression> E # decltype of an id-expression 2395218887Sdim // # or class member access 2396218887Sdim // ::= DT <expression> E # decltype of an expression 2397218887Sdim 2398218887Sdim // This purports to be an exhaustive list of id-expressions and 2399218887Sdim // class member accesses. Note that we do not ignore parentheses; 2400218887Sdim // parentheses change the semantics of decltype for these 2401218887Sdim // expressions (and cause the mangler to use the other form). 2402218887Sdim if (isa<DeclRefExpr>(E) || 2403218887Sdim isa<MemberExpr>(E) || 2404218887Sdim isa<UnresolvedLookupExpr>(E) || 2405218887Sdim isa<DependentScopeDeclRefExpr>(E) || 2406218887Sdim isa<CXXDependentScopeMemberExpr>(E) || 2407218887Sdim isa<UnresolvedMemberExpr>(E)) 2408218887Sdim Out << "Dt"; 2409218887Sdim else 2410218887Sdim Out << "DT"; 2411218887Sdim mangleExpression(E); 2412218887Sdim Out << 'E'; 2413218887Sdim} 2414218887Sdim 2415223017Sdimvoid CXXNameMangler::mangleType(const UnaryTransformType *T) { 2416223017Sdim // If this is dependent, we need to record that. If not, we simply 2417223017Sdim // mangle it as the underlying type since they are equivalent. 2418223017Sdim if (T->isDependentType()) { 2419223017Sdim Out << 'U'; 2420223017Sdim 2421223017Sdim switch (T->getUTTKind()) { 2422223017Sdim case UnaryTransformType::EnumUnderlyingType: 2423223017Sdim Out << "3eut"; 2424223017Sdim break; 2425223017Sdim } 2426223017Sdim } 2427223017Sdim 2428223017Sdim mangleType(T->getUnderlyingType()); 2429223017Sdim} 2430223017Sdim 2431218887Sdimvoid CXXNameMangler::mangleType(const AutoType *T) { 2432218887Sdim QualType D = T->getDeducedType(); 2433219077Sdim // <builtin-type> ::= Da # dependent auto 2434219077Sdim if (D.isNull()) 2435251662Sdim Out << (T->isDecltypeAuto() ? "Dc" : "Da"); 2436219077Sdim else 2437219077Sdim mangleType(D); 2438218887Sdim} 2439218887Sdim 2440226633Sdimvoid CXXNameMangler::mangleType(const AtomicType *T) { 2441226633Sdim // <type> ::= U <source-name> <type> # vendor extended type qualifier 2442226633Sdim // (Until there's a standardized mangling...) 2443226633Sdim Out << "U7_Atomic"; 2444226633Sdim mangleType(T->getValueType()); 2445226633Sdim} 2446226633Sdim 2447218887Sdimvoid CXXNameMangler::mangleIntegerLiteral(QualType T, 2448218887Sdim const llvm::APSInt &Value) { 2449218887Sdim // <expr-primary> ::= L <type> <value number> E # integer literal 2450218887Sdim Out << 'L'; 2451218887Sdim 2452218887Sdim mangleType(T); 2453218887Sdim if (T->isBooleanType()) { 2454218887Sdim // Boolean values are encoded as 0/1. 2455218887Sdim Out << (Value.getBoolValue() ? '1' : '0'); 2456218887Sdim } else { 2457218887Sdim mangleNumber(Value); 2458218887Sdim } 2459218887Sdim Out << 'E'; 2460218887Sdim 2461218887Sdim} 2462218887Sdim 2463234982Sdim/// Mangles a member expression. 2464221345Sdimvoid CXXNameMangler::mangleMemberExpr(const Expr *base, 2465221345Sdim bool isArrow, 2466221345Sdim NestedNameSpecifier *qualifier, 2467221345Sdim NamedDecl *firstQualifierLookup, 2468221345Sdim DeclarationName member, 2469221345Sdim unsigned arity) { 2470221345Sdim // <expression> ::= dt <expression> <unresolved-name> 2471221345Sdim // ::= pt <expression> <unresolved-name> 2472234982Sdim if (base) { 2473234982Sdim if (base->isImplicitCXXThis()) { 2474234982Sdim // Note: GCC mangles member expressions to the implicit 'this' as 2475234982Sdim // *this., whereas we represent them as this->. The Itanium C++ ABI 2476234982Sdim // does not specify anything here, so we follow GCC. 2477234982Sdim Out << "dtdefpT"; 2478234982Sdim } else { 2479234982Sdim Out << (isArrow ? "pt" : "dt"); 2480234982Sdim mangleExpression(base); 2481234982Sdim } 2482234982Sdim } 2483221345Sdim mangleUnresolvedName(qualifier, firstQualifierLookup, member, arity); 2484218887Sdim} 2485218887Sdim 2486221345Sdim/// Look at the callee of the given call expression and determine if 2487221345Sdim/// it's a parenthesized id-expression which would have triggered ADL 2488221345Sdim/// otherwise. 2489221345Sdimstatic bool isParenthesizedADLCallee(const CallExpr *call) { 2490221345Sdim const Expr *callee = call->getCallee(); 2491221345Sdim const Expr *fn = callee->IgnoreParens(); 2492221345Sdim 2493221345Sdim // Must be parenthesized. IgnoreParens() skips __extension__ nodes, 2494221345Sdim // too, but for those to appear in the callee, it would have to be 2495221345Sdim // parenthesized. 2496221345Sdim if (callee == fn) return false; 2497221345Sdim 2498221345Sdim // Must be an unresolved lookup. 2499221345Sdim const UnresolvedLookupExpr *lookup = dyn_cast<UnresolvedLookupExpr>(fn); 2500221345Sdim if (!lookup) return false; 2501221345Sdim 2502221345Sdim assert(!lookup->requiresADL()); 2503221345Sdim 2504221345Sdim // Must be an unqualified lookup. 2505221345Sdim if (lookup->getQualifier()) return false; 2506221345Sdim 2507221345Sdim // Must not have found a class member. Note that if one is a class 2508221345Sdim // member, they're all class members. 2509221345Sdim if (lookup->getNumDecls() > 0 && 2510221345Sdim (*lookup->decls_begin())->isCXXClassMember()) 2511221345Sdim return false; 2512221345Sdim 2513221345Sdim // Otherwise, ADL would have been triggered. 2514221345Sdim return true; 2515221345Sdim} 2516221345Sdim 2517218887Sdimvoid CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity) { 2518218887Sdim // <expression> ::= <unary operator-name> <expression> 2519218887Sdim // ::= <binary operator-name> <expression> <expression> 2520218887Sdim // ::= <trinary operator-name> <expression> <expression> <expression> 2521218887Sdim // ::= cv <type> expression # conversion with one argument 2522218887Sdim // ::= cv <type> _ <expression>* E # conversion with a different number of arguments 2523218887Sdim // ::= st <type> # sizeof (a type) 2524218887Sdim // ::= at <type> # alignof (a type) 2525218887Sdim // ::= <template-param> 2526218887Sdim // ::= <function-param> 2527218887Sdim // ::= sr <type> <unqualified-name> # dependent name 2528218887Sdim // ::= sr <type> <unqualified-name> <template-args> # dependent template-id 2529223017Sdim // ::= ds <expression> <expression> # expr.*expr 2530218887Sdim // ::= sZ <template-param> # size of a parameter pack 2531218887Sdim // ::= sZ <function-param> # size of a function parameter pack 2532218887Sdim // ::= <expr-primary> 2533218887Sdim // <expr-primary> ::= L <type> <value number> E # integer literal 2534218887Sdim // ::= L <type <value float> E # floating literal 2535218887Sdim // ::= L <mangled-name> E # external name 2536234982Sdim // ::= fpT # 'this' expression 2537224145Sdim QualType ImplicitlyConvertedToType; 2538224145Sdim 2539224145Sdimrecurse: 2540218887Sdim switch (E->getStmtClass()) { 2541218887Sdim case Expr::NoStmtClass: 2542218887Sdim#define ABSTRACT_STMT(Type) 2543218887Sdim#define EXPR(Type, Base) 2544218887Sdim#define STMT(Type, Base) \ 2545218887Sdim case Expr::Type##Class: 2546218887Sdim#include "clang/AST/StmtNodes.inc" 2547218887Sdim // fallthrough 2548218887Sdim 2549218887Sdim // These all can only appear in local or variable-initialization 2550218887Sdim // contexts and so should never appear in a mangling. 2551218887Sdim case Expr::AddrLabelExprClass: 2552218887Sdim case Expr::DesignatedInitExprClass: 2553218887Sdim case Expr::ImplicitValueInitExprClass: 2554218887Sdim case Expr::ParenListExprClass: 2555234353Sdim case Expr::LambdaExprClass: 2556251662Sdim case Expr::MSPropertyRefExprClass: 2557218887Sdim llvm_unreachable("unexpected statement kind"); 2558218887Sdim 2559218887Sdim // FIXME: invent manglings for all these. 2560218887Sdim case Expr::BlockExprClass: 2561218887Sdim case Expr::CXXPseudoDestructorExprClass: 2562218887Sdim case Expr::ChooseExprClass: 2563218887Sdim case Expr::CompoundLiteralExprClass: 2564218887Sdim case Expr::ExtVectorElementExprClass: 2565221345Sdim case Expr::GenericSelectionExprClass: 2566218887Sdim case Expr::ObjCEncodeExprClass: 2567218887Sdim case Expr::ObjCIsaExprClass: 2568218887Sdim case Expr::ObjCIvarRefExprClass: 2569218887Sdim case Expr::ObjCMessageExprClass: 2570218887Sdim case Expr::ObjCPropertyRefExprClass: 2571218887Sdim case Expr::ObjCProtocolExprClass: 2572218887Sdim case Expr::ObjCSelectorExprClass: 2573218887Sdim case Expr::ObjCStringLiteralClass: 2574239462Sdim case Expr::ObjCBoxedExprClass: 2575234353Sdim case Expr::ObjCArrayLiteralClass: 2576234353Sdim case Expr::ObjCDictionaryLiteralClass: 2577234353Sdim case Expr::ObjCSubscriptRefExprClass: 2578224145Sdim case Expr::ObjCIndirectCopyRestoreExprClass: 2579218887Sdim case Expr::OffsetOfExprClass: 2580218887Sdim case Expr::PredefinedExprClass: 2581218887Sdim case Expr::ShuffleVectorExprClass: 2582263508Sdim case Expr::ConvertVectorExprClass: 2583218887Sdim case Expr::StmtExprClass: 2584218887Sdim case Expr::UnaryTypeTraitExprClass: 2585218887Sdim case Expr::BinaryTypeTraitExprClass: 2586234353Sdim case Expr::TypeTraitExprClass: 2587221345Sdim case Expr::ArrayTypeTraitExprClass: 2588221345Sdim case Expr::ExpressionTraitExprClass: 2589218887Sdim case Expr::VAArgExprClass: 2590218887Sdim case Expr::CXXUuidofExprClass: 2591223017Sdim case Expr::CUDAKernelCallExprClass: 2592223017Sdim case Expr::AsTypeExprClass: 2593234353Sdim case Expr::PseudoObjectExprClass: 2594226633Sdim case Expr::AtomicExprClass: 2595223017Sdim { 2596218887Sdim // As bad as this diagnostic is, it's better than crashing. 2597226633Sdim DiagnosticsEngine &Diags = Context.getDiags(); 2598226633Sdim unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2599218887Sdim "cannot yet mangle expression type %0"); 2600218887Sdim Diags.Report(E->getExprLoc(), DiagID) 2601218887Sdim << E->getStmtClassName() << E->getSourceRange(); 2602218887Sdim break; 2603218887Sdim } 2604218887Sdim 2605218887Sdim // Even gcc-4.5 doesn't mangle this. 2606218887Sdim case Expr::BinaryConditionalOperatorClass: { 2607226633Sdim DiagnosticsEngine &Diags = Context.getDiags(); 2608218887Sdim unsigned DiagID = 2609226633Sdim Diags.getCustomDiagID(DiagnosticsEngine::Error, 2610218887Sdim "?: operator with omitted middle operand cannot be mangled"); 2611218887Sdim Diags.Report(E->getExprLoc(), DiagID) 2612218887Sdim << E->getStmtClassName() << E->getSourceRange(); 2613218887Sdim break; 2614218887Sdim } 2615218887Sdim 2616218887Sdim // These are used for internal purposes and cannot be meaningfully mangled. 2617218887Sdim case Expr::OpaqueValueExprClass: 2618218887Sdim llvm_unreachable("cannot mangle opaque value; mangling wrong thing?"); 2619218887Sdim 2620234353Sdim case Expr::InitListExprClass: { 2621234353Sdim // Proposal by Jason Merrill, 2012-01-03 2622234353Sdim Out << "il"; 2623234353Sdim const InitListExpr *InitList = cast<InitListExpr>(E); 2624234353Sdim for (unsigned i = 0, e = InitList->getNumInits(); i != e; ++i) 2625234353Sdim mangleExpression(InitList->getInit(i)); 2626234353Sdim Out << "E"; 2627234353Sdim break; 2628234353Sdim } 2629234353Sdim 2630218887Sdim case Expr::CXXDefaultArgExprClass: 2631218887Sdim mangleExpression(cast<CXXDefaultArgExpr>(E)->getExpr(), Arity); 2632218887Sdim break; 2633218887Sdim 2634251662Sdim case Expr::CXXDefaultInitExprClass: 2635251662Sdim mangleExpression(cast<CXXDefaultInitExpr>(E)->getExpr(), Arity); 2636251662Sdim break; 2637251662Sdim 2638263508Sdim case Expr::CXXStdInitializerListExprClass: 2639263508Sdim mangleExpression(cast<CXXStdInitializerListExpr>(E)->getSubExpr(), Arity); 2640263508Sdim break; 2641263508Sdim 2642224145Sdim case Expr::SubstNonTypeTemplateParmExprClass: 2643224145Sdim mangleExpression(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(), 2644224145Sdim Arity); 2645224145Sdim break; 2646224145Sdim 2647234353Sdim case Expr::UserDefinedLiteralClass: 2648234353Sdim // We follow g++'s approach of mangling a UDL as a call to the literal 2649234353Sdim // operator. 2650218887Sdim case Expr::CXXMemberCallExprClass: // fallthrough 2651218887Sdim case Expr::CallExprClass: { 2652218887Sdim const CallExpr *CE = cast<CallExpr>(E); 2653221345Sdim 2654221345Sdim // <expression> ::= cp <simple-id> <expression>* E 2655221345Sdim // We use this mangling only when the call would use ADL except 2656221345Sdim // for being parenthesized. Per discussion with David 2657221345Sdim // Vandervoorde, 2011.04.25. 2658221345Sdim if (isParenthesizedADLCallee(CE)) { 2659221345Sdim Out << "cp"; 2660221345Sdim // The callee here is a parenthesized UnresolvedLookupExpr with 2661221345Sdim // no qualifier and should always get mangled as a <simple-id> 2662221345Sdim // anyway. 2663221345Sdim 2664221345Sdim // <expression> ::= cl <expression>* E 2665221345Sdim } else { 2666221345Sdim Out << "cl"; 2667221345Sdim } 2668221345Sdim 2669218887Sdim mangleExpression(CE->getCallee(), CE->getNumArgs()); 2670218887Sdim for (unsigned I = 0, N = CE->getNumArgs(); I != N; ++I) 2671218887Sdim mangleExpression(CE->getArg(I)); 2672218887Sdim Out << 'E'; 2673218887Sdim break; 2674218887Sdim } 2675218887Sdim 2676218887Sdim case Expr::CXXNewExprClass: { 2677218887Sdim const CXXNewExpr *New = cast<CXXNewExpr>(E); 2678218887Sdim if (New->isGlobalNew()) Out << "gs"; 2679218887Sdim Out << (New->isArray() ? "na" : "nw"); 2680218887Sdim for (CXXNewExpr::const_arg_iterator I = New->placement_arg_begin(), 2681218887Sdim E = New->placement_arg_end(); I != E; ++I) 2682218887Sdim mangleExpression(*I); 2683218887Sdim Out << '_'; 2684218887Sdim mangleType(New->getAllocatedType()); 2685218887Sdim if (New->hasInitializer()) { 2686234353Sdim // Proposal by Jason Merrill, 2012-01-03 2687234353Sdim if (New->getInitializationStyle() == CXXNewExpr::ListInit) 2688234353Sdim Out << "il"; 2689234353Sdim else 2690234353Sdim Out << "pi"; 2691234353Sdim const Expr *Init = New->getInitializer(); 2692234353Sdim if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) { 2693234353Sdim // Directly inline the initializers. 2694234353Sdim for (CXXConstructExpr::const_arg_iterator I = CCE->arg_begin(), 2695234353Sdim E = CCE->arg_end(); 2696234353Sdim I != E; ++I) 2697234353Sdim mangleExpression(*I); 2698234353Sdim } else if (const ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init)) { 2699234353Sdim for (unsigned i = 0, e = PLE->getNumExprs(); i != e; ++i) 2700234353Sdim mangleExpression(PLE->getExpr(i)); 2701234353Sdim } else if (New->getInitializationStyle() == CXXNewExpr::ListInit && 2702234353Sdim isa<InitListExpr>(Init)) { 2703234353Sdim // Only take InitListExprs apart for list-initialization. 2704234353Sdim const InitListExpr *InitList = cast<InitListExpr>(Init); 2705234353Sdim for (unsigned i = 0, e = InitList->getNumInits(); i != e; ++i) 2706234353Sdim mangleExpression(InitList->getInit(i)); 2707234353Sdim } else 2708234353Sdim mangleExpression(Init); 2709218887Sdim } 2710218887Sdim Out << 'E'; 2711218887Sdim break; 2712218887Sdim } 2713218887Sdim 2714218887Sdim case Expr::MemberExprClass: { 2715218887Sdim const MemberExpr *ME = cast<MemberExpr>(E); 2716218887Sdim mangleMemberExpr(ME->getBase(), ME->isArrow(), 2717221345Sdim ME->getQualifier(), 0, ME->getMemberDecl()->getDeclName(), 2718218887Sdim Arity); 2719218887Sdim break; 2720218887Sdim } 2721218887Sdim 2722218887Sdim case Expr::UnresolvedMemberExprClass: { 2723218887Sdim const UnresolvedMemberExpr *ME = cast<UnresolvedMemberExpr>(E); 2724218887Sdim mangleMemberExpr(ME->getBase(), ME->isArrow(), 2725221345Sdim ME->getQualifier(), 0, ME->getMemberName(), 2726218887Sdim Arity); 2727218887Sdim if (ME->hasExplicitTemplateArgs()) 2728218887Sdim mangleTemplateArgs(ME->getExplicitTemplateArgs()); 2729218887Sdim break; 2730218887Sdim } 2731218887Sdim 2732218887Sdim case Expr::CXXDependentScopeMemberExprClass: { 2733218887Sdim const CXXDependentScopeMemberExpr *ME 2734218887Sdim = cast<CXXDependentScopeMemberExpr>(E); 2735218887Sdim mangleMemberExpr(ME->getBase(), ME->isArrow(), 2736221345Sdim ME->getQualifier(), ME->getFirstQualifierFoundInScope(), 2737221345Sdim ME->getMember(), Arity); 2738218887Sdim if (ME->hasExplicitTemplateArgs()) 2739218887Sdim mangleTemplateArgs(ME->getExplicitTemplateArgs()); 2740218887Sdim break; 2741218887Sdim } 2742218887Sdim 2743218887Sdim case Expr::UnresolvedLookupExprClass: { 2744218887Sdim const UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(E); 2745221345Sdim mangleUnresolvedName(ULE->getQualifier(), 0, ULE->getName(), Arity); 2746224145Sdim 2747224145Sdim // All the <unresolved-name> productions end in a 2748224145Sdim // base-unresolved-name, where <template-args> are just tacked 2749224145Sdim // onto the end. 2750218887Sdim if (ULE->hasExplicitTemplateArgs()) 2751218887Sdim mangleTemplateArgs(ULE->getExplicitTemplateArgs()); 2752218887Sdim break; 2753218887Sdim } 2754218887Sdim 2755218887Sdim case Expr::CXXUnresolvedConstructExprClass: { 2756218887Sdim const CXXUnresolvedConstructExpr *CE = cast<CXXUnresolvedConstructExpr>(E); 2757218887Sdim unsigned N = CE->arg_size(); 2758218887Sdim 2759218887Sdim Out << "cv"; 2760218887Sdim mangleType(CE->getType()); 2761218887Sdim if (N != 1) Out << '_'; 2762218887Sdim for (unsigned I = 0; I != N; ++I) mangleExpression(CE->getArg(I)); 2763218887Sdim if (N != 1) Out << 'E'; 2764218887Sdim break; 2765218887Sdim } 2766218887Sdim 2767218887Sdim case Expr::CXXTemporaryObjectExprClass: 2768218887Sdim case Expr::CXXConstructExprClass: { 2769218887Sdim const CXXConstructExpr *CE = cast<CXXConstructExpr>(E); 2770218887Sdim unsigned N = CE->getNumArgs(); 2771218887Sdim 2772234353Sdim // Proposal by Jason Merrill, 2012-01-03 2773234353Sdim if (CE->isListInitialization()) 2774234353Sdim Out << "tl"; 2775234353Sdim else 2776234353Sdim Out << "cv"; 2777218887Sdim mangleType(CE->getType()); 2778218887Sdim if (N != 1) Out << '_'; 2779218887Sdim for (unsigned I = 0; I != N; ++I) mangleExpression(CE->getArg(I)); 2780218887Sdim if (N != 1) Out << 'E'; 2781218887Sdim break; 2782218887Sdim } 2783218887Sdim 2784234353Sdim case Expr::CXXScalarValueInitExprClass: 2785234353Sdim Out <<"cv"; 2786234353Sdim mangleType(E->getType()); 2787234353Sdim Out <<"_E"; 2788234353Sdim break; 2789234353Sdim 2790243830Sdim case Expr::CXXNoexceptExprClass: 2791243830Sdim Out << "nx"; 2792243830Sdim mangleExpression(cast<CXXNoexceptExpr>(E)->getOperand()); 2793243830Sdim break; 2794243830Sdim 2795221345Sdim case Expr::UnaryExprOrTypeTraitExprClass: { 2796221345Sdim const UnaryExprOrTypeTraitExpr *SAE = cast<UnaryExprOrTypeTraitExpr>(E); 2797224145Sdim 2798224145Sdim if (!SAE->isInstantiationDependent()) { 2799224145Sdim // Itanium C++ ABI: 2800224145Sdim // If the operand of a sizeof or alignof operator is not 2801224145Sdim // instantiation-dependent it is encoded as an integer literal 2802224145Sdim // reflecting the result of the operator. 2803224145Sdim // 2804224145Sdim // If the result of the operator is implicitly converted to a known 2805224145Sdim // integer type, that type is used for the literal; otherwise, the type 2806224145Sdim // of std::size_t or std::ptrdiff_t is used. 2807224145Sdim QualType T = (ImplicitlyConvertedToType.isNull() || 2808224145Sdim !ImplicitlyConvertedToType->isIntegerType())? SAE->getType() 2809224145Sdim : ImplicitlyConvertedToType; 2810226633Sdim llvm::APSInt V = SAE->EvaluateKnownConstInt(Context.getASTContext()); 2811226633Sdim mangleIntegerLiteral(T, V); 2812224145Sdim break; 2813224145Sdim } 2814224145Sdim 2815221345Sdim switch(SAE->getKind()) { 2816221345Sdim case UETT_SizeOf: 2817221345Sdim Out << 's'; 2818221345Sdim break; 2819221345Sdim case UETT_AlignOf: 2820221345Sdim Out << 'a'; 2821221345Sdim break; 2822221345Sdim case UETT_VecStep: 2823226633Sdim DiagnosticsEngine &Diags = Context.getDiags(); 2824226633Sdim unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2825221345Sdim "cannot yet mangle vec_step expression"); 2826221345Sdim Diags.Report(DiagID); 2827221345Sdim return; 2828221345Sdim } 2829218887Sdim if (SAE->isArgumentType()) { 2830218887Sdim Out << 't'; 2831218887Sdim mangleType(SAE->getArgumentType()); 2832218887Sdim } else { 2833218887Sdim Out << 'z'; 2834218887Sdim mangleExpression(SAE->getArgumentExpr()); 2835218887Sdim } 2836218887Sdim break; 2837218887Sdim } 2838218887Sdim 2839218887Sdim case Expr::CXXThrowExprClass: { 2840218887Sdim const CXXThrowExpr *TE = cast<CXXThrowExpr>(E); 2841263508Sdim // <expression> ::= tw <expression> # throw expression 2842263508Sdim // ::= tr # rethrow 2843218887Sdim if (TE->getSubExpr()) { 2844218887Sdim Out << "tw"; 2845218887Sdim mangleExpression(TE->getSubExpr()); 2846218887Sdim } else { 2847218887Sdim Out << "tr"; 2848218887Sdim } 2849218887Sdim break; 2850218887Sdim } 2851218887Sdim 2852218887Sdim case Expr::CXXTypeidExprClass: { 2853218887Sdim const CXXTypeidExpr *TIE = cast<CXXTypeidExpr>(E); 2854263508Sdim // <expression> ::= ti <type> # typeid (type) 2855263508Sdim // ::= te <expression> # typeid (expression) 2856218887Sdim if (TIE->isTypeOperand()) { 2857218887Sdim Out << "ti"; 2858263508Sdim mangleType(TIE->getTypeOperand(Context.getASTContext())); 2859218887Sdim } else { 2860218887Sdim Out << "te"; 2861218887Sdim mangleExpression(TIE->getExprOperand()); 2862218887Sdim } 2863218887Sdim break; 2864218887Sdim } 2865218887Sdim 2866218887Sdim case Expr::CXXDeleteExprClass: { 2867218887Sdim const CXXDeleteExpr *DE = cast<CXXDeleteExpr>(E); 2868263508Sdim // <expression> ::= [gs] dl <expression> # [::] delete expr 2869263508Sdim // ::= [gs] da <expression> # [::] delete [] expr 2870218887Sdim if (DE->isGlobalDelete()) Out << "gs"; 2871218887Sdim Out << (DE->isArrayForm() ? "da" : "dl"); 2872218887Sdim mangleExpression(DE->getArgument()); 2873218887Sdim break; 2874218887Sdim } 2875218887Sdim 2876218887Sdim case Expr::UnaryOperatorClass: { 2877218887Sdim const UnaryOperator *UO = cast<UnaryOperator>(E); 2878218887Sdim mangleOperatorName(UnaryOperator::getOverloadedOperator(UO->getOpcode()), 2879218887Sdim /*Arity=*/1); 2880218887Sdim mangleExpression(UO->getSubExpr()); 2881218887Sdim break; 2882218887Sdim } 2883218887Sdim 2884218887Sdim case Expr::ArraySubscriptExprClass: { 2885218887Sdim const ArraySubscriptExpr *AE = cast<ArraySubscriptExpr>(E); 2886218887Sdim 2887221345Sdim // Array subscript is treated as a syntactically weird form of 2888218887Sdim // binary operator. 2889218887Sdim Out << "ix"; 2890218887Sdim mangleExpression(AE->getLHS()); 2891218887Sdim mangleExpression(AE->getRHS()); 2892218887Sdim break; 2893218887Sdim } 2894218887Sdim 2895218887Sdim case Expr::CompoundAssignOperatorClass: // fallthrough 2896218887Sdim case Expr::BinaryOperatorClass: { 2897218887Sdim const BinaryOperator *BO = cast<BinaryOperator>(E); 2898223017Sdim if (BO->getOpcode() == BO_PtrMemD) 2899223017Sdim Out << "ds"; 2900223017Sdim else 2901223017Sdim mangleOperatorName(BinaryOperator::getOverloadedOperator(BO->getOpcode()), 2902223017Sdim /*Arity=*/2); 2903218887Sdim mangleExpression(BO->getLHS()); 2904218887Sdim mangleExpression(BO->getRHS()); 2905218887Sdim break; 2906218887Sdim } 2907218887Sdim 2908218887Sdim case Expr::ConditionalOperatorClass: { 2909218887Sdim const ConditionalOperator *CO = cast<ConditionalOperator>(E); 2910218887Sdim mangleOperatorName(OO_Conditional, /*Arity=*/3); 2911218887Sdim mangleExpression(CO->getCond()); 2912218887Sdim mangleExpression(CO->getLHS(), Arity); 2913218887Sdim mangleExpression(CO->getRHS(), Arity); 2914218887Sdim break; 2915218887Sdim } 2916218887Sdim 2917218887Sdim case Expr::ImplicitCastExprClass: { 2918224145Sdim ImplicitlyConvertedToType = E->getType(); 2919224145Sdim E = cast<ImplicitCastExpr>(E)->getSubExpr(); 2920224145Sdim goto recurse; 2921218887Sdim } 2922224145Sdim 2923224145Sdim case Expr::ObjCBridgedCastExprClass: { 2924224145Sdim // Mangle ownership casts as a vendor extended operator __bridge, 2925224145Sdim // __bridge_transfer, or __bridge_retain. 2926226633Sdim StringRef Kind = cast<ObjCBridgedCastExpr>(E)->getBridgeKindName(); 2927224145Sdim Out << "v1U" << Kind.size() << Kind; 2928224145Sdim } 2929224145Sdim // Fall through to mangle the cast itself. 2930224145Sdim 2931218887Sdim case Expr::CStyleCastExprClass: 2932218887Sdim case Expr::CXXStaticCastExprClass: 2933218887Sdim case Expr::CXXDynamicCastExprClass: 2934218887Sdim case Expr::CXXReinterpretCastExprClass: 2935218887Sdim case Expr::CXXConstCastExprClass: 2936218887Sdim case Expr::CXXFunctionalCastExprClass: { 2937218887Sdim const ExplicitCastExpr *ECE = cast<ExplicitCastExpr>(E); 2938218887Sdim Out << "cv"; 2939218887Sdim mangleType(ECE->getType()); 2940218887Sdim mangleExpression(ECE->getSubExpr()); 2941218887Sdim break; 2942218887Sdim } 2943218887Sdim 2944218887Sdim case Expr::CXXOperatorCallExprClass: { 2945218887Sdim const CXXOperatorCallExpr *CE = cast<CXXOperatorCallExpr>(E); 2946218887Sdim unsigned NumArgs = CE->getNumArgs(); 2947218887Sdim mangleOperatorName(CE->getOperator(), /*Arity=*/NumArgs); 2948218887Sdim // Mangle the arguments. 2949218887Sdim for (unsigned i = 0; i != NumArgs; ++i) 2950218887Sdim mangleExpression(CE->getArg(i)); 2951218887Sdim break; 2952218887Sdim } 2953218887Sdim 2954218887Sdim case Expr::ParenExprClass: 2955218887Sdim mangleExpression(cast<ParenExpr>(E)->getSubExpr(), Arity); 2956218887Sdim break; 2957218887Sdim 2958218887Sdim case Expr::DeclRefExprClass: { 2959218887Sdim const NamedDecl *D = cast<DeclRefExpr>(E)->getDecl(); 2960218887Sdim 2961218887Sdim switch (D->getKind()) { 2962218887Sdim default: 2963218887Sdim // <expr-primary> ::= L <mangled-name> E # external name 2964218887Sdim Out << 'L'; 2965218887Sdim mangle(D, "_Z"); 2966218887Sdim Out << 'E'; 2967218887Sdim break; 2968218887Sdim 2969221345Sdim case Decl::ParmVar: 2970221345Sdim mangleFunctionParam(cast<ParmVarDecl>(D)); 2971221345Sdim break; 2972221345Sdim 2973218887Sdim case Decl::EnumConstant: { 2974218887Sdim const EnumConstantDecl *ED = cast<EnumConstantDecl>(D); 2975218887Sdim mangleIntegerLiteral(ED->getType(), ED->getInitVal()); 2976218887Sdim break; 2977218887Sdim } 2978218887Sdim 2979218887Sdim case Decl::NonTypeTemplateParm: { 2980218887Sdim const NonTypeTemplateParmDecl *PD = cast<NonTypeTemplateParmDecl>(D); 2981218887Sdim mangleTemplateParameter(PD->getIndex()); 2982218887Sdim break; 2983218887Sdim } 2984218887Sdim 2985218887Sdim } 2986218887Sdim 2987218887Sdim break; 2988218887Sdim } 2989218887Sdim 2990218887Sdim case Expr::SubstNonTypeTemplateParmPackExprClass: 2991224145Sdim // FIXME: not clear how to mangle this! 2992224145Sdim // template <unsigned N...> class A { 2993224145Sdim // template <class U...> void foo(U (&x)[N]...); 2994224145Sdim // }; 2995224145Sdim Out << "_SUBSTPACK_"; 2996218887Sdim break; 2997243830Sdim 2998243830Sdim case Expr::FunctionParmPackExprClass: { 2999243830Sdim // FIXME: not clear how to mangle this! 3000243830Sdim const FunctionParmPackExpr *FPPE = cast<FunctionParmPackExpr>(E); 3001243830Sdim Out << "v110_SUBSTPACK"; 3002243830Sdim mangleFunctionParam(FPPE->getParameterPack()); 3003243830Sdim break; 3004243830Sdim } 3005243830Sdim 3006218887Sdim case Expr::DependentScopeDeclRefExprClass: { 3007218887Sdim const DependentScopeDeclRefExpr *DRE = cast<DependentScopeDeclRefExpr>(E); 3008224145Sdim mangleUnresolvedName(DRE->getQualifier(), 0, DRE->getDeclName(), Arity); 3009218887Sdim 3010224145Sdim // All the <unresolved-name> productions end in a 3011224145Sdim // base-unresolved-name, where <template-args> are just tacked 3012224145Sdim // onto the end. 3013218887Sdim if (DRE->hasExplicitTemplateArgs()) 3014218887Sdim mangleTemplateArgs(DRE->getExplicitTemplateArgs()); 3015218887Sdim break; 3016218887Sdim } 3017218887Sdim 3018218887Sdim case Expr::CXXBindTemporaryExprClass: 3019218887Sdim mangleExpression(cast<CXXBindTemporaryExpr>(E)->getSubExpr()); 3020218887Sdim break; 3021218887Sdim 3022218887Sdim case Expr::ExprWithCleanupsClass: 3023218887Sdim mangleExpression(cast<ExprWithCleanups>(E)->getSubExpr(), Arity); 3024218887Sdim break; 3025218887Sdim 3026218887Sdim case Expr::FloatingLiteralClass: { 3027218887Sdim const FloatingLiteral *FL = cast<FloatingLiteral>(E); 3028218887Sdim Out << 'L'; 3029218887Sdim mangleType(FL->getType()); 3030218887Sdim mangleFloat(FL->getValue()); 3031218887Sdim Out << 'E'; 3032218887Sdim break; 3033218887Sdim } 3034218887Sdim 3035218887Sdim case Expr::CharacterLiteralClass: 3036218887Sdim Out << 'L'; 3037218887Sdim mangleType(E->getType()); 3038218887Sdim Out << cast<CharacterLiteral>(E)->getValue(); 3039218887Sdim Out << 'E'; 3040218887Sdim break; 3041218887Sdim 3042234353Sdim // FIXME. __objc_yes/__objc_no are mangled same as true/false 3043234353Sdim case Expr::ObjCBoolLiteralExprClass: 3044234353Sdim Out << "Lb"; 3045234353Sdim Out << (cast<ObjCBoolLiteralExpr>(E)->getValue() ? '1' : '0'); 3046234353Sdim Out << 'E'; 3047234353Sdim break; 3048234353Sdim 3049218887Sdim case Expr::CXXBoolLiteralExprClass: 3050218887Sdim Out << "Lb"; 3051218887Sdim Out << (cast<CXXBoolLiteralExpr>(E)->getValue() ? '1' : '0'); 3052218887Sdim Out << 'E'; 3053218887Sdim break; 3054218887Sdim 3055218887Sdim case Expr::IntegerLiteralClass: { 3056218887Sdim llvm::APSInt Value(cast<IntegerLiteral>(E)->getValue()); 3057218887Sdim if (E->getType()->isSignedIntegerType()) 3058218887Sdim Value.setIsSigned(true); 3059218887Sdim mangleIntegerLiteral(E->getType(), Value); 3060218887Sdim break; 3061218887Sdim } 3062218887Sdim 3063218887Sdim case Expr::ImaginaryLiteralClass: { 3064218887Sdim const ImaginaryLiteral *IE = cast<ImaginaryLiteral>(E); 3065218887Sdim // Mangle as if a complex literal. 3066218887Sdim // Proposal from David Vandevoorde, 2010.06.30. 3067218887Sdim Out << 'L'; 3068218887Sdim mangleType(E->getType()); 3069218887Sdim if (const FloatingLiteral *Imag = 3070218887Sdim dyn_cast<FloatingLiteral>(IE->getSubExpr())) { 3071218887Sdim // Mangle a floating-point zero of the appropriate type. 3072218887Sdim mangleFloat(llvm::APFloat(Imag->getValue().getSemantics())); 3073218887Sdim Out << '_'; 3074218887Sdim mangleFloat(Imag->getValue()); 3075218887Sdim } else { 3076218887Sdim Out << "0_"; 3077218887Sdim llvm::APSInt Value(cast<IntegerLiteral>(IE->getSubExpr())->getValue()); 3078218887Sdim if (IE->getSubExpr()->getType()->isSignedIntegerType()) 3079218887Sdim Value.setIsSigned(true); 3080218887Sdim mangleNumber(Value); 3081218887Sdim } 3082218887Sdim Out << 'E'; 3083218887Sdim break; 3084218887Sdim } 3085218887Sdim 3086218887Sdim case Expr::StringLiteralClass: { 3087218887Sdim // Revised proposal from David Vandervoorde, 2010.07.15. 3088218887Sdim Out << 'L'; 3089218887Sdim assert(isa<ConstantArrayType>(E->getType())); 3090218887Sdim mangleType(E->getType()); 3091218887Sdim Out << 'E'; 3092218887Sdim break; 3093218887Sdim } 3094218887Sdim 3095218887Sdim case Expr::GNUNullExprClass: 3096218887Sdim // FIXME: should this really be mangled the same as nullptr? 3097218887Sdim // fallthrough 3098218887Sdim 3099218887Sdim case Expr::CXXNullPtrLiteralExprClass: { 3100218887Sdim Out << "LDnE"; 3101218887Sdim break; 3102218887Sdim } 3103218887Sdim 3104218887Sdim case Expr::PackExpansionExprClass: 3105218887Sdim Out << "sp"; 3106218887Sdim mangleExpression(cast<PackExpansionExpr>(E)->getPattern()); 3107218887Sdim break; 3108218887Sdim 3109218887Sdim case Expr::SizeOfPackExprClass: { 3110218887Sdim Out << "sZ"; 3111218887Sdim const NamedDecl *Pack = cast<SizeOfPackExpr>(E)->getPack(); 3112218887Sdim if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Pack)) 3113218887Sdim mangleTemplateParameter(TTP->getIndex()); 3114218887Sdim else if (const NonTypeTemplateParmDecl *NTTP 3115218887Sdim = dyn_cast<NonTypeTemplateParmDecl>(Pack)) 3116218887Sdim mangleTemplateParameter(NTTP->getIndex()); 3117218887Sdim else if (const TemplateTemplateParmDecl *TempTP 3118218887Sdim = dyn_cast<TemplateTemplateParmDecl>(Pack)) 3119218887Sdim mangleTemplateParameter(TempTP->getIndex()); 3120224145Sdim else 3121224145Sdim mangleFunctionParam(cast<ParmVarDecl>(Pack)); 3122221345Sdim break; 3123218887Sdim } 3124224145Sdim 3125224145Sdim case Expr::MaterializeTemporaryExprClass: { 3126224145Sdim mangleExpression(cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr()); 3127224145Sdim break; 3128218887Sdim } 3129234982Sdim 3130234982Sdim case Expr::CXXThisExprClass: 3131234982Sdim Out << "fpT"; 3132234982Sdim break; 3133224145Sdim } 3134218887Sdim} 3135218887Sdim 3136221345Sdim/// Mangle an expression which refers to a parameter variable. 3137221345Sdim/// 3138221345Sdim/// <expression> ::= <function-param> 3139221345Sdim/// <function-param> ::= fp <top-level CV-qualifiers> _ # L == 0, I == 0 3140221345Sdim/// <function-param> ::= fp <top-level CV-qualifiers> 3141221345Sdim/// <parameter-2 non-negative number> _ # L == 0, I > 0 3142221345Sdim/// <function-param> ::= fL <L-1 non-negative number> 3143221345Sdim/// p <top-level CV-qualifiers> _ # L > 0, I == 0 3144221345Sdim/// <function-param> ::= fL <L-1 non-negative number> 3145221345Sdim/// p <top-level CV-qualifiers> 3146221345Sdim/// <I-1 non-negative number> _ # L > 0, I > 0 3147221345Sdim/// 3148221345Sdim/// L is the nesting depth of the parameter, defined as 1 if the 3149221345Sdim/// parameter comes from the innermost function prototype scope 3150221345Sdim/// enclosing the current context, 2 if from the next enclosing 3151221345Sdim/// function prototype scope, and so on, with one special case: if 3152221345Sdim/// we've processed the full parameter clause for the innermost 3153221345Sdim/// function type, then L is one less. This definition conveniently 3154221345Sdim/// makes it irrelevant whether a function's result type was written 3155221345Sdim/// trailing or leading, but is otherwise overly complicated; the 3156221345Sdim/// numbering was first designed without considering references to 3157221345Sdim/// parameter in locations other than return types, and then the 3158221345Sdim/// mangling had to be generalized without changing the existing 3159221345Sdim/// manglings. 3160221345Sdim/// 3161221345Sdim/// I is the zero-based index of the parameter within its parameter 3162221345Sdim/// declaration clause. Note that the original ABI document describes 3163221345Sdim/// this using 1-based ordinals. 3164221345Sdimvoid CXXNameMangler::mangleFunctionParam(const ParmVarDecl *parm) { 3165221345Sdim unsigned parmDepth = parm->getFunctionScopeDepth(); 3166221345Sdim unsigned parmIndex = parm->getFunctionScopeIndex(); 3167221345Sdim 3168221345Sdim // Compute 'L'. 3169221345Sdim // parmDepth does not include the declaring function prototype. 3170221345Sdim // FunctionTypeDepth does account for that. 3171221345Sdim assert(parmDepth < FunctionTypeDepth.getDepth()); 3172221345Sdim unsigned nestingDepth = FunctionTypeDepth.getDepth() - parmDepth; 3173221345Sdim if (FunctionTypeDepth.isInResultType()) 3174221345Sdim nestingDepth--; 3175221345Sdim 3176221345Sdim if (nestingDepth == 0) { 3177221345Sdim Out << "fp"; 3178221345Sdim } else { 3179221345Sdim Out << "fL" << (nestingDepth - 1) << 'p'; 3180221345Sdim } 3181221345Sdim 3182221345Sdim // Top-level qualifiers. We don't have to worry about arrays here, 3183221345Sdim // because parameters declared as arrays should already have been 3184239462Sdim // transformed to have pointer type. FIXME: apparently these don't 3185221345Sdim // get mangled if used as an rvalue of a known non-class type? 3186221345Sdim assert(!parm->getType()->isArrayType() 3187221345Sdim && "parameter's type is still an array type?"); 3188221345Sdim mangleQualifiers(parm->getType().getQualifiers()); 3189221345Sdim 3190221345Sdim // Parameter index. 3191221345Sdim if (parmIndex != 0) { 3192221345Sdim Out << (parmIndex - 1); 3193221345Sdim } 3194221345Sdim Out << '_'; 3195221345Sdim} 3196221345Sdim 3197218887Sdimvoid CXXNameMangler::mangleCXXCtorType(CXXCtorType T) { 3198218887Sdim // <ctor-dtor-name> ::= C1 # complete object constructor 3199218887Sdim // ::= C2 # base object constructor 3200218887Sdim // ::= C3 # complete object allocating constructor 3201218887Sdim // 3202218887Sdim switch (T) { 3203218887Sdim case Ctor_Complete: 3204218887Sdim Out << "C1"; 3205218887Sdim break; 3206218887Sdim case Ctor_Base: 3207218887Sdim Out << "C2"; 3208218887Sdim break; 3209218887Sdim case Ctor_CompleteAllocating: 3210218887Sdim Out << "C3"; 3211218887Sdim break; 3212218887Sdim } 3213218887Sdim} 3214218887Sdim 3215218887Sdimvoid CXXNameMangler::mangleCXXDtorType(CXXDtorType T) { 3216218887Sdim // <ctor-dtor-name> ::= D0 # deleting destructor 3217218887Sdim // ::= D1 # complete object destructor 3218218887Sdim // ::= D2 # base object destructor 3219218887Sdim // 3220218887Sdim switch (T) { 3221218887Sdim case Dtor_Deleting: 3222218887Sdim Out << "D0"; 3223218887Sdim break; 3224218887Sdim case Dtor_Complete: 3225218887Sdim Out << "D1"; 3226218887Sdim break; 3227218887Sdim case Dtor_Base: 3228218887Sdim Out << "D2"; 3229218887Sdim break; 3230218887Sdim } 3231218887Sdim} 3232218887Sdim 3233218887Sdimvoid CXXNameMangler::mangleTemplateArgs( 3234226633Sdim const ASTTemplateArgumentListInfo &TemplateArgs) { 3235218887Sdim // <template-args> ::= I <template-arg>+ E 3236218887Sdim Out << 'I'; 3237223017Sdim for (unsigned i = 0, e = TemplateArgs.NumTemplateArgs; i != e; ++i) 3238243830Sdim mangleTemplateArg(TemplateArgs.getTemplateArgs()[i].getArgument()); 3239218887Sdim Out << 'E'; 3240218887Sdim} 3241218887Sdim 3242243830Sdimvoid CXXNameMangler::mangleTemplateArgs(const TemplateArgumentList &AL) { 3243218887Sdim // <template-args> ::= I <template-arg>+ E 3244218887Sdim Out << 'I'; 3245218887Sdim for (unsigned i = 0, e = AL.size(); i != e; ++i) 3246243830Sdim mangleTemplateArg(AL[i]); 3247218887Sdim Out << 'E'; 3248218887Sdim} 3249218887Sdim 3250243830Sdimvoid CXXNameMangler::mangleTemplateArgs(const TemplateArgument *TemplateArgs, 3251218887Sdim unsigned NumTemplateArgs) { 3252218887Sdim // <template-args> ::= I <template-arg>+ E 3253218887Sdim Out << 'I'; 3254218887Sdim for (unsigned i = 0; i != NumTemplateArgs; ++i) 3255243830Sdim mangleTemplateArg(TemplateArgs[i]); 3256218887Sdim Out << 'E'; 3257218887Sdim} 3258218887Sdim 3259243830Sdimvoid CXXNameMangler::mangleTemplateArg(TemplateArgument A) { 3260218887Sdim // <template-arg> ::= <type> # type or template 3261218887Sdim // ::= X <expression> E # expression 3262218887Sdim // ::= <expr-primary> # simple expressions 3263218887Sdim // ::= J <template-arg>* E # argument pack 3264224145Sdim if (!A.isInstantiationDependent() || A.isDependent()) 3265224145Sdim A = Context.getASTContext().getCanonicalTemplateArgument(A); 3266224145Sdim 3267218887Sdim switch (A.getKind()) { 3268218887Sdim case TemplateArgument::Null: 3269218887Sdim llvm_unreachable("Cannot mangle NULL template argument"); 3270218887Sdim 3271218887Sdim case TemplateArgument::Type: 3272218887Sdim mangleType(A.getAsType()); 3273218887Sdim break; 3274218887Sdim case TemplateArgument::Template: 3275218887Sdim // This is mangled as <type>. 3276218887Sdim mangleType(A.getAsTemplate()); 3277218887Sdim break; 3278218887Sdim case TemplateArgument::TemplateExpansion: 3279218887Sdim // <type> ::= Dp <type> # pack expansion (C++0x) 3280218887Sdim Out << "Dp"; 3281218887Sdim mangleType(A.getAsTemplateOrTemplatePattern()); 3282218887Sdim break; 3283234353Sdim case TemplateArgument::Expression: { 3284234353Sdim // It's possible to end up with a DeclRefExpr here in certain 3285234353Sdim // dependent cases, in which case we should mangle as a 3286234353Sdim // declaration. 3287234353Sdim const Expr *E = A.getAsExpr()->IgnoreParens(); 3288234353Sdim if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 3289234353Sdim const ValueDecl *D = DRE->getDecl(); 3290234353Sdim if (isa<VarDecl>(D) || isa<FunctionDecl>(D)) { 3291234353Sdim Out << "L"; 3292234353Sdim mangle(D, "_Z"); 3293234353Sdim Out << 'E'; 3294234353Sdim break; 3295234353Sdim } 3296234353Sdim } 3297234353Sdim 3298218887Sdim Out << 'X'; 3299234353Sdim mangleExpression(E); 3300218887Sdim Out << 'E'; 3301218887Sdim break; 3302234353Sdim } 3303218887Sdim case TemplateArgument::Integral: 3304239462Sdim mangleIntegerLiteral(A.getIntegralType(), A.getAsIntegral()); 3305218887Sdim break; 3306218887Sdim case TemplateArgument::Declaration: { 3307218887Sdim // <expr-primary> ::= L <mangled-name> E # external name 3308218887Sdim // Clang produces AST's where pointer-to-member-function expressions 3309218887Sdim // and pointer-to-function expressions are represented as a declaration not 3310218887Sdim // an expression. We compensate for it here to produce the correct mangling. 3311243830Sdim ValueDecl *D = A.getAsDecl(); 3312243830Sdim bool compensateMangling = !A.isDeclForReferenceParam(); 3313218887Sdim if (compensateMangling) { 3314218887Sdim Out << 'X'; 3315218887Sdim mangleOperatorName(OO_Amp, 1); 3316218887Sdim } 3317218887Sdim 3318218887Sdim Out << 'L'; 3319218887Sdim // References to external entities use the mangled name; if the name would 3320218887Sdim // not normally be manged then mangle it as unqualified. 3321218887Sdim // 3322218887Sdim // FIXME: The ABI specifies that external names here should have _Z, but 3323218887Sdim // gcc leaves this off. 3324218887Sdim if (compensateMangling) 3325218887Sdim mangle(D, "_Z"); 3326218887Sdim else 3327218887Sdim mangle(D, "Z"); 3328218887Sdim Out << 'E'; 3329218887Sdim 3330218887Sdim if (compensateMangling) 3331218887Sdim Out << 'E'; 3332218887Sdim 3333218887Sdim break; 3334218887Sdim } 3335243830Sdim case TemplateArgument::NullPtr: { 3336243830Sdim // <expr-primary> ::= L <type> 0 E 3337243830Sdim Out << 'L'; 3338243830Sdim mangleType(A.getNullPtrType()); 3339243830Sdim Out << "0E"; 3340243830Sdim break; 3341243830Sdim } 3342218887Sdim case TemplateArgument::Pack: { 3343263508Sdim // <template-arg> ::= J <template-arg>* E 3344218887Sdim Out << 'J'; 3345263508Sdim for (TemplateArgument::pack_iterator PA = A.pack_begin(), 3346218887Sdim PAEnd = A.pack_end(); 3347218887Sdim PA != PAEnd; ++PA) 3348243830Sdim mangleTemplateArg(*PA); 3349218887Sdim Out << 'E'; 3350218887Sdim } 3351218887Sdim } 3352218887Sdim} 3353218887Sdim 3354218887Sdimvoid CXXNameMangler::mangleTemplateParameter(unsigned Index) { 3355218887Sdim // <template-param> ::= T_ # first template parameter 3356218887Sdim // ::= T <parameter-2 non-negative number> _ 3357218887Sdim if (Index == 0) 3358218887Sdim Out << "T_"; 3359218887Sdim else 3360218887Sdim Out << 'T' << (Index - 1) << '_'; 3361218887Sdim} 3362218887Sdim 3363224145Sdimvoid CXXNameMangler::mangleExistingSubstitution(QualType type) { 3364224145Sdim bool result = mangleSubstitution(type); 3365224145Sdim assert(result && "no existing substitution for type"); 3366224145Sdim (void) result; 3367224145Sdim} 3368224145Sdim 3369224145Sdimvoid CXXNameMangler::mangleExistingSubstitution(TemplateName tname) { 3370224145Sdim bool result = mangleSubstitution(tname); 3371224145Sdim assert(result && "no existing substitution for template name"); 3372224145Sdim (void) result; 3373224145Sdim} 3374224145Sdim 3375218887Sdim// <substitution> ::= S <seq-id> _ 3376218887Sdim// ::= S_ 3377218887Sdimbool CXXNameMangler::mangleSubstitution(const NamedDecl *ND) { 3378218887Sdim // Try one of the standard substitutions first. 3379218887Sdim if (mangleStandardSubstitution(ND)) 3380218887Sdim return true; 3381218887Sdim 3382218887Sdim ND = cast<NamedDecl>(ND->getCanonicalDecl()); 3383218887Sdim return mangleSubstitution(reinterpret_cast<uintptr_t>(ND)); 3384218887Sdim} 3385218887Sdim 3386234353Sdim/// \brief Determine whether the given type has any qualifiers that are 3387234353Sdim/// relevant for substitutions. 3388234353Sdimstatic bool hasMangledSubstitutionQualifiers(QualType T) { 3389234353Sdim Qualifiers Qs = T.getQualifiers(); 3390234353Sdim return Qs.getCVRQualifiers() || Qs.hasAddressSpace(); 3391234353Sdim} 3392234353Sdim 3393218887Sdimbool CXXNameMangler::mangleSubstitution(QualType T) { 3394234353Sdim if (!hasMangledSubstitutionQualifiers(T)) { 3395218887Sdim if (const RecordType *RT = T->getAs<RecordType>()) 3396218887Sdim return mangleSubstitution(RT->getDecl()); 3397218887Sdim } 3398218887Sdim 3399218887Sdim uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr()); 3400218887Sdim 3401218887Sdim return mangleSubstitution(TypePtr); 3402218887Sdim} 3403218887Sdim 3404218887Sdimbool CXXNameMangler::mangleSubstitution(TemplateName Template) { 3405218887Sdim if (TemplateDecl *TD = Template.getAsTemplateDecl()) 3406218887Sdim return mangleSubstitution(TD); 3407218887Sdim 3408218887Sdim Template = Context.getASTContext().getCanonicalTemplateName(Template); 3409218887Sdim return mangleSubstitution( 3410218887Sdim reinterpret_cast<uintptr_t>(Template.getAsVoidPointer())); 3411218887Sdim} 3412218887Sdim 3413218887Sdimbool CXXNameMangler::mangleSubstitution(uintptr_t Ptr) { 3414218887Sdim llvm::DenseMap<uintptr_t, unsigned>::iterator I = Substitutions.find(Ptr); 3415218887Sdim if (I == Substitutions.end()) 3416218887Sdim return false; 3417218887Sdim 3418218887Sdim unsigned SeqID = I->second; 3419218887Sdim if (SeqID == 0) 3420218887Sdim Out << "S_"; 3421218887Sdim else { 3422218887Sdim SeqID--; 3423218887Sdim 3424218887Sdim // <seq-id> is encoded in base-36, using digits and upper case letters. 3425218887Sdim char Buffer[10]; 3426218887Sdim char *BufferPtr = llvm::array_endof(Buffer); 3427218887Sdim 3428218887Sdim if (SeqID == 0) *--BufferPtr = '0'; 3429218887Sdim 3430218887Sdim while (SeqID) { 3431218887Sdim assert(BufferPtr > Buffer && "Buffer overflow!"); 3432218887Sdim 3433218887Sdim char c = static_cast<char>(SeqID % 36); 3434218887Sdim 3435218887Sdim *--BufferPtr = (c < 10 ? '0' + c : 'A' + c - 10); 3436218887Sdim SeqID /= 36; 3437218887Sdim } 3438218887Sdim 3439218887Sdim Out << 'S' 3440226633Sdim << StringRef(BufferPtr, llvm::array_endof(Buffer)-BufferPtr) 3441218887Sdim << '_'; 3442218887Sdim } 3443218887Sdim 3444218887Sdim return true; 3445218887Sdim} 3446218887Sdim 3447218887Sdimstatic bool isCharType(QualType T) { 3448218887Sdim if (T.isNull()) 3449218887Sdim return false; 3450218887Sdim 3451218887Sdim return T->isSpecificBuiltinType(BuiltinType::Char_S) || 3452218887Sdim T->isSpecificBuiltinType(BuiltinType::Char_U); 3453218887Sdim} 3454218887Sdim 3455218887Sdim/// isCharSpecialization - Returns whether a given type is a template 3456218887Sdim/// specialization of a given name with a single argument of type char. 3457218887Sdimstatic bool isCharSpecialization(QualType T, const char *Name) { 3458218887Sdim if (T.isNull()) 3459218887Sdim return false; 3460218887Sdim 3461218887Sdim const RecordType *RT = T->getAs<RecordType>(); 3462218887Sdim if (!RT) 3463218887Sdim return false; 3464218887Sdim 3465218887Sdim const ClassTemplateSpecializationDecl *SD = 3466218887Sdim dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl()); 3467218887Sdim if (!SD) 3468218887Sdim return false; 3469218887Sdim 3470234353Sdim if (!isStdNamespace(getEffectiveDeclContext(SD))) 3471218887Sdim return false; 3472218887Sdim 3473218887Sdim const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs(); 3474218887Sdim if (TemplateArgs.size() != 1) 3475218887Sdim return false; 3476218887Sdim 3477218887Sdim if (!isCharType(TemplateArgs[0].getAsType())) 3478218887Sdim return false; 3479218887Sdim 3480218887Sdim return SD->getIdentifier()->getName() == Name; 3481218887Sdim} 3482218887Sdim 3483218887Sdimtemplate <std::size_t StrLen> 3484218887Sdimstatic bool isStreamCharSpecialization(const ClassTemplateSpecializationDecl*SD, 3485218887Sdim const char (&Str)[StrLen]) { 3486218887Sdim if (!SD->getIdentifier()->isStr(Str)) 3487218887Sdim return false; 3488218887Sdim 3489218887Sdim const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs(); 3490218887Sdim if (TemplateArgs.size() != 2) 3491218887Sdim return false; 3492218887Sdim 3493218887Sdim if (!isCharType(TemplateArgs[0].getAsType())) 3494218887Sdim return false; 3495218887Sdim 3496218887Sdim if (!isCharSpecialization(TemplateArgs[1].getAsType(), "char_traits")) 3497218887Sdim return false; 3498218887Sdim 3499218887Sdim return true; 3500218887Sdim} 3501218887Sdim 3502218887Sdimbool CXXNameMangler::mangleStandardSubstitution(const NamedDecl *ND) { 3503218887Sdim // <substitution> ::= St # ::std:: 3504218887Sdim if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) { 3505218887Sdim if (isStd(NS)) { 3506218887Sdim Out << "St"; 3507218887Sdim return true; 3508218887Sdim } 3509218887Sdim } 3510218887Sdim 3511218887Sdim if (const ClassTemplateDecl *TD = dyn_cast<ClassTemplateDecl>(ND)) { 3512234353Sdim if (!isStdNamespace(getEffectiveDeclContext(TD))) 3513218887Sdim return false; 3514218887Sdim 3515218887Sdim // <substitution> ::= Sa # ::std::allocator 3516218887Sdim if (TD->getIdentifier()->isStr("allocator")) { 3517218887Sdim Out << "Sa"; 3518218887Sdim return true; 3519218887Sdim } 3520218887Sdim 3521218887Sdim // <<substitution> ::= Sb # ::std::basic_string 3522218887Sdim if (TD->getIdentifier()->isStr("basic_string")) { 3523218887Sdim Out << "Sb"; 3524218887Sdim return true; 3525218887Sdim } 3526218887Sdim } 3527218887Sdim 3528218887Sdim if (const ClassTemplateSpecializationDecl *SD = 3529218887Sdim dyn_cast<ClassTemplateSpecializationDecl>(ND)) { 3530234353Sdim if (!isStdNamespace(getEffectiveDeclContext(SD))) 3531218887Sdim return false; 3532218887Sdim 3533218887Sdim // <substitution> ::= Ss # ::std::basic_string<char, 3534218887Sdim // ::std::char_traits<char>, 3535218887Sdim // ::std::allocator<char> > 3536218887Sdim if (SD->getIdentifier()->isStr("basic_string")) { 3537218887Sdim const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs(); 3538218887Sdim 3539218887Sdim if (TemplateArgs.size() != 3) 3540218887Sdim return false; 3541218887Sdim 3542218887Sdim if (!isCharType(TemplateArgs[0].getAsType())) 3543218887Sdim return false; 3544218887Sdim 3545218887Sdim if (!isCharSpecialization(TemplateArgs[1].getAsType(), "char_traits")) 3546218887Sdim return false; 3547218887Sdim 3548218887Sdim if (!isCharSpecialization(TemplateArgs[2].getAsType(), "allocator")) 3549218887Sdim return false; 3550218887Sdim 3551218887Sdim Out << "Ss"; 3552218887Sdim return true; 3553218887Sdim } 3554218887Sdim 3555218887Sdim // <substitution> ::= Si # ::std::basic_istream<char, 3556218887Sdim // ::std::char_traits<char> > 3557218887Sdim if (isStreamCharSpecialization(SD, "basic_istream")) { 3558218887Sdim Out << "Si"; 3559218887Sdim return true; 3560218887Sdim } 3561218887Sdim 3562218887Sdim // <substitution> ::= So # ::std::basic_ostream<char, 3563218887Sdim // ::std::char_traits<char> > 3564218887Sdim if (isStreamCharSpecialization(SD, "basic_ostream")) { 3565218887Sdim Out << "So"; 3566218887Sdim return true; 3567218887Sdim } 3568218887Sdim 3569218887Sdim // <substitution> ::= Sd # ::std::basic_iostream<char, 3570218887Sdim // ::std::char_traits<char> > 3571218887Sdim if (isStreamCharSpecialization(SD, "basic_iostream")) { 3572218887Sdim Out << "Sd"; 3573218887Sdim return true; 3574218887Sdim } 3575218887Sdim } 3576218887Sdim return false; 3577218887Sdim} 3578218887Sdim 3579218887Sdimvoid CXXNameMangler::addSubstitution(QualType T) { 3580234353Sdim if (!hasMangledSubstitutionQualifiers(T)) { 3581218887Sdim if (const RecordType *RT = T->getAs<RecordType>()) { 3582218887Sdim addSubstitution(RT->getDecl()); 3583218887Sdim return; 3584218887Sdim } 3585218887Sdim } 3586218887Sdim 3587218887Sdim uintptr_t TypePtr = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr()); 3588218887Sdim addSubstitution(TypePtr); 3589218887Sdim} 3590218887Sdim 3591218887Sdimvoid CXXNameMangler::addSubstitution(TemplateName Template) { 3592218887Sdim if (TemplateDecl *TD = Template.getAsTemplateDecl()) 3593218887Sdim return addSubstitution(TD); 3594218887Sdim 3595218887Sdim Template = Context.getASTContext().getCanonicalTemplateName(Template); 3596218887Sdim addSubstitution(reinterpret_cast<uintptr_t>(Template.getAsVoidPointer())); 3597218887Sdim} 3598218887Sdim 3599218887Sdimvoid CXXNameMangler::addSubstitution(uintptr_t Ptr) { 3600218887Sdim assert(!Substitutions.count(Ptr) && "Substitution already exists!"); 3601218887Sdim Substitutions[Ptr] = SeqID++; 3602218887Sdim} 3603218887Sdim 3604218887Sdim// 3605218887Sdim 3606218887Sdim/// \brief Mangles the name of the declaration D and emits that name to the 3607218887Sdim/// given output stream. 3608218887Sdim/// 3609218887Sdim/// If the declaration D requires a mangled name, this routine will emit that 3610218887Sdim/// mangled name to \p os and return true. Otherwise, \p os will be unchanged 3611218887Sdim/// and this routine will return false. In this case, the caller should just 3612218887Sdim/// emit the identifier of the declaration (\c D->getIdentifier()) as its 3613218887Sdim/// name. 3614263508Sdimvoid ItaniumMangleContextImpl::mangleCXXName(const NamedDecl *D, 3615263508Sdim raw_ostream &Out) { 3616218887Sdim assert((isa<FunctionDecl>(D) || isa<VarDecl>(D)) && 3617218887Sdim "Invalid mangleName() call, argument is not a variable or function!"); 3618218887Sdim assert(!isa<CXXConstructorDecl>(D) && !isa<CXXDestructorDecl>(D) && 3619218887Sdim "Invalid mangleName() call on 'structor decl!"); 3620218887Sdim 3621218887Sdim PrettyStackTraceDecl CrashInfo(D, SourceLocation(), 3622218887Sdim getASTContext().getSourceManager(), 3623218887Sdim "Mangling declaration"); 3624218887Sdim 3625221345Sdim CXXNameMangler Mangler(*this, Out, D); 3626218887Sdim return Mangler.mangle(D); 3627218887Sdim} 3628218887Sdim 3629263508Sdimvoid ItaniumMangleContextImpl::mangleCXXCtor(const CXXConstructorDecl *D, 3630263508Sdim CXXCtorType Type, 3631263508Sdim raw_ostream &Out) { 3632218887Sdim CXXNameMangler Mangler(*this, Out, D, Type); 3633218887Sdim Mangler.mangle(D); 3634218887Sdim} 3635218887Sdim 3636263508Sdimvoid ItaniumMangleContextImpl::mangleCXXDtor(const CXXDestructorDecl *D, 3637263508Sdim CXXDtorType Type, 3638263508Sdim raw_ostream &Out) { 3639218887Sdim CXXNameMangler Mangler(*this, Out, D, Type); 3640218887Sdim Mangler.mangle(D); 3641218887Sdim} 3642218887Sdim 3643263508Sdimvoid ItaniumMangleContextImpl::mangleThunk(const CXXMethodDecl *MD, 3644263508Sdim const ThunkInfo &Thunk, 3645263508Sdim raw_ostream &Out) { 3646218887Sdim // <special-name> ::= T <call-offset> <base encoding> 3647218887Sdim // # base is the nominal target function of thunk 3648218887Sdim // <special-name> ::= Tc <call-offset> <call-offset> <base encoding> 3649218887Sdim // # base is the nominal target function of thunk 3650218887Sdim // # first call-offset is 'this' adjustment 3651218887Sdim // # second call-offset is result adjustment 3652218887Sdim 3653218887Sdim assert(!isa<CXXDestructorDecl>(MD) && 3654218887Sdim "Use mangleCXXDtor for destructor decls!"); 3655218887Sdim CXXNameMangler Mangler(*this, Out); 3656218887Sdim Mangler.getStream() << "_ZT"; 3657218887Sdim if (!Thunk.Return.isEmpty()) 3658218887Sdim Mangler.getStream() << 'c'; 3659218887Sdim 3660218887Sdim // Mangle the 'this' pointer adjustment. 3661263508Sdim Mangler.mangleCallOffset(Thunk.This.NonVirtual, 3662263508Sdim Thunk.This.Virtual.Itanium.VCallOffsetOffset); 3663263508Sdim 3664218887Sdim // Mangle the return pointer adjustment if there is one. 3665218887Sdim if (!Thunk.Return.isEmpty()) 3666218887Sdim Mangler.mangleCallOffset(Thunk.Return.NonVirtual, 3667263508Sdim Thunk.Return.Virtual.Itanium.VBaseOffsetOffset); 3668263508Sdim 3669218887Sdim Mangler.mangleFunctionEncoding(MD); 3670218887Sdim} 3671218887Sdim 3672263508Sdimvoid ItaniumMangleContextImpl::mangleCXXDtorThunk( 3673263508Sdim const CXXDestructorDecl *DD, CXXDtorType Type, 3674263508Sdim const ThisAdjustment &ThisAdjustment, raw_ostream &Out) { 3675218887Sdim // <special-name> ::= T <call-offset> <base encoding> 3676218887Sdim // # base is the nominal target function of thunk 3677218887Sdim CXXNameMangler Mangler(*this, Out, DD, Type); 3678218887Sdim Mangler.getStream() << "_ZT"; 3679218887Sdim 3680218887Sdim // Mangle the 'this' pointer adjustment. 3681218887Sdim Mangler.mangleCallOffset(ThisAdjustment.NonVirtual, 3682263508Sdim ThisAdjustment.Virtual.Itanium.VCallOffsetOffset); 3683218887Sdim 3684218887Sdim Mangler.mangleFunctionEncoding(DD); 3685218887Sdim} 3686218887Sdim 3687218887Sdim/// mangleGuardVariable - Returns the mangled name for a guard variable 3688218887Sdim/// for the passed in VarDecl. 3689263508Sdimvoid ItaniumMangleContextImpl::mangleStaticGuardVariable(const VarDecl *D, 3690263508Sdim raw_ostream &Out) { 3691218887Sdim // <special-name> ::= GV <object name> # Guard variable for one-time 3692218887Sdim // # initialization 3693218887Sdim CXXNameMangler Mangler(*this, Out); 3694218887Sdim Mangler.getStream() << "_ZGV"; 3695218887Sdim Mangler.mangleName(D); 3696218887Sdim} 3697218887Sdim 3698263508Sdimvoid ItaniumMangleContextImpl::mangleDynamicInitializer(const VarDecl *MD, 3699251662Sdim raw_ostream &Out) { 3700263508Sdim // These symbols are internal in the Itanium ABI, so the names don't matter. 3701263508Sdim // Clang has traditionally used this symbol and allowed LLVM to adjust it to 3702263508Sdim // avoid duplicate symbols. 3703263508Sdim Out << "__cxx_global_var_init"; 3704263508Sdim} 3705263508Sdim 3706263508Sdimvoid ItaniumMangleContextImpl::mangleDynamicAtExitDestructor(const VarDecl *D, 3707263508Sdim raw_ostream &Out) { 3708263508Sdim // Prefix the mangling of D with __dtor_. 3709263508Sdim CXXNameMangler Mangler(*this, Out); 3710263508Sdim Mangler.getStream() << "__dtor_"; 3711263508Sdim if (shouldMangleDeclName(D)) 3712263508Sdim Mangler.mangle(D); 3713263508Sdim else 3714263508Sdim Mangler.getStream() << D->getName(); 3715263508Sdim} 3716263508Sdim 3717263508Sdimvoid ItaniumMangleContextImpl::mangleItaniumThreadLocalInit(const VarDecl *D, 3718263508Sdim raw_ostream &Out) { 3719251662Sdim // <special-name> ::= TH <object name> 3720251662Sdim CXXNameMangler Mangler(*this, Out); 3721251662Sdim Mangler.getStream() << "_ZTH"; 3722251662Sdim Mangler.mangleName(D); 3723251662Sdim} 3724251662Sdim 3725263508Sdimvoid 3726263508SdimItaniumMangleContextImpl::mangleItaniumThreadLocalWrapper(const VarDecl *D, 3727263508Sdim raw_ostream &Out) { 3728251662Sdim // <special-name> ::= TW <object name> 3729251662Sdim CXXNameMangler Mangler(*this, Out); 3730251662Sdim Mangler.getStream() << "_ZTW"; 3731251662Sdim Mangler.mangleName(D); 3732251662Sdim} 3733251662Sdim 3734263508Sdimvoid ItaniumMangleContextImpl::mangleReferenceTemporary(const VarDecl *D, 3735263508Sdim raw_ostream &Out) { 3736218887Sdim // We match the GCC mangling here. 3737218887Sdim // <special-name> ::= GR <object name> 3738218887Sdim CXXNameMangler Mangler(*this, Out); 3739218887Sdim Mangler.getStream() << "_ZGR"; 3740218887Sdim Mangler.mangleName(D); 3741218887Sdim} 3742218887Sdim 3743263508Sdimvoid ItaniumMangleContextImpl::mangleCXXVTable(const CXXRecordDecl *RD, 3744263508Sdim raw_ostream &Out) { 3745218887Sdim // <special-name> ::= TV <type> # virtual table 3746218887Sdim CXXNameMangler Mangler(*this, Out); 3747218887Sdim Mangler.getStream() << "_ZTV"; 3748218887Sdim Mangler.mangleNameOrStandardSubstitution(RD); 3749218887Sdim} 3750218887Sdim 3751263508Sdimvoid ItaniumMangleContextImpl::mangleCXXVTT(const CXXRecordDecl *RD, 3752263508Sdim raw_ostream &Out) { 3753218887Sdim // <special-name> ::= TT <type> # VTT structure 3754218887Sdim CXXNameMangler Mangler(*this, Out); 3755218887Sdim Mangler.getStream() << "_ZTT"; 3756218887Sdim Mangler.mangleNameOrStandardSubstitution(RD); 3757218887Sdim} 3758218887Sdim 3759263508Sdimvoid ItaniumMangleContextImpl::mangleCXXCtorVTable(const CXXRecordDecl *RD, 3760263508Sdim int64_t Offset, 3761263508Sdim const CXXRecordDecl *Type, 3762263508Sdim raw_ostream &Out) { 3763218887Sdim // <special-name> ::= TC <type> <offset number> _ <base type> 3764218887Sdim CXXNameMangler Mangler(*this, Out); 3765218887Sdim Mangler.getStream() << "_ZTC"; 3766218887Sdim Mangler.mangleNameOrStandardSubstitution(RD); 3767218887Sdim Mangler.getStream() << Offset; 3768218887Sdim Mangler.getStream() << '_'; 3769218887Sdim Mangler.mangleNameOrStandardSubstitution(Type); 3770218887Sdim} 3771218887Sdim 3772263508Sdimvoid ItaniumMangleContextImpl::mangleCXXRTTI(QualType Ty, raw_ostream &Out) { 3773218887Sdim // <special-name> ::= TI <type> # typeinfo structure 3774218887Sdim assert(!Ty.hasQualifiers() && "RTTI info cannot have top-level qualifiers"); 3775218887Sdim CXXNameMangler Mangler(*this, Out); 3776218887Sdim Mangler.getStream() << "_ZTI"; 3777218887Sdim Mangler.mangleType(Ty); 3778218887Sdim} 3779218887Sdim 3780263508Sdimvoid ItaniumMangleContextImpl::mangleCXXRTTIName(QualType Ty, 3781263508Sdim raw_ostream &Out) { 3782218887Sdim // <special-name> ::= TS <type> # typeinfo name (null terminated byte string) 3783218887Sdim CXXNameMangler Mangler(*this, Out); 3784218887Sdim Mangler.getStream() << "_ZTS"; 3785218887Sdim Mangler.mangleType(Ty); 3786218887Sdim} 3787218887Sdim 3788263508Sdimvoid ItaniumMangleContextImpl::mangleTypeName(QualType Ty, raw_ostream &Out) { 3789263508Sdim mangleCXXRTTIName(Ty, Out); 3790218887Sdim} 3791263508Sdim 3792263508SdimItaniumMangleContext * 3793263508SdimItaniumMangleContext::create(ASTContext &Context, DiagnosticsEngine &Diags) { 3794263508Sdim return new ItaniumMangleContextImpl(Context, Diags); 3795263508Sdim} 3796