/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp

Bug Summary

File:	clang/lib/AST/MicrosoftMangle.cpp
Warning:	line 2419, column 27 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name MicrosoftMangle.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/lib/AST -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-01-11-115256-23437-1 -x c++ /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp
1//===--- MicrosoftMangle.cpp - Microsoft Visual C++ Name Mangling ---------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This provides C++ name mangling targeting the Microsoft Visual C++ ABI.
10//
11//===----------------------------------------------------------------------===//

13#include "clang/AST/Mangle.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/Attr.h"
16#include "clang/AST/CXXInheritance.h"
17#include "clang/AST/CharUnits.h"
18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclCXX.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/AST/DeclOpenMP.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/CRC.h"
31#include "llvm/Support/MD5.h"
32#include "llvm/Support/MathExtras.h"
33#include "llvm/Support/StringSaver.h"
34#include "llvm/Support/xxhash.h"

36using namespace clang;

38namespace {

40struct msvc_hashing_ostream : public llvm::raw_svector_ostream {
raw_ostream &OS;
llvm::SmallString<64> Buffer;

msvc_hashing_ostream(raw_ostream &OS)
    : llvm::raw_svector_ostream(Buffer), OS(OS) {}
~msvc_hashing_ostream() override {
  StringRef MangledName = str();
  bool StartsWithEscape = MangledName.startswith("\01");
  if (StartsWithEscape)
    MangledName = MangledName.drop_front(1);
  if (MangledName.size() <= 4096) {
    OS << str();
    return;
  }

  llvm::MD5 Hasher;
  llvm::MD5::MD5Result Hash;
  Hasher.update(MangledName);
  Hasher.final(Hash);

  SmallString<32> HexString;
  llvm::MD5::stringifyResult(Hash, HexString);

  if (StartsWithEscape)
    OS << '\01';
  OS << "??@" << HexString << '@';
}
68};

70static const DeclContext *
71getLambdaDefaultArgumentDeclContext(const Decl *D) {
if (const auto *RD = dyn_cast<CXXRecordDecl>(D))
  if (RD->isLambda())
    if (const auto *Parm =
            dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl()))
      return Parm->getDeclContext();
return nullptr;
78}

80/// Retrieve the declaration context that should be used when mangling
81/// the given declaration.
82static const DeclContext *getEffectiveDeclContext(const Decl *D) {
// The ABI assumes that lambda closure types that occur within
// default arguments live in the context of the function. However, due to
// the way in which Clang parses and creates function declarations, this is
// not the case: the lambda closure type ends up living in the context
// where the function itself resides, because the function declaration itself
// had not yet been created. Fix the context here.
if (const auto *LDADC = getLambdaDefaultArgumentDeclContext(D))
  return LDADC;

// Perform the same check for block literals.
if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
  if (ParmVarDecl *ContextParam =
          dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl()))
    return ContextParam->getDeclContext();
}

const DeclContext *DC = D->getDeclContext();
if (isa<CapturedDecl>(DC) || isa<OMPDeclareReductionDecl>(DC) ||
    isa<OMPDeclareMapperDecl>(DC)) {
  return getEffectiveDeclContext(cast<Decl>(DC));
}

return DC->getRedeclContext();
106}

108static const DeclContext *getEffectiveParentContext(const DeclContext *DC) {
return getEffectiveDeclContext(cast<Decl>(DC));
110}

112static const FunctionDecl *getStructor(const NamedDecl *ND) {
if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(ND))
  return FTD->getTemplatedDecl()->getCanonicalDecl();

const auto *FD = cast<FunctionDecl>(ND);
if (const auto *FTD = FD->getPrimaryTemplate())
  return FTD->getTemplatedDecl()->getCanonicalDecl();

return FD->getCanonicalDecl();
121}

123/// MicrosoftMangleContextImpl - Overrides the default MangleContext for the
124/// Microsoft Visual C++ ABI.
125class MicrosoftMangleContextImpl : public MicrosoftMangleContext {
typedef std::pair<const DeclContext *, IdentifierInfo *> DiscriminatorKeyTy;
llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator;
llvm::DenseMap<const NamedDecl *, unsigned> Uniquifier;
llvm::DenseMap<const CXXRecordDecl *, unsigned> LambdaIds;
llvm::DenseMap<const NamedDecl *, unsigned> SEHFilterIds;
llvm::DenseMap<const NamedDecl *, unsigned> SEHFinallyIds;
SmallString<16> AnonymousNamespaceHash;

134public:
MicrosoftMangleContextImpl(ASTContext &Context, DiagnosticsEngine &Diags);
bool shouldMangleCXXName(const NamedDecl *D) override;
bool shouldMangleStringLiteral(const StringLiteral *SL) override;
void mangleCXXName(const NamedDecl *D, raw_ostream &Out) override;
void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD,
                              const MethodVFTableLocation &ML,
                              raw_ostream &Out) override;
void mangleThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk,
                 raw_ostream &) override;
void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type,
                        const ThisAdjustment &ThisAdjustment,
                        raw_ostream &) override;
void mangleCXXVFTable(const CXXRecordDecl *Derived,
                      ArrayRef<const CXXRecordDecl *> BasePath,
                      raw_ostream &Out) override;
void mangleCXXVBTable(const CXXRecordDecl *Derived,
                      ArrayRef<const CXXRecordDecl *> BasePath,
                      raw_ostream &Out) override;
void mangleCXXVirtualDisplacementMap(const CXXRecordDecl *SrcRD,
                                     const CXXRecordDecl *DstRD,
                                     raw_ostream &Out) override;
void mangleCXXThrowInfo(QualType T, bool IsConst, bool IsVolatile,
                        bool IsUnaligned, uint32_t NumEntries,
                        raw_ostream &Out) override;
void mangleCXXCatchableTypeArray(QualType T, uint32_t NumEntries,
                                 raw_ostream &Out) override;
void mangleCXXCatchableType(QualType T, const CXXConstructorDecl *CD,
                            CXXCtorType CT, uint32_t Size, uint32_t NVOffset,
                            int32_t VBPtrOffset, uint32_t VBIndex,
                            raw_ostream &Out) override;
void mangleCXXRTTI(QualType T, raw_ostream &Out) override;
void mangleCXXRTTIName(QualType T, raw_ostream &Out) override;
void mangleCXXRTTIBaseClassDescriptor(const CXXRecordDecl *Derived,
                                      uint32_t NVOffset, int32_t VBPtrOffset,
                                      uint32_t VBTableOffset, uint32_t Flags,
                                      raw_ostream &Out) override;
void mangleCXXRTTIBaseClassArray(const CXXRecordDecl *Derived,
                                 raw_ostream &Out) override;
void mangleCXXRTTIClassHierarchyDescriptor(const CXXRecordDecl *Derived,
                                           raw_ostream &Out) override;
void
mangleCXXRTTICompleteObjectLocator(const CXXRecordDecl *Derived,
                                   ArrayRef<const CXXRecordDecl *> BasePath,
                                   raw_ostream &Out) override;
void mangleTypeName(QualType T, raw_ostream &) override;
void mangleCXXCtor(const CXXConstructorDecl *D, CXXCtorType Type,
                   raw_ostream &) override;
void mangleCXXDtor(const CXXDestructorDecl *D, CXXDtorType Type,
                   raw_ostream &) override;
void mangleReferenceTemporary(const VarDecl *, unsigned ManglingNumber,
                              raw_ostream &) override;
void mangleStaticGuardVariable(const VarDecl *D, raw_ostream &Out) override;
void mangleThreadSafeStaticGuardVariable(const VarDecl *D, unsigned GuardNum,
                                         raw_ostream &Out) override;
void mangleDynamicInitializer(const VarDecl *D, raw_ostream &Out) override;
void mangleDynamicAtExitDestructor(const VarDecl *D,
                                   raw_ostream &Out) override;
void mangleSEHFilterExpression(const NamedDecl *EnclosingDecl,
                               raw_ostream &Out) override;
void mangleSEHFinallyBlock(const NamedDecl *EnclosingDecl,
                           raw_ostream &Out) override;
void mangleStringLiteral(const StringLiteral *SL, raw_ostream &Out) override;
bool getNextDiscriminator(const NamedDecl *ND, unsigned &disc) {
  const DeclContext *DC = getEffectiveDeclContext(ND);
  if (!DC->isFunctionOrMethod())
    return false;

  // Lambda closure types are already numbered, give out a phony number so
  // that they demangle nicely.
  if (const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
    if (RD->isLambda()) {
      disc = 1;
      return true;
    }
  }

  // Use the canonical number for externally visible decls.
  if (ND->isExternallyVisible()) {
    disc = getASTContext().getManglingNumber(ND);
    return true;
  }

  // Anonymous tags are already numbered.
  if (const TagDecl *Tag = dyn_cast<TagDecl>(ND)) {
    if (!Tag->hasNameForLinkage() &&
        !getASTContext().getDeclaratorForUnnamedTagDecl(Tag) &&
        !getASTContext().getTypedefNameForUnnamedTagDecl(Tag))
      return false;
  }

  // Make up a reasonable number for internal decls.
  unsigned &discriminator = Uniquifier[ND];
  if (!discriminator)
    discriminator = ++Discriminator[std::make_pair(DC, ND->getIdentifier())];
  disc = discriminator + 1;
  return true;
}

unsigned getLambdaId(const CXXRecordDecl *RD) {
  assert(RD->isLambda() && "RD must be a lambda!")((RD->isLambda() && "RD must be a lambda!") ? static_cast
<void> (0) : __assert_fail ("RD->isLambda() && \"RD must be a lambda!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 234, __PRETTY_FUNCTION__));
  assert(!RD->isExternallyVisible() && "RD must not be visible!")((!RD->isExternallyVisible() && "RD must not be visible!"
) ? static_cast<void> (0) : __assert_fail ("!RD->isExternallyVisible() && \"RD must not be visible!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 235, __PRETTY_FUNCTION__));
  assert(RD->getLambdaManglingNumber() == 0 &&((RD->getLambdaManglingNumber() == 0 && "RD must not have a mangling number!"
) ? static_cast<void> (0) : __assert_fail ("RD->getLambdaManglingNumber() == 0 && \"RD must not have a mangling number!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 237, __PRETTY_FUNCTION__))
         "RD must not have a mangling number!")((RD->getLambdaManglingNumber() == 0 && "RD must not have a mangling number!"
) ? static_cast<void> (0) : __assert_fail ("RD->getLambdaManglingNumber() == 0 && \"RD must not have a mangling number!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 237, __PRETTY_FUNCTION__));
  std::pair<llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator, bool>
      Result = LambdaIds.insert(std::make_pair(RD, LambdaIds.size()));
  return Result.first->second;
}

/// Return a character sequence that is (somewhat) unique to the TU suitable
/// for mangling anonymous namespaces.
StringRef getAnonymousNamespaceHash() const {
  return AnonymousNamespaceHash;
}

249private:
void mangleInitFiniStub(const VarDecl *D, char CharCode, raw_ostream &Out);
251};

253/// MicrosoftCXXNameMangler - Manage the mangling of a single name for the
254/// Microsoft Visual C++ ABI.
255class MicrosoftCXXNameMangler {
MicrosoftMangleContextImpl &Context;
raw_ostream &Out;

/// The "structor" is the top-level declaration being mangled, if
/// that's not a template specialization; otherwise it's the pattern
/// for that specialization.
const NamedDecl *Structor;
unsigned StructorType;

typedef llvm::SmallVector<std::string, 10> BackRefVec;
BackRefVec NameBackReferences;

typedef llvm::DenseMap<const void *, unsigned> ArgBackRefMap;
ArgBackRefMap FunArgBackReferences;
ArgBackRefMap TemplateArgBackReferences;

typedef llvm::DenseMap<const void *, StringRef> TemplateArgStringMap;
TemplateArgStringMap TemplateArgStrings;
llvm::StringSaver TemplateArgStringStorage;
llvm::BumpPtrAllocator TemplateArgStringStorageAlloc;

typedef std::set<std::pair<int, bool>> PassObjectSizeArgsSet;
PassObjectSizeArgsSet PassObjectSizeArgs;

ASTContext &getASTContext() const { return Context.getASTContext(); }

const bool PointersAre64Bit;

284public:
enum QualifierMangleMode { QMM_Drop, QMM_Mangle, QMM_Escape, QMM_Result };

MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_)
    : Context(C), Out(Out_), Structor(nullptr), StructorType(-1),
      TemplateArgStringStorage(TemplateArgStringStorageAlloc),
      PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
                       64) {}

MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_,
                        const CXXConstructorDecl *D, CXXCtorType Type)
    : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
      TemplateArgStringStorage(TemplateArgStringStorageAlloc),
      PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
                       64) {}

MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_,
                        const CXXDestructorDecl *D, CXXDtorType Type)
    : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
      TemplateArgStringStorage(TemplateArgStringStorageAlloc),
      PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
                       64) {}

raw_ostream &getStream() const { return Out; }

void mangle(const NamedDecl *D, StringRef Prefix = "?");
void mangleName(const NamedDecl *ND);
void mangleFunctionEncoding(const FunctionDecl *FD, bool ShouldMangle);
void mangleVariableEncoding(const VarDecl *VD);
void mangleMemberDataPointer(const CXXRecordDecl *RD, const ValueDecl *VD);
void mangleMemberFunctionPointer(const CXXRecordDecl *RD,
                                 const CXXMethodDecl *MD);
void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD,
                              const MethodVFTableLocation &ML);
void mangleNumber(int64_t Number);
void mangleTagTypeKind(TagTypeKind TK);
void mangleArtificialTagType(TagTypeKind TK, StringRef UnqualifiedName,
                            ArrayRef<StringRef> NestedNames = None);
void mangleAddressSpaceType(QualType T, Qualifiers Quals, SourceRange Range);
void mangleType(QualType T, SourceRange Range,
                QualifierMangleMode QMM = QMM_Mangle);
void mangleFunctionType(const FunctionType *T,
                        const FunctionDecl *D = nullptr,
                        bool ForceThisQuals = false,
                        bool MangleExceptionSpec = true);
void mangleNestedName(const NamedDecl *ND);

331private:
bool isStructorDecl(const NamedDecl *ND) const {
  return ND == Structor || getStructor(ND) == Structor;
}

bool is64BitPointer(Qualifiers Quals) const {
  LangAS AddrSpace = Quals.getAddressSpace();
  return AddrSpace == LangAS::ptr64 ||
         (PointersAre64Bit && !(AddrSpace == LangAS::ptr32_sptr ||
                                AddrSpace == LangAS::ptr32_uptr));
}

void mangleUnqualifiedName(const NamedDecl *ND) {
  mangleUnqualifiedName(ND, ND->getDeclName());
}
void mangleUnqualifiedName(const NamedDecl *ND, DeclarationName Name);
void mangleSourceName(StringRef Name);
void mangleOperatorName(OverloadedOperatorKind OO, SourceLocation Loc);
void mangleCXXDtorType(CXXDtorType T);
void mangleQualifiers(Qualifiers Quals, bool IsMember);
void mangleRefQualifier(RefQualifierKind RefQualifier);
void manglePointerCVQualifiers(Qualifiers Quals);
void manglePointerExtQualifiers(Qualifiers Quals, QualType PointeeType);

void mangleUnscopedTemplateName(const TemplateDecl *ND);
void
mangleTemplateInstantiationName(const TemplateDecl *TD,
                                const TemplateArgumentList &TemplateArgs);
void mangleObjCMethodName(const ObjCMethodDecl *MD);

void mangleFunctionArgumentType(QualType T, SourceRange Range);
void manglePassObjectSizeArg(const PassObjectSizeAttr *POSA);

bool isArtificialTagType(QualType T) const;

// Declare manglers for every type class.
367#define ABSTRACT_TYPE(CLASS, PARENT)
368#define NON_CANONICAL_TYPE(CLASS, PARENT)
369#define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T, \
                                          Qualifiers Quals, \
                                          SourceRange Range);
372#include "clang/AST/TypeNodes.inc"
373#undef ABSTRACT_TYPE
374#undef NON_CANONICAL_TYPE
375#undef TYPE

void mangleType(const TagDecl *TD);
void mangleDecayedArrayType(const ArrayType *T);
void mangleArrayType(const ArrayType *T);
void mangleFunctionClass(const FunctionDecl *FD);
void mangleCallingConvention(CallingConv CC);
void mangleCallingConvention(const FunctionType *T);
void mangleIntegerLiteral(const llvm::APSInt &Number, bool IsBoolean);
void mangleExpression(const Expr *E);
void mangleThrowSpecification(const FunctionProtoType *T);

void mangleTemplateArgs(const TemplateDecl *TD,
                        const TemplateArgumentList &TemplateArgs);
void mangleTemplateArg(const TemplateDecl *TD, const TemplateArgument &TA,
                       const NamedDecl *Parm);

void mangleObjCProtocol(const ObjCProtocolDecl *PD);
void mangleObjCLifetime(const QualType T, Qualifiers Quals,
                        SourceRange Range);
void mangleObjCKindOfType(const ObjCObjectType *T, Qualifiers Quals,
                          SourceRange Range);
397};
398}

400MicrosoftMangleContextImpl::MicrosoftMangleContextImpl(ASTContext &Context,
                                                     DiagnosticsEngine &Diags)
  : MicrosoftMangleContext(Context, Diags) {
// To mangle anonymous namespaces, hash the path to the main source file. The
// path should be whatever (probably relative) path was passed on the command
// line. The goal is for the compiler to produce the same output regardless of
// working directory, so use the uncanonicalized relative path.
//
// It's important to make the mangled names unique because, when CodeView
// debug info is in use, the debugger uses mangled type names to distinguish
// between otherwise identically named types in anonymous namespaces.
//
// These symbols are always internal, so there is no need for the hash to
// match what MSVC produces. For the same reason, clang is free to change the
// hash at any time without breaking compatibility with old versions of clang.
// The generated names are intended to look similar to what MSVC generates,
// which are something like "?A0x01234567@".
SourceManager &SM = Context.getSourceManager();
if (const FileEntry *FE = SM.getFileEntryForID(SM.getMainFileID())) {
  // Truncate the hash so we get 8 characters of hexadecimal.
  uint32_t TruncatedHash = uint32_t(xxHash64(FE->getName()));
  AnonymousNamespaceHash = llvm::utohexstr(TruncatedHash);
} else {
  // If we don't have a path to the main file, we'll just use 0.
  AnonymousNamespaceHash = "0";
}
426}

