1 //===--- MicrosoftMangle.cpp - Microsoft Visual C++ Name Mangling ---------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This provides C++ name mangling targeting the Microsoft Visual C++ ABI.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/AST/ASTContext.h"
14 #include "clang/AST/Attr.h"
15 #include "clang/AST/CXXInheritance.h"
16 #include "clang/AST/CharUnits.h"
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/DeclOpenMP.h"
21 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/ExprCXX.h"
24 #include "clang/AST/GlobalDecl.h"
25 #include "clang/AST/Mangle.h"
26 #include "clang/AST/VTableBuilder.h"
27 #include "clang/Basic/ABI.h"
28 #include "clang/Basic/DiagnosticOptions.h"
29 #include "clang/Basic/FileManager.h"
30 #include "clang/Basic/SourceManager.h"
31 #include "clang/Basic/TargetInfo.h"
32 #include "llvm/ADT/StringExtras.h"
33 #include "llvm/Support/CRC.h"
34 #include "llvm/Support/MD5.h"
35 #include "llvm/Support/MathExtras.h"
36 #include "llvm/Support/StringSaver.h"
37 #include "llvm/Support/xxhash.h"
38
39 using namespace clang;
40
41 namespace {
42
43 // Get GlobalDecl of DeclContext of local entities.
getGlobalDeclAsDeclContext(const DeclContext * DC)44 static GlobalDecl getGlobalDeclAsDeclContext(const DeclContext *DC) {
45 GlobalDecl GD;
46 if (auto *CD = dyn_cast<CXXConstructorDecl>(DC))
47 GD = GlobalDecl(CD, Ctor_Complete);
48 else if (auto *DD = dyn_cast<CXXDestructorDecl>(DC))
49 GD = GlobalDecl(DD, Dtor_Complete);
50 else
51 GD = GlobalDecl(cast<FunctionDecl>(DC));
52 return GD;
53 }
54
55 struct msvc_hashing_ostream : public llvm::raw_svector_ostream {
56 raw_ostream &OS;
57 llvm::SmallString<64> Buffer;
58
msvc_hashing_ostream__anon14c0cd2b0111::msvc_hashing_ostream59 msvc_hashing_ostream(raw_ostream &OS)
60 : llvm::raw_svector_ostream(Buffer), OS(OS) {}
~msvc_hashing_ostream__anon14c0cd2b0111::msvc_hashing_ostream61 ~msvc_hashing_ostream() override {
62 StringRef MangledName = str();
63 bool StartsWithEscape = MangledName.startswith("\01");
64 if (StartsWithEscape)
65 MangledName = MangledName.drop_front(1);
66 if (MangledName.size() < 4096) {
67 OS << str();
68 return;
69 }
70
71 llvm::MD5 Hasher;
72 llvm::MD5::MD5Result Hash;
73 Hasher.update(MangledName);
74 Hasher.final(Hash);
75
76 SmallString<32> HexString;
77 llvm::MD5::stringifyResult(Hash, HexString);
78
79 if (StartsWithEscape)
80 OS << '\01';
81 OS << "??@" << HexString << '@';
82 }
83 };
84
85 static const DeclContext *
getLambdaDefaultArgumentDeclContext(const Decl * D)86 getLambdaDefaultArgumentDeclContext(const Decl *D) {
87 if (const auto *RD = dyn_cast<CXXRecordDecl>(D))
88 if (RD->isLambda())
89 if (const auto *Parm =
90 dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl()))
91 return Parm->getDeclContext();
92 return nullptr;
93 }
94
95 /// Retrieve the declaration context that should be used when mangling
96 /// the given declaration.
getEffectiveDeclContext(const Decl * D)97 static const DeclContext *getEffectiveDeclContext(const Decl *D) {
98 // The ABI assumes that lambda closure types that occur within
99 // default arguments live in the context of the function. However, due to
100 // the way in which Clang parses and creates function declarations, this is
101 // not the case: the lambda closure type ends up living in the context
102 // where the function itself resides, because the function declaration itself
103 // had not yet been created. Fix the context here.
104 if (const auto *LDADC = getLambdaDefaultArgumentDeclContext(D))
105 return LDADC;
106
107 // Perform the same check for block literals.
108 if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
109 if (ParmVarDecl *ContextParam =
110 dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl()))
111 return ContextParam->getDeclContext();
112 }
113
114 const DeclContext *DC = D->getDeclContext();
115 if (isa<CapturedDecl>(DC) || isa<OMPDeclareReductionDecl>(DC) ||
116 isa<OMPDeclareMapperDecl>(DC)) {
117 return getEffectiveDeclContext(cast<Decl>(DC));
118 }
119
120 return DC->getRedeclContext();
121 }
122
getEffectiveParentContext(const DeclContext * DC)123 static const DeclContext *getEffectiveParentContext(const DeclContext *DC) {
124 return getEffectiveDeclContext(cast<Decl>(DC));
125 }
126
getStructor(const NamedDecl * ND)127 static const FunctionDecl *getStructor(const NamedDecl *ND) {
128 if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(ND))
129 return FTD->getTemplatedDecl()->getCanonicalDecl();
130
131 const auto *FD = cast<FunctionDecl>(ND);
132 if (const auto *FTD = FD->getPrimaryTemplate())
133 return FTD->getTemplatedDecl()->getCanonicalDecl();
134
135 return FD->getCanonicalDecl();
136 }
137
138 /// MicrosoftMangleContextImpl - Overrides the default MangleContext for the
139 /// Microsoft Visual C++ ABI.
140 class MicrosoftMangleContextImpl : public MicrosoftMangleContext {
141 typedef std::pair<const DeclContext *, IdentifierInfo *> DiscriminatorKeyTy;
142 llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator;
143 llvm::DenseMap<const NamedDecl *, unsigned> Uniquifier;
144 llvm::DenseMap<const CXXRecordDecl *, unsigned> LambdaIds;
145 llvm::DenseMap<const NamedDecl *, unsigned> SEHFilterIds;
146 llvm::DenseMap<const NamedDecl *, unsigned> SEHFinallyIds;
147 SmallString<16> AnonymousNamespaceHash;
148
149 public:
150 MicrosoftMangleContextImpl(ASTContext &Context, DiagnosticsEngine &Diags,
151 bool IsAux = false);
152 bool shouldMangleCXXName(const NamedDecl *D) override;
153 bool shouldMangleStringLiteral(const StringLiteral *SL) override;
154 void mangleCXXName(GlobalDecl GD, raw_ostream &Out) override;
155 void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD,
156 const MethodVFTableLocation &ML,
157 raw_ostream &Out) override;
158 void mangleThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk,
159 raw_ostream &) override;
160 void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type,
161 const ThisAdjustment &ThisAdjustment,
162 raw_ostream &) override;
163 void mangleCXXVFTable(const CXXRecordDecl *Derived,
164 ArrayRef<const CXXRecordDecl *> BasePath,
165 raw_ostream &Out) override;
166 void mangleCXXVBTable(const CXXRecordDecl *Derived,
167 ArrayRef<const CXXRecordDecl *> BasePath,
168 raw_ostream &Out) override;
169 void mangleCXXVirtualDisplacementMap(const CXXRecordDecl *SrcRD,
170 const CXXRecordDecl *DstRD,
171 raw_ostream &Out) override;
172 void mangleCXXThrowInfo(QualType T, bool IsConst, bool IsVolatile,
173 bool IsUnaligned, uint32_t NumEntries,
174 raw_ostream &Out) override;
175 void mangleCXXCatchableTypeArray(QualType T, uint32_t NumEntries,
176 raw_ostream &Out) override;
177 void mangleCXXCatchableType(QualType T, const CXXConstructorDecl *CD,
178 CXXCtorType CT, uint32_t Size, uint32_t NVOffset,
179 int32_t VBPtrOffset, uint32_t VBIndex,
180 raw_ostream &Out) override;
181 void mangleCXXRTTI(QualType T, raw_ostream &Out) override;
182 void mangleCXXRTTIName(QualType T, raw_ostream &Out) override;
183 void mangleCXXRTTIBaseClassDescriptor(const CXXRecordDecl *Derived,
184 uint32_t NVOffset, int32_t VBPtrOffset,
185 uint32_t VBTableOffset, uint32_t Flags,
186 raw_ostream &Out) override;
187 void mangleCXXRTTIBaseClassArray(const CXXRecordDecl *Derived,
188 raw_ostream &Out) override;
189 void mangleCXXRTTIClassHierarchyDescriptor(const CXXRecordDecl *Derived,
190 raw_ostream &Out) override;
191 void
192 mangleCXXRTTICompleteObjectLocator(const CXXRecordDecl *Derived,
193 ArrayRef<const CXXRecordDecl *> BasePath,
194 raw_ostream &Out) override;
195 void mangleTypeName(QualType T, raw_ostream &) override;
196 void mangleReferenceTemporary(const VarDecl *, unsigned ManglingNumber,
197 raw_ostream &) override;
198 void mangleStaticGuardVariable(const VarDecl *D, raw_ostream &Out) override;
199 void mangleThreadSafeStaticGuardVariable(const VarDecl *D, unsigned GuardNum,
200 raw_ostream &Out) override;
201 void mangleDynamicInitializer(const VarDecl *D, raw_ostream &Out) override;
202 void mangleDynamicAtExitDestructor(const VarDecl *D,
203 raw_ostream &Out) override;
204 void mangleSEHFilterExpression(const NamedDecl *EnclosingDecl,
205 raw_ostream &Out) override;
206 void mangleSEHFinallyBlock(const NamedDecl *EnclosingDecl,
207 raw_ostream &Out) override;
208 void mangleStringLiteral(const StringLiteral *SL, raw_ostream &Out) override;
getNextDiscriminator(const NamedDecl * ND,unsigned & disc)209 bool getNextDiscriminator(const NamedDecl *ND, unsigned &disc) {
210 const DeclContext *DC = getEffectiveDeclContext(ND);
211 if (!DC->isFunctionOrMethod())
212 return false;
213
214 // Lambda closure types are already numbered, give out a phony number so
215 // that they demangle nicely.
216 if (const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
217 if (RD->isLambda()) {
218 disc = 1;
219 return true;
220 }
221 }
222
223 // Use the canonical number for externally visible decls.
224 if (ND->isExternallyVisible()) {
225 disc = getASTContext().getManglingNumber(ND, isAux());
226 return true;
227 }
228
229 // Anonymous tags are already numbered.
230 if (const TagDecl *Tag = dyn_cast<TagDecl>(ND)) {
231 if (!Tag->hasNameForLinkage() &&
232 !getASTContext().getDeclaratorForUnnamedTagDecl(Tag) &&
233 !getASTContext().getTypedefNameForUnnamedTagDecl(Tag))
234 return false;
235 }
236
237 // Make up a reasonable number for internal decls.
238 unsigned &discriminator = Uniquifier[ND];
239 if (!discriminator)
240 discriminator = ++Discriminator[std::make_pair(DC, ND->getIdentifier())];
241 disc = discriminator + 1;
242 return true;
243 }
244
getLambdaString(const CXXRecordDecl * Lambda)245 std::string getLambdaString(const CXXRecordDecl *Lambda) override {
246 assert(Lambda->isLambda() && "RD must be a lambda!");
247 std::string Name("<lambda_");
248
249 Decl *LambdaContextDecl = Lambda->getLambdaContextDecl();
250 unsigned LambdaManglingNumber = Lambda->getLambdaManglingNumber();
251 unsigned LambdaId;
252 const ParmVarDecl *Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
253 const FunctionDecl *Func =
254 Parm ? dyn_cast<FunctionDecl>(Parm->getDeclContext()) : nullptr;
255
256 if (Func) {
257 unsigned DefaultArgNo =
258 Func->getNumParams() - Parm->getFunctionScopeIndex();
259 Name += llvm::utostr(DefaultArgNo);
260 Name += "_";
261 }
262
263 if (LambdaManglingNumber)
264 LambdaId = LambdaManglingNumber;
265 else
266 LambdaId = getLambdaIdForDebugInfo(Lambda);
267
268 Name += llvm::utostr(LambdaId);
269 Name += ">";
270 return Name;
271 }
272
getLambdaId(const CXXRecordDecl * RD)273 unsigned getLambdaId(const CXXRecordDecl *RD) {
274 assert(RD->isLambda() && "RD must be a lambda!");
275 assert(!RD->isExternallyVisible() && "RD must not be visible!");
276 assert(RD->getLambdaManglingNumber() == 0 &&
277 "RD must not have a mangling number!");
278 std::pair<llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator, bool>
279 Result = LambdaIds.insert(std::make_pair(RD, LambdaIds.size()));
280 return Result.first->second;
281 }
282
getLambdaIdForDebugInfo(const CXXRecordDecl * RD)283 unsigned getLambdaIdForDebugInfo(const CXXRecordDecl *RD) {
284 assert(RD->isLambda() && "RD must be a lambda!");
285 assert(!RD->isExternallyVisible() && "RD must not be visible!");
286 assert(RD->getLambdaManglingNumber() == 0 &&
287 "RD must not have a mangling number!");
288 llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator Result =
289 LambdaIds.find(RD);
290 // The lambda should exist, but return 0 in case it doesn't.
291 if (Result == LambdaIds.end())
292 return 0;
293 return Result->second;
294 }
295
296 /// Return a character sequence that is (somewhat) unique to the TU suitable
297 /// for mangling anonymous namespaces.
getAnonymousNamespaceHash() const298 StringRef getAnonymousNamespaceHash() const {
299 return AnonymousNamespaceHash;
300 }
301
302 private:
303 void mangleInitFiniStub(const VarDecl *D, char CharCode, raw_ostream &Out);
304 };
305
306 /// MicrosoftCXXNameMangler - Manage the mangling of a single name for the
307 /// Microsoft Visual C++ ABI.
308 class MicrosoftCXXNameMangler {
309 MicrosoftMangleContextImpl &Context;
310 raw_ostream &Out;
311
312 /// The "structor" is the top-level declaration being mangled, if
313 /// that's not a template specialization; otherwise it's the pattern
314 /// for that specialization.
315 const NamedDecl *Structor;
316 unsigned StructorType;
317
318 typedef llvm::SmallVector<std::string, 10> BackRefVec;
319 BackRefVec NameBackReferences;
320
321 typedef llvm::DenseMap<const void *, unsigned> ArgBackRefMap;
322 ArgBackRefMap FunArgBackReferences;
323 ArgBackRefMap TemplateArgBackReferences;
324
325 typedef llvm::DenseMap<const void *, StringRef> TemplateArgStringMap;
326 TemplateArgStringMap TemplateArgStrings;
327 llvm::StringSaver TemplateArgStringStorage;
328 llvm::BumpPtrAllocator TemplateArgStringStorageAlloc;
329
330 typedef std::set<std::pair<int, bool>> PassObjectSizeArgsSet;
331 PassObjectSizeArgsSet PassObjectSizeArgs;
332
getASTContext() const333 ASTContext &getASTContext() const { return Context.getASTContext(); }
334
335 const bool PointersAre64Bit;
336
337 public:
338 enum QualifierMangleMode { QMM_Drop, QMM_Mangle, QMM_Escape, QMM_Result };
339
MicrosoftCXXNameMangler(MicrosoftMangleContextImpl & C,raw_ostream & Out_)340 MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_)
341 : Context(C), Out(Out_), Structor(nullptr), StructorType(-1),
342 TemplateArgStringStorage(TemplateArgStringStorageAlloc),
343 PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
344 64) {}
345
MicrosoftCXXNameMangler(MicrosoftMangleContextImpl & C,raw_ostream & Out_,const CXXConstructorDecl * D,CXXCtorType Type)346 MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_,
347 const CXXConstructorDecl *D, CXXCtorType Type)
348 : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
349 TemplateArgStringStorage(TemplateArgStringStorageAlloc),
350 PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
351 64) {}
352
MicrosoftCXXNameMangler(MicrosoftMangleContextImpl & C,raw_ostream & Out_,const CXXDestructorDecl * D,CXXDtorType Type)353 MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_,
354 const CXXDestructorDecl *D, CXXDtorType Type)
355 : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
356 TemplateArgStringStorage(TemplateArgStringStorageAlloc),
357 PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
358 64) {}
359
getStream() const360 raw_ostream &getStream() const { return Out; }
361
362 void mangle(GlobalDecl GD, StringRef Prefix = "?");
363 void mangleName(GlobalDecl GD);
364 void mangleFunctionEncoding(GlobalDecl GD, bool ShouldMangle);
365 void mangleVariableEncoding(const VarDecl *VD);
366 void mangleMemberDataPointer(const CXXRecordDecl *RD, const ValueDecl *VD,
367 StringRef Prefix = "$");
368 void mangleMemberFunctionPointer(const CXXRecordDecl *RD,
369 const CXXMethodDecl *MD,
370 StringRef Prefix = "$");
371 void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD,
372 const MethodVFTableLocation &ML);
373 void mangleNumber(int64_t Number);
374 void mangleNumber(llvm::APSInt Number);
375 void mangleFloat(llvm::APFloat Number);
376 void mangleBits(llvm::APInt Number);
377 void mangleTagTypeKind(TagTypeKind TK);
378 void mangleArtificialTagType(TagTypeKind TK, StringRef UnqualifiedName,
379 ArrayRef<StringRef> NestedNames = None);
380 void mangleAddressSpaceType(QualType T, Qualifiers Quals, SourceRange Range);
381 void mangleType(QualType T, SourceRange Range,
382 QualifierMangleMode QMM = QMM_Mangle);
383 void mangleFunctionType(const FunctionType *T,
384 const FunctionDecl *D = nullptr,
385 bool ForceThisQuals = false,
386 bool MangleExceptionSpec = true);
387 void mangleNestedName(GlobalDecl GD);
388
389 private:
isStructorDecl(const NamedDecl * ND) const390 bool isStructorDecl(const NamedDecl *ND) const {
391 return ND == Structor || getStructor(ND) == Structor;
392 }
393
is64BitPointer(Qualifiers Quals) const394 bool is64BitPointer(Qualifiers Quals) const {
395 LangAS AddrSpace = Quals.getAddressSpace();
396 return AddrSpace == LangAS::ptr64 ||
397 (PointersAre64Bit && !(AddrSpace == LangAS::ptr32_sptr ||
398 AddrSpace == LangAS::ptr32_uptr));
399 }
400
mangleUnqualifiedName(GlobalDecl GD)401 void mangleUnqualifiedName(GlobalDecl GD) {
402 mangleUnqualifiedName(GD, cast<NamedDecl>(GD.getDecl())->getDeclName());
403 }
404 void mangleUnqualifiedName(GlobalDecl GD, DeclarationName Name);
405 void mangleSourceName(StringRef Name);
406 void mangleOperatorName(OverloadedOperatorKind OO, SourceLocation Loc);
407 void mangleCXXDtorType(CXXDtorType T);
408 void mangleQualifiers(Qualifiers Quals, bool IsMember);
409 void mangleRefQualifier(RefQualifierKind RefQualifier);
410 void manglePointerCVQualifiers(Qualifiers Quals);
411 void manglePointerExtQualifiers(Qualifiers Quals, QualType PointeeType);
412
413 void mangleUnscopedTemplateName(GlobalDecl GD);
414 void
415 mangleTemplateInstantiationName(GlobalDecl GD,
416 const TemplateArgumentList &TemplateArgs);
417 void mangleObjCMethodName(const ObjCMethodDecl *MD);
418
419 void mangleFunctionArgumentType(QualType T, SourceRange Range);
420 void manglePassObjectSizeArg(const PassObjectSizeAttr *POSA);
421
422 bool isArtificialTagType(QualType T) const;
423
424 // Declare manglers for every type class.
425 #define ABSTRACT_TYPE(CLASS, PARENT)
426 #define NON_CANONICAL_TYPE(CLASS, PARENT)
427 #define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T, \
428 Qualifiers Quals, \
429 SourceRange Range);
430 #include "clang/AST/TypeNodes.inc"
431 #undef ABSTRACT_TYPE
432 #undef NON_CANONICAL_TYPE
433 #undef TYPE
434
435 void mangleType(const TagDecl *TD);
436 void mangleDecayedArrayType(const ArrayType *T);
437 void mangleArrayType(const ArrayType *T);
438 void mangleFunctionClass(const FunctionDecl *FD);
439 void mangleCallingConvention(CallingConv CC);
440 void mangleCallingConvention(const FunctionType *T);
441 void mangleIntegerLiteral(const llvm::APSInt &Number,
442 const NonTypeTemplateParmDecl *PD = nullptr,
443 QualType TemplateArgType = QualType());
444 void mangleExpression(const Expr *E, const NonTypeTemplateParmDecl *PD);
445 void mangleThrowSpecification(const FunctionProtoType *T);
446
447 void mangleTemplateArgs(const TemplateDecl *TD,
448 const TemplateArgumentList &TemplateArgs);
449 void mangleTemplateArg(const TemplateDecl *TD, const TemplateArgument &TA,
450 const NamedDecl *Parm);
451 void mangleTemplateArgValue(QualType T, const APValue &V,
452 bool WithScalarType = false);
453
454 void mangleObjCProtocol(const ObjCProtocolDecl *PD);
455 void mangleObjCLifetime(const QualType T, Qualifiers Quals,
456 SourceRange Range);
457 void mangleObjCKindOfType(const ObjCObjectType *T, Qualifiers Quals,
458 SourceRange Range);
459 };
460 }
461
MicrosoftMangleContextImpl(ASTContext & Context,DiagnosticsEngine & Diags,bool IsAux)462 MicrosoftMangleContextImpl::MicrosoftMangleContextImpl(ASTContext &Context,
463 DiagnosticsEngine &Diags,
464 bool IsAux)
465 : MicrosoftMangleContext(Context, Diags, IsAux) {
466 // To mangle anonymous namespaces, hash the path to the main source file. The
467 // path should be whatever (probably relative) path was passed on the command
468 // line. The goal is for the compiler to produce the same output regardless of
469 // working directory, so use the uncanonicalized relative path.
470 //
471 // It's important to make the mangled names unique because, when CodeView
472 // debug info is in use, the debugger uses mangled type names to distinguish
473 // between otherwise identically named types in anonymous namespaces.
474 //
475 // These symbols are always internal, so there is no need for the hash to
476 // match what MSVC produces. For the same reason, clang is free to change the
477 // hash at any time without breaking compatibility with old versions of clang.
478 // The generated names are intended to look similar to what MSVC generates,
479 // which are something like "?A0x01234567@".
480 SourceManager &SM = Context.getSourceManager();
481 if (const FileEntry *FE = SM.getFileEntryForID(SM.getMainFileID())) {
482 // Truncate the hash so we get 8 characters of hexadecimal.
483 uint32_t TruncatedHash = uint32_t(xxHash64(FE->getName()));
484 AnonymousNamespaceHash = llvm::utohexstr(TruncatedHash);
485 } else {
486 // If we don't have a path to the main file, we'll just use 0.
487 AnonymousNamespaceHash = "0";
488 }
489 }
490
shouldMangleCXXName(const NamedDecl * D)491 bool MicrosoftMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) {
492 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
493 LanguageLinkage L = FD->getLanguageLinkage();
494 // Overloadable functions need mangling.
495 if (FD->hasAttr<OverloadableAttr>())
496 return true;
497
498 // The ABI expects that we would never mangle "typical" user-defined entry
499 // points regardless of visibility or freestanding-ness.
500 //
501 // N.B. This is distinct from asking about "main". "main" has a lot of
502 // special rules associated with it in the standard while these
503 // user-defined entry points are outside of the purview of the standard.
504 // For example, there can be only one definition for "main" in a standards
505 // compliant program; however nothing forbids the existence of wmain and
506 // WinMain in the same translation unit.
507 if (FD->isMSVCRTEntryPoint())
508 return false;
509
510 // C++ functions and those whose names are not a simple identifier need
511 // mangling.
512 if (!FD->getDeclName().isIdentifier() || L == CXXLanguageLinkage)
513 return true;
514
515 // C functions are not mangled.
516 if (L == CLanguageLinkage)
517 return false;
518 }
519
520 // Otherwise, no mangling is done outside C++ mode.
521 if (!getASTContext().getLangOpts().CPlusPlus)
522 return false;
523
524 const VarDecl *VD = dyn_cast<VarDecl>(D);
525 if (VD && !isa<DecompositionDecl>(D)) {
526 // C variables are not mangled.
527 if (VD->isExternC())
528 return false;
529
530 // Variables at global scope with internal linkage are not mangled.
531 const DeclContext *DC = getEffectiveDeclContext(D);
532 // Check for extern variable declared locally.
533 if (DC->isFunctionOrMethod() && D->hasLinkage())
534 while (!DC->isNamespace() && !DC->isTranslationUnit())
535 DC = getEffectiveParentContext(DC);
536
537 if (DC->isTranslationUnit() && D->getFormalLinkage() == InternalLinkage &&
538 !isa<VarTemplateSpecializationDecl>(D) &&
539 D->getIdentifier() != nullptr)
540 return false;
541 }
542
543 return true;
544 }
545
546 bool
shouldMangleStringLiteral(const StringLiteral * SL)547 MicrosoftMangleContextImpl::shouldMangleStringLiteral(const StringLiteral *SL) {
548 return true;
549 }
550
mangle(GlobalDecl GD,StringRef Prefix)551 void MicrosoftCXXNameMangler::mangle(GlobalDecl GD, StringRef Prefix) {
552 const NamedDecl *D = cast<NamedDecl>(GD.getDecl());
553 // MSVC doesn't mangle C++ names the same way it mangles extern "C" names.
554 // Therefore it's really important that we don't decorate the
555 // name with leading underscores or leading/trailing at signs. So, by
556 // default, we emit an asm marker at the start so we get the name right.
557 // Callers can override this with a custom prefix.
558
559 // <mangled-name> ::= ? <name> <type-encoding>
560 Out << Prefix;
561 mangleName(GD);
562 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
563 mangleFunctionEncoding(GD, Context.shouldMangleDeclName(FD));
564 else if (const VarDecl *VD = dyn_cast<VarDecl>(D))
565 mangleVariableEncoding(VD);
566 else if (isa<MSGuidDecl>(D))
567 // MSVC appears to mangle GUIDs as if they were variables of type
568 // 'const struct __s_GUID'.
569 Out << "3U__s_GUID@@B";
570 else if (isa<TemplateParamObjectDecl>(D)) {
571 // Template parameter objects don't get a <type-encoding>; their type is
572 // specified as part of their value.
573 } else
574 llvm_unreachable("Tried to mangle unexpected NamedDecl!");
575 }
576
mangleFunctionEncoding(GlobalDecl GD,bool ShouldMangle)577 void MicrosoftCXXNameMangler::mangleFunctionEncoding(GlobalDecl GD,
578 bool ShouldMangle) {
579 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
580 // <type-encoding> ::= <function-class> <function-type>
581
582 // Since MSVC operates on the type as written and not the canonical type, it
583 // actually matters which decl we have here. MSVC appears to choose the
584 // first, since it is most likely to be the declaration in a header file.
585 FD = FD->getFirstDecl();
586
587 // We should never ever see a FunctionNoProtoType at this point.
588 // We don't even know how to mangle their types anyway :).
589 const FunctionProtoType *FT = FD->getType()->castAs<FunctionProtoType>();
590
591 // extern "C" functions can hold entities that must be mangled.
592 // As it stands, these functions still need to get expressed in the full
593 // external name. They have their class and type omitted, replaced with '9'.
594 if (ShouldMangle) {
595 // We would like to mangle all extern "C" functions using this additional
596 // component but this would break compatibility with MSVC's behavior.
597 // Instead, do this when we know that compatibility isn't important (in
598 // other words, when it is an overloaded extern "C" function).
599 if (FD->isExternC() && FD->hasAttr<OverloadableAttr>())
600 Out << "$$J0";
601
602 mangleFunctionClass(FD);
603
604 mangleFunctionType(FT, FD, false, false);
605 } else {
606 Out << '9';
607 }
608 }
609
mangleVariableEncoding(const VarDecl * VD)610 void MicrosoftCXXNameMangler::mangleVariableEncoding(const VarDecl *VD) {
611 // <type-encoding> ::= <storage-class> <variable-type>
612 // <storage-class> ::= 0 # private static member
613 // ::= 1 # protected static member
614 // ::= 2 # public static member
615 // ::= 3 # global
616 // ::= 4 # static local
617
618 // The first character in the encoding (after the name) is the storage class.
619 if (VD->isStaticDataMember()) {
620 // If it's a static member, it also encodes the access level.
621 switch (VD->getAccess()) {
622 default:
623 case AS_private: Out << '0'; break;
624 case AS_protected: Out << '1'; break;
625 case AS_public: Out << '2'; break;
626 }
627 }
628 else if (!VD->isStaticLocal())
629 Out << '3';
630 else
631 Out << '4';
632 // Now mangle the type.
633 // <variable-type> ::= <type> <cvr-qualifiers>
634 // ::= <type> <pointee-cvr-qualifiers> # pointers, references
635 // Pointers and references are odd. The type of 'int * const foo;' gets
636 // mangled as 'QAHA' instead of 'PAHB', for example.
637 SourceRange SR = VD->getSourceRange();
638 QualType Ty = VD->getType();
639 if (Ty->isPointerType() || Ty->isReferenceType() ||
640 Ty->isMemberPointerType()) {
641 mangleType(Ty, SR, QMM_Drop);
642 manglePointerExtQualifiers(
643 Ty.getDesugaredType(getASTContext()).getLocalQualifiers(), QualType());
644 if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) {
645 mangleQualifiers(MPT->getPointeeType().getQualifiers(), true);
646 // Member pointers are suffixed with a back reference to the member
647 // pointer's class name.
648 mangleName(MPT->getClass()->getAsCXXRecordDecl());
649 } else
650 mangleQualifiers(Ty->getPointeeType().getQualifiers(), false);
651 } else if (const ArrayType *AT = getASTContext().getAsArrayType(Ty)) {
652 // Global arrays are funny, too.
653 mangleDecayedArrayType(AT);
654 if (AT->getElementType()->isArrayType())
655 Out << 'A';
656 else
657 mangleQualifiers(Ty.getQualifiers(), false);
658 } else {
659 mangleType(Ty, SR, QMM_Drop);
660 mangleQualifiers(Ty.getQualifiers(), false);
661 }
662 }
663
mangleMemberDataPointer(const CXXRecordDecl * RD,const ValueDecl * VD,StringRef Prefix)664 void MicrosoftCXXNameMangler::mangleMemberDataPointer(const CXXRecordDecl *RD,
665 const ValueDecl *VD,
666 StringRef Prefix) {
667 // <member-data-pointer> ::= <integer-literal>
668 // ::= $F <number> <number>
669 // ::= $G <number> <number> <number>
670
671 int64_t FieldOffset;
672 int64_t VBTableOffset;
673 MSInheritanceModel IM = RD->getMSInheritanceModel();
674 if (VD) {
675 FieldOffset = getASTContext().getFieldOffset(VD);
676 assert(FieldOffset % getASTContext().getCharWidth() == 0 &&
677 "cannot take address of bitfield");
678 FieldOffset /= getASTContext().getCharWidth();
679
680 VBTableOffset = 0;
681
682 if (IM == MSInheritanceModel::Virtual)
683 FieldOffset -= getASTContext().getOffsetOfBaseWithVBPtr(RD).getQuantity();
684 } else {
685 FieldOffset = RD->nullFieldOffsetIsZero() ? 0 : -1;
686
687 VBTableOffset = -1;
688 }
689
690 char Code = '\0';
691 switch (IM) {
692 case MSInheritanceModel::Single: Code = '0'; break;
693 case MSInheritanceModel::Multiple: Code = '0'; break;
694 case MSInheritanceModel::Virtual: Code = 'F'; break;
695 case MSInheritanceModel::Unspecified: Code = 'G'; break;
696 }
697
698 Out << Prefix << Code;
699
700 mangleNumber(FieldOffset);
701
702 // The C++ standard doesn't allow base-to-derived member pointer conversions
703 // in template parameter contexts, so the vbptr offset of data member pointers
704 // is always zero.
705 if (inheritanceModelHasVBPtrOffsetField(IM))
706 mangleNumber(0);
707 if (inheritanceModelHasVBTableOffsetField(IM))
708 mangleNumber(VBTableOffset);
709 }
710
711 void
mangleMemberFunctionPointer(const CXXRecordDecl * RD,const CXXMethodDecl * MD,StringRef Prefix)712 MicrosoftCXXNameMangler::mangleMemberFunctionPointer(const CXXRecordDecl *RD,
713 const CXXMethodDecl *MD,
714 StringRef Prefix) {
715 // <member-function-pointer> ::= $1? <name>
716 // ::= $H? <name> <number>
717 // ::= $I? <name> <number> <number>
718 // ::= $J? <name> <number> <number> <number>
719
720 MSInheritanceModel IM = RD->getMSInheritanceModel();
721
722 char Code = '\0';
723 switch (IM) {
724 case MSInheritanceModel::Single: Code = '1'; break;
725 case MSInheritanceModel::Multiple: Code = 'H'; break;
726 case MSInheritanceModel::Virtual: Code = 'I'; break;
727 case MSInheritanceModel::Unspecified: Code = 'J'; break;
728 }
729
730 // If non-virtual, mangle the name. If virtual, mangle as a virtual memptr
731 // thunk.
732 uint64_t NVOffset = 0;
733 uint64_t VBTableOffset = 0;
734 uint64_t VBPtrOffset = 0;
735 if (MD) {
736 Out << Prefix << Code << '?';
737 if (MD->isVirtual()) {
738 MicrosoftVTableContext *VTContext =
739 cast<MicrosoftVTableContext>(getASTContext().getVTableContext());
740 MethodVFTableLocation ML =
741 VTContext->getMethodVFTableLocation(GlobalDecl(MD));
742 mangleVirtualMemPtrThunk(MD, ML);
743 NVOffset = ML.VFPtrOffset.getQuantity();
744 VBTableOffset = ML.VBTableIndex * 4;
745 if (ML.VBase) {
746 const ASTRecordLayout &Layout = getASTContext().getASTRecordLayout(RD);
747 VBPtrOffset = Layout.getVBPtrOffset().getQuantity();
748 }
749 } else {
750 mangleName(MD);
751 mangleFunctionEncoding(MD, /*ShouldMangle=*/true);
752 }
753
754 if (VBTableOffset == 0 && IM == MSInheritanceModel::Virtual)
755 NVOffset -= getASTContext().getOffsetOfBaseWithVBPtr(RD).getQuantity();
756 } else {
757 // Null single inheritance member functions are encoded as a simple nullptr.
758 if (IM == MSInheritanceModel::Single) {
759 Out << Prefix << "0A@";
760 return;
761 }
762 if (IM == MSInheritanceModel::Unspecified)
763 VBTableOffset = -1;
764 Out << Prefix << Code;
765 }
766
767 if (inheritanceModelHasNVOffsetField(/*IsMemberFunction=*/true, IM))
768 mangleNumber(static_cast<uint32_t>(NVOffset));
769 if (inheritanceModelHasVBPtrOffsetField(IM))
770 mangleNumber(VBPtrOffset);
771 if (inheritanceModelHasVBTableOffsetField(IM))
772 mangleNumber(VBTableOffset);
773 }
774
mangleVirtualMemPtrThunk(const CXXMethodDecl * MD,const MethodVFTableLocation & ML)775 void MicrosoftCXXNameMangler::mangleVirtualMemPtrThunk(
776 const CXXMethodDecl *MD, const MethodVFTableLocation &ML) {
777 // Get the vftable offset.
778 CharUnits PointerWidth = getASTContext().toCharUnitsFromBits(
779 getASTContext().getTargetInfo().getPointerWidth(0));
780 uint64_t OffsetInVFTable = ML.Index * PointerWidth.getQuantity();
781
782 Out << "?_9";
783 mangleName(MD->getParent());
784 Out << "$B";
785 mangleNumber(OffsetInVFTable);
786 Out << 'A';
787 mangleCallingConvention(MD->getType()->castAs<FunctionProtoType>());
788 }
789
mangleName(GlobalDecl GD)790 void MicrosoftCXXNameMangler::mangleName(GlobalDecl GD) {
791 // <name> ::= <unscoped-name> {[<named-scope>]+ | [<nested-name>]}? @
792
793 // Always start with the unqualified name.
794 mangleUnqualifiedName(GD);
795
796 mangleNestedName(GD);
797
798 // Terminate the whole name with an '@'.
799 Out << '@';
800 }
801
mangleNumber(int64_t Number)802 void MicrosoftCXXNameMangler::mangleNumber(int64_t Number) {
803 mangleNumber(llvm::APSInt(llvm::APInt(64, Number), /*IsUnsigned*/false));
804 }
805
mangleNumber(llvm::APSInt Number)806 void MicrosoftCXXNameMangler::mangleNumber(llvm::APSInt Number) {
807 // MSVC never mangles any integer wider than 64 bits. In general it appears
808 // to convert every integer to signed 64 bit before mangling (including
809 // unsigned 64 bit values). Do the same, but preserve bits beyond the bottom
810 // 64.
811 unsigned Width = std::max(Number.getBitWidth(), 64U);
812 llvm::APInt Value = Number.extend(Width);
813
814 // <non-negative integer> ::= A@ # when Number == 0
815 // ::= <decimal digit> # when 1 <= Number <= 10
816 // ::= <hex digit>+ @ # when Number >= 10
817 //
818 // <number> ::= [?] <non-negative integer>
819
820 if (Value.isNegative()) {
821 Value = -Value;
822 Out << '?';
823 }
824 mangleBits(Value);
825 }
826
mangleFloat(llvm::APFloat Number)827 void MicrosoftCXXNameMangler::mangleFloat(llvm::APFloat Number) {
828 using llvm::APFloat;
829
830 switch (APFloat::SemanticsToEnum(Number.getSemantics())) {
831 case APFloat::S_IEEEsingle: Out << 'A'; break;
832 case APFloat::S_IEEEdouble: Out << 'B'; break;
833
834 // The following are all Clang extensions. We try to pick manglings that are
835 // unlikely to conflict with MSVC's scheme.
836 case APFloat::S_IEEEhalf: Out << 'V'; break;
837 case APFloat::S_BFloat: Out << 'W'; break;
838 case APFloat::S_x87DoubleExtended: Out << 'X'; break;
839 case APFloat::S_IEEEquad: Out << 'Y'; break;
840 case APFloat::S_PPCDoubleDouble: Out << 'Z'; break;
841 }
842
843 mangleBits(Number.bitcastToAPInt());
844 }
845
mangleBits(llvm::APInt Value)846 void MicrosoftCXXNameMangler::mangleBits(llvm::APInt Value) {
847 if (Value == 0)
848 Out << "A@";
849 else if (Value.uge(1) && Value.ule(10))
850 Out << (Value - 1);
851 else {
852 // Numbers that are not encoded as decimal digits are represented as nibbles
853 // in the range of ASCII characters 'A' to 'P'.
854 // The number 0x123450 would be encoded as 'BCDEFA'
855 llvm::SmallString<32> EncodedNumberBuffer;
856 for (; Value != 0; Value.lshrInPlace(4))
857 EncodedNumberBuffer.push_back('A' + (Value & 0xf).getZExtValue());
858 std::reverse(EncodedNumberBuffer.begin(), EncodedNumberBuffer.end());
859 Out.write(EncodedNumberBuffer.data(), EncodedNumberBuffer.size());
860 Out << '@';
861 }
862 }
863
isTemplate(GlobalDecl GD,const TemplateArgumentList * & TemplateArgs)864 static GlobalDecl isTemplate(GlobalDecl GD,
865 const TemplateArgumentList *&TemplateArgs) {
866 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
867 // Check if we have a function template.
868 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
869 if (const TemplateDecl *TD = FD->getPrimaryTemplate()) {
870 TemplateArgs = FD->getTemplateSpecializationArgs();
871 return GD.getWithDecl(TD);
872 }
873 }
874
875 // Check if we have a class template.
876 if (const ClassTemplateSpecializationDecl *Spec =
877 dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
878 TemplateArgs = &Spec->getTemplateArgs();
879 return GD.getWithDecl(Spec->getSpecializedTemplate());
880 }
881
882 // Check if we have a variable template.
883 if (const VarTemplateSpecializationDecl *Spec =
884 dyn_cast<VarTemplateSpecializationDecl>(ND)) {
885 TemplateArgs = &Spec->getTemplateArgs();
886 return GD.getWithDecl(Spec->getSpecializedTemplate());
887 }
888
889 return GlobalDecl();
890 }
891
mangleUnqualifiedName(GlobalDecl GD,DeclarationName Name)892 void MicrosoftCXXNameMangler::mangleUnqualifiedName(GlobalDecl GD,
893 DeclarationName Name) {
894 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
895 // <unqualified-name> ::= <operator-name>
896 // ::= <ctor-dtor-name>
897 // ::= <source-name>
898 // ::= <template-name>
899
900 // Check if we have a template.
901 const TemplateArgumentList *TemplateArgs = nullptr;
902 if (GlobalDecl TD = isTemplate(GD, TemplateArgs)) {
903 // Function templates aren't considered for name back referencing. This
904 // makes sense since function templates aren't likely to occur multiple
905 // times in a symbol.
906 if (isa<FunctionTemplateDecl>(TD.getDecl())) {
907 mangleTemplateInstantiationName(TD, *TemplateArgs);
908 Out << '@';
909 return;
910 }
911
912 // Here comes the tricky thing: if we need to mangle something like
913 // void foo(A::X<Y>, B::X<Y>),
914 // the X<Y> part is aliased. However, if you need to mangle
915 // void foo(A::X<A::Y>, A::X<B::Y>),
916 // the A::X<> part is not aliased.
917 // That is, from the mangler's perspective we have a structure like this:
918 // namespace[s] -> type[ -> template-parameters]
919 // but from the Clang perspective we have
920 // type [ -> template-parameters]
921 // \-> namespace[s]
922 // What we do is we create a new mangler, mangle the same type (without
923 // a namespace suffix) to a string using the extra mangler and then use
924 // the mangled type name as a key to check the mangling of different types
925 // for aliasing.
926
927 // It's important to key cache reads off ND, not TD -- the same TD can
928 // be used with different TemplateArgs, but ND uniquely identifies
929 // TD / TemplateArg pairs.
930 ArgBackRefMap::iterator Found = TemplateArgBackReferences.find(ND);
931 if (Found == TemplateArgBackReferences.end()) {
932
933 TemplateArgStringMap::iterator Found = TemplateArgStrings.find(ND);
934 if (Found == TemplateArgStrings.end()) {
935 // Mangle full template name into temporary buffer.
936 llvm::SmallString<64> TemplateMangling;
937 llvm::raw_svector_ostream Stream(TemplateMangling);
938 MicrosoftCXXNameMangler Extra(Context, Stream);
939 Extra.mangleTemplateInstantiationName(TD, *TemplateArgs);
940
941 // Use the string backref vector to possibly get a back reference.
942 mangleSourceName(TemplateMangling);
943
944 // Memoize back reference for this type if one exist, else memoize
945 // the mangling itself.
946 BackRefVec::iterator StringFound =
947 llvm::find(NameBackReferences, TemplateMangling);
948 if (StringFound != NameBackReferences.end()) {
949 TemplateArgBackReferences[ND] =
950 StringFound - NameBackReferences.begin();
951 } else {
952 TemplateArgStrings[ND] =
953 TemplateArgStringStorage.save(TemplateMangling.str());
954 }
955 } else {
956 Out << Found->second << '@'; // Outputs a StringRef.
957 }
958 } else {
959 Out << Found->second; // Outputs a back reference (an int).
960 }
961 return;
962 }
963
964 switch (Name.getNameKind()) {
965 case DeclarationName::Identifier: {
966 if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) {
967 bool IsDeviceStub =
968 ND &&
969 ((isa<FunctionDecl>(ND) && ND->hasAttr<CUDAGlobalAttr>()) ||
970 (isa<FunctionTemplateDecl>(ND) &&
971 cast<FunctionTemplateDecl>(ND)
972 ->getTemplatedDecl()
973 ->hasAttr<CUDAGlobalAttr>())) &&
974 GD.getKernelReferenceKind() == KernelReferenceKind::Stub;
975 if (IsDeviceStub)
976 mangleSourceName(
977 (llvm::Twine("__device_stub__") + II->getName()).str());
978 else
979 mangleSourceName(II->getName());
980 break;
981 }
982
983 // Otherwise, an anonymous entity. We must have a declaration.
984 assert(ND && "mangling empty name without declaration");
985
986 if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
987 if (NS->isAnonymousNamespace()) {
988 Out << "?A0x" << Context.getAnonymousNamespaceHash() << '@';
989 break;
990 }
991 }
992
993 if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(ND)) {
994 // Decomposition declarations are considered anonymous, and get
995 // numbered with a $S prefix.
996 llvm::SmallString<64> Name("$S");
997 // Get a unique id for the anonymous struct.
998 Name += llvm::utostr(Context.getAnonymousStructId(DD) + 1);
999 mangleSourceName(Name);
1000 break;
1001 }
1002
1003 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
1004 // We must have an anonymous union or struct declaration.
1005 const CXXRecordDecl *RD = VD->getType()->getAsCXXRecordDecl();
1006 assert(RD && "expected variable decl to have a record type");
1007 // Anonymous types with no tag or typedef get the name of their
1008 // declarator mangled in. If they have no declarator, number them with
1009 // a $S prefix.
1010 llvm::SmallString<64> Name("$S");
1011 // Get a unique id for the anonymous struct.
1012 Name += llvm::utostr(Context.getAnonymousStructId(RD) + 1);
1013 mangleSourceName(Name.str());
1014 break;
1015 }
1016
1017 if (const MSGuidDecl *GD = dyn_cast<MSGuidDecl>(ND)) {
1018 // Mangle a GUID object as if it were a variable with the corresponding
1019 // mangled name.
1020 SmallString<sizeof("_GUID_12345678_1234_1234_1234_1234567890ab")> GUID;
1021 llvm::raw_svector_ostream GUIDOS(GUID);
1022 Context.mangleMSGuidDecl(GD, GUIDOS);
1023 mangleSourceName(GUID);
1024 break;
1025 }
1026
1027 if (const auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
1028 Out << "?__N";
1029 mangleTemplateArgValue(TPO->getType().getUnqualifiedType(),
1030 TPO->getValue());
1031 break;
1032 }
1033
1034 // We must have an anonymous struct.
1035 const TagDecl *TD = cast<TagDecl>(ND);
1036 if (const TypedefNameDecl *D = TD->getTypedefNameForAnonDecl()) {
1037 assert(TD->getDeclContext() == D->getDeclContext() &&
1038 "Typedef should not be in another decl context!");
1039 assert(D->getDeclName().getAsIdentifierInfo() &&
1040 "Typedef was not named!");
1041 mangleSourceName(D->getDeclName().getAsIdentifierInfo()->getName());
1042 break;
1043 }
1044
1045 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) {
1046 if (Record->isLambda()) {
1047 llvm::SmallString<10> Name("<lambda_");
1048
1049 Decl *LambdaContextDecl = Record->getLambdaContextDecl();
1050 unsigned LambdaManglingNumber = Record->getLambdaManglingNumber();
1051 unsigned LambdaId;
1052 const ParmVarDecl *Parm =
1053 dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
1054 const FunctionDecl *Func =
1055 Parm ? dyn_cast<FunctionDecl>(Parm->getDeclContext()) : nullptr;
1056
1057 if (Func) {
1058 unsigned DefaultArgNo =
1059 Func->getNumParams() - Parm->getFunctionScopeIndex();
1060 Name += llvm::utostr(DefaultArgNo);
1061 Name += "_";
1062 }
1063
1064 if (LambdaManglingNumber)
1065 LambdaId = LambdaManglingNumber;
1066 else
1067 LambdaId = Context.getLambdaId(Record);
1068
1069 Name += llvm::utostr(LambdaId);
1070 Name += ">";
1071
1072 mangleSourceName(Name);
1073
1074 // If the context is a variable or a class member and not a parameter,
1075 // it is encoded in a qualified name.
1076 if (LambdaManglingNumber && LambdaContextDecl) {
1077 if ((isa<VarDecl>(LambdaContextDecl) ||
1078 isa<FieldDecl>(LambdaContextDecl)) &&
1079 !isa<ParmVarDecl>(LambdaContextDecl)) {
1080 mangleUnqualifiedName(cast<NamedDecl>(LambdaContextDecl));
1081 }
1082 }
1083 break;
1084 }
1085 }
1086
1087 llvm::SmallString<64> Name;
1088 if (DeclaratorDecl *DD =
1089 Context.getASTContext().getDeclaratorForUnnamedTagDecl(TD)) {
1090 // Anonymous types without a name for linkage purposes have their
1091 // declarator mangled in if they have one.
1092 Name += "<unnamed-type-";
1093 Name += DD->getName();
1094 } else if (TypedefNameDecl *TND =
1095 Context.getASTContext().getTypedefNameForUnnamedTagDecl(
1096 TD)) {
1097 // Anonymous types without a name for linkage purposes have their
1098 // associate typedef mangled in if they have one.
1099 Name += "<unnamed-type-";
1100 Name += TND->getName();
1101 } else if (isa<EnumDecl>(TD) &&
1102 cast<EnumDecl>(TD)->enumerator_begin() !=
1103 cast<EnumDecl>(TD)->enumerator_end()) {
1104 // Anonymous non-empty enums mangle in the first enumerator.
1105 auto *ED = cast<EnumDecl>(TD);
1106 Name += "<unnamed-enum-";
1107 Name += ED->enumerator_begin()->getName();
1108 } else {
1109 // Otherwise, number the types using a $S prefix.
1110 Name += "<unnamed-type-$S";
1111 Name += llvm::utostr(Context.getAnonymousStructId(TD) + 1);
1112 }
1113 Name += ">";
1114 mangleSourceName(Name.str());
1115 break;
1116 }
1117
1118 case DeclarationName::ObjCZeroArgSelector:
1119 case DeclarationName::ObjCOneArgSelector:
1120 case DeclarationName::ObjCMultiArgSelector: {
1121 // This is reachable only when constructing an outlined SEH finally
1122 // block. Nothing depends on this mangling and it's used only with
1123 // functinos with internal linkage.
1124 llvm::SmallString<64> Name;
1125 mangleSourceName(Name.str());
1126 break;
1127 }
1128
1129 case DeclarationName::CXXConstructorName:
1130 if (isStructorDecl(ND)) {
1131 if (StructorType == Ctor_CopyingClosure) {
1132 Out << "?_O";
1133 return;
1134 }
1135 if (StructorType == Ctor_DefaultClosure) {
1136 Out << "?_F";
1137 return;
1138 }
1139 }
1140 Out << "?0";
1141 return;
1142
1143 case DeclarationName::CXXDestructorName:
1144 if (isStructorDecl(ND))
1145 // If the named decl is the C++ destructor we're mangling,
1146 // use the type we were given.
1147 mangleCXXDtorType(static_cast<CXXDtorType>(StructorType));
1148 else
1149 // Otherwise, use the base destructor name. This is relevant if a
1150 // class with a destructor is declared within a destructor.
1151 mangleCXXDtorType(Dtor_Base);
1152 break;
1153
1154 case DeclarationName::CXXConversionFunctionName:
1155 // <operator-name> ::= ?B # (cast)
1156 // The target type is encoded as the return type.
1157 Out << "?B";
1158 break;
1159
1160 case DeclarationName::CXXOperatorName:
1161 mangleOperatorName(Name.getCXXOverloadedOperator(), ND->getLocation());
1162 break;
1163
1164 case DeclarationName::CXXLiteralOperatorName: {
1165 Out << "?__K";
1166 mangleSourceName(Name.getCXXLiteralIdentifier()->getName());
1167 break;
1168 }
1169
1170 case DeclarationName::CXXDeductionGuideName:
1171 llvm_unreachable("Can't mangle a deduction guide name!");
1172
1173 case DeclarationName::CXXUsingDirective:
1174 llvm_unreachable("Can't mangle a using directive name!");
1175 }
1176 }
1177
1178 // <postfix> ::= <unqualified-name> [<postfix>]
1179 // ::= <substitution> [<postfix>]
mangleNestedName(GlobalDecl GD)1180 void MicrosoftCXXNameMangler::mangleNestedName(GlobalDecl GD) {
1181 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
1182 const DeclContext *DC = getEffectiveDeclContext(ND);
1183 while (!DC->isTranslationUnit()) {
1184 if (isa<TagDecl>(ND) || isa<VarDecl>(ND)) {
1185 unsigned Disc;
1186 if (Context.getNextDiscriminator(ND, Disc)) {
1187 Out << '?';
1188 mangleNumber(Disc);
1189 Out << '?';
1190 }
1191 }
1192
1193 if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) {
1194 auto Discriminate =
1195 [](StringRef Name, const unsigned Discriminator,
1196 const unsigned ParameterDiscriminator) -> std::string {
1197 std::string Buffer;
1198 llvm::raw_string_ostream Stream(Buffer);
1199 Stream << Name;
1200 if (Discriminator)
1201 Stream << '_' << Discriminator;
1202 if (ParameterDiscriminator)
1203 Stream << '_' << ParameterDiscriminator;
1204 return Stream.str();
1205 };
1206
1207 unsigned Discriminator = BD->getBlockManglingNumber();
1208 if (!Discriminator)
1209 Discriminator = Context.getBlockId(BD, /*Local=*/false);
1210
1211 // Mangle the parameter position as a discriminator to deal with unnamed
1212 // parameters. Rather than mangling the unqualified parameter name,
1213 // always use the position to give a uniform mangling.
1214 unsigned ParameterDiscriminator = 0;
1215 if (const auto *MC = BD->getBlockManglingContextDecl())
1216 if (const auto *P = dyn_cast<ParmVarDecl>(MC))
1217 if (const auto *F = dyn_cast<FunctionDecl>(P->getDeclContext()))
1218 ParameterDiscriminator =
1219 F->getNumParams() - P->getFunctionScopeIndex();
1220
1221 DC = getEffectiveDeclContext(BD);
1222
1223 Out << '?';
1224 mangleSourceName(Discriminate("_block_invoke", Discriminator,
1225 ParameterDiscriminator));
1226 // If we have a block mangling context, encode that now. This allows us
1227 // to discriminate between named static data initializers in the same
1228 // scope. This is handled differently from parameters, which use
1229 // positions to discriminate between multiple instances.
1230 if (const auto *MC = BD->getBlockManglingContextDecl())
1231 if (!isa<ParmVarDecl>(MC))
1232 if (const auto *ND = dyn_cast<NamedDecl>(MC))
1233 mangleUnqualifiedName(ND);
1234 // MS ABI and Itanium manglings are in inverted scopes. In the case of a
1235 // RecordDecl, mangle the entire scope hierarchy at this point rather than
1236 // just the unqualified name to get the ordering correct.
1237 if (const auto *RD = dyn_cast<RecordDecl>(DC))
1238 mangleName(RD);
1239 else
1240 Out << '@';
1241 // void __cdecl
1242 Out << "YAX";
1243 // struct __block_literal *
1244 Out << 'P';
1245 // __ptr64
1246 if (PointersAre64Bit)
1247 Out << 'E';
1248 Out << 'A';
1249 mangleArtificialTagType(TTK_Struct,
1250 Discriminate("__block_literal", Discriminator,
1251 ParameterDiscriminator));
1252 Out << "@Z";
1253
1254 // If the effective context was a Record, we have fully mangled the
1255 // qualified name and do not need to continue.
1256 if (isa<RecordDecl>(DC))
1257 break;
1258 continue;
1259 } else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) {
1260 mangleObjCMethodName(Method);
1261 } else if (isa<NamedDecl>(DC)) {
1262 ND = cast<NamedDecl>(DC);
1263 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
1264 mangle(getGlobalDeclAsDeclContext(FD), "?");
1265 break;
1266 } else {
1267 mangleUnqualifiedName(ND);
1268 // Lambdas in default arguments conceptually belong to the function the
1269 // parameter corresponds to.
1270 if (const auto *LDADC = getLambdaDefaultArgumentDeclContext(ND)) {
1271 DC = LDADC;
1272 continue;
1273 }
1274 }
1275 }
1276 DC = DC->getParent();
1277 }
1278 }
1279
mangleCXXDtorType(CXXDtorType T)1280 void MicrosoftCXXNameMangler::mangleCXXDtorType(CXXDtorType T) {
1281 // Microsoft uses the names on the case labels for these dtor variants. Clang
1282 // uses the Itanium terminology internally. Everything in this ABI delegates
1283 // towards the base dtor.
1284 switch (T) {
1285 // <operator-name> ::= ?1 # destructor
1286 case Dtor_Base: Out << "?1"; return;
1287 // <operator-name> ::= ?_D # vbase destructor
1288 case Dtor_Complete: Out << "?_D"; return;
1289 // <operator-name> ::= ?_G # scalar deleting destructor
1290 case Dtor_Deleting: Out << "?_G"; return;
1291 // <operator-name> ::= ?_E # vector deleting destructor
1292 // FIXME: Add a vector deleting dtor type. It goes in the vtable, so we need
1293 // it.
1294 case Dtor_Comdat:
1295 llvm_unreachable("not expecting a COMDAT");
1296 }
1297 llvm_unreachable("Unsupported dtor type?");
1298 }
1299
mangleOperatorName(OverloadedOperatorKind OO,SourceLocation Loc)1300 void MicrosoftCXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO,
1301 SourceLocation Loc) {
1302 switch (OO) {
1303 // ?0 # constructor
1304 // ?1 # destructor
1305 // <operator-name> ::= ?2 # new
1306 case OO_New: Out << "?2"; break;
1307 // <operator-name> ::= ?3 # delete
1308 case OO_Delete: Out << "?3"; break;
1309 // <operator-name> ::= ?4 # =
1310 case OO_Equal: Out << "?4"; break;
1311 // <operator-name> ::= ?5 # >>
1312 case OO_GreaterGreater: Out << "?5"; break;
1313 // <operator-name> ::= ?6 # <<
1314 case OO_LessLess: Out << "?6"; break;
1315 // <operator-name> ::= ?7 # !
1316 case OO_Exclaim: Out << "?7"; break;
1317 // <operator-name> ::= ?8 # ==
1318 case OO_EqualEqual: Out << "?8"; break;
1319 // <operator-name> ::= ?9 # !=
1320 case OO_ExclaimEqual: Out << "?9"; break;
1321 // <operator-name> ::= ?A # []
1322 case OO_Subscript: Out << "?A"; break;
1323 // ?B # conversion
1324 // <operator-name> ::= ?C # ->
1325 case OO_Arrow: Out << "?C"; break;
1326 // <operator-name> ::= ?D # *
1327 case OO_Star: Out << "?D"; break;
1328 // <operator-name> ::= ?E # ++
1329 case OO_PlusPlus: Out << "?E"; break;
1330 // <operator-name> ::= ?F # --
1331 case OO_MinusMinus: Out << "?F"; break;
1332 // <operator-name> ::= ?G # -
1333 case OO_Minus: Out << "?G"; break;
1334 // <operator-name> ::= ?H # +
1335 case OO_Plus: Out << "?H"; break;
1336 // <operator-name> ::= ?I # &
1337 case OO_Amp: Out << "?I"; break;
1338 // <operator-name> ::= ?J # ->*
1339 case OO_ArrowStar: Out << "?J"; break;
1340 // <operator-name> ::= ?K # /
1341 case OO_Slash: Out << "?K"; break;
1342 // <operator-name> ::= ?L # %
1343 case OO_Percent: Out << "?L"; break;
1344 // <operator-name> ::= ?M # <
1345 case OO_Less: Out << "?M"; break;
1346 // <operator-name> ::= ?N # <=
1347 case OO_LessEqual: Out << "?N"; break;
1348 // <operator-name> ::= ?O # >
1349 case OO_Greater: Out << "?O"; break;
1350 // <operator-name> ::= ?P # >=
1351 case OO_GreaterEqual: Out << "?P"; break;
1352 // <operator-name> ::= ?Q # ,
1353 case OO_Comma: Out << "?Q"; break;
1354 // <operator-name> ::= ?R # ()
1355 case OO_Call: Out << "?R"; break;
1356 // <operator-name> ::= ?S # ~
1357 case OO_Tilde: Out << "?S"; break;
1358 // <operator-name> ::= ?T # ^
1359 case OO_Caret: Out << "?T"; break;
1360 // <operator-name> ::= ?U # |
1361 case OO_Pipe: Out << "?U"; break;
1362 // <operator-name> ::= ?V # &&
1363 case OO_AmpAmp: Out << "?V"; break;
1364 // <operator-name> ::= ?W # ||
1365 case OO_PipePipe: Out << "?W"; break;
1366 // <operator-name> ::= ?X # *=
1367 case OO_StarEqual: Out << "?X"; break;
1368 // <operator-name> ::= ?Y # +=
1369 case OO_PlusEqual: Out << "?Y"; break;
1370 // <operator-name> ::= ?Z # -=
1371 case OO_MinusEqual: Out << "?Z"; break;
1372 // <operator-name> ::= ?_0 # /=
1373 case OO_SlashEqual: Out << "?_0"; break;
1374 // <operator-name> ::= ?_1 # %=
1375 case OO_PercentEqual: Out << "?_1"; break;
1376 // <operator-name> ::= ?_2 # >>=
1377 case OO_GreaterGreaterEqual: Out << "?_2"; break;
1378 // <operator-name> ::= ?_3 # <<=
1379 case OO_LessLessEqual: Out << "?_3"; break;
1380 // <operator-name> ::= ?_4 # &=
1381 case OO_AmpEqual: Out << "?_4"; break;
1382 // <operator-name> ::= ?_5 # |=
1383 case OO_PipeEqual: Out << "?_5"; break;
1384 // <operator-name> ::= ?_6 # ^=
1385 case OO_CaretEqual: Out << "?_6"; break;
1386 // ?_7 # vftable
1387 // ?_8 # vbtable
1388 // ?_9 # vcall
1389 // ?_A # typeof
1390 // ?_B # local static guard
1391 // ?_C # string
1392 // ?_D # vbase destructor
1393 // ?_E # vector deleting destructor
1394 // ?_F # default constructor closure
1395 // ?_G # scalar deleting destructor
1396 // ?_H # vector constructor iterator
1397 // ?_I # vector destructor iterator
1398 // ?_J # vector vbase constructor iterator
1399 // ?_K # virtual displacement map
1400 // ?_L # eh vector constructor iterator
1401 // ?_M # eh vector destructor iterator
1402 // ?_N # eh vector vbase constructor iterator
1403 // ?_O # copy constructor closure
1404 // ?_P<name> # udt returning <name>
1405 // ?_Q # <unknown>
1406 // ?_R0 # RTTI Type Descriptor
1407 // ?_R1 # RTTI Base Class Descriptor at (a,b,c,d)
1408 // ?_R2 # RTTI Base Class Array
1409 // ?_R3 # RTTI Class Hierarchy Descriptor
1410 // ?_R4 # RTTI Complete Object Locator
1411 // ?_S # local vftable
1412 // ?_T # local vftable constructor closure
1413 // <operator-name> ::= ?_U # new[]
1414 case OO_Array_New: Out << "?_U"; break;
1415 // <operator-name> ::= ?_V # delete[]
1416 case OO_Array_Delete: Out << "?_V"; break;
1417 // <operator-name> ::= ?__L # co_await
1418 case OO_Coawait: Out << "?__L"; break;
1419 // <operator-name> ::= ?__M # <=>
1420 case OO_Spaceship: Out << "?__M"; break;
1421
1422 case OO_Conditional: {
1423 DiagnosticsEngine &Diags = Context.getDiags();
1424 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
1425 "cannot mangle this conditional operator yet");
1426 Diags.Report(Loc, DiagID);
1427 break;
1428 }
1429
1430 case OO_None:
1431 case NUM_OVERLOADED_OPERATORS:
1432 llvm_unreachable("Not an overloaded operator");
1433 }
1434 }
1435
mangleSourceName(StringRef Name)1436 void MicrosoftCXXNameMangler::mangleSourceName(StringRef Name) {
1437 // <source name> ::= <identifier> @
1438 BackRefVec::iterator Found = llvm::find(NameBackReferences, Name);
1439 if (Found == NameBackReferences.end()) {
1440 if (NameBackReferences.size() < 10)
1441 NameBackReferences.push_back(std::string(Name));
1442 Out << Name << '@';
1443 } else {
1444 Out << (Found - NameBackReferences.begin());
1445 }
1446 }
1447
mangleObjCMethodName(const ObjCMethodDecl * MD)1448 void MicrosoftCXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) {
1449 Context.mangleObjCMethodNameAsSourceName(MD, Out);
1450 }
1451
mangleTemplateInstantiationName(GlobalDecl GD,const TemplateArgumentList & TemplateArgs)1452 void MicrosoftCXXNameMangler::mangleTemplateInstantiationName(
1453 GlobalDecl GD, const TemplateArgumentList &TemplateArgs) {
1454 // <template-name> ::= <unscoped-template-name> <template-args>
1455 // ::= <substitution>
1456 // Always start with the unqualified name.
1457
1458 // Templates have their own context for back references.
1459 ArgBackRefMap OuterFunArgsContext;
1460 ArgBackRefMap OuterTemplateArgsContext;
1461 BackRefVec OuterTemplateContext;
1462 PassObjectSizeArgsSet OuterPassObjectSizeArgs;
1463 NameBackReferences.swap(OuterTemplateContext);
1464 FunArgBackReferences.swap(OuterFunArgsContext);
1465 TemplateArgBackReferences.swap(OuterTemplateArgsContext);
1466 PassObjectSizeArgs.swap(OuterPassObjectSizeArgs);
1467
1468 mangleUnscopedTemplateName(GD);
1469 mangleTemplateArgs(cast<TemplateDecl>(GD.getDecl()), TemplateArgs);
1470
1471 // Restore the previous back reference contexts.
1472 NameBackReferences.swap(OuterTemplateContext);
1473 FunArgBackReferences.swap(OuterFunArgsContext);
1474 TemplateArgBackReferences.swap(OuterTemplateArgsContext);
1475 PassObjectSizeArgs.swap(OuterPassObjectSizeArgs);
1476 }
1477
mangleUnscopedTemplateName(GlobalDecl GD)1478 void MicrosoftCXXNameMangler::mangleUnscopedTemplateName(GlobalDecl GD) {
1479 // <unscoped-template-name> ::= ?$ <unqualified-name>
1480 Out << "?$";
1481 mangleUnqualifiedName(GD);
1482 }
1483
mangleIntegerLiteral(const llvm::APSInt & Value,const NonTypeTemplateParmDecl * PD,QualType TemplateArgType)1484 void MicrosoftCXXNameMangler::mangleIntegerLiteral(
1485 const llvm::APSInt &Value, const NonTypeTemplateParmDecl *PD,
1486 QualType TemplateArgType) {
1487 // <integer-literal> ::= $0 <number>
1488 Out << "$";
1489
1490 // Since MSVC 2019, add 'M[<type>]' after '$' for auto template parameter when
1491 // argument is integer.
1492 if (getASTContext().getLangOpts().isCompatibleWithMSVC(
1493 LangOptions::MSVC2019) &&
1494 PD && PD->getType()->getTypeClass() == Type::Auto &&
1495 !TemplateArgType.isNull()) {
1496 Out << "M";
1497 mangleType(TemplateArgType, SourceRange(), QMM_Drop);
1498 }
1499
1500 Out << "0";
1501
1502 mangleNumber(Value);
1503 }
1504
mangleExpression(const Expr * E,const NonTypeTemplateParmDecl * PD)1505 void MicrosoftCXXNameMangler::mangleExpression(
1506 const Expr *E, const NonTypeTemplateParmDecl *PD) {
1507 // See if this is a constant expression.
1508 if (Optional<llvm::APSInt> Value =
1509 E->getIntegerConstantExpr(Context.getASTContext())) {
1510 mangleIntegerLiteral(*Value, PD, E->getType());
1511 return;
1512 }
1513
1514 // As bad as this diagnostic is, it's better than crashing.
1515 DiagnosticsEngine &Diags = Context.getDiags();
1516 unsigned DiagID = Diags.getCustomDiagID(
1517 DiagnosticsEngine::Error, "cannot yet mangle expression type %0");
1518 Diags.Report(E->getExprLoc(), DiagID) << E->getStmtClassName()
1519 << E->getSourceRange();
1520 }
1521
mangleTemplateArgs(const TemplateDecl * TD,const TemplateArgumentList & TemplateArgs)1522 void MicrosoftCXXNameMangler::mangleTemplateArgs(
1523 const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) {
1524 // <template-args> ::= <template-arg>+
1525 const TemplateParameterList *TPL = TD->getTemplateParameters();
1526 assert(TPL->size() == TemplateArgs.size() &&
1527 "size mismatch between args and parms!");
1528
1529 for (size_t i = 0; i < TemplateArgs.size(); ++i) {
1530 const TemplateArgument &TA = TemplateArgs[i];
1531
1532 // Separate consecutive packs by $$Z.
1533 if (i > 0 && TA.getKind() == TemplateArgument::Pack &&
1534 TemplateArgs[i - 1].getKind() == TemplateArgument::Pack)
1535 Out << "$$Z";
1536
1537 mangleTemplateArg(TD, TA, TPL->getParam(i));
1538 }
1539 }
1540
mangleTemplateArg(const TemplateDecl * TD,const TemplateArgument & TA,const NamedDecl * Parm)1541 void MicrosoftCXXNameMangler::mangleTemplateArg(const TemplateDecl *TD,
1542 const TemplateArgument &TA,
1543 const NamedDecl *Parm) {
1544 // <template-arg> ::= <type>
1545 // ::= <integer-literal>
1546 // ::= <member-data-pointer>
1547 // ::= <member-function-pointer>
1548 // ::= $ <constant-value>
1549 // ::= <template-args>
1550 //
1551 // <constant-value> ::= 0 <number> # integer
1552 // ::= 1 <mangled-name> # address of D
1553 // ::= 2 <type> <typed-constant-value>* @ # struct
1554 // ::= 3 <type> <constant-value>* @ # array
1555 // ::= 4 ??? # string
1556 // ::= 5 <constant-value> @ # address of subobject
1557 // ::= 6 <constant-value> <unqualified-name> @ # a.b
1558 // ::= 7 <type> [<unqualified-name> <constant-value>] @
1559 // # union, with or without an active member
1560 // # pointer to member, symbolically
1561 // ::= 8 <class> <unqualified-name> @
1562 // ::= A <type> <non-negative integer> # float
1563 // ::= B <type> <non-negative integer> # double
1564 // ::= E <mangled-name> # reference to D
1565 // # pointer to member, by component value
1566 // ::= F <number> <number>
1567 // ::= G <number> <number> <number>
1568 // ::= H <mangled-name> <number>
1569 // ::= I <mangled-name> <number> <number>
1570 // ::= J <mangled-name> <number> <number> <number>
1571 //
1572 // <typed-constant-value> ::= [<type>] <constant-value>
1573 //
1574 // The <type> appears to be included in a <typed-constant-value> only in the
1575 // '0', '1', '8', 'A', 'B', and 'E' cases.
1576
1577 switch (TA.getKind()) {
1578 case TemplateArgument::Null:
1579 llvm_unreachable("Can't mangle null template arguments!");
1580 case TemplateArgument::TemplateExpansion:
1581 llvm_unreachable("Can't mangle template expansion arguments!");
1582 case TemplateArgument::Type: {
1583 QualType T = TA.getAsType();
1584 mangleType(T, SourceRange(), QMM_Escape);
1585 break;
1586 }
1587 case TemplateArgument::Declaration: {
1588 const NamedDecl *ND = TA.getAsDecl();
1589 if (isa<FieldDecl>(ND) || isa<IndirectFieldDecl>(ND)) {
1590 mangleMemberDataPointer(cast<CXXRecordDecl>(ND->getDeclContext())
1591 ->getMostRecentNonInjectedDecl(),
1592 cast<ValueDecl>(ND));
1593 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
1594 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
1595 if (MD && MD->isInstance()) {
1596 mangleMemberFunctionPointer(
1597 MD->getParent()->getMostRecentNonInjectedDecl(), MD);
1598 } else {
1599 Out << "$1?";
1600 mangleName(FD);
1601 mangleFunctionEncoding(FD, /*ShouldMangle=*/true);
1602 }
1603 } else if (TA.getParamTypeForDecl()->isRecordType()) {
1604 Out << "$";
1605 auto *TPO = cast<TemplateParamObjectDecl>(ND);
1606 mangleTemplateArgValue(TPO->getType().getUnqualifiedType(),
1607 TPO->getValue());
1608 } else {
1609 mangle(ND, TA.getParamTypeForDecl()->isReferenceType() ? "$E?" : "$1?");
1610 }
1611 break;
1612 }
1613 case TemplateArgument::Integral: {
1614 QualType T = TA.getIntegralType();
1615 mangleIntegerLiteral(TA.getAsIntegral(),
1616 cast<NonTypeTemplateParmDecl>(Parm), T);
1617 break;
1618 }
1619 case TemplateArgument::NullPtr: {
1620 QualType T = TA.getNullPtrType();
1621 if (const MemberPointerType *MPT = T->getAs<MemberPointerType>()) {
1622 const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
1623 if (MPT->isMemberFunctionPointerType() &&
1624 !isa<FunctionTemplateDecl>(TD)) {
1625 mangleMemberFunctionPointer(RD, nullptr);
1626 return;
1627 }
1628 if (MPT->isMemberDataPointer()) {
1629 if (!isa<FunctionTemplateDecl>(TD)) {
1630 mangleMemberDataPointer(RD, nullptr);
1631 return;
1632 }
1633 // nullptr data pointers are always represented with a single field
1634 // which is initialized with either 0 or -1. Why -1? Well, we need to
1635 // distinguish the case where the data member is at offset zero in the
1636 // record.
1637 // However, we are free to use 0 *if* we would use multiple fields for
1638 // non-nullptr member pointers.
1639 if (!RD->nullFieldOffsetIsZero()) {
1640 mangleIntegerLiteral(llvm::APSInt::get(-1),
1641 cast<NonTypeTemplateParmDecl>(Parm), T);
1642 return;
1643 }
1644 }
1645 }
1646 mangleIntegerLiteral(llvm::APSInt::getUnsigned(0),
1647 cast<NonTypeTemplateParmDecl>(Parm), T);
1648 break;
1649 }
1650 case TemplateArgument::Expression:
1651 mangleExpression(TA.getAsExpr(), cast<NonTypeTemplateParmDecl>(Parm));
1652 break;
1653 case TemplateArgument::Pack: {
1654 ArrayRef<TemplateArgument> TemplateArgs = TA.getPackAsArray();
1655 if (TemplateArgs.empty()) {
1656 if (isa<TemplateTypeParmDecl>(Parm) ||
1657 isa<TemplateTemplateParmDecl>(Parm))
1658 // MSVC 2015 changed the mangling for empty expanded template packs,
1659 // use the old mangling for link compatibility for old versions.
1660 Out << (Context.getASTContext().getLangOpts().isCompatibleWithMSVC(
1661 LangOptions::MSVC2015)
1662 ? "$$V"
1663 : "$$$V");
1664 else if (isa<NonTypeTemplateParmDecl>(Parm))
1665 Out << "$S";
1666 else
1667 llvm_unreachable("unexpected template parameter decl!");
1668 } else {
1669 for (const TemplateArgument &PA : TemplateArgs)
1670 mangleTemplateArg(TD, PA, Parm);
1671 }
1672 break;
1673 }
1674 case TemplateArgument::Template: {
1675 const NamedDecl *ND =
1676 TA.getAsTemplate().getAsTemplateDecl()->getTemplatedDecl();
1677 if (const auto *TD = dyn_cast<TagDecl>(ND)) {
1678 mangleType(TD);
1679 } else if (isa<TypeAliasDecl>(ND)) {
1680 Out << "$$Y";
1681 mangleName(ND);
1682 } else {
1683 llvm_unreachable("unexpected template template NamedDecl!");
1684 }
1685 break;
1686 }
1687 }
1688 }
1689
mangleTemplateArgValue(QualType T,const APValue & V,bool WithScalarType)1690 void MicrosoftCXXNameMangler::mangleTemplateArgValue(QualType T,
1691 const APValue &V,
1692 bool WithScalarType) {
1693 switch (V.getKind()) {
1694 case APValue::None:
1695 case APValue::Indeterminate:
1696 // FIXME: MSVC doesn't allow this, so we can't be sure how it should be
1697 // mangled.
1698 if (WithScalarType)
1699 mangleType(T, SourceRange(), QMM_Escape);
1700 Out << '@';
1701 return;
1702
1703 case APValue::Int:
1704 if (WithScalarType)
1705 mangleType(T, SourceRange(), QMM_Escape);
1706 Out << '0';
1707 mangleNumber(V.getInt());
1708 return;
1709
1710 case APValue::Float:
1711 if (WithScalarType)
1712 mangleType(T, SourceRange(), QMM_Escape);
1713 mangleFloat(V.getFloat());
1714 return;
1715
1716 case APValue::LValue: {
1717 if (WithScalarType)
1718 mangleType(T, SourceRange(), QMM_Escape);
1719
1720 // We don't know how to mangle past-the-end pointers yet.
1721 if (V.isLValueOnePastTheEnd())
1722 break;
1723
1724 APValue::LValueBase Base = V.getLValueBase();
1725 if (!V.hasLValuePath() || V.getLValuePath().empty()) {
1726 // Taking the address of a complete object has a special-case mangling.
1727 if (Base.isNull()) {
1728 // MSVC emits 0A@ for null pointers. Generalize this for arbitrary
1729 // integers cast to pointers.
1730 // FIXME: This mangles 0 cast to a pointer the same as a null pointer,
1731 // even in cases where the two are different values.
1732 Out << "0";
1733 mangleNumber(V.getLValueOffset().getQuantity());
1734 } else if (!V.hasLValuePath()) {
1735 // FIXME: This can only happen as an extension. Invent a mangling.
1736 break;
1737 } else if (auto *VD = Base.dyn_cast<const ValueDecl*>()) {
1738 Out << (T->isReferenceType() ? "E" : "1");
1739 mangle(VD);
1740 } else {
1741 break;
1742 }
1743 } else {
1744 unsigned NumAts = 0;
1745 if (T->isPointerType()) {
1746 Out << "5";
1747 ++NumAts;
1748 }
1749
1750 QualType T = Base.getType();
1751 for (APValue::LValuePathEntry E : V.getLValuePath()) {
1752 // We don't know how to mangle array subscripting yet.
1753 if (T->isArrayType())
1754 goto mangling_unknown;
1755
1756 const Decl *D = E.getAsBaseOrMember().getPointer();
1757 auto *FD = dyn_cast<FieldDecl>(D);
1758 // We don't know how to mangle derived-to-base conversions yet.
1759 if (!FD)
1760 goto mangling_unknown;
1761
1762 Out << "6";
1763 ++NumAts;
1764 T = FD->getType();
1765 }
1766
1767 auto *VD = Base.dyn_cast<const ValueDecl*>();
1768 if (!VD)
1769 break;
1770 Out << "E";
1771 mangle(VD);
1772
1773 for (APValue::LValuePathEntry E : V.getLValuePath()) {
1774 const Decl *D = E.getAsBaseOrMember().getPointer();
1775 mangleUnqualifiedName(cast<FieldDecl>(D));
1776 }
1777 for (unsigned I = 0; I != NumAts; ++I)
1778 Out << '@';
1779 }
1780
1781 return;
1782 }
1783
1784 case APValue::MemberPointer: {
1785 if (WithScalarType)
1786 mangleType(T, SourceRange(), QMM_Escape);
1787
1788 // FIXME: The below manglings don't include a conversion, so bail if there
1789 // would be one. MSVC mangles the (possibly converted) value of the
1790 // pointer-to-member object as if it were a struct, leading to collisions
1791 // in some cases.
1792 if (!V.getMemberPointerPath().empty())
1793 break;
1794
1795 const CXXRecordDecl *RD =
1796 T->castAs<MemberPointerType>()->getMostRecentCXXRecordDecl();
1797 const ValueDecl *D = V.getMemberPointerDecl();
1798 if (T->isMemberDataPointerType())
1799 mangleMemberDataPointer(RD, D, "");
1800 else
1801 mangleMemberFunctionPointer(RD, cast_or_null<CXXMethodDecl>(D), "");
1802 return;
1803 }
1804
1805 case APValue::Struct: {
1806 Out << '2';
1807 mangleType(T, SourceRange(), QMM_Escape);
1808 const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
1809 assert(RD && "unexpected type for record value");
1810
1811 unsigned BaseIndex = 0;
1812 for (const CXXBaseSpecifier &B : RD->bases())
1813 mangleTemplateArgValue(B.getType(), V.getStructBase(BaseIndex++));
1814 for (const FieldDecl *FD : RD->fields())
1815 if (!FD->isUnnamedBitfield())
1816 mangleTemplateArgValue(FD->getType(),
1817 V.getStructField(FD->getFieldIndex()),
1818 /*WithScalarType*/ true);
1819 Out << '@';
1820 return;
1821 }
1822
1823 case APValue::Union:
1824 Out << '7';
1825 mangleType(T, SourceRange(), QMM_Escape);
1826 if (const FieldDecl *FD = V.getUnionField()) {
1827 mangleUnqualifiedName(FD);
1828 mangleTemplateArgValue(FD->getType(), V.getUnionValue());
1829 }
1830 Out << '@';
1831 return;
1832
1833 case APValue::ComplexInt:
1834 // We mangle complex types as structs, so mangle the value as a struct too.
1835 Out << '2';
1836 mangleType(T, SourceRange(), QMM_Escape);
1837 Out << '0';
1838 mangleNumber(V.getComplexIntReal());
1839 Out << '0';
1840 mangleNumber(V.getComplexIntImag());
1841 Out << '@';
1842 return;
1843
1844 case APValue::ComplexFloat:
1845 Out << '2';
1846 mangleType(T, SourceRange(), QMM_Escape);
1847 mangleFloat(V.getComplexFloatReal());
1848 mangleFloat(V.getComplexFloatImag());
1849 Out << '@';
1850 return;
1851
1852 case APValue::Array: {
1853 Out << '3';
1854 QualType ElemT = getASTContext().getAsArrayType(T)->getElementType();
1855 mangleType(ElemT, SourceRange(), QMM_Escape);
1856 for (unsigned I = 0, N = V.getArraySize(); I != N; ++I) {
1857 const APValue &ElemV = I < V.getArrayInitializedElts()
1858 ? V.getArrayInitializedElt(I)
1859 : V.getArrayFiller();
1860 mangleTemplateArgValue(ElemT, ElemV);
1861 Out << '@';
1862 }
1863 Out << '@';
1864 return;
1865 }
1866
1867 case APValue::Vector: {
1868 // __m128 is mangled as a struct containing an array. We follow this
1869 // approach for all vector types.
1870 Out << '2';
1871 mangleType(T, SourceRange(), QMM_Escape);
1872 Out << '3';
1873 QualType ElemT = T->castAs<VectorType>()->getElementType();
1874 mangleType(ElemT, SourceRange(), QMM_Escape);
1875 for (unsigned I = 0, N = V.getVectorLength(); I != N; ++I) {
1876 const APValue &ElemV = V.getVectorElt(I);
1877 mangleTemplateArgValue(ElemT, ElemV);
1878 Out << '@';
1879 }
1880 Out << "@@";
1881 return;
1882 }
1883
1884 case APValue::AddrLabelDiff:
1885 case APValue::FixedPoint:
1886 break;
1887 }
1888
1889 mangling_unknown:
1890 DiagnosticsEngine &Diags = Context.getDiags();
1891 unsigned DiagID = Diags.getCustomDiagID(
1892 DiagnosticsEngine::Error, "cannot mangle this template argument yet");
1893 Diags.Report(DiagID);
1894 }
1895
mangleObjCProtocol(const ObjCProtocolDecl * PD)1896 void MicrosoftCXXNameMangler::mangleObjCProtocol(const ObjCProtocolDecl *PD) {
1897 llvm::SmallString<64> TemplateMangling;
1898 llvm::raw_svector_ostream Stream(TemplateMangling);
1899 MicrosoftCXXNameMangler Extra(Context, Stream);
1900
1901 Stream << "?$";
1902 Extra.mangleSourceName("Protocol");
1903 Extra.mangleArtificialTagType(TTK_Struct, PD->getName());
1904
1905 mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
1906 }
1907
mangleObjCLifetime(const QualType Type,Qualifiers Quals,SourceRange Range)1908 void MicrosoftCXXNameMangler::mangleObjCLifetime(const QualType Type,
1909 Qualifiers Quals,
1910 SourceRange Range) {
1911 llvm::SmallString<64> TemplateMangling;
1912 llvm::raw_svector_ostream Stream(TemplateMangling);
1913 MicrosoftCXXNameMangler Extra(Context, Stream);
1914
1915 Stream << "?$";
1916 switch (Quals.getObjCLifetime()) {
1917 case Qualifiers::OCL_None:
1918 case Qualifiers::OCL_ExplicitNone:
1919 break;
1920 case Qualifiers::OCL_Autoreleasing:
1921 Extra.mangleSourceName("Autoreleasing");
1922 break;
1923 case Qualifiers::OCL_Strong:
1924 Extra.mangleSourceName("Strong");
1925 break;
1926 case Qualifiers::OCL_Weak:
1927 Extra.mangleSourceName("Weak");
1928 break;
1929 }
1930 Extra.manglePointerCVQualifiers(Quals);
1931 Extra.manglePointerExtQualifiers(Quals, Type);
1932 Extra.mangleType(Type, Range);
1933
1934 mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
1935 }
1936
mangleObjCKindOfType(const ObjCObjectType * T,Qualifiers Quals,SourceRange Range)1937 void MicrosoftCXXNameMangler::mangleObjCKindOfType(const ObjCObjectType *T,
1938 Qualifiers Quals,
1939 SourceRange Range) {
1940 llvm::SmallString<64> TemplateMangling;
1941 llvm::raw_svector_ostream Stream(TemplateMangling);
1942 MicrosoftCXXNameMangler Extra(Context, Stream);
1943
1944 Stream << "?$";
1945 Extra.mangleSourceName("KindOf");
1946 Extra.mangleType(QualType(T, 0)
1947 .stripObjCKindOfType(getASTContext())
1948 ->castAs<ObjCObjectType>(),
1949 Quals, Range);
1950
1951 mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
1952 }
1953
mangleQualifiers(Qualifiers Quals,bool IsMember)1954 void MicrosoftCXXNameMangler::mangleQualifiers(Qualifiers Quals,
1955 bool IsMember) {
1956 // <cvr-qualifiers> ::= [E] [F] [I] <base-cvr-qualifiers>
1957 // 'E' means __ptr64 (32-bit only); 'F' means __unaligned (32/64-bit only);
1958 // 'I' means __restrict (32/64-bit).
1959 // Note that the MSVC __restrict keyword isn't the same as the C99 restrict
1960 // keyword!
1961 // <base-cvr-qualifiers> ::= A # near
1962 // ::= B # near const
1963 // ::= C # near volatile
1964 // ::= D # near const volatile
1965 // ::= E # far (16-bit)
1966 // ::= F # far const (16-bit)
1967 // ::= G # far volatile (16-bit)
1968 // ::= H # far const volatile (16-bit)
1969 // ::= I # huge (16-bit)
1970 // ::= J # huge const (16-bit)
1971 // ::= K # huge volatile (16-bit)
1972 // ::= L # huge const volatile (16-bit)
1973 // ::= M <basis> # based
1974 // ::= N <basis> # based const
1975 // ::= O <basis> # based volatile
1976 // ::= P <basis> # based const volatile
1977 // ::= Q # near member
1978 // ::= R # near const member
1979 // ::= S # near volatile member
1980 // ::= T # near const volatile member
1981 // ::= U # far member (16-bit)
1982 // ::= V # far const member (16-bit)
1983 // ::= W # far volatile member (16-bit)
1984 // ::= X # far const volatile member (16-bit)
1985 // ::= Y # huge member (16-bit)
1986 // ::= Z # huge const member (16-bit)
1987 // ::= 0 # huge volatile member (16-bit)
1988 // ::= 1 # huge const volatile member (16-bit)
1989 // ::= 2 <basis> # based member
1990 // ::= 3 <basis> # based const member
1991 // ::= 4 <basis> # based volatile member
1992 // ::= 5 <basis> # based const volatile member
1993 // ::= 6 # near function (pointers only)
1994 // ::= 7 # far function (pointers only)
1995 // ::= 8 # near method (pointers only)
1996 // ::= 9 # far method (pointers only)
1997 // ::= _A <basis> # based function (pointers only)
1998 // ::= _B <basis> # based function (far?) (pointers only)
1999 // ::= _C <basis> # based method (pointers only)
2000 // ::= _D <basis> # based method (far?) (pointers only)
2001 // ::= _E # block (Clang)
2002 // <basis> ::= 0 # __based(void)
2003 // ::= 1 # __based(segment)?
2004 // ::= 2 <name> # __based(name)
2005 // ::= 3 # ?
2006 // ::= 4 # ?
2007 // ::= 5 # not really based
2008 bool HasConst = Quals.hasConst(),
2009 HasVolatile = Quals.hasVolatile();
2010
2011 if (!IsMember) {
2012 if (HasConst && HasVolatile) {
2013 Out << 'D';
2014 } else if (HasVolatile) {
2015 Out << 'C';
2016 } else if (HasConst) {
2017 Out << 'B';
2018 } else {
2019 Out << 'A';
2020 }
2021 } else {
2022 if (HasConst && HasVolatile) {
2023 Out << 'T';
2024 } else if (HasVolatile) {
2025 Out << 'S';
2026 } else if (HasConst) {
2027 Out << 'R';
2028 } else {
2029 Out << 'Q';
2030 }
2031 }
2032
2033 // FIXME: For now, just drop all extension qualifiers on the floor.
2034 }
2035
2036 void
mangleRefQualifier(RefQualifierKind RefQualifier)2037 MicrosoftCXXNameMangler::mangleRefQualifier(RefQualifierKind RefQualifier) {
2038 // <ref-qualifier> ::= G # lvalue reference
2039 // ::= H # rvalue-reference
2040 switch (RefQualifier) {
2041 case RQ_None:
2042 break;
2043
2044 case RQ_LValue:
2045 Out << 'G';
2046 break;
2047
2048 case RQ_RValue:
2049 Out << 'H';
2050 break;
2051 }
2052 }
2053
manglePointerExtQualifiers(Qualifiers Quals,QualType PointeeType)2054 void MicrosoftCXXNameMangler::manglePointerExtQualifiers(Qualifiers Quals,
2055 QualType PointeeType) {
2056 // Check if this is a default 64-bit pointer or has __ptr64 qualifier.
2057 bool is64Bit = PointeeType.isNull() ? PointersAre64Bit :
2058 is64BitPointer(PointeeType.getQualifiers());
2059 if (is64Bit && (PointeeType.isNull() || !PointeeType->isFunctionType()))
2060 Out << 'E';
2061
2062 if (Quals.hasRestrict())
2063 Out << 'I';
2064
2065 if (Quals.hasUnaligned() ||
2066 (!PointeeType.isNull() && PointeeType.getLocalQualifiers().hasUnaligned()))
2067 Out << 'F';
2068 }
2069
manglePointerCVQualifiers(Qualifiers Quals)2070 void MicrosoftCXXNameMangler::manglePointerCVQualifiers(Qualifiers Quals) {
2071 // <pointer-cv-qualifiers> ::= P # no qualifiers
2072 // ::= Q # const
2073 // ::= R # volatile
2074 // ::= S # const volatile
2075 bool HasConst = Quals.hasConst(),
2076 HasVolatile = Quals.hasVolatile();
2077
2078 if (HasConst && HasVolatile) {
2079 Out << 'S';
2080 } else if (HasVolatile) {
2081 Out << 'R';
2082 } else if (HasConst) {
2083 Out << 'Q';
2084 } else {
2085 Out << 'P';
2086 }
2087 }
2088
mangleFunctionArgumentType(QualType T,SourceRange Range)2089 void MicrosoftCXXNameMangler::mangleFunctionArgumentType(QualType T,
2090 SourceRange Range) {
2091 // MSVC will backreference two canonically equivalent types that have slightly
2092 // different manglings when mangled alone.
2093
2094 // Decayed types do not match up with non-decayed versions of the same type.
2095 //
2096 // e.g.
2097 // void (*x)(void) will not form a backreference with void x(void)
2098 void *TypePtr;
2099 if (const auto *DT = T->getAs<DecayedType>()) {
2100 QualType OriginalType = DT->getOriginalType();
2101 // All decayed ArrayTypes should be treated identically; as-if they were
2102 // a decayed IncompleteArrayType.
2103 if (const auto *AT = getASTContext().getAsArrayType(OriginalType))
2104 OriginalType = getASTContext().getIncompleteArrayType(
2105 AT->getElementType(), AT->getSizeModifier(),
2106 AT->getIndexTypeCVRQualifiers());
2107
2108 TypePtr = OriginalType.getCanonicalType().getAsOpaquePtr();
2109 // If the original parameter was textually written as an array,
2110 // instead treat the decayed parameter like it's const.
2111 //
2112 // e.g.
2113 // int [] -> int * const
2114 if (OriginalType->isArrayType())
2115 T = T.withConst();
2116 } else {
2117 TypePtr = T.getCanonicalType().getAsOpaquePtr();
2118 }
2119
2120 ArgBackRefMap::iterator Found = FunArgBackReferences.find(TypePtr);
2121
2122 if (Found == FunArgBackReferences.end()) {
2123 size_t OutSizeBefore = Out.tell();
2124
2125 mangleType(T, Range, QMM_Drop);
2126
2127 // See if it's worth creating a back reference.
2128 // Only types longer than 1 character are considered
2129 // and only 10 back references slots are available:
2130 bool LongerThanOneChar = (Out.tell() - OutSizeBefore > 1);
2131 if (LongerThanOneChar && FunArgBackReferences.size() < 10) {
2132 size_t Size = FunArgBackReferences.size();
2133 FunArgBackReferences[TypePtr] = Size;
2134 }
2135 } else {
2136 Out << Found->second;
2137 }
2138 }
2139
manglePassObjectSizeArg(const PassObjectSizeAttr * POSA)2140 void MicrosoftCXXNameMangler::manglePassObjectSizeArg(
2141 const PassObjectSizeAttr *POSA) {
2142 int Type = POSA->getType();
2143 bool Dynamic = POSA->isDynamic();
2144
2145 auto Iter = PassObjectSizeArgs.insert({Type, Dynamic}).first;
2146 auto *TypePtr = (const void *)&*Iter;
2147 ArgBackRefMap::iterator Found = FunArgBackReferences.find(TypePtr);
2148
2149 if (Found == FunArgBackReferences.end()) {
2150 std::string Name =
2151 Dynamic ? "__pass_dynamic_object_size" : "__pass_object_size";
2152 mangleArtificialTagType(TTK_Enum, Name + llvm::utostr(Type), {"__clang"});
2153
2154 if (FunArgBackReferences.size() < 10) {
2155 size_t Size = FunArgBackReferences.size();
2156 FunArgBackReferences[TypePtr] = Size;
2157 }
2158 } else {
2159 Out << Found->second;
2160 }
2161 }
2162
mangleAddressSpaceType(QualType T,Qualifiers Quals,SourceRange Range)2163 void MicrosoftCXXNameMangler::mangleAddressSpaceType(QualType T,
2164 Qualifiers Quals,
2165 SourceRange Range) {
2166 // Address space is mangled as an unqualified templated type in the __clang
2167 // namespace. The demangled version of this is:
2168 // In the case of a language specific address space:
2169 // __clang::struct _AS[language_addr_space]<Type>
2170 // where:
2171 // <language_addr_space> ::= <OpenCL-addrspace> | <CUDA-addrspace>
2172 // <OpenCL-addrspace> ::= "CL" [ "global" | "local" | "constant" |
2173 // "private"| "generic" | "device" | "host" ]
2174 // <CUDA-addrspace> ::= "CU" [ "device" | "constant" | "shared" ]
2175 // Note that the above were chosen to match the Itanium mangling for this.
2176 //
2177 // In the case of a non-language specific address space:
2178 // __clang::struct _AS<TargetAS, Type>
2179 assert(Quals.hasAddressSpace() && "Not valid without address space");
2180 llvm::SmallString<32> ASMangling;
2181 llvm::raw_svector_ostream Stream(ASMangling);
2182 MicrosoftCXXNameMangler Extra(Context, Stream);
2183 Stream << "?$";
2184
2185 LangAS AS = Quals.getAddressSpace();
2186 if (Context.getASTContext().addressSpaceMapManglingFor(AS)) {
2187 unsigned TargetAS = Context.getASTContext().getTargetAddressSpace(AS);
2188 Extra.mangleSourceName("_AS");
2189 Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(TargetAS));
2190 } else {
2191 switch (AS) {
2192 default:
2193 llvm_unreachable("Not a language specific address space");
2194 case LangAS::opencl_global:
2195 Extra.mangleSourceName("_ASCLglobal");
2196 break;
2197 case LangAS::opencl_global_device:
2198 Extra.mangleSourceName("_ASCLdevice");
2199 break;
2200 case LangAS::opencl_global_host:
2201 Extra.mangleSourceName("_ASCLhost");
2202 break;
2203 case LangAS::opencl_local:
2204 Extra.mangleSourceName("_ASCLlocal");
2205 break;
2206 case LangAS::opencl_constant:
2207 Extra.mangleSourceName("_ASCLconstant");
2208 break;
2209 case LangAS::opencl_private:
2210 Extra.mangleSourceName("_ASCLprivate");
2211 break;
2212 case LangAS::opencl_generic:
2213 Extra.mangleSourceName("_ASCLgeneric");
2214 break;
2215 case LangAS::cuda_device:
2216 Extra.mangleSourceName("_ASCUdevice");
2217 break;
2218 case LangAS::cuda_constant:
2219 Extra.mangleSourceName("_ASCUconstant");
2220 break;
2221 case LangAS::cuda_shared:
2222 Extra.mangleSourceName("_ASCUshared");
2223 break;
2224 case LangAS::ptr32_sptr:
2225 case LangAS::ptr32_uptr:
2226 case LangAS::ptr64:
2227 llvm_unreachable("don't mangle ptr address spaces with _AS");
2228 }
2229 }
2230
2231 Extra.mangleType(T, Range, QMM_Escape);
2232 mangleQualifiers(Qualifiers(), false);
2233 mangleArtificialTagType(TTK_Struct, ASMangling, {"__clang"});
2234 }
2235
mangleType(QualType T,SourceRange Range,QualifierMangleMode QMM)2236 void MicrosoftCXXNameMangler::mangleType(QualType T, SourceRange Range,
2237 QualifierMangleMode QMM) {
2238 // Don't use the canonical types. MSVC includes things like 'const' on
2239 // pointer arguments to function pointers that canonicalization strips away.
2240 T = T.getDesugaredType(getASTContext());
2241 Qualifiers Quals = T.getLocalQualifiers();
2242
2243 if (const ArrayType *AT = getASTContext().getAsArrayType(T)) {
2244 // If there were any Quals, getAsArrayType() pushed them onto the array
2245 // element type.
2246 if (QMM == QMM_Mangle)
2247 Out << 'A';
2248 else if (QMM == QMM_Escape || QMM == QMM_Result)
2249 Out << "$$B";
2250 mangleArrayType(AT);
2251 return;
2252 }
2253
2254 bool IsPointer = T->isAnyPointerType() || T->isMemberPointerType() ||
2255 T->isReferenceType() || T->isBlockPointerType();
2256
2257 switch (QMM) {
2258 case QMM_Drop:
2259 if (Quals.hasObjCLifetime())
2260 Quals = Quals.withoutObjCLifetime();
2261 break;
2262 case QMM_Mangle:
2263 if (const FunctionType *FT = dyn_cast<FunctionType>(T)) {
2264 Out << '6';
2265 mangleFunctionType(FT);
2266 return;
2267 }
2268 mangleQualifiers(Quals, false);
2269 break;
2270 case QMM_Escape:
2271 if (!IsPointer && Quals) {
2272 Out << "$$C";
2273 mangleQualifiers(Quals, false);
2274 }
2275 break;
2276 case QMM_Result:
2277 // Presence of __unaligned qualifier shouldn't affect mangling here.
2278 Quals.removeUnaligned();
2279 if (Quals.hasObjCLifetime())
2280 Quals = Quals.withoutObjCLifetime();
2281 if ((!IsPointer && Quals) || isa<TagType>(T) || isArtificialTagType(T)) {
2282 Out << '?';
2283 mangleQualifiers(Quals, false);
2284 }
2285 break;
2286 }
2287
2288 const Type *ty = T.getTypePtr();
2289
2290 switch (ty->getTypeClass()) {
2291 #define ABSTRACT_TYPE(CLASS, PARENT)
2292 #define NON_CANONICAL_TYPE(CLASS, PARENT) \
2293 case Type::CLASS: \
2294 llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \
2295 return;
2296 #define TYPE(CLASS, PARENT) \
2297 case Type::CLASS: \
2298 mangleType(cast<CLASS##Type>(ty), Quals, Range); \
2299 break;
2300 #include "clang/AST/TypeNodes.inc"
2301 #undef ABSTRACT_TYPE
2302 #undef NON_CANONICAL_TYPE
2303 #undef TYPE
2304 }
2305 }
2306
mangleType(const BuiltinType * T,Qualifiers,SourceRange Range)2307 void MicrosoftCXXNameMangler::mangleType(const BuiltinType *T, Qualifiers,
2308 SourceRange Range) {
2309 // <type> ::= <builtin-type>
2310 // <builtin-type> ::= X # void
2311 // ::= C # signed char
2312 // ::= D # char
2313 // ::= E # unsigned char
2314 // ::= F # short
2315 // ::= G # unsigned short (or wchar_t if it's not a builtin)
2316 // ::= H # int
2317 // ::= I # unsigned int
2318 // ::= J # long
2319 // ::= K # unsigned long
2320 // L # <none>
2321 // ::= M # float
2322 // ::= N # double
2323 // ::= O # long double (__float80 is mangled differently)
2324 // ::= _J # long long, __int64
2325 // ::= _K # unsigned long long, __int64
2326 // ::= _L # __int128
2327 // ::= _M # unsigned __int128
2328 // ::= _N # bool
2329 // _O # <array in parameter>
2330 // ::= _Q # char8_t
2331 // ::= _S # char16_t
2332 // ::= _T # __float80 (Intel)
2333 // ::= _U # char32_t
2334 // ::= _W # wchar_t
2335 // ::= _Z # __float80 (Digital Mars)
2336 switch (T->getKind()) {
2337 case BuiltinType::Void:
2338 Out << 'X';
2339 break;
2340 case BuiltinType::SChar:
2341 Out << 'C';
2342 break;
2343 case BuiltinType::Char_U:
2344 case BuiltinType::Char_S:
2345 Out << 'D';
2346 break;
2347 case BuiltinType::UChar:
2348 Out << 'E';
2349 break;
2350 case BuiltinType::Short:
2351 Out << 'F';
2352 break;
2353 case BuiltinType::UShort:
2354 Out << 'G';
2355 break;
2356 case BuiltinType::Int:
2357 Out << 'H';
2358 break;
2359 case BuiltinType::UInt:
2360 Out << 'I';
2361 break;
2362 case BuiltinType::Long:
2363 Out << 'J';
2364 break;
2365 case BuiltinType::ULong:
2366 Out << 'K';
2367 break;
2368 case BuiltinType::Float:
2369 Out << 'M';
2370 break;
2371 case BuiltinType::Double:
2372 Out << 'N';
2373 break;
2374 // TODO: Determine size and mangle accordingly
2375 case BuiltinType::LongDouble:
2376 Out << 'O';
2377 break;
2378 case BuiltinType::LongLong:
2379 Out << "_J";
2380 break;
2381 case BuiltinType::ULongLong:
2382 Out << "_K";
2383 break;
2384 case BuiltinType::Int128:
2385 Out << "_L";
2386 break;
2387 case BuiltinType::UInt128:
2388 Out << "_M";
2389 break;
2390 case BuiltinType::Bool:
2391 Out << "_N";
2392 break;
2393 case BuiltinType::Char8:
2394 Out << "_Q";
2395 break;
2396 case BuiltinType::Char16:
2397 Out << "_S";
2398 break;
2399 case BuiltinType::Char32:
2400 Out << "_U";
2401 break;
2402 case BuiltinType::WChar_S:
2403 case BuiltinType::WChar_U:
2404 Out << "_W";
2405 break;
2406
2407 #define BUILTIN_TYPE(Id, SingletonId)
2408 #define PLACEHOLDER_TYPE(Id, SingletonId) \
2409 case BuiltinType::Id:
2410 #include "clang/AST/BuiltinTypes.def"
2411 case BuiltinType::Dependent:
2412 llvm_unreachable("placeholder types shouldn't get to name mangling");
2413
2414 case BuiltinType::ObjCId:
2415 mangleArtificialTagType(TTK_Struct, "objc_object");
2416 break;
2417 case BuiltinType::ObjCClass:
2418 mangleArtificialTagType(TTK_Struct, "objc_class");
2419 break;
2420 case BuiltinType::ObjCSel:
2421 mangleArtificialTagType(TTK_Struct, "objc_selector");
2422 break;
2423
2424 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2425 case BuiltinType::Id: \
2426 Out << "PAUocl_" #ImgType "_" #Suffix "@@"; \
2427 break;
2428 #include "clang/Basic/OpenCLImageTypes.def"
2429 case BuiltinType::OCLSampler:
2430 Out << "PA";
2431 mangleArtificialTagType(TTK_Struct, "ocl_sampler");
2432 break;
2433 case BuiltinType::OCLEvent:
2434 Out << "PA";
2435 mangleArtificialTagType(TTK_Struct, "ocl_event");
2436 break;
2437 case BuiltinType::OCLClkEvent:
2438 Out << "PA";
2439 mangleArtificialTagType(TTK_Struct, "ocl_clkevent");
2440 break;
2441 case BuiltinType::OCLQueue:
2442 Out << "PA";
2443 mangleArtificialTagType(TTK_Struct, "ocl_queue");
2444 break;
2445 case BuiltinType::OCLReserveID:
2446 Out << "PA";
2447 mangleArtificialTagType(TTK_Struct, "ocl_reserveid");
2448 break;
2449 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2450 case BuiltinType::Id: \
2451 mangleArtificialTagType(TTK_Struct, "ocl_" #ExtType); \
2452 break;
2453 #include "clang/Basic/OpenCLExtensionTypes.def"
2454
2455 case BuiltinType::NullPtr:
2456 Out << "$$T";
2457 break;
2458
2459 case BuiltinType::Float16:
2460 mangleArtificialTagType(TTK_Struct, "_Float16", {"__clang"});
2461 break;
2462
2463 case BuiltinType::Half:
2464 if (!getASTContext().getLangOpts().HLSL)
2465 mangleArtificialTagType(TTK_Struct, "_Half", {"__clang"});
2466 else if (getASTContext().getLangOpts().NativeHalfType)
2467 Out << "$f16@";
2468 else
2469 Out << "$halff@";
2470 break;
2471
2472 #define SVE_TYPE(Name, Id, SingletonId) \
2473 case BuiltinType::Id:
2474 #include "clang/Basic/AArch64SVEACLETypes.def"
2475 #define PPC_VECTOR_TYPE(Name, Id, Size) \
2476 case BuiltinType::Id:
2477 #include "clang/Basic/PPCTypes.def"
2478 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2479 #include "clang/Basic/RISCVVTypes.def"
2480 case BuiltinType::ShortAccum:
2481 case BuiltinType::Accum:
2482 case BuiltinType::LongAccum:
2483 case BuiltinType::UShortAccum:
2484 case BuiltinType::UAccum:
2485 case BuiltinType::ULongAccum:
2486 case BuiltinType::ShortFract:
2487 case BuiltinType::Fract:
2488 case BuiltinType::LongFract:
2489 case BuiltinType::UShortFract:
2490 case BuiltinType::UFract:
2491 case BuiltinType::ULongFract:
2492 case BuiltinType::SatShortAccum:
2493 case BuiltinType::SatAccum:
2494 case BuiltinType::SatLongAccum:
2495 case BuiltinType::SatUShortAccum:
2496 case BuiltinType::SatUAccum:
2497 case BuiltinType::SatULongAccum:
2498 case BuiltinType::SatShortFract:
2499 case BuiltinType::SatFract:
2500 case BuiltinType::SatLongFract:
2501 case BuiltinType::SatUShortFract:
2502 case BuiltinType::SatUFract:
2503 case BuiltinType::SatULongFract:
2504 case BuiltinType::BFloat16:
2505 case BuiltinType::Ibm128:
2506 case BuiltinType::Float128: {
2507 DiagnosticsEngine &Diags = Context.getDiags();
2508 unsigned DiagID = Diags.getCustomDiagID(
2509 DiagnosticsEngine::Error, "cannot mangle this built-in %0 type yet");
2510 Diags.Report(Range.getBegin(), DiagID)
2511 << T->getName(Context.getASTContext().getPrintingPolicy()) << Range;
2512 break;
2513 }
2514 }
2515 }
2516
2517 // <type> ::= <function-type>
mangleType(const FunctionProtoType * T,Qualifiers,SourceRange)2518 void MicrosoftCXXNameMangler::mangleType(const FunctionProtoType *T, Qualifiers,
2519 SourceRange) {
2520 // Structors only appear in decls, so at this point we know it's not a
2521 // structor type.
2522 // FIXME: This may not be lambda-friendly.
2523 if (T->getMethodQuals() || T->getRefQualifier() != RQ_None) {
2524 Out << "$$A8@@";
2525 mangleFunctionType(T, /*D=*/nullptr, /*ForceThisQuals=*/true);
2526 } else {
2527 Out << "$$A6";
2528 mangleFunctionType(T);
2529 }
2530 }
mangleType(const FunctionNoProtoType * T,Qualifiers,SourceRange)2531 void MicrosoftCXXNameMangler::mangleType(const FunctionNoProtoType *T,
2532 Qualifiers, SourceRange) {
2533 Out << "$$A6";
2534 mangleFunctionType(T);
2535 }
2536
mangleFunctionType(const FunctionType * T,const FunctionDecl * D,bool ForceThisQuals,bool MangleExceptionSpec)2537 void MicrosoftCXXNameMangler::mangleFunctionType(const FunctionType *T,
2538 const FunctionDecl *D,
2539 bool ForceThisQuals,
2540 bool MangleExceptionSpec) {
2541 // <function-type> ::= <this-cvr-qualifiers> <calling-convention>
2542 // <return-type> <argument-list> <throw-spec>
2543 const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(T);
2544
2545 SourceRange Range;
2546 if (D) Range = D->getSourceRange();
2547
2548 bool IsInLambda = false;
2549 bool IsStructor = false, HasThisQuals = ForceThisQuals, IsCtorClosure = false;
2550 CallingConv CC = T->getCallConv();
2551 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(D)) {
2552 if (MD->getParent()->isLambda())
2553 IsInLambda = true;
2554 if (MD->isInstance())
2555 HasThisQuals = true;
2556 if (isa<CXXDestructorDecl>(MD)) {
2557 IsStructor = true;
2558 } else if (isa<CXXConstructorDecl>(MD)) {
2559 IsStructor = true;
2560 IsCtorClosure = (StructorType == Ctor_CopyingClosure ||
2561 StructorType == Ctor_DefaultClosure) &&
2562 isStructorDecl(MD);
2563 if (IsCtorClosure)
2564 CC = getASTContext().getDefaultCallingConvention(
2565 /*IsVariadic=*/false, /*IsCXXMethod=*/true);
2566 }
2567 }
2568
2569 // If this is a C++ instance method, mangle the CVR qualifiers for the
2570 // this pointer.
2571 if (HasThisQuals) {
2572 Qualifiers Quals = Proto->getMethodQuals();
2573 manglePointerExtQualifiers(Quals, /*PointeeType=*/QualType());
2574 mangleRefQualifier(Proto->getRefQualifier());
2575 mangleQualifiers(Quals, /*IsMember=*/false);
2576 }
2577
2578 mangleCallingConvention(CC);
2579
2580 // <return-type> ::= <type>
2581 // ::= @ # structors (they have no declared return type)
2582 if (IsStructor) {
2583 if (isa<CXXDestructorDecl>(D) && isStructorDecl(D)) {
2584 // The scalar deleting destructor takes an extra int argument which is not
2585 // reflected in the AST.
2586 if (StructorType == Dtor_Deleting) {
2587 Out << (PointersAre64Bit ? "PEAXI@Z" : "PAXI@Z");
2588 return;
2589 }
2590 // The vbase destructor returns void which is not reflected in the AST.
2591 if (StructorType == Dtor_Complete) {
2592 Out << "XXZ";
2593 return;
2594 }
2595 }
2596 if (IsCtorClosure) {
2597 // Default constructor closure and copy constructor closure both return
2598 // void.
2599 Out << 'X';
2600
2601 if (StructorType == Ctor_DefaultClosure) {
2602 // Default constructor closure always has no arguments.
2603 Out << 'X';
2604 } else if (StructorType == Ctor_CopyingClosure) {
2605 // Copy constructor closure always takes an unqualified reference.
2606 mangleFunctionArgumentType(getASTContext().getLValueReferenceType(
2607 Proto->getParamType(0)
2608 ->getAs<LValueReferenceType>()
2609 ->getPointeeType(),
2610 /*SpelledAsLValue=*/true),
2611 Range);
2612 Out << '@';
2613 } else {
2614 llvm_unreachable("unexpected constructor closure!");
2615 }
2616 Out << 'Z';
2617 return;
2618 }
2619 Out << '@';
2620 } else if (IsInLambda && D && isa<CXXConversionDecl>(D)) {
2621 // The only lambda conversion operators are to function pointers, which
2622 // can differ by their calling convention and are typically deduced. So
2623 // we make sure that this type gets mangled properly.
2624 mangleType(T->getReturnType(), Range, QMM_Result);
2625 } else {
2626 QualType ResultType = T->getReturnType();
2627 if (IsInLambda && isa<CXXConversionDecl>(D)) {
2628 // The only lambda conversion operators are to function pointers, which
2629 // can differ by their calling convention and are typically deduced. So
2630 // we make sure that this type gets mangled properly.
2631 mangleType(ResultType, Range, QMM_Result);
2632 } else if (const auto *AT = dyn_cast_or_null<AutoType>(
2633 ResultType->getContainedAutoType())) {
2634 Out << '?';
2635 mangleQualifiers(ResultType.getLocalQualifiers(), /*IsMember=*/false);
2636 Out << '?';
2637 assert(AT->getKeyword() != AutoTypeKeyword::GNUAutoType &&
2638 "shouldn't need to mangle __auto_type!");
2639 mangleSourceName(AT->isDecltypeAuto() ? "<decltype-auto>" : "<auto>");
2640 Out << '@';
2641 } else if (IsInLambda) {
2642 Out << '@';
2643 } else {
2644 if (ResultType->isVoidType())
2645 ResultType = ResultType.getUnqualifiedType();
2646 mangleType(ResultType, Range, QMM_Result);
2647 }
2648 }
2649
2650 // <argument-list> ::= X # void
2651 // ::= <type>+ @
2652 // ::= <type>* Z # varargs
2653 if (!Proto) {
2654 // Function types without prototypes can arise when mangling a function type
2655 // within an overloadable function in C. We mangle these as the absence of
2656 // any parameter types (not even an empty parameter list).
2657 Out << '@';
2658 } else if (Proto->getNumParams() == 0 && !Proto->isVariadic()) {
2659 Out << 'X';
2660 } else {
2661 // Happens for function pointer type arguments for example.
2662 for (unsigned I = 0, E = Proto->getNumParams(); I != E; ++I) {
2663 mangleFunctionArgumentType(Proto->getParamType(I), Range);
2664 // Mangle each pass_object_size parameter as if it's a parameter of enum
2665 // type passed directly after the parameter with the pass_object_size
2666 // attribute. The aforementioned enum's name is __pass_object_size, and we
2667 // pretend it resides in a top-level namespace called __clang.
2668 //
2669 // FIXME: Is there a defined extension notation for the MS ABI, or is it
2670 // necessary to just cross our fingers and hope this type+namespace
2671 // combination doesn't conflict with anything?
2672 if (D)
2673 if (const auto *P = D->getParamDecl(I)->getAttr<PassObjectSizeAttr>())
2674 manglePassObjectSizeArg(P);
2675 }
2676 // <builtin-type> ::= Z # ellipsis
2677 if (Proto->isVariadic())
2678 Out << 'Z';
2679 else
2680 Out << '@';
2681 }
2682
2683 if (MangleExceptionSpec && getASTContext().getLangOpts().CPlusPlus17 &&
2684 getASTContext().getLangOpts().isCompatibleWithMSVC(
2685 LangOptions::MSVC2017_5))
2686 mangleThrowSpecification(Proto);
2687 else
2688 Out << 'Z';
2689 }
2690
mangleFunctionClass(const FunctionDecl * FD)2691 void MicrosoftCXXNameMangler::mangleFunctionClass(const FunctionDecl *FD) {
2692 // <function-class> ::= <member-function> E? # E designates a 64-bit 'this'
2693 // # pointer. in 64-bit mode *all*
2694 // # 'this' pointers are 64-bit.
2695 // ::= <global-function>
2696 // <member-function> ::= A # private: near
2697 // ::= B # private: far
2698 // ::= C # private: static near
2699 // ::= D # private: static far
2700 // ::= E # private: virtual near
2701 // ::= F # private: virtual far
2702 // ::= I # protected: near
2703 // ::= J # protected: far
2704 // ::= K # protected: static near
2705 // ::= L # protected: static far
2706 // ::= M # protected: virtual near
2707 // ::= N # protected: virtual far
2708 // ::= Q # public: near
2709 // ::= R # public: far
2710 // ::= S # public: static near
2711 // ::= T # public: static far
2712 // ::= U # public: virtual near
2713 // ::= V # public: virtual far
2714 // <global-function> ::= Y # global near
2715 // ::= Z # global far
2716 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
2717 bool IsVirtual = MD->isVirtual();
2718 // When mangling vbase destructor variants, ignore whether or not the
2719 // underlying destructor was defined to be virtual.
2720 if (isa<CXXDestructorDecl>(MD) && isStructorDecl(MD) &&
2721 StructorType == Dtor_Complete) {
2722 IsVirtual = false;
2723 }
2724 switch (MD->getAccess()) {
2725 case AS_none:
2726 llvm_unreachable("Unsupported access specifier");
2727 case AS_private:
2728 if (MD->isStatic())
2729 Out << 'C';
2730 else if (IsVirtual)
2731 Out << 'E';
2732 else
2733 Out << 'A';
2734 break;
2735 case AS_protected:
2736 if (MD->isStatic())
2737 Out << 'K';
2738 else if (IsVirtual)
2739 Out << 'M';
2740 else
2741 Out << 'I';
2742 break;
2743 case AS_public:
2744 if (MD->isStatic())
2745 Out << 'S';
2746 else if (IsVirtual)
2747 Out << 'U';
2748 else
2749 Out << 'Q';
2750 }
2751 } else {
2752 Out << 'Y';
2753 }
2754 }
mangleCallingConvention(CallingConv CC)2755 void MicrosoftCXXNameMangler::mangleCallingConvention(CallingConv CC) {
2756 // <calling-convention> ::= A # __cdecl
2757 // ::= B # __export __cdecl
2758 // ::= C # __pascal
2759 // ::= D # __export __pascal
2760 // ::= E # __thiscall
2761 // ::= F # __export __thiscall
2762 // ::= G # __stdcall
2763 // ::= H # __export __stdcall
2764 // ::= I # __fastcall
2765 // ::= J # __export __fastcall
2766 // ::= Q # __vectorcall
2767 // ::= S # __attribute__((__swiftcall__)) // Clang-only
2768 // ::= T # __attribute__((__swiftasynccall__))
2769 // // Clang-only
2770 // ::= w # __regcall
2771 // The 'export' calling conventions are from a bygone era
2772 // (*cough*Win16*cough*) when functions were declared for export with
2773 // that keyword. (It didn't actually export them, it just made them so
2774 // that they could be in a DLL and somebody from another module could call
2775 // them.)
2776
2777 switch (CC) {
2778 default:
2779 llvm_unreachable("Unsupported CC for mangling");
2780 case CC_Win64:
2781 case CC_X86_64SysV:
2782 case CC_C: Out << 'A'; break;
2783 case CC_X86Pascal: Out << 'C'; break;
2784 case CC_X86ThisCall: Out << 'E'; break;
2785 case CC_X86StdCall: Out << 'G'; break;
2786 case CC_X86FastCall: Out << 'I'; break;
2787 case CC_X86VectorCall: Out << 'Q'; break;
2788 case CC_Swift: Out << 'S'; break;
2789 case CC_SwiftAsync: Out << 'W'; break;
2790 case CC_PreserveMost: Out << 'U'; break;
2791 case CC_X86RegCall: Out << 'w'; break;
2792 }
2793 }
mangleCallingConvention(const FunctionType * T)2794 void MicrosoftCXXNameMangler::mangleCallingConvention(const FunctionType *T) {
2795 mangleCallingConvention(T->getCallConv());
2796 }
2797
mangleThrowSpecification(const FunctionProtoType * FT)2798 void MicrosoftCXXNameMangler::mangleThrowSpecification(
2799 const FunctionProtoType *FT) {
2800 // <throw-spec> ::= Z # (default)
2801 // ::= _E # noexcept
2802 if (FT->canThrow())
2803 Out << 'Z';
2804 else
2805 Out << "_E";
2806 }
2807
mangleType(const UnresolvedUsingType * T,Qualifiers,SourceRange Range)2808 void MicrosoftCXXNameMangler::mangleType(const UnresolvedUsingType *T,
2809 Qualifiers, SourceRange Range) {
2810 // Probably should be mangled as a template instantiation; need to see what
2811 // VC does first.
2812 DiagnosticsEngine &Diags = Context.getDiags();
2813 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2814 "cannot mangle this unresolved dependent type yet");
2815 Diags.Report(Range.getBegin(), DiagID)
2816 << Range;
2817 }
2818
2819 // <type> ::= <union-type> | <struct-type> | <class-type> | <enum-type>
2820 // <union-type> ::= T <name>
2821 // <struct-type> ::= U <name>
2822 // <class-type> ::= V <name>
2823 // <enum-type> ::= W4 <name>
mangleTagTypeKind(TagTypeKind TTK)2824 void MicrosoftCXXNameMangler::mangleTagTypeKind(TagTypeKind TTK) {
2825 switch (TTK) {
2826 case TTK_Union:
2827 Out << 'T';
2828 break;
2829 case TTK_Struct:
2830 case TTK_Interface:
2831 Out << 'U';
2832 break;
2833 case TTK_Class:
2834 Out << 'V';
2835 break;
2836 case TTK_Enum:
2837 Out << "W4";
2838 break;
2839 }
2840 }
mangleType(const EnumType * T,Qualifiers,SourceRange)2841 void MicrosoftCXXNameMangler::mangleType(const EnumType *T, Qualifiers,
2842 SourceRange) {
2843 mangleType(cast<TagType>(T)->getDecl());
2844 }
mangleType(const RecordType * T,Qualifiers,SourceRange)2845 void MicrosoftCXXNameMangler::mangleType(const RecordType *T, Qualifiers,
2846 SourceRange) {
2847 mangleType(cast<TagType>(T)->getDecl());
2848 }
mangleType(const TagDecl * TD)2849 void MicrosoftCXXNameMangler::mangleType(const TagDecl *TD) {
2850 mangleTagTypeKind(TD->getTagKind());
2851 mangleName(TD);
2852 }
2853
2854 // If you add a call to this, consider updating isArtificialTagType() too.
mangleArtificialTagType(TagTypeKind TK,StringRef UnqualifiedName,ArrayRef<StringRef> NestedNames)2855 void MicrosoftCXXNameMangler::mangleArtificialTagType(
2856 TagTypeKind TK, StringRef UnqualifiedName,
2857 ArrayRef<StringRef> NestedNames) {
2858 // <name> ::= <unscoped-name> {[<named-scope>]+ | [<nested-name>]}? @
2859 mangleTagTypeKind(TK);
2860
2861 // Always start with the unqualified name.
2862 mangleSourceName(UnqualifiedName);
2863
2864 for (StringRef N : llvm::reverse(NestedNames))
2865 mangleSourceName(N);
2866
2867 // Terminate the whole name with an '@'.
2868 Out << '@';
2869 }
2870
2871 // <type> ::= <array-type>
2872 // <array-type> ::= <pointer-cvr-qualifiers> <cvr-qualifiers>
2873 // [Y <dimension-count> <dimension>+]
2874 // <element-type> # as global, E is never required
2875 // It's supposed to be the other way around, but for some strange reason, it
2876 // isn't. Today this behavior is retained for the sole purpose of backwards
2877 // compatibility.
mangleDecayedArrayType(const ArrayType * T)2878 void MicrosoftCXXNameMangler::mangleDecayedArrayType(const ArrayType *T) {
2879 // This isn't a recursive mangling, so now we have to do it all in this
2880 // one call.
2881 manglePointerCVQualifiers(T->getElementType().getQualifiers());
2882 mangleType(T->getElementType(), SourceRange());
2883 }
mangleType(const ConstantArrayType * T,Qualifiers,SourceRange)2884 void MicrosoftCXXNameMangler::mangleType(const ConstantArrayType *T, Qualifiers,
2885 SourceRange) {
2886 llvm_unreachable("Should have been special cased");
2887 }
mangleType(const VariableArrayType * T,Qualifiers,SourceRange)2888 void MicrosoftCXXNameMangler::mangleType(const VariableArrayType *T, Qualifiers,
2889 SourceRange) {
2890 llvm_unreachable("Should have been special cased");
2891 }
mangleType(const DependentSizedArrayType * T,Qualifiers,SourceRange)2892 void MicrosoftCXXNameMangler::mangleType(const DependentSizedArrayType *T,
2893 Qualifiers, SourceRange) {
2894 llvm_unreachable("Should have been special cased");
2895 }
mangleType(const IncompleteArrayType * T,Qualifiers,SourceRange)2896 void MicrosoftCXXNameMangler::mangleType(const IncompleteArrayType *T,
2897 Qualifiers, SourceRange) {
2898 llvm_unreachable("Should have been special cased");
2899 }
mangleArrayType(const ArrayType * T)2900 void MicrosoftCXXNameMangler::mangleArrayType(const ArrayType *T) {
2901 QualType ElementTy(T, 0);
2902 SmallVector<llvm::APInt, 3> Dimensions;
2903 for (;;) {
2904 if (ElementTy->isConstantArrayType()) {
2905 const ConstantArrayType *CAT =
2906 getASTContext().getAsConstantArrayType(ElementTy);
2907 Dimensions.push_back(CAT->getSize());
2908 ElementTy = CAT->getElementType();
2909 } else if (ElementTy->isIncompleteArrayType()) {
2910 const IncompleteArrayType *IAT =
2911 getASTContext().getAsIncompleteArrayType(ElementTy);
2912 Dimensions.push_back(llvm::APInt(32, 0));
2913 ElementTy = IAT->getElementType();
2914 } else if (ElementTy->isVariableArrayType()) {
2915 const VariableArrayType *VAT =
2916 getASTContext().getAsVariableArrayType(ElementTy);
2917 Dimensions.push_back(llvm::APInt(32, 0));
2918 ElementTy = VAT->getElementType();
2919 } else if (ElementTy->isDependentSizedArrayType()) {
2920 // The dependent expression has to be folded into a constant (TODO).
2921 const DependentSizedArrayType *DSAT =
2922 getASTContext().getAsDependentSizedArrayType(ElementTy);
2923 DiagnosticsEngine &Diags = Context.getDiags();
2924 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2925 "cannot mangle this dependent-length array yet");
2926 Diags.Report(DSAT->getSizeExpr()->getExprLoc(), DiagID)
2927 << DSAT->getBracketsRange();
2928 return;
2929 } else {
2930 break;
2931 }
2932 }
2933 Out << 'Y';
2934 // <dimension-count> ::= <number> # number of extra dimensions
2935 mangleNumber(Dimensions.size());
2936 for (const llvm::APInt &Dimension : Dimensions)
2937 mangleNumber(Dimension.getLimitedValue());
2938 mangleType(ElementTy, SourceRange(), QMM_Escape);
2939 }
2940
2941 // <type> ::= <pointer-to-member-type>
2942 // <pointer-to-member-type> ::= <pointer-cvr-qualifiers> <cvr-qualifiers>
2943 // <class name> <type>
mangleType(const MemberPointerType * T,Qualifiers Quals,SourceRange Range)2944 void MicrosoftCXXNameMangler::mangleType(const MemberPointerType *T,
2945 Qualifiers Quals, SourceRange Range) {
2946 QualType PointeeType = T->getPointeeType();
2947 manglePointerCVQualifiers(Quals);
2948 manglePointerExtQualifiers(Quals, PointeeType);
2949 if (const FunctionProtoType *FPT = PointeeType->getAs<FunctionProtoType>()) {
2950 Out << '8';
2951 mangleName(T->getClass()->castAs<RecordType>()->getDecl());
2952 mangleFunctionType(FPT, nullptr, true);
2953 } else {
2954 mangleQualifiers(PointeeType.getQualifiers(), true);
2955 mangleName(T->getClass()->castAs<RecordType>()->getDecl());
2956 mangleType(PointeeType, Range, QMM_Drop);
2957 }
2958 }
2959
mangleType(const TemplateTypeParmType * T,Qualifiers,SourceRange Range)2960 void MicrosoftCXXNameMangler::mangleType(const TemplateTypeParmType *T,
2961 Qualifiers, SourceRange Range) {
2962 DiagnosticsEngine &Diags = Context.getDiags();
2963 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2964 "cannot mangle this template type parameter type yet");
2965 Diags.Report(Range.getBegin(), DiagID)
2966 << Range;
2967 }
2968
mangleType(const SubstTemplateTypeParmPackType * T,Qualifiers,SourceRange Range)2969 void MicrosoftCXXNameMangler::mangleType(const SubstTemplateTypeParmPackType *T,
2970 Qualifiers, SourceRange Range) {
2971 DiagnosticsEngine &Diags = Context.getDiags();
2972 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2973 "cannot mangle this substituted parameter pack yet");
2974 Diags.Report(Range.getBegin(), DiagID)
2975 << Range;
2976 }
2977
2978 // <type> ::= <pointer-type>
2979 // <pointer-type> ::= E? <pointer-cvr-qualifiers> <cvr-qualifiers> <type>
2980 // # the E is required for 64-bit non-static pointers
mangleType(const PointerType * T,Qualifiers Quals,SourceRange Range)2981 void MicrosoftCXXNameMangler::mangleType(const PointerType *T, Qualifiers Quals,
2982 SourceRange Range) {
2983 QualType PointeeType = T->getPointeeType();
2984 manglePointerCVQualifiers(Quals);
2985 manglePointerExtQualifiers(Quals, PointeeType);
2986
2987 // For pointer size address spaces, go down the same type mangling path as
2988 // non address space types.
2989 LangAS AddrSpace = PointeeType.getQualifiers().getAddressSpace();
2990 if (isPtrSizeAddressSpace(AddrSpace) || AddrSpace == LangAS::Default)
2991 mangleType(PointeeType, Range);
2992 else
2993 mangleAddressSpaceType(PointeeType, PointeeType.getQualifiers(), Range);
2994 }
2995
mangleType(const ObjCObjectPointerType * T,Qualifiers Quals,SourceRange Range)2996 void MicrosoftCXXNameMangler::mangleType(const ObjCObjectPointerType *T,
2997 Qualifiers Quals, SourceRange Range) {
2998 QualType PointeeType = T->getPointeeType();
2999 switch (Quals.getObjCLifetime()) {
3000 case Qualifiers::OCL_None:
3001 case Qualifiers::OCL_ExplicitNone:
3002 break;
3003 case Qualifiers::OCL_Autoreleasing:
3004 case Qualifiers::OCL_Strong:
3005 case Qualifiers::OCL_Weak:
3006 return mangleObjCLifetime(PointeeType, Quals, Range);
3007 }
3008 manglePointerCVQualifiers(Quals);
3009 manglePointerExtQualifiers(Quals, PointeeType);
3010 mangleType(PointeeType, Range);
3011 }
3012
3013 // <type> ::= <reference-type>
3014 // <reference-type> ::= A E? <cvr-qualifiers> <type>
3015 // # the E is required for 64-bit non-static lvalue references
mangleType(const LValueReferenceType * T,Qualifiers Quals,SourceRange Range)3016 void MicrosoftCXXNameMangler::mangleType(const LValueReferenceType *T,
3017 Qualifiers Quals, SourceRange Range) {
3018 QualType PointeeType = T->getPointeeType();
3019 assert(!Quals.hasConst() && !Quals.hasVolatile() && "unexpected qualifier!");
3020 Out << 'A';
3021 manglePointerExtQualifiers(Quals, PointeeType);
3022 mangleType(PointeeType, Range);
3023 }
3024
3025 // <type> ::= <r-value-reference-type>
3026 // <r-value-reference-type> ::= $$Q E? <cvr-qualifiers> <type>
3027 // # the E is required for 64-bit non-static rvalue references
mangleType(const RValueReferenceType * T,Qualifiers Quals,SourceRange Range)3028 void MicrosoftCXXNameMangler::mangleType(const RValueReferenceType *T,
3029 Qualifiers Quals, SourceRange Range) {
3030 QualType PointeeType = T->getPointeeType();
3031 assert(!Quals.hasConst() && !Quals.hasVolatile() && "unexpected qualifier!");
3032 Out << "$$Q";
3033 manglePointerExtQualifiers(Quals, PointeeType);
3034 mangleType(PointeeType, Range);
3035 }
3036
mangleType(const ComplexType * T,Qualifiers,SourceRange Range)3037 void MicrosoftCXXNameMangler::mangleType(const ComplexType *T, Qualifiers,
3038 SourceRange Range) {
3039 QualType ElementType = T->getElementType();
3040
3041 llvm::SmallString<64> TemplateMangling;
3042 llvm::raw_svector_ostream Stream(TemplateMangling);
3043 MicrosoftCXXNameMangler Extra(Context, Stream);
3044 Stream << "?$";
3045 Extra.mangleSourceName("_Complex");
3046 Extra.mangleType(ElementType, Range, QMM_Escape);
3047
3048 mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
3049 }
3050
3051 // Returns true for types that mangleArtificialTagType() gets called for with
3052 // TTK_Union, TTK_Struct, TTK_Class and where compatibility with MSVC's
3053 // mangling matters.
3054 // (It doesn't matter for Objective-C types and the like that cl.exe doesn't
3055 // support.)
isArtificialTagType(QualType T) const3056 bool MicrosoftCXXNameMangler::isArtificialTagType(QualType T) const {
3057 const Type *ty = T.getTypePtr();
3058 switch (ty->getTypeClass()) {
3059 default:
3060 return false;
3061
3062 case Type::Vector: {
3063 // For ABI compatibility only __m64, __m128(id), and __m256(id) matter,
3064 // but since mangleType(VectorType*) always calls mangleArtificialTagType()
3065 // just always return true (the other vector types are clang-only).
3066 return true;
3067 }
3068 }
3069 }
3070
mangleType(const VectorType * T,Qualifiers Quals,SourceRange Range)3071 void MicrosoftCXXNameMangler::mangleType(const VectorType *T, Qualifiers Quals,
3072 SourceRange Range) {
3073 const BuiltinType *ET = T->getElementType()->getAs<BuiltinType>();
3074 assert(ET && "vectors with non-builtin elements are unsupported");
3075 uint64_t Width = getASTContext().getTypeSize(T);
3076 // Pattern match exactly the typedefs in our intrinsic headers. Anything that
3077 // doesn't match the Intel types uses a custom mangling below.
3078 size_t OutSizeBefore = Out.tell();
3079 if (!isa<ExtVectorType>(T)) {
3080 if (getASTContext().getTargetInfo().getTriple().isX86()) {
3081 if (Width == 64 && ET->getKind() == BuiltinType::LongLong) {
3082 mangleArtificialTagType(TTK_Union, "__m64");
3083 } else if (Width >= 128) {
3084 if (ET->getKind() == BuiltinType::Float)
3085 mangleArtificialTagType(TTK_Union, "__m" + llvm::utostr(Width));
3086 else if (ET->getKind() == BuiltinType::LongLong)
3087 mangleArtificialTagType(TTK_Union, "__m" + llvm::utostr(Width) + 'i');
3088 else if (ET->getKind() == BuiltinType::Double)
3089 mangleArtificialTagType(TTK_Struct, "__m" + llvm::utostr(Width) + 'd');
3090 }
3091 }
3092 }
3093
3094 bool IsBuiltin = Out.tell() != OutSizeBefore;
3095 if (!IsBuiltin) {
3096 // The MS ABI doesn't have a special mangling for vector types, so we define
3097 // our own mangling to handle uses of __vector_size__ on user-specified
3098 // types, and for extensions like __v4sf.
3099
3100 llvm::SmallString<64> TemplateMangling;
3101 llvm::raw_svector_ostream Stream(TemplateMangling);
3102 MicrosoftCXXNameMangler Extra(Context, Stream);
3103 Stream << "?$";
3104 Extra.mangleSourceName("__vector");
3105 Extra.mangleType(QualType(ET, 0), Range, QMM_Escape);
3106 Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(T->getNumElements()));
3107
3108 mangleArtificialTagType(TTK_Union, TemplateMangling, {"__clang"});
3109 }
3110 }
3111
mangleType(const ExtVectorType * T,Qualifiers Quals,SourceRange Range)3112 void MicrosoftCXXNameMangler::mangleType(const ExtVectorType *T,
3113 Qualifiers Quals, SourceRange Range) {
3114 mangleType(static_cast<const VectorType *>(T), Quals, Range);
3115 }
3116
mangleType(const DependentVectorType * T,Qualifiers,SourceRange Range)3117 void MicrosoftCXXNameMangler::mangleType(const DependentVectorType *T,
3118 Qualifiers, SourceRange Range) {
3119 DiagnosticsEngine &Diags = Context.getDiags();
3120 unsigned DiagID = Diags.getCustomDiagID(
3121 DiagnosticsEngine::Error,
3122 "cannot mangle this dependent-sized vector type yet");
3123 Diags.Report(Range.getBegin(), DiagID) << Range;
3124 }
3125
mangleType(const DependentSizedExtVectorType * T,Qualifiers,SourceRange Range)3126 void MicrosoftCXXNameMangler::mangleType(const DependentSizedExtVectorType *T,
3127 Qualifiers, SourceRange Range) {
3128 DiagnosticsEngine &Diags = Context.getDiags();
3129 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3130 "cannot mangle this dependent-sized extended vector type yet");
3131 Diags.Report(Range.getBegin(), DiagID)
3132 << Range;
3133 }
3134
mangleType(const ConstantMatrixType * T,Qualifiers quals,SourceRange Range)3135 void MicrosoftCXXNameMangler::mangleType(const ConstantMatrixType *T,
3136 Qualifiers quals, SourceRange Range) {
3137 DiagnosticsEngine &Diags = Context.getDiags();
3138 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3139 "Cannot mangle this matrix type yet");
3140 Diags.Report(Range.getBegin(), DiagID) << Range;
3141 }
3142
mangleType(const DependentSizedMatrixType * T,Qualifiers quals,SourceRange Range)3143 void MicrosoftCXXNameMangler::mangleType(const DependentSizedMatrixType *T,
3144 Qualifiers quals, SourceRange Range) {
3145 DiagnosticsEngine &Diags = Context.getDiags();
3146 unsigned DiagID = Diags.getCustomDiagID(
3147 DiagnosticsEngine::Error,
3148 "Cannot mangle this dependent-sized matrix type yet");
3149 Diags.Report(Range.getBegin(), DiagID) << Range;
3150 }
3151
mangleType(const DependentAddressSpaceType * T,Qualifiers,SourceRange Range)3152 void MicrosoftCXXNameMangler::mangleType(const DependentAddressSpaceType *T,
3153 Qualifiers, SourceRange Range) {
3154 DiagnosticsEngine &Diags = Context.getDiags();
3155 unsigned DiagID = Diags.getCustomDiagID(
3156 DiagnosticsEngine::Error,
3157 "cannot mangle this dependent address space type yet");
3158 Diags.Report(Range.getBegin(), DiagID) << Range;
3159 }
3160
mangleType(const ObjCInterfaceType * T,Qualifiers,SourceRange)3161 void MicrosoftCXXNameMangler::mangleType(const ObjCInterfaceType *T, Qualifiers,
3162 SourceRange) {
3163 // ObjC interfaces have structs underlying them.
3164 mangleTagTypeKind(TTK_Struct);
3165 mangleName(T->getDecl());
3166 }
3167
mangleType(const ObjCObjectType * T,Qualifiers Quals,SourceRange Range)3168 void MicrosoftCXXNameMangler::mangleType(const ObjCObjectType *T,
3169 Qualifiers Quals, SourceRange Range) {
3170 if (T->isKindOfType())
3171 return mangleObjCKindOfType(T, Quals, Range);
3172
3173 if (T->qual_empty() && !T->isSpecialized())
3174 return mangleType(T->getBaseType(), Range, QMM_Drop);
3175
3176 ArgBackRefMap OuterFunArgsContext;
3177 ArgBackRefMap OuterTemplateArgsContext;
3178 BackRefVec OuterTemplateContext;
3179
3180 FunArgBackReferences.swap(OuterFunArgsContext);
3181 TemplateArgBackReferences.swap(OuterTemplateArgsContext);
3182 NameBackReferences.swap(OuterTemplateContext);
3183
3184 mangleTagTypeKind(TTK_Struct);
3185
3186 Out << "?$";
3187 if (T->isObjCId())
3188 mangleSourceName("objc_object");
3189 else if (T->isObjCClass())
3190 mangleSourceName("objc_class");
3191 else
3192 mangleSourceName(T->getInterface()->getName());
3193
3194 for (const auto &Q : T->quals())
3195 mangleObjCProtocol(Q);
3196
3197 if (T->isSpecialized())
3198 for (const auto &TA : T->getTypeArgs())
3199 mangleType(TA, Range, QMM_Drop);
3200
3201 Out << '@';
3202
3203 Out << '@';
3204
3205 FunArgBackReferences.swap(OuterFunArgsContext);
3206 TemplateArgBackReferences.swap(OuterTemplateArgsContext);
3207 NameBackReferences.swap(OuterTemplateContext);
3208 }
3209
mangleType(const BlockPointerType * T,Qualifiers Quals,SourceRange Range)3210 void MicrosoftCXXNameMangler::mangleType(const BlockPointerType *T,
3211 Qualifiers Quals, SourceRange Range) {
3212 QualType PointeeType = T->getPointeeType();
3213 manglePointerCVQualifiers(Quals);
3214 manglePointerExtQualifiers(Quals, PointeeType);
3215
3216 Out << "_E";
3217
3218 mangleFunctionType(PointeeType->castAs<FunctionProtoType>());
3219 }
3220
mangleType(const InjectedClassNameType *,Qualifiers,SourceRange)3221 void MicrosoftCXXNameMangler::mangleType(const InjectedClassNameType *,
3222 Qualifiers, SourceRange) {
3223 llvm_unreachable("Cannot mangle injected class name type.");
3224 }
3225
mangleType(const TemplateSpecializationType * T,Qualifiers,SourceRange Range)3226 void MicrosoftCXXNameMangler::mangleType(const TemplateSpecializationType *T,
3227 Qualifiers, SourceRange Range) {
3228 DiagnosticsEngine &Diags = Context.getDiags();
3229 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3230 "cannot mangle this template specialization type yet");
3231 Diags.Report(Range.getBegin(), DiagID)
3232 << Range;
3233 }
3234
mangleType(const DependentNameType * T,Qualifiers,SourceRange Range)3235 void MicrosoftCXXNameMangler::mangleType(const DependentNameType *T, Qualifiers,
3236 SourceRange Range) {
3237 DiagnosticsEngine &Diags = Context.getDiags();
3238 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3239 "cannot mangle this dependent name type yet");
3240 Diags.Report(Range.getBegin(), DiagID)
3241 << Range;
3242 }
3243
mangleType(const DependentTemplateSpecializationType * T,Qualifiers,SourceRange Range)3244 void MicrosoftCXXNameMangler::mangleType(
3245 const DependentTemplateSpecializationType *T, Qualifiers,
3246 SourceRange Range) {
3247 DiagnosticsEngine &Diags = Context.getDiags();
3248 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3249 "cannot mangle this dependent template specialization type yet");
3250 Diags.Report(Range.getBegin(), DiagID)
3251 << Range;
3252 }
3253
mangleType(const PackExpansionType * T,Qualifiers,SourceRange Range)3254 void MicrosoftCXXNameMangler::mangleType(const PackExpansionType *T, Qualifiers,
3255 SourceRange Range) {
3256 DiagnosticsEngine &Diags = Context.getDiags();
3257 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3258 "cannot mangle this pack expansion yet");
3259 Diags.Report(Range.getBegin(), DiagID)
3260 << Range;
3261 }
3262
mangleType(const TypeOfType * T,Qualifiers,SourceRange Range)3263 void MicrosoftCXXNameMangler::mangleType(const TypeOfType *T, Qualifiers,
3264 SourceRange Range) {
3265 DiagnosticsEngine &Diags = Context.getDiags();
3266 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3267 "cannot mangle this typeof(type) yet");
3268 Diags.Report(Range.getBegin(), DiagID)
3269 << Range;
3270 }
3271
mangleType(const TypeOfExprType * T,Qualifiers,SourceRange Range)3272 void MicrosoftCXXNameMangler::mangleType(const TypeOfExprType *T, Qualifiers,
3273 SourceRange Range) {
3274 DiagnosticsEngine &Diags = Context.getDiags();
3275 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3276 "cannot mangle this typeof(expression) yet");
3277 Diags.Report(Range.getBegin(), DiagID)
3278 << Range;
3279 }
3280
mangleType(const DecltypeType * T,Qualifiers,SourceRange Range)3281 void MicrosoftCXXNameMangler::mangleType(const DecltypeType *T, Qualifiers,
3282 SourceRange Range) {
3283 DiagnosticsEngine &Diags = Context.getDiags();
3284 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3285 "cannot mangle this decltype() yet");
3286 Diags.Report(Range.getBegin(), DiagID)
3287 << Range;
3288 }
3289
mangleType(const UnaryTransformType * T,Qualifiers,SourceRange Range)3290 void MicrosoftCXXNameMangler::mangleType(const UnaryTransformType *T,
3291 Qualifiers, SourceRange Range) {
3292 DiagnosticsEngine &Diags = Context.getDiags();
3293 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3294 "cannot mangle this unary transform type yet");
3295 Diags.Report(Range.getBegin(), DiagID)
3296 << Range;
3297 }
3298
mangleType(const AutoType * T,Qualifiers,SourceRange Range)3299 void MicrosoftCXXNameMangler::mangleType(const AutoType *T, Qualifiers,
3300 SourceRange Range) {
3301 assert(T->getDeducedType().isNull() && "expecting a dependent type!");
3302
3303 DiagnosticsEngine &Diags = Context.getDiags();
3304 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3305 "cannot mangle this 'auto' type yet");
3306 Diags.Report(Range.getBegin(), DiagID)
3307 << Range;
3308 }
3309
mangleType(const DeducedTemplateSpecializationType * T,Qualifiers,SourceRange Range)3310 void MicrosoftCXXNameMangler::mangleType(
3311 const DeducedTemplateSpecializationType *T, Qualifiers, SourceRange Range) {
3312 assert(T->getDeducedType().isNull() && "expecting a dependent type!");
3313
3314 DiagnosticsEngine &Diags = Context.getDiags();
3315 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
3316 "cannot mangle this deduced class template specialization type yet");
3317 Diags.Report(Range.getBegin(), DiagID)
3318 << Range;
3319 }
3320
mangleType(const AtomicType * T,Qualifiers,SourceRange Range)3321 void MicrosoftCXXNameMangler::mangleType(const AtomicType *T, Qualifiers,
3322 SourceRange Range) {
3323 QualType ValueType = T->getValueType();
3324
3325 llvm::SmallString<64> TemplateMangling;
3326 llvm::raw_svector_ostream Stream(TemplateMangling);
3327 MicrosoftCXXNameMangler Extra(Context, Stream);
3328 Stream << "?$";
3329 Extra.mangleSourceName("_Atomic");
3330 Extra.mangleType(ValueType, Range, QMM_Escape);
3331
3332 mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
3333 }
3334
mangleType(const PipeType * T,Qualifiers,SourceRange Range)3335 void MicrosoftCXXNameMangler::mangleType(const PipeType *T, Qualifiers,
3336 SourceRange Range) {
3337 QualType ElementType = T->getElementType();
3338
3339 llvm::SmallString<64> TemplateMangling;
3340 llvm::raw_svector_ostream Stream(TemplateMangling);
3341 MicrosoftCXXNameMangler Extra(Context, Stream);
3342 Stream << "?$";
3343 Extra.mangleSourceName("ocl_pipe");
3344 Extra.mangleType(ElementType, Range, QMM_Escape);
3345 Extra.mangleIntegerLiteral(llvm::APSInt::get(T->isReadOnly()));
3346
3347 mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
3348 }
3349
mangleCXXName(GlobalDecl GD,raw_ostream & Out)3350 void MicrosoftMangleContextImpl::mangleCXXName(GlobalDecl GD,
3351 raw_ostream &Out) {
3352 const NamedDecl *D = cast<NamedDecl>(GD.getDecl());
3353 PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
3354 getASTContext().getSourceManager(),
3355 "Mangling declaration");
3356
3357 msvc_hashing_ostream MHO(Out);
3358
3359 if (auto *CD = dyn_cast<CXXConstructorDecl>(D)) {
3360 auto Type = GD.getCtorType();
3361 MicrosoftCXXNameMangler mangler(*this, MHO, CD, Type);
3362 return mangler.mangle(GD);
3363 }
3364
3365 if (auto *DD = dyn_cast<CXXDestructorDecl>(D)) {
3366 auto Type = GD.getDtorType();
3367 MicrosoftCXXNameMangler mangler(*this, MHO, DD, Type);
3368 return mangler.mangle(GD);
3369 }
3370
3371 MicrosoftCXXNameMangler Mangler(*this, MHO);
3372 return Mangler.mangle(GD);
3373 }
3374
mangleType(const BitIntType * T,Qualifiers,SourceRange Range)3375 void MicrosoftCXXNameMangler::mangleType(const BitIntType *T, Qualifiers,
3376 SourceRange Range) {
3377 llvm::SmallString<64> TemplateMangling;
3378 llvm::raw_svector_ostream Stream(TemplateMangling);
3379 MicrosoftCXXNameMangler Extra(Context, Stream);
3380 Stream << "?$";
3381 if (T->isUnsigned())
3382 Extra.mangleSourceName("_UBitInt");
3383 else
3384 Extra.mangleSourceName("_BitInt");
3385 Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(T->getNumBits()));
3386
3387 mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
3388 }
3389
mangleType(const DependentBitIntType * T,Qualifiers,SourceRange Range)3390 void MicrosoftCXXNameMangler::mangleType(const DependentBitIntType *T,
3391 Qualifiers, SourceRange Range) {
3392 DiagnosticsEngine &Diags = Context.getDiags();
3393 unsigned DiagID = Diags.getCustomDiagID(
3394 DiagnosticsEngine::Error, "cannot mangle this DependentBitInt type yet");
3395 Diags.Report(Range.getBegin(), DiagID) << Range;
3396 }
3397
3398 // <this-adjustment> ::= <no-adjustment> | <static-adjustment> |
3399 // <virtual-adjustment>
3400 // <no-adjustment> ::= A # private near
3401 // ::= B # private far
3402 // ::= I # protected near
3403 // ::= J # protected far
3404 // ::= Q # public near
3405 // ::= R # public far
3406 // <static-adjustment> ::= G <static-offset> # private near
3407 // ::= H <static-offset> # private far
3408 // ::= O <static-offset> # protected near
3409 // ::= P <static-offset> # protected far
3410 // ::= W <static-offset> # public near
3411 // ::= X <static-offset> # public far
3412 // <virtual-adjustment> ::= $0 <virtual-shift> <static-offset> # private near
3413 // ::= $1 <virtual-shift> <static-offset> # private far
3414 // ::= $2 <virtual-shift> <static-offset> # protected near
3415 // ::= $3 <virtual-shift> <static-offset> # protected far
3416 // ::= $4 <virtual-shift> <static-offset> # public near
3417 // ::= $5 <virtual-shift> <static-offset> # public far
3418 // <virtual-shift> ::= <vtordisp-shift> | <vtordispex-shift>
3419 // <vtordisp-shift> ::= <offset-to-vtordisp>
3420 // <vtordispex-shift> ::= <offset-to-vbptr> <vbase-offset-offset>
3421 // <offset-to-vtordisp>
mangleThunkThisAdjustment(AccessSpecifier AS,const ThisAdjustment & Adjustment,MicrosoftCXXNameMangler & Mangler,raw_ostream & Out)3422 static void mangleThunkThisAdjustment(AccessSpecifier AS,
3423 const ThisAdjustment &Adjustment,
3424 MicrosoftCXXNameMangler &Mangler,
3425 raw_ostream &Out) {
3426 if (!Adjustment.Virtual.isEmpty()) {
3427 Out << '$';
3428 char AccessSpec;
3429 switch (AS) {
3430 case AS_none:
3431 llvm_unreachable("Unsupported access specifier");
3432 case AS_private:
3433 AccessSpec = '0';
3434 break;
3435 case AS_protected:
3436 AccessSpec = '2';
3437 break;
3438 case AS_public:
3439 AccessSpec = '4';
3440 }
3441 if (Adjustment.Virtual.Microsoft.VBPtrOffset) {
3442 Out << 'R' << AccessSpec;
3443 Mangler.mangleNumber(
3444 static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VBPtrOffset));
3445 Mangler.mangleNumber(
3446 static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VBOffsetOffset));
3447 Mangler.mangleNumber(
3448 static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VtordispOffset));
3449 Mangler.mangleNumber(static_cast<uint32_t>(Adjustment.NonVirtual));
3450 } else {
3451 Out << AccessSpec;
3452 Mangler.mangleNumber(
3453 static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VtordispOffset));
3454 Mangler.mangleNumber(-static_cast<uint32_t>(Adjustment.NonVirtual));
3455 }
3456 } else if (Adjustment.NonVirtual != 0) {
3457 switch (AS) {
3458 case AS_none:
3459 llvm_unreachable("Unsupported access specifier");
3460 case AS_private:
3461 Out << 'G';
3462 break;
3463 case AS_protected:
3464 Out << 'O';
3465 break;
3466 case AS_public:
3467 Out << 'W';
3468 }
3469 Mangler.mangleNumber(-static_cast<uint32_t>(Adjustment.NonVirtual));
3470 } else {
3471 switch (AS) {
3472 case AS_none:
3473 llvm_unreachable("Unsupported access specifier");
3474 case AS_private:
3475 Out << 'A';
3476 break;
3477 case AS_protected:
3478 Out << 'I';
3479 break;
3480 case AS_public:
3481 Out << 'Q';
3482 }
3483 }
3484 }
3485
mangleVirtualMemPtrThunk(const CXXMethodDecl * MD,const MethodVFTableLocation & ML,raw_ostream & Out)3486 void MicrosoftMangleContextImpl::mangleVirtualMemPtrThunk(
3487 const CXXMethodDecl *MD, const MethodVFTableLocation &ML,
3488 raw_ostream &Out) {
3489 msvc_hashing_ostream MHO(Out);
3490 MicrosoftCXXNameMangler Mangler(*this, MHO);
3491 Mangler.getStream() << '?';
3492 Mangler.mangleVirtualMemPtrThunk(MD, ML);
3493 }
3494
mangleThunk(const CXXMethodDecl * MD,const ThunkInfo & Thunk,raw_ostream & Out)3495 void MicrosoftMangleContextImpl::mangleThunk(const CXXMethodDecl *MD,
3496 const ThunkInfo &Thunk,
3497 raw_ostream &Out) {
3498 msvc_hashing_ostream MHO(Out);
3499 MicrosoftCXXNameMangler Mangler(*this, MHO);
3500 Mangler.getStream() << '?';
3501 Mangler.mangleName(MD);
3502
3503 // Usually the thunk uses the access specifier of the new method, but if this
3504 // is a covariant return thunk, then MSVC always uses the public access
3505 // specifier, and we do the same.
3506 AccessSpecifier AS = Thunk.Return.isEmpty() ? MD->getAccess() : AS_public;
3507 mangleThunkThisAdjustment(AS, Thunk.This, Mangler, MHO);
3508
3509 if (!Thunk.Return.isEmpty())
3510 assert(Thunk.Method != nullptr &&
3511 "Thunk info should hold the overridee decl");
3512
3513 const CXXMethodDecl *DeclForFPT = Thunk.Method ? Thunk.Method : MD;
3514 Mangler.mangleFunctionType(
3515 DeclForFPT->getType()->castAs<FunctionProtoType>(), MD);
3516 }
3517
mangleCXXDtorThunk(const CXXDestructorDecl * DD,CXXDtorType Type,const ThisAdjustment & Adjustment,raw_ostream & Out)3518 void MicrosoftMangleContextImpl::mangleCXXDtorThunk(
3519 const CXXDestructorDecl *DD, CXXDtorType Type,
3520 const ThisAdjustment &Adjustment, raw_ostream &Out) {
3521 // FIXME: Actually, the dtor thunk should be emitted for vector deleting
3522 // dtors rather than scalar deleting dtors. Just use the vector deleting dtor
3523 // mangling manually until we support both deleting dtor types.
3524 assert(Type == Dtor_Deleting);
3525 msvc_hashing_ostream MHO(Out);
3526 MicrosoftCXXNameMangler Mangler(*this, MHO, DD, Type);
3527 Mangler.getStream() << "??_E";
3528 Mangler.mangleName(DD->getParent());
3529 mangleThunkThisAdjustment(DD->getAccess(), Adjustment, Mangler, MHO);
3530 Mangler.mangleFunctionType(DD->getType()->castAs<FunctionProtoType>(), DD);
3531 }
3532
mangleCXXVFTable(const CXXRecordDecl * Derived,ArrayRef<const CXXRecordDecl * > BasePath,raw_ostream & Out)3533 void MicrosoftMangleContextImpl::mangleCXXVFTable(
3534 const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
3535 raw_ostream &Out) {
3536 // <mangled-name> ::= ?_7 <class-name> <storage-class>
3537 // <cvr-qualifiers> [<name>] @
3538 // NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class>
3539 // is always '6' for vftables.
3540 msvc_hashing_ostream MHO(Out);
3541 MicrosoftCXXNameMangler Mangler(*this, MHO);
3542 if (Derived->hasAttr<DLLImportAttr>())
3543 Mangler.getStream() << "??_S";
3544 else
3545 Mangler.getStream() << "??_7";
3546 Mangler.mangleName(Derived);
3547 Mangler.getStream() << "6B"; // '6' for vftable, 'B' for const.
3548 for (const CXXRecordDecl *RD : BasePath)
3549 Mangler.mangleName(RD);
3550 Mangler.getStream() << '@';
3551 }
3552
mangleCXXVBTable(const CXXRecordDecl * Derived,ArrayRef<const CXXRecordDecl * > BasePath,raw_ostream & Out)3553 void MicrosoftMangleContextImpl::mangleCXXVBTable(
3554 const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
3555 raw_ostream &Out) {
3556 // <mangled-name> ::= ?_8 <class-name> <storage-class>
3557 // <cvr-qualifiers> [<name>] @
3558 // NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class>
3559 // is always '7' for vbtables.
3560 msvc_hashing_ostream MHO(Out);
3561 MicrosoftCXXNameMangler Mangler(*this, MHO);
3562 Mangler.getStream() << "??_8";
3563 Mangler.mangleName(Derived);
3564 Mangler.getStream() << "7B"; // '7' for vbtable, 'B' for const.
3565 for (const CXXRecordDecl *RD : BasePath)
3566 Mangler.mangleName(RD);
3567 Mangler.getStream() << '@';
3568 }
3569
mangleCXXRTTI(QualType T,raw_ostream & Out)3570 void MicrosoftMangleContextImpl::mangleCXXRTTI(QualType T, raw_ostream &Out) {
3571 msvc_hashing_ostream MHO(Out);
3572 MicrosoftCXXNameMangler Mangler(*this, MHO);
3573 Mangler.getStream() << "??_R0";
3574 Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
3575 Mangler.getStream() << "@8";
3576 }
3577
mangleCXXRTTIName(QualType T,raw_ostream & Out)3578 void MicrosoftMangleContextImpl::mangleCXXRTTIName(QualType T,
3579 raw_ostream &Out) {
3580 MicrosoftCXXNameMangler Mangler(*this, Out);
3581 Mangler.getStream() << '.';
3582 Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
3583 }
3584
mangleCXXVirtualDisplacementMap(const CXXRecordDecl * SrcRD,const CXXRecordDecl * DstRD,raw_ostream & Out)3585 void MicrosoftMangleContextImpl::mangleCXXVirtualDisplacementMap(
3586 const CXXRecordDecl *SrcRD, const CXXRecordDecl *DstRD, raw_ostream &Out) {
3587 msvc_hashing_ostream MHO(Out);
3588 MicrosoftCXXNameMangler Mangler(*this, MHO);
3589 Mangler.getStream() << "??_K";
3590 Mangler.mangleName(SrcRD);
3591 Mangler.getStream() << "$C";
3592 Mangler.mangleName(DstRD);
3593 }
3594
mangleCXXThrowInfo(QualType T,bool IsConst,bool IsVolatile,bool IsUnaligned,uint32_t NumEntries,raw_ostream & Out)3595 void MicrosoftMangleContextImpl::mangleCXXThrowInfo(QualType T, bool IsConst,
3596 bool IsVolatile,
3597 bool IsUnaligned,
3598 uint32_t NumEntries,
3599 raw_ostream &Out) {
3600 msvc_hashing_ostream MHO(Out);
3601 MicrosoftCXXNameMangler Mangler(*this, MHO);
3602 Mangler.getStream() << "_TI";
3603 if (IsConst)
3604 Mangler.getStream() << 'C';
3605 if (IsVolatile)
3606 Mangler.getStream() << 'V';
3607 if (IsUnaligned)
3608 Mangler.getStream() << 'U';
3609 Mangler.getStream() << NumEntries;
3610 Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
3611 }
3612
mangleCXXCatchableTypeArray(QualType T,uint32_t NumEntries,raw_ostream & Out)3613 void MicrosoftMangleContextImpl::mangleCXXCatchableTypeArray(
3614 QualType T, uint32_t NumEntries, raw_ostream &Out) {
3615 msvc_hashing_ostream MHO(Out);
3616 MicrosoftCXXNameMangler Mangler(*this, MHO);
3617 Mangler.getStream() << "_CTA";
3618 Mangler.getStream() << NumEntries;
3619 Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
3620 }
3621
mangleCXXCatchableType(QualType T,const CXXConstructorDecl * CD,CXXCtorType CT,uint32_t Size,uint32_t NVOffset,int32_t VBPtrOffset,uint32_t VBIndex,raw_ostream & Out)3622 void MicrosoftMangleContextImpl::mangleCXXCatchableType(
3623 QualType T, const CXXConstructorDecl *CD, CXXCtorType CT, uint32_t Size,
3624 uint32_t NVOffset, int32_t VBPtrOffset, uint32_t VBIndex,
3625 raw_ostream &Out) {
3626 MicrosoftCXXNameMangler Mangler(*this, Out);
3627 Mangler.getStream() << "_CT";
3628
3629 llvm::SmallString<64> RTTIMangling;
3630 {
3631 llvm::raw_svector_ostream Stream(RTTIMangling);
3632 msvc_hashing_ostream MHO(Stream);
3633 mangleCXXRTTI(T, MHO);
3634 }
3635 Mangler.getStream() << RTTIMangling;
3636
3637 // VS2015 and VS2017.1 omit the copy-constructor in the mangled name but
3638 // both older and newer versions include it.
3639 // FIXME: It is known that the Ctor is present in 2013, and in 2017.7
3640 // (_MSC_VER 1914) and newer, and that it's omitted in 2015 and 2017.4
3641 // (_MSC_VER 1911), but it's unknown when exactly it reappeared (1914?
3642 // Or 1912, 1913 already?).
3643 bool OmitCopyCtor = getASTContext().getLangOpts().isCompatibleWithMSVC(
3644 LangOptions::MSVC2015) &&
3645 !getASTContext().getLangOpts().isCompatibleWithMSVC(
3646 LangOptions::MSVC2017_7);
3647 llvm::SmallString<64> CopyCtorMangling;
3648 if (!OmitCopyCtor && CD) {
3649 llvm::raw_svector_ostream Stream(CopyCtorMangling);
3650 msvc_hashing_ostream MHO(Stream);
3651 mangleCXXName(GlobalDecl(CD, CT), MHO);
3652 }
3653 Mangler.getStream() << CopyCtorMangling;
3654
3655 Mangler.getStream() << Size;
3656 if (VBPtrOffset == -1) {
3657 if (NVOffset) {
3658 Mangler.getStream() << NVOffset;
3659 }
3660 } else {
3661 Mangler.getStream() << NVOffset;
3662 Mangler.getStream() << VBPtrOffset;
3663 Mangler.getStream() << VBIndex;
3664 }
3665 }
3666
mangleCXXRTTIBaseClassDescriptor(const CXXRecordDecl * Derived,uint32_t NVOffset,int32_t VBPtrOffset,uint32_t VBTableOffset,uint32_t Flags,raw_ostream & Out)3667 void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassDescriptor(
3668 const CXXRecordDecl *Derived, uint32_t NVOffset, int32_t VBPtrOffset,
3669 uint32_t VBTableOffset, uint32_t Flags, raw_ostream &Out) {
3670 msvc_hashing_ostream MHO(Out);
3671 MicrosoftCXXNameMangler Mangler(*this, MHO);
3672 Mangler.getStream() << "??_R1";
3673 Mangler.mangleNumber(NVOffset);
3674 Mangler.mangleNumber(VBPtrOffset);
3675 Mangler.mangleNumber(VBTableOffset);
3676 Mangler.mangleNumber(Flags);
3677 Mangler.mangleName(Derived);
3678 Mangler.getStream() << "8";
3679 }
3680
mangleCXXRTTIBaseClassArray(const CXXRecordDecl * Derived,raw_ostream & Out)3681 void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassArray(
3682 const CXXRecordDecl *Derived, raw_ostream &Out) {
3683 msvc_hashing_ostream MHO(Out);
3684 MicrosoftCXXNameMangler Mangler(*this, MHO);
3685 Mangler.getStream() << "??_R2";
3686 Mangler.mangleName(Derived);
3687 Mangler.getStream() << "8";
3688 }
3689
mangleCXXRTTIClassHierarchyDescriptor(const CXXRecordDecl * Derived,raw_ostream & Out)3690 void MicrosoftMangleContextImpl::mangleCXXRTTIClassHierarchyDescriptor(
3691 const CXXRecordDecl *Derived, raw_ostream &Out) {
3692 msvc_hashing_ostream MHO(Out);
3693 MicrosoftCXXNameMangler Mangler(*this, MHO);
3694 Mangler.getStream() << "??_R3";
3695 Mangler.mangleName(Derived);
3696 Mangler.getStream() << "8";
3697 }
3698
mangleCXXRTTICompleteObjectLocator(const CXXRecordDecl * Derived,ArrayRef<const CXXRecordDecl * > BasePath,raw_ostream & Out)3699 void MicrosoftMangleContextImpl::mangleCXXRTTICompleteObjectLocator(
3700 const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
3701 raw_ostream &Out) {
3702 // <mangled-name> ::= ?_R4 <class-name> <storage-class>
3703 // <cvr-qualifiers> [<name>] @
3704 // NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class>
3705 // is always '6' for vftables.
3706 llvm::SmallString<64> VFTableMangling;
3707 llvm::raw_svector_ostream Stream(VFTableMangling);
3708 mangleCXXVFTable(Derived, BasePath, Stream);
3709
3710 if (VFTableMangling.startswith("??@")) {
3711 assert(VFTableMangling.endswith("@"));
3712 Out << VFTableMangling << "??_R4@";
3713 return;
3714 }
3715
3716 assert(VFTableMangling.startswith("??_7") ||
3717 VFTableMangling.startswith("??_S"));
3718
3719 Out << "??_R4" << VFTableMangling.str().drop_front(4);
3720 }
3721
mangleSEHFilterExpression(const NamedDecl * EnclosingDecl,raw_ostream & Out)3722 void MicrosoftMangleContextImpl::mangleSEHFilterExpression(
3723 const NamedDecl *EnclosingDecl, raw_ostream &Out) {
3724 msvc_hashing_ostream MHO(Out);
3725 MicrosoftCXXNameMangler Mangler(*this, MHO);
3726 // The function body is in the same comdat as the function with the handler,
3727 // so the numbering here doesn't have to be the same across TUs.
3728 //
3729 // <mangled-name> ::= ?filt$ <filter-number> @0
3730 Mangler.getStream() << "?filt$" << SEHFilterIds[EnclosingDecl]++ << "@0@";
3731 Mangler.mangleName(EnclosingDecl);
3732 }
3733
mangleSEHFinallyBlock(const NamedDecl * EnclosingDecl,raw_ostream & Out)3734 void MicrosoftMangleContextImpl::mangleSEHFinallyBlock(
3735 const NamedDecl *EnclosingDecl, raw_ostream &Out) {
3736 msvc_hashing_ostream MHO(Out);
3737 MicrosoftCXXNameMangler Mangler(*this, MHO);
3738 // The function body is in the same comdat as the function with the handler,
3739 // so the numbering here doesn't have to be the same across TUs.
3740 //
3741 // <mangled-name> ::= ?fin$ <filter-number> @0
3742 Mangler.getStream() << "?fin$" << SEHFinallyIds[EnclosingDecl]++ << "@0@";
3743 Mangler.mangleName(EnclosingDecl);
3744 }
3745
mangleTypeName(QualType T,raw_ostream & Out)3746 void MicrosoftMangleContextImpl::mangleTypeName(QualType T, raw_ostream &Out) {
3747 // This is just a made up unique string for the purposes of tbaa. undname
3748 // does *not* know how to demangle it.
3749 MicrosoftCXXNameMangler Mangler(*this, Out);
3750 Mangler.getStream() << '?';
3751 Mangler.mangleType(T, SourceRange());
3752 }
3753
mangleReferenceTemporary(const VarDecl * VD,unsigned ManglingNumber,raw_ostream & Out)3754 void MicrosoftMangleContextImpl::mangleReferenceTemporary(
3755 const VarDecl *VD, unsigned ManglingNumber, raw_ostream &Out) {
3756 msvc_hashing_ostream MHO(Out);
3757 MicrosoftCXXNameMangler Mangler(*this, MHO);
3758
3759 Mangler.getStream() << "?$RT" << ManglingNumber << '@';
3760 Mangler.mangle(VD, "");
3761 }
3762
mangleThreadSafeStaticGuardVariable(const VarDecl * VD,unsigned GuardNum,raw_ostream & Out)3763 void MicrosoftMangleContextImpl::mangleThreadSafeStaticGuardVariable(
3764 const VarDecl *VD, unsigned GuardNum, raw_ostream &Out) {
3765 msvc_hashing_ostream MHO(Out);
3766 MicrosoftCXXNameMangler Mangler(*this, MHO);
3767
3768 Mangler.getStream() << "?$TSS" << GuardNum << '@';
3769 Mangler.mangleNestedName(VD);
3770 Mangler.getStream() << "@4HA";
3771 }
3772
mangleStaticGuardVariable(const VarDecl * VD,raw_ostream & Out)3773 void MicrosoftMangleContextImpl::mangleStaticGuardVariable(const VarDecl *VD,
3774 raw_ostream &Out) {
3775 // <guard-name> ::= ?_B <postfix> @5 <scope-depth>
3776 // ::= ?__J <postfix> @5 <scope-depth>
3777 // ::= ?$S <guard-num> @ <postfix> @4IA
3778
3779 // The first mangling is what MSVC uses to guard static locals in inline
3780 // functions. It uses a different mangling in external functions to support
3781 // guarding more than 32 variables. MSVC rejects inline functions with more
3782 // than 32 static locals. We don't fully implement the second mangling
3783 // because those guards are not externally visible, and instead use LLVM's
3784 // default renaming when creating a new guard variable.
3785 msvc_hashing_ostream MHO(Out);
3786 MicrosoftCXXNameMangler Mangler(*this, MHO);
3787
3788 bool Visible = VD->isExternallyVisible();
3789 if (Visible) {
3790 Mangler.getStream() << (VD->getTLSKind() ? "??__J" : "??_B");
3791 } else {
3792 Mangler.getStream() << "?$S1@";
3793 }
3794 unsigned ScopeDepth = 0;
3795 if (Visible && !getNextDiscriminator(VD, ScopeDepth))
3796 // If we do not have a discriminator and are emitting a guard variable for
3797 // use at global scope, then mangling the nested name will not be enough to
3798 // remove ambiguities.
3799 Mangler.mangle(VD, "");
3800 else
3801 Mangler.mangleNestedName(VD);
3802 Mangler.getStream() << (Visible ? "@5" : "@4IA");
3803 if (ScopeDepth)
3804 Mangler.mangleNumber(ScopeDepth);
3805 }
3806
mangleInitFiniStub(const VarDecl * D,char CharCode,raw_ostream & Out)3807 void MicrosoftMangleContextImpl::mangleInitFiniStub(const VarDecl *D,
3808 char CharCode,
3809 raw_ostream &Out) {
3810 msvc_hashing_ostream MHO(Out);
3811 MicrosoftCXXNameMangler Mangler(*this, MHO);
3812 Mangler.getStream() << "??__" << CharCode;
3813 if (D->isStaticDataMember()) {
3814 Mangler.getStream() << '?';
3815 Mangler.mangleName(D);
3816 Mangler.mangleVariableEncoding(D);
3817 Mangler.getStream() << "@@";
3818 } else {
3819 Mangler.mangleName(D);
3820 }
3821 // This is the function class mangling. These stubs are global, non-variadic,
3822 // cdecl functions that return void and take no args.
3823 Mangler.getStream() << "YAXXZ";
3824 }
3825
mangleDynamicInitializer(const VarDecl * D,raw_ostream & Out)3826 void MicrosoftMangleContextImpl::mangleDynamicInitializer(const VarDecl *D,
3827 raw_ostream &Out) {
3828 // <initializer-name> ::= ?__E <name> YAXXZ
3829 mangleInitFiniStub(D, 'E', Out);
3830 }
3831
3832 void
mangleDynamicAtExitDestructor(const VarDecl * D,raw_ostream & Out)3833 MicrosoftMangleContextImpl::mangleDynamicAtExitDestructor(const VarDecl *D,
3834 raw_ostream &Out) {
3835 // <destructor-name> ::= ?__F <name> YAXXZ
3836 mangleInitFiniStub(D, 'F', Out);
3837 }
3838
mangleStringLiteral(const StringLiteral * SL,raw_ostream & Out)3839 void MicrosoftMangleContextImpl::mangleStringLiteral(const StringLiteral *SL,
3840 raw_ostream &Out) {
3841 // <char-type> ::= 0 # char, char16_t, char32_t
3842 // # (little endian char data in mangling)
3843 // ::= 1 # wchar_t (big endian char data in mangling)
3844 //
3845 // <literal-length> ::= <non-negative integer> # the length of the literal
3846 //
3847 // <encoded-crc> ::= <hex digit>+ @ # crc of the literal including
3848 // # trailing null bytes
3849 //
3850 // <encoded-string> ::= <simple character> # uninteresting character
3851 // ::= '?$' <hex digit> <hex digit> # these two nibbles
3852 // # encode the byte for the
3853 // # character
3854 // ::= '?' [a-z] # \xe1 - \xfa
3855 // ::= '?' [A-Z] # \xc1 - \xda
3856 // ::= '?' [0-9] # [,/\:. \n\t'-]
3857 //
3858 // <literal> ::= '??_C@_' <char-type> <literal-length> <encoded-crc>
3859 // <encoded-string> '@'
3860 MicrosoftCXXNameMangler Mangler(*this, Out);
3861 Mangler.getStream() << "??_C@_";
3862
3863 // The actual string length might be different from that of the string literal
3864 // in cases like:
3865 // char foo[3] = "foobar";
3866 // char bar[42] = "foobar";
3867 // Where it is truncated or zero-padded to fit the array. This is the length
3868 // used for mangling, and any trailing null-bytes also need to be mangled.
3869 unsigned StringLength = getASTContext()
3870 .getAsConstantArrayType(SL->getType())
3871 ->getSize()
3872 .getZExtValue();
3873 unsigned StringByteLength = StringLength * SL->getCharByteWidth();
3874
3875 // <char-type>: The "kind" of string literal is encoded into the mangled name.
3876 if (SL->isWide())
3877 Mangler.getStream() << '1';
3878 else
3879 Mangler.getStream() << '0';
3880
3881 // <literal-length>: The next part of the mangled name consists of the length
3882 // of the string in bytes.
3883 Mangler.mangleNumber(StringByteLength);
3884
3885 auto GetLittleEndianByte = [&SL](unsigned Index) {
3886 unsigned CharByteWidth = SL->getCharByteWidth();
3887 if (Index / CharByteWidth >= SL->getLength())
3888 return static_cast<char>(0);
3889 uint32_t CodeUnit = SL->getCodeUnit(Index / CharByteWidth);
3890 unsigned OffsetInCodeUnit = Index % CharByteWidth;
3891 return static_cast<char>((CodeUnit >> (8 * OffsetInCodeUnit)) & 0xff);
3892 };
3893
3894 auto GetBigEndianByte = [&SL](unsigned Index) {
3895 unsigned CharByteWidth = SL->getCharByteWidth();
3896 if (Index / CharByteWidth >= SL->getLength())
3897 return static_cast<char>(0);
3898 uint32_t CodeUnit = SL->getCodeUnit(Index / CharByteWidth);
3899 unsigned OffsetInCodeUnit = (CharByteWidth - 1) - (Index % CharByteWidth);
3900 return static_cast<char>((CodeUnit >> (8 * OffsetInCodeUnit)) & 0xff);
3901 };
3902
3903 // CRC all the bytes of the StringLiteral.
3904 llvm::JamCRC JC;
3905 for (unsigned I = 0, E = StringByteLength; I != E; ++I)
3906 JC.update(GetLittleEndianByte(I));
3907
3908 // <encoded-crc>: The CRC is encoded utilizing the standard number mangling
3909 // scheme.
3910 Mangler.mangleNumber(JC.getCRC());
3911
3912 // <encoded-string>: The mangled name also contains the first 32 bytes
3913 // (including null-terminator bytes) of the encoded StringLiteral.
3914 // Each character is encoded by splitting them into bytes and then encoding
3915 // the constituent bytes.
3916 auto MangleByte = [&Mangler](char Byte) {
3917 // There are five different manglings for characters:
3918 // - [a-zA-Z0-9_$]: A one-to-one mapping.
3919 // - ?[a-z]: The range from \xe1 to \xfa.
3920 // - ?[A-Z]: The range from \xc1 to \xda.
3921 // - ?[0-9]: The set of [,/\:. \n\t'-].
3922 // - ?$XX: A fallback which maps nibbles.
3923 if (isAsciiIdentifierContinue(Byte, /*AllowDollar=*/true)) {
3924 Mangler.getStream() << Byte;
3925 } else if (isLetter(Byte & 0x7f)) {
3926 Mangler.getStream() << '?' << static_cast<char>(Byte & 0x7f);
3927 } else {
3928 const char SpecialChars[] = {',', '/', '\\', ':', '.',
3929 ' ', '\n', '\t', '\'', '-'};
3930 const char *Pos = llvm::find(SpecialChars, Byte);
3931 if (Pos != std::end(SpecialChars)) {
3932 Mangler.getStream() << '?' << (Pos - std::begin(SpecialChars));
3933 } else {
3934 Mangler.getStream() << "?$";
3935 Mangler.getStream() << static_cast<char>('A' + ((Byte >> 4) & 0xf));
3936 Mangler.getStream() << static_cast<char>('A' + (Byte & 0xf));
3937 }
3938 }
3939 };
3940
3941 // Enforce our 32 bytes max, except wchar_t which gets 32 chars instead.
3942 unsigned MaxBytesToMangle = SL->isWide() ? 64U : 32U;
3943 unsigned NumBytesToMangle = std::min(MaxBytesToMangle, StringByteLength);
3944 for (unsigned I = 0; I != NumBytesToMangle; ++I) {
3945 if (SL->isWide())
3946 MangleByte(GetBigEndianByte(I));
3947 else
3948 MangleByte(GetLittleEndianByte(I));
3949 }
3950
3951 Mangler.getStream() << '@';
3952 }
3953
create(ASTContext & Context,DiagnosticsEngine & Diags,bool IsAux)3954 MicrosoftMangleContext *MicrosoftMangleContext::create(ASTContext &Context,
3955 DiagnosticsEngine &Diags,
3956 bool IsAux) {
3957 return new MicrosoftMangleContextImpl(Context, Diags, IsAux);
3958 }
3959