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