428bool MicrosoftMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) {
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
  LanguageLinkage L = FD->getLanguageLinkage();
  // Overloadable functions need mangling.
  if (FD->hasAttr<OverloadableAttr>())
    return true;

  // The ABI expects that we would never mangle "typical" user-defined entry
  // points regardless of visibility or freestanding-ness.
  //
  // N.B. This is distinct from asking about "main".  "main" has a lot of
  // special rules associated with it in the standard while these
  // user-defined entry points are outside of the purview of the standard.
  // For example, there can be only one definition for "main" in a standards
  // compliant program; however nothing forbids the existence of wmain and
  // WinMain in the same translation unit.
  if (FD->isMSVCRTEntryPoint())
    return false;

  // C++ functions and those whose names are not a simple identifier need
  // mangling.
  if (!FD->getDeclName().isIdentifier() || L == CXXLanguageLinkage)
    return true;

  // C functions are not mangled.
  if (L == CLanguageLinkage)
    return false;
}

// Otherwise, no mangling is done outside C++ mode.
if (!getASTContext().getLangOpts().CPlusPlus)
  return false;

const VarDecl *VD = dyn_cast<VarDecl>(D);
if (VD && !isa<DecompositionDecl>(D)) {
  // C variables are not mangled.
  if (VD->isExternC())
    return false;

  // Variables at global scope with non-internal linkage are not mangled.
  const DeclContext *DC = getEffectiveDeclContext(D);
  // Check for extern variable declared locally.
  if (DC->isFunctionOrMethod() && D->hasLinkage())
    while (!DC->isNamespace() && !DC->isTranslationUnit())
      DC = getEffectiveParentContext(DC);

  if (DC->isTranslationUnit() && D->getFormalLinkage() == InternalLinkage &&
      !isa<VarTemplateSpecializationDecl>(D) &&
      D->getIdentifier() != nullptr)
    return false;
}

return true;
481}

483bool
484MicrosoftMangleContextImpl::shouldMangleStringLiteral(const StringLiteral *SL) {
return true;
486}

488void MicrosoftCXXNameMangler::mangle(const NamedDecl *D, StringRef Prefix) {
// MSVC doesn't mangle C++ names the same way it mangles extern "C" names.
// Therefore it's really important that we don't decorate the
// name with leading underscores or leading/trailing at signs. So, by
// default, we emit an asm marker at the start so we get the name right.
// Callers can override this with a custom prefix.

// <mangled-name> ::= ? <name> <type-encoding>
Out << Prefix;
mangleName(D);
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
  mangleFunctionEncoding(FD, Context.shouldMangleDeclName(FD));
else if (const VarDecl *VD = dyn_cast<VarDecl>(D))
  mangleVariableEncoding(VD);
else
  llvm_unreachable("Tried to mangle unexpected NamedDecl!")::llvm::llvm_unreachable_internal("Tried to mangle unexpected NamedDecl!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 503);
504}

506void MicrosoftCXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD,
                                                   bool ShouldMangle) {
// <type-encoding> ::= <function-class> <function-type>

// Since MSVC operates on the type as written and not the canonical type, it
// actually matters which decl we have here.  MSVC appears to choose the
// first, since it is most likely to be the declaration in a header file.
FD = FD->getFirstDecl();

// We should never ever see a FunctionNoProtoType at this point.
// We don't even know how to mangle their types anyway :).
const FunctionProtoType *FT = FD->getType()->castAs<FunctionProtoType>();

// extern "C" functions can hold entities that must be mangled.
// As it stands, these functions still need to get expressed in the full
// external name.  They have their class and type omitted, replaced with '9'.
if (ShouldMangle) {
  // We would like to mangle all extern "C" functions using this additional
  // component but this would break compatibility with MSVC's behavior.
  // Instead, do this when we know that compatibility isn't important (in
  // other words, when it is an overloaded extern "C" function).
  if (FD->isExternC() && FD->hasAttr<OverloadableAttr>())
    Out << "$$J0";

  mangleFunctionClass(FD);

  mangleFunctionType(FT, FD, false, false);
} else {
  Out << '9';
}
536}

538void MicrosoftCXXNameMangler::mangleVariableEncoding(const VarDecl *VD) {
// <type-encoding> ::= <storage-class> <variable-type>
// <storage-class> ::= 0  # private static member
//                 ::= 1  # protected static member
//                 ::= 2  # public static member
//                 ::= 3  # global
//                 ::= 4  # static local

// The first character in the encoding (after the name) is the storage class.
if (VD->isStaticDataMember()) {
  // If it's a static member, it also encodes the access level.
  switch (VD->getAccess()) {
    default:
    case AS_private: Out << '0'; break;
    case AS_protected: Out << '1'; break;
    case AS_public: Out << '2'; break;
  }
}
else if (!VD->isStaticLocal())
  Out << '3';
else
  Out << '4';
// Now mangle the type.
// <variable-type> ::= <type> <cvr-qualifiers>
//                 ::= <type> <pointee-cvr-qualifiers> # pointers, references
// Pointers and references are odd. The type of 'int * const foo;' gets
// mangled as 'QAHA' instead of 'PAHB', for example.
SourceRange SR = VD->getSourceRange();
QualType Ty = VD->getType();
if (Ty->isPointerType() || Ty->isReferenceType() ||
    Ty->isMemberPointerType()) {
  mangleType(Ty, SR, QMM_Drop);
  manglePointerExtQualifiers(
      Ty.getDesugaredType(getASTContext()).getLocalQualifiers(), QualType());
  if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) {
    mangleQualifiers(MPT->getPointeeType().getQualifiers(), true);
    // Member pointers are suffixed with a back reference to the member
    // pointer's class name.
    mangleName(MPT->getClass()->getAsCXXRecordDecl());
  } else
    mangleQualifiers(Ty->getPointeeType().getQualifiers(), false);
} else if (const ArrayType *AT = getASTContext().getAsArrayType(Ty)) {
  // Global arrays are funny, too.
  mangleDecayedArrayType(AT);
  if (AT->getElementType()->isArrayType())
    Out << 'A';
  else
    mangleQualifiers(Ty.getQualifiers(), false);
} else {
  mangleType(Ty, SR, QMM_Drop);
  mangleQualifiers(Ty.getQualifiers(), false);
}
590}

