clang  15.0.0git
MicrosoftMangle.cpp
Go to the documentation of this file.
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"
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"
27 #include "clang/Basic/ABI.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.
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 
59  msvc_hashing_ostream(raw_ostream &OS)
60  : llvm::raw_svector_ostream(Buffer), OS(OS) {}
61  ~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 *
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.
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 
123 static const DeclContext *getEffectiveParentContext(const DeclContext *DC) {
124  return getEffectiveDeclContext(cast<Decl>(DC));
125 }
126 
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,
162  raw_ostream &) override;
163  void mangleCXXVFTable(const CXXRecordDecl *Derived,
165  raw_ostream &Out) override;
166  void mangleCXXVBTable(const CXXRecordDecl *Derived,
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,
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;
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 
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 
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 
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.
298  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 
333  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 
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 
346  MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_,
348  : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
349  TemplateArgStringStorage(TemplateArgStringStorageAlloc),
350  PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
351  64) {}
352 
353  MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_,
355  : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
356  TemplateArgStringStorage(TemplateArgStringStorageAlloc),
357  PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
358  64) {}
359 
360  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:
390  bool isStructorDecl(const NamedDecl *ND) const {
391  return ND == Structor || getStructor(ND) == Structor;
392  }
393 
394  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 
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 
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 
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
547 MicrosoftMangleContextImpl::shouldMangleStringLiteral(const StringLiteral *SL) {
548  return true;
549 }
550 
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 
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 
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 
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;
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.
706  mangleNumber(0);
708  mangleNumber(VBTableOffset);
709 }
710 
711 void
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 
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());
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));
770  mangleNumber(VBPtrOffset);
772  mangleNumber(VBTableOffset);
773 }
774 
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 
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 
802 void MicrosoftCXXNameMangler::mangleNumber(int64_t Number) {
803  mangleNumber(llvm::APSInt(llvm::APInt(64, Number), /*IsUnsigned*/false));
804 }
805 
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 
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 
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 
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 
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()) {
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>]
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 
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 
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:
1432  llvm_unreachable("Not an overloaded operator");
1433  }
1434 }
1435 
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 
1448 void MicrosoftCXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) {
1449  Context.mangleObjCMethodNameAsSourceName(MD, Out);
1450 }
1451 
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 
1478 void MicrosoftCXXNameMangler::mangleUnscopedTemplateName(GlobalDecl GD) {
1479  // <unscoped-template-name> ::= ?$ <unqualified-name>
1480  Out << "?$";
1481  mangleUnqualifiedName(GD);
1482 }
1483 
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 
1505 void MicrosoftCXXNameMangler::mangleExpression(
1506  const Expr *E, const NonTypeTemplateParmDecl *PD) {
1507  // See if this is a constant expression.
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 
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 
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()) {
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(
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 =
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 
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 
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 
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 
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 
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
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 
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 
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 
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 
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 
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 
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 
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>
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 }
2531 void MicrosoftCXXNameMangler::mangleType(const FunctionNoProtoType *T,
2533  Out << "$$A6";
2534  mangleFunctionType(T);
2535 }
2536 
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 
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)
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 
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 }
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 }
2794 void MicrosoftCXXNameMangler::mangleCallingConvention(const FunctionType *T) {
2795  mangleCallingConvention(T->getCallConv());
2796 }
2797 
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 
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>
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 }
2841 void MicrosoftCXXNameMangler::mangleType(const EnumType *T, Qualifiers,
2842  SourceRange) {
2843  mangleType(cast<TagType>(T)->getDecl());
2844 }
2845 void MicrosoftCXXNameMangler::mangleType(const RecordType *T, Qualifiers,
2846  SourceRange) {
2847  mangleType(cast<TagType>(T)->getDecl());
2848 }
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.
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.
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 }
2884 void MicrosoftCXXNameMangler::mangleType(const ConstantArrayType *T, Qualifiers,
2885  SourceRange) {
2886  llvm_unreachable("Should have been special cased");
2887 }
2888 void MicrosoftCXXNameMangler::mangleType(const VariableArrayType *T, Qualifiers,
2889  SourceRange) {
2890  llvm_unreachable("Should have been special cased");
2891 }
2892 void MicrosoftCXXNameMangler::mangleType(const DependentSizedArrayType *T,
2894  llvm_unreachable("Should have been special cased");
2895 }
2896 void MicrosoftCXXNameMangler::mangleType(const IncompleteArrayType *T,
2898  llvm_unreachable("Should have been special cased");
2899 }
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>
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 
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 
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
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 
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
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
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 
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.)
3056 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 
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 
3112 void MicrosoftCXXNameMangler::mangleType(const ExtVectorType *T,
3113  Qualifiers Quals, SourceRange Range) {
3114  mangleType(static_cast<const VectorType *>(T), Quals, Range);
3115 }
3116 
3117 void MicrosoftCXXNameMangler::mangleType(const DependentVectorType *T,
3118  Qualifiers, SourceRange Range) {
3119  DiagnosticsEngine &Diags = Context.getDiags();
3120  unsigned DiagID = Diags.getCustomDiagID(
3122  "cannot mangle this dependent-sized vector type yet");
3123  Diags.Report(Range.getBegin(), DiagID) << Range;
3124 }
3125 
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 
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 
3143 void MicrosoftCXXNameMangler::mangleType(const DependentSizedMatrixType *T,
3144  Qualifiers quals, SourceRange Range) {
3145  DiagnosticsEngine &Diags = Context.getDiags();
3146  unsigned DiagID = Diags.getCustomDiagID(
3148  "Cannot mangle this dependent-sized matrix type yet");
3149  Diags.Report(Range.getBegin(), DiagID) << Range;
3150 }
3151 
3152 void MicrosoftCXXNameMangler::mangleType(const DependentAddressSpaceType *T,
3153  Qualifiers, SourceRange Range) {
3154  DiagnosticsEngine &Diags = Context.getDiags();
3155  unsigned DiagID = Diags.getCustomDiagID(
3157  "cannot mangle this dependent address space type yet");
3158  Diags.Report(Range.getBegin(), DiagID) << Range;
3159 }
3160 
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 
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 
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 
3221 void MicrosoftCXXNameMangler::mangleType(const InjectedClassNameType *,
3223  llvm_unreachable("Cannot mangle injected class name type.");
3224 }
3225 
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 
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 
3244 void MicrosoftCXXNameMangler::mangleType(
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 
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 
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 
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 
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 
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 
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 
3310 void MicrosoftCXXNameMangler::mangleType(
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 
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 
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 
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 
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 
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>
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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
3833 MicrosoftMangleContextImpl::mangleDynamicAtExitDestructor(const VarDecl *D,
3834  raw_ostream &Out) {
3835  // <destructor-name> ::= ?__F <name> YAXXZ
3836  mangleInitFiniStub(D, 'F', Out);
3837 }
3838 
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 
3955  DiagnosticsEngine &Diags,
3956  bool IsAux) {
3957  return new MicrosoftMangleContextImpl(Context, Diags, IsAux);
3958 }
clang::BuiltinType
This class is used for builtin types like 'int'.
Definition: Type.h:2563
clang::FunctionDecl::getSourceRange
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4092
clang::InternalLinkage
@ InternalLinkage
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:31
clang::TemplateDecl::getTemplatedDecl
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
Definition: DeclTemplate.h:441
clang::GlobalDecl::getDtorType
CXXDtorType getDtorType() const
Definition: GlobalDecl.h:110
clang::Type::isRecordType
bool isRecordType() const
Definition: Type.h:6897
max
__DEVICE__ int max(int __a, int __b)
Definition: __clang_cuda_math.h:196
clang::ASTContext::getDeclaratorForUnnamedTagDecl
DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)
Definition: ASTContext.cpp:11931
clang::Dtor_Base
@ Dtor_Base
Base object dtor.
Definition: ABI.h:36
clang::PipeType::isReadOnly
bool isReadOnly() const
Definition: Type.h:6437
clang::DeducedTemplateSpecializationType
Represents a C++17 deduced template specialization type.
Definition: Type.h:5177
clang::APValue::LValueBase
Definition: APValue.h:146
clang::StringLiteral::getCodeUnit
uint32_t getCodeUnit(size_t i) const
Definition: Expr.h:1865
llvm
YAML serialization mapping.
Definition: Dominators.h:30
clang::CXXConstructorDecl
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2434
clang::VarDecl::getSourceRange
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2095
clang::CC_X86FastCall
@ CC_X86FastCall
Definition: Specifiers.h:266
clang::FunctionDecl::getNumParams
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3445
clang::Type::isBlockPointerType
bool isBlockPointerType() const
Definition: Type.h:6815
clang::VarDecl::getTLSKind
TLSKind getTLSKind() const
Definition: Decl.cpp:2073
clang::QualType::getLocalQualifiers
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:6578
clang::interp::APInt
llvm::APInt APInt
Definition: Integral.h:27
clang::CC_Win64
@ CC_Win64
Definition: Specifiers.h:270
clang::CXXMethodDecl::isStatic
bool isStatic() const
Definition: DeclCXX.cpp:2113
clang::BuiltinType::getName
StringRef getName(const PrintingPolicy &Policy) const
Definition: Type.cpp:2979
mangleThunkThisAdjustment
static void mangleThunkThisAdjustment(AccessSpecifier AS, const ThisAdjustment &Adjustment, MicrosoftCXXNameMangler &Mangler, raw_ostream &Out)
Definition: MicrosoftMangle.cpp:3422
clang::StringLiteral::isWide
bool isWide() const
Definition: Expr.h:1887
Error
llvm::Error Error
Definition: ByteCodeEmitter.cpp:20
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1376
clang::Decl::hasAttr
bool hasAttr() const
Definition: DeclBase.h:549
clang::PipeType::getElementType
QualType getElementType() const
Definition: Type.h:6418
clang::TTK_Enum
@ TTK_Enum
The "enum" keyword.
Definition: Type.h:5457
clang::ConstantArrayType
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:3001
clang::DependentSizedArrayType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3181
clang::NamedDecl::isExternallyVisible
bool isExternallyVisible() const
Definition: Decl.h:405
clang::ConstantArrayType::getSize
const llvm::APInt & getSize() const
Definition: Type.h:3024
llvm::SmallVector
Definition: LLVM.h:38
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::QualType::getQualifiers
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6586
clang::TTK_Struct
@ TTK_Struct
The "struct" keyword.
Definition: Type.h:5445
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:247
clang::Qualifiers::withoutObjCLifetime
Qualifiers withoutObjCLifetime() const
Definition: Type.h:340
clang::TemplateArgument::getIntegralType
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:326
clang::AS_private
@ AS_private
Definition: Specifiers.h:111
TargetInfo.h
CXXInheritance.h
clang::Stmt::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:324
clang::TemplateArgument::getParamTypeForDecl
QualType getParamTypeForDecl() const
Definition: TemplateBase.h:280
clang::FunctionDecl::getCanonicalDecl
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3370
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:731
clang::NonTypeTemplateParmDecl
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Definition: DeclTemplate.h:1410
clang::ASTContext::getTargetAddressSpace
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.cpp:12085
Attr.h
clang::TemplateName::getAsTemplateDecl
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
Definition: TemplateName.cpp:108
clang::FunctionDecl::getParamDecl
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2533
AttributeLangSupport::C
@ C
Definition: SemaDeclAttr.cpp:55
clang::NamedDecl::hasLinkage
bool hasLinkage() const
Determine whether this declaration has linkage.
Definition: Decl.cpp:1849
clang::QualType::getCanonicalType
QualType getCanonicalType() const
Definition: Type.h:6598
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2862
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:192
clang::Qualifiers
The collection of all-type qualifiers we support.
Definition: Type.h:147
clang::PipeType
PipeType - OpenCL20.
Definition: Type.h:6407
getCharWidth
static unsigned getCharWidth(tok::TokenKind kind, const TargetInfo &Target)
Definition: LiteralSupport.cpp:40
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1680
clang::Redeclarable::getFirstDecl
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:216
DeclCXX.h
clang::ObjCObjectPointerType::getPointeeType
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:6219
clang::TemplateSpecializationType
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:5238
clang::BitIntType::getNumBits
unsigned getNumBits() const
Definition: Type.h:6452
DeclOpenMP.h
clang::ComplexType::getElementType
QualType getElementType() const
Definition: Type.h:2669
clang::FunctionDecl::getPrimaryTemplate
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3877
llvm::Optional
Definition: LLVM.h:40
clang::RQ_RValue
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1515
SourceManager.h
clang::Ctor_Complete
@ Ctor_Complete
Complete object ctor.
Definition: ABI.h:25
clang::Type::isVoidType
bool isVoidType() const
Definition: Type.h:7096
clang::FunctionDecl::getTemplateSpecializationArgs
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3893
clang::RefQualifierKind
RefQualifierKind
The kind of C++11 ref-qualifier associated with a function type.
Definition: Type.h:1507
clang::TagDecl::getTypedefNameForAnonDecl
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3583
clang::Decl::getAttr
T * getAttr() const
Definition: DeclBase.h:545
clang::CC_X86ThisCall
@ CC_X86ThisCall
Definition: Specifiers.h:267
clang::DeclarationName::getAsIdentifierInfo
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
Definition: DeclarationName.h:419
clang::ObjCInterfaceType::getDecl
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.cpp:823
Identifier
StringRef Identifier
Definition: Format.cpp:2585
clang::FunctionType
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3618
clang::VarTemplateSpecializationDecl
Represents a variable template specialization, which refers to a variable template with a given set o...
Definition: DeclTemplate.h:2690
clang::Qualifiers::hasConst
bool hasConst() const
Definition: Type.h:264
clang::Qualifiers::removeUnaligned
void removeUnaligned()
Definition: Type.h:322
clang::FunctionNoProtoType
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Definition: Type.h:3918
clang::ObjCObjectType::getInterface
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface.
Definition: Type.h:6186
clang::TTK_Interface
@ TTK_Interface
The "__interface" keyword.
Definition: Type.h:5448
clang::BitIntType::isUnsigned
bool isUnsigned() const
Definition: Type.h:6450
clang::TemplateArgument::getAsExpr
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:341
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:144
clang::ASTContext::getSourceManager
SourceManager & getSourceManager()
Definition: ASTContext.h:717
clang::CXXRecordDecl::getLambdaContextDecl
Decl * getLambdaContextDecl() const
Retrieve the declaration that provides additional context for a lambda, when the normal declaration c...
Definition: DeclCXX.cpp:1614
clang::TemplateArgument::getAsIntegral
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
Definition: TemplateBase.h:312
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:627
clang::Ctor_CopyingClosure
@ Ctor_CopyingClosure
Copying closure variant of a ctor.
Definition: ABI.h:28
clang::Dtor_Complete
@ Dtor_Complete
Complete object dtor.
Definition: ABI.h:35
clang::DependentSizedMatrixType
Represents a matrix type where the type and the number of rows and columns is dependent on a template...
Definition: Type.h:3586
clang::CC_X86StdCall
@ CC_X86StdCall
Definition: Specifiers.h:265
clang::FunctionProtoType::isVariadic
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:4289
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1556
Decl.h
clang::ThisAdjustment::VirtualAdjustment::VtordispOffset
int32_t VtordispOffset
The offset of the vtordisp (in bytes), relative to the ECX.
Definition: Thunk.h:108
clang::ObjCObjectType
Represents a class type in Objective C.
Definition: Type.h:5951
DeclObjC.h
ABI.h
clang::GlobalDecl
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:56
clang::AS_none
@ AS_none
Definition: Specifiers.h:112
clang::CPlusPlus17
@ CPlusPlus17
Definition: LangStandard.h:56
uint64_t
unsigned long uint64_t
Definition: hlsl_basic_types.h:24
clang::ReferenceType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2841
clang::Ctor_DefaultClosure
@ Ctor_DefaultClosure
Default closure variant of a ctor.
Definition: ABI.h:29
clang::Qualifiers::getAddressSpace
LangAS getAddressSpace() const
Definition: Type.h:378
APSInt
llvm::APSInt APSInt
Definition: ByteCodeEmitter.cpp:19
U
clang::Expr::getIntegerConstantExpr
Optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
Definition: ExprConstant.cpp:15765
clang::Type::isReferenceType
bool isReferenceType() const
Definition: Type.h:6819
V
#define V(N, I)
Definition: ASTContext.h:3184
clang::CC_Swift
@ CC_Swift
Definition: Specifiers.h:278
clang::LangOptions::isCompatibleWithMSVC
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
Definition: LangOptions.h:512
min
__DEVICE__ int min(int __a, int __b)
Definition: __clang_cuda_math.h:197
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4706
clang::TemplateArgument::getKind
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:244
clang::CXXCtorType
CXXCtorType
C++ constructor types.
Definition: ABI.h:24
clang::TemplateParameterList::getParam
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:139
DeclTemplate.h
clang::PackExpansionType
Represents a pack expansion of types.
Definition: Type.h:5767
clang::CXXMethodDecl::isInstance
bool isInstance() const
Definition: DeclCXX.h:2008
clang::Decl::getAccess
AccessSpecifier getAccess() const
Definition: DeclBase.h:480
clang::Qualifiers::hasRestrict
bool hasRestrict() const
Definition: Type.h:284
clang::TagTypeKind
TagTypeKind
The kind of a tag type.
Definition: Type.h:5443
clang::BlockDecl
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4208
clang::VarDecl::isStaticLocal
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1123
clang::XRayInstrKind::None
constexpr XRayInstrMask None
Definition: XRayInstr.h:38
clang::inheritanceModelHasVBTableOffsetField
bool inheritanceModelHasVBTableOffsetField(MSInheritanceModel Inheritance)
Definition: CXXInheritance.h:377
clang::AS_public
@ AS_public
Definition: Specifiers.h:109
clang::VectorType
Represents a GCC generic vector type.
Definition: Type.h:3301
clang::VarDecl::isStaticDataMember
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1198
clang::MethodVFTableLocation::VBase
const CXXRecordDecl * VBase
If nonnull, holds the last vbase which contains the vfptr that the method definition is adjusted to.
Definition: VTableBuilder.h:516
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:209
clang::PrettyStackTraceDecl
PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specifi...
Definition: DeclBase.h:1239
clang::ObjCObjectType::getTypeArgs
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments of this object type (semantically).
Definition: Type.cpp:770
clang::CPlusPlus
@ CPlusPlus
Definition: LangStandard.h:53
clang::ArrayType
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2955
clang::CXXDtorType
CXXDtorType
C++ destructor types.
Definition: ABI.h:33
clang::ConstantMatrixType
Represents a concrete matrix type with constant number of rows and columns.
Definition: Type.h:3527
clang::MemberPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2919
clang::DecompositionDecl
A decomposition declaration.
Definition: DeclCXX.h:4049
clang::MethodVFTableLocation::Index
uint64_t Index
Method's index in the vftable.
Definition: VTableBuilder.h:523
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7302
clang::TypeOfType
Represents typeof(type), a GCC extension.
Definition: Type.h:4558
clang::isLetter
LLVM_READONLY bool isLetter(unsigned char c)
Return true if this character is an ASCII letter: [a-zA-Z].
Definition: CharInfo.h:117
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:61
clang::FunctionType::getCallConv
CallingConv getCallConv() const
Definition: Type.h:3891
clang::FunctionProtoType::getParamType
QualType getParamType(unsigned i) const
Definition: Type.h:4169
clang::MSGuidDecl
A global _GUID constant.
Definition: DeclCXX.h:4172
clang::CXXDestructorDecl
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2701
clang::DeclContext::isTranslationUnit
bool isTranslationUnit() const
Definition: DeclBase.h:1977
clang::AutoType
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Definition: Type.h:5107
clang::Type::isFunctionType
bool isFunctionType() const
Definition: Type.h:6803
Expr.h
clang::Qualifiers::hasObjCLifetime
bool hasObjCLifetime() const
Definition: Type.h:351
llvm::SmallString
Definition: LLVM.h:37
ASTContext.h
clang::FunctionProtoType::canThrow
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
Definition: Type.cpp:3337
clang::CallingConv
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:263
clang::ASTRecordLayout::getVBPtrOffset
CharUnits getVBPtrOffset() const
getVBPtrOffset - Get the offset for virtual base table pointer.
Definition: RecordLayout.h:324
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:874
clang::UnresolvedUsingType
Represents the dependent type named by a dependently-scoped typename using declaration,...
Definition: Type.h:4413
clang::Type::getPointeeType
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:625
clang::TagDecl
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3355
clang::TemplateParameterList
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:70
clang::StringLiteral
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1767
clang::TTK_Class
@ TTK_Class
The "class" keyword.
Definition: Type.h:5454
clang::ObjCObjectType::getBaseType
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:6014
clang::NUM_OVERLOADED_OPERATORS
@ NUM_OVERLOADED_OPERATORS
Definition: OperatorKinds.h:26
clang::Type::getAsCXXRecordDecl
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1759
clang::TTK_Union
@ TTK_Union
The "union" keyword.
Definition: Type.h:5451
clang::RQ_None
@ RQ_None
No ref-qualifier was provided.
Definition: Type.h:1509
clang::DeclContext::isNamespace
bool isNamespace() const
Definition: DeclBase.h:1986
clang::CXXRecordDecl::bases
base_class_range bases()
Definition: DeclCXX.h:596
clang::DependentAddressSpaceType
Represents an extended address space qualifier where the input address space value is dependent.
Definition: Type.h:3219
clang::MemberPointerType::getClass
const Type * getClass() const
Definition: Type.h:2933
clang::Qualifiers::hasAddressSpace
bool hasAddressSpace() const
Definition: Type.h:377
ExprCXX.h
Base
clang::SubstTemplateTypeParmPackType
Represents the result of substituting a set of types for a template type parameter pack.
Definition: Type.h:5024
clang::ThunkInfo::This
ThisAdjustment This
The this pointer adjustment.
Definition: Thunk.h:158
clang::Qualifiers::hasUnaligned
bool hasUnaligned() const
Definition: Type.h:318
clang::AtomicType::getValueType
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:6388
clang::index::SymbolRole::Dynamic
@ Dynamic
clang::BlockPointerType
Pointer to a block type.
Definition: Type.h:2792
clang::FunctionProtoType::getRefQualifier
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Definition: Type.h:4315
clang::CXXRecordDecl::getMSInheritanceModel
MSInheritanceModel getMSInheritanceModel() const
Returns the inheritance model used for this record.
Definition: MicrosoftCXXABI.cpp:234
clang::Type::getTypeClass
TypeClass getTypeClass() const
Definition: Type.h:1927
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:330
clang::OverloadedOperatorKind
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
clang::NamedDecl::getFormalLinkage
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Definition: Decl.h:396
clang::BitIntType
A fixed int type of a specified bitwidth.
Definition: Type.h:6441
clang::IncompleteArrayType
Represents a C array with an unspecified size.
Definition: Type.h:3061
clang::interp::Null
bool Null(InterpState &S, CodePtr OpPC)
Definition: Interp.h:820
clang::TemplateDecl::getTemplateParameters
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:428
clang::QualType::getUnqualifiedType
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6639
CharUnits.h
clang::isAsciiIdentifierContinue
LLVM_READONLY bool isAsciiIdentifierContinue(unsigned char c, bool AllowDollar=false)
Returns true if this is a body character of a C identifier, which is [a-zA-Z0-9_].
Definition: CharInfo.h:64
clang::CC_C
@ CC_C
Definition: Specifiers.h:264
clang::UnaryTransformType
A unary type transform, which is a type constructed from another.
Definition: Type.h:4624
clang::TemplateTypeParmType
Definition: Type.h:4892
clang::DeducedType::getDeducedType
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it has not been deduced.
Definition: Type.h:5094
clang::LangAS
LangAS
Defines the address space values used by the address space qualifier of QualType.
Definition: AddressSpaces.h:25
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7369
clang::transformer::EditKind::Range
@ Range
clang::ObjCProtocolQualifiers::qual_empty
bool qual_empty() const
Definition: Type.h:5854
clang::QualType::getDesugaredType
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
Definition: Type.h:1043
clang::AccessSpecifier
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:108
clang::ObjCObjectPointerType
Represents a pointer to an Objective C object.
Definition: Type.h:6207
clang::ASTRecordLayout
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:38
clang::ThisAdjustment::VirtualAdjustment::VBPtrOffset
int32_t VBPtrOffset
The offset of the vbptr of the derived class (in bytes), relative to the ECX after vtordisp adjustmen...
Definition: Thunk.h:112
clang::ThunkInfo::Return
ReturnAdjustment Return
The return adjustment.
Definition: Thunk.h:161
clang::ThisAdjustment::NonVirtual
int64_t NonVirtual
The non-virtual adjustment from the derived object to its nearest virtual base.
Definition: Thunk.h:94
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
clang::inheritanceModelHasNVOffsetField
bool inheritanceModelHasNVOffsetField(bool IsMemberFunction, MSInheritanceModel Inheritance)
Definition: CXXInheritance.h:371
clang::OO_None
@ OO_None
Not an overloaded operator.
Definition: OperatorKinds.h:22
clang::DeclContext::getRedeclContext
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1797
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::serialized_diags::create
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
Definition: SerializedDiagnosticPrinter.cpp:301
clang::DependentSizedArrayType
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3159
clang::Type::isMemberPointerType
bool isMemberPointerType() const
Definition: Type.h:6855
clang::Type::getContainedAutoType
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
Definition: Type.h:2349
clang::VariableArrayType
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3105
clang::Type::isPointerType
bool isPointerType() const
Definition: Type.h:6807
clang::CXXRecordDecl::nullFieldOffsetIsZero
bool nullFieldOffsetIsZero() const
In the Microsoft C++ ABI, use zero for the field offset of a null data member pointer if we can guara...
Definition: MicrosoftCXXABI.cpp:240
VTableBuilder.h
clang::syntax::NodeRole::Size
@ Size
clang::ReturnAdjustment::isEmpty
bool isEmpty() const
Definition: Thunk.h:69
clang::ThisAdjustment::Virtual
union clang::ThisAdjustment::VirtualAdjustment Virtual
clang::ObjCObjectType::isObjCClass
bool isObjCClass() const
Definition: Type.h:6020
clang::TemplateArgument::getPackAsArray
ArrayRef< TemplateArgument > getPackAsArray() const
Return the array of arguments in this template argument pack.
Definition: TemplateBase.h:377
clang::NamedDecl::getIdentifier
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:268
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:674
clang::ComplexType
Complex values, per C99 6.2.5p11.
Definition: Type.h:2659
clang::AS_protected
@ AS_protected
Definition: Specifiers.h:110
clang::CXXLanguageLinkage
@ CXXLanguageLinkage
Definition: Linkage.h:66
clang::DecltypeType
Represents the type decltype(expr) (C++11).
Definition: Type.h:4581
clang::ObjCObjectType::isKindOfType
bool isKindOfType() const
Whether this ia a "__kindof" type (semantically).
Definition: Type.cpp:788
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3956
clang::GlobalDecl::getWithDecl
GlobalDecl getWithDecl(const Decl *D)
Definition: GlobalDecl.h:163
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1902
clang::CLanguageLinkage
@ CLanguageLinkage
Definition: Linkage.h:65
clang::Expr::getExprLoc
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:247
clang::ASTContext::getPrintingPolicy
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:709
clang::RecordDecl::fields
field_range fields() const
Definition: Decl.h:4134
clang::TemplateDecl
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:409
clang::BlockPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2804
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:796
llvm::ArrayRef
Definition: LLVM.h:34
Value
Value
Definition: UninitializedValues.cpp:102
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::ParmVarDecl::getFunctionScopeIndex
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
Definition: Decl.h:1740
clang::DeclaratorDecl
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:726
clang::ThunkInfo
The this pointer adjustment as well as an optional return adjustment for a thunk.
Definition: Thunk.h:156
clang::LanguageLinkage
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have.
Definition: Linkage.h:64
clang::ObjCObjectType::isSpecialized
bool isSpecialized() const
Determine whether this object type is "specialized", meaning that it has type arguments.
Definition: Type.cpp:752
clang::RISCV::Float
@ Float
Definition: RISCVVIntrinsicUtils.h:147
clang::ThisAdjustment::VirtualAdjustment::Microsoft
struct clang::ThisAdjustment::VirtualAdjustment::@181 Microsoft
clang::inheritanceModelHasVBPtrOffsetField
bool inheritanceModelHasVBPtrOffsetField(MSInheritanceModel Inheritance)
Definition: CXXInheritance.h:365
clang::MicrosoftVTableContext
Definition: VTableBuilder.h:544
clang::FunctionProtoType::getNumParams
unsigned getNumParams() const
Definition: Type.h:4167
clang::Qualifiers::hasVolatile
bool hasVolatile() const
Definition: Type.h:274
clang::Dtor_Comdat
@ Dtor_Comdat
The COMDAT used for dtors.
Definition: ABI.h:37
clang::InjectedClassNameType
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:5391
clang::TemplateArgumentList
A template argument list.
Definition: DeclTemplate.h:238
clang::CC_X86VectorCall
@ CC_X86VectorCall
Definition: Specifiers.h:268
clang::ASTContext::getTypedefNameForUnnamedTagDecl
TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)
Definition: ASTContext.cpp:11922
clang::TemplateParameterList::size
unsigned size() const
Definition: DeclTemplate.h:130
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::TypeOfExprType
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:4515
clang::StringLiteral::getCharByteWidth
unsigned getCharByteWidth() const
Definition: Expr.h:1880
clang::FunctionProtoType::getMethodQuals
Qualifiers getMethodQuals() const
Definition: Type.h:4307
clang::FunctionDecl::isExternC
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:3282
clang::MemberPointerType
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2903
clang::DependentTemplateSpecializationType
Represents a template specialization type whose template cannot be resolved, e.g.
Definition: Type.h:5676
clang::CXXRecordDecl::getMostRecentNonInjectedDecl
CXXRecordDecl * getMostRecentNonInjectedDecl()
Definition: DeclCXX.h:527
int64_t
long int64_t
Definition: hlsl_basic_types.h:25
clang::BuiltinType::getKind
Kind getKind() const
Definition: Type.h:2598
clang::ThisAdjustment::VirtualAdjustment::isEmpty
bool isEmpty() const
Definition: Thunk.h:124
clang::TemplateArgument::getAsDecl
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:275
clang::ThunkInfo::Method
const CXXMethodDecl * Method
Holds a pointer to the overridden method this thunk is for, if needed by the ABI to distinguish diffe...
Definition: Thunk.h:168
clang::isPtrSizeAddressSpace
bool isPtrSizeAddressSpace(LangAS AS)
Definition: AddressSpaces.h:85
clang::RValueReferenceType
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2885
clang::ObjCMethodDecl
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2712
clang::VarDecl::isExternC
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
Definition: Decl.cpp:2151
clang::DiagnosticsEngine::getCustomDiagID
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:868
clang::IdentifierInfo::getName
StringRef getName() const
Return the actual identifier string.
Definition: IdentifierTable.h:195
clang::MicrosoftVTableContext::getMethodVFTableLocation
MethodVFTableLocation getMethodVFTableLocation(GlobalDecl GD)
Definition: VTableBuilder.cpp:3775
clang::Type::isMemberDataPointerType
bool isMemberDataPointerType() const
Definition: Type.h:6866
clang
Definition: CalledOnceCheck.h:17
clang::Type::isAnyPointerType
bool isAnyPointerType() const
Definition: Type.h:6811
clang::LangAS::ptr64
@ ptr64
clang::VectorType::getElementType
QualType getElementType() const
Definition: Type.h:3342
clang::Type::isArrayType
bool isArrayType() const
Definition: Type.h:6873
clang::LangAS::ptr32_uptr
@ ptr32_uptr
clang::TemplateArgument::getNullPtrType
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
Definition: TemplateBase.h:286
clang::Qualifiers::getObjCLifetime
ObjCLifetime getObjCLifetime() const
Definition: Type.h:352
clang::CC_X86Pascal
@ CC_X86Pascal
Definition: Specifiers.h:269
clang::TemplateArgument::getAsTemplate
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:292
clang::QualType::withConst
QualType withConst() const
Definition: Type.h:905
clang::CC_X86RegCall
@ CC_X86RegCall
Definition: Specifiers.h:272
clang::CC_SwiftAsync
@ CC_SwiftAsync
Definition: Specifiers.h:279
clang::ThisAdjustment::VirtualAdjustment::VBOffsetOffset
int32_t VBOffsetOffset
The offset (in bytes) of the vbase offset in the vbtable.
Definition: Thunk.h:115
clang::CC_PreserveMost
@ CC_PreserveMost
Definition: Specifiers.h:280
clang::ObjCProtocolDecl
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2052
clang::Expr::getType
QualType getType() const
Definition: Expr.h:141
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
clang::FunctionType::getReturnType
QualType getReturnType() const
Definition: Type.h:3880
clang::NamedDecl::getDeclName
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:311
clang::RQ_LValue
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1512
clang::GlobalDecl::getCtorType
CXXCtorType getCtorType() const
Definition: GlobalDecl.h:105
clang::Dtor_Deleting
@ Dtor_Deleting
Deleting dtor.
Definition: ABI.h:34
clang::MSInheritanceModel
MSInheritanceModel
Assigned inheritance model for a class in the MS C++ ABI.
Definition: Specifiers.h:371
clang::ObjCObjectType::isObjCId
bool isObjCId() const
Definition: Type.h:6016
clang::TagDecl::getTagKind
TagKind getTagKind() const
Definition: Decl.h:3552
clang::ObjCProtocolQualifiers::quals
qual_range quals() const
Definition: Type.h:5850
clang::TypedefNameDecl
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3207
clang::StringLiteral::getLength
unsigned getLength() const
Definition: Expr.h:1879
clang::ASTContext::addressSpaceMapManglingFor
bool addressSpaceMapManglingFor(LangAS AS) const
Definition: ASTContext.h:2793
clang::MethodVFTableLocation::VBTableIndex
uint64_t VBTableIndex
If nonzero, holds the vbtable index of the virtual base with the vfptr.
Definition: VTableBuilder.h:512
clang::GlobalDecl::getDecl
const Decl * getDecl() const
Definition: GlobalDecl.h:103
DiagnosticOptions.h
GlobalDecl.h
clang::DependentVectorType
Represents a vector type where either the type or size is dependent.
Definition: Type.h:3380
clang::DependentNameType
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:5625
clang::QualType::getTypePtr
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6559
clang::RecordType::getDecl
RecordDecl * getDecl() const
Definition: Type.h:4716
clang::QualType::getAsOpaquePtr
void * getAsOpaquePtr() const
Definition: Type.h:776
clang::ExtVectorType
ExtVectorType - Extended vector type.
Definition: Type.h:3422
clang::CharUnits
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
clang::PointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2722
clang::VectorType::getNumElements
unsigned getNumElements() const
Definition: Type.h:3343
Mangle.h
clang::Stmt::getStmtClassName
const char * getStmtClassName() const
Definition: Stmt.cpp:77
clang::CXXRecordDecl::isLambda
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:999
clang::APValue
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
clang::AtomicType
Definition: Type.h:6377
clang::MethodVFTableLocation::VFPtrOffset
CharUnits VFPtrOffset
This is the offset of the vfptr from the start of the last vbase, or the complete type if there are n...
Definition: VTableBuilder.h:520
FileManager.h
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:685
clang::CC_X86_64SysV
@ CC_X86_64SysV
Definition: Specifiers.h:271
clang::ArrayType::getElementType
QualType getElementType() const
Definition: Type.h:2976
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::HLSL
@ HLSL
Definition: LangStandard.h:63
clang::MicrosoftMangleContext
Definition: Mangle.h:219
SM
#define SM(sm)
Definition: Cuda.cpp:81
clang::ThisAdjustment
A this pointer adjustment.
Definition: Thunk.h:91
clang::DependentSizedArrayType::getBracketsRange
SourceRange getBracketsRange() const
Definition: Type.h:3187
clang::EnumType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
Definition: Type.h:4732
clang::DeclContext::isFunctionOrMethod
bool isFunctionOrMethod() const
Definition: DeclBase.h:1954
clang::APValue::LValuePathEntry
A non-discriminated union of a base, field, or array index.
Definition: APValue.h:208
clang::ClassTemplateSpecializationDecl
Represents a class template specialization, which refers to a class template with a given set of temp...
Definition: DeclTemplate.h:1829
clang::DependentSizedExtVectorType
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:3261
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:432
clang::TemplateArgumentList::size
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:298
clang::NamespaceDecl
Represent a C++ namespace.
Definition: Decl.h:540
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1872
clang::CXXRecordDecl::getLambdaManglingNumber
unsigned getLambdaManglingNumber() const
If this is the closure type of a lambda expression, retrieve the number to be used for name mangling ...
Definition: DeclCXX.h:1729
clang::DependentBitIntType
Definition: Type.h:6470
clang::ObjCInterfaceType
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:6151
clang::ASTContext::getLangOpts
const LangOptions & getLangOpts() const
Definition: ASTContext.h:787
clang::DecayedType
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2775
clang::CharUnits::getQuantity
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
isTemplate
static GlobalDecl isTemplate(GlobalDecl GD, const TemplateArgumentList *&TemplateArgs)
Definition: MicrosoftMangle.cpp:864
clang::MethodVFTableLocation
Definition: VTableBuilder.h:510
clang::LangAS::ptr32_sptr
@ ptr32_sptr
clang::CXXMethodDecl::isVirtual
bool isVirtual() const
Definition: DeclCXX.h:2025
clang::GlobalDecl::getKernelReferenceKind
KernelReferenceKind getKernelReferenceKind() const
Definition: GlobalDecl.h:132
clang::ento::ObjKind::OS
@ OS
Indicates that the tracking object is a descendant of a referenced-counted OSObject,...
clang::TemplateArgument::getAsType
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:268
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1537
clang::LValueReferenceType
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2867
clang::CXXMethodDecl::getParent
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Definition: DeclCXX.h:2096
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1981
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:441
Type
MatchType Type
Definition: ASTMatchFinder.cpp:71
clang::NamedDecl::getName
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:274