MicrosoftMangle.cpp revision 280031
1//===--- MicrosoftMangle.cpp - Microsoft Visual C++ Name Mangling ---------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This provides C++ name mangling targeting the Microsoft Visual C++ ABI. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/Mangle.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/Attr.h" 17#include "clang/AST/CXXInheritance.h" 18#include "clang/AST/CharUnits.h" 19#include "clang/AST/Decl.h" 20#include "clang/AST/DeclCXX.h" 21#include "clang/AST/DeclObjC.h" 22#include "clang/AST/DeclTemplate.h" 23#include "clang/AST/Expr.h" 24#include "clang/AST/ExprCXX.h" 25#include "clang/AST/VTableBuilder.h" 26#include "clang/Basic/ABI.h" 27#include "clang/Basic/DiagnosticOptions.h" 28#include "clang/Basic/TargetInfo.h" 29#include "llvm/ADT/StringExtras.h" 30#include "llvm/Support/MathExtras.h" 31 32using namespace clang; 33 34namespace { 35 36/// \brief Retrieve the declaration context that should be used when mangling 37/// the given declaration. 38static const DeclContext *getEffectiveDeclContext(const Decl *D) { 39 // The ABI assumes that lambda closure types that occur within 40 // default arguments live in the context of the function. However, due to 41 // the way in which Clang parses and creates function declarations, this is 42 // not the case: the lambda closure type ends up living in the context 43 // where the function itself resides, because the function declaration itself 44 // had not yet been created. Fix the context here. 45 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 46 if (RD->isLambda()) 47 if (ParmVarDecl *ContextParam = 48 dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl())) 49 return ContextParam->getDeclContext(); 50 } 51 52 // Perform the same check for block literals. 53 if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) { 54 if (ParmVarDecl *ContextParam = 55 dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl())) 56 return ContextParam->getDeclContext(); 57 } 58 59 const DeclContext *DC = D->getDeclContext(); 60 if (const CapturedDecl *CD = dyn_cast<CapturedDecl>(DC)) 61 return getEffectiveDeclContext(CD); 62 63 return DC; 64} 65 66static const DeclContext *getEffectiveParentContext(const DeclContext *DC) { 67 return getEffectiveDeclContext(cast<Decl>(DC)); 68} 69 70static const FunctionDecl *getStructor(const FunctionDecl *fn) { 71 if (const FunctionTemplateDecl *ftd = fn->getPrimaryTemplate()) 72 return ftd->getTemplatedDecl(); 73 74 return fn; 75} 76 77static bool isLambda(const NamedDecl *ND) { 78 const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(ND); 79 if (!Record) 80 return false; 81 82 return Record->isLambda(); 83} 84 85/// MicrosoftMangleContextImpl - Overrides the default MangleContext for the 86/// Microsoft Visual C++ ABI. 87class MicrosoftMangleContextImpl : public MicrosoftMangleContext { 88 typedef std::pair<const DeclContext *, IdentifierInfo *> DiscriminatorKeyTy; 89 llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator; 90 llvm::DenseMap<const NamedDecl *, unsigned> Uniquifier; 91 llvm::DenseMap<const CXXRecordDecl *, unsigned> LambdaIds; 92 93public: 94 MicrosoftMangleContextImpl(ASTContext &Context, DiagnosticsEngine &Diags) 95 : MicrosoftMangleContext(Context, Diags) {} 96 bool shouldMangleCXXName(const NamedDecl *D) override; 97 bool shouldMangleStringLiteral(const StringLiteral *SL) override; 98 void mangleCXXName(const NamedDecl *D, raw_ostream &Out) override; 99 void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD, 100 raw_ostream &) override; 101 void mangleThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk, 102 raw_ostream &) override; 103 void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type, 104 const ThisAdjustment &ThisAdjustment, 105 raw_ostream &) override; 106 void mangleCXXVFTable(const CXXRecordDecl *Derived, 107 ArrayRef<const CXXRecordDecl *> BasePath, 108 raw_ostream &Out) override; 109 void mangleCXXVBTable(const CXXRecordDecl *Derived, 110 ArrayRef<const CXXRecordDecl *> BasePath, 111 raw_ostream &Out) override; 112 void mangleCXXRTTI(QualType T, raw_ostream &Out) override; 113 void mangleCXXRTTIName(QualType T, raw_ostream &Out) override; 114 void mangleCXXRTTIBaseClassDescriptor(const CXXRecordDecl *Derived, 115 uint32_t NVOffset, int32_t VBPtrOffset, 116 uint32_t VBTableOffset, uint32_t Flags, 117 raw_ostream &Out) override; 118 void mangleCXXRTTIBaseClassArray(const CXXRecordDecl *Derived, 119 raw_ostream &Out) override; 120 void mangleCXXRTTIClassHierarchyDescriptor(const CXXRecordDecl *Derived, 121 raw_ostream &Out) override; 122 void 123 mangleCXXRTTICompleteObjectLocator(const CXXRecordDecl *Derived, 124 ArrayRef<const CXXRecordDecl *> BasePath, 125 raw_ostream &Out) override; 126 void mangleTypeName(QualType T, raw_ostream &) override; 127 void mangleCXXCtor(const CXXConstructorDecl *D, CXXCtorType Type, 128 raw_ostream &) override; 129 void mangleCXXDtor(const CXXDestructorDecl *D, CXXDtorType Type, 130 raw_ostream &) override; 131 void mangleReferenceTemporary(const VarDecl *, unsigned ManglingNumber, 132 raw_ostream &) override; 133 void mangleStaticGuardVariable(const VarDecl *D, raw_ostream &Out) override; 134 void mangleDynamicInitializer(const VarDecl *D, raw_ostream &Out) override; 135 void mangleDynamicAtExitDestructor(const VarDecl *D, 136 raw_ostream &Out) override; 137 void mangleStringLiteral(const StringLiteral *SL, raw_ostream &Out) override; 138 bool getNextDiscriminator(const NamedDecl *ND, unsigned &disc) { 139 // Lambda closure types are already numbered. 140 if (isLambda(ND)) 141 return false; 142 143 const DeclContext *DC = getEffectiveDeclContext(ND); 144 if (!DC->isFunctionOrMethod()) 145 return false; 146 147 // Use the canonical number for externally visible decls. 148 if (ND->isExternallyVisible()) { 149 disc = getASTContext().getManglingNumber(ND); 150 return true; 151 } 152 153 // Anonymous tags are already numbered. 154 if (const TagDecl *Tag = dyn_cast<TagDecl>(ND)) { 155 if (Tag->getName().empty() && !Tag->getTypedefNameForAnonDecl()) 156 return false; 157 } 158 159 // Make up a reasonable number for internal decls. 160 unsigned &discriminator = Uniquifier[ND]; 161 if (!discriminator) 162 discriminator = ++Discriminator[std::make_pair(DC, ND->getIdentifier())]; 163 disc = discriminator + 1; 164 return true; 165 } 166 167 unsigned getLambdaId(const CXXRecordDecl *RD) { 168 assert(RD->isLambda() && "RD must be a lambda!"); 169 assert(!RD->isExternallyVisible() && "RD must not be visible!"); 170 assert(RD->getLambdaManglingNumber() == 0 && 171 "RD must not have a mangling number!"); 172 std::pair<llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator, bool> 173 Result = LambdaIds.insert(std::make_pair(RD, LambdaIds.size())); 174 return Result.first->second; 175 } 176 177private: 178 void mangleInitFiniStub(const VarDecl *D, raw_ostream &Out, char CharCode); 179}; 180 181/// MicrosoftCXXNameMangler - Manage the mangling of a single name for the 182/// Microsoft Visual C++ ABI. 183class MicrosoftCXXNameMangler { 184 MicrosoftMangleContextImpl &Context; 185 raw_ostream &Out; 186 187 /// The "structor" is the top-level declaration being mangled, if 188 /// that's not a template specialization; otherwise it's the pattern 189 /// for that specialization. 190 const NamedDecl *Structor; 191 unsigned StructorType; 192 193 typedef llvm::SmallVector<std::string, 10> BackRefVec; 194 BackRefVec NameBackReferences; 195 196 typedef llvm::DenseMap<void *, unsigned> ArgBackRefMap; 197 ArgBackRefMap TypeBackReferences; 198 199 ASTContext &getASTContext() const { return Context.getASTContext(); } 200 201 // FIXME: If we add support for __ptr32/64 qualifiers, then we should push 202 // this check into mangleQualifiers(). 203 const bool PointersAre64Bit; 204 205public: 206 enum QualifierMangleMode { QMM_Drop, QMM_Mangle, QMM_Escape, QMM_Result }; 207 208 MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_) 209 : Context(C), Out(Out_), Structor(nullptr), StructorType(-1), 210 PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) == 211 64) {} 212 213 MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_, 214 const CXXDestructorDecl *D, CXXDtorType Type) 215 : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type), 216 PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) == 217 64) {} 218 219 raw_ostream &getStream() const { return Out; } 220 221 void mangle(const NamedDecl *D, StringRef Prefix = "\01?"); 222 void mangleName(const NamedDecl *ND); 223 void mangleFunctionEncoding(const FunctionDecl *FD); 224 void mangleVariableEncoding(const VarDecl *VD); 225 void mangleMemberDataPointer(const CXXRecordDecl *RD, const ValueDecl *VD); 226 void mangleMemberFunctionPointer(const CXXRecordDecl *RD, 227 const CXXMethodDecl *MD); 228 void mangleVirtualMemPtrThunk( 229 const CXXMethodDecl *MD, 230 const MicrosoftVTableContext::MethodVFTableLocation &ML); 231 void mangleNumber(int64_t Number); 232 void mangleType(QualType T, SourceRange Range, 233 QualifierMangleMode QMM = QMM_Mangle); 234 void mangleFunctionType(const FunctionType *T, 235 const FunctionDecl *D = nullptr, 236 bool ForceThisQuals = false); 237 void mangleNestedName(const NamedDecl *ND); 238 239private: 240 void mangleUnqualifiedName(const NamedDecl *ND) { 241 mangleUnqualifiedName(ND, ND->getDeclName()); 242 } 243 void mangleUnqualifiedName(const NamedDecl *ND, DeclarationName Name); 244 void mangleSourceName(StringRef Name); 245 void mangleOperatorName(OverloadedOperatorKind OO, SourceLocation Loc); 246 void mangleCXXDtorType(CXXDtorType T); 247 void mangleQualifiers(Qualifiers Quals, bool IsMember); 248 void mangleRefQualifier(RefQualifierKind RefQualifier); 249 void manglePointerCVQualifiers(Qualifiers Quals); 250 void manglePointerExtQualifiers(Qualifiers Quals, const Type *PointeeType); 251 252 void mangleUnscopedTemplateName(const TemplateDecl *ND); 253 void 254 mangleTemplateInstantiationName(const TemplateDecl *TD, 255 const TemplateArgumentList &TemplateArgs); 256 void mangleObjCMethodName(const ObjCMethodDecl *MD); 257 258 void mangleArgumentType(QualType T, SourceRange Range); 259 260 // Declare manglers for every type class. 261#define ABSTRACT_TYPE(CLASS, PARENT) 262#define NON_CANONICAL_TYPE(CLASS, PARENT) 263#define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T, \ 264 SourceRange Range); 265#include "clang/AST/TypeNodes.def" 266#undef ABSTRACT_TYPE 267#undef NON_CANONICAL_TYPE 268#undef TYPE 269 270 void mangleType(const TagDecl *TD); 271 void mangleDecayedArrayType(const ArrayType *T); 272 void mangleArrayType(const ArrayType *T); 273 void mangleFunctionClass(const FunctionDecl *FD); 274 void mangleCallingConvention(const FunctionType *T); 275 void mangleIntegerLiteral(const llvm::APSInt &Number, bool IsBoolean); 276 void mangleExpression(const Expr *E); 277 void mangleThrowSpecification(const FunctionProtoType *T); 278 279 void mangleTemplateArgs(const TemplateDecl *TD, 280 const TemplateArgumentList &TemplateArgs); 281 void mangleTemplateArg(const TemplateDecl *TD, const TemplateArgument &TA, 282 const NamedDecl *Parm); 283}; 284} 285 286bool MicrosoftMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) { 287 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 288 LanguageLinkage L = FD->getLanguageLinkage(); 289 // Overloadable functions need mangling. 290 if (FD->hasAttr<OverloadableAttr>()) 291 return true; 292 293 // The ABI expects that we would never mangle "typical" user-defined entry 294 // points regardless of visibility or freestanding-ness. 295 // 296 // N.B. This is distinct from asking about "main". "main" has a lot of 297 // special rules associated with it in the standard while these 298 // user-defined entry points are outside of the purview of the standard. 299 // For example, there can be only one definition for "main" in a standards 300 // compliant program; however nothing forbids the existence of wmain and 301 // WinMain in the same translation unit. 302 if (FD->isMSVCRTEntryPoint()) 303 return false; 304 305 // C++ functions and those whose names are not a simple identifier need 306 // mangling. 307 if (!FD->getDeclName().isIdentifier() || L == CXXLanguageLinkage) 308 return true; 309 310 // C functions are not mangled. 311 if (L == CLanguageLinkage) 312 return false; 313 } 314 315 // Otherwise, no mangling is done outside C++ mode. 316 if (!getASTContext().getLangOpts().CPlusPlus) 317 return false; 318 319 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 320 // C variables are not mangled. 321 if (VD->isExternC()) 322 return false; 323 324 // Variables at global scope with non-internal linkage are not mangled. 325 const DeclContext *DC = getEffectiveDeclContext(D); 326 // Check for extern variable declared locally. 327 if (DC->isFunctionOrMethod() && D->hasLinkage()) 328 while (!DC->isNamespace() && !DC->isTranslationUnit()) 329 DC = getEffectiveParentContext(DC); 330 331 if (DC->isTranslationUnit() && D->getFormalLinkage() == InternalLinkage && 332 !isa<VarTemplateSpecializationDecl>(D)) 333 return false; 334 } 335 336 return true; 337} 338 339bool 340MicrosoftMangleContextImpl::shouldMangleStringLiteral(const StringLiteral *SL) { 341 return true; 342} 343 344void MicrosoftCXXNameMangler::mangle(const NamedDecl *D, StringRef Prefix) { 345 // MSVC doesn't mangle C++ names the same way it mangles extern "C" names. 346 // Therefore it's really important that we don't decorate the 347 // name with leading underscores or leading/trailing at signs. So, by 348 // default, we emit an asm marker at the start so we get the name right. 349 // Callers can override this with a custom prefix. 350 351 // <mangled-name> ::= ? <name> <type-encoding> 352 Out << Prefix; 353 mangleName(D); 354 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 355 mangleFunctionEncoding(FD); 356 else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 357 mangleVariableEncoding(VD); 358 else { 359 // TODO: Fields? Can MSVC even mangle them? 360 // Issue a diagnostic for now. 361 DiagnosticsEngine &Diags = Context.getDiags(); 362 unsigned DiagID = Diags.getCustomDiagID( 363 DiagnosticsEngine::Error, "cannot mangle this declaration yet"); 364 Diags.Report(D->getLocation(), DiagID) << D->getSourceRange(); 365 } 366} 367 368void MicrosoftCXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD) { 369 // <type-encoding> ::= <function-class> <function-type> 370 371 // Since MSVC operates on the type as written and not the canonical type, it 372 // actually matters which decl we have here. MSVC appears to choose the 373 // first, since it is most likely to be the declaration in a header file. 374 FD = FD->getFirstDecl(); 375 376 // We should never ever see a FunctionNoProtoType at this point. 377 // We don't even know how to mangle their types anyway :). 378 const FunctionProtoType *FT = FD->getType()->castAs<FunctionProtoType>(); 379 380 // extern "C" functions can hold entities that must be mangled. 381 // As it stands, these functions still need to get expressed in the full 382 // external name. They have their class and type omitted, replaced with '9'. 383 if (Context.shouldMangleDeclName(FD)) { 384 // First, the function class. 385 mangleFunctionClass(FD); 386 387 mangleFunctionType(FT, FD); 388 } else 389 Out << '9'; 390} 391 392void MicrosoftCXXNameMangler::mangleVariableEncoding(const VarDecl *VD) { 393 // <type-encoding> ::= <storage-class> <variable-type> 394 // <storage-class> ::= 0 # private static member 395 // ::= 1 # protected static member 396 // ::= 2 # public static member 397 // ::= 3 # global 398 // ::= 4 # static local 399 400 // The first character in the encoding (after the name) is the storage class. 401 if (VD->isStaticDataMember()) { 402 // If it's a static member, it also encodes the access level. 403 switch (VD->getAccess()) { 404 default: 405 case AS_private: Out << '0'; break; 406 case AS_protected: Out << '1'; break; 407 case AS_public: Out << '2'; break; 408 } 409 } 410 else if (!VD->isStaticLocal()) 411 Out << '3'; 412 else 413 Out << '4'; 414 // Now mangle the type. 415 // <variable-type> ::= <type> <cvr-qualifiers> 416 // ::= <type> <pointee-cvr-qualifiers> # pointers, references 417 // Pointers and references are odd. The type of 'int * const foo;' gets 418 // mangled as 'QAHA' instead of 'PAHB', for example. 419 SourceRange SR = VD->getSourceRange(); 420 QualType Ty = VD->getType(); 421 if (Ty->isPointerType() || Ty->isReferenceType() || 422 Ty->isMemberPointerType()) { 423 mangleType(Ty, SR, QMM_Drop); 424 manglePointerExtQualifiers( 425 Ty.getDesugaredType(getASTContext()).getLocalQualifiers(), nullptr); 426 if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) { 427 mangleQualifiers(MPT->getPointeeType().getQualifiers(), true); 428 // Member pointers are suffixed with a back reference to the member 429 // pointer's class name. 430 mangleName(MPT->getClass()->getAsCXXRecordDecl()); 431 } else 432 mangleQualifiers(Ty->getPointeeType().getQualifiers(), false); 433 } else if (const ArrayType *AT = getASTContext().getAsArrayType(Ty)) { 434 // Global arrays are funny, too. 435 mangleDecayedArrayType(AT); 436 if (AT->getElementType()->isArrayType()) 437 Out << 'A'; 438 else 439 mangleQualifiers(Ty.getQualifiers(), false); 440 } else { 441 mangleType(Ty, SR, QMM_Drop); 442 mangleQualifiers(Ty.getQualifiers(), false); 443 } 444} 445 446void MicrosoftCXXNameMangler::mangleMemberDataPointer(const CXXRecordDecl *RD, 447 const ValueDecl *VD) { 448 // <member-data-pointer> ::= <integer-literal> 449 // ::= $F <number> <number> 450 // ::= $G <number> <number> <number> 451 452 int64_t FieldOffset; 453 int64_t VBTableOffset; 454 MSInheritanceAttr::Spelling IM = RD->getMSInheritanceModel(); 455 if (VD) { 456 FieldOffset = getASTContext().getFieldOffset(VD); 457 assert(FieldOffset % getASTContext().getCharWidth() == 0 && 458 "cannot take address of bitfield"); 459 FieldOffset /= getASTContext().getCharWidth(); 460 461 VBTableOffset = 0; 462 } else { 463 FieldOffset = RD->nullFieldOffsetIsZero() ? 0 : -1; 464 465 VBTableOffset = -1; 466 } 467 468 char Code = '\0'; 469 switch (IM) { 470 case MSInheritanceAttr::Keyword_single_inheritance: Code = '0'; break; 471 case MSInheritanceAttr::Keyword_multiple_inheritance: Code = '0'; break; 472 case MSInheritanceAttr::Keyword_virtual_inheritance: Code = 'F'; break; 473 case MSInheritanceAttr::Keyword_unspecified_inheritance: Code = 'G'; break; 474 } 475 476 Out << '$' << Code; 477 478 mangleNumber(FieldOffset); 479 480 // The C++ standard doesn't allow base-to-derived member pointer conversions 481 // in template parameter contexts, so the vbptr offset of data member pointers 482 // is always zero. 483 if (MSInheritanceAttr::hasVBPtrOffsetField(IM)) 484 mangleNumber(0); 485 if (MSInheritanceAttr::hasVBTableOffsetField(IM)) 486 mangleNumber(VBTableOffset); 487} 488 489void 490MicrosoftCXXNameMangler::mangleMemberFunctionPointer(const CXXRecordDecl *RD, 491 const CXXMethodDecl *MD) { 492 // <member-function-pointer> ::= $1? <name> 493 // ::= $H? <name> <number> 494 // ::= $I? <name> <number> <number> 495 // ::= $J? <name> <number> <number> <number> 496 497 MSInheritanceAttr::Spelling IM = RD->getMSInheritanceModel(); 498 499 char Code = '\0'; 500 switch (IM) { 501 case MSInheritanceAttr::Keyword_single_inheritance: Code = '1'; break; 502 case MSInheritanceAttr::Keyword_multiple_inheritance: Code = 'H'; break; 503 case MSInheritanceAttr::Keyword_virtual_inheritance: Code = 'I'; break; 504 case MSInheritanceAttr::Keyword_unspecified_inheritance: Code = 'J'; break; 505 } 506 507 // If non-virtual, mangle the name. If virtual, mangle as a virtual memptr 508 // thunk. 509 uint64_t NVOffset = 0; 510 uint64_t VBTableOffset = 0; 511 uint64_t VBPtrOffset = 0; 512 if (MD) { 513 Out << '$' << Code << '?'; 514 if (MD->isVirtual()) { 515 MicrosoftVTableContext *VTContext = 516 cast<MicrosoftVTableContext>(getASTContext().getVTableContext()); 517 const MicrosoftVTableContext::MethodVFTableLocation &ML = 518 VTContext->getMethodVFTableLocation(GlobalDecl(MD)); 519 mangleVirtualMemPtrThunk(MD, ML); 520 NVOffset = ML.VFPtrOffset.getQuantity(); 521 VBTableOffset = ML.VBTableIndex * 4; 522 if (ML.VBase) { 523 const ASTRecordLayout &Layout = getASTContext().getASTRecordLayout(RD); 524 VBPtrOffset = Layout.getVBPtrOffset().getQuantity(); 525 } 526 } else { 527 mangleName(MD); 528 mangleFunctionEncoding(MD); 529 } 530 } else { 531 // Null single inheritance member functions are encoded as a simple nullptr. 532 if (IM == MSInheritanceAttr::Keyword_single_inheritance) { 533 Out << "$0A@"; 534 return; 535 } 536 if (IM == MSInheritanceAttr::Keyword_unspecified_inheritance) 537 VBTableOffset = -1; 538 Out << '$' << Code; 539 } 540 541 if (MSInheritanceAttr::hasNVOffsetField(/*IsMemberFunction=*/true, IM)) 542 mangleNumber(NVOffset); 543 if (MSInheritanceAttr::hasVBPtrOffsetField(IM)) 544 mangleNumber(VBPtrOffset); 545 if (MSInheritanceAttr::hasVBTableOffsetField(IM)) 546 mangleNumber(VBTableOffset); 547} 548 549void MicrosoftCXXNameMangler::mangleVirtualMemPtrThunk( 550 const CXXMethodDecl *MD, 551 const MicrosoftVTableContext::MethodVFTableLocation &ML) { 552 // Get the vftable offset. 553 CharUnits PointerWidth = getASTContext().toCharUnitsFromBits( 554 getASTContext().getTargetInfo().getPointerWidth(0)); 555 uint64_t OffsetInVFTable = ML.Index * PointerWidth.getQuantity(); 556 557 Out << "?_9"; 558 mangleName(MD->getParent()); 559 Out << "$B"; 560 mangleNumber(OffsetInVFTable); 561 Out << 'A'; 562 Out << (PointersAre64Bit ? 'A' : 'E'); 563} 564 565void MicrosoftCXXNameMangler::mangleName(const NamedDecl *ND) { 566 // <name> ::= <unscoped-name> {[<named-scope>]+ | [<nested-name>]}? @ 567 568 // Always start with the unqualified name. 569 mangleUnqualifiedName(ND); 570 571 mangleNestedName(ND); 572 573 // Terminate the whole name with an '@'. 574 Out << '@'; 575} 576 577void MicrosoftCXXNameMangler::mangleNumber(int64_t Number) { 578 // <non-negative integer> ::= A@ # when Number == 0 579 // ::= <decimal digit> # when 1 <= Number <= 10 580 // ::= <hex digit>+ @ # when Number >= 10 581 // 582 // <number> ::= [?] <non-negative integer> 583 584 uint64_t Value = static_cast<uint64_t>(Number); 585 if (Number < 0) { 586 Value = -Value; 587 Out << '?'; 588 } 589 590 if (Value == 0) 591 Out << "A@"; 592 else if (Value >= 1 && Value <= 10) 593 Out << (Value - 1); 594 else { 595 // Numbers that are not encoded as decimal digits are represented as nibbles 596 // in the range of ASCII characters 'A' to 'P'. 597 // The number 0x123450 would be encoded as 'BCDEFA' 598 char EncodedNumberBuffer[sizeof(uint64_t) * 2]; 599 MutableArrayRef<char> BufferRef(EncodedNumberBuffer); 600 MutableArrayRef<char>::reverse_iterator I = BufferRef.rbegin(); 601 for (; Value != 0; Value >>= 4) 602 *I++ = 'A' + (Value & 0xf); 603 Out.write(I.base(), I - BufferRef.rbegin()); 604 Out << '@'; 605 } 606} 607 608static const TemplateDecl * 609isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs) { 610 // Check if we have a function template. 611 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { 612 if (const TemplateDecl *TD = FD->getPrimaryTemplate()) { 613 TemplateArgs = FD->getTemplateSpecializationArgs(); 614 return TD; 615 } 616 } 617 618 // Check if we have a class template. 619 if (const ClassTemplateSpecializationDecl *Spec = 620 dyn_cast<ClassTemplateSpecializationDecl>(ND)) { 621 TemplateArgs = &Spec->getTemplateArgs(); 622 return Spec->getSpecializedTemplate(); 623 } 624 625 // Check if we have a variable template. 626 if (const VarTemplateSpecializationDecl *Spec = 627 dyn_cast<VarTemplateSpecializationDecl>(ND)) { 628 TemplateArgs = &Spec->getTemplateArgs(); 629 return Spec->getSpecializedTemplate(); 630 } 631 632 return nullptr; 633} 634 635void MicrosoftCXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, 636 DeclarationName Name) { 637 // <unqualified-name> ::= <operator-name> 638 // ::= <ctor-dtor-name> 639 // ::= <source-name> 640 // ::= <template-name> 641 642 // Check if we have a template. 643 const TemplateArgumentList *TemplateArgs = nullptr; 644 if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { 645 // Function templates aren't considered for name back referencing. This 646 // makes sense since function templates aren't likely to occur multiple 647 // times in a symbol. 648 // FIXME: Test alias template mangling with MSVC 2013. 649 if (!isa<ClassTemplateDecl>(TD)) { 650 mangleTemplateInstantiationName(TD, *TemplateArgs); 651 Out << '@'; 652 return; 653 } 654 655 // Here comes the tricky thing: if we need to mangle something like 656 // void foo(A::X<Y>, B::X<Y>), 657 // the X<Y> part is aliased. However, if you need to mangle 658 // void foo(A::X<A::Y>, A::X<B::Y>), 659 // the A::X<> part is not aliased. 660 // That said, from the mangler's perspective we have a structure like this: 661 // namespace[s] -> type[ -> template-parameters] 662 // but from the Clang perspective we have 663 // type [ -> template-parameters] 664 // \-> namespace[s] 665 // What we do is we create a new mangler, mangle the same type (without 666 // a namespace suffix) to a string using the extra mangler and then use 667 // the mangled type name as a key to check the mangling of different types 668 // for aliasing. 669 670 llvm::SmallString<64> TemplateMangling; 671 llvm::raw_svector_ostream Stream(TemplateMangling); 672 MicrosoftCXXNameMangler Extra(Context, Stream); 673 Extra.mangleTemplateInstantiationName(TD, *TemplateArgs); 674 Stream.flush(); 675 676 mangleSourceName(TemplateMangling); 677 return; 678 } 679 680 switch (Name.getNameKind()) { 681 case DeclarationName::Identifier: { 682 if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) { 683 mangleSourceName(II->getName()); 684 break; 685 } 686 687 // Otherwise, an anonymous entity. We must have a declaration. 688 assert(ND && "mangling empty name without declaration"); 689 690 if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) { 691 if (NS->isAnonymousNamespace()) { 692 Out << "?A@"; 693 break; 694 } 695 } 696 697 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) { 698 // We must have an anonymous union or struct declaration. 699 const CXXRecordDecl *RD = VD->getType()->getAsCXXRecordDecl(); 700 assert(RD && "expected variable decl to have a record type"); 701 // Anonymous types with no tag or typedef get the name of their 702 // declarator mangled in. If they have no declarator, number them with 703 // a $S prefix. 704 llvm::SmallString<64> Name("$S"); 705 // Get a unique id for the anonymous struct. 706 Name += llvm::utostr(Context.getAnonymousStructId(RD) + 1); 707 mangleSourceName(Name.str()); 708 break; 709 } 710 711 // We must have an anonymous struct. 712 const TagDecl *TD = cast<TagDecl>(ND); 713 if (const TypedefNameDecl *D = TD->getTypedefNameForAnonDecl()) { 714 assert(TD->getDeclContext() == D->getDeclContext() && 715 "Typedef should not be in another decl context!"); 716 assert(D->getDeclName().getAsIdentifierInfo() && 717 "Typedef was not named!"); 718 mangleSourceName(D->getDeclName().getAsIdentifierInfo()->getName()); 719 break; 720 } 721 722 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) { 723 if (Record->isLambda()) { 724 llvm::SmallString<10> Name("<lambda_"); 725 unsigned LambdaId; 726 if (Record->getLambdaManglingNumber()) 727 LambdaId = Record->getLambdaManglingNumber(); 728 else 729 LambdaId = Context.getLambdaId(Record); 730 731 Name += llvm::utostr(LambdaId); 732 Name += ">"; 733 734 mangleSourceName(Name); 735 break; 736 } 737 } 738 739 llvm::SmallString<64> Name("<unnamed-type-"); 740 if (TD->hasDeclaratorForAnonDecl()) { 741 // Anonymous types with no tag or typedef get the name of their 742 // declarator mangled in if they have one. 743 Name += TD->getDeclaratorForAnonDecl()->getName(); 744 } else { 745 // Otherwise, number the types using a $S prefix. 746 Name += "$S"; 747 Name += llvm::utostr(Context.getAnonymousStructId(TD)); 748 } 749 Name += ">"; 750 mangleSourceName(Name.str()); 751 break; 752 } 753 754 case DeclarationName::ObjCZeroArgSelector: 755 case DeclarationName::ObjCOneArgSelector: 756 case DeclarationName::ObjCMultiArgSelector: 757 llvm_unreachable("Can't mangle Objective-C selector names here!"); 758 759 case DeclarationName::CXXConstructorName: 760 if (ND == Structor) { 761 assert(StructorType == Ctor_Complete && 762 "Should never be asked to mangle a ctor other than complete"); 763 } 764 Out << "?0"; 765 break; 766 767 case DeclarationName::CXXDestructorName: 768 if (ND == Structor) 769 // If the named decl is the C++ destructor we're mangling, 770 // use the type we were given. 771 mangleCXXDtorType(static_cast<CXXDtorType>(StructorType)); 772 else 773 // Otherwise, use the base destructor name. This is relevant if a 774 // class with a destructor is declared within a destructor. 775 mangleCXXDtorType(Dtor_Base); 776 break; 777 778 case DeclarationName::CXXConversionFunctionName: 779 // <operator-name> ::= ?B # (cast) 780 // The target type is encoded as the return type. 781 Out << "?B"; 782 break; 783 784 case DeclarationName::CXXOperatorName: 785 mangleOperatorName(Name.getCXXOverloadedOperator(), ND->getLocation()); 786 break; 787 788 case DeclarationName::CXXLiteralOperatorName: { 789 Out << "?__K"; 790 mangleSourceName(Name.getCXXLiteralIdentifier()->getName()); 791 break; 792 } 793 794 case DeclarationName::CXXUsingDirective: 795 llvm_unreachable("Can't mangle a using directive name!"); 796 } 797} 798 799void MicrosoftCXXNameMangler::mangleNestedName(const NamedDecl *ND) { 800 // <postfix> ::= <unqualified-name> [<postfix>] 801 // ::= <substitution> [<postfix>] 802 const DeclContext *DC = getEffectiveDeclContext(ND); 803 804 while (!DC->isTranslationUnit()) { 805 if (isa<TagDecl>(ND) || isa<VarDecl>(ND)) { 806 unsigned Disc; 807 if (Context.getNextDiscriminator(ND, Disc)) { 808 Out << '?'; 809 mangleNumber(Disc); 810 Out << '?'; 811 } 812 } 813 814 if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) { 815 DiagnosticsEngine &Diags = Context.getDiags(); 816 unsigned DiagID = 817 Diags.getCustomDiagID(DiagnosticsEngine::Error, 818 "cannot mangle a local inside this block yet"); 819 Diags.Report(BD->getLocation(), DiagID); 820 821 // FIXME: This is completely, utterly, wrong; see ItaniumMangle 822 // for how this should be done. 823 Out << "__block_invoke" << Context.getBlockId(BD, false); 824 Out << '@'; 825 continue; 826 } else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) { 827 mangleObjCMethodName(Method); 828 } else if (isa<NamedDecl>(DC)) { 829 ND = cast<NamedDecl>(DC); 830 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { 831 mangle(FD, "?"); 832 break; 833 } else 834 mangleUnqualifiedName(ND); 835 } 836 DC = DC->getParent(); 837 } 838} 839 840void MicrosoftCXXNameMangler::mangleCXXDtorType(CXXDtorType T) { 841 // Microsoft uses the names on the case labels for these dtor variants. Clang 842 // uses the Itanium terminology internally. Everything in this ABI delegates 843 // towards the base dtor. 844 switch (T) { 845 // <operator-name> ::= ?1 # destructor 846 case Dtor_Base: Out << "?1"; return; 847 // <operator-name> ::= ?_D # vbase destructor 848 case Dtor_Complete: Out << "?_D"; return; 849 // <operator-name> ::= ?_G # scalar deleting destructor 850 case Dtor_Deleting: Out << "?_G"; return; 851 // <operator-name> ::= ?_E # vector deleting destructor 852 // FIXME: Add a vector deleting dtor type. It goes in the vtable, so we need 853 // it. 854 case Dtor_Comdat: 855 llvm_unreachable("not expecting a COMDAT"); 856 } 857 llvm_unreachable("Unsupported dtor type?"); 858} 859 860void MicrosoftCXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO, 861 SourceLocation Loc) { 862 switch (OO) { 863 // ?0 # constructor 864 // ?1 # destructor 865 // <operator-name> ::= ?2 # new 866 case OO_New: Out << "?2"; break; 867 // <operator-name> ::= ?3 # delete 868 case OO_Delete: Out << "?3"; break; 869 // <operator-name> ::= ?4 # = 870 case OO_Equal: Out << "?4"; break; 871 // <operator-name> ::= ?5 # >> 872 case OO_GreaterGreater: Out << "?5"; break; 873 // <operator-name> ::= ?6 # << 874 case OO_LessLess: Out << "?6"; break; 875 // <operator-name> ::= ?7 # ! 876 case OO_Exclaim: Out << "?7"; break; 877 // <operator-name> ::= ?8 # == 878 case OO_EqualEqual: Out << "?8"; break; 879 // <operator-name> ::= ?9 # != 880 case OO_ExclaimEqual: Out << "?9"; break; 881 // <operator-name> ::= ?A # [] 882 case OO_Subscript: Out << "?A"; break; 883 // ?B # conversion 884 // <operator-name> ::= ?C # -> 885 case OO_Arrow: Out << "?C"; break; 886 // <operator-name> ::= ?D # * 887 case OO_Star: Out << "?D"; break; 888 // <operator-name> ::= ?E # ++ 889 case OO_PlusPlus: Out << "?E"; break; 890 // <operator-name> ::= ?F # -- 891 case OO_MinusMinus: Out << "?F"; break; 892 // <operator-name> ::= ?G # - 893 case OO_Minus: Out << "?G"; break; 894 // <operator-name> ::= ?H # + 895 case OO_Plus: Out << "?H"; break; 896 // <operator-name> ::= ?I # & 897 case OO_Amp: Out << "?I"; break; 898 // <operator-name> ::= ?J # ->* 899 case OO_ArrowStar: Out << "?J"; break; 900 // <operator-name> ::= ?K # / 901 case OO_Slash: Out << "?K"; break; 902 // <operator-name> ::= ?L # % 903 case OO_Percent: Out << "?L"; break; 904 // <operator-name> ::= ?M # < 905 case OO_Less: Out << "?M"; break; 906 // <operator-name> ::= ?N # <= 907 case OO_LessEqual: Out << "?N"; break; 908 // <operator-name> ::= ?O # > 909 case OO_Greater: Out << "?O"; break; 910 // <operator-name> ::= ?P # >= 911 case OO_GreaterEqual: Out << "?P"; break; 912 // <operator-name> ::= ?Q # , 913 case OO_Comma: Out << "?Q"; break; 914 // <operator-name> ::= ?R # () 915 case OO_Call: Out << "?R"; break; 916 // <operator-name> ::= ?S # ~ 917 case OO_Tilde: Out << "?S"; break; 918 // <operator-name> ::= ?T # ^ 919 case OO_Caret: Out << "?T"; break; 920 // <operator-name> ::= ?U # | 921 case OO_Pipe: Out << "?U"; break; 922 // <operator-name> ::= ?V # && 923 case OO_AmpAmp: Out << "?V"; break; 924 // <operator-name> ::= ?W # || 925 case OO_PipePipe: Out << "?W"; break; 926 // <operator-name> ::= ?X # *= 927 case OO_StarEqual: Out << "?X"; break; 928 // <operator-name> ::= ?Y # += 929 case OO_PlusEqual: Out << "?Y"; break; 930 // <operator-name> ::= ?Z # -= 931 case OO_MinusEqual: Out << "?Z"; break; 932 // <operator-name> ::= ?_0 # /= 933 case OO_SlashEqual: Out << "?_0"; break; 934 // <operator-name> ::= ?_1 # %= 935 case OO_PercentEqual: Out << "?_1"; break; 936 // <operator-name> ::= ?_2 # >>= 937 case OO_GreaterGreaterEqual: Out << "?_2"; break; 938 // <operator-name> ::= ?_3 # <<= 939 case OO_LessLessEqual: Out << "?_3"; break; 940 // <operator-name> ::= ?_4 # &= 941 case OO_AmpEqual: Out << "?_4"; break; 942 // <operator-name> ::= ?_5 # |= 943 case OO_PipeEqual: Out << "?_5"; break; 944 // <operator-name> ::= ?_6 # ^= 945 case OO_CaretEqual: Out << "?_6"; break; 946 // ?_7 # vftable 947 // ?_8 # vbtable 948 // ?_9 # vcall 949 // ?_A # typeof 950 // ?_B # local static guard 951 // ?_C # string 952 // ?_D # vbase destructor 953 // ?_E # vector deleting destructor 954 // ?_F # default constructor closure 955 // ?_G # scalar deleting destructor 956 // ?_H # vector constructor iterator 957 // ?_I # vector destructor iterator 958 // ?_J # vector vbase constructor iterator 959 // ?_K # virtual displacement map 960 // ?_L # eh vector constructor iterator 961 // ?_M # eh vector destructor iterator 962 // ?_N # eh vector vbase constructor iterator 963 // ?_O # copy constructor closure 964 // ?_P<name> # udt returning <name> 965 // ?_Q # <unknown> 966 // ?_R0 # RTTI Type Descriptor 967 // ?_R1 # RTTI Base Class Descriptor at (a,b,c,d) 968 // ?_R2 # RTTI Base Class Array 969 // ?_R3 # RTTI Class Hierarchy Descriptor 970 // ?_R4 # RTTI Complete Object Locator 971 // ?_S # local vftable 972 // ?_T # local vftable constructor closure 973 // <operator-name> ::= ?_U # new[] 974 case OO_Array_New: Out << "?_U"; break; 975 // <operator-name> ::= ?_V # delete[] 976 case OO_Array_Delete: Out << "?_V"; break; 977 978 case OO_Conditional: { 979 DiagnosticsEngine &Diags = Context.getDiags(); 980 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 981 "cannot mangle this conditional operator yet"); 982 Diags.Report(Loc, DiagID); 983 break; 984 } 985 986 case OO_None: 987 case NUM_OVERLOADED_OPERATORS: 988 llvm_unreachable("Not an overloaded operator"); 989 } 990} 991 992void MicrosoftCXXNameMangler::mangleSourceName(StringRef Name) { 993 // <source name> ::= <identifier> @ 994 BackRefVec::iterator Found = 995 std::find(NameBackReferences.begin(), NameBackReferences.end(), Name); 996 if (Found == NameBackReferences.end()) { 997 if (NameBackReferences.size() < 10) 998 NameBackReferences.push_back(Name); 999 Out << Name << '@'; 1000 } else { 1001 Out << (Found - NameBackReferences.begin()); 1002 } 1003} 1004 1005void MicrosoftCXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) { 1006 Context.mangleObjCMethodName(MD, Out); 1007} 1008 1009void MicrosoftCXXNameMangler::mangleTemplateInstantiationName( 1010 const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) { 1011 // <template-name> ::= <unscoped-template-name> <template-args> 1012 // ::= <substitution> 1013 // Always start with the unqualified name. 1014 1015 // Templates have their own context for back references. 1016 ArgBackRefMap OuterArgsContext; 1017 BackRefVec OuterTemplateContext; 1018 NameBackReferences.swap(OuterTemplateContext); 1019 TypeBackReferences.swap(OuterArgsContext); 1020 1021 mangleUnscopedTemplateName(TD); 1022 mangleTemplateArgs(TD, TemplateArgs); 1023 1024 // Restore the previous back reference contexts. 1025 NameBackReferences.swap(OuterTemplateContext); 1026 TypeBackReferences.swap(OuterArgsContext); 1027} 1028 1029void 1030MicrosoftCXXNameMangler::mangleUnscopedTemplateName(const TemplateDecl *TD) { 1031 // <unscoped-template-name> ::= ?$ <unqualified-name> 1032 Out << "?$"; 1033 mangleUnqualifiedName(TD); 1034} 1035 1036void MicrosoftCXXNameMangler::mangleIntegerLiteral(const llvm::APSInt &Value, 1037 bool IsBoolean) { 1038 // <integer-literal> ::= $0 <number> 1039 Out << "$0"; 1040 // Make sure booleans are encoded as 0/1. 1041 if (IsBoolean && Value.getBoolValue()) 1042 mangleNumber(1); 1043 else if (Value.isSigned()) 1044 mangleNumber(Value.getSExtValue()); 1045 else 1046 mangleNumber(Value.getZExtValue()); 1047} 1048 1049void MicrosoftCXXNameMangler::mangleExpression(const Expr *E) { 1050 // See if this is a constant expression. 1051 llvm::APSInt Value; 1052 if (E->isIntegerConstantExpr(Value, Context.getASTContext())) { 1053 mangleIntegerLiteral(Value, E->getType()->isBooleanType()); 1054 return; 1055 } 1056 1057 // Look through no-op casts like template parameter substitutions. 1058 E = E->IgnoreParenNoopCasts(Context.getASTContext()); 1059 1060 const CXXUuidofExpr *UE = nullptr; 1061 if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) { 1062 if (UO->getOpcode() == UO_AddrOf) 1063 UE = dyn_cast<CXXUuidofExpr>(UO->getSubExpr()); 1064 } else 1065 UE = dyn_cast<CXXUuidofExpr>(E); 1066 1067 if (UE) { 1068 // This CXXUuidofExpr is mangled as-if it were actually a VarDecl from 1069 // const __s_GUID _GUID_{lower case UUID with underscores} 1070 StringRef Uuid = UE->getUuidAsStringRef(Context.getASTContext()); 1071 std::string Name = "_GUID_" + Uuid.lower(); 1072 std::replace(Name.begin(), Name.end(), '-', '_'); 1073 1074 // If we had to peek through an address-of operator, treat this like we are 1075 // dealing with a pointer type. Otherwise, treat it like a const reference. 1076 // 1077 // N.B. This matches up with the handling of TemplateArgument::Declaration 1078 // in mangleTemplateArg 1079 if (UE == E) 1080 Out << "$E?"; 1081 else 1082 Out << "$1?"; 1083 Out << Name << "@@3U__s_GUID@@B"; 1084 return; 1085 } 1086 1087 // As bad as this diagnostic is, it's better than crashing. 1088 DiagnosticsEngine &Diags = Context.getDiags(); 1089 unsigned DiagID = Diags.getCustomDiagID( 1090 DiagnosticsEngine::Error, "cannot yet mangle expression type %0"); 1091 Diags.Report(E->getExprLoc(), DiagID) << E->getStmtClassName() 1092 << E->getSourceRange(); 1093} 1094 1095void MicrosoftCXXNameMangler::mangleTemplateArgs( 1096 const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) { 1097 // <template-args> ::= <template-arg>+ 1098 const TemplateParameterList *TPL = TD->getTemplateParameters(); 1099 assert(TPL->size() == TemplateArgs.size() && 1100 "size mismatch between args and parms!"); 1101 1102 unsigned Idx = 0; 1103 for (const TemplateArgument &TA : TemplateArgs.asArray()) 1104 mangleTemplateArg(TD, TA, TPL->getParam(Idx++)); 1105} 1106 1107void MicrosoftCXXNameMangler::mangleTemplateArg(const TemplateDecl *TD, 1108 const TemplateArgument &TA, 1109 const NamedDecl *Parm) { 1110 // <template-arg> ::= <type> 1111 // ::= <integer-literal> 1112 // ::= <member-data-pointer> 1113 // ::= <member-function-pointer> 1114 // ::= $E? <name> <type-encoding> 1115 // ::= $1? <name> <type-encoding> 1116 // ::= $0A@ 1117 // ::= <template-args> 1118 1119 switch (TA.getKind()) { 1120 case TemplateArgument::Null: 1121 llvm_unreachable("Can't mangle null template arguments!"); 1122 case TemplateArgument::TemplateExpansion: 1123 llvm_unreachable("Can't mangle template expansion arguments!"); 1124 case TemplateArgument::Type: { 1125 QualType T = TA.getAsType(); 1126 mangleType(T, SourceRange(), QMM_Escape); 1127 break; 1128 } 1129 case TemplateArgument::Declaration: { 1130 const NamedDecl *ND = cast<NamedDecl>(TA.getAsDecl()); 1131 if (isa<FieldDecl>(ND) || isa<IndirectFieldDecl>(ND)) { 1132 mangleMemberDataPointer( 1133 cast<CXXRecordDecl>(ND->getDeclContext())->getMostRecentDecl(), 1134 cast<ValueDecl>(ND)); 1135 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { 1136 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD); 1137 if (MD && MD->isInstance()) 1138 mangleMemberFunctionPointer(MD->getParent()->getMostRecentDecl(), MD); 1139 else 1140 mangle(FD, "$1?"); 1141 } else { 1142 mangle(ND, TA.getParamTypeForDecl()->isReferenceType() ? "$E?" : "$1?"); 1143 } 1144 break; 1145 } 1146 case TemplateArgument::Integral: 1147 mangleIntegerLiteral(TA.getAsIntegral(), 1148 TA.getIntegralType()->isBooleanType()); 1149 break; 1150 case TemplateArgument::NullPtr: { 1151 QualType T = TA.getNullPtrType(); 1152 if (const MemberPointerType *MPT = T->getAs<MemberPointerType>()) { 1153 const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl(); 1154 if (MPT->isMemberFunctionPointerType() && isa<ClassTemplateDecl>(TD)) { 1155 mangleMemberFunctionPointer(RD, nullptr); 1156 return; 1157 } 1158 if (MPT->isMemberDataPointer()) { 1159 mangleMemberDataPointer(RD, nullptr); 1160 return; 1161 } 1162 } 1163 Out << "$0A@"; 1164 break; 1165 } 1166 case TemplateArgument::Expression: 1167 mangleExpression(TA.getAsExpr()); 1168 break; 1169 case TemplateArgument::Pack: { 1170 ArrayRef<TemplateArgument> TemplateArgs = TA.getPackAsArray(); 1171 if (TemplateArgs.empty()) { 1172 if (isa<TemplateTypeParmDecl>(Parm) || 1173 isa<TemplateTemplateParmDecl>(Parm)) 1174 Out << "$$V"; 1175 else if (isa<NonTypeTemplateParmDecl>(Parm)) 1176 Out << "$S"; 1177 else 1178 llvm_unreachable("unexpected template parameter decl!"); 1179 } else { 1180 for (const TemplateArgument &PA : TemplateArgs) 1181 mangleTemplateArg(TD, PA, Parm); 1182 } 1183 break; 1184 } 1185 case TemplateArgument::Template: { 1186 const NamedDecl *ND = 1187 TA.getAsTemplate().getAsTemplateDecl()->getTemplatedDecl(); 1188 if (const auto *TD = dyn_cast<TagDecl>(ND)) { 1189 mangleType(TD); 1190 } else if (isa<TypeAliasDecl>(ND)) { 1191 Out << "$$Y"; 1192 mangleName(ND); 1193 } else { 1194 llvm_unreachable("unexpected template template NamedDecl!"); 1195 } 1196 break; 1197 } 1198 } 1199} 1200 1201void MicrosoftCXXNameMangler::mangleQualifiers(Qualifiers Quals, 1202 bool IsMember) { 1203 // <cvr-qualifiers> ::= [E] [F] [I] <base-cvr-qualifiers> 1204 // 'E' means __ptr64 (32-bit only); 'F' means __unaligned (32/64-bit only); 1205 // 'I' means __restrict (32/64-bit). 1206 // Note that the MSVC __restrict keyword isn't the same as the C99 restrict 1207 // keyword! 1208 // <base-cvr-qualifiers> ::= A # near 1209 // ::= B # near const 1210 // ::= C # near volatile 1211 // ::= D # near const volatile 1212 // ::= E # far (16-bit) 1213 // ::= F # far const (16-bit) 1214 // ::= G # far volatile (16-bit) 1215 // ::= H # far const volatile (16-bit) 1216 // ::= I # huge (16-bit) 1217 // ::= J # huge const (16-bit) 1218 // ::= K # huge volatile (16-bit) 1219 // ::= L # huge const volatile (16-bit) 1220 // ::= M <basis> # based 1221 // ::= N <basis> # based const 1222 // ::= O <basis> # based volatile 1223 // ::= P <basis> # based const volatile 1224 // ::= Q # near member 1225 // ::= R # near const member 1226 // ::= S # near volatile member 1227 // ::= T # near const volatile member 1228 // ::= U # far member (16-bit) 1229 // ::= V # far const member (16-bit) 1230 // ::= W # far volatile member (16-bit) 1231 // ::= X # far const volatile member (16-bit) 1232 // ::= Y # huge member (16-bit) 1233 // ::= Z # huge const member (16-bit) 1234 // ::= 0 # huge volatile member (16-bit) 1235 // ::= 1 # huge const volatile member (16-bit) 1236 // ::= 2 <basis> # based member 1237 // ::= 3 <basis> # based const member 1238 // ::= 4 <basis> # based volatile member 1239 // ::= 5 <basis> # based const volatile member 1240 // ::= 6 # near function (pointers only) 1241 // ::= 7 # far function (pointers only) 1242 // ::= 8 # near method (pointers only) 1243 // ::= 9 # far method (pointers only) 1244 // ::= _A <basis> # based function (pointers only) 1245 // ::= _B <basis> # based function (far?) (pointers only) 1246 // ::= _C <basis> # based method (pointers only) 1247 // ::= _D <basis> # based method (far?) (pointers only) 1248 // ::= _E # block (Clang) 1249 // <basis> ::= 0 # __based(void) 1250 // ::= 1 # __based(segment)? 1251 // ::= 2 <name> # __based(name) 1252 // ::= 3 # ? 1253 // ::= 4 # ? 1254 // ::= 5 # not really based 1255 bool HasConst = Quals.hasConst(), 1256 HasVolatile = Quals.hasVolatile(); 1257 1258 if (!IsMember) { 1259 if (HasConst && HasVolatile) { 1260 Out << 'D'; 1261 } else if (HasVolatile) { 1262 Out << 'C'; 1263 } else if (HasConst) { 1264 Out << 'B'; 1265 } else { 1266 Out << 'A'; 1267 } 1268 } else { 1269 if (HasConst && HasVolatile) { 1270 Out << 'T'; 1271 } else if (HasVolatile) { 1272 Out << 'S'; 1273 } else if (HasConst) { 1274 Out << 'R'; 1275 } else { 1276 Out << 'Q'; 1277 } 1278 } 1279 1280 // FIXME: For now, just drop all extension qualifiers on the floor. 1281} 1282 1283void 1284MicrosoftCXXNameMangler::mangleRefQualifier(RefQualifierKind RefQualifier) { 1285 // <ref-qualifier> ::= G # lvalue reference 1286 // ::= H # rvalue-reference 1287 switch (RefQualifier) { 1288 case RQ_None: 1289 break; 1290 1291 case RQ_LValue: 1292 Out << 'G'; 1293 break; 1294 1295 case RQ_RValue: 1296 Out << 'H'; 1297 break; 1298 } 1299} 1300 1301void 1302MicrosoftCXXNameMangler::manglePointerExtQualifiers(Qualifiers Quals, 1303 const Type *PointeeType) { 1304 bool HasRestrict = Quals.hasRestrict(); 1305 if (PointersAre64Bit && (!PointeeType || !PointeeType->isFunctionType())) 1306 Out << 'E'; 1307 1308 if (HasRestrict) 1309 Out << 'I'; 1310} 1311 1312void MicrosoftCXXNameMangler::manglePointerCVQualifiers(Qualifiers Quals) { 1313 // <pointer-cv-qualifiers> ::= P # no qualifiers 1314 // ::= Q # const 1315 // ::= R # volatile 1316 // ::= S # const volatile 1317 bool HasConst = Quals.hasConst(), 1318 HasVolatile = Quals.hasVolatile(); 1319 1320 if (HasConst && HasVolatile) { 1321 Out << 'S'; 1322 } else if (HasVolatile) { 1323 Out << 'R'; 1324 } else if (HasConst) { 1325 Out << 'Q'; 1326 } else { 1327 Out << 'P'; 1328 } 1329} 1330 1331void MicrosoftCXXNameMangler::mangleArgumentType(QualType T, 1332 SourceRange Range) { 1333 // MSVC will backreference two canonically equivalent types that have slightly 1334 // different manglings when mangled alone. 1335 1336 // Decayed types do not match up with non-decayed versions of the same type. 1337 // 1338 // e.g. 1339 // void (*x)(void) will not form a backreference with void x(void) 1340 void *TypePtr; 1341 if (const DecayedType *DT = T->getAs<DecayedType>()) { 1342 TypePtr = DT->getOriginalType().getCanonicalType().getAsOpaquePtr(); 1343 // If the original parameter was textually written as an array, 1344 // instead treat the decayed parameter like it's const. 1345 // 1346 // e.g. 1347 // int [] -> int * const 1348 if (DT->getOriginalType()->isArrayType()) 1349 T = T.withConst(); 1350 } else 1351 TypePtr = T.getCanonicalType().getAsOpaquePtr(); 1352 1353 ArgBackRefMap::iterator Found = TypeBackReferences.find(TypePtr); 1354 1355 if (Found == TypeBackReferences.end()) { 1356 size_t OutSizeBefore = Out.GetNumBytesInBuffer(); 1357 1358 mangleType(T, Range, QMM_Drop); 1359 1360 // See if it's worth creating a back reference. 1361 // Only types longer than 1 character are considered 1362 // and only 10 back references slots are available: 1363 bool LongerThanOneChar = (Out.GetNumBytesInBuffer() - OutSizeBefore > 1); 1364 if (LongerThanOneChar && TypeBackReferences.size() < 10) { 1365 size_t Size = TypeBackReferences.size(); 1366 TypeBackReferences[TypePtr] = Size; 1367 } 1368 } else { 1369 Out << Found->second; 1370 } 1371} 1372 1373void MicrosoftCXXNameMangler::mangleType(QualType T, SourceRange Range, 1374 QualifierMangleMode QMM) { 1375 // Don't use the canonical types. MSVC includes things like 'const' on 1376 // pointer arguments to function pointers that canonicalization strips away. 1377 T = T.getDesugaredType(getASTContext()); 1378 Qualifiers Quals = T.getLocalQualifiers(); 1379 if (const ArrayType *AT = getASTContext().getAsArrayType(T)) { 1380 // If there were any Quals, getAsArrayType() pushed them onto the array 1381 // element type. 1382 if (QMM == QMM_Mangle) 1383 Out << 'A'; 1384 else if (QMM == QMM_Escape || QMM == QMM_Result) 1385 Out << "$$B"; 1386 mangleArrayType(AT); 1387 return; 1388 } 1389 1390 bool IsPointer = T->isAnyPointerType() || T->isMemberPointerType() || 1391 T->isBlockPointerType(); 1392 1393 switch (QMM) { 1394 case QMM_Drop: 1395 break; 1396 case QMM_Mangle: 1397 if (const FunctionType *FT = dyn_cast<FunctionType>(T)) { 1398 Out << '6'; 1399 mangleFunctionType(FT); 1400 return; 1401 } 1402 mangleQualifiers(Quals, false); 1403 break; 1404 case QMM_Escape: 1405 if (!IsPointer && Quals) { 1406 Out << "$$C"; 1407 mangleQualifiers(Quals, false); 1408 } 1409 break; 1410 case QMM_Result: 1411 if ((!IsPointer && Quals) || isa<TagType>(T)) { 1412 Out << '?'; 1413 mangleQualifiers(Quals, false); 1414 } 1415 break; 1416 } 1417 1418 // We have to mangle these now, while we still have enough information. 1419 if (IsPointer) { 1420 manglePointerCVQualifiers(Quals); 1421 manglePointerExtQualifiers(Quals, T->getPointeeType().getTypePtr()); 1422 } 1423 const Type *ty = T.getTypePtr(); 1424 1425 switch (ty->getTypeClass()) { 1426#define ABSTRACT_TYPE(CLASS, PARENT) 1427#define NON_CANONICAL_TYPE(CLASS, PARENT) \ 1428 case Type::CLASS: \ 1429 llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \ 1430 return; 1431#define TYPE(CLASS, PARENT) \ 1432 case Type::CLASS: \ 1433 mangleType(cast<CLASS##Type>(ty), Range); \ 1434 break; 1435#include "clang/AST/TypeNodes.def" 1436#undef ABSTRACT_TYPE 1437#undef NON_CANONICAL_TYPE 1438#undef TYPE 1439 } 1440} 1441 1442void MicrosoftCXXNameMangler::mangleType(const BuiltinType *T, 1443 SourceRange Range) { 1444 // <type> ::= <builtin-type> 1445 // <builtin-type> ::= X # void 1446 // ::= C # signed char 1447 // ::= D # char 1448 // ::= E # unsigned char 1449 // ::= F # short 1450 // ::= G # unsigned short (or wchar_t if it's not a builtin) 1451 // ::= H # int 1452 // ::= I # unsigned int 1453 // ::= J # long 1454 // ::= K # unsigned long 1455 // L # <none> 1456 // ::= M # float 1457 // ::= N # double 1458 // ::= O # long double (__float80 is mangled differently) 1459 // ::= _J # long long, __int64 1460 // ::= _K # unsigned long long, __int64 1461 // ::= _L # __int128 1462 // ::= _M # unsigned __int128 1463 // ::= _N # bool 1464 // _O # <array in parameter> 1465 // ::= _T # __float80 (Intel) 1466 // ::= _W # wchar_t 1467 // ::= _Z # __float80 (Digital Mars) 1468 switch (T->getKind()) { 1469 case BuiltinType::Void: Out << 'X'; break; 1470 case BuiltinType::SChar: Out << 'C'; break; 1471 case BuiltinType::Char_U: case BuiltinType::Char_S: Out << 'D'; break; 1472 case BuiltinType::UChar: Out << 'E'; break; 1473 case BuiltinType::Short: Out << 'F'; break; 1474 case BuiltinType::UShort: Out << 'G'; break; 1475 case BuiltinType::Int: Out << 'H'; break; 1476 case BuiltinType::UInt: Out << 'I'; break; 1477 case BuiltinType::Long: Out << 'J'; break; 1478 case BuiltinType::ULong: Out << 'K'; break; 1479 case BuiltinType::Float: Out << 'M'; break; 1480 case BuiltinType::Double: Out << 'N'; break; 1481 // TODO: Determine size and mangle accordingly 1482 case BuiltinType::LongDouble: Out << 'O'; break; 1483 case BuiltinType::LongLong: Out << "_J"; break; 1484 case BuiltinType::ULongLong: Out << "_K"; break; 1485 case BuiltinType::Int128: Out << "_L"; break; 1486 case BuiltinType::UInt128: Out << "_M"; break; 1487 case BuiltinType::Bool: Out << "_N"; break; 1488 case BuiltinType::Char16: Out << "_S"; break; 1489 case BuiltinType::Char32: Out << "_U"; break; 1490 case BuiltinType::WChar_S: 1491 case BuiltinType::WChar_U: Out << "_W"; break; 1492 1493#define BUILTIN_TYPE(Id, SingletonId) 1494#define PLACEHOLDER_TYPE(Id, SingletonId) \ 1495 case BuiltinType::Id: 1496#include "clang/AST/BuiltinTypes.def" 1497 case BuiltinType::Dependent: 1498 llvm_unreachable("placeholder types shouldn't get to name mangling"); 1499 1500 case BuiltinType::ObjCId: Out << "PAUobjc_object@@"; break; 1501 case BuiltinType::ObjCClass: Out << "PAUobjc_class@@"; break; 1502 case BuiltinType::ObjCSel: Out << "PAUobjc_selector@@"; break; 1503 1504 case BuiltinType::OCLImage1d: Out << "PAUocl_image1d@@"; break; 1505 case BuiltinType::OCLImage1dArray: Out << "PAUocl_image1darray@@"; break; 1506 case BuiltinType::OCLImage1dBuffer: Out << "PAUocl_image1dbuffer@@"; break; 1507 case BuiltinType::OCLImage2d: Out << "PAUocl_image2d@@"; break; 1508 case BuiltinType::OCLImage2dArray: Out << "PAUocl_image2darray@@"; break; 1509 case BuiltinType::OCLImage3d: Out << "PAUocl_image3d@@"; break; 1510 case BuiltinType::OCLSampler: Out << "PAUocl_sampler@@"; break; 1511 case BuiltinType::OCLEvent: Out << "PAUocl_event@@"; break; 1512 1513 case BuiltinType::NullPtr: Out << "$$T"; break; 1514 1515 case BuiltinType::Half: { 1516 DiagnosticsEngine &Diags = Context.getDiags(); 1517 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 1518 "cannot mangle this built-in %0 type yet"); 1519 Diags.Report(Range.getBegin(), DiagID) 1520 << T->getName(Context.getASTContext().getPrintingPolicy()) 1521 << Range; 1522 break; 1523 } 1524 } 1525} 1526 1527// <type> ::= <function-type> 1528void MicrosoftCXXNameMangler::mangleType(const FunctionProtoType *T, 1529 SourceRange) { 1530 // Structors only appear in decls, so at this point we know it's not a 1531 // structor type. 1532 // FIXME: This may not be lambda-friendly. 1533 if (T->getTypeQuals() || T->getRefQualifier() != RQ_None) { 1534 Out << "$$A8@@"; 1535 mangleFunctionType(T, /*D=*/nullptr, /*ForceThisQuals=*/true); 1536 } else { 1537 Out << "$$A6"; 1538 mangleFunctionType(T); 1539 } 1540} 1541void MicrosoftCXXNameMangler::mangleType(const FunctionNoProtoType *T, 1542 SourceRange) { 1543 llvm_unreachable("Can't mangle K&R function prototypes"); 1544} 1545 1546void MicrosoftCXXNameMangler::mangleFunctionType(const FunctionType *T, 1547 const FunctionDecl *D, 1548 bool ForceThisQuals) { 1549 // <function-type> ::= <this-cvr-qualifiers> <calling-convention> 1550 // <return-type> <argument-list> <throw-spec> 1551 const FunctionProtoType *Proto = cast<FunctionProtoType>(T); 1552 1553 SourceRange Range; 1554 if (D) Range = D->getSourceRange(); 1555 1556 bool IsStructor = false, HasThisQuals = ForceThisQuals; 1557 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(D)) { 1558 if (MD->isInstance()) 1559 HasThisQuals = true; 1560 if (isa<CXXConstructorDecl>(MD) || isa<CXXDestructorDecl>(MD)) 1561 IsStructor = true; 1562 } 1563 1564 // If this is a C++ instance method, mangle the CVR qualifiers for the 1565 // this pointer. 1566 if (HasThisQuals) { 1567 Qualifiers Quals = Qualifiers::fromCVRMask(Proto->getTypeQuals()); 1568 manglePointerExtQualifiers(Quals, /*PointeeType=*/nullptr); 1569 mangleRefQualifier(Proto->getRefQualifier()); 1570 mangleQualifiers(Quals, /*IsMember=*/false); 1571 } 1572 1573 mangleCallingConvention(T); 1574 1575 // <return-type> ::= <type> 1576 // ::= @ # structors (they have no declared return type) 1577 if (IsStructor) { 1578 if (isa<CXXDestructorDecl>(D) && D == Structor && 1579 StructorType == Dtor_Deleting) { 1580 // The scalar deleting destructor takes an extra int argument. 1581 // However, the FunctionType generated has 0 arguments. 1582 // FIXME: This is a temporary hack. 1583 // Maybe should fix the FunctionType creation instead? 1584 Out << (PointersAre64Bit ? "PEAXI@Z" : "PAXI@Z"); 1585 return; 1586 } 1587 Out << '@'; 1588 } else { 1589 QualType ResultType = Proto->getReturnType(); 1590 if (const auto *AT = 1591 dyn_cast_or_null<AutoType>(ResultType->getContainedAutoType())) { 1592 Out << '?'; 1593 mangleQualifiers(ResultType.getLocalQualifiers(), /*IsMember=*/false); 1594 Out << '?'; 1595 mangleSourceName(AT->isDecltypeAuto() ? "<decltype-auto>" : "<auto>"); 1596 Out << '@'; 1597 } else { 1598 if (ResultType->isVoidType()) 1599 ResultType = ResultType.getUnqualifiedType(); 1600 mangleType(ResultType, Range, QMM_Result); 1601 } 1602 } 1603 1604 // <argument-list> ::= X # void 1605 // ::= <type>+ @ 1606 // ::= <type>* Z # varargs 1607 if (Proto->getNumParams() == 0 && !Proto->isVariadic()) { 1608 Out << 'X'; 1609 } else { 1610 // Happens for function pointer type arguments for example. 1611 for (const QualType Arg : Proto->param_types()) 1612 mangleArgumentType(Arg, Range); 1613 // <builtin-type> ::= Z # ellipsis 1614 if (Proto->isVariadic()) 1615 Out << 'Z'; 1616 else 1617 Out << '@'; 1618 } 1619 1620 mangleThrowSpecification(Proto); 1621} 1622 1623void MicrosoftCXXNameMangler::mangleFunctionClass(const FunctionDecl *FD) { 1624 // <function-class> ::= <member-function> E? # E designates a 64-bit 'this' 1625 // # pointer. in 64-bit mode *all* 1626 // # 'this' pointers are 64-bit. 1627 // ::= <global-function> 1628 // <member-function> ::= A # private: near 1629 // ::= B # private: far 1630 // ::= C # private: static near 1631 // ::= D # private: static far 1632 // ::= E # private: virtual near 1633 // ::= F # private: virtual far 1634 // ::= I # protected: near 1635 // ::= J # protected: far 1636 // ::= K # protected: static near 1637 // ::= L # protected: static far 1638 // ::= M # protected: virtual near 1639 // ::= N # protected: virtual far 1640 // ::= Q # public: near 1641 // ::= R # public: far 1642 // ::= S # public: static near 1643 // ::= T # public: static far 1644 // ::= U # public: virtual near 1645 // ::= V # public: virtual far 1646 // <global-function> ::= Y # global near 1647 // ::= Z # global far 1648 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 1649 switch (MD->getAccess()) { 1650 case AS_none: 1651 llvm_unreachable("Unsupported access specifier"); 1652 case AS_private: 1653 if (MD->isStatic()) 1654 Out << 'C'; 1655 else if (MD->isVirtual()) 1656 Out << 'E'; 1657 else 1658 Out << 'A'; 1659 break; 1660 case AS_protected: 1661 if (MD->isStatic()) 1662 Out << 'K'; 1663 else if (MD->isVirtual()) 1664 Out << 'M'; 1665 else 1666 Out << 'I'; 1667 break; 1668 case AS_public: 1669 if (MD->isStatic()) 1670 Out << 'S'; 1671 else if (MD->isVirtual()) 1672 Out << 'U'; 1673 else 1674 Out << 'Q'; 1675 } 1676 } else 1677 Out << 'Y'; 1678} 1679void MicrosoftCXXNameMangler::mangleCallingConvention(const FunctionType *T) { 1680 // <calling-convention> ::= A # __cdecl 1681 // ::= B # __export __cdecl 1682 // ::= C # __pascal 1683 // ::= D # __export __pascal 1684 // ::= E # __thiscall 1685 // ::= F # __export __thiscall 1686 // ::= G # __stdcall 1687 // ::= H # __export __stdcall 1688 // ::= I # __fastcall 1689 // ::= J # __export __fastcall 1690 // ::= Q # __vectorcall 1691 // The 'export' calling conventions are from a bygone era 1692 // (*cough*Win16*cough*) when functions were declared for export with 1693 // that keyword. (It didn't actually export them, it just made them so 1694 // that they could be in a DLL and somebody from another module could call 1695 // them.) 1696 CallingConv CC = T->getCallConv(); 1697 switch (CC) { 1698 default: 1699 llvm_unreachable("Unsupported CC for mangling"); 1700 case CC_X86_64Win64: 1701 case CC_X86_64SysV: 1702 case CC_C: Out << 'A'; break; 1703 case CC_X86Pascal: Out << 'C'; break; 1704 case CC_X86ThisCall: Out << 'E'; break; 1705 case CC_X86StdCall: Out << 'G'; break; 1706 case CC_X86FastCall: Out << 'I'; break; 1707 case CC_X86VectorCall: Out << 'Q'; break; 1708 } 1709} 1710void MicrosoftCXXNameMangler::mangleThrowSpecification( 1711 const FunctionProtoType *FT) { 1712 // <throw-spec> ::= Z # throw(...) (default) 1713 // ::= @ # throw() or __declspec/__attribute__((nothrow)) 1714 // ::= <type>+ 1715 // NOTE: Since the Microsoft compiler ignores throw specifications, they are 1716 // all actually mangled as 'Z'. (They're ignored because their associated 1717 // functionality isn't implemented, and probably never will be.) 1718 Out << 'Z'; 1719} 1720 1721void MicrosoftCXXNameMangler::mangleType(const UnresolvedUsingType *T, 1722 SourceRange Range) { 1723 // Probably should be mangled as a template instantiation; need to see what 1724 // VC does first. 1725 DiagnosticsEngine &Diags = Context.getDiags(); 1726 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 1727 "cannot mangle this unresolved dependent type yet"); 1728 Diags.Report(Range.getBegin(), DiagID) 1729 << Range; 1730} 1731 1732// <type> ::= <union-type> | <struct-type> | <class-type> | <enum-type> 1733// <union-type> ::= T <name> 1734// <struct-type> ::= U <name> 1735// <class-type> ::= V <name> 1736// <enum-type> ::= W4 <name> 1737void MicrosoftCXXNameMangler::mangleType(const EnumType *T, SourceRange) { 1738 mangleType(cast<TagType>(T)->getDecl()); 1739} 1740void MicrosoftCXXNameMangler::mangleType(const RecordType *T, SourceRange) { 1741 mangleType(cast<TagType>(T)->getDecl()); 1742} 1743void MicrosoftCXXNameMangler::mangleType(const TagDecl *TD) { 1744 switch (TD->getTagKind()) { 1745 case TTK_Union: 1746 Out << 'T'; 1747 break; 1748 case TTK_Struct: 1749 case TTK_Interface: 1750 Out << 'U'; 1751 break; 1752 case TTK_Class: 1753 Out << 'V'; 1754 break; 1755 case TTK_Enum: 1756 Out << "W4"; 1757 break; 1758 } 1759 mangleName(TD); 1760} 1761 1762// <type> ::= <array-type> 1763// <array-type> ::= <pointer-cvr-qualifiers> <cvr-qualifiers> 1764// [Y <dimension-count> <dimension>+] 1765// <element-type> # as global, E is never required 1766// It's supposed to be the other way around, but for some strange reason, it 1767// isn't. Today this behavior is retained for the sole purpose of backwards 1768// compatibility. 1769void MicrosoftCXXNameMangler::mangleDecayedArrayType(const ArrayType *T) { 1770 // This isn't a recursive mangling, so now we have to do it all in this 1771 // one call. 1772 manglePointerCVQualifiers(T->getElementType().getQualifiers()); 1773 mangleType(T->getElementType(), SourceRange()); 1774} 1775void MicrosoftCXXNameMangler::mangleType(const ConstantArrayType *T, 1776 SourceRange) { 1777 llvm_unreachable("Should have been special cased"); 1778} 1779void MicrosoftCXXNameMangler::mangleType(const VariableArrayType *T, 1780 SourceRange) { 1781 llvm_unreachable("Should have been special cased"); 1782} 1783void MicrosoftCXXNameMangler::mangleType(const DependentSizedArrayType *T, 1784 SourceRange) { 1785 llvm_unreachable("Should have been special cased"); 1786} 1787void MicrosoftCXXNameMangler::mangleType(const IncompleteArrayType *T, 1788 SourceRange) { 1789 llvm_unreachable("Should have been special cased"); 1790} 1791void MicrosoftCXXNameMangler::mangleArrayType(const ArrayType *T) { 1792 QualType ElementTy(T, 0); 1793 SmallVector<llvm::APInt, 3> Dimensions; 1794 for (;;) { 1795 if (const ConstantArrayType *CAT = 1796 getASTContext().getAsConstantArrayType(ElementTy)) { 1797 Dimensions.push_back(CAT->getSize()); 1798 ElementTy = CAT->getElementType(); 1799 } else if (ElementTy->isVariableArrayType()) { 1800 const VariableArrayType *VAT = 1801 getASTContext().getAsVariableArrayType(ElementTy); 1802 DiagnosticsEngine &Diags = Context.getDiags(); 1803 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 1804 "cannot mangle this variable-length array yet"); 1805 Diags.Report(VAT->getSizeExpr()->getExprLoc(), DiagID) 1806 << VAT->getBracketsRange(); 1807 return; 1808 } else if (ElementTy->isDependentSizedArrayType()) { 1809 // The dependent expression has to be folded into a constant (TODO). 1810 const DependentSizedArrayType *DSAT = 1811 getASTContext().getAsDependentSizedArrayType(ElementTy); 1812 DiagnosticsEngine &Diags = Context.getDiags(); 1813 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 1814 "cannot mangle this dependent-length array yet"); 1815 Diags.Report(DSAT->getSizeExpr()->getExprLoc(), DiagID) 1816 << DSAT->getBracketsRange(); 1817 return; 1818 } else if (const IncompleteArrayType *IAT = 1819 getASTContext().getAsIncompleteArrayType(ElementTy)) { 1820 Dimensions.push_back(llvm::APInt(32, 0)); 1821 ElementTy = IAT->getElementType(); 1822 } 1823 else break; 1824 } 1825 Out << 'Y'; 1826 // <dimension-count> ::= <number> # number of extra dimensions 1827 mangleNumber(Dimensions.size()); 1828 for (const llvm::APInt &Dimension : Dimensions) 1829 mangleNumber(Dimension.getLimitedValue()); 1830 mangleType(ElementTy, SourceRange(), QMM_Escape); 1831} 1832 1833// <type> ::= <pointer-to-member-type> 1834// <pointer-to-member-type> ::= <pointer-cvr-qualifiers> <cvr-qualifiers> 1835// <class name> <type> 1836void MicrosoftCXXNameMangler::mangleType(const MemberPointerType *T, 1837 SourceRange Range) { 1838 QualType PointeeType = T->getPointeeType(); 1839 if (const FunctionProtoType *FPT = PointeeType->getAs<FunctionProtoType>()) { 1840 Out << '8'; 1841 mangleName(T->getClass()->castAs<RecordType>()->getDecl()); 1842 mangleFunctionType(FPT, nullptr, true); 1843 } else { 1844 mangleQualifiers(PointeeType.getQualifiers(), true); 1845 mangleName(T->getClass()->castAs<RecordType>()->getDecl()); 1846 mangleType(PointeeType, Range, QMM_Drop); 1847 } 1848} 1849 1850void MicrosoftCXXNameMangler::mangleType(const TemplateTypeParmType *T, 1851 SourceRange Range) { 1852 DiagnosticsEngine &Diags = Context.getDiags(); 1853 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 1854 "cannot mangle this template type parameter type yet"); 1855 Diags.Report(Range.getBegin(), DiagID) 1856 << Range; 1857} 1858 1859void MicrosoftCXXNameMangler::mangleType( 1860 const SubstTemplateTypeParmPackType *T, 1861 SourceRange Range) { 1862 DiagnosticsEngine &Diags = Context.getDiags(); 1863 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 1864 "cannot mangle this substituted parameter pack yet"); 1865 Diags.Report(Range.getBegin(), DiagID) 1866 << Range; 1867} 1868 1869// <type> ::= <pointer-type> 1870// <pointer-type> ::= E? <pointer-cvr-qualifiers> <cvr-qualifiers> <type> 1871// # the E is required for 64-bit non-static pointers 1872void MicrosoftCXXNameMangler::mangleType(const PointerType *T, 1873 SourceRange Range) { 1874 QualType PointeeTy = T->getPointeeType(); 1875 mangleType(PointeeTy, Range); 1876} 1877void MicrosoftCXXNameMangler::mangleType(const ObjCObjectPointerType *T, 1878 SourceRange Range) { 1879 // Object pointers never have qualifiers. 1880 Out << 'A'; 1881 manglePointerExtQualifiers(Qualifiers(), T->getPointeeType().getTypePtr()); 1882 mangleType(T->getPointeeType(), Range); 1883} 1884 1885// <type> ::= <reference-type> 1886// <reference-type> ::= A E? <cvr-qualifiers> <type> 1887// # the E is required for 64-bit non-static lvalue references 1888void MicrosoftCXXNameMangler::mangleType(const LValueReferenceType *T, 1889 SourceRange Range) { 1890 Out << 'A'; 1891 manglePointerExtQualifiers(Qualifiers(), T->getPointeeType().getTypePtr()); 1892 mangleType(T->getPointeeType(), Range); 1893} 1894 1895// <type> ::= <r-value-reference-type> 1896// <r-value-reference-type> ::= $$Q E? <cvr-qualifiers> <type> 1897// # the E is required for 64-bit non-static rvalue references 1898void MicrosoftCXXNameMangler::mangleType(const RValueReferenceType *T, 1899 SourceRange Range) { 1900 Out << "$$Q"; 1901 manglePointerExtQualifiers(Qualifiers(), T->getPointeeType().getTypePtr()); 1902 mangleType(T->getPointeeType(), Range); 1903} 1904 1905void MicrosoftCXXNameMangler::mangleType(const ComplexType *T, 1906 SourceRange Range) { 1907 DiagnosticsEngine &Diags = Context.getDiags(); 1908 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 1909 "cannot mangle this complex number type yet"); 1910 Diags.Report(Range.getBegin(), DiagID) 1911 << Range; 1912} 1913 1914void MicrosoftCXXNameMangler::mangleType(const VectorType *T, 1915 SourceRange Range) { 1916 const BuiltinType *ET = T->getElementType()->getAs<BuiltinType>(); 1917 assert(ET && "vectors with non-builtin elements are unsupported"); 1918 uint64_t Width = getASTContext().getTypeSize(T); 1919 // Pattern match exactly the typedefs in our intrinsic headers. Anything that 1920 // doesn't match the Intel types uses a custom mangling below. 1921 bool IntelVector = true; 1922 if (Width == 64 && ET->getKind() == BuiltinType::LongLong) { 1923 Out << "T__m64"; 1924 } else if (Width == 128 || Width == 256) { 1925 if (ET->getKind() == BuiltinType::Float) 1926 Out << "T__m" << Width; 1927 else if (ET->getKind() == BuiltinType::LongLong) 1928 Out << "T__m" << Width << 'i'; 1929 else if (ET->getKind() == BuiltinType::Double) 1930 Out << "U__m" << Width << 'd'; 1931 else 1932 IntelVector = false; 1933 } else { 1934 IntelVector = false; 1935 } 1936 1937 if (!IntelVector) { 1938 // The MS ABI doesn't have a special mangling for vector types, so we define 1939 // our own mangling to handle uses of __vector_size__ on user-specified 1940 // types, and for extensions like __v4sf. 1941 Out << "T__clang_vec" << T->getNumElements() << '_'; 1942 mangleType(ET, Range); 1943 } 1944 1945 Out << "@@"; 1946} 1947 1948void MicrosoftCXXNameMangler::mangleType(const ExtVectorType *T, 1949 SourceRange Range) { 1950 DiagnosticsEngine &Diags = Context.getDiags(); 1951 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 1952 "cannot mangle this extended vector type yet"); 1953 Diags.Report(Range.getBegin(), DiagID) 1954 << Range; 1955} 1956void MicrosoftCXXNameMangler::mangleType(const DependentSizedExtVectorType *T, 1957 SourceRange Range) { 1958 DiagnosticsEngine &Diags = Context.getDiags(); 1959 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 1960 "cannot mangle this dependent-sized extended vector type yet"); 1961 Diags.Report(Range.getBegin(), DiagID) 1962 << Range; 1963} 1964 1965void MicrosoftCXXNameMangler::mangleType(const ObjCInterfaceType *T, 1966 SourceRange) { 1967 // ObjC interfaces have structs underlying them. 1968 Out << 'U'; 1969 mangleName(T->getDecl()); 1970} 1971 1972void MicrosoftCXXNameMangler::mangleType(const ObjCObjectType *T, 1973 SourceRange Range) { 1974 // We don't allow overloading by different protocol qualification, 1975 // so mangling them isn't necessary. 1976 mangleType(T->getBaseType(), Range); 1977} 1978 1979void MicrosoftCXXNameMangler::mangleType(const BlockPointerType *T, 1980 SourceRange Range) { 1981 Out << "_E"; 1982 1983 QualType pointee = T->getPointeeType(); 1984 mangleFunctionType(pointee->castAs<FunctionProtoType>()); 1985} 1986 1987void MicrosoftCXXNameMangler::mangleType(const InjectedClassNameType *, 1988 SourceRange) { 1989 llvm_unreachable("Cannot mangle injected class name type."); 1990} 1991 1992void MicrosoftCXXNameMangler::mangleType(const TemplateSpecializationType *T, 1993 SourceRange Range) { 1994 DiagnosticsEngine &Diags = Context.getDiags(); 1995 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 1996 "cannot mangle this template specialization type yet"); 1997 Diags.Report(Range.getBegin(), DiagID) 1998 << Range; 1999} 2000 2001void MicrosoftCXXNameMangler::mangleType(const DependentNameType *T, 2002 SourceRange Range) { 2003 DiagnosticsEngine &Diags = Context.getDiags(); 2004 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2005 "cannot mangle this dependent name type yet"); 2006 Diags.Report(Range.getBegin(), DiagID) 2007 << Range; 2008} 2009 2010void MicrosoftCXXNameMangler::mangleType( 2011 const DependentTemplateSpecializationType *T, 2012 SourceRange Range) { 2013 DiagnosticsEngine &Diags = Context.getDiags(); 2014 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2015 "cannot mangle this dependent template specialization type yet"); 2016 Diags.Report(Range.getBegin(), DiagID) 2017 << Range; 2018} 2019 2020void MicrosoftCXXNameMangler::mangleType(const PackExpansionType *T, 2021 SourceRange Range) { 2022 DiagnosticsEngine &Diags = Context.getDiags(); 2023 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2024 "cannot mangle this pack expansion yet"); 2025 Diags.Report(Range.getBegin(), DiagID) 2026 << Range; 2027} 2028 2029void MicrosoftCXXNameMangler::mangleType(const TypeOfType *T, 2030 SourceRange Range) { 2031 DiagnosticsEngine &Diags = Context.getDiags(); 2032 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2033 "cannot mangle this typeof(type) yet"); 2034 Diags.Report(Range.getBegin(), DiagID) 2035 << Range; 2036} 2037 2038void MicrosoftCXXNameMangler::mangleType(const TypeOfExprType *T, 2039 SourceRange Range) { 2040 DiagnosticsEngine &Diags = Context.getDiags(); 2041 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2042 "cannot mangle this typeof(expression) yet"); 2043 Diags.Report(Range.getBegin(), DiagID) 2044 << Range; 2045} 2046 2047void MicrosoftCXXNameMangler::mangleType(const DecltypeType *T, 2048 SourceRange Range) { 2049 DiagnosticsEngine &Diags = Context.getDiags(); 2050 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2051 "cannot mangle this decltype() yet"); 2052 Diags.Report(Range.getBegin(), DiagID) 2053 << Range; 2054} 2055 2056void MicrosoftCXXNameMangler::mangleType(const UnaryTransformType *T, 2057 SourceRange Range) { 2058 DiagnosticsEngine &Diags = Context.getDiags(); 2059 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2060 "cannot mangle this unary transform type yet"); 2061 Diags.Report(Range.getBegin(), DiagID) 2062 << Range; 2063} 2064 2065void MicrosoftCXXNameMangler::mangleType(const AutoType *T, SourceRange Range) { 2066 assert(T->getDeducedType().isNull() && "expecting a dependent type!"); 2067 2068 DiagnosticsEngine &Diags = Context.getDiags(); 2069 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2070 "cannot mangle this 'auto' type yet"); 2071 Diags.Report(Range.getBegin(), DiagID) 2072 << Range; 2073} 2074 2075void MicrosoftCXXNameMangler::mangleType(const AtomicType *T, 2076 SourceRange Range) { 2077 DiagnosticsEngine &Diags = Context.getDiags(); 2078 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, 2079 "cannot mangle this C11 atomic type yet"); 2080 Diags.Report(Range.getBegin(), DiagID) 2081 << Range; 2082} 2083 2084void MicrosoftMangleContextImpl::mangleCXXName(const NamedDecl *D, 2085 raw_ostream &Out) { 2086 assert((isa<FunctionDecl>(D) || isa<VarDecl>(D)) && 2087 "Invalid mangleName() call, argument is not a variable or function!"); 2088 assert(!isa<CXXConstructorDecl>(D) && !isa<CXXDestructorDecl>(D) && 2089 "Invalid mangleName() call on 'structor decl!"); 2090 2091 PrettyStackTraceDecl CrashInfo(D, SourceLocation(), 2092 getASTContext().getSourceManager(), 2093 "Mangling declaration"); 2094 2095 MicrosoftCXXNameMangler Mangler(*this, Out); 2096 return Mangler.mangle(D); 2097} 2098 2099// <this-adjustment> ::= <no-adjustment> | <static-adjustment> | 2100// <virtual-adjustment> 2101// <no-adjustment> ::= A # private near 2102// ::= B # private far 2103// ::= I # protected near 2104// ::= J # protected far 2105// ::= Q # public near 2106// ::= R # public far 2107// <static-adjustment> ::= G <static-offset> # private near 2108// ::= H <static-offset> # private far 2109// ::= O <static-offset> # protected near 2110// ::= P <static-offset> # protected far 2111// ::= W <static-offset> # public near 2112// ::= X <static-offset> # public far 2113// <virtual-adjustment> ::= $0 <virtual-shift> <static-offset> # private near 2114// ::= $1 <virtual-shift> <static-offset> # private far 2115// ::= $2 <virtual-shift> <static-offset> # protected near 2116// ::= $3 <virtual-shift> <static-offset> # protected far 2117// ::= $4 <virtual-shift> <static-offset> # public near 2118// ::= $5 <virtual-shift> <static-offset> # public far 2119// <virtual-shift> ::= <vtordisp-shift> | <vtordispex-shift> 2120// <vtordisp-shift> ::= <offset-to-vtordisp> 2121// <vtordispex-shift> ::= <offset-to-vbptr> <vbase-offset-offset> 2122// <offset-to-vtordisp> 2123static void mangleThunkThisAdjustment(const CXXMethodDecl *MD, 2124 const ThisAdjustment &Adjustment, 2125 MicrosoftCXXNameMangler &Mangler, 2126 raw_ostream &Out) { 2127 if (!Adjustment.Virtual.isEmpty()) { 2128 Out << '$'; 2129 char AccessSpec; 2130 switch (MD->getAccess()) { 2131 case AS_none: 2132 llvm_unreachable("Unsupported access specifier"); 2133 case AS_private: 2134 AccessSpec = '0'; 2135 break; 2136 case AS_protected: 2137 AccessSpec = '2'; 2138 break; 2139 case AS_public: 2140 AccessSpec = '4'; 2141 } 2142 if (Adjustment.Virtual.Microsoft.VBPtrOffset) { 2143 Out << 'R' << AccessSpec; 2144 Mangler.mangleNumber( 2145 static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VBPtrOffset)); 2146 Mangler.mangleNumber( 2147 static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VBOffsetOffset)); 2148 Mangler.mangleNumber( 2149 static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VtordispOffset)); 2150 Mangler.mangleNumber(static_cast<uint32_t>(Adjustment.NonVirtual)); 2151 } else { 2152 Out << AccessSpec; 2153 Mangler.mangleNumber( 2154 static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VtordispOffset)); 2155 Mangler.mangleNumber(-static_cast<uint32_t>(Adjustment.NonVirtual)); 2156 } 2157 } else if (Adjustment.NonVirtual != 0) { 2158 switch (MD->getAccess()) { 2159 case AS_none: 2160 llvm_unreachable("Unsupported access specifier"); 2161 case AS_private: 2162 Out << 'G'; 2163 break; 2164 case AS_protected: 2165 Out << 'O'; 2166 break; 2167 case AS_public: 2168 Out << 'W'; 2169 } 2170 Mangler.mangleNumber(-static_cast<uint32_t>(Adjustment.NonVirtual)); 2171 } else { 2172 switch (MD->getAccess()) { 2173 case AS_none: 2174 llvm_unreachable("Unsupported access specifier"); 2175 case AS_private: 2176 Out << 'A'; 2177 break; 2178 case AS_protected: 2179 Out << 'I'; 2180 break; 2181 case AS_public: 2182 Out << 'Q'; 2183 } 2184 } 2185} 2186 2187void 2188MicrosoftMangleContextImpl::mangleVirtualMemPtrThunk(const CXXMethodDecl *MD, 2189 raw_ostream &Out) { 2190 MicrosoftVTableContext *VTContext = 2191 cast<MicrosoftVTableContext>(getASTContext().getVTableContext()); 2192 const MicrosoftVTableContext::MethodVFTableLocation &ML = 2193 VTContext->getMethodVFTableLocation(GlobalDecl(MD)); 2194 2195 MicrosoftCXXNameMangler Mangler(*this, Out); 2196 Mangler.getStream() << "\01?"; 2197 Mangler.mangleVirtualMemPtrThunk(MD, ML); 2198} 2199 2200void MicrosoftMangleContextImpl::mangleThunk(const CXXMethodDecl *MD, 2201 const ThunkInfo &Thunk, 2202 raw_ostream &Out) { 2203 MicrosoftCXXNameMangler Mangler(*this, Out); 2204 Out << "\01?"; 2205 Mangler.mangleName(MD); 2206 mangleThunkThisAdjustment(MD, Thunk.This, Mangler, Out); 2207 if (!Thunk.Return.isEmpty()) 2208 assert(Thunk.Method != nullptr && 2209 "Thunk info should hold the overridee decl"); 2210 2211 const CXXMethodDecl *DeclForFPT = Thunk.Method ? Thunk.Method : MD; 2212 Mangler.mangleFunctionType( 2213 DeclForFPT->getType()->castAs<FunctionProtoType>(), MD); 2214} 2215 2216void MicrosoftMangleContextImpl::mangleCXXDtorThunk( 2217 const CXXDestructorDecl *DD, CXXDtorType Type, 2218 const ThisAdjustment &Adjustment, raw_ostream &Out) { 2219 // FIXME: Actually, the dtor thunk should be emitted for vector deleting 2220 // dtors rather than scalar deleting dtors. Just use the vector deleting dtor 2221 // mangling manually until we support both deleting dtor types. 2222 assert(Type == Dtor_Deleting); 2223 MicrosoftCXXNameMangler Mangler(*this, Out, DD, Type); 2224 Out << "\01??_E"; 2225 Mangler.mangleName(DD->getParent()); 2226 mangleThunkThisAdjustment(DD, Adjustment, Mangler, Out); 2227 Mangler.mangleFunctionType(DD->getType()->castAs<FunctionProtoType>(), DD); 2228} 2229 2230void MicrosoftMangleContextImpl::mangleCXXVFTable( 2231 const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath, 2232 raw_ostream &Out) { 2233 // <mangled-name> ::= ?_7 <class-name> <storage-class> 2234 // <cvr-qualifiers> [<name>] @ 2235 // NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class> 2236 // is always '6' for vftables. 2237 MicrosoftCXXNameMangler Mangler(*this, Out); 2238 Mangler.getStream() << "\01??_7"; 2239 Mangler.mangleName(Derived); 2240 Mangler.getStream() << "6B"; // '6' for vftable, 'B' for const. 2241 for (const CXXRecordDecl *RD : BasePath) 2242 Mangler.mangleName(RD); 2243 Mangler.getStream() << '@'; 2244} 2245 2246void MicrosoftMangleContextImpl::mangleCXXVBTable( 2247 const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath, 2248 raw_ostream &Out) { 2249 // <mangled-name> ::= ?_8 <class-name> <storage-class> 2250 // <cvr-qualifiers> [<name>] @ 2251 // NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class> 2252 // is always '7' for vbtables. 2253 MicrosoftCXXNameMangler Mangler(*this, Out); 2254 Mangler.getStream() << "\01??_8"; 2255 Mangler.mangleName(Derived); 2256 Mangler.getStream() << "7B"; // '7' for vbtable, 'B' for const. 2257 for (const CXXRecordDecl *RD : BasePath) 2258 Mangler.mangleName(RD); 2259 Mangler.getStream() << '@'; 2260} 2261 2262void MicrosoftMangleContextImpl::mangleCXXRTTI(QualType T, raw_ostream &Out) { 2263 MicrosoftCXXNameMangler Mangler(*this, Out); 2264 Mangler.getStream() << "\01??_R0"; 2265 Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result); 2266 Mangler.getStream() << "@8"; 2267} 2268 2269void MicrosoftMangleContextImpl::mangleCXXRTTIName(QualType T, 2270 raw_ostream &Out) { 2271 MicrosoftCXXNameMangler Mangler(*this, Out); 2272 Mangler.getStream() << '.'; 2273 Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result); 2274} 2275 2276void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassDescriptor( 2277 const CXXRecordDecl *Derived, uint32_t NVOffset, int32_t VBPtrOffset, 2278 uint32_t VBTableOffset, uint32_t Flags, raw_ostream &Out) { 2279 MicrosoftCXXNameMangler Mangler(*this, Out); 2280 Mangler.getStream() << "\01??_R1"; 2281 Mangler.mangleNumber(NVOffset); 2282 Mangler.mangleNumber(VBPtrOffset); 2283 Mangler.mangleNumber(VBTableOffset); 2284 Mangler.mangleNumber(Flags); 2285 Mangler.mangleName(Derived); 2286 Mangler.getStream() << "8"; 2287} 2288 2289void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassArray( 2290 const CXXRecordDecl *Derived, raw_ostream &Out) { 2291 MicrosoftCXXNameMangler Mangler(*this, Out); 2292 Mangler.getStream() << "\01??_R2"; 2293 Mangler.mangleName(Derived); 2294 Mangler.getStream() << "8"; 2295} 2296 2297void MicrosoftMangleContextImpl::mangleCXXRTTIClassHierarchyDescriptor( 2298 const CXXRecordDecl *Derived, raw_ostream &Out) { 2299 MicrosoftCXXNameMangler Mangler(*this, Out); 2300 Mangler.getStream() << "\01??_R3"; 2301 Mangler.mangleName(Derived); 2302 Mangler.getStream() << "8"; 2303} 2304 2305void MicrosoftMangleContextImpl::mangleCXXRTTICompleteObjectLocator( 2306 const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath, 2307 raw_ostream &Out) { 2308 // <mangled-name> ::= ?_R4 <class-name> <storage-class> 2309 // <cvr-qualifiers> [<name>] @ 2310 // NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class> 2311 // is always '6' for vftables. 2312 MicrosoftCXXNameMangler Mangler(*this, Out); 2313 Mangler.getStream() << "\01??_R4"; 2314 Mangler.mangleName(Derived); 2315 Mangler.getStream() << "6B"; // '6' for vftable, 'B' for const. 2316 for (const CXXRecordDecl *RD : BasePath) 2317 Mangler.mangleName(RD); 2318 Mangler.getStream() << '@'; 2319} 2320 2321void MicrosoftMangleContextImpl::mangleTypeName(QualType T, raw_ostream &Out) { 2322 // This is just a made up unique string for the purposes of tbaa. undname 2323 // does *not* know how to demangle it. 2324 MicrosoftCXXNameMangler Mangler(*this, Out); 2325 Mangler.getStream() << '?'; 2326 Mangler.mangleType(T, SourceRange()); 2327} 2328 2329void MicrosoftMangleContextImpl::mangleCXXCtor(const CXXConstructorDecl *D, 2330 CXXCtorType Type, 2331 raw_ostream &Out) { 2332 MicrosoftCXXNameMangler mangler(*this, Out); 2333 mangler.mangle(D); 2334} 2335 2336void MicrosoftMangleContextImpl::mangleCXXDtor(const CXXDestructorDecl *D, 2337 CXXDtorType Type, 2338 raw_ostream &Out) { 2339 MicrosoftCXXNameMangler mangler(*this, Out, D, Type); 2340 mangler.mangle(D); 2341} 2342 2343void MicrosoftMangleContextImpl::mangleReferenceTemporary(const VarDecl *VD, 2344 unsigned, 2345 raw_ostream &) { 2346 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, 2347 "cannot mangle this reference temporary yet"); 2348 getDiags().Report(VD->getLocation(), DiagID); 2349} 2350 2351void MicrosoftMangleContextImpl::mangleStaticGuardVariable(const VarDecl *VD, 2352 raw_ostream &Out) { 2353 // TODO: This is not correct, especially with respect to VS "14". VS "14" 2354 // utilizes thread local variables to implement thread safe, re-entrant 2355 // initialization for statics. They no longer differentiate between an 2356 // externally visible and non-externally visible static with respect to 2357 // mangling, they all get $TSS <number>. 2358 // 2359 // N.B. This means that they can get more than 32 static variable guards in a 2360 // scope. It also means that they broke compatibility with their own ABI. 2361 2362 // <guard-name> ::= ?_B <postfix> @5 <scope-depth> 2363 // ::= ?$S <guard-num> @ <postfix> @4IA 2364 2365 // The first mangling is what MSVC uses to guard static locals in inline 2366 // functions. It uses a different mangling in external functions to support 2367 // guarding more than 32 variables. MSVC rejects inline functions with more 2368 // than 32 static locals. We don't fully implement the second mangling 2369 // because those guards are not externally visible, and instead use LLVM's 2370 // default renaming when creating a new guard variable. 2371 MicrosoftCXXNameMangler Mangler(*this, Out); 2372 2373 bool Visible = VD->isExternallyVisible(); 2374 // <operator-name> ::= ?_B # local static guard 2375 Mangler.getStream() << (Visible ? "\01??_B" : "\01?$S1@"); 2376 unsigned ScopeDepth = 0; 2377 if (Visible && !getNextDiscriminator(VD, ScopeDepth)) 2378 // If we do not have a discriminator and are emitting a guard variable for 2379 // use at global scope, then mangling the nested name will not be enough to 2380 // remove ambiguities. 2381 Mangler.mangle(VD, ""); 2382 else 2383 Mangler.mangleNestedName(VD); 2384 Mangler.getStream() << (Visible ? "@5" : "@4IA"); 2385 if (ScopeDepth) 2386 Mangler.mangleNumber(ScopeDepth); 2387} 2388 2389void MicrosoftMangleContextImpl::mangleInitFiniStub(const VarDecl *D, 2390 raw_ostream &Out, 2391 char CharCode) { 2392 MicrosoftCXXNameMangler Mangler(*this, Out); 2393 Mangler.getStream() << "\01??__" << CharCode; 2394 Mangler.mangleName(D); 2395 if (D->isStaticDataMember()) { 2396 Mangler.mangleVariableEncoding(D); 2397 Mangler.getStream() << '@'; 2398 } 2399 // This is the function class mangling. These stubs are global, non-variadic, 2400 // cdecl functions that return void and take no args. 2401 Mangler.getStream() << "YAXXZ"; 2402} 2403 2404void MicrosoftMangleContextImpl::mangleDynamicInitializer(const VarDecl *D, 2405 raw_ostream &Out) { 2406 // <initializer-name> ::= ?__E <name> YAXXZ 2407 mangleInitFiniStub(D, Out, 'E'); 2408} 2409 2410void 2411MicrosoftMangleContextImpl::mangleDynamicAtExitDestructor(const VarDecl *D, 2412 raw_ostream &Out) { 2413 // <destructor-name> ::= ?__F <name> YAXXZ 2414 mangleInitFiniStub(D, Out, 'F'); 2415} 2416 2417void MicrosoftMangleContextImpl::mangleStringLiteral(const StringLiteral *SL, 2418 raw_ostream &Out) { 2419 // <char-type> ::= 0 # char 2420 // ::= 1 # wchar_t 2421 // ::= ??? # char16_t/char32_t will need a mangling too... 2422 // 2423 // <literal-length> ::= <non-negative integer> # the length of the literal 2424 // 2425 // <encoded-crc> ::= <hex digit>+ @ # crc of the literal including 2426 // # null-terminator 2427 // 2428 // <encoded-string> ::= <simple character> # uninteresting character 2429 // ::= '?$' <hex digit> <hex digit> # these two nibbles 2430 // # encode the byte for the 2431 // # character 2432 // ::= '?' [a-z] # \xe1 - \xfa 2433 // ::= '?' [A-Z] # \xc1 - \xda 2434 // ::= '?' [0-9] # [,/\:. \n\t'-] 2435 // 2436 // <literal> ::= '??_C@_' <char-type> <literal-length> <encoded-crc> 2437 // <encoded-string> '@' 2438 MicrosoftCXXNameMangler Mangler(*this, Out); 2439 Mangler.getStream() << "\01??_C@_"; 2440 2441 // <char-type>: The "kind" of string literal is encoded into the mangled name. 2442 if (SL->isWide()) 2443 Mangler.getStream() << '1'; 2444 else 2445 Mangler.getStream() << '0'; 2446 2447 // <literal-length>: The next part of the mangled name consists of the length 2448 // of the string. 2449 // The StringLiteral does not consider the NUL terminator byte(s) but the 2450 // mangling does. 2451 // N.B. The length is in terms of bytes, not characters. 2452 Mangler.mangleNumber(SL->getByteLength() + SL->getCharByteWidth()); 2453 2454 // We will use the "Rocksoft^tm Model CRC Algorithm" to describe the 2455 // properties of our CRC: 2456 // Width : 32 2457 // Poly : 04C11DB7 2458 // Init : FFFFFFFF 2459 // RefIn : True 2460 // RefOut : True 2461 // XorOut : 00000000 2462 // Check : 340BC6D9 2463 uint32_t CRC = 0xFFFFFFFFU; 2464 2465 auto UpdateCRC = [&CRC](char Byte) { 2466 for (unsigned i = 0; i < 8; ++i) { 2467 bool Bit = CRC & 0x80000000U; 2468 if (Byte & (1U << i)) 2469 Bit = !Bit; 2470 CRC <<= 1; 2471 if (Bit) 2472 CRC ^= 0x04C11DB7U; 2473 } 2474 }; 2475 2476 auto GetLittleEndianByte = [&Mangler, &SL](unsigned Index) { 2477 unsigned CharByteWidth = SL->getCharByteWidth(); 2478 uint32_t CodeUnit = SL->getCodeUnit(Index / CharByteWidth); 2479 unsigned OffsetInCodeUnit = Index % CharByteWidth; 2480 return static_cast<char>((CodeUnit >> (8 * OffsetInCodeUnit)) & 0xff); 2481 }; 2482 2483 auto GetBigEndianByte = [&Mangler, &SL](unsigned Index) { 2484 unsigned CharByteWidth = SL->getCharByteWidth(); 2485 uint32_t CodeUnit = SL->getCodeUnit(Index / CharByteWidth); 2486 unsigned OffsetInCodeUnit = (CharByteWidth - 1) - (Index % CharByteWidth); 2487 return static_cast<char>((CodeUnit >> (8 * OffsetInCodeUnit)) & 0xff); 2488 }; 2489 2490 // CRC all the bytes of the StringLiteral. 2491 for (unsigned I = 0, E = SL->getByteLength(); I != E; ++I) 2492 UpdateCRC(GetLittleEndianByte(I)); 2493 2494 // The NUL terminator byte(s) were not present earlier, 2495 // we need to manually process those bytes into the CRC. 2496 for (unsigned NullTerminator = 0; NullTerminator < SL->getCharByteWidth(); 2497 ++NullTerminator) 2498 UpdateCRC('\x00'); 2499 2500 // The literature refers to the process of reversing the bits in the final CRC 2501 // output as "reflection". 2502 CRC = llvm::reverseBits(CRC); 2503 2504 // <encoded-crc>: The CRC is encoded utilizing the standard number mangling 2505 // scheme. 2506 Mangler.mangleNumber(CRC); 2507 2508 // <encoded-string>: The mangled name also contains the first 32 _characters_ 2509 // (including null-terminator bytes) of the StringLiteral. 2510 // Each character is encoded by splitting them into bytes and then encoding 2511 // the constituent bytes. 2512 auto MangleByte = [&Mangler](char Byte) { 2513 // There are five different manglings for characters: 2514 // - [a-zA-Z0-9_$]: A one-to-one mapping. 2515 // - ?[a-z]: The range from \xe1 to \xfa. 2516 // - ?[A-Z]: The range from \xc1 to \xda. 2517 // - ?[0-9]: The set of [,/\:. \n\t'-]. 2518 // - ?$XX: A fallback which maps nibbles. 2519 if (isIdentifierBody(Byte, /*AllowDollar=*/true)) { 2520 Mangler.getStream() << Byte; 2521 } else if (isLetter(Byte & 0x7f)) { 2522 Mangler.getStream() << '?' << static_cast<char>(Byte & 0x7f); 2523 } else { 2524 const char SpecialChars[] = {',', '/', '\\', ':', '.', 2525 ' ', '\n', '\t', '\'', '-'}; 2526 const char *Pos = 2527 std::find(std::begin(SpecialChars), std::end(SpecialChars), Byte); 2528 if (Pos != std::end(SpecialChars)) { 2529 Mangler.getStream() << '?' << (Pos - std::begin(SpecialChars)); 2530 } else { 2531 Mangler.getStream() << "?$"; 2532 Mangler.getStream() << static_cast<char>('A' + ((Byte >> 4) & 0xf)); 2533 Mangler.getStream() << static_cast<char>('A' + (Byte & 0xf)); 2534 } 2535 } 2536 }; 2537 2538 // Enforce our 32 character max. 2539 unsigned NumCharsToMangle = std::min(32U, SL->getLength()); 2540 for (unsigned I = 0, E = NumCharsToMangle * SL->getCharByteWidth(); I != E; 2541 ++I) 2542 if (SL->isWide()) 2543 MangleByte(GetBigEndianByte(I)); 2544 else 2545 MangleByte(GetLittleEndianByte(I)); 2546 2547 // Encode the NUL terminator if there is room. 2548 if (NumCharsToMangle < 32) 2549 for (unsigned NullTerminator = 0; NullTerminator < SL->getCharByteWidth(); 2550 ++NullTerminator) 2551 MangleByte(0); 2552 2553 Mangler.getStream() << '@'; 2554} 2555 2556MicrosoftMangleContext * 2557MicrosoftMangleContext::create(ASTContext &Context, DiagnosticsEngine &Diags) { 2558 return new MicrosoftMangleContextImpl(Context, Diags); 2559} 2560