592void MicrosoftCXXNameMangler::mangleMemberDataPointer(const CXXRecordDecl *RD,
                                                    const ValueDecl *VD) {
// <member-data-pointer> ::= <integer-literal>
//                       ::= $F <number> <number>
//                       ::= $G <number> <number> <number>

int64_t FieldOffset;
int64_t VBTableOffset;
MSInheritanceModel IM = RD->getMSInheritanceModel();
if (VD) {
  FieldOffset = getASTContext().getFieldOffset(VD);
  assert(FieldOffset % getASTContext().getCharWidth() == 0 &&((FieldOffset % getASTContext().getCharWidth() == 0 &&
 "cannot take address of bitfield") ? static_cast<void>
 (0) : __assert_fail ("FieldOffset % getASTContext().getCharWidth() == 0 && \"cannot take address of bitfield\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 604, __PRETTY_FUNCTION__))
         "cannot take address of bitfield")((FieldOffset % getASTContext().getCharWidth() == 0 &&
 "cannot take address of bitfield") ? static_cast<void>
 (0) : __assert_fail ("FieldOffset % getASTContext().getCharWidth() == 0 && \"cannot take address of bitfield\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 604, __PRETTY_FUNCTION__));
  FieldOffset /= getASTContext().getCharWidth();

  VBTableOffset = 0;

  if (IM == MSInheritanceModel::Virtual)
    FieldOffset -= getASTContext().getOffsetOfBaseWithVBPtr(RD).getQuantity();
} else {
  FieldOffset = RD->nullFieldOffsetIsZero() ? 0 : -1;

  VBTableOffset = -1;
}

char Code = '\0';
switch (IM) {
case MSInheritanceModel::Single:      Code = '0'; break;
case MSInheritanceModel::Multiple:    Code = '0'; break;
case MSInheritanceModel::Virtual:     Code = 'F'; break;
case MSInheritanceModel::Unspecified: Code = 'G'; break;
}

Out << '$' << Code;

mangleNumber(FieldOffset);

// The C++ standard doesn't allow base-to-derived member pointer conversions
// in template parameter contexts, so the vbptr offset of data member pointers
// is always zero.
if (inheritanceModelHasVBPtrOffsetField(IM))
  mangleNumber(0);
if (inheritanceModelHasVBTableOffsetField(IM))
  mangleNumber(VBTableOffset);
636}

638void
639MicrosoftCXXNameMangler::mangleMemberFunctionPointer(const CXXRecordDecl *RD,
                                                   const CXXMethodDecl *MD) {
// <member-function-pointer> ::= $1? <name>
//                           ::= $H? <name> <number>
//                           ::= $I? <name> <number> <number>
//                           ::= $J? <name> <number> <number> <number>

MSInheritanceModel IM = RD->getMSInheritanceModel();

char Code = '\0';
switch (IM) {
case MSInheritanceModel::Single:      Code = '1'; break;
case MSInheritanceModel::Multiple:    Code = 'H'; break;
case MSInheritanceModel::Virtual:     Code = 'I'; break;
case MSInheritanceModel::Unspecified: Code = 'J'; break;
}

// If non-virtual, mangle the name.  If virtual, mangle as a virtual memptr
// thunk.
uint64_t NVOffset = 0;
uint64_t VBTableOffset = 0;
uint64_t VBPtrOffset = 0;
if (MD) {
  Out << '$' << Code << '?';
  if (MD->isVirtual()) {
    MicrosoftVTableContext *VTContext =
        cast<MicrosoftVTableContext>(getASTContext().getVTableContext());
    MethodVFTableLocation ML =
        VTContext->getMethodVFTableLocation(GlobalDecl(MD));
    mangleVirtualMemPtrThunk(MD, ML);
    NVOffset = ML.VFPtrOffset.getQuantity();
    VBTableOffset = ML.VBTableIndex * 4;
    if (ML.VBase) {
      const ASTRecordLayout &Layout = getASTContext().getASTRecordLayout(RD);
      VBPtrOffset = Layout.getVBPtrOffset().getQuantity();
    }
  } else {
    mangleName(MD);
    mangleFunctionEncoding(MD, /*ShouldMangle=*/true);
  }

  if (VBTableOffset == 0 && IM == MSInheritanceModel::Virtual)
    NVOffset -= getASTContext().getOffsetOfBaseWithVBPtr(RD).getQuantity();
} else {
  // Null single inheritance member functions are encoded as a simple nullptr.
  if (IM == MSInheritanceModel::Single) {
    Out << "$0A@";
    return;
  }
  if (IM == MSInheritanceModel::Unspecified)
    VBTableOffset = -1;
  Out << '$' << Code;
}

if (inheritanceModelHasNVOffsetField(/*IsMemberFunction=*/true, IM))
  mangleNumber(static_cast<uint32_t>(NVOffset));
if (inheritanceModelHasVBPtrOffsetField(IM))
  mangleNumber(VBPtrOffset);
if (inheritanceModelHasVBTableOffsetField(IM))
  mangleNumber(VBTableOffset);
699}

701void MicrosoftCXXNameMangler::mangleVirtualMemPtrThunk(
  const CXXMethodDecl *MD, const MethodVFTableLocation &ML) {
// Get the vftable offset.
CharUnits PointerWidth = getASTContext().toCharUnitsFromBits(
    getASTContext().getTargetInfo().getPointerWidth(0));
uint64_t OffsetInVFTable = ML.Index * PointerWidth.getQuantity();

Out << "?_9";
mangleName(MD->getParent());
Out << "$B";
mangleNumber(OffsetInVFTable);
Out << 'A';
mangleCallingConvention(MD->getType()->getAs<FunctionProtoType>());
2
←
Assuming the object is not a 'FunctionProtoType'→
3
←
Passing null pointer value via 1st parameter 'T'→
4
←
Calling 'MicrosoftCXXNameMangler::mangleCallingConvention'→
714}

716void MicrosoftCXXNameMangler::mangleName(const NamedDecl *ND) {
// <name> ::= <unscoped-name> {[<named-scope>]+ | [<nested-name>]}? @

// Always start with the unqualified name.
mangleUnqualifiedName(ND);

mangleNestedName(ND);

// Terminate the whole name with an '@'.
Out << '@';
726}

728void MicrosoftCXXNameMangler::mangleNumber(int64_t Number) {
// <non-negative integer> ::= A@              # when Number == 0
//                        ::= <decimal digit> # when 1 <= Number <= 10
//                        ::= <hex digit>+ @  # when Number >= 10
//
// <number>               ::= [?] <non-negative integer>

uint64_t Value = static_cast<uint64_t>(Number);
if (Number < 0) {
  Value = -Value;
  Out << '?';
}

if (Value == 0)
  Out << "A@";
else if (Value >= 1 && Value <= 10)
  Out << (Value - 1);
else {
  // Numbers that are not encoded as decimal digits are represented as nibbles
  // in the range of ASCII characters 'A' to 'P'.
  // The number 0x123450 would be encoded as 'BCDEFA'
  char EncodedNumberBuffer[sizeof(uint64_t) * 2];
  MutableArrayRef<char> BufferRef(EncodedNumberBuffer);
  MutableArrayRef<char>::reverse_iterator I = BufferRef.rbegin();
  for (; Value != 0; Value >>= 4)
    *I++ = 'A' + (Value & 0xf);
  Out.write(I.base(), I - BufferRef.rbegin());
  Out << '@';
}
757}

759static const TemplateDecl *
760isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs) {
// Check if we have a function template.
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
  if (const TemplateDecl *TD = FD->getPrimaryTemplate()) {
    TemplateArgs = FD->getTemplateSpecializationArgs();
    return TD;
  }
}

// Check if we have a class template.
if (const ClassTemplateSpecializationDecl *Spec =
        dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
  TemplateArgs = &Spec->getTemplateArgs();
  return Spec->getSpecializedTemplate();
}

// Check if we have a variable template.
if (const VarTemplateSpecializationDecl *Spec =
        dyn_cast<VarTemplateSpecializationDecl>(ND)) {
  TemplateArgs = &Spec->getTemplateArgs();
  return Spec->getSpecializedTemplate();
}

return nullptr;
784}

786void MicrosoftCXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND,
                                                  DeclarationName Name) {
//  <unqualified-name> ::= <operator-name>
//                     ::= <ctor-dtor-name>
//                     ::= <source-name>
//                     ::= <template-name>

// Check if we have a template.
const TemplateArgumentList *TemplateArgs = nullptr;
if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
  // Function templates aren't considered for name back referencing.  This
  // makes sense since function templates aren't likely to occur multiple
  // times in a symbol.
  if (isa<FunctionTemplateDecl>(TD)) {
    mangleTemplateInstantiationName(TD, *TemplateArgs);
    Out << '@';
    return;
  }

  // Here comes the tricky thing: if we need to mangle something like
  //   void foo(A::X<Y>, B::X<Y>),
  // the X<Y> part is aliased. However, if you need to mangle
  //   void foo(A::X<A::Y>, A::X<B::Y>),
  // the A::X<> part is not aliased.
  // That is, from the mangler's perspective we have a structure like this:
  //   namespace[s] -> type[ -> template-parameters]
  // but from the Clang perspective we have
  //   type [ -> template-parameters]
  //      \-> namespace[s]
  // What we do is we create a new mangler, mangle the same type (without
  // a namespace suffix) to a string using the extra mangler and then use
  // the mangled type name as a key to check the mangling of different types
  // for aliasing.

  // It's important to key cache reads off ND, not TD -- the same TD can
  // be used with different TemplateArgs, but ND uniquely identifies
  // TD / TemplateArg pairs.
  ArgBackRefMap::iterator Found = TemplateArgBackReferences.find(ND);
  if (Found == TemplateArgBackReferences.end()) {

    TemplateArgStringMap::iterator Found = TemplateArgStrings.find(ND);
    if (Found == TemplateArgStrings.end()) {
      // Mangle full template name into temporary buffer.
      llvm::SmallString<64> TemplateMangling;
      llvm::raw_svector_ostream Stream(TemplateMangling);
      MicrosoftCXXNameMangler Extra(Context, Stream);
      Extra.mangleTemplateInstantiationName(TD, *TemplateArgs);

      // Use the string backref vector to possibly get a back reference.
      mangleSourceName(TemplateMangling);

      // Memoize back reference for this type if one exist, else memoize
      // the mangling itself.
      BackRefVec::iterator StringFound =
          llvm::find(NameBackReferences, TemplateMangling);
      if (StringFound != NameBackReferences.end()) {
        TemplateArgBackReferences[ND] =
            StringFound - NameBackReferences.begin();
      } else {
        TemplateArgStrings[ND] =
            TemplateArgStringStorage.save(TemplateMangling.str());
      }
    } else {
      Out << Found->second << '@'; // Outputs a StringRef.
    }
  } else {
    Out << Found->second; // Outputs a back reference (an int).
  }
  return;
}

switch (Name.getNameKind()) {
  case DeclarationName::Identifier: {
    if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) {
      mangleSourceName(II->getName());
      break;
    }

    // Otherwise, an anonymous entity.  We must have a declaration.
    assert(ND && "mangling empty name without declaration")((ND && "mangling empty name without declaration") ? static_cast
<void> (0) : __assert_fail ("ND && \"mangling empty name without declaration\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 865, __PRETTY_FUNCTION__));

    if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
      if (NS->isAnonymousNamespace()) {
        Out << "?A0x" << Context.getAnonymousNamespaceHash() << '@';
        break;
      }
    }

    if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(ND)) {
      // Decomposition declarations are considered anonymous, and get
      // numbered with a $S prefix.
      llvm::SmallString<64> Name("$S");
      // Get a unique id for the anonymous struct.
      Name += llvm::utostr(Context.getAnonymousStructId(DD) + 1);
      mangleSourceName(Name);
      break;
    }

    if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
      // We must have an anonymous union or struct declaration.
      const CXXRecordDecl *RD = VD->getType()->getAsCXXRecordDecl();
      assert(RD && "expected variable decl to have a record type")((RD && "expected variable decl to have a record type"
) ? static_cast<void> (0) : __assert_fail ("RD && \"expected variable decl to have a record type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 887, __PRETTY_FUNCTION__));
      // Anonymous types with no tag or typedef get the name of their
      // declarator mangled in.  If they have no declarator, number them with
      // a $S prefix.
      llvm::SmallString<64> Name("$S");
      // Get a unique id for the anonymous struct.
      Name += llvm::utostr(Context.getAnonymousStructId(RD) + 1);
      mangleSourceName(Name.str());
      break;
    }

    // We must have an anonymous struct.
    const TagDecl *TD = cast<TagDecl>(ND);
    if (const TypedefNameDecl *D = TD->getTypedefNameForAnonDecl()) {
      assert(TD->getDeclContext() == D->getDeclContext() &&((TD->getDeclContext() == D->getDeclContext() &&
 "Typedef should not be in another decl context!") ? static_cast
<void> (0) : __assert_fail ("TD->getDeclContext() == D->getDeclContext() && \"Typedef should not be in another decl context!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 902, __PRETTY_FUNCTION__))
             "Typedef should not be in another decl context!")((TD->getDeclContext() == D->getDeclContext() &&
 "Typedef should not be in another decl context!") ? static_cast
<void> (0) : __assert_fail ("TD->getDeclContext() == D->getDeclContext() && \"Typedef should not be in another decl context!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 902, __PRETTY_FUNCTION__));
      assert(D->getDeclName().getAsIdentifierInfo() &&((D->getDeclName().getAsIdentifierInfo() && "Typedef was not named!"
) ? static_cast<void> (0) : __assert_fail ("D->getDeclName().getAsIdentifierInfo() && \"Typedef was not named!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 904, __PRETTY_FUNCTION__))
             "Typedef was not named!")((D->getDeclName().getAsIdentifierInfo() && "Typedef was not named!"
) ? static_cast<void> (0) : __assert_fail ("D->getDeclName().getAsIdentifierInfo() && \"Typedef was not named!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 904, __PRETTY_FUNCTION__));
      mangleSourceName(D->getDeclName().getAsIdentifierInfo()->getName());
      break;
    }

    if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) {
      if (Record->isLambda()) {
        llvm::SmallString<10> Name("<lambda_");

        Decl *LambdaContextDecl = Record->getLambdaContextDecl();
        unsigned LambdaManglingNumber = Record->getLambdaManglingNumber();
        unsigned LambdaId;
        const ParmVarDecl *Parm =
            dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
        const FunctionDecl *Func =
            Parm ? dyn_cast<FunctionDecl>(Parm->getDeclContext()) : nullptr;

        if (Func) {
          unsigned DefaultArgNo =
              Func->getNumParams() - Parm->getFunctionScopeIndex();
          Name += llvm::utostr(DefaultArgNo);
          Name += "_";
        }

        if (LambdaManglingNumber)
          LambdaId = LambdaManglingNumber;
        else
          LambdaId = Context.getLambdaId(Record);

        Name += llvm::utostr(LambdaId);
        Name += ">";

        mangleSourceName(Name);

        // If the context of a closure type is an initializer for a class
        // member (static or nonstatic), it is encoded in a qualified name.
        if (LambdaManglingNumber && LambdaContextDecl) {
          if ((isa<VarDecl>(LambdaContextDecl) ||
               isa<FieldDecl>(LambdaContextDecl)) &&
              LambdaContextDecl->getDeclContext()->isRecord()) {
            mangleUnqualifiedName(cast<NamedDecl>(LambdaContextDecl));
          }
        }
        break;
      }
    }

    llvm::SmallString<64> Name;
    if (DeclaratorDecl *DD =
            Context.getASTContext().getDeclaratorForUnnamedTagDecl(TD)) {
      // Anonymous types without a name for linkage purposes have their
      // declarator mangled in if they have one.
      Name += "<unnamed-type-";
      Name += DD->getName();
    } else if (TypedefNameDecl *TND =
                   Context.getASTContext().getTypedefNameForUnnamedTagDecl(
                       TD)) {
      // Anonymous types without a name for linkage purposes have their
      // associate typedef mangled in if they have one.
      Name += "<unnamed-type-";
      Name += TND->getName();
    } else if (isa<EnumDecl>(TD) &&
               cast<EnumDecl>(TD)->enumerator_begin() !=
                   cast<EnumDecl>(TD)->enumerator_end()) {
      // Anonymous non-empty enums mangle in the first enumerator.
      auto *ED = cast<EnumDecl>(TD);
      Name += "<unnamed-enum-";
      Name += ED->enumerator_begin()->getName();
    } else {
      // Otherwise, number the types using a $S prefix.
      Name += "<unnamed-type-$S";
      Name += llvm::utostr(Context.getAnonymousStructId(TD) + 1);
    }
    Name += ">";
    mangleSourceName(Name.str());
    break;
  }

  case DeclarationName::ObjCZeroArgSelector:
  case DeclarationName::ObjCOneArgSelector:
  case DeclarationName::ObjCMultiArgSelector: {
    // This is reachable only when constructing an outlined SEH finally
    // block.  Nothing depends on this mangling and it's used only with
    // functinos with internal linkage.
    llvm::SmallString<64> Name;
    mangleSourceName(Name.str());
    break;
  }

  case DeclarationName::CXXConstructorName:
    if (isStructorDecl(ND)) {
      if (StructorType == Ctor_CopyingClosure) {
        Out << "?_O";
        return;
      }
      if (StructorType == Ctor_DefaultClosure) {
        Out << "?_F";
        return;
      }
    }
    Out << "?0";
    return;

  case DeclarationName::CXXDestructorName:
    if (isStructorDecl(ND))
      // If the named decl is the C++ destructor we're mangling,
      // use the type we were given.
      mangleCXXDtorType(static_cast<CXXDtorType>(StructorType));
    else
      // Otherwise, use the base destructor name. This is relevant if a
      // class with a destructor is declared within a destructor.
      mangleCXXDtorType(Dtor_Base);
    break;

  case DeclarationName::CXXConversionFunctionName:
    // <operator-name> ::= ?B # (cast)
    // The target type is encoded as the return type.
    Out << "?B";
    break;

  case DeclarationName::CXXOperatorName:
    mangleOperatorName(Name.getCXXOverloadedOperator(), ND->getLocation());
    break;

  case DeclarationName::CXXLiteralOperatorName: {
    Out << "?__K";
    mangleSourceName(Name.getCXXLiteralIdentifier()->getName());
    break;
  }

  case DeclarationName::CXXDeductionGuideName:
    llvm_unreachable("Can't mangle a deduction guide name!")::llvm::llvm_unreachable_internal("Can't mangle a deduction guide name!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1035);

  case DeclarationName::CXXUsingDirective:
    llvm_unreachable("Can't mangle a using directive name!")::llvm::llvm_unreachable_internal("Can't mangle a using directive name!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1038);
}
1040}

1042// <postfix> ::= <unqualified-name> [<postfix>]
1043//           ::= <substitution> [<postfix>]
1044void MicrosoftCXXNameMangler::mangleNestedName(const NamedDecl *ND) {
const DeclContext *DC = getEffectiveDeclContext(ND);
while (!DC->isTranslationUnit()) {
  if (isa<TagDecl>(ND) || isa<VarDecl>(ND)) {
    unsigned Disc;
    if (Context.getNextDiscriminator(ND, Disc)) {
      Out << '?';
      mangleNumber(Disc);
      Out << '?';
    }
  }

  if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) {
    auto Discriminate =
        [](StringRef Name, const unsigned Discriminator,
           const unsigned ParameterDiscriminator) -> std::string {
      std::string Buffer;
      llvm::raw_string_ostream Stream(Buffer);
      Stream << Name;
      if (Discriminator)
        Stream << '_' << Discriminator;
      if (ParameterDiscriminator)
        Stream << '_' << ParameterDiscriminator;
      return Stream.str();
    };

    unsigned Discriminator = BD->getBlockManglingNumber();
    if (!Discriminator)
      Discriminator = Context.getBlockId(BD, /*Local=*/false);

    // Mangle the parameter position as a discriminator to deal with unnamed
    // parameters.  Rather than mangling the unqualified parameter name,
    // always use the position to give a uniform mangling.
    unsigned ParameterDiscriminator = 0;
    if (const auto *MC = BD->getBlockManglingContextDecl())
      if (const auto *P = dyn_cast<ParmVarDecl>(MC))
        if (const auto *F = dyn_cast<FunctionDecl>(P->getDeclContext()))
          ParameterDiscriminator =
              F->getNumParams() - P->getFunctionScopeIndex();

    DC = getEffectiveDeclContext(BD);

    Out << '?';
    mangleSourceName(Discriminate("_block_invoke", Discriminator,
                                  ParameterDiscriminator));
    // If we have a block mangling context, encode that now.  This allows us
    // to discriminate between named static data initializers in the same
    // scope.  This is handled differently from parameters, which use
    // positions to discriminate between multiple instances.
    if (const auto *MC = BD->getBlockManglingContextDecl())
      if (!isa<ParmVarDecl>(MC))
        if (const auto *ND = dyn_cast<NamedDecl>(MC))
          mangleUnqualifiedName(ND);
    // MS ABI and Itanium manglings are in inverted scopes.  In the case of a
    // RecordDecl, mangle the entire scope hierarchy at this point rather than
    // just the unqualified name to get the ordering correct.
    if (const auto *RD = dyn_cast<RecordDecl>(DC))
      mangleName(RD);
    else
      Out << '@';
    // void __cdecl
    Out << "YAX";
    // struct __block_literal *
    Out << 'P';
    // __ptr64
    if (PointersAre64Bit)
      Out << 'E';
    Out << 'A';
    mangleArtificialTagType(TTK_Struct,
                           Discriminate("__block_literal", Discriminator,
                                        ParameterDiscriminator));
    Out << "@Z";

    // If the effective context was a Record, we have fully mangled the
    // qualified name and do not need to continue.
    if (isa<RecordDecl>(DC))
      break;
    continue;
  } else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) {
    mangleObjCMethodName(Method);
  } else if (isa<NamedDecl>(DC)) {
    ND = cast<NamedDecl>(DC);
    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
      mangle(FD, "?");
      break;
    } else {
      mangleUnqualifiedName(ND);
      // Lambdas in default arguments conceptually belong to the function the
      // parameter corresponds to.
      if (const auto *LDADC = getLambdaDefaultArgumentDeclContext(ND)) {
        DC = LDADC;
        continue;
      }
    }
  }
  DC = DC->getParent();
}
1141}

1143void MicrosoftCXXNameMangler::mangleCXXDtorType(CXXDtorType T) {
// Microsoft uses the names on the case labels for these dtor variants.  Clang
// uses the Itanium terminology internally.  Everything in this ABI delegates
// towards the base dtor.
switch (T) {
// <operator-name> ::= ?1  # destructor
case Dtor_Base: Out << "?1"; return;
// <operator-name> ::= ?_D # vbase destructor
case Dtor_Complete: Out << "?_D"; return;
// <operator-name> ::= ?_G # scalar deleting destructor
case Dtor_Deleting: Out << "?_G"; return;
// <operator-name> ::= ?_E # vector deleting destructor
// FIXME: Add a vector deleting dtor type.  It goes in the vtable, so we need
// it.
case Dtor_Comdat:
  llvm_unreachable("not expecting a COMDAT")::llvm::llvm_unreachable_internal("not expecting a COMDAT", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1158);
}
llvm_unreachable("Unsupported dtor type?")::llvm::llvm_unreachable_internal("Unsupported dtor type?", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1160);
1161}

1163void MicrosoftCXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO,
                                               SourceLocation Loc) {
switch (OO) {
//                     ?0 # constructor
//                     ?1 # destructor
// <operator-name> ::= ?2 # new
case OO_New: Out << "?2"; break;
// <operator-name> ::= ?3 # delete
case OO_Delete: Out << "?3"; break;
// <operator-name> ::= ?4 # =
case OO_Equal: Out << "?4"; break;
// <operator-name> ::= ?5 # >>
case OO_GreaterGreater: Out << "?5"; break;
// <operator-name> ::= ?6 # <<
case OO_LessLess: Out << "?6"; break;
// <operator-name> ::= ?7 # !
case OO_Exclaim: Out << "?7"; break;
// <operator-name> ::= ?8 # ==
case OO_EqualEqual: Out << "?8"; break;
// <operator-name> ::= ?9 # !=
case OO_ExclaimEqual: Out << "?9"; break;
// <operator-name> ::= ?A # []
case OO_Subscript: Out << "?A"; break;
//                     ?B # conversion
// <operator-name> ::= ?C # ->
case OO_Arrow: Out << "?C"; break;
// <operator-name> ::= ?D # *
case OO_Star: Out << "?D"; break;
// <operator-name> ::= ?E # ++
case OO_PlusPlus: Out << "?E"; break;
// <operator-name> ::= ?F # --
case OO_MinusMinus: Out << "?F"; break;
// <operator-name> ::= ?G # -
case OO_Minus: Out << "?G"; break;
// <operator-name> ::= ?H # +
case OO_Plus: Out << "?H"; break;
// <operator-name> ::= ?I # &
case OO_Amp: Out << "?I"; break;
// <operator-name> ::= ?J # ->*
case OO_ArrowStar: Out << "?J"; break;
// <operator-name> ::= ?K # /
case OO_Slash: Out << "?K"; break;
// <operator-name> ::= ?L # %
case OO_Percent: Out << "?L"; break;
// <operator-name> ::= ?M # <
case OO_Less: Out << "?M"; break;
// <operator-name> ::= ?N # <=
case OO_LessEqual: Out << "?N"; break;
// <operator-name> ::= ?O # >
case OO_Greater: Out << "?O"; break;
// <operator-name> ::= ?P # >=
case OO_GreaterEqual: Out << "?P"; break;
// <operator-name> ::= ?Q # ,
case OO_Comma: Out << "?Q"; break;
// <operator-name> ::= ?R # ()
case OO_Call: Out << "?R"; break;
// <operator-name> ::= ?S # ~
case OO_Tilde: Out << "?S"; break;
// <operator-name> ::= ?T # ^
case OO_Caret: Out << "?T"; break;
// <operator-name> ::= ?U # |
case OO_Pipe: Out << "?U"; break;
// <operator-name> ::= ?V # &&
case OO_AmpAmp: Out << "?V"; break;
// <operator-name> ::= ?W # ||
case OO_PipePipe: Out << "?W"; break;
// <operator-name> ::= ?X # *=
case OO_StarEqual: Out << "?X"; break;
// <operator-name> ::= ?Y # +=
case OO_PlusEqual: Out << "?Y"; break;
// <operator-name> ::= ?Z # -=
case OO_MinusEqual: Out << "?Z"; break;
// <operator-name> ::= ?_0 # /=
case OO_SlashEqual: Out << "?_0"; break;
// <operator-name> ::= ?_1 # %=
case OO_PercentEqual: Out << "?_1"; break;
// <operator-name> ::= ?_2 # >>=
case OO_GreaterGreaterEqual: Out << "?_2"; break;
// <operator-name> ::= ?_3 # <<=
case OO_LessLessEqual: Out << "?_3"; break;
// <operator-name> ::= ?_4 # &=
case OO_AmpEqual: Out << "?_4"; break;
// <operator-name> ::= ?_5 # |=
case OO_PipeEqual: Out << "?_5"; break;
// <operator-name> ::= ?_6 # ^=
case OO_CaretEqual: Out << "?_6"; break;
//                     ?_7 # vftable
//                     ?_8 # vbtable
//                     ?_9 # vcall
//                     ?_A # typeof
//                     ?_B # local static guard
//                     ?_C # string
//                     ?_D # vbase destructor
//                     ?_E # vector deleting destructor
//                     ?_F # default constructor closure
//                     ?_G # scalar deleting destructor
//                     ?_H # vector constructor iterator
//                     ?_I # vector destructor iterator
//                     ?_J # vector vbase constructor iterator
//                     ?_K # virtual displacement map
//                     ?_L # eh vector constructor iterator
//                     ?_M # eh vector destructor iterator
//                     ?_N # eh vector vbase constructor iterator
//                     ?_O # copy constructor closure
//                     ?_P<name> # udt returning <name>
//                     ?_Q # <unknown>
//                     ?_R0 # RTTI Type Descriptor
//                     ?_R1 # RTTI Base Class Descriptor at (a,b,c,d)
//                     ?_R2 # RTTI Base Class Array
//                     ?_R3 # RTTI Class Hierarchy Descriptor
//                     ?_R4 # RTTI Complete Object Locator
//                     ?_S # local vftable
//                     ?_T # local vftable constructor closure
// <operator-name> ::= ?_U # new[]
case OO_Array_New: Out << "?_U"; break;
// <operator-name> ::= ?_V # delete[]
case OO_Array_Delete: Out << "?_V"; break;
// <operator-name> ::= ?__L # co_await
case OO_Coawait: Out << "?__L"; break;
// <operator-name> ::= ?__M # <=>
case OO_Spaceship: Out << "?__M"; break;

case OO_Conditional: {
  DiagnosticsEngine &Diags = Context.getDiags();
  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
    "cannot mangle this conditional operator yet");
  Diags.Report(Loc, DiagID);
  break;
}

case OO_None:
case NUM_OVERLOADED_OPERATORS:
  llvm_unreachable("Not an overloaded operator")::llvm::llvm_unreachable_internal("Not an overloaded operator"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1295);
}
1297}

1299void MicrosoftCXXNameMangler::mangleSourceName(StringRef Name) {
// <source name> ::= <identifier> @
BackRefVec::iterator Found = llvm::find(NameBackReferences, Name);
if (Found == NameBackReferences.end()) {
  if (NameBackReferences.size() < 10)
    NameBackReferences.push_back(Name);
  Out << Name << '@';
} else {
  Out << (Found - NameBackReferences.begin());
}
1309}

1311void MicrosoftCXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) {
Context.mangleObjCMethodName(MD, Out);
1313}

1315void MicrosoftCXXNameMangler::mangleTemplateInstantiationName(
  const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) {
// <template-name> ::= <unscoped-template-name> <template-args>
//                 ::= <substitution>
// Always start with the unqualified name.

// Templates have their own context for back references.
ArgBackRefMap OuterFunArgsContext;
ArgBackRefMap OuterTemplateArgsContext;
BackRefVec OuterTemplateContext;
PassObjectSizeArgsSet OuterPassObjectSizeArgs;
NameBackReferences.swap(OuterTemplateContext);
FunArgBackReferences.swap(OuterFunArgsContext);
TemplateArgBackReferences.swap(OuterTemplateArgsContext);
PassObjectSizeArgs.swap(OuterPassObjectSizeArgs);

mangleUnscopedTemplateName(TD);
mangleTemplateArgs(TD, TemplateArgs);

// Restore the previous back reference contexts.
NameBackReferences.swap(OuterTemplateContext);
FunArgBackReferences.swap(OuterFunArgsContext);
TemplateArgBackReferences.swap(OuterTemplateArgsContext);
PassObjectSizeArgs.swap(OuterPassObjectSizeArgs);
1339}

1341void
1342MicrosoftCXXNameMangler::mangleUnscopedTemplateName(const TemplateDecl *TD) {
// <unscoped-template-name> ::= ?$ <unqualified-name>
Out << "?$";
mangleUnqualifiedName(TD);
1346}

1348void MicrosoftCXXNameMangler::mangleIntegerLiteral(const llvm::APSInt &Value,
                                                 bool IsBoolean) {
// <integer-literal> ::= $0 <number>
Out << "$0";
// Make sure booleans are encoded as 0/1.
if (IsBoolean && Value.getBoolValue())
  mangleNumber(1);
else if (Value.isSigned())
  mangleNumber(Value.getSExtValue());
else
  mangleNumber(Value.getZExtValue());
1359}

1361void MicrosoftCXXNameMangler::mangleExpression(const Expr *E) {
// See if this is a constant expression.
llvm::APSInt Value;
if (E->isIntegerConstantExpr(Value, Context.getASTContext())) {
  mangleIntegerLiteral(Value, E->getType()->isBooleanType());
  return;
}

// Look through no-op casts like template parameter substitutions.
E = E->IgnoreParenNoopCasts(Context.getASTContext());

const CXXUuidofExpr *UE = nullptr;
if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
  if (UO->getOpcode() == UO_AddrOf)
    UE = dyn_cast<CXXUuidofExpr>(UO->getSubExpr());
} else
  UE = dyn_cast<CXXUuidofExpr>(E);

if (UE) {
  // If we had to peek through an address-of operator, treat this like we are
  // dealing with a pointer type.  Otherwise, treat it like a const reference.
  //
  // N.B. This matches up with the handling of TemplateArgument::Declaration
  // in mangleTemplateArg
  if (UE == E)
    Out << "$E?";
  else
    Out << "$1?";

  // This CXXUuidofExpr is mangled as-if it were actually a VarDecl from
  // const __s_GUID _GUID_{lower case UUID with underscores}
  StringRef Uuid = UE->getUuidStr();
  std::string Name = "_GUID_" + Uuid.lower();
  std::replace(Name.begin(), Name.end(), '-', '_');

  mangleSourceName(Name);
  // Terminate the whole name with an '@'.
  Out << '@';
  // It's a global variable.
  Out << '3';
  // It's a struct called __s_GUID.
  mangleArtificialTagType(TTK_Struct, "__s_GUID");
  // It's const.
  Out << 'B';
  return;
}

// As bad as this diagnostic is, it's better than crashing.
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(
    DiagnosticsEngine::Error, "cannot yet mangle expression type %0");
Diags.Report(E->getExprLoc(), DiagID) << E->getStmtClassName()
                                      << E->getSourceRange();
1414}

1416void MicrosoftCXXNameMangler::mangleTemplateArgs(
  const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) {
// <template-args> ::= <template-arg>+
const TemplateParameterList *TPL = TD->getTemplateParameters();
assert(TPL->size() == TemplateArgs.size() &&((TPL->size() == TemplateArgs.size() && "size mismatch between args and parms!"
) ? static_cast<void> (0) : __assert_fail ("TPL->size() == TemplateArgs.size() && \"size mismatch between args and parms!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1421, __PRETTY_FUNCTION__))
       "size mismatch between args and parms!")((TPL->size() == TemplateArgs.size() && "size mismatch between args and parms!"
) ? static_cast<void> (0) : __assert_fail ("TPL->size() == TemplateArgs.size() && \"size mismatch between args and parms!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1421, __PRETTY_FUNCTION__));

for (size_t i = 0; i < TemplateArgs.size(); ++i) {
  const TemplateArgument &TA = TemplateArgs[i];

  // Separate consecutive packs by $$Z.
  if (i > 0 && TA.getKind() == TemplateArgument::Pack &&
      TemplateArgs[i - 1].getKind() == TemplateArgument::Pack)
    Out << "$$Z";

  mangleTemplateArg(TD, TA, TPL->getParam(i));
}
1433}

1435void MicrosoftCXXNameMangler::mangleTemplateArg(const TemplateDecl *TD,
                                              const TemplateArgument &TA,
                                              const NamedDecl *Parm) {
// <template-arg> ::= <type>
//                ::= <integer-literal>
//                ::= <member-data-pointer>
//                ::= <member-function-pointer>
//                ::= $E? <name> <type-encoding>
//                ::= $1? <name> <type-encoding>
//                ::= $0A@
//                ::= <template-args>

switch (TA.getKind()) {
case TemplateArgument::Null:
  llvm_unreachable("Can't mangle null template arguments!")::llvm::llvm_unreachable_internal("Can't mangle null template arguments!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1449);
case TemplateArgument::TemplateExpansion:
  llvm_unreachable("Can't mangle template expansion arguments!")::llvm::llvm_unreachable_internal("Can't mangle template expansion arguments!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1451);
case TemplateArgument::Type: {
  QualType T = TA.getAsType();
  mangleType(T, SourceRange(), QMM_Escape);
  break;
}
case TemplateArgument::Declaration: {
  const NamedDecl *ND = TA.getAsDecl();
  if (isa<FieldDecl>(ND) || isa<IndirectFieldDecl>(ND)) {
    mangleMemberDataPointer(cast<CXXRecordDecl>(ND->getDeclContext())
                                ->getMostRecentNonInjectedDecl(),
                            cast<ValueDecl>(ND));
  } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
    const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
    if (MD && MD->isInstance()) {
      mangleMemberFunctionPointer(
          MD->getParent()->getMostRecentNonInjectedDecl(), MD);
    } else {
      Out << "$1?";
      mangleName(FD);
      mangleFunctionEncoding(FD, /*ShouldMangle=*/true);
    }
  } else {
    mangle(ND, TA.getParamTypeForDecl()->isReferenceType() ? "$E?" : "$1?");
  }
  break;
}
case TemplateArgument::Integral:
  mangleIntegerLiteral(TA.getAsIntegral(),
                       TA.getIntegralType()->isBooleanType());
  break;
case TemplateArgument::NullPtr: {
  QualType T = TA.getNullPtrType();
  if (const MemberPointerType *MPT = T->getAs<MemberPointerType>()) {
    const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
    if (MPT->isMemberFunctionPointerType() &&
        !isa<FunctionTemplateDecl>(TD)) {
      mangleMemberFunctionPointer(RD, nullptr);
      return;
    }
    if (MPT->isMemberDataPointer()) {
      if (!isa<FunctionTemplateDecl>(TD)) {
        mangleMemberDataPointer(RD, nullptr);
        return;
      }
      // nullptr data pointers are always represented with a single field
      // which is initialized with either 0 or -1.  Why -1?  Well, we need to
      // distinguish the case where the data member is at offset zero in the
      // record.
      // However, we are free to use 0 *if* we would use multiple fields for
      // non-nullptr member pointers.
      if (!RD->nullFieldOffsetIsZero()) {
        mangleIntegerLiteral(llvm::APSInt::get(-1), /*IsBoolean=*/false);
        return;
      }
    }
  }
  mangleIntegerLiteral(llvm::APSInt::getUnsigned(0), /*IsBoolean=*/false);
  break;
}
case TemplateArgument::Expression:
  mangleExpression(TA.getAsExpr());
  break;
case TemplateArgument::Pack: {
  ArrayRef<TemplateArgument> TemplateArgs = TA.getPackAsArray();
  if (TemplateArgs.empty()) {
    if (isa<TemplateTypeParmDecl>(Parm) ||
        isa<TemplateTemplateParmDecl>(Parm))
      // MSVC 2015 changed the mangling for empty expanded template packs,
      // use the old mangling for link compatibility for old versions.
      Out << (Context.getASTContext().getLangOpts().isCompatibleWithMSVC(
                  LangOptions::MSVC2015)
                  ? "$$V"
                  : "$$$V");
    else if (isa<NonTypeTemplateParmDecl>(Parm))
      Out << "$S";
    else
      llvm_unreachable("unexpected template parameter decl!")::llvm::llvm_unreachable_internal("unexpected template parameter decl!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1528);
  } else {
    for (const TemplateArgument &PA : TemplateArgs)
      mangleTemplateArg(TD, PA, Parm);
  }
  break;
}
case TemplateArgument::Template: {
  const NamedDecl *ND =
      TA.getAsTemplate().getAsTemplateDecl()->getTemplatedDecl();
  if (const auto *TD = dyn_cast<TagDecl>(ND)) {
    mangleType(TD);
  } else if (isa<TypeAliasDecl>(ND)) {
    Out << "$$Y";
    mangleName(ND);
  } else {
    llvm_unreachable("unexpected template template NamedDecl!")::llvm::llvm_unreachable_internal("unexpected template template NamedDecl!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1544);
  }
  break;
}
}
1549}

1551void MicrosoftCXXNameMangler::mangleObjCProtocol(const ObjCProtocolDecl *PD) {
llvm::SmallString<64> TemplateMangling;
llvm::raw_svector_ostream Stream(TemplateMangling);
MicrosoftCXXNameMangler Extra(Context, Stream);

Stream << "?$";
Extra.mangleSourceName("Protocol");
Extra.mangleArtificialTagType(TTK_Struct, PD->getName());

mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
1561}

1563void MicrosoftCXXNameMangler::mangleObjCLifetime(const QualType Type,
                                               Qualifiers Quals,
                                               SourceRange Range) {
llvm::SmallString<64> TemplateMangling;
llvm::raw_svector_ostream Stream(TemplateMangling);
MicrosoftCXXNameMangler Extra(Context, Stream);

Stream << "?$";
switch (Quals.getObjCLifetime()) {
case Qualifiers::OCL_None:
case Qualifiers::OCL_ExplicitNone:
  break;
case Qualifiers::OCL_Autoreleasing:
  Extra.mangleSourceName("Autoreleasing");
  break;
case Qualifiers::OCL_Strong:
  Extra.mangleSourceName("Strong");
  break;
case Qualifiers::OCL_Weak:
  Extra.mangleSourceName("Weak");
  break;
}
Extra.manglePointerCVQualifiers(Quals);
Extra.manglePointerExtQualifiers(Quals, Type);
Extra.mangleType(Type, Range);

mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
1590}

1592void MicrosoftCXXNameMangler::mangleObjCKindOfType(const ObjCObjectType *T,
                                                 Qualifiers Quals,
                                                 SourceRange Range) {
llvm::SmallString<64> TemplateMangling;
llvm::raw_svector_ostream Stream(TemplateMangling);
MicrosoftCXXNameMangler Extra(Context, Stream);

Stream << "?$";
Extra.mangleSourceName("KindOf");
Extra.mangleType(QualType(T, 0)
                     .stripObjCKindOfType(getASTContext())
                     ->getAs<ObjCObjectType>(),
                 Quals, Range);

mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
1607}

1609void MicrosoftCXXNameMangler::mangleQualifiers(Qualifiers Quals,
                                             bool IsMember) {
// <cvr-qualifiers> ::= [E] [F] [I] <base-cvr-qualifiers>
// 'E' means __ptr64 (32-bit only); 'F' means __unaligned (32/64-bit only);
// 'I' means __restrict (32/64-bit).
// Note that the MSVC __restrict keyword isn't the same as the C99 restrict
// keyword!
// <base-cvr-qualifiers> ::= A  # near
//                       ::= B  # near const
//                       ::= C  # near volatile
//                       ::= D  # near const volatile
//                       ::= E  # far (16-bit)
//                       ::= F  # far const (16-bit)
//                       ::= G  # far volatile (16-bit)
//                       ::= H  # far const volatile (16-bit)
//                       ::= I  # huge (16-bit)
//                       ::= J  # huge const (16-bit)
//                       ::= K  # huge volatile (16-bit)
//                       ::= L  # huge const volatile (16-bit)
//                       ::= M <basis> # based
//                       ::= N <basis> # based const
//                       ::= O <basis> # based volatile
//                       ::= P <basis> # based const volatile
//                       ::= Q  # near member
//                       ::= R  # near const member
//                       ::= S  # near volatile member
//                       ::= T  # near const volatile member
//                       ::= U  # far member (16-bit)
//                       ::= V  # far const member (16-bit)
//                       ::= W  # far volatile member (16-bit)
//                       ::= X  # far const volatile member (16-bit)
//                       ::= Y  # huge member (16-bit)
//                       ::= Z  # huge const member (16-bit)
//                       ::= 0  # huge volatile member (16-bit)
//                       ::= 1  # huge const volatile member (16-bit)
//                       ::= 2 <basis> # based member
//                       ::= 3 <basis> # based const member
//                       ::= 4 <basis> # based volatile member
//                       ::= 5 <basis> # based const volatile member
//                       ::= 6  # near function (pointers only)
//                       ::= 7  # far function (pointers only)
//                       ::= 8  # near method (pointers only)
//                       ::= 9  # far method (pointers only)
//                       ::= _A <basis> # based function (pointers only)
//                       ::= _B <basis> # based function (far?) (pointers only)
//                       ::= _C <basis> # based method (pointers only)
//                       ::= _D <basis> # based method (far?) (pointers only)
//                       ::= _E # block (Clang)
// <basis> ::= 0 # __based(void)
//         ::= 1 # __based(segment)?
//         ::= 2 <name> # __based(name)
//         ::= 3 # ?
//         ::= 4 # ?
//         ::= 5 # not really based
bool HasConst = Quals.hasConst(),
     HasVolatile = Quals.hasVolatile();

if (!IsMember) {
  if (HasConst && HasVolatile) {
    Out << 'D';
  } else if (HasVolatile) {
    Out << 'C';
  } else if (HasConst) {
    Out << 'B';
  } else {
    Out << 'A';
  }
} else {
  if (HasConst && HasVolatile) {
    Out << 'T';
  } else if (HasVolatile) {
    Out << 'S';
  } else if (HasConst) {
    Out << 'R';
  } else {
    Out << 'Q';
  }
}

// FIXME: For now, just drop all extension qualifiers on the floor.
1689}

1691void
1692MicrosoftCXXNameMangler::mangleRefQualifier(RefQualifierKind RefQualifier) {
// <ref-qualifier> ::= G                # lvalue reference
//                 ::= H                # rvalue-reference
switch (RefQualifier) {
case RQ_None:
  break;

case RQ_LValue:
  Out << 'G';
  break;

case RQ_RValue:
  Out << 'H';
  break;
}
1707}

1709void MicrosoftCXXNameMangler::manglePointerExtQualifiers(Qualifiers Quals,
                                                       QualType PointeeType) {
// Check if this is a default 64-bit pointer or has __ptr64 qualifier.
bool is64Bit = PointeeType.isNull() ? PointersAre64Bit :
    is64BitPointer(PointeeType.getQualifiers());
if (is64Bit && (PointeeType.isNull() || !PointeeType->isFunctionType()))
  Out << 'E';

if (Quals.hasRestrict())
  Out << 'I';

if (Quals.hasUnaligned() ||
    (!PointeeType.isNull() && PointeeType.getLocalQualifiers().hasUnaligned()))
  Out << 'F';
1723}

1725void MicrosoftCXXNameMangler::manglePointerCVQualifiers(Qualifiers Quals) {
// <pointer-cv-qualifiers> ::= P  # no qualifiers
//                         ::= Q  # const
//                         ::= R  # volatile
//                         ::= S  # const volatile
bool HasConst = Quals.hasConst(),
     HasVolatile = Quals.hasVolatile();

if (HasConst && HasVolatile) {
  Out << 'S';
} else if (HasVolatile) {
  Out << 'R';
} else if (HasConst) {
  Out << 'Q';
} else {
  Out << 'P';
}
1742}

1744void MicrosoftCXXNameMangler::mangleFunctionArgumentType(QualType T,
                                                       SourceRange Range) {
// MSVC will backreference two canonically equivalent types that have slightly
// different manglings when mangled alone.

// Decayed types do not match up with non-decayed versions of the same type.
//
// e.g.
// void (*x)(void) will not form a backreference with void x(void)
void *TypePtr;
if (const auto *DT = T->getAs<DecayedType>()) {
  QualType OriginalType = DT->getOriginalType();
  // All decayed ArrayTypes should be treated identically; as-if they were
  // a decayed IncompleteArrayType.
  if (const auto *AT = getASTContext().getAsArrayType(OriginalType))
    OriginalType = getASTContext().getIncompleteArrayType(
        AT->getElementType(), AT->getSizeModifier(),
        AT->getIndexTypeCVRQualifiers());

  TypePtr = OriginalType.getCanonicalType().getAsOpaquePtr();
  // If the original parameter was textually written as an array,
  // instead treat the decayed parameter like it's const.
  //
  // e.g.
  // int [] -> int * const
  if (OriginalType->isArrayType())
    T = T.withConst();
} else {
  TypePtr = T.getCanonicalType().getAsOpaquePtr();
}

ArgBackRefMap::iterator Found = FunArgBackReferences.find(TypePtr);

if (Found == FunArgBackReferences.end()) {
  size_t OutSizeBefore = Out.tell();

  mangleType(T, Range, QMM_Drop);

  // See if it's worth creating a back reference.
  // Only types longer than 1 character are considered
  // and only 10 back references slots are available:
  bool LongerThanOneChar = (Out.tell() - OutSizeBefore > 1);
  if (LongerThanOneChar && FunArgBackReferences.size() < 10) {
    size_t Size = FunArgBackReferences.size();
    FunArgBackReferences[TypePtr] = Size;
  }
} else {
  Out << Found->second;
}
1793}

1795void MicrosoftCXXNameMangler::manglePassObjectSizeArg(
  const PassObjectSizeAttr *POSA) {
int Type = POSA->getType();
bool Dynamic = POSA->isDynamic();

auto Iter = PassObjectSizeArgs.insert({Type, Dynamic}).first;
auto *TypePtr = (const void *)&*Iter;
ArgBackRefMap::iterator Found = FunArgBackReferences.find(TypePtr);

if (Found == FunArgBackReferences.end()) {
  std::string Name =
      Dynamic ? "__pass_dynamic_object_size" : "__pass_object_size";
  mangleArtificialTagType(TTK_Enum, Name + llvm::utostr(Type), {"__clang"});

  if (FunArgBackReferences.size() < 10) {
    size_t Size = FunArgBackReferences.size();
    FunArgBackReferences[TypePtr] = Size;
  }
} else {
  Out << Found->second;
}
1816}

1818void MicrosoftCXXNameMangler::mangleAddressSpaceType(QualType T,
                                                   Qualifiers Quals,
                                                   SourceRange Range) {
// Address space is mangled as an unqualified templated type in the __clang
// namespace. The demangled version of this is:
// In the case of a language specific address space:
// __clang::struct _AS[language_addr_space]<Type>
// where:
//  <language_addr_space> ::= <OpenCL-addrspace> | <CUDA-addrspace>
//    <OpenCL-addrspace> ::= "CL" [ "global" | "local" | "constant" |
//                                "private"| "generic" ]
//    <CUDA-addrspace> ::= "CU" [ "device" | "constant" | "shared" ]
//    Note that the above were chosen to match the Itanium mangling for this.
//
// In the case of a non-language specific address space:
//  __clang::struct _AS<TargetAS, Type>
assert(Quals.hasAddressSpace() && "Not valid without address space")((Quals.hasAddressSpace() && "Not valid without address space"
) ? static_cast<void> (0) : __assert_fail ("Quals.hasAddressSpace() && \"Not valid without address space\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1834, __PRETTY_FUNCTION__));
llvm::SmallString<32> ASMangling;
llvm::raw_svector_ostream Stream(ASMangling);
MicrosoftCXXNameMangler Extra(Context, Stream);
Stream << "?$";

LangAS AS = Quals.getAddressSpace();
if (Context.getASTContext().addressSpaceMapManglingFor(AS)) {
  unsigned TargetAS = Context.getASTContext().getTargetAddressSpace(AS);
  Extra.mangleSourceName("_AS");
  Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(TargetAS),
                             /*IsBoolean*/ false);
} else {
  switch (AS) {
  default:
    llvm_unreachable("Not a language specific address space")::llvm::llvm_unreachable_internal("Not a language specific address space"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1849);
  case LangAS::opencl_global:
    Extra.mangleSourceName("_ASCLglobal");
    break;
  case LangAS::opencl_local:
    Extra.mangleSourceName("_ASCLlocal");
    break;
  case LangAS::opencl_constant:
    Extra.mangleSourceName("_ASCLconstant");
    break;
  case LangAS::opencl_private:
    Extra.mangleSourceName("_ASCLprivate");
    break;
  case LangAS::opencl_generic:
    Extra.mangleSourceName("_ASCLgeneric");
    break;
  case LangAS::cuda_device:
    Extra.mangleSourceName("_ASCUdevice");
    break;
  case LangAS::cuda_constant:
    Extra.mangleSourceName("_ASCUconstant");
    break;
  case LangAS::cuda_shared:
    Extra.mangleSourceName("_ASCUshared");
    break;
  case LangAS::ptr32_sptr:
  case LangAS::ptr32_uptr:
  case LangAS::ptr64:
    llvm_unreachable("don't mangle ptr address spaces with _AS")::llvm::llvm_unreachable_internal("don't mangle ptr address spaces with _AS"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1877);
  }
}

Extra.mangleType(T, Range, QMM_Escape);
mangleQualifiers(Qualifiers(), false);
mangleArtificialTagType(TTK_Struct, ASMangling, {"__clang"});
1884}

1886void MicrosoftCXXNameMangler::mangleType(QualType T, SourceRange Range,
                                       QualifierMangleMode QMM) {
// Don't use the canonical types.  MSVC includes things like 'const' on
// pointer arguments to function pointers that canonicalization strips away.
T = T.getDesugaredType(getASTContext());
Qualifiers Quals = T.getLocalQualifiers();

if (const ArrayType *AT = getASTContext().getAsArrayType(T)) {
  // If there were any Quals, getAsArrayType() pushed them onto the array
  // element type.
  if (QMM == QMM_Mangle)
    Out << 'A';
  else if (QMM == QMM_Escape || QMM == QMM_Result)
    Out << "$$B";
  mangleArrayType(AT);
  return;
}

bool IsPointer = T->isAnyPointerType() || T->isMemberPointerType() ||
                 T->isReferenceType() || T->isBlockPointerType();

switch (QMM) {
case QMM_Drop:
  if (Quals.hasObjCLifetime())
    Quals = Quals.withoutObjCLifetime();
  break;
case QMM_Mangle:
  if (const FunctionType *FT = dyn_cast<FunctionType>(T)) {
    Out << '6';
    mangleFunctionType(FT);
    return;
  }
  mangleQualifiers(Quals, false);
  break;
case QMM_Escape:
  if (!IsPointer && Quals) {
    Out << "$$C";
    mangleQualifiers(Quals, false);
  }
  break;
case QMM_Result:
  // Presence of __unaligned qualifier shouldn't affect mangling here.
  Quals.removeUnaligned();
  if (Quals.hasObjCLifetime())
    Quals = Quals.withoutObjCLifetime();
  if ((!IsPointer && Quals) || isa<TagType>(T) || isArtificialTagType(T)) {
    Out << '?';
    mangleQualifiers(Quals, false);
  }
  break;
}

const Type *ty = T.getTypePtr();

switch (ty->getTypeClass()) {
1941#define ABSTRACT_TYPE(CLASS, PARENT)
1942#define NON_CANONICAL_TYPE(CLASS, PARENT) \
case Type::CLASS: \
  llvm_unreachable("can't mangle non-canonical type " #CLASS "Type")::llvm::llvm_unreachable_internal("can't mangle non-canonical type "
 #CLASS "Type", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 1944); \
  return;
1946#define TYPE(CLASS, PARENT) \
case Type::CLASS: \
  mangleType(cast<CLASS##Type>(ty), Quals, Range); \
  break;
1950#include "clang/AST/TypeNodes.inc"
1951#undef ABSTRACT_TYPE
1952#undef NON_CANONICAL_TYPE
1953#undef TYPE
}
1955}

1957void MicrosoftCXXNameMangler::mangleType(const BuiltinType *T, Qualifiers,
                                       SourceRange Range) {
//  <type>         ::= <builtin-type>
//  <builtin-type> ::= X  # void
//                 ::= C  # signed char
//                 ::= D  # char
//                 ::= E  # unsigned char
//                 ::= F  # short
//                 ::= G  # unsigned short (or wchar_t if it's not a builtin)
//                 ::= H  # int
//                 ::= I  # unsigned int
//                 ::= J  # long
//                 ::= K  # unsigned long
//                     L  # <none>
//                 ::= M  # float
//                 ::= N  # double
//                 ::= O  # long double (__float80 is mangled differently)
//                 ::= _J # long long, __int64
//                 ::= _K # unsigned long long, __int64
//                 ::= _L # __int128
//                 ::= _M # unsigned __int128
//                 ::= _N # bool
//                     _O # <array in parameter>
//                 ::= _Q # char8_t
//                 ::= _S # char16_t
//                 ::= _T # __float80 (Intel)
//                 ::= _U # char32_t
//                 ::= _W # wchar_t
//                 ::= _Z # __float80 (Digital Mars)
switch (T->getKind()) {
case BuiltinType::Void:
  Out << 'X';
  break;
case BuiltinType::SChar:
  Out << 'C';
  break;
case BuiltinType::Char_U:
case BuiltinType::Char_S:
  Out << 'D';
  break;
case BuiltinType::UChar:
  Out << 'E';
  break;
case BuiltinType::Short:
  Out << 'F';
  break;
case BuiltinType::UShort:
  Out << 'G';
  break;
case BuiltinType::Int:
  Out << 'H';
  break;
case BuiltinType::UInt:
  Out << 'I';
  break;
case BuiltinType::Long:
  Out << 'J';
  break;
case BuiltinType::ULong:
  Out << 'K';
  break;
case BuiltinType::Float:
  Out << 'M';
  break;
case BuiltinType::Double:
  Out << 'N';
  break;
// TODO: Determine size and mangle accordingly
case BuiltinType::LongDouble:
  Out << 'O';
  break;
case BuiltinType::LongLong:
  Out << "_J";
  break;
case BuiltinType::ULongLong:
  Out << "_K";
  break;
case BuiltinType::Int128:
  Out << "_L";
  break;
case BuiltinType::UInt128:
  Out << "_M";
  break;
case BuiltinType::Bool:
  Out << "_N";
  break;
case BuiltinType::Char8:
  Out << "_Q";
  break;
case BuiltinType::Char16:
  Out << "_S";
  break;
case BuiltinType::Char32:
  Out << "_U";
  break;
case BuiltinType::WChar_S:
case BuiltinType::WChar_U:
  Out << "_W";
  break;

2057#define BUILTIN_TYPE(Id, SingletonId)
2058#define PLACEHOLDER_TYPE(Id, SingletonId) \
case BuiltinType::Id:
2060#include "clang/AST/BuiltinTypes.def"
case BuiltinType::Dependent:
  llvm_unreachable("placeholder types shouldn't get to name mangling")::llvm::llvm_unreachable_internal("placeholder types shouldn't get to name mangling"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2062);

case BuiltinType::ObjCId:
  mangleArtificialTagType(TTK_Struct, "objc_object");
  break;
case BuiltinType::ObjCClass:
  mangleArtificialTagType(TTK_Struct, "objc_class");
  break;
case BuiltinType::ObjCSel:
  mangleArtificialTagType(TTK_Struct, "objc_selector");
  break;

2074#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id: \
  Out << "PAUocl_" #ImgType "_" #Suffix "@@"; \
  break;
2078#include "clang/Basic/OpenCLImageTypes.def"
case BuiltinType::OCLSampler:
  Out << "PA";
  mangleArtificialTagType(TTK_Struct, "ocl_sampler");
  break;
case BuiltinType::OCLEvent:
  Out << "PA";
  mangleArtificialTagType(TTK_Struct, "ocl_event");
  break;
case BuiltinType::OCLClkEvent:
  Out << "PA";
  mangleArtificialTagType(TTK_Struct, "ocl_clkevent");
  break;
case BuiltinType::OCLQueue:
  Out << "PA";
  mangleArtificialTagType(TTK_Struct, "ocl_queue");
  break;
case BuiltinType::OCLReserveID:
  Out << "PA";
  mangleArtificialTagType(TTK_Struct, "ocl_reserveid");
  break;
2099#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
case BuiltinType::Id: \
  mangleArtificialTagType(TTK_Struct, "ocl_" #ExtType); \
  break;
2103#include "clang/Basic/OpenCLExtensionTypes.def"

case BuiltinType::NullPtr:
  Out << "$$T";
  break;

case BuiltinType::Float16:
  mangleArtificialTagType(TTK_Struct, "_Float16", {"__clang"});
  break;

case BuiltinType::Half:
  mangleArtificialTagType(TTK_Struct, "_Half", {"__clang"});
  break;

2117#define SVE_TYPE(Name, Id, SingletonId) \
case BuiltinType::Id:
2119#include "clang/Basic/AArch64SVEACLETypes.def"
case BuiltinType::ShortAccum:
case BuiltinType::Accum:
case BuiltinType::LongAccum:
case BuiltinType::UShortAccum:
case BuiltinType::UAccum:
case BuiltinType::ULongAccum:
case BuiltinType::ShortFract:
case BuiltinType::Fract:
case BuiltinType::LongFract:
case BuiltinType::UShortFract:
case BuiltinType::UFract:
case BuiltinType::ULongFract:
case BuiltinType::SatShortAccum:
case BuiltinType::SatAccum:
case BuiltinType::SatLongAccum:
case BuiltinType::SatUShortAccum:
case BuiltinType::SatUAccum:
case BuiltinType::SatULongAccum:
case BuiltinType::SatShortFract:
case BuiltinType::SatFract:
case BuiltinType::SatLongFract:
case BuiltinType::SatUShortFract:
case BuiltinType::SatUFract:
case BuiltinType::SatULongFract:
case BuiltinType::Float128: {
  DiagnosticsEngine &Diags = Context.getDiags();
  unsigned DiagID = Diags.getCustomDiagID(
      DiagnosticsEngine::Error, "cannot mangle this built-in %0 type yet");
  Diags.Report(Range.getBegin(), DiagID)
      << T->getName(Context.getASTContext().getPrintingPolicy()) << Range;
  break;
}
}
2153}

2155// <type>          ::= <function-type>
2156void MicrosoftCXXNameMangler::mangleType(const FunctionProtoType *T, Qualifiers,
                                       SourceRange) {
// Structors only appear in decls, so at this point we know it's not a
// structor type.
// FIXME: This may not be lambda-friendly.
if (T->getMethodQuals() || T->getRefQualifier() != RQ_None) {
  Out << "$$A8@@";
  mangleFunctionType(T, /*D=*/nullptr, /*ForceThisQuals=*/true);
} else {
  Out << "$$A6";
  mangleFunctionType(T);
}
2168}
2169void MicrosoftCXXNameMangler::mangleType(const FunctionNoProtoType *T,
                                       Qualifiers, SourceRange) {
Out << "$$A6";
mangleFunctionType(T);
2173}

2175void MicrosoftCXXNameMangler::mangleFunctionType(const FunctionType *T,
                                               const FunctionDecl *D,
                                               bool ForceThisQuals,
                                               bool MangleExceptionSpec) {
// <function-type> ::= <this-cvr-qualifiers> <calling-convention>
//                     <return-type> <argument-list> <throw-spec>
const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(T);

SourceRange Range;
if (D) Range = D->getSourceRange();

bool IsInLambda = false;
bool IsStructor = false, HasThisQuals = ForceThisQuals, IsCtorClosure = false;
CallingConv CC = T->getCallConv();
if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(D)) {
  if (MD->getParent()->isLambda())
    IsInLambda = true;
  if (MD->isInstance())
    HasThisQuals = true;
  if (isa<CXXDestructorDecl>(MD)) {
    IsStructor = true;
  } else if (isa<CXXConstructorDecl>(MD)) {
    IsStructor = true;
    IsCtorClosure = (StructorType == Ctor_CopyingClosure ||
                     StructorType == Ctor_DefaultClosure) &&
                    isStructorDecl(MD);
    if (IsCtorClosure)
      CC = getASTContext().getDefaultCallingConvention(
          /*IsVariadic=*/false, /*IsCXXMethod=*/true);
  }
}

// If this is a C++ instance method, mangle the CVR qualifiers for the
// this pointer.
if (HasThisQuals) {
  Qualifiers Quals = Proto->getMethodQuals();
  manglePointerExtQualifiers(Quals, /*PointeeType=*/QualType());
  mangleRefQualifier(Proto->getRefQualifier());
  mangleQualifiers(Quals, /*IsMember=*/false);
}

mangleCallingConvention(CC);

// <return-type> ::= <type>
//               ::= @ # structors (they have no declared return type)
if (IsStructor) {
  if (isa<CXXDestructorDecl>(D) && isStructorDecl(D)) {
    // The scalar deleting destructor takes an extra int argument which is not
    // reflected in the AST.
    if (StructorType == Dtor_Deleting) {
      Out << (PointersAre64Bit ? "PEAXI@Z" : "PAXI@Z");
      return;
    }
    // The vbase destructor returns void which is not reflected in the AST.
    if (StructorType == Dtor_Complete) {
      Out << "XXZ";
      return;
    }
  }
  if (IsCtorClosure) {
    // Default constructor closure and copy constructor closure both return
    // void.
    Out << 'X';

    if (StructorType == Ctor_DefaultClosure) {
      // Default constructor closure always has no arguments.
      Out << 'X';
    } else if (StructorType == Ctor_CopyingClosure) {
      // Copy constructor closure always takes an unqualified reference.
      mangleFunctionArgumentType(getASTContext().getLValueReferenceType(
                                     Proto->getParamType(0)
                                         ->getAs<LValueReferenceType>()
                                         ->getPointeeType(),
                                     /*SpelledAsLValue=*/true),
                                 Range);
      Out << '@';
    } else {
      llvm_unreachable("unexpected constructor closure!")::llvm::llvm_unreachable_internal("unexpected constructor closure!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2252);
    }
    Out << 'Z';
    return;
  }
  Out << '@';
} else {
  QualType ResultType = T->getReturnType();
  if (const auto *AT =
          dyn_cast_or_null<AutoType>(ResultType->getContainedAutoType())) {
    Out << '?';
    mangleQualifiers(ResultType.getLocalQualifiers(), /*IsMember=*/false);
    Out << '?';
    assert(AT->getKeyword() != AutoTypeKeyword::GNUAutoType &&((AT->getKeyword() != AutoTypeKeyword::GNUAutoType &&
 "shouldn't need to mangle __auto_type!") ? static_cast<void
> (0) : __assert_fail ("AT->getKeyword() != AutoTypeKeyword::GNUAutoType && \"shouldn't need to mangle __auto_type!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2266, __PRETTY_FUNCTION__))
           "shouldn't need to mangle __auto_type!")((AT->getKeyword() != AutoTypeKeyword::GNUAutoType &&
 "shouldn't need to mangle __auto_type!") ? static_cast<void
> (0) : __assert_fail ("AT->getKeyword() != AutoTypeKeyword::GNUAutoType && \"shouldn't need to mangle __auto_type!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2266, __PRETTY_FUNCTION__));
    mangleSourceName(AT->isDecltypeAuto() ? "<decltype-auto>" : "<auto>");
    Out << '@';
  } else if (IsInLambda) {
    Out << '@';
  } else {
    if (ResultType->isVoidType())
      ResultType = ResultType.getUnqualifiedType();
    mangleType(ResultType, Range, QMM_Result);
  }
}

// <argument-list> ::= X # void
//                 ::= <type>+ @
//                 ::= <type>* Z # varargs
if (!Proto) {
  // Function types without prototypes can arise when mangling a function type
  // within an overloadable function in C. We mangle these as the absence of
  // any parameter types (not even an empty parameter list).
  Out << '@';
} else if (Proto->getNumParams() == 0 && !Proto->isVariadic()) {
  Out << 'X';
} else {
  // Happens for function pointer type arguments for example.
  for (unsigned I = 0, E = Proto->getNumParams(); I != E; ++I) {
    mangleFunctionArgumentType(Proto->getParamType(I), Range);
    // Mangle each pass_object_size parameter as if it's a parameter of enum
    // type passed directly after the parameter with the pass_object_size
    // attribute. The aforementioned enum's name is __pass_object_size, and we
    // pretend it resides in a top-level namespace called __clang.
    //
    // FIXME: Is there a defined extension notation for the MS ABI, or is it
    // necessary to just cross our fingers and hope this type+namespace
    // combination doesn't conflict with anything?
    if (D)
      if (const auto *P = D->getParamDecl(I)->getAttr<PassObjectSizeAttr>())
        manglePassObjectSizeArg(P);
  }
  // <builtin-type>      ::= Z  # ellipsis
  if (Proto->isVariadic())
    Out << 'Z';
  else
    Out << '@';
}

if (MangleExceptionSpec && getASTContext().getLangOpts().CPlusPlus17 &&
    getASTContext().getLangOpts().isCompatibleWithMSVC(
        LangOptions::MSVC2017_5))
  mangleThrowSpecification(Proto);
else
  Out << 'Z';
2317}

2319void MicrosoftCXXNameMangler::mangleFunctionClass(const FunctionDecl *FD) {
// <function-class>  ::= <member-function> E? # E designates a 64-bit 'this'
//                                            # pointer. in 64-bit mode *all*
//                                            # 'this' pointers are 64-bit.
//                   ::= <global-function>
// <member-function> ::= A # private: near
//                   ::= B # private: far
//                   ::= C # private: static near
//                   ::= D # private: static far
//                   ::= E # private: virtual near
//                   ::= F # private: virtual far
//                   ::= I # protected: near
//                   ::= J # protected: far
//                   ::= K # protected: static near
//                   ::= L # protected: static far
//                   ::= M # protected: virtual near
//                   ::= N # protected: virtual far
//                   ::= Q # public: near
//                   ::= R # public: far
//                   ::= S # public: static near
//                   ::= T # public: static far
//                   ::= U # public: virtual near
//                   ::= V # public: virtual far
// <global-function> ::= Y # global near
//                   ::= Z # global far
if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
  bool IsVirtual = MD->isVirtual();
  // When mangling vbase destructor variants, ignore whether or not the
  // underlying destructor was defined to be virtual.
  if (isa<CXXDestructorDecl>(MD) && isStructorDecl(MD) &&
      StructorType == Dtor_Complete) {
    IsVirtual = false;
  }
  switch (MD->getAccess()) {
    case AS_none:
      llvm_unreachable("Unsupported access specifier")::llvm::llvm_unreachable_internal("Unsupported access specifier"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2354);
    case AS_private:
      if (MD->isStatic())
        Out << 'C';
      else if (IsVirtual)
        Out << 'E';
      else
        Out << 'A';
      break;
    case AS_protected:
      if (MD->isStatic())
        Out << 'K';
      else if (IsVirtual)
        Out << 'M';
      else
        Out << 'I';
      break;
    case AS_public:
      if (MD->isStatic())
        Out << 'S';
      else if (IsVirtual)
        Out << 'U';
      else
        Out << 'Q';
  }
} else {
  Out << 'Y';
}
2382}
2383void MicrosoftCXXNameMangler::mangleCallingConvention(CallingConv CC) {
// <calling-convention> ::= A # __cdecl
//                      ::= B # __export __cdecl
//                      ::= C # __pascal
//                      ::= D # __export __pascal
//                      ::= E # __thiscall
//                      ::= F # __export __thiscall
//                      ::= G # __stdcall
//                      ::= H # __export __stdcall
//                      ::= I # __fastcall
//                      ::= J # __export __fastcall
//                      ::= Q # __vectorcall
//                      ::= w # __regcall
// The 'export' calling conventions are from a bygone era
// (*cough*Win16*cough*) when functions were declared for export with
// that keyword. (It didn't actually export them, it just made them so
// that they could be in a DLL and somebody from another module could call
// them.)

switch (CC) {
  default:
    llvm_unreachable("Unsupported CC for mangling")::llvm::llvm_unreachable_internal("Unsupported CC for mangling"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2404);
  case CC_Win64:
  case CC_X86_64SysV:
  case CC_C: Out << 'A'; break;
  case CC_X86Pascal: Out << 'C'; break;
  case CC_X86ThisCall: Out << 'E'; break;
  case CC_X86StdCall: Out << 'G'; break;
  case CC_X86FastCall: Out << 'I'; break;
  case CC_X86VectorCall: Out << 'Q'; break;
  case CC_Swift: Out << 'S'; break;
  case CC_PreserveMost: Out << 'U'; break;
  case CC_X86RegCall: Out << 'w'; break;
}
2417}
2418void MicrosoftCXXNameMangler::mangleCallingConvention(const FunctionType *T) {
mangleCallingConvention(T->getCallConv());
5
←
Called C++ object pointer is null
2420}

2422void MicrosoftCXXNameMangler::mangleThrowSpecification(
                                              const FunctionProtoType *FT) {
// <throw-spec> ::= Z # (default)
//              ::= _E # noexcept
if (FT->canThrow())
  Out << 'Z';
else
  Out << "_E";
2430}

2432void MicrosoftCXXNameMangler::mangleType(const UnresolvedUsingType *T,
                                       Qualifiers, SourceRange Range) {
// Probably should be mangled as a template instantiation; need to see what
// VC does first.
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this unresolved dependent type yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2441}

2443// <type>        ::= <union-type> | <struct-type> | <class-type> | <enum-type>
2444// <union-type>  ::= T <name>
2445// <struct-type> ::= U <name>
2446// <class-type>  ::= V <name>
2447// <enum-type>   ::= W4 <name>
2448void MicrosoftCXXNameMangler::mangleTagTypeKind(TagTypeKind TTK) {
switch (TTK) {
  case TTK_Union:
    Out << 'T';
    break;
  case TTK_Struct:
  case TTK_Interface:
    Out << 'U';
    break;
  case TTK_Class:
    Out << 'V';
    break;
  case TTK_Enum:
    Out << "W4";
    break;
}
2464}
2465void MicrosoftCXXNameMangler::mangleType(const EnumType *T, Qualifiers,
                                       SourceRange) {
mangleType(cast<TagType>(T)->getDecl());
2468}
2469void MicrosoftCXXNameMangler::mangleType(const RecordType *T, Qualifiers,
                                       SourceRange) {
mangleType(cast<TagType>(T)->getDecl());
2472}
2473void MicrosoftCXXNameMangler::mangleType(const TagDecl *TD) {
mangleTagTypeKind(TD->getTagKind());
mangleName(TD);
2476}

2478// If you add a call to this, consider updating isArtificialTagType() too.
2479void MicrosoftCXXNameMangler::mangleArtificialTagType(
  TagTypeKind TK, StringRef UnqualifiedName,
  ArrayRef<StringRef> NestedNames) {
// <name> ::= <unscoped-name> {[<named-scope>]+ | [<nested-name>]}? @
mangleTagTypeKind(TK);

// Always start with the unqualified name.
mangleSourceName(UnqualifiedName);

for (auto I = NestedNames.rbegin(), E = NestedNames.rend(); I != E; ++I)
  mangleSourceName(*I);

// Terminate the whole name with an '@'.
Out << '@';
2493}

2495// <type>       ::= <array-type>
2496// <array-type> ::= <pointer-cvr-qualifiers> <cvr-qualifiers>
2497//                  [Y <dimension-count> <dimension>+]
2498//                  <element-type> # as global, E is never required
2499// It's supposed to be the other way around, but for some strange reason, it
2500// isn't. Today this behavior is retained for the sole purpose of backwards
2501// compatibility.
2502void MicrosoftCXXNameMangler::mangleDecayedArrayType(const ArrayType *T) {
// This isn't a recursive mangling, so now we have to do it all in this
// one call.
manglePointerCVQualifiers(T->getElementType().getQualifiers());
mangleType(T->getElementType(), SourceRange());
2507}
2508void MicrosoftCXXNameMangler::mangleType(const ConstantArrayType *T, Qualifiers,
                                       SourceRange) {
llvm_unreachable("Should have been special cased")::llvm::llvm_unreachable_internal("Should have been special cased"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2510);
2511}
2512void MicrosoftCXXNameMangler::mangleType(const VariableArrayType *T, Qualifiers,
                                       SourceRange) {
llvm_unreachable("Should have been special cased")::llvm::llvm_unreachable_internal("Should have been special cased"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2514);
2515}
2516void MicrosoftCXXNameMangler::mangleType(const DependentSizedArrayType *T,
                                       Qualifiers, SourceRange) {
llvm_unreachable("Should have been special cased")::llvm::llvm_unreachable_internal("Should have been special cased"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2518);
2519}
2520void MicrosoftCXXNameMangler::mangleType(const IncompleteArrayType *T,
                                       Qualifiers, SourceRange) {
llvm_unreachable("Should have been special cased")::llvm::llvm_unreachable_internal("Should have been special cased"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2522);
2523}
2524void MicrosoftCXXNameMangler::mangleArrayType(const ArrayType *T) {
QualType ElementTy(T, 0);
SmallVector<llvm::APInt, 3> Dimensions;
for (;;) {
  if (ElementTy->isConstantArrayType()) {
    const ConstantArrayType *CAT =
        getASTContext().getAsConstantArrayType(ElementTy);
    Dimensions.push_back(CAT->getSize());
    ElementTy = CAT->getElementType();
  } else if (ElementTy->isIncompleteArrayType()) {
    const IncompleteArrayType *IAT =
        getASTContext().getAsIncompleteArrayType(ElementTy);
    Dimensions.push_back(llvm::APInt(32, 0));
    ElementTy = IAT->getElementType();
  } else if (ElementTy->isVariableArrayType()) {
    const VariableArrayType *VAT =
      getASTContext().getAsVariableArrayType(ElementTy);
    Dimensions.push_back(llvm::APInt(32, 0));
    ElementTy = VAT->getElementType();
  } else if (ElementTy->isDependentSizedArrayType()) {
    // The dependent expression has to be folded into a constant (TODO).
    const DependentSizedArrayType *DSAT =
      getASTContext().getAsDependentSizedArrayType(ElementTy);
    DiagnosticsEngine &Diags = Context.getDiags();
    unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
      "cannot mangle this dependent-length array yet");
    Diags.Report(DSAT->getSizeExpr()->getExprLoc(), DiagID)
      << DSAT->getBracketsRange();
    return;
  } else {
    break;
  }
}
Out << 'Y';
// <dimension-count> ::= <number> # number of extra dimensions
mangleNumber(Dimensions.size());
for (const llvm::APInt &Dimension : Dimensions)
  mangleNumber(Dimension.getLimitedValue());
mangleType(ElementTy, SourceRange(), QMM_Escape);
2563}

2565// <type>                   ::= <pointer-to-member-type>
2566// <pointer-to-member-type> ::= <pointer-cvr-qualifiers> <cvr-qualifiers>
2567//                                                          <class name> <type>
2568void MicrosoftCXXNameMangler::mangleType(const MemberPointerType *T,
                                       Qualifiers Quals, SourceRange Range) {
QualType PointeeType = T->getPointeeType();
manglePointerCVQualifiers(Quals);
manglePointerExtQualifiers(Quals, PointeeType);
if (const FunctionProtoType *FPT = PointeeType->getAs<FunctionProtoType>()) {
  Out << '8';
  mangleName(T->getClass()->castAs<RecordType>()->getDecl());
  mangleFunctionType(FPT, nullptr, true);
} else {
  mangleQualifiers(PointeeType.getQualifiers(), true);
  mangleName(T->getClass()->castAs<RecordType>()->getDecl());
  mangleType(PointeeType, Range, QMM_Drop);
}
2582}

2584void MicrosoftCXXNameMangler::mangleType(const TemplateTypeParmType *T,
                                       Qualifiers, SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this template type parameter type yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2591}

2593void MicrosoftCXXNameMangler::mangleType(const SubstTemplateTypeParmPackType *T,
                                       Qualifiers, SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this substituted parameter pack yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2600}

2602// <type> ::= <pointer-type>
2603// <pointer-type> ::= E? <pointer-cvr-qualifiers> <cvr-qualifiers> <type>
2604//                       # the E is required for 64-bit non-static pointers
2605void MicrosoftCXXNameMangler::mangleType(const PointerType *T, Qualifiers Quals,
                                       SourceRange Range) {
QualType PointeeType = T->getPointeeType();
manglePointerCVQualifiers(Quals);
manglePointerExtQualifiers(Quals, PointeeType);

// For pointer size address spaces, go down the same type mangling path as
// non address space types.
LangAS AddrSpace = PointeeType.getQualifiers().getAddressSpace();
if (isPtrSizeAddressSpace(AddrSpace) || AddrSpace == LangAS::Default)
  mangleType(PointeeType, Range);
else
  mangleAddressSpaceType(PointeeType, PointeeType.getQualifiers(), Range);
2618}

2620void MicrosoftCXXNameMangler::mangleType(const ObjCObjectPointerType *T,
                                       Qualifiers Quals, SourceRange Range) {
QualType PointeeType = T->getPointeeType();
switch (Quals.getObjCLifetime()) {
case Qualifiers::OCL_None:
case Qualifiers::OCL_ExplicitNone:
  break;
case Qualifiers::OCL_Autoreleasing:
case Qualifiers::OCL_Strong:
case Qualifiers::OCL_Weak:
  return mangleObjCLifetime(PointeeType, Quals, Range);
}
manglePointerCVQualifiers(Quals);
manglePointerExtQualifiers(Quals, PointeeType);
mangleType(PointeeType, Range);
2635}

2637// <type> ::= <reference-type>
2638// <reference-type> ::= A E? <cvr-qualifiers> <type>
2639//                 # the E is required for 64-bit non-static lvalue references
2640void MicrosoftCXXNameMangler::mangleType(const LValueReferenceType *T,
                                       Qualifiers Quals, SourceRange Range) {
QualType PointeeType = T->getPointeeType();
assert(!Quals.hasConst() && !Quals.hasVolatile() && "unexpected qualifier!")((!Quals.hasConst() && !Quals.hasVolatile() &&
 "unexpected qualifier!") ? static_cast<void> (0) : __assert_fail
 ("!Quals.hasConst() && !Quals.hasVolatile() && \"unexpected qualifier!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2643, __PRETTY_FUNCTION__));
Out << 'A';
manglePointerExtQualifiers(Quals, PointeeType);
mangleType(PointeeType, Range);
2647}

2649// <type> ::= <r-value-reference-type>
2650// <r-value-reference-type> ::= $$Q E? <cvr-qualifiers> <type>
2651//                 # the E is required for 64-bit non-static rvalue references
2652void MicrosoftCXXNameMangler::mangleType(const RValueReferenceType *T,
                                       Qualifiers Quals, SourceRange Range) {
QualType PointeeType = T->getPointeeType();
assert(!Quals.hasConst() && !Quals.hasVolatile() && "unexpected qualifier!")((!Quals.hasConst() && !Quals.hasVolatile() &&
 "unexpected qualifier!") ? static_cast<void> (0) : __assert_fail
 ("!Quals.hasConst() && !Quals.hasVolatile() && \"unexpected qualifier!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2655, __PRETTY_FUNCTION__));
Out << "$$Q";
manglePointerExtQualifiers(Quals, PointeeType);
mangleType(PointeeType, Range);
2659}

2661void MicrosoftCXXNameMangler::mangleType(const ComplexType *T, Qualifiers,
                                       SourceRange Range) {
QualType ElementType = T->getElementType();

llvm::SmallString<64> TemplateMangling;
llvm::raw_svector_ostream Stream(TemplateMangling);
MicrosoftCXXNameMangler Extra(Context, Stream);
Stream << "?$";
Extra.mangleSourceName("_Complex");
Extra.mangleType(ElementType, Range, QMM_Escape);

mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
2673}

2675// Returns true for types that mangleArtificialTagType() gets called for with
2676// TTK_Union, TTK_Struct, TTK_Class and where compatibility with MSVC's
2677// mangling matters.
2678// (It doesn't matter for Objective-C types and the like that cl.exe doesn't
2679// support.)
2680bool MicrosoftCXXNameMangler::isArtificialTagType(QualType T) const {
const Type *ty = T.getTypePtr();
switch (ty->getTypeClass()) {
default:
  return false;

case Type::Vector: {
  // For ABI compatibility only __m64, __m128(id), and __m256(id) matter,
  // but since mangleType(VectorType*) always calls mangleArtificialTagType()
  // just always return true (the other vector types are clang-only).
  return true;
}
}
2693}

2695void MicrosoftCXXNameMangler::mangleType(const VectorType *T, Qualifiers Quals,
                                       SourceRange Range) {
const BuiltinType *ET = T->getElementType()->getAs<BuiltinType>();
assert(ET && "vectors with non-builtin elements are unsupported")((ET && "vectors with non-builtin elements are unsupported"
) ? static_cast<void> (0) : __assert_fail ("ET && \"vectors with non-builtin elements are unsupported\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2698, __PRETTY_FUNCTION__));
uint64_t Width = getASTContext().getTypeSize(T);
// Pattern match exactly the typedefs in our intrinsic headers.  Anything that
// doesn't match the Intel types uses a custom mangling below.
size_t OutSizeBefore = Out.tell();
if (!isa<ExtVectorType>(T)) {
  if (getASTContext().getTargetInfo().getTriple().isX86()) {
    if (Width == 64 && ET->getKind() == BuiltinType::LongLong) {
      mangleArtificialTagType(TTK_Union, "__m64");
    } else if (Width >= 128) {
      if (ET->getKind() == BuiltinType::Float)
        mangleArtificialTagType(TTK_Union, "__m" + llvm::utostr(Width));
      else if (ET->getKind() == BuiltinType::LongLong)
        mangleArtificialTagType(TTK_Union, "__m" + llvm::utostr(Width) + 'i');
      else if (ET->getKind() == BuiltinType::Double)
        mangleArtificialTagType(TTK_Struct, "__m" + llvm::utostr(Width) + 'd');
    }
  }
}

bool IsBuiltin = Out.tell() != OutSizeBefore;
if (!IsBuiltin) {
  // The MS ABI doesn't have a special mangling for vector types, so we define
  // our own mangling to handle uses of __vector_size__ on user-specified
  // types, and for extensions like __v4sf.

  llvm::SmallString<64> TemplateMangling;
  llvm::raw_svector_ostream Stream(TemplateMangling);
  MicrosoftCXXNameMangler Extra(Context, Stream);
  Stream << "?$";
  Extra.mangleSourceName("__vector");
  Extra.mangleType(QualType(ET, 0), Range, QMM_Escape);
  Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(T->getNumElements()),
                             /*IsBoolean=*/false);

  mangleArtificialTagType(TTK_Union, TemplateMangling, {"__clang"});
}
2735}

2737void MicrosoftCXXNameMangler::mangleType(const ExtVectorType *T,
                                       Qualifiers Quals, SourceRange Range) {
mangleType(static_cast<const VectorType *>(T), Quals, Range);
2740}

2742void MicrosoftCXXNameMangler::mangleType(const DependentVectorType *T,
                                       Qualifiers, SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(
    DiagnosticsEngine::Error,
    "cannot mangle this dependent-sized vector type yet");
Diags.Report(Range.getBegin(), DiagID) << Range;
2749}

2751void MicrosoftCXXNameMangler::mangleType(const DependentSizedExtVectorType *T,
                                       Qualifiers, SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this dependent-sized extended vector type yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2758}

2760void MicrosoftCXXNameMangler::mangleType(const DependentAddressSpaceType *T,
                                       Qualifiers, SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(
    DiagnosticsEngine::Error,
    "cannot mangle this dependent address space type yet");
Diags.Report(Range.getBegin(), DiagID) << Range;
2767}

2769void MicrosoftCXXNameMangler::mangleType(const ObjCInterfaceType *T, Qualifiers,
                                       SourceRange) {
// ObjC interfaces have structs underlying them.
mangleTagTypeKind(TTK_Struct);
mangleName(T->getDecl());
2774}

2776void MicrosoftCXXNameMangler::mangleType(const ObjCObjectType *T,
                                       Qualifiers Quals, SourceRange Range) {
if (T->isKindOfType())
  return mangleObjCKindOfType(T, Quals, Range);

if (T->qual_empty() && !T->isSpecialized())
  return mangleType(T->getBaseType(), Range, QMM_Drop);

ArgBackRefMap OuterFunArgsContext;
ArgBackRefMap OuterTemplateArgsContext;
BackRefVec OuterTemplateContext;

FunArgBackReferences.swap(OuterFunArgsContext);
TemplateArgBackReferences.swap(OuterTemplateArgsContext);
NameBackReferences.swap(OuterTemplateContext);

mangleTagTypeKind(TTK_Struct);

Out << "?$";
if (T->isObjCId())
  mangleSourceName("objc_object");
else if (T->isObjCClass())
  mangleSourceName("objc_class");
else
  mangleSourceName(T->getInterface()->getName());

for (const auto &Q : T->quals())
  mangleObjCProtocol(Q);

if (T->isSpecialized())
  for (const auto &TA : T->getTypeArgs())
    mangleType(TA, Range, QMM_Drop);

Out << '@';

Out << '@';

FunArgBackReferences.swap(OuterFunArgsContext);
TemplateArgBackReferences.swap(OuterTemplateArgsContext);
NameBackReferences.swap(OuterTemplateContext);
2816}

2818void MicrosoftCXXNameMangler::mangleType(const BlockPointerType *T,
                                       Qualifiers Quals, SourceRange Range) {
QualType PointeeType = T->getPointeeType();
manglePointerCVQualifiers(Quals);
manglePointerExtQualifiers(Quals, PointeeType);

Out << "_E";

mangleFunctionType(PointeeType->castAs<FunctionProtoType>());
2827}

2829void MicrosoftCXXNameMangler::mangleType(const InjectedClassNameType *,
                                       Qualifiers, SourceRange) {
llvm_unreachable("Cannot mangle injected class name type.")::llvm::llvm_unreachable_internal("Cannot mangle injected class name type."
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2831);
2832}

2834void MicrosoftCXXNameMangler::mangleType(const TemplateSpecializationType *T,
                                       Qualifiers, SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this template specialization type yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2841}

2843void MicrosoftCXXNameMangler::mangleType(const DependentNameType *T, Qualifiers,
                                       SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this dependent name type yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2850}

2852void MicrosoftCXXNameMangler::mangleType(
  const DependentTemplateSpecializationType *T, Qualifiers,
  SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this dependent template specialization type yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2860}

2862void MicrosoftCXXNameMangler::mangleType(const PackExpansionType *T, Qualifiers,
                                       SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this pack expansion yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2869}

2871void MicrosoftCXXNameMangler::mangleType(const TypeOfType *T, Qualifiers,
                                       SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this typeof(type) yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2878}

2880void MicrosoftCXXNameMangler::mangleType(const TypeOfExprType *T, Qualifiers,
                                       SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this typeof(expression) yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2887}

2889void MicrosoftCXXNameMangler::mangleType(const DecltypeType *T, Qualifiers,
                                       SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this decltype() yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2896}

2898void MicrosoftCXXNameMangler::mangleType(const UnaryTransformType *T,
                                       Qualifiers, SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this unary transform type yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2905}

2907void MicrosoftCXXNameMangler::mangleType(const AutoType *T, Qualifiers,
                                       SourceRange Range) {
assert(T->getDeducedType().isNull() && "expecting a dependent type!")((T->getDeducedType().isNull() && "expecting a dependent type!"
) ? static_cast<void> (0) : __assert_fail ("T->getDeducedType().isNull() && \"expecting a dependent type!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2909, __PRETTY_FUNCTION__));

DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this 'auto' type yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2916}

2918void MicrosoftCXXNameMangler::mangleType(
  const DeducedTemplateSpecializationType *T, Qualifiers, SourceRange Range) {
assert(T->getDeducedType().isNull() && "expecting a dependent type!")((T->getDeducedType().isNull() && "expecting a dependent type!"
) ? static_cast<void> (0) : __assert_fail ("T->getDeducedType().isNull() && \"expecting a dependent type!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2920, __PRETTY_FUNCTION__));

DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this deduced class template specialization type yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2927}

2929void MicrosoftCXXNameMangler::mangleType(const AtomicType *T, Qualifiers,
                                       SourceRange Range) {
QualType ValueType = T->getValueType();

llvm::SmallString<64> TemplateMangling;
llvm::raw_svector_ostream Stream(TemplateMangling);
MicrosoftCXXNameMangler Extra(Context, Stream);
Stream << "?$";
Extra.mangleSourceName("_Atomic");
Extra.mangleType(ValueType, Range, QMM_Escape);

mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
2941}

2943void MicrosoftCXXNameMangler::mangleType(const PipeType *T, Qualifiers,
                                       SourceRange Range) {
DiagnosticsEngine &Diags = Context.getDiags();
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
  "cannot mangle this OpenCL pipe type yet");
Diags.Report(Range.getBegin(), DiagID)
  << Range;
2950}

2952void MicrosoftMangleContextImpl::mangleCXXName(const NamedDecl *D,
                                             raw_ostream &Out) {
assert((isa<FunctionDecl>(D) || isa<VarDecl>(D)) &&(((isa<FunctionDecl>(D) || isa<VarDecl>(D)) &&
 "Invalid mangleName() call, argument is not a variable or function!"
) ? static_cast<void> (0) : __assert_fail ("(isa<FunctionDecl>(D) || isa<VarDecl>(D)) && \"Invalid mangleName() call, argument is not a variable or function!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2955, __PRETTY_FUNCTION__))
       "Invalid mangleName() call, argument is not a variable or function!")(((isa<FunctionDecl>(D) || isa<VarDecl>(D)) &&
 "Invalid mangleName() call, argument is not a variable or function!"
) ? static_cast<void> (0) : __assert_fail ("(isa<FunctionDecl>(D) || isa<VarDecl>(D)) && \"Invalid mangleName() call, argument is not a variable or function!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2955, __PRETTY_FUNCTION__));
assert(!isa<CXXConstructorDecl>(D) && !isa<CXXDestructorDecl>(D) &&((!isa<CXXConstructorDecl>(D) && !isa<CXXDestructorDecl
>(D) && "Invalid mangleName() call on 'structor decl!"
) ? static_cast<void> (0) : __assert_fail ("!isa<CXXConstructorDecl>(D) && !isa<CXXDestructorDecl>(D) && \"Invalid mangleName() call on 'structor decl!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2957, __PRETTY_FUNCTION__))
       "Invalid mangleName() call on 'structor decl!")((!isa<CXXConstructorDecl>(D) && !isa<CXXDestructorDecl
>(D) && "Invalid mangleName() call on 'structor decl!"
) ? static_cast<void> (0) : __assert_fail ("!isa<CXXConstructorDecl>(D) && !isa<CXXDestructorDecl>(D) && \"Invalid mangleName() call on 'structor decl!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 2957, __PRETTY_FUNCTION__));

PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
                               getASTContext().getSourceManager(),
                               "Mangling declaration");

msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
return Mangler.mangle(D);
2966}

2968// <this-adjustment> ::= <no-adjustment> | <static-adjustment> |
2969//                       <virtual-adjustment>
2970// <no-adjustment>      ::= A # private near
2971//                      ::= B # private far
2972//                      ::= I # protected near
2973//                      ::= J # protected far
2974//                      ::= Q # public near
2975//                      ::= R # public far
2976// <static-adjustment>  ::= G <static-offset> # private near
2977//                      ::= H <static-offset> # private far
2978//                      ::= O <static-offset> # protected near
2979//                      ::= P <static-offset> # protected far
2980//                      ::= W <static-offset> # public near
2981//                      ::= X <static-offset> # public far
2982// <virtual-adjustment> ::= $0 <virtual-shift> <static-offset> # private near
2983//                      ::= $1 <virtual-shift> <static-offset> # private far
2984//                      ::= $2 <virtual-shift> <static-offset> # protected near
2985//                      ::= $3 <virtual-shift> <static-offset> # protected far
2986//                      ::= $4 <virtual-shift> <static-offset> # public near
2987//                      ::= $5 <virtual-shift> <static-offset> # public far
2988// <virtual-shift>      ::= <vtordisp-shift> | <vtordispex-shift>
2989// <vtordisp-shift>     ::= <offset-to-vtordisp>
2990// <vtordispex-shift>   ::= <offset-to-vbptr> <vbase-offset-offset>
2991//                          <offset-to-vtordisp>
2992static void mangleThunkThisAdjustment(AccessSpecifier AS,
                                    const ThisAdjustment &Adjustment,
                                    MicrosoftCXXNameMangler &Mangler,
                                    raw_ostream &Out) {
if (!Adjustment.Virtual.isEmpty()) {
  Out << '$';
  char AccessSpec;
  switch (AS) {
  case AS_none:
    llvm_unreachable("Unsupported access specifier")::llvm::llvm_unreachable_internal("Unsupported access specifier"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 3001);
  case AS_private:
    AccessSpec = '0';
    break;
  case AS_protected:
    AccessSpec = '2';
    break;
  case AS_public:
    AccessSpec = '4';
  }
  if (Adjustment.Virtual.Microsoft.VBPtrOffset) {
    Out << 'R' << AccessSpec;
    Mangler.mangleNumber(
        static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VBPtrOffset));
    Mangler.mangleNumber(
        static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VBOffsetOffset));
    Mangler.mangleNumber(
        static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VtordispOffset));
    Mangler.mangleNumber(static_cast<uint32_t>(Adjustment.NonVirtual));
  } else {
    Out << AccessSpec;
    Mangler.mangleNumber(
        static_cast<uint32_t>(Adjustment.Virtual.Microsoft.VtordispOffset));
    Mangler.mangleNumber(-static_cast<uint32_t>(Adjustment.NonVirtual));
  }
} else if (Adjustment.NonVirtual != 0) {
  switch (AS) {
  case AS_none:
    llvm_unreachable("Unsupported access specifier")::llvm::llvm_unreachable_internal("Unsupported access specifier"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 3029);
  case AS_private:
    Out << 'G';
    break;
  case AS_protected:
    Out << 'O';
    break;
  case AS_public:
    Out << 'W';
  }
  Mangler.mangleNumber(-static_cast<uint32_t>(Adjustment.NonVirtual));
} else {
  switch (AS) {
  case AS_none:
    llvm_unreachable("Unsupported access specifier")::llvm::llvm_unreachable_internal("Unsupported access specifier"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 3043);
  case AS_private:
    Out << 'A';
    break;
  case AS_protected:
    Out << 'I';
    break;
  case AS_public:
    Out << 'Q';
  }
}
3054}

3056void MicrosoftMangleContextImpl::mangleVirtualMemPtrThunk(
  const CXXMethodDecl *MD, const MethodVFTableLocation &ML,
  raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
Mangler.getStream() << '?';
Mangler.mangleVirtualMemPtrThunk(MD, ML);
1
Calling 'MicrosoftCXXNameMangler::mangleVirtualMemPtrThunk'→
3063}

3065void MicrosoftMangleContextImpl::mangleThunk(const CXXMethodDecl *MD,
                                           const ThunkInfo &Thunk,
                                           raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
Mangler.getStream() << '?';
Mangler.mangleName(MD);

// Usually the thunk uses the access specifier of the new method, but if this
// is a covariant return thunk, then MSVC always uses the public access
// specifier, and we do the same.
AccessSpecifier AS = Thunk.Return.isEmpty() ? MD->getAccess() : AS_public;
mangleThunkThisAdjustment(AS, Thunk.This, Mangler, MHO);

if (!Thunk.Return.isEmpty())
  assert(Thunk.Method != nullptr &&((Thunk.Method != nullptr && "Thunk info should hold the overridee decl"
) ? static_cast<void> (0) : __assert_fail ("Thunk.Method != nullptr && \"Thunk info should hold the overridee decl\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 3081, __PRETTY_FUNCTION__))
         "Thunk info should hold the overridee decl")((Thunk.Method != nullptr && "Thunk info should hold the overridee decl"
) ? static_cast<void> (0) : __assert_fail ("Thunk.Method != nullptr && \"Thunk info should hold the overridee decl\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 3081, __PRETTY_FUNCTION__));

const CXXMethodDecl *DeclForFPT = Thunk.Method ? Thunk.Method : MD;
Mangler.mangleFunctionType(
    DeclForFPT->getType()->castAs<FunctionProtoType>(), MD);
3086}

3088void MicrosoftMangleContextImpl::mangleCXXDtorThunk(
  const CXXDestructorDecl *DD, CXXDtorType Type,
  const ThisAdjustment &Adjustment, raw_ostream &Out) {
// FIXME: Actually, the dtor thunk should be emitted for vector deleting
// dtors rather than scalar deleting dtors. Just use the vector deleting dtor
// mangling manually until we support both deleting dtor types.
assert(Type == Dtor_Deleting)((Type == Dtor_Deleting) ? static_cast<void> (0) : __assert_fail
 ("Type == Dtor_Deleting", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 3094, __PRETTY_FUNCTION__));
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO, DD, Type);
Mangler.getStream() << "??_E";
Mangler.mangleName(DD->getParent());
mangleThunkThisAdjustment(DD->getAccess(), Adjustment, Mangler, MHO);
Mangler.mangleFunctionType(DD->getType()->castAs<FunctionProtoType>(), DD);
3101}

3103void MicrosoftMangleContextImpl::mangleCXXVFTable(
  const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
  raw_ostream &Out) {
// <mangled-name> ::= ?_7 <class-name> <storage-class>
//                    <cvr-qualifiers> [<name>] @
// NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class>
// is always '6' for vftables.
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
if (Derived->hasAttr<DLLImportAttr>())
  Mangler.getStream() << "??_S";
else
  Mangler.getStream() << "??_7";
Mangler.mangleName(Derived);
Mangler.getStream() << "6B"; // '6' for vftable, 'B' for const.
for (const CXXRecordDecl *RD : BasePath)
  Mangler.mangleName(RD);
Mangler.getStream() << '@';
3121}

3123void MicrosoftMangleContextImpl::mangleCXXVBTable(
  const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
  raw_ostream &Out) {
// <mangled-name> ::= ?_8 <class-name> <storage-class>
//                    <cvr-qualifiers> [<name>] @
// NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class>
// is always '7' for vbtables.
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
Mangler.getStream() << "??_8";
Mangler.mangleName(Derived);
Mangler.getStream() << "7B";  // '7' for vbtable, 'B' for const.
for (const CXXRecordDecl *RD : BasePath)
  Mangler.mangleName(RD);
Mangler.getStream() << '@';
3138}

3140void MicrosoftMangleContextImpl::mangleCXXRTTI(QualType T, raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
Mangler.getStream() << "??_R0";
Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
Mangler.getStream() << "@8";
3146}

3148void MicrosoftMangleContextImpl::mangleCXXRTTIName(QualType T,
                                                 raw_ostream &Out) {
MicrosoftCXXNameMangler Mangler(*this, Out);
Mangler.getStream() << '.';
Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
3153}

3155void MicrosoftMangleContextImpl::mangleCXXVirtualDisplacementMap(
  const CXXRecordDecl *SrcRD, const CXXRecordDecl *DstRD, raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
Mangler.getStream() << "??_K";
Mangler.mangleName(SrcRD);
Mangler.getStream() << "$C";
Mangler.mangleName(DstRD);
3163}

3165void MicrosoftMangleContextImpl::mangleCXXThrowInfo(QualType T, bool IsConst,
                                                  bool IsVolatile,
                                                  bool IsUnaligned,
                                                  uint32_t NumEntries,
                                                  raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
Mangler.getStream() << "_TI";
if (IsConst)
  Mangler.getStream() << 'C';
if (IsVolatile)
  Mangler.getStream() << 'V';
if (IsUnaligned)
  Mangler.getStream() << 'U';
Mangler.getStream() << NumEntries;
Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
3181}

3183void MicrosoftMangleContextImpl::mangleCXXCatchableTypeArray(
  QualType T, uint32_t NumEntries, raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
Mangler.getStream() << "_CTA";
Mangler.getStream() << NumEntries;
Mangler.mangleType(T, SourceRange(), MicrosoftCXXNameMangler::QMM_Result);
3190}

3192void MicrosoftMangleContextImpl::mangleCXXCatchableType(
  QualType T, const CXXConstructorDecl *CD, CXXCtorType CT, uint32_t Size,
  uint32_t NVOffset, int32_t VBPtrOffset, uint32_t VBIndex,
  raw_ostream &Out) {
MicrosoftCXXNameMangler Mangler(*this, Out);
Mangler.getStream() << "_CT";

llvm::SmallString<64> RTTIMangling;
{
  llvm::raw_svector_ostream Stream(RTTIMangling);
  msvc_hashing_ostream MHO(Stream);
  mangleCXXRTTI(T, MHO);
}
Mangler.getStream() << RTTIMangling;

// VS2015 and VS2017.1 omit the copy-constructor in the mangled name but
// both older and newer versions include it.
// FIXME: It is known that the Ctor is present in 2013, and in 2017.7
// (_MSC_VER 1914) and newer, and that it's omitted in 2015 and 2017.4
// (_MSC_VER 1911), but it's unknown when exactly it reappeared (1914?
// Or 1912, 1913 aleady?).
bool OmitCopyCtor = getASTContext().getLangOpts().isCompatibleWithMSVC(
                        LangOptions::MSVC2015) &&
                    !getASTContext().getLangOpts().isCompatibleWithMSVC(
                        LangOptions::MSVC2017_7);
llvm::SmallString<64> CopyCtorMangling;
if (!OmitCopyCtor && CD) {
  llvm::raw_svector_ostream Stream(CopyCtorMangling);
  msvc_hashing_ostream MHO(Stream);
  mangleCXXCtor(CD, CT, MHO);
}
Mangler.getStream() << CopyCtorMangling;

Mangler.getStream() << Size;
if (VBPtrOffset == -1) {
  if (NVOffset) {
    Mangler.getStream() << NVOffset;
  }
} else {
  Mangler.getStream() << NVOffset;
  Mangler.getStream() << VBPtrOffset;
  Mangler.getStream() << VBIndex;
}
3235}

3237void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassDescriptor(
  const CXXRecordDecl *Derived, uint32_t NVOffset, int32_t VBPtrOffset,
  uint32_t VBTableOffset, uint32_t Flags, raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
Mangler.getStream() << "??_R1";
Mangler.mangleNumber(NVOffset);
Mangler.mangleNumber(VBPtrOffset);
Mangler.mangleNumber(VBTableOffset);
Mangler.mangleNumber(Flags);
Mangler.mangleName(Derived);
Mangler.getStream() << "8";
3249}

3251void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassArray(
  const CXXRecordDecl *Derived, raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
Mangler.getStream() << "??_R2";
Mangler.mangleName(Derived);
Mangler.getStream() << "8";
3258}

3260void MicrosoftMangleContextImpl::mangleCXXRTTIClassHierarchyDescriptor(
  const CXXRecordDecl *Derived, raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
Mangler.getStream() << "??_R3";
Mangler.mangleName(Derived);
Mangler.getStream() << "8";
3267}

3269void MicrosoftMangleContextImpl::mangleCXXRTTICompleteObjectLocator(
  const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
  raw_ostream &Out) {
// <mangled-name> ::= ?_R4 <class-name> <storage-class>
//                    <cvr-qualifiers> [<name>] @
// NOTE: <cvr-qualifiers> here is always 'B' (const). <storage-class>
// is always '6' for vftables.
llvm::SmallString<64> VFTableMangling;
llvm::raw_svector_ostream Stream(VFTableMangling);
mangleCXXVFTable(Derived, BasePath, Stream);

if (VFTableMangling.startswith("??@")) {
  assert(VFTableMangling.endswith("@"))((VFTableMangling.endswith("@")) ? static_cast<void> (0
) : __assert_fail ("VFTableMangling.endswith(\"@\")", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 3281, __PRETTY_FUNCTION__));
  Out << VFTableMangling << "??_R4@";
  return;
}

assert(VFTableMangling.startswith("??_7") ||((VFTableMangling.startswith("??_7") || VFTableMangling.startswith
("??_S")) ? static_cast<void> (0) : __assert_fail ("VFTableMangling.startswith(\"??_7\") || VFTableMangling.startswith(\"??_S\")"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 3287, __PRETTY_FUNCTION__))
       VFTableMangling.startswith("??_S"))((VFTableMangling.startswith("??_7") || VFTableMangling.startswith
("??_S")) ? static_cast<void> (0) : __assert_fail ("VFTableMangling.startswith(\"??_7\") || VFTableMangling.startswith(\"??_S\")"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/AST/MicrosoftMangle.cpp"
, 3287, __PRETTY_FUNCTION__));

Out << "??_R4" << StringRef(VFTableMangling).drop_front(4);
3290}

3292void MicrosoftMangleContextImpl::mangleSEHFilterExpression(
  const NamedDecl *EnclosingDecl, raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
// The function body is in the same comdat as the function with the handler,
// so the numbering here doesn't have to be the same across TUs.
//
// <mangled-name> ::= ?filt$ <filter-number> @0
Mangler.getStream() << "?filt$" << SEHFilterIds[EnclosingDecl]++ << "@0@";
Mangler.mangleName(EnclosingDecl);
3302}

3304void MicrosoftMangleContextImpl::mangleSEHFinallyBlock(
  const NamedDecl *EnclosingDecl, raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
// The function body is in the same comdat as the function with the handler,
// so the numbering here doesn't have to be the same across TUs.
//
// <mangled-name> ::= ?fin$ <filter-number> @0
Mangler.getStream() << "?fin$" << SEHFinallyIds[EnclosingDecl]++ << "@0@";
Mangler.mangleName(EnclosingDecl);
3314}

3316void MicrosoftMangleContextImpl::mangleTypeName(QualType T, raw_ostream &Out) {
// This is just a made up unique string for the purposes of tbaa.  undname
// does *not* know how to demangle it.
MicrosoftCXXNameMangler Mangler(*this, Out);
Mangler.getStream() << '?';
Mangler.mangleType(T, SourceRange());
3322}

3324void MicrosoftMangleContextImpl::mangleCXXCtor(const CXXConstructorDecl *D,
                                             CXXCtorType Type,
                                             raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler mangler(*this, MHO, D, Type);
mangler.mangle(D);
3330}

3332void MicrosoftMangleContextImpl::mangleCXXDtor(const CXXDestructorDecl *D,
                                             CXXDtorType Type,
                                             raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler mangler(*this, MHO, D, Type);
mangler.mangle(D);
3338}

3340void MicrosoftMangleContextImpl::mangleReferenceTemporary(
  const VarDecl *VD, unsigned ManglingNumber, raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);

Mangler.getStream() << "?$RT" << ManglingNumber << '@';
Mangler.mangle(VD, "");
3347}

3349void MicrosoftMangleContextImpl::mangleThreadSafeStaticGuardVariable(
  const VarDecl *VD, unsigned GuardNum, raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);

Mangler.getStream() << "?$TSS" << GuardNum << '@';
Mangler.mangleNestedName(VD);
Mangler.getStream() << "@4HA";
3357}

3359void MicrosoftMangleContextImpl::mangleStaticGuardVariable(const VarDecl *VD,
                                                         raw_ostream &Out) {
// <guard-name> ::= ?_B <postfix> @5 <scope-depth>
//              ::= ?__J <postfix> @5 <scope-depth>
//              ::= ?$S <guard-num> @ <postfix> @4IA

// The first mangling is what MSVC uses to guard static locals in inline
// functions.  It uses a different mangling in external functions to support
// guarding more than 32 variables.  MSVC rejects inline functions with more
// than 32 static locals.  We don't fully implement the second mangling
// because those guards are not externally visible, and instead use LLVM's
// default renaming when creating a new guard variable.
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);

bool Visible = VD->isExternallyVisible();
if (Visible) {
  Mangler.getStream() << (VD->getTLSKind() ? "??__J" : "??_B");
} else {
  Mangler.getStream() << "?$S1@";
}
unsigned ScopeDepth = 0;
if (Visible && !getNextDiscriminator(VD, ScopeDepth))
  // If we do not have a discriminator and are emitting a guard variable for
  // use at global scope, then mangling the nested name will not be enough to
  // remove ambiguities.
  Mangler.mangle(VD, "");
else
  Mangler.mangleNestedName(VD);
Mangler.getStream() << (Visible ? "@5" : "@4IA");
if (ScopeDepth)
  Mangler.mangleNumber(ScopeDepth);
3391}

3393void MicrosoftMangleContextImpl::mangleInitFiniStub(const VarDecl *D,
                                                  char CharCode,
                                                  raw_ostream &Out) {
msvc_hashing_ostream MHO(Out);
MicrosoftCXXNameMangler Mangler(*this, MHO);
Mangler.getStream() << "??__" << CharCode;
if (D->isStaticDataMember()) {
  Mangler.getStream() << '?';
  Mangler.mangleName(D);
  Mangler.mangleVariableEncoding(D);
  Mangler.getStream() << "@@";
} else {
  Mangler.mangleName(D);
}
// This is the function class mangling.  These stubs are global, non-variadic,
// cdecl functions that return void and take no args.
Mangler.getStream() << "YAXXZ";
3410}

3412void MicrosoftMangleContextImpl::mangleDynamicInitializer(const VarDecl *D,
                                                        raw_ostream &Out) {
// <initializer-name> ::= ?__E <name> YAXXZ
mangleInitFiniStub(D, 'E', Out);
3416}

3418void
3419MicrosoftMangleContextImpl::mangleDynamicAtExitDestructor(const VarDecl *D,
                                                        raw_ostream &Out) {
// <destructor-name> ::= ?__F <name> YAXXZ
mangleInitFiniStub(D, 'F', Out);
3423}

3425void MicrosoftMangleContextImpl::mangleStringLiteral(const StringLiteral *SL,
                                                   raw_ostream &Out) {
// <char-type> ::= 0   # char, char16_t, char32_t
//                     # (little endian char data in mangling)
//             ::= 1   # wchar_t (big endian char data in mangling)
//
// <literal-length> ::= <non-negative integer>  # the length of the literal
//
// <encoded-crc>    ::= <hex digit>+ @          # crc of the literal including
//                                              # trailing null bytes
//
// <encoded-string> ::= <simple character>           # uninteresting character
//                  ::= '?$' <hex digit> <hex digit> # these two nibbles
//                                                   # encode the byte for the
//                                                   # character
//                  ::= '?' [a-z]                    # \xe1 - \xfa
//                  ::= '?' [A-Z]                    # \xc1 - \xda
//                  ::= '?' [0-9]                    # [,/\:. \n\t'-]
//
// <literal> ::= '??_C@_' <char-type> <literal-length> <encoded-crc>
//               <encoded-string> '@'
MicrosoftCXXNameMangler Mangler(*this, Out);
Mangler.getStream() << "??_C@_";

// The actual string length might be different from that of the string literal
// in cases like:
// char foo[3] = "foobar";
// char bar[42] = "foobar";
// Where it is truncated or zero-padded to fit the array. This is the length
// used for mangling, and any trailing null-bytes also need to be mangled.
unsigned StringLength = getASTContext()
                            .getAsConstantArrayType(SL->getType())
                            ->getSize()
                            .getZExtValue();
unsigned StringByteLength = StringLength * SL->getCharByteWidth();

// <char-type>: The "kind" of string literal is encoded into the mangled name.
if (SL->isWide())
  Mangler.getStream() << '1';
else
  Mangler.getStream() << '0';

// <literal-length>: The next part of the mangled name consists of the length
// of the string in bytes.
Mangler.mangleNumber(StringByteLength);

auto GetLittleEndianByte = [&SL](unsigned Index) {
  unsigned CharByteWidth = SL->getCharByteWidth();
  if (Index / CharByteWidth >= SL->getLength())
    return static_cast<char>(0);
  uint32_t CodeUnit = SL->getCodeUnit(Index / CharByteWidth);
  unsigned OffsetInCodeUnit = Index % CharByteWidth;
  return static_cast<char>((CodeUnit >> (8 * OffsetInCodeUnit)) & 0xff);
};

auto GetBigEndianByte = [&SL](unsigned Index) {
  unsigned CharByteWidth = SL->getCharByteWidth();
  if (Index / CharByteWidth >= SL->getLength())
    return static_cast<char>(0);
  uint32_t CodeUnit = SL->getCodeUnit(Index / CharByteWidth);
  unsigned OffsetInCodeUnit = (CharByteWidth - 1) - (Index % CharByteWidth);
  return static_cast<char>((CodeUnit >> (8 * OffsetInCodeUnit)) & 0xff);
};

// CRC all the bytes of the StringLiteral.
llvm::JamCRC JC;
for (unsigned I = 0, E = StringByteLength; I != E; ++I)
  JC.update(GetLittleEndianByte(I));

// <encoded-crc>: The CRC is encoded utilizing the standard number mangling
// scheme.
Mangler.mangleNumber(JC.getCRC());

// <encoded-string>: The mangled name also contains the first 32 bytes
// (including null-terminator bytes) of the encoded StringLiteral.
// Each character is encoded by splitting them into bytes and then encoding
// the constituent bytes.
auto MangleByte = [&Mangler](char Byte) {
  // There are five different manglings for characters:
  // - [a-zA-Z0-9_$]: A one-to-one mapping.
  // - ?[a-z]: The range from \xe1 to \xfa.
  // - ?[A-Z]: The range from \xc1 to \xda.
  // - ?[0-9]: The set of [,/\:. \n\t'-].
  // - ?$XX: A fallback which maps nibbles.
  if (isIdentifierBody(Byte, /*AllowDollar=*/true)) {
    Mangler.getStream() << Byte;
  } else if (isLetter(Byte & 0x7f)) {
    Mangler.getStream() << '?' << static_cast<char>(Byte & 0x7f);
  } else {
    const char SpecialChars[] = {',', '/',  '\\', ':',  '.',
                                 ' ', '\n', '\t', '\'', '-'};
    const char *Pos = llvm::find(SpecialChars, Byte);
    if (Pos != std::end(SpecialChars)) {
      Mangler.getStream() << '?' << (Pos - std::begin(SpecialChars));
    } else {
      Mangler.getStream() << "?$";
      Mangler.getStream() << static_cast<char>('A' + ((Byte >> 4) & 0xf));
      Mangler.getStream() << static_cast<char>('A' + (Byte & 0xf));
    }
  }
};

// Enforce our 32 bytes max, except wchar_t which gets 32 chars instead.
unsigned MaxBytesToMangle = SL->isWide() ? 64U : 32U;
unsigned NumBytesToMangle = std::min(MaxBytesToMangle, StringByteLength);
for (unsigned I = 0; I != NumBytesToMangle; ++I) {
  if (SL->isWide())
    MangleByte(GetBigEndianByte(I));
  else
    MangleByte(GetLittleEndianByte(I));
}

Mangler.getStream() << '@';
3538}

3540MicrosoftMangleContext *
3541MicrosoftMangleContext::create(ASTContext &Context, DiagnosticsEngine &Diags) {
return new MicrosoftMangleContextImpl(Context, Diags);
3543}