clang  6.0.0svn
MicrosoftMangle.cpp
Go to the documentation of this file.
1 //===--- MicrosoftMangle.cpp - Microsoft Visual C++ Name Mangling ---------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This provides C++ name mangling targeting the Microsoft Visual C++ ABI.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/Mangle.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Attr.h"
18 #include "clang/AST/CharUnits.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/DeclOpenMP.h"
23 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
27 #include "clang/Basic/ABI.h"
29 #include "clang/Basic/TargetInfo.h"
30 #include "llvm/ADT/StringExtras.h"
31 #include "llvm/Support/JamCRC.h"
32 #include "llvm/Support/MD5.h"
33 #include "llvm/Support/MathExtras.h"
34 
35 using namespace clang;
36 
37 namespace {
38 
39 struct msvc_hashing_ostream : public llvm::raw_svector_ostream {
40  raw_ostream &OS;
41  llvm::SmallString<64> Buffer;
42 
43  msvc_hashing_ostream(raw_ostream &OS)
44  : llvm::raw_svector_ostream(Buffer), OS(OS) {}
45  ~msvc_hashing_ostream() override {
46  StringRef MangledName = str();
47  bool StartsWithEscape = MangledName.startswith("\01");
48  if (StartsWithEscape)
49  MangledName = MangledName.drop_front(1);
50  if (MangledName.size() <= 4096) {
51  OS << str();
52  return;
53  }
54 
55  llvm::MD5 Hasher;
56  llvm::MD5::MD5Result Hash;
57  Hasher.update(MangledName);
58  Hasher.final(Hash);
59 
60  SmallString<32> HexString;
61  llvm::MD5::stringifyResult(Hash, HexString);
62 
63  if (StartsWithEscape)
64  OS << '\01';
65  OS << "??@" << HexString << '@';
66  }
67 };
68 
69 static const DeclContext *
70 getLambdaDefaultArgumentDeclContext(const Decl *D) {
71  if (const auto *RD = dyn_cast<CXXRecordDecl>(D))
72  if (RD->isLambda())
73  if (const auto *Parm =
74  dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl()))
75  return Parm->getDeclContext();
76  return nullptr;
77 }
78 
79 /// \brief Retrieve the declaration context that should be used when mangling
80 /// the given declaration.
81 static const DeclContext *getEffectiveDeclContext(const Decl *D) {
82  // The ABI assumes that lambda closure types that occur within
83  // default arguments live in the context of the function. However, due to
84  // the way in which Clang parses and creates function declarations, this is
85  // not the case: the lambda closure type ends up living in the context
86  // where the function itself resides, because the function declaration itself
87  // had not yet been created. Fix the context here.
88  if (const auto *LDADC = getLambdaDefaultArgumentDeclContext(D))
89  return LDADC;
90 
91  // Perform the same check for block literals.
92  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
93  if (ParmVarDecl *ContextParam =
94  dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl()))
95  return ContextParam->getDeclContext();
96  }
97 
98  const DeclContext *DC = D->getDeclContext();
99  if (isa<CapturedDecl>(DC) || isa<OMPDeclareReductionDecl>(DC)) {
100  return getEffectiveDeclContext(cast<Decl>(DC));
101  }
102 
103  return DC->getRedeclContext();
104 }
105 
106 static const DeclContext *getEffectiveParentContext(const DeclContext *DC) {
107  return getEffectiveDeclContext(cast<Decl>(DC));
108 }
109 
110 static const FunctionDecl *getStructor(const NamedDecl *ND) {
111  if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(ND))
112  return FTD->getTemplatedDecl()->getCanonicalDecl();
113 
114  const auto *FD = cast<FunctionDecl>(ND);
115  if (const auto *FTD = FD->getPrimaryTemplate())
116  return FTD->getTemplatedDecl()->getCanonicalDecl();
117 
118  return FD->getCanonicalDecl();
119 }
120 
121 /// MicrosoftMangleContextImpl - Overrides the default MangleContext for the
122 /// Microsoft Visual C++ ABI.
123 class MicrosoftMangleContextImpl : public MicrosoftMangleContext {
124  typedef std::pair<const DeclContext *, IdentifierInfo *> DiscriminatorKeyTy;
125  llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator;
126  llvm::DenseMap<const NamedDecl *, unsigned> Uniquifier;
127  llvm::DenseMap<const CXXRecordDecl *, unsigned> LambdaIds;
128  llvm::DenseMap<const NamedDecl *, unsigned> SEHFilterIds;
129  llvm::DenseMap<const NamedDecl *, unsigned> SEHFinallyIds;
130 
131 public:
132  MicrosoftMangleContextImpl(ASTContext &Context, DiagnosticsEngine &Diags)
133  : MicrosoftMangleContext(Context, Diags) {}
134  bool shouldMangleCXXName(const NamedDecl *D) override;
135  bool shouldMangleStringLiteral(const StringLiteral *SL) override;
136  void mangleCXXName(const NamedDecl *D, raw_ostream &Out) override;
137  void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD,
138  raw_ostream &) override;
139  void mangleThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk,
140  raw_ostream &) override;
141  void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type,
143  raw_ostream &) override;
144  void mangleCXXVFTable(const CXXRecordDecl *Derived,
146  raw_ostream &Out) override;
147  void mangleCXXVBTable(const CXXRecordDecl *Derived,
149  raw_ostream &Out) override;
150  void mangleCXXVirtualDisplacementMap(const CXXRecordDecl *SrcRD,
151  const CXXRecordDecl *DstRD,
152  raw_ostream &Out) override;
153  void mangleCXXThrowInfo(QualType T, bool IsConst, bool IsVolatile,
154  bool IsUnaligned, uint32_t NumEntries,
155  raw_ostream &Out) override;
156  void mangleCXXCatchableTypeArray(QualType T, uint32_t NumEntries,
157  raw_ostream &Out) override;
158  void mangleCXXCatchableType(QualType T, const CXXConstructorDecl *CD,
159  CXXCtorType CT, uint32_t Size, uint32_t NVOffset,
160  int32_t VBPtrOffset, uint32_t VBIndex,
161  raw_ostream &Out) override;
162  void mangleCXXRTTI(QualType T, raw_ostream &Out) override;
163  void mangleCXXRTTIName(QualType T, raw_ostream &Out) override;
164  void mangleCXXRTTIBaseClassDescriptor(const CXXRecordDecl *Derived,
165  uint32_t NVOffset, int32_t VBPtrOffset,
166  uint32_t VBTableOffset, uint32_t Flags,
167  raw_ostream &Out) override;
168  void mangleCXXRTTIBaseClassArray(const CXXRecordDecl *Derived,
169  raw_ostream &Out) override;
170  void mangleCXXRTTIClassHierarchyDescriptor(const CXXRecordDecl *Derived,
171  raw_ostream &Out) override;
172  void
173  mangleCXXRTTICompleteObjectLocator(const CXXRecordDecl *Derived,
175  raw_ostream &Out) override;
176  void mangleTypeName(QualType T, raw_ostream &) override;
177  void mangleCXXCtor(const CXXConstructorDecl *D, CXXCtorType Type,
178  raw_ostream &) override;
179  void mangleCXXDtor(const CXXDestructorDecl *D, CXXDtorType Type,
180  raw_ostream &) override;
181  void mangleReferenceTemporary(const VarDecl *, unsigned ManglingNumber,
182  raw_ostream &) override;
183  void mangleStaticGuardVariable(const VarDecl *D, raw_ostream &Out) override;
184  void mangleThreadSafeStaticGuardVariable(const VarDecl *D, unsigned GuardNum,
185  raw_ostream &Out) override;
186  void mangleDynamicInitializer(const VarDecl *D, raw_ostream &Out) override;
187  void mangleDynamicAtExitDestructor(const VarDecl *D,
188  raw_ostream &Out) override;
189  void mangleSEHFilterExpression(const NamedDecl *EnclosingDecl,
190  raw_ostream &Out) override;
191  void mangleSEHFinallyBlock(const NamedDecl *EnclosingDecl,
192  raw_ostream &Out) override;
193  void mangleStringLiteral(const StringLiteral *SL, raw_ostream &Out) override;
194  bool getNextDiscriminator(const NamedDecl *ND, unsigned &disc) {
195  const DeclContext *DC = getEffectiveDeclContext(ND);
196  if (!DC->isFunctionOrMethod())
197  return false;
198 
199  // Lambda closure types are already numbered, give out a phony number so
200  // that they demangle nicely.
201  if (const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
202  if (RD->isLambda()) {
203  disc = 1;
204  return true;
205  }
206  }
207 
208  // Use the canonical number for externally visible decls.
209  if (ND->isExternallyVisible()) {
210  disc = getASTContext().getManglingNumber(ND);
211  return true;
212  }
213 
214  // Anonymous tags are already numbered.
215  if (const TagDecl *Tag = dyn_cast<TagDecl>(ND)) {
216  if (!Tag->hasNameForLinkage() &&
217  !getASTContext().getDeclaratorForUnnamedTagDecl(Tag) &&
218  !getASTContext().getTypedefNameForUnnamedTagDecl(Tag))
219  return false;
220  }
221 
222  // Make up a reasonable number for internal decls.
223  unsigned &discriminator = Uniquifier[ND];
224  if (!discriminator)
225  discriminator = ++Discriminator[std::make_pair(DC, ND->getIdentifier())];
226  disc = discriminator + 1;
227  return true;
228  }
229 
230  unsigned getLambdaId(const CXXRecordDecl *RD) {
231  assert(RD->isLambda() && "RD must be a lambda!");
232  assert(!RD->isExternallyVisible() && "RD must not be visible!");
233  assert(RD->getLambdaManglingNumber() == 0 &&
234  "RD must not have a mangling number!");
235  std::pair<llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator, bool>
236  Result = LambdaIds.insert(std::make_pair(RD, LambdaIds.size()));
237  return Result.first->second;
238  }
239 
240 private:
241  void mangleInitFiniStub(const VarDecl *D, char CharCode, raw_ostream &Out);
242 };
243 
244 /// MicrosoftCXXNameMangler - Manage the mangling of a single name for the
245 /// Microsoft Visual C++ ABI.
246 class MicrosoftCXXNameMangler {
247  MicrosoftMangleContextImpl &Context;
248  raw_ostream &Out;
249 
250  /// The "structor" is the top-level declaration being mangled, if
251  /// that's not a template specialization; otherwise it's the pattern
252  /// for that specialization.
253  const NamedDecl *Structor;
254  unsigned StructorType;
255 
256  typedef llvm::SmallVector<std::string, 10> BackRefVec;
257  BackRefVec NameBackReferences;
258 
259  typedef llvm::DenseMap<const void *, unsigned> ArgBackRefMap;
260  ArgBackRefMap TypeBackReferences;
261 
262  typedef std::set<int> PassObjectSizeArgsSet;
263  PassObjectSizeArgsSet PassObjectSizeArgs;
264 
265  ASTContext &getASTContext() const { return Context.getASTContext(); }
266 
267  // FIXME: If we add support for __ptr32/64 qualifiers, then we should push
268  // this check into mangleQualifiers().
269  const bool PointersAre64Bit;
270 
271 public:
272  enum QualifierMangleMode { QMM_Drop, QMM_Mangle, QMM_Escape, QMM_Result };
273 
274  MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_)
275  : Context(C), Out(Out_), Structor(nullptr), StructorType(-1),
276  PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
277  64) {}
278 
279  MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_,
281  : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
282  PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
283  64) {}
284 
285  MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_,
287  : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
288  PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
289  64) {}
290 
291  raw_ostream &getStream() const { return Out; }
292 
293  void mangle(const NamedDecl *D, StringRef Prefix = "\01?");
294  void mangleName(const NamedDecl *ND);
295  void mangleFunctionEncoding(const FunctionDecl *FD, bool ShouldMangle);
296  void mangleVariableEncoding(const VarDecl *VD);
297  void mangleMemberDataPointer(const CXXRecordDecl *RD, const ValueDecl *VD);
298  void mangleMemberFunctionPointer(const CXXRecordDecl *RD,
299  const CXXMethodDecl *MD);
300  void mangleVirtualMemPtrThunk(
301  const CXXMethodDecl *MD,
303  void mangleNumber(int64_t Number);
304  void mangleTagTypeKind(TagTypeKind TK);
305  void mangleArtificalTagType(TagTypeKind TK, StringRef UnqualifiedName,
306  ArrayRef<StringRef> NestedNames = None);
307  void mangleType(QualType T, SourceRange Range,
308  QualifierMangleMode QMM = QMM_Mangle);
309  void mangleFunctionType(const FunctionType *T,
310  const FunctionDecl *D = nullptr,
311  bool ForceThisQuals = false);
312  void mangleNestedName(const NamedDecl *ND);
313 
314 private:
315  bool isStructorDecl(const NamedDecl *ND) const {
316  return ND == Structor || getStructor(ND) == Structor;
317  }
318 
319  void mangleUnqualifiedName(const NamedDecl *ND) {
320  mangleUnqualifiedName(ND, ND->getDeclName());
321  }
322  void mangleUnqualifiedName(const NamedDecl *ND, DeclarationName Name);
323  void mangleSourceName(StringRef Name);
324  void mangleOperatorName(OverloadedOperatorKind OO, SourceLocation Loc);
325  void mangleCXXDtorType(CXXDtorType T);
326  void mangleQualifiers(Qualifiers Quals, bool IsMember);
327  void mangleRefQualifier(RefQualifierKind RefQualifier);
328  void manglePointerCVQualifiers(Qualifiers Quals);
329  void manglePointerExtQualifiers(Qualifiers Quals, QualType PointeeType);
330 
331  void mangleUnscopedTemplateName(const TemplateDecl *ND);
332  void
333  mangleTemplateInstantiationName(const TemplateDecl *TD,
334  const TemplateArgumentList &TemplateArgs);
335  void mangleObjCMethodName(const ObjCMethodDecl *MD);
336 
337  void mangleArgumentType(QualType T, SourceRange Range);
338  void manglePassObjectSizeArg(const PassObjectSizeAttr *POSA);
339 
340  // Declare manglers for every type class.
341 #define ABSTRACT_TYPE(CLASS, PARENT)
342 #define NON_CANONICAL_TYPE(CLASS, PARENT)
343 #define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T, \
344  Qualifiers Quals, \
345  SourceRange Range);
346 #include "clang/AST/TypeNodes.def"
347 #undef ABSTRACT_TYPE
348 #undef NON_CANONICAL_TYPE
349 #undef TYPE
350 
351  void mangleType(const TagDecl *TD);
352  void mangleDecayedArrayType(const ArrayType *T);
353  void mangleArrayType(const ArrayType *T);
354  void mangleFunctionClass(const FunctionDecl *FD);
355  void mangleCallingConvention(CallingConv CC);
356  void mangleCallingConvention(const FunctionType *T);
357  void mangleIntegerLiteral(const llvm::APSInt &Number, bool IsBoolean);
358  void mangleExpression(const Expr *E);
359  void mangleThrowSpecification(const FunctionProtoType *T);
360 
361  void mangleTemplateArgs(const TemplateDecl *TD,
362  const TemplateArgumentList &TemplateArgs);
363  void mangleTemplateArg(const TemplateDecl *TD, const TemplateArgument &TA,
364  const NamedDecl *Parm);
365 };
366 }
367 
368 bool MicrosoftMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) {
369  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
370  LanguageLinkage L = FD->getLanguageLinkage();
371  // Overloadable functions need mangling.
372  if (FD->hasAttr<OverloadableAttr>())
373  return true;
374 
375  // The ABI expects that we would never mangle "typical" user-defined entry
376  // points regardless of visibility or freestanding-ness.
377  //
378  // N.B. This is distinct from asking about "main". "main" has a lot of
379  // special rules associated with it in the standard while these
380  // user-defined entry points are outside of the purview of the standard.
381  // For example, there can be only one definition for "main" in a standards
382  // compliant program; however nothing forbids the existence of wmain and
383  // WinMain in the same translation unit.
384  if (FD->isMSVCRTEntryPoint())
385  return false;
386 
387  // C++ functions and those whose names are not a simple identifier need
388  // mangling.
389  if (!FD->getDeclName().isIdentifier() || L == CXXLanguageLinkage)
390  return true;
391 
392  // C functions are not mangled.
393  if (L == CLanguageLinkage)
394  return false;
395  }
396 
397  // Otherwise, no mangling is done outside C++ mode.
398  if (!getASTContext().getLangOpts().CPlusPlus)
399  return false;
400 
401  const VarDecl *VD = dyn_cast<VarDecl>(D);
402  if (VD && !isa<DecompositionDecl>(D)) {
403  // C variables are not mangled.
404  if (VD->isExternC())
405  return false;
406 
407  // Variables at global scope with non-internal linkage are not mangled.
408  const DeclContext *DC = getEffectiveDeclContext(D);
409  // Check for extern variable declared locally.
410  if (DC->isFunctionOrMethod() && D->hasLinkage())
411  while (!DC->isNamespace() && !DC->isTranslationUnit())
412  DC = getEffectiveParentContext(DC);
413 
414  if (DC->isTranslationUnit() && D->getFormalLinkage() == InternalLinkage &&
415  !isa<VarTemplateSpecializationDecl>(D) &&
416  D->getIdentifier() != nullptr)
417  return false;
418  }
419 
420  return true;
421 }
422 
423 bool
424 MicrosoftMangleContextImpl::shouldMangleStringLiteral(const StringLiteral *SL) {
425  return true;
426 }
427 
428 void MicrosoftCXXNameMangler::mangle(const NamedDecl *D, StringRef Prefix) {
429  // MSVC doesn't mangle C++ names the same way it mangles extern "C" names.
430  // Therefore it's really important that we don't decorate the
431  // name with leading underscores or leading/trailing at signs. So, by
432  // default, we emit an asm marker at the start so we get the name right.
433  // Callers can override this with a custom prefix.
434 
435  // <mangled-name> ::= ? <name> <type-encoding>
436  Out << Prefix;
437  mangleName(D);
438  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
439  mangleFunctionEncoding(FD, Context.shouldMangleDeclName(FD));
440  else if (const VarDecl *VD = dyn_cast<VarDecl>(D))
441  mangleVariableEncoding(VD);
442  else
443  llvm_unreachable("Tried to mangle unexpected NamedDecl!");
444 }
445 
446 void MicrosoftCXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD,
447  bool ShouldMangle) {
448  // <type-encoding> ::= <function-class> <function-type>
449 
450  // Since MSVC operates on the type as written and not the canonical type, it
451  // actually matters which decl we have here. MSVC appears to choose the
452  // first, since it is most likely to be the declaration in a header file.
453  FD = FD->getFirstDecl();
454 
455  // We should never ever see a FunctionNoProtoType at this point.
456  // We don't even know how to mangle their types anyway :).
457  const FunctionProtoType *FT = FD->getType()->castAs<FunctionProtoType>();
458 
459  // extern "C" functions can hold entities that must be mangled.
460  // As it stands, these functions still need to get expressed in the full
461  // external name. They have their class and type omitted, replaced with '9'.
462  if (ShouldMangle) {
463  // We would like to mangle all extern "C" functions using this additional
464  // component but this would break compatibility with MSVC's behavior.
465  // Instead, do this when we know that compatibility isn't important (in
466  // other words, when it is an overloaded extern "C" function).
467  if (FD->isExternC() && FD->hasAttr<OverloadableAttr>())
468  Out << "$$J0";
469 
470  mangleFunctionClass(FD);
471 
472  mangleFunctionType(FT, FD);
473  } else {
474  Out << '9';
475  }
476 }
477 
478 void MicrosoftCXXNameMangler::mangleVariableEncoding(const VarDecl *VD) {
479  // <type-encoding> ::= <storage-class> <variable-type>
480  // <storage-class> ::= 0 # private static member
481  // ::= 1 # protected static member
482  // ::= 2 # public static member
483  // ::= 3 # global
484  // ::= 4 # static local
485 
486  // The first character in the encoding (after the name) is the storage class.
487  if (VD->isStaticDataMember()) {
488  // If it's a static member, it also encodes the access level.
489  switch (VD->getAccess()) {
490  default:
491  case AS_private: Out << '0'; break;
492  case AS_protected: Out << '1'; break;
493  case AS_public: Out << '2'; break;
494  }
495  }
496  else if (!VD->isStaticLocal())
497  Out << '3';
498  else
499  Out << '4';
500  // Now mangle the type.
501  // <variable-type> ::= <type> <cvr-qualifiers>
502  // ::= <type> <pointee-cvr-qualifiers> # pointers, references
503  // Pointers and references are odd. The type of 'int * const foo;' gets
504  // mangled as 'QAHA' instead of 'PAHB', for example.
505  SourceRange SR = VD->getSourceRange();
506  QualType Ty = VD->getType();
507  if (Ty->isPointerType() || Ty->isReferenceType() ||
508  Ty->isMemberPointerType()) {
509  mangleType(Ty, SR, QMM_Drop);
510  manglePointerExtQualifiers(
511  Ty.getDesugaredType(getASTContext()).getLocalQualifiers(), QualType());
512  if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) {
513  mangleQualifiers(MPT->getPointeeType().getQualifiers(), true);
514  // Member pointers are suffixed with a back reference to the member
515  // pointer's class name.
516  mangleName(MPT->getClass()->getAsCXXRecordDecl());
517  } else
518  mangleQualifiers(Ty->getPointeeType().getQualifiers(), false);
519  } else if (const ArrayType *AT = getASTContext().getAsArrayType(Ty)) {
520  // Global arrays are funny, too.
521  mangleDecayedArrayType(AT);
522  if (AT->getElementType()->isArrayType())
523  Out << 'A';
524  else
525  mangleQualifiers(Ty.getQualifiers(), false);
526  } else {
527  mangleType(Ty, SR, QMM_Drop);
528  mangleQualifiers(Ty.getQualifiers(), false);
529  }
530 }
531 
532 void MicrosoftCXXNameMangler::mangleMemberDataPointer(const CXXRecordDecl *RD,
533  const ValueDecl *VD) {
534  // <member-data-pointer> ::= <integer-literal>
535  // ::= $F <number> <number>
536  // ::= $G <number> <number> <number>
537 
538  int64_t FieldOffset;
539  int64_t VBTableOffset;
540  MSInheritanceAttr::Spelling IM = RD->getMSInheritanceModel();
541  if (VD) {
542  FieldOffset = getASTContext().getFieldOffset(VD);
543  assert(FieldOffset % getASTContext().getCharWidth() == 0 &&
544  "cannot take address of bitfield");
545  FieldOffset /= getASTContext().getCharWidth();
546 
547  VBTableOffset = 0;
548 
549  if (IM == MSInheritanceAttr::Keyword_virtual_inheritance)
550  FieldOffset -= getASTContext().getOffsetOfBaseWithVBPtr(RD).getQuantity();
551  } else {
552  FieldOffset = RD->nullFieldOffsetIsZero() ? 0 : -1;
553 
554  VBTableOffset = -1;
555  }
556 
557  char Code = '\0';
558  switch (IM) {
559  case MSInheritanceAttr::Keyword_single_inheritance: Code = '0'; break;
560  case MSInheritanceAttr::Keyword_multiple_inheritance: Code = '0'; break;
561  case MSInheritanceAttr::Keyword_virtual_inheritance: Code = 'F'; break;
562  case MSInheritanceAttr::Keyword_unspecified_inheritance: Code = 'G'; break;
563  }
564 
565  Out << '$' << Code;
566 
567  mangleNumber(FieldOffset);
568 
569  // The C++ standard doesn't allow base-to-derived member pointer conversions
570  // in template parameter contexts, so the vbptr offset of data member pointers
571  // is always zero.
572  if (MSInheritanceAttr::hasVBPtrOffsetField(IM))
573  mangleNumber(0);
574  if (MSInheritanceAttr::hasVBTableOffsetField(IM))
575  mangleNumber(VBTableOffset);
576 }
577 
578 void
579 MicrosoftCXXNameMangler::mangleMemberFunctionPointer(const CXXRecordDecl *RD,
580  const CXXMethodDecl *MD) {
581  // <member-function-pointer> ::= $1? <name>
582  // ::= $H? <name> <number>
583  // ::= $I? <name> <number> <number>
584  // ::= $J? <name> <number> <number> <number>
585 
586  MSInheritanceAttr::Spelling IM = RD->getMSInheritanceModel();
587 
588  char Code = '\0';
589  switch (IM) {
590  case MSInheritanceAttr::Keyword_single_inheritance: Code = '1'; break;
591  case MSInheritanceAttr::Keyword_multiple_inheritance: Code = 'H'; break;
592  case MSInheritanceAttr::Keyword_virtual_inheritance: Code = 'I'; break;
593  case MSInheritanceAttr::Keyword_unspecified_inheritance: Code = 'J'; break;
594  }
595 
596  // If non-virtual, mangle the name. If virtual, mangle as a virtual memptr
597  // thunk.
598  uint64_t NVOffset = 0;
599  uint64_t VBTableOffset = 0;
600  uint64_t VBPtrOffset = 0;
601  if (MD) {
602  Out << '$' << Code << '?';
603  if (MD->isVirtual()) {
604  MicrosoftVTableContext *VTContext =
605  cast<MicrosoftVTableContext>(getASTContext().getVTableContext());
607  VTContext->getMethodVFTableLocation(GlobalDecl(MD));
608  mangleVirtualMemPtrThunk(MD, ML);
609  NVOffset = ML.VFPtrOffset.getQuantity();
610  VBTableOffset = ML.VBTableIndex * 4;
611  if (ML.VBase) {
612  const ASTRecordLayout &Layout = getASTContext().getASTRecordLayout(RD);
613  VBPtrOffset = Layout.getVBPtrOffset().getQuantity();
614  }
615  } else {
616  mangleName(MD);
617  mangleFunctionEncoding(MD, /*ShouldMangle=*/true);
618  }
619 
620  if (VBTableOffset == 0 &&
621  IM == MSInheritanceAttr::Keyword_virtual_inheritance)
622  NVOffset -= getASTContext().getOffsetOfBaseWithVBPtr(RD).getQuantity();
623  } else {
624  // Null single inheritance member functions are encoded as a simple nullptr.
625  if (IM == MSInheritanceAttr::Keyword_single_inheritance) {
626  Out << "$0A@";
627  return;
628  }
629  if (IM == MSInheritanceAttr::Keyword_unspecified_inheritance)
630  VBTableOffset = -1;
631  Out << '$' << Code;
632  }
633 
634  if (MSInheritanceAttr::hasNVOffsetField(/*IsMemberFunction=*/true, IM))
635  mangleNumber(static_cast<uint32_t>(NVOffset));
636  if (MSInheritanceAttr::hasVBPtrOffsetField(IM))
637  mangleNumber(VBPtrOffset);
638  if (MSInheritanceAttr::hasVBTableOffsetField(IM))
639  mangleNumber(VBTableOffset);
640 }
641 
642 void MicrosoftCXXNameMangler::mangleVirtualMemPtrThunk(
643  const CXXMethodDecl *MD,
645  // Get the vftable offset.
646  CharUnits PointerWidth = getASTContext().toCharUnitsFromBits(
647  getASTContext().getTargetInfo().getPointerWidth(0));
648  uint64_t OffsetInVFTable = ML.Index * PointerWidth.getQuantity();
649 
650  Out << "?_9";
651  mangleName(MD->getParent());
652  Out << "$B";
653  mangleNumber(OffsetInVFTable);
654  Out << 'A';
655  mangleCallingConvention(MD->getType()->getAs<FunctionProtoType>());
656 }
657 
658 void MicrosoftCXXNameMangler::mangleName(const NamedDecl *ND) {
659  // <name> ::= <unscoped-name> {[<named-scope>]+ | [<nested-name>]}? @
660 
661  // Always start with the unqualified name.
662  mangleUnqualifiedName(ND);
663 
664  mangleNestedName(ND);
665 
666  // Terminate the whole name with an '@'.
667  Out << '@';
668 }
669 
670 void MicrosoftCXXNameMangler::mangleNumber(int64_t Number) {
671  // <non-negative integer> ::= A@ # when Number == 0
672  // ::= <decimal digit> # when 1 <= Number <= 10
673  // ::= <hex digit>+ @ # when Number >= 10
674  //
675  // <number> ::= [?] <non-negative integer>
676 
677  uint64_t Value = static_cast<uint64_t>(Number);
678  if (Number < 0) {
679  Value = -Value;
680  Out << '?';
681  }
682 
683  if (Value == 0)
684  Out << "A@";
685  else if (Value >= 1 && Value <= 10)
686  Out << (Value - 1);
687  else {
688  // Numbers that are not encoded as decimal digits are represented as nibbles
689  // in the range of ASCII characters 'A' to 'P'.
690  // The number 0x123450 would be encoded as 'BCDEFA'
691  char EncodedNumberBuffer[sizeof(uint64_t) * 2];
692  MutableArrayRef<char> BufferRef(EncodedNumberBuffer);
693  MutableArrayRef<char>::reverse_iterator I = BufferRef.rbegin();
694  for (; Value != 0; Value >>= 4)
695  *I++ = 'A' + (Value & 0xf);
696  Out.write(I.base(), I - BufferRef.rbegin());
697  Out << '@';
698  }
699 }
700 
701 static const TemplateDecl *
702 isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs) {
703  // Check if we have a function template.
704  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
705  if (const TemplateDecl *TD = FD->getPrimaryTemplate()) {
706  TemplateArgs = FD->getTemplateSpecializationArgs();
707  return TD;
708  }
709  }
710 
711  // Check if we have a class template.
712  if (const ClassTemplateSpecializationDecl *Spec =
713  dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
714  TemplateArgs = &Spec->getTemplateArgs();
715  return Spec->getSpecializedTemplate();
716  }
717 
718  // Check if we have a variable template.
719  if (const VarTemplateSpecializationDecl *Spec =
720  dyn_cast<VarTemplateSpecializationDecl>(ND)) {
721  TemplateArgs = &Spec->getTemplateArgs();
722  return Spec->getSpecializedTemplate();
723  }
724 
725  return nullptr;
726 }
727 
728 void MicrosoftCXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND,
729  DeclarationName Name) {
730  // <unqualified-name> ::= <operator-name>
731  // ::= <ctor-dtor-name>
732  // ::= <source-name>
733  // ::= <template-name>
734 
735  // Check if we have a template.
736  const TemplateArgumentList *TemplateArgs = nullptr;
737  if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
738  // Function templates aren't considered for name back referencing. This
739  // makes sense since function templates aren't likely to occur multiple
740  // times in a symbol.
741  if (isa<FunctionTemplateDecl>(TD)) {
742  mangleTemplateInstantiationName(TD, *TemplateArgs);
743  Out << '@';
744  return;
745  }
746 
747  // Here comes the tricky thing: if we need to mangle something like
748  // void foo(A::X<Y>, B::X<Y>),
749  // the X<Y> part is aliased. However, if you need to mangle
750  // void foo(A::X<A::Y>, A::X<B::Y>),
751  // the A::X<> part is not aliased.
752  // That said, from the mangler's perspective we have a structure like this:
753  // namespace[s] -> type[ -> template-parameters]
754  // but from the Clang perspective we have
755  // type [ -> template-parameters]
756  // \-> namespace[s]
757  // What we do is we create a new mangler, mangle the same type (without
758  // a namespace suffix) to a string using the extra mangler and then use
759  // the mangled type name as a key to check the mangling of different types
760  // for aliasing.
761 
762  llvm::SmallString<64> TemplateMangling;
763  llvm::raw_svector_ostream Stream(TemplateMangling);
764  MicrosoftCXXNameMangler Extra(Context, Stream);
765  Extra.mangleTemplateInstantiationName(TD, *TemplateArgs);
766 
767  mangleSourceName(TemplateMangling);
768  return;
769  }
770 
771  switch (Name.getNameKind()) {
773  if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) {
774  mangleSourceName(II->getName());
775  break;
776  }
777 
778  // Otherwise, an anonymous entity. We must have a declaration.
779  assert(ND && "mangling empty name without declaration");
780 
781  if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
782  if (NS->isAnonymousNamespace()) {
783  Out << "?A@";
784  break;
785  }
786  }
787 
788  if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(ND)) {
789  // FIXME: Invented mangling for decomposition declarations:
790  // [X,Y,Z]
791  // where X,Y,Z are the names of the bindings.
792  llvm::SmallString<128> Name("[");
793  for (auto *BD : DD->bindings()) {
794  if (Name.size() > 1)
795  Name += ',';
796  Name += BD->getDeclName().getAsIdentifierInfo()->getName();
797  }
798  Name += ']';
799  mangleSourceName(Name);
800  break;
801  }
802 
803  if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
804  // We must have an anonymous union or struct declaration.
805  const CXXRecordDecl *RD = VD->getType()->getAsCXXRecordDecl();
806  assert(RD && "expected variable decl to have a record type");
807  // Anonymous types with no tag or typedef get the name of their
808  // declarator mangled in. If they have no declarator, number them with
809  // a $S prefix.
810  llvm::SmallString<64> Name("$S");
811  // Get a unique id for the anonymous struct.
812  Name += llvm::utostr(Context.getAnonymousStructId(RD) + 1);
813  mangleSourceName(Name.str());
814  break;
815  }
816 
817  // We must have an anonymous struct.
818  const TagDecl *TD = cast<TagDecl>(ND);
819  if (const TypedefNameDecl *D = TD->getTypedefNameForAnonDecl()) {
820  assert(TD->getDeclContext() == D->getDeclContext() &&
821  "Typedef should not be in another decl context!");
822  assert(D->getDeclName().getAsIdentifierInfo() &&
823  "Typedef was not named!");
824  mangleSourceName(D->getDeclName().getAsIdentifierInfo()->getName());
825  break;
826  }
827 
828  if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) {
829  if (Record->isLambda()) {
830  llvm::SmallString<10> Name("<lambda_");
831 
832  Decl *LambdaContextDecl = Record->getLambdaContextDecl();
833  unsigned LambdaManglingNumber = Record->getLambdaManglingNumber();
834  unsigned LambdaId;
835  const ParmVarDecl *Parm =
836  dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
837  const FunctionDecl *Func =
838  Parm ? dyn_cast<FunctionDecl>(Parm->getDeclContext()) : nullptr;
839 
840  if (Func) {
841  unsigned DefaultArgNo =
842  Func->getNumParams() - Parm->getFunctionScopeIndex();
843  Name += llvm::utostr(DefaultArgNo);
844  Name += "_";
845  }
846 
847  if (LambdaManglingNumber)
848  LambdaId = LambdaManglingNumber;
849  else
850  LambdaId = Context.getLambdaId(Record);
851 
852  Name += llvm::utostr(LambdaId);
853  Name += ">";
854 
855  mangleSourceName(Name);
856 
857  // If the context of a closure type is an initializer for a class
858  // member (static or nonstatic), it is encoded in a qualified name.
859  if (LambdaManglingNumber && LambdaContextDecl) {
860  if ((isa<VarDecl>(LambdaContextDecl) ||
861  isa<FieldDecl>(LambdaContextDecl)) &&
862  LambdaContextDecl->getDeclContext()->isRecord()) {
863  mangleUnqualifiedName(cast<NamedDecl>(LambdaContextDecl));
864  }
865  }
866  break;
867  }
868  }
869 
871  if (DeclaratorDecl *DD =
872  Context.getASTContext().getDeclaratorForUnnamedTagDecl(TD)) {
873  // Anonymous types without a name for linkage purposes have their
874  // declarator mangled in if they have one.
875  Name += "<unnamed-type-";
876  Name += DD->getName();
877  } else if (TypedefNameDecl *TND =
878  Context.getASTContext().getTypedefNameForUnnamedTagDecl(
879  TD)) {
880  // Anonymous types without a name for linkage purposes have their
881  // associate typedef mangled in if they have one.
882  Name += "<unnamed-type-";
883  Name += TND->getName();
884  } else if (auto *ED = dyn_cast<EnumDecl>(TD)) {
885  auto EnumeratorI = ED->enumerator_begin();
886  assert(EnumeratorI != ED->enumerator_end());
887  Name += "<unnamed-enum-";
888  Name += EnumeratorI->getName();
889  } else {
890  // Otherwise, number the types using a $S prefix.
891  Name += "<unnamed-type-$S";
892  Name += llvm::utostr(Context.getAnonymousStructId(TD) + 1);
893  }
894  Name += ">";
895  mangleSourceName(Name.str());
896  break;
897  }
898 
902  llvm_unreachable("Can't mangle Objective-C selector names here!");
903 
905  if (isStructorDecl(ND)) {
906  if (StructorType == Ctor_CopyingClosure) {
907  Out << "?_O";
908  return;
909  }
910  if (StructorType == Ctor_DefaultClosure) {
911  Out << "?_F";
912  return;
913  }
914  }
915  Out << "?0";
916  return;
917 
919  if (isStructorDecl(ND))
920  // If the named decl is the C++ destructor we're mangling,
921  // use the type we were given.
922  mangleCXXDtorType(static_cast<CXXDtorType>(StructorType));
923  else
924  // Otherwise, use the base destructor name. This is relevant if a
925  // class with a destructor is declared within a destructor.
926  mangleCXXDtorType(Dtor_Base);
927  break;
928 
930  // <operator-name> ::= ?B # (cast)
931  // The target type is encoded as the return type.
932  Out << "?B";
933  break;
934 
936  mangleOperatorName(Name.getCXXOverloadedOperator(), ND->getLocation());
937  break;
938 
940  Out << "?__K";
941  mangleSourceName(Name.getCXXLiteralIdentifier()->getName());
942  break;
943  }
944 
946  llvm_unreachable("Can't mangle a deduction guide name!");
947 
949  llvm_unreachable("Can't mangle a using directive name!");
950  }
951 }
952 
953 void MicrosoftCXXNameMangler::mangleNestedName(const NamedDecl *ND) {
954  // <postfix> ::= <unqualified-name> [<postfix>]
955  // ::= <substitution> [<postfix>]
956  const DeclContext *DC = getEffectiveDeclContext(ND);
957 
958  while (!DC->isTranslationUnit()) {
959  if (isa<TagDecl>(ND) || isa<VarDecl>(ND)) {
960  unsigned Disc;
961  if (Context.getNextDiscriminator(ND, Disc)) {
962  Out << '?';
963  mangleNumber(Disc);
964  Out << '?';
965  }
966  }
967 
968  if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) {
969  auto Discriminate =
970  [](StringRef Name, const unsigned Discriminator,
971  const unsigned ParameterDiscriminator) -> std::string {
972  std::string Buffer;
973  llvm::raw_string_ostream Stream(Buffer);
974  Stream << Name;
975  if (Discriminator)
976  Stream << '_' << Discriminator;
977  if (ParameterDiscriminator)
978  Stream << '_' << ParameterDiscriminator;
979  return Stream.str();
980  };
981 
982  unsigned Discriminator = BD->getBlockManglingNumber();
983  if (!Discriminator)
984  Discriminator = Context.getBlockId(BD, /*Local=*/false);
985 
986  // Mangle the parameter position as a discriminator to deal with unnamed
987  // parameters. Rather than mangling the unqualified parameter name,
988  // always use the position to give a uniform mangling.
989  unsigned ParameterDiscriminator = 0;
990  if (const auto *MC = BD->getBlockManglingContextDecl())
991  if (const auto *P = dyn_cast<ParmVarDecl>(MC))
992  if (const auto *F = dyn_cast<FunctionDecl>(P->getDeclContext()))
993  ParameterDiscriminator =
994  F->getNumParams() - P->getFunctionScopeIndex();
995 
996  DC = getEffectiveDeclContext(BD);
997 
998  Out << '?';
999  mangleSourceName(Discriminate("_block_invoke", Discriminator,
1000  ParameterDiscriminator));
1001  // If we have a block mangling context, encode that now. This allows us
1002  // to discriminate between named static data initializers in the same
1003  // scope. This is handled differently from parameters, which use
1004  // positions to discriminate between multiple instances.
1005  if (const auto *MC = BD->getBlockManglingContextDecl())
1006  if (!isa<ParmVarDecl>(MC))
1007  if (const auto *ND = dyn_cast<NamedDecl>(MC))
1008  mangleUnqualifiedName(ND);
1009  // MS ABI and Itanium manglings are in inverted scopes. In the case of a
1010  // RecordDecl, mangle the entire scope hierachy at this point rather than
1011  // just the unqualified name to get the ordering correct.
1012  if (const auto *RD = dyn_cast<RecordDecl>(DC))
1013  mangleName(RD);
1014  else
1015  Out << '@';
1016  // void __cdecl
1017  Out << "YAX";
1018  // struct __block_literal *
1019  Out << 'P';
1020  // __ptr64
1021  if (PointersAre64Bit)
1022  Out << 'E';
1023  Out << 'A';
1024  mangleArtificalTagType(TTK_Struct,
1025  Discriminate("__block_literal", Discriminator,
1026  ParameterDiscriminator));
1027  Out << "@Z";
1028 
1029  // If the effective context was a Record, we have fully mangled the
1030  // qualified name and do not need to continue.
1031  if (isa<RecordDecl>(DC))
1032  break;
1033  continue;
1034  } else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) {
1035  mangleObjCMethodName(Method);
1036  } else if (isa<NamedDecl>(DC)) {
1037  ND = cast<NamedDecl>(DC);
1038  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
1039  mangle(FD, "?");
1040  break;
1041  } else {
1042  mangleUnqualifiedName(ND);
1043  // Lambdas in default arguments conceptually belong to the function the
1044  // parameter corresponds to.
1045  if (const auto *LDADC = getLambdaDefaultArgumentDeclContext(ND)) {
1046  DC = LDADC;
1047  continue;
1048  }
1049  }
1050  }
1051  DC = DC->getParent();
1052  }
1053 }
1054 
1055 void MicrosoftCXXNameMangler::mangleCXXDtorType(CXXDtorType T) {
1056  // Microsoft uses the names on the case labels for these dtor variants. Clang
1057  // uses the Itanium terminology internally. Everything in this ABI delegates
1058  // towards the base dtor.
1059  switch (T) {
1060  // <operator-name> ::= ?1 # destructor
1061  case Dtor_Base: Out << "?1"; return;
1062  // <operator-name> ::= ?_D # vbase destructor
1063  case Dtor_Complete: Out << "?_D"; return;
1064  // <operator-name> ::= ?_G # scalar deleting destructor
1065  case Dtor_Deleting: Out << "?_G"; return;
1066  // <operator-name> ::= ?_E # vector deleting destructor
1067  // FIXME: Add a vector deleting dtor type. It goes in the vtable, so we need
1068  // it.
1069  case Dtor_Comdat:
1070  llvm_unreachable("not expecting a COMDAT");
1071  }
1072  llvm_unreachable("Unsupported dtor type?");
1073 }
1074 
1075 void MicrosoftCXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO,
1076  SourceLocation Loc) {
1077  switch (OO) {
1078  // ?0 # constructor
1079  // ?1 # destructor
1080  // <operator-name> ::= ?2 # new
1081  case OO_New: Out << "?2"; break;
1082  // <operator-name> ::= ?3 # delete
1083  case OO_Delete: Out << "?3"; break;
1084  // <operator-name> ::= ?4 # =
1085  case OO_Equal: Out << "?4"; break;
1086  // <operator-name> ::= ?5 # >>
1087  case OO_GreaterGreater: Out << "?5"; break;
1088  // <operator-name> ::= ?6 # <<
1089  case OO_LessLess: Out << "?6"; break;
1090  // <operator-name> ::= ?7 # !
1091  case OO_Exclaim: Out << "?7"; break;
1092  // <operator-name> ::= ?8 # ==
1093  case OO_EqualEqual: Out << "?8"; break;
1094  // <operator-name> ::= ?9 # !=
1095  case OO_ExclaimEqual: Out << "?9"; break;
1096  // <operator-name> ::= ?A # []
1097  case OO_Subscript: Out << "?A"; break;
1098  // ?B # conversion
1099  // <operator-name> ::= ?C # ->
1100  case OO_Arrow: Out << "?C"; break;
1101  // <operator-name> ::= ?D # *
1102  case OO_Star: Out << "?D"; break;
1103  // <operator-name> ::= ?E # ++
1104  case OO_PlusPlus: Out << "?E"; break;
1105  // <operator-name> ::= ?F # --
1106  case OO_MinusMinus: Out << "?F"; break;
1107  // <operator-name> ::= ?G # -
1108  case OO_Minus: Out << "?G"; break;
1109  // <operator-name> ::= ?H # +
1110  case OO_Plus: Out << "?H"; break;
1111  // <operator-name> ::= ?I # &
1112  case OO_Amp: Out << "?I"; break;
1113  // <operator-name> ::= ?J # ->*
1114  case OO_ArrowStar: Out << "?J"; break;
1115  // <operator-name> ::= ?K # /
1116  case OO_Slash: Out << "?K"; break;
1117  // <operator-name> ::= ?L # %
1118  case OO_Percent: Out << "?L"; break;
1119  // <operator-name> ::= ?M # <
1120  case OO_Less: Out << "?M"; break;
1121  // <operator-name> ::= ?N # <=
1122  case OO_LessEqual: Out << "?N"; break;
1123  // <operator-name> ::= ?O # >
1124  case OO_Greater: Out << "?O"; break;
1125  // <operator-name> ::= ?P # >=
1126  case OO_GreaterEqual: Out << "?P"; break;
1127  // <operator-name> ::= ?Q # ,
1128  case OO_Comma: Out << "?Q"; break;
1129  // <operator-name> ::= ?R # ()
1130  case OO_Call: Out << "?R"; break;
1131  // <operator-name> ::= ?S # ~
1132  case OO_Tilde: Out << "?S"; break;
1133  // <operator-name> ::= ?T # ^
1134  case OO_Caret: Out << "?T"; break;
1135  // <operator-name> ::= ?U # |
1136  case OO_Pipe: Out << "?U"; break;
1137  // <operator-name> ::= ?V # &&
1138  case OO_AmpAmp: Out << "?V"; break;
1139  // <operator-name> ::= ?W # ||
1140  case OO_PipePipe: Out << "?W"; break;
1141  // <operator-name> ::= ?X # *=
1142  case OO_StarEqual: Out << "?X"; break;
1143  // <operator-name> ::= ?Y # +=
1144  case OO_PlusEqual: Out << "?Y"; break;
1145  // <operator-name> ::= ?Z # -=
1146  case OO_MinusEqual: Out << "?Z"; break;
1147  // <operator-name> ::= ?_0 # /=
1148  case OO_SlashEqual: Out << "?_0"; break;
1149  // <operator-name> ::= ?_1 # %=
1150  case OO_PercentEqual: Out << "?_1"; break;
1151  // <operator-name> ::= ?_2 # >>=
1152  case OO_GreaterGreaterEqual: Out << "?_2"; break;
1153  // <operator-name> ::= ?_3 # <<=
1154  case OO_LessLessEqual: Out << "?_3"; break;
1155  // <operator-name> ::= ?_4 # &=
1156  case OO_AmpEqual: Out << "?_4"; break;
1157  // <operator-name> ::= ?_5 # |=
1158  case OO_PipeEqual: Out << "?_5"; break;
1159  // <operator-name> ::= ?_6 # ^=
1160  case OO_CaretEqual: Out << "?_6"; break;
1161  // ?_7 # vftable
1162  // ?_8 # vbtable
1163  // ?_9 # vcall
1164  // ?_A # typeof
1165  // ?_B # local static guard
1166  // ?_C # string
1167  // ?_D # vbase destructor
1168  // ?_E # vector deleting destructor
1169  // ?_F # default constructor closure
1170  // ?_G # scalar deleting destructor
1171  // ?_H # vector constructor iterator
1172  // ?_I # vector destructor iterator
1173  // ?_J # vector vbase constructor iterator
1174  // ?_K # virtual displacement map
1175  // ?_L # eh vector constructor iterator
1176  // ?_M # eh vector destructor iterator
1177  // ?_N # eh vector vbase constructor iterator
1178  // ?_O # copy constructor closure
1179  // ?_P<name> # udt returning <name>
1180  // ?_Q # <unknown>
1181  // ?_R0 # RTTI Type Descriptor
1182  // ?_R1 # RTTI Base Class Descriptor at (a,b,c,d)
1183  // ?_R2 # RTTI Base Class Array
1184  // ?_R3 # RTTI Class Hierarchy Descriptor
1185  // ?_R4 # RTTI Complete Object Locator
1186  // ?_S # local vftable
1187  // ?_T # local vftable constructor closure
1188  // <operator-name> ::= ?_U # new[]
1189  case OO_Array_New: Out << "?_U"; break;
1190  // <operator-name> ::= ?_V # delete[]
1191  case OO_Array_Delete: Out << "?_V"; break;
1192  // <operator-name> ::= ?__L # co_await
1193  case OO_Coawait: Out << "?__L"; break;
1194 
1195  case OO_Spaceship: {
1196  // FIXME: Once MS picks a mangling, use it.
1197  DiagnosticsEngine &Diags = Context.getDiags();
1198  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
1199  "cannot mangle this three-way comparison operator yet");
1200  Diags.Report(Loc, DiagID);
1201  break;
1202  }
1203 
1204  case OO_Conditional: {
1205  DiagnosticsEngine &Diags = Context.getDiags();
1206  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
1207  "cannot mangle this conditional operator yet");
1208  Diags.Report(Loc, DiagID);
1209  break;
1210  }
1211 
1212  case OO_None:
1214  llvm_unreachable("Not an overloaded operator");
1215  }
1216 }
1217 
1218 void MicrosoftCXXNameMangler::mangleSourceName(StringRef Name) {
1219  // <source name> ::= <identifier> @
1220  BackRefVec::iterator Found =
1221  std::find(NameBackReferences.begin(), NameBackReferences.end(), Name);
1222  if (Found == NameBackReferences.end()) {
1223  if (NameBackReferences.size() < 10)
1224  NameBackReferences.push_back(Name);
1225  Out << Name << '@';
1226  } else {
1227  Out << (Found - NameBackReferences.begin());
1228  }
1229 }
1230 
1231 void MicrosoftCXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) {
1232  Context.mangleObjCMethodName(MD, Out);
1233 }
1234 
1235 void MicrosoftCXXNameMangler::mangleTemplateInstantiationName(
1236  const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) {
1237  // <template-name> ::= <unscoped-template-name> <template-args>
1238  // ::= <substitution>
1239  // Always start with the unqualified name.
1240 
1241  // Templates have their own context for back references.
1242  ArgBackRefMap OuterArgsContext;
1243  BackRefVec OuterTemplateContext;
1244  PassObjectSizeArgsSet OuterPassObjectSizeArgs;
1245  NameBackReferences.swap(OuterTemplateContext);
1246  TypeBackReferences.swap(OuterArgsContext);
1247  PassObjectSizeArgs.swap(OuterPassObjectSizeArgs);
1248 
1249  mangleUnscopedTemplateName(TD);
1250  mangleTemplateArgs(TD, TemplateArgs);
1251 
1252  // Restore the previous back reference contexts.
1253  NameBackReferences.swap(OuterTemplateContext);
1254  TypeBackReferences.swap(OuterArgsContext);
1255  PassObjectSizeArgs.swap(OuterPassObjectSizeArgs);
1256 }
1257 
1258 void
1259 MicrosoftCXXNameMangler::mangleUnscopedTemplateName(const TemplateDecl *TD) {
1260  // <unscoped-template-name> ::= ?$ <unqualified-name>
1261  Out << "?$";
1262  mangleUnqualifiedName(TD);
1263 }
1264 
1265 void MicrosoftCXXNameMangler::mangleIntegerLiteral(const llvm::APSInt &Value,
1266  bool IsBoolean) {
1267  // <integer-literal> ::= $0 <number>
1268  Out << "$0";
1269  // Make sure booleans are encoded as 0/1.
1270  if (IsBoolean && Value.getBoolValue())
1271  mangleNumber(1);
1272  else if (Value.isSigned())
1273  mangleNumber(Value.getSExtValue());
1274  else
1275  mangleNumber(Value.getZExtValue());
1276 }
1277 
1278 void MicrosoftCXXNameMangler::mangleExpression(const Expr *E) {
1279  // See if this is a constant expression.
1280  llvm::APSInt Value;
1281  if (E->isIntegerConstantExpr(Value, Context.getASTContext())) {
1282  mangleIntegerLiteral(Value, E->getType()->isBooleanType());
1283  return;
1284  }
1285 
1286  // Look through no-op casts like template parameter substitutions.
1287  E = E->IgnoreParenNoopCasts(Context.getASTContext());
1288 
1289  const CXXUuidofExpr *UE = nullptr;
1290  if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
1291  if (UO->getOpcode() == UO_AddrOf)
1292  UE = dyn_cast<CXXUuidofExpr>(UO->getSubExpr());
1293  } else
1294  UE = dyn_cast<CXXUuidofExpr>(E);
1295 
1296  if (UE) {
1297  // If we had to peek through an address-of operator, treat this like we are
1298  // dealing with a pointer type. Otherwise, treat it like a const reference.
1299  //
1300  // N.B. This matches up with the handling of TemplateArgument::Declaration
1301  // in mangleTemplateArg
1302  if (UE == E)
1303  Out << "$E?";
1304  else
1305  Out << "$1?";
1306 
1307  // This CXXUuidofExpr is mangled as-if it were actually a VarDecl from
1308  // const __s_GUID _GUID_{lower case UUID with underscores}
1309  StringRef Uuid = UE->getUuidStr();
1310  std::string Name = "_GUID_" + Uuid.lower();
1311  std::replace(Name.begin(), Name.end(), '-', '_');
1312 
1313  mangleSourceName(Name);
1314  // Terminate the whole name with an '@'.
1315  Out << '@';
1316  // It's a global variable.
1317  Out << '3';
1318  // It's a struct called __s_GUID.
1319  mangleArtificalTagType(TTK_Struct, "__s_GUID");
1320  // It's const.
1321  Out << 'B';
1322  return;
1323  }
1324 
1325  // As bad as this diagnostic is, it's better than crashing.
1326  DiagnosticsEngine &Diags = Context.getDiags();
1327  unsigned DiagID = Diags.getCustomDiagID(
1328  DiagnosticsEngine::Error, "cannot yet mangle expression type %0");
1329  Diags.Report(E->getExprLoc(), DiagID) << E->getStmtClassName()
1330  << E->getSourceRange();
1331 }
1332 
1333 void MicrosoftCXXNameMangler::mangleTemplateArgs(
1334  const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) {
1335  // <template-args> ::= <template-arg>+
1336  const TemplateParameterList *TPL = TD->getTemplateParameters();
1337  assert(TPL->size() == TemplateArgs.size() &&
1338  "size mismatch between args and parms!");
1339 
1340  unsigned Idx = 0;
1341  for (const TemplateArgument &TA : TemplateArgs.asArray())
1342  mangleTemplateArg(TD, TA, TPL->getParam(Idx++));
1343 }
1344 
1345 void MicrosoftCXXNameMangler::mangleTemplateArg(const TemplateDecl *TD,
1346  const TemplateArgument &TA,
1347  const NamedDecl *Parm) {
1348  // <template-arg> ::= <type>
1349  // ::= <integer-literal>
1350  // ::= <member-data-pointer>
1351  // ::= <member-function-pointer>
1352  // ::= $E? <name> <type-encoding>
1353  // ::= $1? <name> <type-encoding>
1354  // ::= $0A@
1355  // ::= <template-args>
1356 
1357  switch (TA.getKind()) {
1359  llvm_unreachable("Can't mangle null template arguments!");
1361  llvm_unreachable("Can't mangle template expansion arguments!");
1362  case TemplateArgument::Type: {
1363  QualType T = TA.getAsType();
1364  mangleType(T, SourceRange(), QMM_Escape);
1365  break;
1366  }
1368  const NamedDecl *ND = cast<NamedDecl>(TA.getAsDecl());
1369  if (isa<FieldDecl>(ND) || isa<IndirectFieldDecl>(ND)) {
1370  mangleMemberDataPointer(
1371  cast<CXXRecordDecl>(ND->getDeclContext())->getMostRecentDecl(),
1372  cast<ValueDecl>(ND));
1373  } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
1374  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
1375  if (MD && MD->isInstance()) {
1376  mangleMemberFunctionPointer(MD->getParent()->getMostRecentDecl(), MD);
1377  } else {
1378  Out << "$1?";
1379  mangleName(FD);
1380  mangleFunctionEncoding(FD, /*ShouldMangle=*/true);
1381  }
1382  } else {
1383  mangle(ND, TA.getParamTypeForDecl()->isReferenceType() ? "$E?" : "$1?");
1384  }
1385  break;
1386  }
1388  mangleIntegerLiteral(TA.getAsIntegral(),
1389  TA.getIntegralType()->isBooleanType());
1390  break;
1392  QualType T = TA.getNullPtrType();
1393  if (const MemberPointerType *MPT = T->getAs<MemberPointerType>()) {
1394  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
1395  if (MPT->isMemberFunctionPointerType() &&
1396  !isa<FunctionTemplateDecl>(TD)) {
1397  mangleMemberFunctionPointer(RD, nullptr);
1398  return;
1399  }
1400  if (MPT->isMemberDataPointer()) {
1401  if (!isa<FunctionTemplateDecl>(TD)) {
1402  mangleMemberDataPointer(RD, nullptr);
1403  return;
1404  }
1405  // nullptr data pointers are always represented with a single field
1406  // which is initialized with either 0 or -1. Why -1? Well, we need to
1407  // distinguish the case where the data member is at offset zero in the
1408  // record.
1409  // However, we are free to use 0 *if* we would use multiple fields for
1410  // non-nullptr member pointers.
1411  if (!RD->nullFieldOffsetIsZero()) {
1412  mangleIntegerLiteral(llvm::APSInt::get(-1), /*IsBoolean=*/false);
1413  return;
1414  }
1415  }
1416  }
1417  mangleIntegerLiteral(llvm::APSInt::getUnsigned(0), /*IsBoolean=*/false);
1418  break;
1419  }
1421  mangleExpression(TA.getAsExpr());
1422  break;
1423  case TemplateArgument::Pack: {
1424  ArrayRef<TemplateArgument> TemplateArgs = TA.getPackAsArray();
1425  if (TemplateArgs.empty()) {
1426  if (isa<TemplateTypeParmDecl>(Parm) ||
1427  isa<TemplateTemplateParmDecl>(Parm))
1428  // MSVC 2015 changed the mangling for empty expanded template packs,
1429  // use the old mangling for link compatibility for old versions.
1430  Out << (Context.getASTContext().getLangOpts().isCompatibleWithMSVC(
1432  ? "$$V"
1433  : "$$$V");
1434  else if (isa<NonTypeTemplateParmDecl>(Parm))
1435  Out << "$S";
1436  else
1437  llvm_unreachable("unexpected template parameter decl!");
1438  } else {
1439  for (const TemplateArgument &PA : TemplateArgs)
1440  mangleTemplateArg(TD, PA, Parm);
1441  }
1442  break;
1443  }
1445  const NamedDecl *ND =
1447  if (const auto *TD = dyn_cast<TagDecl>(ND)) {
1448  mangleType(TD);
1449  } else if (isa<TypeAliasDecl>(ND)) {
1450  Out << "$$Y";
1451  mangleName(ND);
1452  } else {
1453  llvm_unreachable("unexpected template template NamedDecl!");
1454  }
1455  break;
1456  }
1457  }
1458 }
1459 
1460 void MicrosoftCXXNameMangler::mangleQualifiers(Qualifiers Quals,
1461  bool IsMember) {
1462  // <cvr-qualifiers> ::= [E] [F] [I] <base-cvr-qualifiers>
1463  // 'E' means __ptr64 (32-bit only); 'F' means __unaligned (32/64-bit only);
1464  // 'I' means __restrict (32/64-bit).
1465  // Note that the MSVC __restrict keyword isn't the same as the C99 restrict
1466  // keyword!
1467  // <base-cvr-qualifiers> ::= A # near
1468  // ::= B # near const
1469  // ::= C # near volatile
1470  // ::= D # near const volatile
1471  // ::= E # far (16-bit)
1472  // ::= F # far const (16-bit)
1473  // ::= G # far volatile (16-bit)
1474  // ::= H # far const volatile (16-bit)
1475  // ::= I # huge (16-bit)
1476  // ::= J # huge const (16-bit)
1477  // ::= K # huge volatile (16-bit)
1478  // ::= L # huge const volatile (16-bit)
1479  // ::= M <basis> # based
1480  // ::= N <basis> # based const
1481  // ::= O <basis> # based volatile
1482  // ::= P <basis> # based const volatile
1483  // ::= Q # near member
1484  // ::= R # near const member
1485  // ::= S # near volatile member
1486  // ::= T # near const volatile member
1487  // ::= U # far member (16-bit)
1488  // ::= V # far const member (16-bit)
1489  // ::= W # far volatile member (16-bit)
1490  // ::= X # far const volatile member (16-bit)
1491  // ::= Y # huge member (16-bit)
1492  // ::= Z # huge const member (16-bit)
1493  // ::= 0 # huge volatile member (16-bit)
1494  // ::= 1 # huge const volatile member (16-bit)
1495  // ::= 2 <basis> # based member
1496  // ::= 3 <basis> # based const member
1497  // ::= 4 <basis> # based volatile member
1498  // ::= 5 <basis> # based const volatile member
1499  // ::= 6 # near function (pointers only)
1500  // ::= 7 # far function (pointers only)
1501  // ::= 8 # near method (pointers only)
1502  // ::= 9 # far method (pointers only)
1503  // ::= _A <basis> # based function (pointers only)
1504  // ::= _B <basis> # based function (far?) (pointers only)
1505  // ::= _C <basis> # based method (pointers only)
1506  // ::= _D <basis> # based method (far?) (pointers only)
1507  // ::= _E # block (Clang)
1508  // <basis> ::= 0 # __based(void)
1509  // ::= 1 # __based(segment)?
1510  // ::= 2 <name> # __based(name)
1511  // ::= 3 # ?
1512  // ::= 4 # ?
1513  // ::= 5 # not really based
1514  bool HasConst = Quals.hasConst(),
1515  HasVolatile = Quals.hasVolatile();
1516 
1517  if (!IsMember) {
1518  if (HasConst && HasVolatile) {
1519  Out << 'D';
1520  } else if (HasVolatile) {
1521  Out << 'C';
1522  } else if (HasConst) {
1523  Out << 'B';
1524  } else {
1525  Out << 'A';
1526  }
1527  } else {
1528  if (HasConst && HasVolatile) {
1529  Out << 'T';
1530  } else if (HasVolatile) {
1531  Out << 'S';
1532  } else if (HasConst) {
1533  Out << 'R';
1534  } else {
1535  Out << 'Q';
1536  }
1537  }
1538 
1539  // FIXME: For now, just drop all extension qualifiers on the floor.
1540 }
1541 
1542 void
1543 MicrosoftCXXNameMangler::mangleRefQualifier(RefQualifierKind RefQualifier) {
1544  // <ref-qualifier> ::= G # lvalue reference
1545  // ::= H # rvalue-reference
1546  switch (RefQualifier) {
1547  case RQ_None:
1548  break;
1549 
1550  case RQ_LValue:
1551  Out << 'G';
1552  break;
1553 
1554  case RQ_RValue:
1555  Out << 'H';
1556  break;
1557  }
1558 }
1559 
1560 void MicrosoftCXXNameMangler::manglePointerExtQualifiers(Qualifiers Quals,
1561  QualType PointeeType) {
1562  bool HasRestrict = Quals.hasRestrict();
1563  if (PointersAre64Bit &&
1564  (PointeeType.isNull() || !PointeeType->isFunctionType()))
1565  Out << 'E';
1566 
1567  if (HasRestrict)
1568  Out << 'I';
1569 
1570  if (Quals.hasUnaligned() ||
1571  (!PointeeType.isNull() && PointeeType.getLocalQualifiers().hasUnaligned()))
1572  Out << 'F';
1573 }
1574 
1575 void MicrosoftCXXNameMangler::manglePointerCVQualifiers(Qualifiers Quals) {
1576  // <pointer-cv-qualifiers> ::= P # no qualifiers
1577  // ::= Q # const
1578  // ::= R # volatile
1579  // ::= S # const volatile
1580  bool HasConst = Quals.hasConst(),
1581  HasVolatile = Quals.hasVolatile();
1582 
1583  if (HasConst && HasVolatile) {
1584  Out << 'S';
1585  } else if (HasVolatile) {
1586  Out << 'R';
1587  } else if (HasConst) {
1588  Out << 'Q';
1589  } else {
1590  Out << 'P';
1591  }
1592 }
1593 
1594 void MicrosoftCXXNameMangler::mangleArgumentType(QualType T,
1595  SourceRange Range) {
1596  // MSVC will backreference two canonically equivalent types that have slightly
1597  // different manglings when mangled alone.
1598 
1599  // Decayed types do not match up with non-decayed versions of the same type.
1600  //
1601  // e.g.
1602  // void (*x)(void) will not form a backreference with void x(void)
1603  void *TypePtr;
1604  if (const auto *DT = T->getAs<DecayedType>()) {
1605  QualType OriginalType = DT->getOriginalType();
1606  // All decayed ArrayTypes should be treated identically; as-if they were
1607  // a decayed IncompleteArrayType.
1608  if (const auto *AT = getASTContext().getAsArrayType(OriginalType))
1609  OriginalType = getASTContext().getIncompleteArrayType(
1610  AT->getElementType(), AT->getSizeModifier(),
1611  AT->getIndexTypeCVRQualifiers());
1612 
1613  TypePtr = OriginalType.getCanonicalType().getAsOpaquePtr();
1614  // If the original parameter was textually written as an array,
1615  // instead treat the decayed parameter like it's const.
1616  //
1617  // e.g.
1618  // int [] -> int * const
1619  if (OriginalType->isArrayType())
1620  T = T.withConst();
1621  } else {
1622  TypePtr = T.getCanonicalType().getAsOpaquePtr();
1623  }
1624 
1625  ArgBackRefMap::iterator Found = TypeBackReferences.find(TypePtr);
1626 
1627  if (Found == TypeBackReferences.end()) {
1628  size_t OutSizeBefore = Out.tell();
1629 
1630  mangleType(T, Range, QMM_Drop);
1631 
1632  // See if it's worth creating a back reference.
1633  // Only types longer than 1 character are considered
1634  // and only 10 back references slots are available:
1635  bool LongerThanOneChar = (Out.tell() - OutSizeBefore > 1);
1636  if (LongerThanOneChar && TypeBackReferences.size() < 10) {
1637  size_t Size = TypeBackReferences.size();
1638  TypeBackReferences[TypePtr] = Size;
1639  }
1640  } else {
1641  Out << Found->second;
1642  }
1643 }
1644 
1645 void MicrosoftCXXNameMangler::manglePassObjectSizeArg(
1646  const PassObjectSizeAttr *POSA) {
1647  int Type = POSA->getType();
1648 
1649  auto Iter = PassObjectSizeArgs.insert(Type).first;
1650  auto *TypePtr = (const void *)&*Iter;
1651  ArgBackRefMap::iterator Found = TypeBackReferences.find(TypePtr);
1652 
1653  if (Found == TypeBackReferences.end()) {
1654  mangleArtificalTagType(TTK_Enum, "__pass_object_size" + llvm::utostr(Type),
1655  {"__clang"});
1656 
1657  if (TypeBackReferences.size() < 10) {
1658  size_t Size = TypeBackReferences.size();
1659  TypeBackReferences[TypePtr] = Size;
1660  }
1661  } else {
1662  Out << Found->second;
1663  }
1664 }
1665 
1666 void MicrosoftCXXNameMangler::mangleType(QualType T, SourceRange Range,
1667  QualifierMangleMode QMM) {
1668  // Don't use the canonical types. MSVC includes things like 'const' on
1669  // pointer arguments to function pointers that canonicalization strips away.
1670  T = T.getDesugaredType(getASTContext());
1671  Qualifiers Quals = T.getLocalQualifiers();
1672  if (const ArrayType *AT = getASTContext().getAsArrayType(T)) {
1673  // If there were any Quals, getAsArrayType() pushed them onto the array
1674  // element type.
1675  if (QMM == QMM_Mangle)
1676  Out << 'A';
1677  else if (QMM == QMM_Escape || QMM == QMM_Result)
1678  Out << "$$B";
1679  mangleArrayType(AT);
1680  return;
1681  }
1682 
1683  bool IsPointer = T->isAnyPointerType() || T->isMemberPointerType() ||
1684  T->isReferenceType() || T->isBlockPointerType();
1685 
1686  switch (QMM) {
1687  case QMM_Drop:
1688  break;
1689  case QMM_Mangle:
1690  if (const FunctionType *FT = dyn_cast<FunctionType>(T)) {
1691  Out << '6';
1692  mangleFunctionType(FT);
1693  return;
1694  }
1695  mangleQualifiers(Quals, false);
1696  break;
1697  case QMM_Escape:
1698  if (!IsPointer && Quals) {
1699  Out << "$$C";
1700  mangleQualifiers(Quals, false);
1701  }
1702  break;
1703  case QMM_Result:
1704  // Presence of __unaligned qualifier shouldn't affect mangling here.
1705  Quals.removeUnaligned();
1706  if ((!IsPointer && Quals) || isa<TagType>(T)) {
1707  Out << '?';
1708  mangleQualifiers(Quals, false);
1709  }
1710  break;
1711  }
1712 
1713  const Type *ty = T.getTypePtr();
1714 
1715  switch (ty->getTypeClass()) {
1716 #define ABSTRACT_TYPE(CLASS, PARENT)
1717 #define NON_CANONICAL_TYPE(CLASS, PARENT) \
1718  case Type::CLASS: \
1719  llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \
1720  return;
1721 #define TYPE(CLASS, PARENT) \
1722  case Type::CLASS: \
1723  mangleType(cast<CLASS##Type>(ty), Quals, Range); \
1724  break;
1725 #include "clang/AST/TypeNodes.def"
1726 #undef ABSTRACT_TYPE
1727 #undef NON_CANONICAL_TYPE
1728 #undef TYPE
1729  }
1730 }
1731 
1732 void MicrosoftCXXNameMangler::mangleType(const BuiltinType *T, Qualifiers,
1733  SourceRange Range) {
1734  // <type> ::= <builtin-type>
1735  // <builtin-type> ::= X # void
1736  // ::= C # signed char
1737  // ::= D # char
1738  // ::= E # unsigned char
1739  // ::= F # short
1740  // ::= G # unsigned short (or wchar_t if it's not a builtin)
1741  // ::= H # int
1742  // ::= I # unsigned int
1743  // ::= J # long
1744  // ::= K # unsigned long
1745  // L # <none>
1746  // ::= M # float
1747  // ::= N # double
1748  // ::= O # long double (__float80 is mangled differently)
1749  // ::= _J # long long, __int64
1750  // ::= _K # unsigned long long, __int64
1751  // ::= _L # __int128
1752  // ::= _M # unsigned __int128
1753  // ::= _N # bool
1754  // _O # <array in parameter>
1755  // ::= _T # __float80 (Intel)
1756  // ::= _S # char16_t
1757  // ::= _U # char32_t
1758  // ::= _W # wchar_t
1759  // ::= _Z # __float80 (Digital Mars)
1760  switch (T->getKind()) {
1761  case BuiltinType::Void:
1762  Out << 'X';
1763  break;
1764  case BuiltinType::SChar:
1765  Out << 'C';
1766  break;
1767  case BuiltinType::Char_U:
1768  case BuiltinType::Char_S:
1769  Out << 'D';
1770  break;
1771  case BuiltinType::UChar:
1772  Out << 'E';
1773  break;
1774  case BuiltinType::Short:
1775  Out << 'F';
1776  break;
1777  case BuiltinType::UShort:
1778  Out << 'G';
1779  break;
1780  case BuiltinType::Int:
1781  Out << 'H';
1782  break;
1783  case BuiltinType::UInt:
1784  Out << 'I';
1785  break;
1786  case BuiltinType::Long:
1787  Out << 'J';
1788  break;
1789  case BuiltinType::ULong:
1790  Out << 'K';
1791  break;
1792  case BuiltinType::Float:
1793  Out << 'M';
1794  break;
1795  case BuiltinType::Double:
1796  Out << 'N';
1797  break;
1798  // TODO: Determine size and mangle accordingly
1799  case BuiltinType::LongDouble:
1800  Out << 'O';
1801  break;
1802  case BuiltinType::LongLong:
1803  Out << "_J";
1804  break;
1805  case BuiltinType::ULongLong:
1806  Out << "_K";
1807  break;
1808  case BuiltinType::Int128:
1809  Out << "_L";
1810  break;
1811  case BuiltinType::UInt128:
1812  Out << "_M";
1813  break;
1814  case BuiltinType::Bool:
1815  Out << "_N";
1816  break;
1817  case BuiltinType::Char16:
1818  Out << "_S";
1819  break;
1820  case BuiltinType::Char32:
1821  Out << "_U";
1822  break;
1823  case BuiltinType::WChar_S:
1824  case BuiltinType::WChar_U:
1825  Out << "_W";
1826  break;
1827 
1828 #define BUILTIN_TYPE(Id, SingletonId)
1829 #define PLACEHOLDER_TYPE(Id, SingletonId) \
1830  case BuiltinType::Id:
1831 #include "clang/AST/BuiltinTypes.def"
1832  case BuiltinType::Dependent:
1833  llvm_unreachable("placeholder types shouldn't get to name mangling");
1834 
1835  case BuiltinType::ObjCId:
1836  Out << "PA";
1837  mangleArtificalTagType(TTK_Struct, "objc_object");
1838  break;
1839  case BuiltinType::ObjCClass:
1840  Out << "PA";
1841  mangleArtificalTagType(TTK_Struct, "objc_class");
1842  break;
1843  case BuiltinType::ObjCSel:
1844  Out << "PA";
1845  mangleArtificalTagType(TTK_Struct, "objc_selector");
1846  break;
1847 
1848 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1849  case BuiltinType::Id: \
1850  Out << "PAUocl_" #ImgType "_" #Suffix "@@"; \
1851  break;
1852 #include "clang/Basic/OpenCLImageTypes.def"
1853  case BuiltinType::OCLSampler:
1854  Out << "PA";
1855  mangleArtificalTagType(TTK_Struct, "ocl_sampler");
1856  break;
1857  case BuiltinType::OCLEvent:
1858  Out << "PA";
1859  mangleArtificalTagType(TTK_Struct, "ocl_event");
1860  break;
1861  case BuiltinType::OCLClkEvent:
1862  Out << "PA";
1863  mangleArtificalTagType(TTK_Struct, "ocl_clkevent");
1864  break;
1865  case BuiltinType::OCLQueue:
1866  Out << "PA";
1867  mangleArtificalTagType(TTK_Struct, "ocl_queue");
1868  break;
1869  case BuiltinType::OCLReserveID:
1870  Out << "PA";
1871  mangleArtificalTagType(TTK_Struct, "ocl_reserveid");
1872  break;
1873 
1874  case BuiltinType::NullPtr:
1875  Out << "$$T";
1876  break;
1877 
1878  case BuiltinType::Float16:
1879  case BuiltinType::Float128:
1880  case BuiltinType::Half: {
1881  DiagnosticsEngine &Diags = Context.getDiags();
1882  unsigned DiagID = Diags.getCustomDiagID(
1883  DiagnosticsEngine::Error, "cannot mangle this built-in %0 type yet");
1884  Diags.Report(Range.getBegin(), DiagID)
1885  << T->getName(Context.getASTContext().getPrintingPolicy()) << Range;
1886  break;
1887  }
1888  }
1889 }
1890 
1891 // <type> ::= <function-type>
1892 void MicrosoftCXXNameMangler::mangleType(const FunctionProtoType *T, Qualifiers,
1893  SourceRange) {
1894  // Structors only appear in decls, so at this point we know it's not a
1895  // structor type.
1896  // FIXME: This may not be lambda-friendly.
1897  if (T->getTypeQuals() || T->getRefQualifier() != RQ_None) {
1898  Out << "$$A8@@";
1899  mangleFunctionType(T, /*D=*/nullptr, /*ForceThisQuals=*/true);
1900  } else {
1901  Out << "$$A6";
1902  mangleFunctionType(T);
1903  }
1904 }
1905 void MicrosoftCXXNameMangler::mangleType(const FunctionNoProtoType *T,
1907  Out << "$$A6";
1908  mangleFunctionType(T);
1909 }
1910 
1911 void MicrosoftCXXNameMangler::mangleFunctionType(const FunctionType *T,
1912  const FunctionDecl *D,
1913  bool ForceThisQuals) {
1914  // <function-type> ::= <this-cvr-qualifiers> <calling-convention>
1915  // <return-type> <argument-list> <throw-spec>
1916  const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(T);
1917 
1918  SourceRange Range;
1919  if (D) Range = D->getSourceRange();
1920 
1921  bool IsInLambda = false;
1922  bool IsStructor = false, HasThisQuals = ForceThisQuals, IsCtorClosure = false;
1923  CallingConv CC = T->getCallConv();
1924  if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(D)) {
1925  if (MD->getParent()->isLambda())
1926  IsInLambda = true;
1927  if (MD->isInstance())
1928  HasThisQuals = true;
1929  if (isa<CXXDestructorDecl>(MD)) {
1930  IsStructor = true;
1931  } else if (isa<CXXConstructorDecl>(MD)) {
1932  IsStructor = true;
1933  IsCtorClosure = (StructorType == Ctor_CopyingClosure ||
1934  StructorType == Ctor_DefaultClosure) &&
1935  isStructorDecl(MD);
1936  if (IsCtorClosure)
1937  CC = getASTContext().getDefaultCallingConvention(
1938  /*IsVariadic=*/false, /*IsCXXMethod=*/true);
1939  }
1940  }
1941 
1942  // If this is a C++ instance method, mangle the CVR qualifiers for the
1943  // this pointer.
1944  if (HasThisQuals) {
1946  manglePointerExtQualifiers(Quals, /*PointeeType=*/QualType());
1947  mangleRefQualifier(Proto->getRefQualifier());
1948  mangleQualifiers(Quals, /*IsMember=*/false);
1949  }
1950 
1951  mangleCallingConvention(CC);
1952 
1953  // <return-type> ::= <type>
1954  // ::= @ # structors (they have no declared return type)
1955  if (IsStructor) {
1956  if (isa<CXXDestructorDecl>(D) && isStructorDecl(D)) {
1957  // The scalar deleting destructor takes an extra int argument which is not
1958  // reflected in the AST.
1959  if (StructorType == Dtor_Deleting) {
1960  Out << (PointersAre64Bit ? "PEAXI@Z" : "PAXI@Z");
1961  return;
1962  }
1963  // The vbase destructor returns void which is not reflected in the AST.
1964  if (StructorType == Dtor_Complete) {
1965  Out << "XXZ";
1966  return;
1967  }
1968  }
1969  if (IsCtorClosure) {
1970  // Default constructor closure and copy constructor closure both return
1971  // void.
1972  Out << 'X';
1973 
1974  if (StructorType == Ctor_DefaultClosure) {
1975  // Default constructor closure always has no arguments.
1976  Out << 'X';
1977  } else if (StructorType == Ctor_CopyingClosure) {
1978  // Copy constructor closure always takes an unqualified reference.
1979  mangleArgumentType(getASTContext().getLValueReferenceType(
1980  Proto->getParamType(0)
1982  ->getPointeeType(),
1983  /*SpelledAsLValue=*/true),
1984  Range);
1985  Out << '@';
1986  } else {
1987  llvm_unreachable("unexpected constructor closure!");
1988  }
1989  Out << 'Z';
1990  return;
1991  }
1992  Out << '@';
1993  } else {
1994  QualType ResultType = T->getReturnType();
1995  if (const auto *AT =
1996  dyn_cast_or_null<AutoType>(ResultType->getContainedAutoType())) {
1997  Out << '?';
1998  mangleQualifiers(ResultType.getLocalQualifiers(), /*IsMember=*/false);
1999  Out << '?';
2000  assert(AT->getKeyword() != AutoTypeKeyword::GNUAutoType &&
2001  "shouldn't need to mangle __auto_type!");
2002  mangleSourceName(AT->isDecltypeAuto() ? "<decltype-auto>" : "<auto>");
2003  Out << '@';
2004  } else if (IsInLambda) {
2005  Out << '@';
2006  } else {
2007  if (ResultType->isVoidType())
2008  ResultType = ResultType.getUnqualifiedType();
2009  mangleType(ResultType, Range, QMM_Result);
2010  }
2011  }
2012 
2013  // <argument-list> ::= X # void
2014  // ::= <type>+ @
2015  // ::= <type>* Z # varargs
2016  if (!Proto) {
2017  // Function types without prototypes can arise when mangling a function type
2018  // within an overloadable function in C. We mangle these as the absence of
2019  // any parameter types (not even an empty parameter list).
2020  Out << '@';
2021  } else if (Proto->getNumParams() == 0 && !Proto->isVariadic()) {
2022  Out << 'X';
2023  } else {
2024  // Happens for function pointer type arguments for example.
2025  for (unsigned I = 0, E = Proto->getNumParams(); I != E; ++I) {
2026  mangleArgumentType(Proto->getParamType(I), Range);
2027  // Mangle each pass_object_size parameter as if it's a parameter of enum
2028  // type passed directly after the parameter with the pass_object_size
2029  // attribute. The aforementioned enum's name is __pass_object_size, and we
2030  // pretend it resides in a top-level namespace called __clang.
2031  //
2032  // FIXME: Is there a defined extension notation for the MS ABI, or is it
2033  // necessary to just cross our fingers and hope this type+namespace
2034  // combination doesn't conflict with anything?
2035  if (D)
2036  if (const auto *P = D->getParamDecl(I)->getAttr<PassObjectSizeAttr>())
2037  manglePassObjectSizeArg(P);
2038  }
2039  // <builtin-type> ::= Z # ellipsis
2040  if (Proto->isVariadic())
2041  Out << 'Z';
2042  else
2043  Out << '@';
2044  }
2045 
2046  mangleThrowSpecification(Proto);
2047 }
2048 
2049 void MicrosoftCXXNameMangler::mangleFunctionClass(const FunctionDecl *FD) {
2050  // <function-class> ::= <member-function> E? # E designates a 64-bit 'this'
2051  // # pointer. in 64-bit mode *all*
2052  // # 'this' pointers are 64-bit.
2053  // ::= <global-function>
2054  // <member-function> ::= A # private: near
2055  // ::= B # private: far
2056  // ::= C # private: static near
2057  // ::= D # private: static far
2058  // ::= E # private: virtual near
2059  // ::= F # private: virtual far
2060  // ::= I # protected: near
2061  // ::= J # protected: far
2062  // ::= K # protected: static near
2063  // ::= L # protected: static far
2064  // ::= M # protected: virtual near
2065  // ::= N # protected: virtual far
2066  // ::= Q # public: near
2067  // ::= R # public: far
2068  // ::= S # public: static near
2069  // ::= T # public: static far
2070  // ::= U # public: virtual near
2071  // ::= V # public: virtual far
2072  // <global-function> ::= Y # global near
2073  // ::= Z # global far
2074  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
2075  bool IsVirtual = MD->isVirtual();
2076  // When mangling vbase destructor variants, ignore whether or not the
2077  // underlying destructor was defined to be virtual.
2078  if (isa<CXXDestructorDecl>(MD) && isStructorDecl(MD) &&
2079  StructorType == Dtor_Complete) {
2080  IsVirtual = false;
2081  }
2082  switch (MD->getAccess()) {
2083  case AS_none:
2084  llvm_unreachable("Unsupported access specifier");
2085  case AS_private:
2086  if (MD->isStatic())
2087  Out << 'C';
2088  else if (IsVirtual)
2089  Out << 'E';
2090  else
2091  Out << 'A';
2092  break;
2093  case AS_protected:
2094  if (MD->isStatic())
2095  Out << 'K';
2096  else if (IsVirtual)
2097  Out << 'M';
2098  else
2099  Out << 'I';
2100  break;
2101  case AS_public:
2102  if (MD->isStatic())
2103  Out << 'S';
2104  else if (IsVirtual)
2105  Out << 'U';
2106  else
2107  Out << 'Q';
2108  }
2109  } else {
2110  Out << 'Y';
2111  }
2112 }
2113 void MicrosoftCXXNameMangler::mangleCallingConvention(CallingConv CC) {
2114  // <calling-convention> ::= A # __cdecl
2115  // ::= B # __export __cdecl
2116  // ::= C # __pascal
2117  // ::= D # __export __pascal
2118  // ::= E # __thiscall
2119  // ::= F # __export __thiscall
2120  // ::= G # __stdcall
2121  // ::= H # __export __stdcall
2122  // ::= I # __fastcall
2123  // ::= J # __export __fastcall
2124  // ::= Q # __vectorcall
2125  // ::= w # __regcall
2126  // The 'export' calling conventions are from a bygone era
2127  // (*cough*Win16*cough*) when functions were declared for export with
2128  // that keyword. (It didn't actually export them, it just made them so
2129  // that they could be in a DLL and somebody from another module could call
2130  // them.)
2131 
2132  switch (CC) {
2133  default:
2134  llvm_unreachable("Unsupported CC for mangling");
2135  case CC_Win64:
2136  case CC_X86_64SysV:
2137  case CC_C: Out << 'A'; break;
2138  case CC_X86Pascal: Out << 'C'; break;
2139  case CC_X86ThisCall: Out << 'E'; break;
2140  case CC_X86StdCall: Out << 'G'; break;
2141  case CC_X86FastCall: Out << 'I'; break;
2142  case CC_X86VectorCall: Out << 'Q'; break;
2143  case CC_X86RegCall: Out << 'w'; break;
2144  }
2145 }
2146 void MicrosoftCXXNameMangler::mangleCallingConvention(const FunctionType *T) {
2147  mangleCallingConvention(T->getCallConv());
2148 }
2149 void MicrosoftCXXNameMangler::mangleThrowSpecification(
2150  const FunctionProtoType *FT) {
2151  // <throw-spec> ::= Z # throw(...) (default)
2152  // ::= @ # throw() or __declspec/__attribute__((nothrow))
2153  // ::= <type>+
2154  // NOTE: Since the Microsoft compiler ignores throw specifications, they are
2155  // all actually mangled as 'Z'. (They're ignored because their associated
2156  // functionality isn't implemented, and probably never will be.)
2157  Out << 'Z';
2158 }
2159 
2160 void MicrosoftCXXNameMangler::mangleType(const UnresolvedUsingType *T,
2161  Qualifiers, SourceRange Range) {
2162  // Probably should be mangled as a template instantiation; need to see what
2163  // VC does first.
2164  DiagnosticsEngine &Diags = Context.getDiags();
2165  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2166  "cannot mangle this unresolved dependent type yet");
2167  Diags.Report(Range.getBegin(), DiagID)
2168  << Range;
2169 }
2170 
2171 // <type> ::= <union-type> | <struct-type> | <class-type> | <enum-type>
2172 // <union-type> ::= T <name>
2173 // <struct-type> ::= U <name>
2174 // <class-type> ::= V <name>
2175 // <enum-type> ::= W4 <name>
2176 void MicrosoftCXXNameMangler::mangleTagTypeKind(TagTypeKind TTK) {
2177  switch (TTK) {
2178  case TTK_Union:
2179  Out << 'T';
2180  break;
2181  case TTK_Struct:
2182  case TTK_Interface:
2183  Out << 'U';
2184  break;
2185  case TTK_Class:
2186  Out << 'V';
2187  break;
2188  case TTK_Enum:
2189  Out << "W4";
2190  break;
2191  }
2192 }
2193 void MicrosoftCXXNameMangler::mangleType(const EnumType *T, Qualifiers,
2194  SourceRange) {
2195  mangleType(cast<TagType>(T)->getDecl());
2196 }
2197 void MicrosoftCXXNameMangler::mangleType(const RecordType *T, Qualifiers,
2198  SourceRange) {
2199  mangleType(cast<TagType>(T)->getDecl());
2200 }
2201 void MicrosoftCXXNameMangler::mangleType(const TagDecl *TD) {
2202  mangleTagTypeKind(TD->getTagKind());
2203  mangleName(TD);
2204 }
2205 void MicrosoftCXXNameMangler::mangleArtificalTagType(
2206  TagTypeKind TK, StringRef UnqualifiedName, ArrayRef<StringRef> NestedNames) {
2207  // <name> ::= <unscoped-name> {[<named-scope>]+ | [<nested-name>]}? @
2208  mangleTagTypeKind(TK);
2209 
2210  // Always start with the unqualified name.
2211  mangleSourceName(UnqualifiedName);
2212 
2213  for (auto I = NestedNames.rbegin(), E = NestedNames.rend(); I != E; ++I)
2214  mangleSourceName(*I);
2215 
2216  // Terminate the whole name with an '@'.
2217  Out << '@';
2218 }
2219 
2220 // <type> ::= <array-type>
2221 // <array-type> ::= <pointer-cvr-qualifiers> <cvr-qualifiers>
2222 // [Y <dimension-count> <dimension>+]
2223 // <element-type> # as global, E is never required
2224 // It's supposed to be the other way around, but for some strange reason, it
2225 // isn't. Today this behavior is retained for the sole purpose of backwards
2226 // compatibility.
2227 void MicrosoftCXXNameMangler::mangleDecayedArrayType(const ArrayType *T) {
2228  // This isn't a recursive mangling, so now we have to do it all in this
2229  // one call.
2230  manglePointerCVQualifiers(T->getElementType().getQualifiers());
2231  mangleType(T->getElementType(), SourceRange());
2232 }
2233 void MicrosoftCXXNameMangler::mangleType(const ConstantArrayType *T, Qualifiers,
2234  SourceRange) {
2235  llvm_unreachable("Should have been special cased");
2236 }
2237 void MicrosoftCXXNameMangler::mangleType(const VariableArrayType *T, Qualifiers,
2238  SourceRange) {
2239  llvm_unreachable("Should have been special cased");
2240 }
2241 void MicrosoftCXXNameMangler::mangleType(const DependentSizedArrayType *T,
2243  llvm_unreachable("Should have been special cased");
2244 }
2245 void MicrosoftCXXNameMangler::mangleType(const IncompleteArrayType *T,
2247  llvm_unreachable("Should have been special cased");
2248 }
2249 void MicrosoftCXXNameMangler::mangleArrayType(const ArrayType *T) {
2250  QualType ElementTy(T, 0);
2251  SmallVector<llvm::APInt, 3> Dimensions;
2252  for (;;) {
2253  if (ElementTy->isConstantArrayType()) {
2254  const ConstantArrayType *CAT =
2255  getASTContext().getAsConstantArrayType(ElementTy);
2256  Dimensions.push_back(CAT->getSize());
2257  ElementTy = CAT->getElementType();
2258  } else if (ElementTy->isIncompleteArrayType()) {
2259  const IncompleteArrayType *IAT =
2260  getASTContext().getAsIncompleteArrayType(ElementTy);
2261  Dimensions.push_back(llvm::APInt(32, 0));
2262  ElementTy = IAT->getElementType();
2263  } else if (ElementTy->isVariableArrayType()) {
2264  const VariableArrayType *VAT =
2265  getASTContext().getAsVariableArrayType(ElementTy);
2266  Dimensions.push_back(llvm::APInt(32, 0));
2267  ElementTy = VAT->getElementType();
2268  } else if (ElementTy->isDependentSizedArrayType()) {
2269  // The dependent expression has to be folded into a constant (TODO).
2270  const DependentSizedArrayType *DSAT =
2271  getASTContext().getAsDependentSizedArrayType(ElementTy);
2272  DiagnosticsEngine &Diags = Context.getDiags();
2273  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2274  "cannot mangle this dependent-length array yet");
2275  Diags.Report(DSAT->getSizeExpr()->getExprLoc(), DiagID)
2276  << DSAT->getBracketsRange();
2277  return;
2278  } else {
2279  break;
2280  }
2281  }
2282  Out << 'Y';
2283  // <dimension-count> ::= <number> # number of extra dimensions
2284  mangleNumber(Dimensions.size());
2285  for (const llvm::APInt &Dimension : Dimensions)
2286  mangleNumber(Dimension.getLimitedValue());
2287  mangleType(ElementTy, SourceRange(), QMM_Escape);
2288 }
2289 
2290 // <type> ::= <pointer-to-member-type>
2291 // <pointer-to-member-type> ::= <pointer-cvr-qualifiers> <cvr-qualifiers>
2292 // <class name> <type>
2293 void MicrosoftCXXNameMangler::mangleType(const MemberPointerType *T, Qualifiers Quals,
2294  SourceRange Range) {
2295  QualType PointeeType = T->getPointeeType();
2296  manglePointerCVQualifiers(Quals);
2297  manglePointerExtQualifiers(Quals, PointeeType);
2298  if (const FunctionProtoType *FPT = PointeeType->getAs<FunctionProtoType>()) {
2299  Out << '8';
2300  mangleName(T->getClass()->castAs<RecordType>()->getDecl());
2301  mangleFunctionType(FPT, nullptr, true);
2302  } else {
2303  mangleQualifiers(PointeeType.getQualifiers(), true);
2304  mangleName(T->getClass()->castAs<RecordType>()->getDecl());
2305  mangleType(PointeeType, Range, QMM_Drop);
2306  }
2307 }
2308 
2309 void MicrosoftCXXNameMangler::mangleType(const TemplateTypeParmType *T,
2310  Qualifiers, SourceRange Range) {
2311  DiagnosticsEngine &Diags = Context.getDiags();
2312  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2313  "cannot mangle this template type parameter type yet");
2314  Diags.Report(Range.getBegin(), DiagID)
2315  << Range;
2316 }
2317 
2318 void MicrosoftCXXNameMangler::mangleType(const SubstTemplateTypeParmPackType *T,
2319  Qualifiers, SourceRange Range) {
2320  DiagnosticsEngine &Diags = Context.getDiags();
2321  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2322  "cannot mangle this substituted parameter pack yet");
2323  Diags.Report(Range.getBegin(), DiagID)
2324  << Range;
2325 }
2326 
2327 // <type> ::= <pointer-type>
2328 // <pointer-type> ::= E? <pointer-cvr-qualifiers> <cvr-qualifiers> <type>
2329 // # the E is required for 64-bit non-static pointers
2330 void MicrosoftCXXNameMangler::mangleType(const PointerType *T, Qualifiers Quals,
2331  SourceRange Range) {
2332  QualType PointeeType = T->getPointeeType();
2333  manglePointerCVQualifiers(Quals);
2334  manglePointerExtQualifiers(Quals, PointeeType);
2335  mangleType(PointeeType, Range);
2336 }
2337 
2338 void MicrosoftCXXNameMangler::mangleType(const ObjCObjectPointerType *T,
2339  Qualifiers Quals, SourceRange Range) {
2340  if (T->isObjCIdType() || T->isObjCClassType())
2341  return mangleType(T->getPointeeType(), Range, QMM_Drop);
2342 
2343  QualType PointeeType = T->getPointeeType();
2344  manglePointerCVQualifiers(Quals);
2345  manglePointerExtQualifiers(Quals, PointeeType);
2346  mangleType(PointeeType, Range);
2347 }
2348 
2349 // <type> ::= <reference-type>
2350 // <reference-type> ::= A E? <cvr-qualifiers> <type>
2351 // # the E is required for 64-bit non-static lvalue references
2352 void MicrosoftCXXNameMangler::mangleType(const LValueReferenceType *T,
2353  Qualifiers Quals, SourceRange Range) {
2354  QualType PointeeType = T->getPointeeType();
2355  assert(!Quals.hasConst() && !Quals.hasVolatile() && "unexpected qualifier!");
2356  Out << 'A';
2357  manglePointerExtQualifiers(Quals, PointeeType);
2358  mangleType(PointeeType, Range);
2359 }
2360 
2361 // <type> ::= <r-value-reference-type>
2362 // <r-value-reference-type> ::= $$Q E? <cvr-qualifiers> <type>
2363 // # the E is required for 64-bit non-static rvalue references
2364 void MicrosoftCXXNameMangler::mangleType(const RValueReferenceType *T,
2365  Qualifiers Quals, SourceRange Range) {
2366  QualType PointeeType = T->getPointeeType();
2367  assert(!Quals.hasConst() && !Quals.hasVolatile() && "unexpected qualifier!");
2368  Out << "$$Q";
2369  manglePointerExtQualifiers(Quals, PointeeType);
2370  mangleType(PointeeType, Range);
2371 }
2372 
2373 void MicrosoftCXXNameMangler::mangleType(const ComplexType *T, Qualifiers,
2374  SourceRange Range) {
2375  QualType ElementType = T->getElementType();
2376 
2377  llvm::SmallString<64> TemplateMangling;
2378  llvm::raw_svector_ostream Stream(TemplateMangling);
2379  MicrosoftCXXNameMangler Extra(Context, Stream);
2380  Stream << "?$";
2381  Extra.mangleSourceName("_Complex");
2382  Extra.mangleType(ElementType, Range, QMM_Escape);
2383 
2384  mangleArtificalTagType(TTK_Struct, TemplateMangling, {"__clang"});
2385 }
2386 
2387 void MicrosoftCXXNameMangler::mangleType(const VectorType *T, Qualifiers Quals,
2388  SourceRange Range) {
2389  const BuiltinType *ET = T->getElementType()->getAs<BuiltinType>();
2390  assert(ET && "vectors with non-builtin elements are unsupported");
2391  uint64_t Width = getASTContext().getTypeSize(T);
2392  // Pattern match exactly the typedefs in our intrinsic headers. Anything that
2393  // doesn't match the Intel types uses a custom mangling below.
2394  size_t OutSizeBefore = Out.tell();
2395  llvm::Triple::ArchType AT =
2396  getASTContext().getTargetInfo().getTriple().getArch();
2397  if (AT == llvm::Triple::x86 || AT == llvm::Triple::x86_64) {
2398  if (Width == 64 && ET->getKind() == BuiltinType::LongLong) {
2399  mangleArtificalTagType(TTK_Union, "__m64");
2400  } else if (Width >= 128) {
2401  if (ET->getKind() == BuiltinType::Float)
2402  mangleArtificalTagType(TTK_Union, "__m" + llvm::utostr(Width));
2403  else if (ET->getKind() == BuiltinType::LongLong)
2404  mangleArtificalTagType(TTK_Union, "__m" + llvm::utostr(Width) + 'i');
2405  else if (ET->getKind() == BuiltinType::Double)
2406  mangleArtificalTagType(TTK_Struct, "__m" + llvm::utostr(Width) + 'd');
2407  }
2408  }
2409 
2410  bool IsBuiltin = Out.tell() != OutSizeBefore;
2411  if (!IsBuiltin) {
2412  // The MS ABI doesn't have a special mangling for vector types, so we define
2413  // our own mangling to handle uses of __vector_size__ on user-specified
2414  // types, and for extensions like __v4sf.
2415 
2416  llvm::SmallString<64> TemplateMangling;
2417  llvm::raw_svector_ostream Stream(TemplateMangling);
2418  MicrosoftCXXNameMangler Extra(Context, Stream);
2419  Stream << "?$";
2420  Extra.mangleSourceName("__vector");
2421  Extra.mangleType(QualType(ET, 0), Range, QMM_Escape);
2422  Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(T->getNumElements()),
2423  /*IsBoolean=*/false);
2424 
2425  mangleArtificalTagType(TTK_Union, TemplateMangling, {"__clang"});
2426  }
2427 }
2428 
2429 void MicrosoftCXXNameMangler::mangleType(const ExtVectorType *T,
2430  Qualifiers Quals, SourceRange Range) {
2431  mangleType(static_cast<const VectorType *>(T), Quals, Range);
2432 }
2433 void MicrosoftCXXNameMangler::mangleType(const DependentSizedExtVectorType *T,
2434  Qualifiers, SourceRange Range) {
2435  DiagnosticsEngine &Diags = Context.getDiags();
2436  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2437  "cannot mangle this dependent-sized extended vector type yet");
2438  Diags.Report(Range.getBegin(), DiagID)
2439  << Range;
2440 }
2441 
2442 void MicrosoftCXXNameMangler::mangleType(const DependentAddressSpaceType *T,
2443  Qualifiers, SourceRange Range) {
2444  DiagnosticsEngine &Diags = Context.getDiags();
2445  unsigned DiagID = Diags.getCustomDiagID(
2447  "cannot mangle this dependent address space type yet");
2448  Diags.Report(Range.getBegin(), DiagID) << Range;
2449 }
2450 
2451 void MicrosoftCXXNameMangler::mangleType(const ObjCInterfaceType *T, Qualifiers,
2452  SourceRange) {
2453  // ObjC interfaces have structs underlying them.
2454  mangleTagTypeKind(TTK_Struct);
2455  mangleName(T->getDecl());
2456 }
2457 
2458 void MicrosoftCXXNameMangler::mangleType(const ObjCObjectType *T, Qualifiers,
2459  SourceRange Range) {
2460  // We don't allow overloading by different protocol qualification,
2461  // so mangling them isn't necessary.
2462  mangleType(T->getBaseType(), Range, QMM_Drop);
2463 }
2464 
2465 void MicrosoftCXXNameMangler::mangleType(const BlockPointerType *T,
2466  Qualifiers Quals, SourceRange Range) {
2467  QualType PointeeType = T->getPointeeType();
2468  manglePointerCVQualifiers(Quals);
2469  manglePointerExtQualifiers(Quals, PointeeType);
2470 
2471  Out << "_E";
2472 
2473  mangleFunctionType(PointeeType->castAs<FunctionProtoType>());
2474 }
2475 
2476 void MicrosoftCXXNameMangler::mangleType(const InjectedClassNameType *,
2478  llvm_unreachable("Cannot mangle injected class name type.");
2479 }
2480 
2481 void MicrosoftCXXNameMangler::mangleType(const TemplateSpecializationType *T,
2482  Qualifiers, SourceRange Range) {
2483  DiagnosticsEngine &Diags = Context.getDiags();
2484  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2485  "cannot mangle this template specialization type yet");
2486  Diags.Report(Range.getBegin(), DiagID)
2487  << Range;
2488 }
2489 
2490 void MicrosoftCXXNameMangler::mangleType(const DependentNameType *T, Qualifiers,
2491  SourceRange Range) {
2492  DiagnosticsEngine &Diags = Context.getDiags();
2493  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2494  "cannot mangle this dependent name type yet");
2495  Diags.Report(Range.getBegin(), DiagID)
2496  << Range;
2497 }
2498 
2499 void MicrosoftCXXNameMangler::mangleType(
2501  SourceRange Range) {
2502  DiagnosticsEngine &Diags = Context.getDiags();
2503  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2504  "cannot mangle this dependent template specialization type yet");
2505  Diags.Report(Range.getBegin(), DiagID)
2506  << Range;
2507 }
2508 
2509 void MicrosoftCXXNameMangler::mangleType(const PackExpansionType *T, Qualifiers,
2510  SourceRange Range) {
2511  DiagnosticsEngine &Diags = Context.getDiags();
2512  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2513  "cannot mangle this pack expansion yet");
2514  Diags.Report(Range.getBegin(), DiagID)
2515  << Range;
2516 }
2517 
2518 void MicrosoftCXXNameMangler::mangleType(const TypeOfType *T, Qualifiers,
2519  SourceRange Range) {
2520  DiagnosticsEngine &Diags = Context.getDiags();
2521  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2522  "cannot mangle this typeof(type) yet");
2523  Diags.Report(Range.getBegin(), DiagID)
2524  << Range;
2525 }
2526 
2527 void MicrosoftCXXNameMangler::mangleType(const TypeOfExprType *T, Qualifiers,
2528  SourceRange Range) {
2529  DiagnosticsEngine &Diags = Context.getDiags();
2530  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2531  "cannot mangle this typeof(expression) yet");
2532  Diags.Report(Range.getBegin(), DiagID)
2533  << Range;
2534 }
2535 
2536 void MicrosoftCXXNameMangler::mangleType(const DecltypeType *T, Qualifiers,
2537  SourceRange Range) {
2538  DiagnosticsEngine &Diags = Context.getDiags();
2539  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2540  "cannot mangle this decltype() yet");
2541  Diags.Report(Range.getBegin(), DiagID)
2542  << Range;
2543 }
2544 
2545 void MicrosoftCXXNameMangler::mangleType(const UnaryTransformType *T,
2546  Qualifiers, SourceRange Range) {
2547  DiagnosticsEngine &Diags = Context.getDiags();
2548  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2549  "cannot mangle this unary transform type yet");
2550  Diags.Report(Range.getBegin(), DiagID)
2551  << Range;
2552 }
2553 
2554 void MicrosoftCXXNameMangler::mangleType(const AutoType *T, Qualifiers,
2555  SourceRange Range) {
2556  assert(T->getDeducedType().isNull() && "expecting a dependent type!");
2557 
2558  DiagnosticsEngine &Diags = Context.getDiags();
2559  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2560  "cannot mangle this 'auto' type yet");
2561  Diags.Report(Range.getBegin(), DiagID)
2562  << Range;
2563 }
2564 
2565 void MicrosoftCXXNameMangler::mangleType(
2567  assert(T->getDeducedType().isNull() && "expecting a dependent type!");
2568 
2569  DiagnosticsEngine &Diags = Context.getDiags();
2570  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2571  "cannot mangle this deduced class template specialization type yet");
2572  Diags.Report(Range.getBegin(), DiagID)
2573  << Range;
2574 }
2575 
2576 void MicrosoftCXXNameMangler::mangleType(const AtomicType *T, Qualifiers,
2577  SourceRange Range) {
2578  QualType ValueType = T->getValueType();
2579 
2580  llvm::SmallString<64> TemplateMangling;
2581  llvm::raw_svector_ostream Stream(TemplateMangling);
2582  MicrosoftCXXNameMangler Extra(Context, Stream);
2583  Stream << "?$";
2584  Extra.mangleSourceName("_Atomic");
2585  Extra.mangleType(ValueType, Range, QMM_Escape);
2586 
2587  mangleArtificalTagType(TTK_Struct, TemplateMangling, {"__clang"});
2588 }
2589 
2590 void MicrosoftCXXNameMangler::mangleType(const PipeType *T, Qualifiers,
2591  SourceRange Range) {
2592  DiagnosticsEngine &Diags = Context.getDiags();
2593  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
2594  "cannot mangle this OpenCL pipe type yet");
2595  Diags.Report(Range.getBegin(), DiagID)
2596  << Range;
2597 }
2598 
2599 void MicrosoftMangleContextImpl::mangleCXXName(const NamedDecl *D,
2600  raw_ostream &Out) {
2601  assert((isa<FunctionDecl>(D) || isa<VarDecl>(D)) &&
2602  "Invalid mangleName() call, argument is not a variable or function!");
2603  assert(!isa<CXXConstructorDecl>(D) && !isa<CXXDestructorDecl>(D) &&
2604  "Invalid mangleName() call on 'structor decl!");
2605 
2606  PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
2607  getASTContext().getSourceManager(),
2608  "Mangling declaration");
2609 
2610  msvc_hashing_ostream MHO(Out);
2611  MicrosoftCXXNameMangler Mangler(*this, MHO);
2612  return Mangler.mangle(D);
2613 }
2614 
2615 // <this-adjustment> ::= <no-adjustment> | <static-adjustment> |
2616 // <virtual-adjustment>
2617 // <no-adjustment> ::= A # private near
2618 // ::= B # private far
2619 // ::= I # protected near
2620 // ::= J # protected far
2621 // ::= Q # public near
2622 // ::= R # public far
2623 // <static-adjustment> ::= G <static-offset> # private near
2624 // ::= H <static-offset> # private far
2625 // ::= O <static-offset> # protected near
2626 // ::= P <static-offset> # protected far
2627 // ::= W <static-offset> # public near
2628 // ::= X <static-offset> # public far
2629 // <virtual-adjustment> ::= $0 <virtual-shift> <static-offset> # private near
2630 // ::= $1 <virtual-shift> <static-offset> # private far
2631 // ::= $2 <virtual-shift> <static-offset> # protected near
2632 // ::= $3 <virtual-shift> <static-offset> # protected far
2633 // ::= $4 <virtual-shift> <static-offset> # public near
2634 // ::= $5 <virtual-shift> <static-offset> # public far
2635 // <virtual-shift> ::= <vtordisp-shift> | <vtordispex-shift>
2636 // <vtordisp-shift> ::= <offset-to-vtordisp>
2637 // <vtordispex-shift> ::= <offset-to-vbptr> <vbase-offset-offset>
2638 // <offset-to-vtordisp>
2640  const ThisAdjustment &Adjustment,
2641  MicrosoftCXXNameMangler &Mangler,
2642  raw_ostream &Out) {
2643  if (!Adjustment.Virtual.isEmpty()) {
2644  Out << '$';
2645  char AccessSpec;
2646  switch (MD->getAccess()) {
2647  case AS_none:
2648  llvm_unreachable("Unsupported access specifier");
2649  case AS_private:
2650  AccessSpec = '0';
2651  break;
2652  case AS_protected:
2653  AccessSpec = '2';
2654  break;
2655  case AS_public:
2656  AccessSpec = '4';
2657  }
2658  if (Adjustment.Virtual.Microsoft.VBPtrOffset) {
2659  Out << 'R' << AccessSpec;
2660  Mangler.mangleNumber(
2661  static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VBPtrOffset));
2662  Mangler.mangleNumber(
2663  static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VBOffsetOffset));
2664  Mangler.mangleNumber(
2665  static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VtordispOffset));
2666  Mangler.mangleNumber(static_cast<uint32_t>(Adjustment.NonVirtual));
2667  } else {
2668  Out << AccessSpec;
2669  Mangler.mangleNumber(
2670  static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VtordispOffset));
2671  Mangler.mangleNumber(-static_cast<uint32_t>(Adjustment.NonVirtual));
2672  }
2673  } else if (Adjustment.NonVirtual != 0) {
2674  switch (MD->getAccess()) {
2675  case AS_none:
2676  llvm_unreachable("Unsupported access specifier");
2677  case AS_private:
2678  Out << 'G';
2679  break;
2680  case AS_protected:
2681  Out << 'O';
2682  break;
2683  case AS_public:
2684  Out << 'W';
2685  }
2686  Mangler.mangleNumber(-static_cast<uint32_t>(Adjustment.NonVirtual));
2687  } else {
2688  switch (MD->getAccess()) {
2689  case AS_none:
2690  llvm_unreachable("Unsupported access specifier");
2691  case AS_private:
2692  Out << 'A';
2693  break;
2694  case AS_protected:
2695  Out << 'I';
2696  break;
2697  case AS_public:
2698  Out << 'Q';
2699  }
2700  }
2701 }
2702 
2703 void
2704 MicrosoftMangleContextImpl::mangleVirtualMemPtrThunk(const CXXMethodDecl *MD,
2705  raw_ostream &Out) {
2706  MicrosoftVTableContext *VTContext =
2707  cast<MicrosoftVTableContext>(getASTContext().getVTableContext());
2709  VTContext->getMethodVFTableLocation(GlobalDecl(MD));
2710 
2711  msvc_hashing_ostream MHO(Out);
2712  MicrosoftCXXNameMangler Mangler(*this, MHO);
2713  Mangler.getStream() << "\01?";
2714  Mangler.mangleVirtualMemPtrThunk(MD, ML);
2715 }
2716 
2717 void MicrosoftMangleContextImpl::mangleThunk(const CXXMethodDecl *MD,
2718  const ThunkInfo &Thunk,
2719  raw_ostream &Out) {
2720  msvc_hashing_ostream MHO(Out);
2721  MicrosoftCXXNameMangler Mangler(*this, MHO);
2722  Mangler.getStream() << "\01?";
2723  Mangler.mangleName(MD);
2724  mangleThunkThisAdjustment(MD, Thunk.This, Mangler, MHO);
2725  if (!Thunk.Return.isEmpty())
2726  assert(Thunk.Method != nullptr &&
2727  "Thunk info should hold the overridee decl");
2728 
2729  const CXXMethodDecl *DeclForFPT = Thunk.Method ? Thunk.Method : MD;
2730  Mangler.mangleFunctionType(
2731  DeclForFPT->getType()->castAs<FunctionProtoType>(), MD);
2732 }
2733 
2734 void MicrosoftMangleContextImpl::mangleCXXDtorThunk(
2735  const CXXDestructorDecl *DD, CXXDtorType Type,
2736  const ThisAdjustment &Adjustment, raw_ostream &Out) {
2737  // FIXME: Actually, the dtor thunk should be emitted for vector deleting
2738  // dtors rather than scalar deleting dtors. Just use the vector deleting dtor
2739  // mangling manually until we support both deleting dtor types.
2740  assert(Type == Dtor_Deleting);
2741  msvc_hashing_ostream MHO(Out);
2742  MicrosoftCXXNameMangler Mangler(*this, MHO, DD, Type);
2743  Mangler.getStream() << "\01??_E";
2744  Mangler.mangleName(DD->getParent());
2745  mangleThunkThisAdjustment(DD, Adjustment, Mangler, MHO);
2746  Mangler.mangleFunctionType(DD->getType()->castAs<FunctionProtoType>(), DD);
2747 }
2748 
2749 void MicrosoftMangleContextImpl::mangleCXXVFTable(
2750  const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
2751  raw_ostream &Out) {
2752  // <mangled-name> ::= ?_7 <class-name> <storage-class>
2753  // <cvr-qualifiers> [<name>] @
2754  // NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class>
2755  // is always '6' for vftables.
2756  msvc_hashing_ostream MHO(Out);
2757  MicrosoftCXXNameMangler Mangler(*this, MHO);
2758  if (Derived->hasAttr<DLLImportAttr>())
2759  Mangler.getStream() << "\01??_S";
2760  else
2761  Mangler.getStream() << "\01??_7";
2762  Mangler.mangleName(Derived);
2763  Mangler.getStream() << "6B"; // '6' for vftable, 'B' for const.
2764  for (const CXXRecordDecl *RD : BasePath)
2765  Mangler.mangleName(RD);
2766  Mangler.getStream() << '@';
2767 }
2768 
2769 void MicrosoftMangleContextImpl::mangleCXXVBTable(
2770  const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
2771  raw_ostream &Out) {
2772  // <mangled-name> ::= ?_8 <class-name> <storage-class>
2773  // <cvr-qualifiers> [<name>] @
2774  // NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class>
2775  // is always '7' for vbtables.
2776  msvc_hashing_ostream MHO(Out);
2777  MicrosoftCXXNameMangler Mangler(*this, MHO);
2778  Mangler.getStream() << "\01??_8";
2779  Mangler.mangleName(Derived);
2780  Mangler.getStream() << "7B"; // '7' for vbtable, 'B' for const.
2781  for (const CXXRecordDecl *RD : BasePath)
2782  Mangler.mangleName(RD);
2783  Mangler.getStream() << '@';
2784 }
2785 
2786 void MicrosoftMangleContextImpl::mangleCXXRTTI(QualType T, raw_ostream &Out) {
2787  msvc_hashing_ostream MHO(Out);
2788  MicrosoftCXXNameMangler Mangler(*this, MHO);
2789  Mangler.getStream() << "\01??_R0";
2790  Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
2791  Mangler.getStream() << "@8";
2792 }
2793 
2794 void MicrosoftMangleContextImpl::mangleCXXRTTIName(QualType T,
2795  raw_ostream &Out) {
2796  MicrosoftCXXNameMangler Mangler(*this, Out);
2797  Mangler.getStream() << '.';
2798  Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
2799 }
2800 
2801 void MicrosoftMangleContextImpl::mangleCXXVirtualDisplacementMap(
2802  const CXXRecordDecl *SrcRD, const CXXRecordDecl *DstRD, raw_ostream &Out) {
2803  msvc_hashing_ostream MHO(Out);
2804  MicrosoftCXXNameMangler Mangler(*this, MHO);
2805  Mangler.getStream() << "\01??_K";
2806  Mangler.mangleName(SrcRD);
2807  Mangler.getStream() << "$C";
2808  Mangler.mangleName(DstRD);
2809 }
2810 
2811 void MicrosoftMangleContextImpl::mangleCXXThrowInfo(QualType T, bool IsConst,
2812  bool IsVolatile,
2813  bool IsUnaligned,
2814  uint32_t NumEntries,
2815  raw_ostream &Out) {
2816  msvc_hashing_ostream MHO(Out);
2817  MicrosoftCXXNameMangler Mangler(*this, MHO);
2818  Mangler.getStream() << "_TI";
2819  if (IsConst)
2820  Mangler.getStream() << 'C';
2821  if (IsVolatile)
2822  Mangler.getStream() << 'V';
2823  if (IsUnaligned)
2824  Mangler.getStream() << 'U';
2825  Mangler.getStream() << NumEntries;
2826  Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
2827 }
2828 
2829 void MicrosoftMangleContextImpl::mangleCXXCatchableTypeArray(
2830  QualType T, uint32_t NumEntries, raw_ostream &Out) {
2831  msvc_hashing_ostream MHO(Out);
2832  MicrosoftCXXNameMangler Mangler(*this, MHO);
2833  Mangler.getStream() << "_CTA";
2834  Mangler.getStream() << NumEntries;
2835  Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
2836 }
2837 
2838 void MicrosoftMangleContextImpl::mangleCXXCatchableType(
2839  QualType T, const CXXConstructorDecl *CD, CXXCtorType CT, uint32_t Size,
2840  uint32_t NVOffset, int32_t VBPtrOffset, uint32_t VBIndex,
2841  raw_ostream &Out) {
2842  MicrosoftCXXNameMangler Mangler(*this, Out);
2843  Mangler.getStream() << "_CT";
2844 
2845  llvm::SmallString<64> RTTIMangling;
2846  {
2847  llvm::raw_svector_ostream Stream(RTTIMangling);
2848  msvc_hashing_ostream MHO(Stream);
2849  mangleCXXRTTI(T, MHO);
2850  }
2851  Mangler.getStream() << RTTIMangling.substr(1);
2852 
2853  // VS2015 CTP6 omits the copy-constructor in the mangled name. This name is,
2854  // in fact, superfluous but I'm not sure the change was made consciously.
2855  llvm::SmallString<64> CopyCtorMangling;
2856  if (!getASTContext().getLangOpts().isCompatibleWithMSVC(
2858  CD) {
2859  llvm::raw_svector_ostream Stream(CopyCtorMangling);
2860  msvc_hashing_ostream MHO(Stream);
2861  mangleCXXCtor(CD, CT, MHO);
2862  }
2863  Mangler.getStream() << CopyCtorMangling.substr(1);
2864 
2865  Mangler.getStream() << Size;
2866  if (VBPtrOffset == -1) {
2867  if (NVOffset) {
2868  Mangler.getStream() << NVOffset;
2869  }
2870  } else {
2871  Mangler.getStream() << NVOffset;
2872  Mangler.getStream() << VBPtrOffset;
2873  Mangler.getStream() << VBIndex;
2874  }
2875 }
2876 
2877 void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassDescriptor(
2878  const CXXRecordDecl *Derived, uint32_t NVOffset, int32_t VBPtrOffset,
2879  uint32_t VBTableOffset, uint32_t Flags, raw_ostream &Out) {
2880  msvc_hashing_ostream MHO(Out);
2881  MicrosoftCXXNameMangler Mangler(*this, MHO);
2882  Mangler.getStream() << "\01??_R1";
2883  Mangler.mangleNumber(NVOffset);
2884  Mangler.mangleNumber(VBPtrOffset);
2885  Mangler.mangleNumber(VBTableOffset);
2886  Mangler.mangleNumber(Flags);
2887  Mangler.mangleName(Derived);
2888  Mangler.getStream() << "8";
2889 }
2890 
2891 void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassArray(
2892  const CXXRecordDecl *Derived, raw_ostream &Out) {
2893  msvc_hashing_ostream MHO(Out);
2894  MicrosoftCXXNameMangler Mangler(*this, MHO);
2895  Mangler.getStream() << "\01??_R2";
2896  Mangler.mangleName(Derived);
2897  Mangler.getStream() << "8";
2898 }
2899 
2900 void MicrosoftMangleContextImpl::mangleCXXRTTIClassHierarchyDescriptor(
2901  const CXXRecordDecl *Derived, raw_ostream &Out) {
2902  msvc_hashing_ostream MHO(Out);
2903  MicrosoftCXXNameMangler Mangler(*this, MHO);
2904  Mangler.getStream() << "\01??_R3";
2905  Mangler.mangleName(Derived);
2906  Mangler.getStream() << "8";
2907 }
2908 
2909 void MicrosoftMangleContextImpl::mangleCXXRTTICompleteObjectLocator(
2910  const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
2911  raw_ostream &Out) {
2912  // <mangled-name> ::= ?_R4 <class-name> <storage-class>
2913  // <cvr-qualifiers> [<name>] @
2914  // NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class>
2915  // is always '6' for vftables.
2916  llvm::SmallString<64> VFTableMangling;
2917  llvm::raw_svector_ostream Stream(VFTableMangling);
2918  mangleCXXVFTable(Derived, BasePath, Stream);
2919 
2920  if (VFTableMangling.startswith("\01??@")) {
2921  assert(VFTableMangling.endswith("@"));
2922  Out << VFTableMangling << "??_R4@";
2923  return;
2924  }
2925 
2926  assert(VFTableMangling.startswith("\01??_7") ||
2927  VFTableMangling.startswith("\01??_S"));
2928 
2929  Out << "\01??_R4" << StringRef(VFTableMangling).drop_front(5);
2930 }
2931 
2932 void MicrosoftMangleContextImpl::mangleSEHFilterExpression(
2933  const NamedDecl *EnclosingDecl, raw_ostream &Out) {
2934  msvc_hashing_ostream MHO(Out);
2935  MicrosoftCXXNameMangler Mangler(*this, MHO);
2936  // The function body is in the same comdat as the function with the handler,
2937  // so the numbering here doesn't have to be the same across TUs.
2938  //
2939  // <mangled-name> ::= ?filt$ <filter-number> @0
2940  Mangler.getStream() << "\01?filt$" << SEHFilterIds[EnclosingDecl]++ << "@0@";
2941  Mangler.mangleName(EnclosingDecl);
2942 }
2943 
2944 void MicrosoftMangleContextImpl::mangleSEHFinallyBlock(
2945  const NamedDecl *EnclosingDecl, raw_ostream &Out) {
2946  msvc_hashing_ostream MHO(Out);
2947  MicrosoftCXXNameMangler Mangler(*this, MHO);
2948  // The function body is in the same comdat as the function with the handler,
2949  // so the numbering here doesn't have to be the same across TUs.
2950  //
2951  // <mangled-name> ::= ?fin$ <filter-number> @0
2952  Mangler.getStream() << "\01?fin$" << SEHFinallyIds[EnclosingDecl]++ << "@0@";
2953  Mangler.mangleName(EnclosingDecl);
2954 }
2955 
2956 void MicrosoftMangleContextImpl::mangleTypeName(QualType T, raw_ostream &Out) {
2957  // This is just a made up unique string for the purposes of tbaa. undname
2958  // does *not* know how to demangle it.
2959  MicrosoftCXXNameMangler Mangler(*this, Out);
2960  Mangler.getStream() << '?';
2961  Mangler.mangleType(T, SourceRange());
2962 }
2963 
2964 void MicrosoftMangleContextImpl::mangleCXXCtor(const CXXConstructorDecl *D,
2965  CXXCtorType Type,
2966  raw_ostream &Out) {
2967  msvc_hashing_ostream MHO(Out);
2968  MicrosoftCXXNameMangler mangler(*this, MHO, D, Type);
2969  mangler.mangle(D);
2970 }
2971 
2972 void MicrosoftMangleContextImpl::mangleCXXDtor(const CXXDestructorDecl *D,
2973  CXXDtorType Type,
2974  raw_ostream &Out) {
2975  msvc_hashing_ostream MHO(Out);
2976  MicrosoftCXXNameMangler mangler(*this, MHO, D, Type);
2977  mangler.mangle(D);
2978 }
2979 
2980 void MicrosoftMangleContextImpl::mangleReferenceTemporary(
2981  const VarDecl *VD, unsigned ManglingNumber, raw_ostream &Out) {
2982  msvc_hashing_ostream MHO(Out);
2983  MicrosoftCXXNameMangler Mangler(*this, MHO);
2984 
2985  Mangler.getStream() << "\01?$RT" << ManglingNumber << '@';
2986  Mangler.mangle(VD, "");
2987 }
2988 
2989 void MicrosoftMangleContextImpl::mangleThreadSafeStaticGuardVariable(
2990  const VarDecl *VD, unsigned GuardNum, raw_ostream &Out) {
2991  msvc_hashing_ostream MHO(Out);
2992  MicrosoftCXXNameMangler Mangler(*this, MHO);
2993 
2994  Mangler.getStream() << "\01?$TSS" << GuardNum << '@';
2995  Mangler.mangleNestedName(VD);
2996  Mangler.getStream() << "@4HA";
2997 }
2998 
2999 void MicrosoftMangleContextImpl::mangleStaticGuardVariable(const VarDecl *VD,
3000  raw_ostream &Out) {
3001  // <guard-name> ::= ?_B <postfix> @5 <scope-depth>
3002  // ::= ?__J <postfix> @5 <scope-depth>
3003  // ::= ?$S <guard-num> @ <postfix> @4IA
3004 
3005  // The first mangling is what MSVC uses to guard static locals in inline
3006  // functions. It uses a different mangling in external functions to support
3007  // guarding more than 32 variables. MSVC rejects inline functions with more
3008  // than 32 static locals. We don't fully implement the second mangling
3009  // because those guards are not externally visible, and instead use LLVM's
3010  // default renaming when creating a new guard variable.
3011  msvc_hashing_ostream MHO(Out);
3012  MicrosoftCXXNameMangler Mangler(*this, MHO);
3013 
3014  bool Visible = VD->isExternallyVisible();
3015  if (Visible) {
3016  Mangler.getStream() << (VD->getTLSKind() ? "\01??__J" : "\01??_B");
3017  } else {
3018  Mangler.getStream() << "\01?$S1@";
3019  }
3020  unsigned ScopeDepth = 0;
3021  if (Visible && !getNextDiscriminator(VD, ScopeDepth))
3022  // If we do not have a discriminator and are emitting a guard variable for
3023  // use at global scope, then mangling the nested name will not be enough to
3024  // remove ambiguities.
3025  Mangler.mangle(VD, "");
3026  else
3027  Mangler.mangleNestedName(VD);
3028  Mangler.getStream() << (Visible ? "@5" : "@4IA");
3029  if (ScopeDepth)
3030  Mangler.mangleNumber(ScopeDepth);
3031 }
3032 
3033 void MicrosoftMangleContextImpl::mangleInitFiniStub(const VarDecl *D,
3034  char CharCode,
3035  raw_ostream &Out) {
3036  msvc_hashing_ostream MHO(Out);
3037  MicrosoftCXXNameMangler Mangler(*this, MHO);
3038  Mangler.getStream() << "\01??__" << CharCode;
3039  Mangler.mangleName(D);
3040  if (D->isStaticDataMember()) {
3041  Mangler.mangleVariableEncoding(D);
3042  Mangler.getStream() << '@';
3043  }
3044  // This is the function class mangling. These stubs are global, non-variadic,
3045  // cdecl functions that return void and take no args.
3046  Mangler.getStream() << "YAXXZ";
3047 }
3048 
3049 void MicrosoftMangleContextImpl::mangleDynamicInitializer(const VarDecl *D,
3050  raw_ostream &Out) {
3051  // <initializer-name> ::= ?__E <name> YAXXZ
3052  mangleInitFiniStub(D, 'E', Out);
3053 }
3054 
3055 void
3056 MicrosoftMangleContextImpl::mangleDynamicAtExitDestructor(const VarDecl *D,
3057  raw_ostream &Out) {
3058  // <destructor-name> ::= ?__F <name> YAXXZ
3059  mangleInitFiniStub(D, 'F', Out);
3060 }
3061 
3062 void MicrosoftMangleContextImpl::mangleStringLiteral(const StringLiteral *SL,
3063  raw_ostream &Out) {
3064  // <char-type> ::= 0 # char
3065  // ::= 1 # wchar_t
3066  // ::= ??? # char16_t/char32_t will need a mangling too...
3067  //
3068  // <literal-length> ::= <non-negative integer> # the length of the literal
3069  //
3070  // <encoded-crc> ::= <hex digit>+ @ # crc of the literal including
3071  // # null-terminator
3072  //
3073  // <encoded-string> ::= <simple character> # uninteresting character
3074  // ::= '?$' <hex digit> <hex digit> # these two nibbles
3075  // # encode the byte for the
3076  // # character
3077  // ::= '?' [a-z] # \xe1 - \xfa
3078  // ::= '?' [A-Z] # \xc1 - \xda
3079  // ::= '?' [0-9] # [,/\:. \n\t'-]
3080  //
3081  // <literal> ::= '??_C@_' <char-type> <literal-length> <encoded-crc>
3082  // <encoded-string> '@'
3083  MicrosoftCXXNameMangler Mangler(*this, Out);
3084  Mangler.getStream() << "\01??_C@_";
3085 
3086  // <char-type>: The "kind" of string literal is encoded into the mangled name.
3087  if (SL->isWide())
3088  Mangler.getStream() << '1';
3089  else
3090  Mangler.getStream() << '0';
3091 
3092  // <literal-length>: The next part of the mangled name consists of the length
3093  // of the string.
3094  // The StringLiteral does not consider the NUL terminator byte(s) but the
3095  // mangling does.
3096  // N.B. The length is in terms of bytes, not characters.
3097  Mangler.mangleNumber(SL->getByteLength() + SL->getCharByteWidth());
3098 
3099  auto GetLittleEndianByte = [&SL](unsigned Index) {
3100  unsigned CharByteWidth = SL->getCharByteWidth();
3101  uint32_t CodeUnit = SL->getCodeUnit(Index / CharByteWidth);
3102  unsigned OffsetInCodeUnit = Index % CharByteWidth;
3103  return static_cast<char>((CodeUnit >> (8 * OffsetInCodeUnit)) & 0xff);
3104  };
3105 
3106  auto GetBigEndianByte = [&SL](unsigned Index) {
3107  unsigned CharByteWidth = SL->getCharByteWidth();
3108  uint32_t CodeUnit = SL->getCodeUnit(Index / CharByteWidth);
3109  unsigned OffsetInCodeUnit = (CharByteWidth - 1) - (Index % CharByteWidth);
3110  return static_cast<char>((CodeUnit >> (8 * OffsetInCodeUnit)) & 0xff);
3111  };
3112 
3113  // CRC all the bytes of the StringLiteral.
3114  llvm::JamCRC JC;
3115  for (unsigned I = 0, E = SL->getByteLength(); I != E; ++I)
3116  JC.update(GetLittleEndianByte(I));
3117 
3118  // The NUL terminator byte(s) were not present earlier,
3119  // we need to manually process those bytes into the CRC.
3120  for (unsigned NullTerminator = 0; NullTerminator < SL->getCharByteWidth();
3121  ++NullTerminator)
3122  JC.update('\x00');
3123 
3124  // <encoded-crc>: The CRC is encoded utilizing the standard number mangling
3125  // scheme.
3126  Mangler.mangleNumber(JC.getCRC());
3127 
3128  // <encoded-string>: The mangled name also contains the first 32 _characters_
3129  // (including null-terminator bytes) of the StringLiteral.
3130  // Each character is encoded by splitting them into bytes and then encoding
3131  // the constituent bytes.
3132  auto MangleByte = [&Mangler](char Byte) {
3133  // There are five different manglings for characters:
3134  // - [a-zA-Z0-9_$]: A one-to-one mapping.
3135  // - ?[a-z]: The range from \xe1 to \xfa.
3136  // - ?[A-Z]: The range from \xc1 to \xda.
3137  // - ?[0-9]: The set of [,/\:. \n\t'-].
3138  // - ?$XX: A fallback which maps nibbles.
3139  if (isIdentifierBody(Byte, /*AllowDollar=*/true)) {
3140  Mangler.getStream() << Byte;
3141  } else if (isLetter(Byte & 0x7f)) {
3142  Mangler.getStream() << '?' << static_cast<char>(Byte & 0x7f);
3143  } else {
3144  const char SpecialChars[] = {',', '/', '\\', ':', '.',
3145  ' ', '\n', '\t', '\'', '-'};
3146  const char *Pos =
3147  std::find(std::begin(SpecialChars), std::end(SpecialChars), Byte);
3148  if (Pos != std::end(SpecialChars)) {
3149  Mangler.getStream() << '?' << (Pos - std::begin(SpecialChars));
3150  } else {
3151  Mangler.getStream() << "?$";
3152  Mangler.getStream() << static_cast<char>('A' + ((Byte >> 4) & 0xf));
3153  Mangler.getStream() << static_cast<char>('A' + (Byte & 0xf));
3154  }
3155  }
3156  };
3157 
3158  // Enforce our 32 character max.
3159  unsigned NumCharsToMangle = std::min(32U, SL->getLength());
3160  for (unsigned I = 0, E = NumCharsToMangle * SL->getCharByteWidth(); I != E;
3161  ++I)
3162  if (SL->isWide())
3163  MangleByte(GetBigEndianByte(I));
3164  else
3165  MangleByte(GetLittleEndianByte(I));
3166 
3167  // Encode the NUL terminator if there is room.
3168  if (NumCharsToMangle < 32)
3169  for (unsigned NullTerminator = 0; NullTerminator < SL->getCharByteWidth();
3170  ++NullTerminator)
3171  MangleByte(0);
3172 
3173  Mangler.getStream() << '@';
3174 }
3175 
3178  return new MicrosoftMangleContextImpl(Context, Diags);
3179 }
Defines the clang::ASTContext interface.
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it&#39;s either not been deduced or was deduce...
Definition: Type.h:4389
An instance of this class is created to represent a function declaration or definition.
Definition: Decl.h:1697
static Qualifiers fromCVRUMask(unsigned CVRU)
Definition: Type.h:251
struct clang::ThisAdjustment::VirtualAdjustment::@119 Microsoft
void removeUnaligned()
Definition: Type.h:316
StringRef getName(const PrintingPolicy &Policy) const
Definition: Type.cpp:2580
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2285
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Definition: Type.h:3632
QualType getPointeeType() const
Definition: Type.h:2298
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:3729
A (possibly-)qualified type.
Definition: Type.h:653
bool isBlockPointerType() const
Definition: Type.h:5952
bool isArrayType() const
Definition: Type.h:5993
bool isMemberPointerType() const
Definition: Type.h:5975
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2783
__auto_type (GNU extension)
ArrayRef< TemplateArgument > getPackAsArray() const
Return the array of arguments in this template argument pack.
Definition: TemplateBase.h:366
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
Definition: Type.h:946
static MicrosoftMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags)
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:26
Kind getKind() const
Definition: Type.h:2166
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3058
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:456
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:4851
The template argument is an expression, and we&#39;ve not resolved it to one of the other forms yet...
Definition: TemplateBase.h:87
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:270
bool isEmpty() const
Definition: ABI.h:87
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
bool isVariadic() const
Definition: Type.h:3617
bool isVirtual() const
Definition: DeclCXX.h:2009
Defines the C++ template declaration subclasses.
StringRef P
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
Definition: DeclTemplate.h:453
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4403
The base class of the type hierarchy.
Definition: Type.h:1353
int64_t NonVirtual
The non-virtual adjustment from the derived object to its nearest virtual base.
Definition: ABI.h:111
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1207
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2560
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:64
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:505
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:133
QualType withConst() const
Definition: Type.h:818
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5631
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2397
Default closure variant of a ctor.
Definition: ABI.h:30
MSInheritanceAttr::Spelling getMSInheritanceModel() const
Returns the inheritance model used for this record.
QualType getElementType() const
Definition: Type.h:2595
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:806
unsigned getNumParams() const
Definition: Type.h:3491
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6307
The "union" keyword.
Definition: Type.h:4696
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:57
Represents a C++17 deduced template specialization type.
Definition: Type.h:4439
A this pointer adjustment.
Definition: ABI.h:108
The "__interface" keyword.
Definition: Type.h:4693
Represents a variable template specialization, which refers to a variable template with a given set o...
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
const CXXMethodDecl * Method
Holds a pointer to the overridden method this thunk is for, if needed by the ABI to distinguish diffe...
Definition: ABI.h:191
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1513
Defines the clang::Expr interface and subclasses for C++ expressions.
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:315
The collection of all-type qualifiers we support.
Definition: Type.h:152
bool isVariableArrayType() const
Definition: Type.h:6005
PipeType - OpenCL20.
Definition: Type.h:5650
bool isDependentSizedArrayType() const
Definition: Type.h:6009
const char * getStmtClassName() const
Definition: Stmt.cpp:74
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:265
int32_t VBOffsetOffset
The offset (in bytes) of the vbase offset in the vbtable.
Definition: ABI.h:132
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:291
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Definition: Decl.h:361
One of these records is kept for each identifier that is lexed.
Represents a class template specialization, which refers to a class template with a given set of temp...
Represents a class type in Objective C.
Definition: Type.h:5186
QualType getPointeeType() const
Definition: Type.h:2402
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:330
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:72
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
LLVM_READONLY bool isLetter(unsigned char c)
Return true if this character is an ASCII letter: [a-zA-Z].
Definition: CharInfo.h:112
bool isNamespace() const
Definition: DeclBase.h:1409
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
Definition: Decl.h:1566
bool isReferenceType() const
Definition: Type.h:5956
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4314
The this pointer adjustment as well as an optional return adjustment for a thunk. ...
Definition: ABI.h:179
unsigned getCharByteWidth() const
Definition: Expr.h:1591
QualType getParamTypeForDecl() const
Definition: TemplateBase.h:269
unsigned getTypeQuals() const
Definition: Type.h:3629
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:5739
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2486
unsigned getLength() const
Definition: Expr.h:1590
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1309
TagKind getTagKind() const
Definition: Decl.h:3146
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
Definition: TemplateBase.h:275
Deleting dtor.
Definition: ABI.h:35
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:147
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:3784
const Type * getClass() const
Definition: Type.h:2538
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1152
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5720
Enums/classes describing ABI related information about constructors, destructors and thunks...
bool isInstance() const
Definition: DeclCXX.h:1992
void * getAsOpaquePtr() const
Definition: Type.h:699
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
bool hasConst() const
Definition: Type.h:269
Expr * getSizeExpr() const
Definition: Type.h:2796
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:2876
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3323
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3235
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
Definition: Decl.cpp:1961
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:1827
bool hasAttr() const
Definition: DeclBase.h:535
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:5249
CXXRecordDecl * getMostRecentDecl()
Definition: DeclCXX.h:722
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1590
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3270
Expr * IgnoreParenNoopCasts(ASTContext &Ctx) LLVM_READONLY
IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the value (including ptr->int ...
Definition: Expr.cpp:2585
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:680
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:264
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:2774
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
CXXDtorType
C++ destructor types.
Definition: ABI.h:34
QualType getElementType() const
Definition: Type.h:2238
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
Definition: Decl.h:3685
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:627
Expr - This represents one expression.
Definition: Expr.h:106
QualType getPointeeType() const
Definition: Type.h:2442
const FunctionProtoType * T
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6370
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:68
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2620
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3343
DeclContext * getDeclContext()
Definition: DeclBase.h:425
uint32_t getCodeUnit(size_t i) const
Definition: Expr.h:1579
bool isObjCIdType() const
True if this is equivalent to the &#39;id&#39; type, i.e.
Definition: Type.h:5504
TLSKind getTLSKind() const
Definition: Decl.cpp:1883
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:264
Represents the type decltype(expr) (C++11).
Definition: Type.h:3854
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.h:1958
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn&#39;t a simple identifier.
Base object dtor.
Definition: ABI.h:37
QualType getType() const
Definition: Expr.h:128
bool isFunctionOrMethod() const
Definition: DeclBase.h:1380
bool isWide() const
Definition: Expr.h:1601
A unary type transform, which is a type constructed from another.
Definition: Type.h:3897
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1331
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1717
Represents a GCC generic vector type.
Definition: Type.h:2916
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2468
CharUnits getVBPtrOffset() const
getVBPtrOffset - Get the offset for virtual base table pointer.
Definition: RecordLayout.h:296
static const TemplateDecl * isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs)
The result type of a method or function.
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
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: DeclCXX.h:1862
The COMDAT used for dtors.
Definition: ABI.h:38
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:233
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:35
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:220
IdentifierInfo * getCXXLiteralIdentifier() const
getCXXLiteralIdentifier - If this name is the name of a literal operator, retrieve the identifier ass...
The "struct" keyword.
Definition: Type.h:4690
QualType getCanonicalType() const
Definition: Type.h:5759
Encodes a location in the source.
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5399
QualType getReturnType() const
Definition: Type.h:3203
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4004
Represents typeof(type), a GCC extension.
Definition: Type.h:3827
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5386
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2934
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have...
Definition: Linkage.h:66
QualType getElementType() const
Definition: Type.h:2951
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1964
No ref-qualifier was provided.
Definition: Type.h:1306
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2184
This file defines OpenMP nodes for declarative directives.
bool hasRestrict() const
Definition: Type.h:283
bool isAnyPointerType() const
Definition: Type.h:5948
RefQualifierKind
The kind of C++11 ref-qualifier associated with a function type.
Definition: Type.h:1304
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:691
TypeClass getTypeClass() const
Definition: Type.h:1615
Complete object dtor.
Definition: ABI.h:36
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
Definition: TemplateBase.h:301
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:1905
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1312
SourceRange getBracketsRange() const
Definition: Type.h:2802
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2370
CXXCtorType
C++ constructor types.
Definition: ABI.h:25
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4635
Represents a pack expansion of types.
Definition: Type.h:4996
StringRef getName() const
Return the actual identifier string.
static void mangleThunkThisAdjustment(const CXXMethodDecl *MD, const ThisAdjustment &Adjustment, MicrosoftCXXNameMangler &Mangler, raw_ostream &Out)
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2792
Represents a template argument.
Definition: TemplateBase.h:51
TagTypeKind
The kind of a tag type.
Definition: Type.h:4688
Dataflow Directional Tag Classes.
ThisAdjustment This
The this pointer adjustment.
Definition: ABI.h:181
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1252
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:80
bool isObjCClassType() const
True if this is equivalent to the &#39;Class&#39; type, i.e.
Definition: Type.h:5510
bool isRecord() const
Definition: DeclBase.h:1405
AccessSpecifier getAccess() const
Definition: DeclBase.h:460
A decomposition declaration.
Definition: DeclCXX.h:3766
DeclarationName - The name of a declaration.
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2085
bool isBooleanType() const
Definition: Type.h:6234
LLVM_READONLY bool isIdentifierBody(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:59
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2504
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
union clang::ThisAdjustment::VirtualAdjustment Virtual
Represents a pointer to an Objective C object.
Definition: Type.h:5442
unsigned getByteLength() const
Definition: Expr.h:1589
Pointer to a block type.
Definition: Type.h:2387
Not an overloaded operator.
Definition: OperatorKinds.h:23
bool isIncompleteArrayType() const
Definition: Type.h:6001
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3978
Complex values, per C99 6.2.5p11.
Definition: Type.h:2225
T * getAttr() const
Definition: DeclBase.h:531
const llvm::APInt & getSize() const
Definition: Type.h:2638
bool isFunctionType() const
Definition: Type.h:5940
bool isStaticLocal() const
isStaticLocal - Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1049
ExtVectorType - Extended vector type.
Definition: Type.h:2990
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1648
ReturnAdjustment Return
The return adjustment.
Definition: ABI.h:184
The template argument is a type.
Definition: TemplateBase.h:60
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
The template argument is actually a parameter pack.
Definition: TemplateBase.h:91
The "class" keyword.
Definition: Type.h:4699
bool isConstantArrayType() const
Definition: Type.h:5997
A template argument list.
Definition: DeclTemplate.h:210
StringRef getUuidStr() const
Definition: ExprCXX.h:913
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:235
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
QualType getParamType(unsigned i) const
Definition: Type.h:3493
CallingConv getCallConv() const
Definition: Type.h:3213
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5800
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3177
bool hasUnaligned() const
Definition: Type.h:312
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4903
bool isVoidType() const
Definition: Type.h:6171
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:76
Represents a C array with an unspecified size.
Definition: Type.h:2674
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5747
int32_t VtordispOffset
The offset of the vtordisp (in bytes), relative to the ECX.
Definition: ABI.h:125
The "enum" keyword.
Definition: Type.h:4702
static unsigned getCharWidth(tok::TokenKind kind, const TargetInfo &Target)
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2145
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:265
Copying closure variant of a ctor.
Definition: ABI.h:29
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1509
Defines the clang::TargetInfo interface.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3505
uint64_t Index
Method&#39;s index in the vftable.
bool hasVolatile() const
Definition: Type.h:276
unsigned getNumElements() const
Definition: Type.h:2952
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:257
Represents an extended address space qualifier where the input address space value is dependent...
Definition: Type.h:2834
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4495
bool isPointerType() const
Definition: Type.h:5944
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1126
QualType getType() const
Definition: Decl.h:638
A trivial tuple used to represent a source range.
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2841
NamedDecl - This represents a decl with a name.
Definition: Decl.h:245
bool isTranslationUnit() const
Definition: DeclBase.h:1401
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2719
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:856
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:281
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:2906
SourceLocation getBegin() const
int32_t VBPtrOffset
The offset of the vbptr of the derived class (in bytes), relative to the ECX after vtordisp adjustmen...
Definition: ABI.h:129
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2620
bool hasLinkage() const
Determine whether this declaration has linkage.
Definition: Decl.cpp:1667
const MethodVFTableLocation & getMethodVFTableLocation(GlobalDecl GD)
SourceLocation getLocation() const
Definition: DeclBase.h:416
QualType getPointeeType() const
Definition: Type.h:2524
bool isExternallyVisible() const
Definition: Decl.h:370
PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specifi...
Definition: DeclBase.h:1161
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5458