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