//===--- MicrosoftMangle.cpp - Microsoft Visual C++ Name Mangling ---------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This provides C++ name mangling targeting the Microsoft Visual C++ ABI.

//

//===----------------------------------------------------------------------===//

#include "clang/AST/ASTContext.h"

#include "clang/AST/Attr.h"

#include "clang/AST/CXXInheritance.h"

#include "clang/AST/CharUnits.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/DeclObjC.h"

#include "clang/AST/DeclOpenMP.h"

#include "clang/AST/DeclTemplate.h"

#include "clang/AST/Expr.h"

#include "clang/AST/ExprCXX.h"

#include "clang/AST/GlobalDecl.h"

#include "clang/AST/Mangle.h"

#include "clang/AST/VTableBuilder.h"

#include "clang/Basic/ABI.h"

#include "clang/Basic/DiagnosticOptions.h"

#include "clang/Basic/FileManager.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Basic/TargetInfo.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/Support/CRC.h"

#include "llvm/Support/MD5.h"

#include "llvm/Support/MathExtras.h"

#include "llvm/Support/StringSaver.h"

#include "llvm/Support/xxhash.h"

using namespace clang;

namespace {

// Get GlobalDecl of DeclContext of local entities.

static GlobalDecl getGlobalDeclAsDeclContext(const DeclContext *DC) {

  GlobalDecl GD;

  if (auto *CD = dyn_cast<CXXConstructorDecl>(DC))

    GD = GlobalDecl(CD, Ctor_Complete);

  else if (auto *DD = dyn_cast<CXXDestructorDecl>(DC))

    GD = GlobalDecl(DD, Dtor_Complete);

  else

    GD = GlobalDecl(cast<FunctionDecl>(DC));

  return GD;

}

struct 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 << '@';

  }

};

static const DeclContext *

getLambdaDefaultArgumentDeclContext(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;

}

/// Retrieve the declaration context that should be used when mangling

/// the given declaration.

static 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();

}

static const DeclContext *getEffectiveParentContext(const DeclContext *DC) {

  return getEffectiveDeclContext(cast<Decl>(DC));

}

static 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();

}

/// MicrosoftMangleContextImpl - Overrides the default MangleContext for the

/// Microsoft Visual C++ ABI.

class 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;

public:

  MicrosoftMangleContextImpl(ASTContext &Context, DiagnosticsEngine &Diags,

                             bool IsAux = false);

  bool shouldMangleCXXName(const NamedDecl *D) override;

  bool shouldMangleStringLiteral(const StringLiteral *SL) override;

  void mangleCXXName(GlobalDecl GD, 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 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, isAux());

      return true;

    }

    // Anonymous tags are already numbered.

    if (const TagDecl *Tag = dyn_cast<TagDecl>(ND)) {

      if (!Tag->hasNameForLinkage() &&

          
!getASTContext().getDeclaratorForUnnamedTagDecl(Tag)19
 &&

          
!getASTContext().getTypedefNameForUnnamedTagDecl(Tag)0
)

        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;

  }

  std::string getLambdaString(const CXXRecordDecl *Lambda) override {

    assert(Lambda->isLambda() && "RD must be a lambda!");

    std::string Name("<lambda_");

    Decl *LambdaContextDecl = Lambda->getLambdaContextDecl();

    unsigned LambdaManglingNumber = Lambda->getLambdaManglingNumber();

    unsigned LambdaId;

    const ParmVarDecl *Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);

    const FunctionDecl *Func =

        Parm ? 
dyn_cast<FunctionDecl>(Parm->getDeclContext())6
 : 
nullptr10
;

    if (Func) {

      unsigned DefaultArgNo =

          Func->getNumParams() - Parm->getFunctionScopeIndex();

      Name += llvm::utostr(DefaultArgNo);

      Name += "_";

    }

    if (LambdaManglingNumber)

      LambdaId = LambdaManglingNumber;

    else

      LambdaId = getLambdaIdForDebugInfo(Lambda);

    Name += llvm::utostr(LambdaId);

    Name += ">";

    return Name;

  }

  unsigned getLambdaId(const CXXRecordDecl *RD) {

    assert(RD->isLambda() && "RD must be a lambda!");

    assert(!RD->isExternallyVisible() && "RD must not be visible!");

    assert(RD->getLambdaManglingNumber() == 0 &&

           "RD must not have a mangling number!");

    std::pair<llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator, bool>

        Result = LambdaIds.insert(std::make_pair(RD, LambdaIds.size()));

    return Result.first->second;

  }

  unsigned getLambdaIdForDebugInfo(const CXXRecordDecl *RD) {

    assert(RD->isLambda() && "RD must be a lambda!");

    assert(!RD->isExternallyVisible() && "RD must not be visible!");

    assert(RD->getLambdaManglingNumber() == 0 &&

           "RD must not have a mangling number!");

    llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator Result =

        LambdaIds.find(RD);

    // The lambda should exist, but return 0 in case it doesn't.

    if (Result == LambdaIds.end())

      return 0;

    return Result->second;

  }

  /// Return a character sequence that is (somewhat) unique to the TU suitable

  /// for mangling anonymous namespaces.

  StringRef getAnonymousNamespaceHash() const {

    return AnonymousNamespaceHash;

  }

private:

  void mangleInitFiniStub(const VarDecl *D, char CharCode, raw_ostream &Out);

};

/// MicrosoftCXXNameMangler - Manage the mangling of a single name for the

/// Microsoft Visual C++ ABI.

class 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;

public:

  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(GlobalDecl GD, StringRef Prefix = "?");

  void mangleName(GlobalDecl GD);

  void mangleFunctionEncoding(GlobalDecl GD, bool ShouldMangle);

  void mangleVariableEncoding(const VarDecl *VD);

  void mangleMemberDataPointer(const CXXRecordDecl *RD, const ValueDecl *VD,

                               StringRef Prefix = "$");

  void mangleMemberFunctionPointer(const CXXRecordDecl *RD,

                                   const CXXMethodDecl *MD,

                                   StringRef Prefix = "$");

  void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD,

                                const MethodVFTableLocation &ML);

  void mangleNumber(int64_t Number);

  void mangleNumber(llvm::APSInt Number);

  void mangleFloat(llvm::APFloat Number);

  void mangleBits(llvm::APInt 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(GlobalDecl GD);

private:

  bool isStructorDecl(const NamedDecl *ND) const {

    return ND == Structor || 
getStructor(ND) == Structor280
;

  }

  bool is64BitPointer(Qualifiers Quals) const {

    LangAS AddrSpace = Quals.getAddressSpace();

    return AddrSpace == LangAS::ptr64 ||

           (PointersAre64Bit && 
!(2.66k
AddrSpace == LangAS::ptr32_sptr2.66k
 ||

                                  
AddrSpace == LangAS::ptr32_uptr2.65k
));

  }

  void mangleUnqualifiedName(GlobalDecl GD) {

    mangleUnqualifiedName(GD, cast<NamedDecl>(GD.getDecl())->getDeclName());

  }

  void mangleUnqualifiedName(GlobalDecl GD, 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(GlobalDecl GD);

  void

  mangleTemplateInstantiationName(GlobalDecl GD,

                                  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.

#define ABSTRACT_TYPE(CLASS, PARENT)

#define NON_CANONICAL_TYPE(CLASS, PARENT)

#define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T, \

                                            Qualifiers Quals, \

                                            SourceRange Range);

#include "clang/AST/TypeNodes.inc"

#undef ABSTRACT_TYPE

#undef NON_CANONICAL_TYPE

#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,

                            const NonTypeTemplateParmDecl *PD = nullptr,

                            QualType TemplateArgType = QualType());

  void mangleExpression(const Expr *E, const NonTypeTemplateParmDecl *PD);

  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 mangleTemplateArgValue(QualType T, const APValue &V,

                              bool WithScalarType = false);

  void mangleObjCProtocol(const ObjCProtocolDecl *PD);

  void mangleObjCLifetime(const QualType T, Qualifiers Quals,

                          SourceRange Range);

  void mangleObjCKindOfType(const ObjCObjectType *T, Qualifiers Quals,

                            SourceRange Range);

};

}

MicrosoftMangleContextImpl::MicrosoftMangleContextImpl(ASTContext &Context,

                                                       DiagnosticsEngine &Diags,

                                                       bool IsAux)

    : MicrosoftMangleContext(Context, Diags, IsAux) {

  // 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";

  }

}

bool 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 == CXXLanguageLinkage113k
)

      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)4.86k
) {

    // C variables are not mangled.

    if (VD->isExternC())

      return false;

    // Variables at global scope with internal linkage are not mangled.

    const DeclContext *DC = getEffectiveDeclContext(D);

    // Check for extern variable declared locally.

    if (DC->isFunctionOrMethod() && 
D->hasLinkage()334
)

      while (!DC->isNamespace() && !DC->isTranslationUnit())

        DC = getEffectiveParentContext(DC);

    if (DC->isTranslationUnit() && 
D->getFormalLinkage() == InternalLinkage3.14k
 &&

        
!isa<VarTemplateSpecializationDecl>(D)24
 &&

        
D->getIdentifier() != nullptr24
)

      return false;

  }

  return true;

}

bool

MicrosoftMangleContextImpl::shouldMangleStringLiteral(const StringLiteral *SL) {

  return true;

}

void MicrosoftCXXNameMangler::mangle(GlobalDecl GD, StringRef Prefix) {

  const NamedDecl *D = cast<NamedDecl>(GD.getDecl());

  // 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(GD);

  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))

    mangleFunctionEncoding(GD, Context.shouldMangleDeclName(FD));

  else if (const VarDecl *VD = dyn_cast<VarDecl>(D))

    mangleVariableEncoding(VD);

  else if (isa<MSGuidDecl>(D))

    // MSVC appears to mangle GUIDs as if they were variables of type

    // 'const struct __s_GUID'.

    Out << "3U__s_GUID@@B";

  else if (isa<TemplateParamObjectDecl>(D)) {

    // Template parameter objects don't get a <type-encoding>; their type is

    // specified as part of their value.

  } else

    llvm_unreachable("Tried to mangle unexpected NamedDecl!");

}

void MicrosoftCXXNameMangler::mangleFunctionEncoding(GlobalDecl GD,

                                                     bool ShouldMangle) {

  const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());

  // <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>()32
)

      Out << "$$J0";

    mangleFunctionClass(FD);

    mangleFunctionType(FT, FD, false, false);

  } else {

    Out << '9';

  }

}

void 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()1.66k
 ||

      
Ty->isMemberPointerType()1.64k
) {

    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);

  }

}

void MicrosoftCXXNameMangler::mangleMemberDataPointer(const CXXRecordDecl *RD,

                                                      const ValueDecl *VD,

                                                      StringRef Prefix) {

  // <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 &&

           "cannot take address of bitfield");

    FieldOffset /= getASTContext().getCharWidth();

    VBTableOffset = 0;

    if (IM == MSInheritanceModel::Virtual)

      FieldOffset -= getASTContext().getOffsetOfBaseWithVBPtr(RD).getQuantity();

  } else {

    FieldOffset = RD->nullFieldOffsetIsZero() ? 
04
 : 
-14
;

    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 << Prefix << 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);

}

void

MicrosoftCXXNameMangler::mangleMemberFunctionPointer(const CXXRecordDecl *RD,

                                                     const CXXMethodDecl *MD,

                                                     StringRef Prefix) {

  // <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 << Prefix << 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::Virtual14
)

      NVOffset -= getASTContext().getOffsetOfBaseWithVBPtr(RD).getQuantity();

  } else {

    // Null single inheritance member functions are encoded as a simple nullptr.

    if (IM == MSInheritanceModel::Single) {

      Out << Prefix << "0A@";

      return;

    }

    if (IM == MSInheritanceModel::Unspecified)

      VBTableOffset = -1;

    Out << Prefix << Code;

  }

  if (inheritanceModelHasNVOffsetField(/*IsMemberFunction=*/true, IM))

    mangleNumber(static_cast<uint32_t>(NVOffset));

  if (inheritanceModelHasVBPtrOffsetField(IM))

    mangleNumber(VBPtrOffset);

  if (inheritanceModelHasVBTableOffsetField(IM))

    mangleNumber(VBTableOffset);

}

void 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()->castAs<FunctionProtoType>());

}

void MicrosoftCXXNameMangler::mangleName(GlobalDecl GD) {

  // <name> ::= <unscoped-name> {[<named-scope>]+ | [<nested-name>]}? @

  // Always start with the unqualified name.

  mangleUnqualifiedName(GD);

  mangleNestedName(GD);

  // Terminate the whole name with an '@'.

  Out << '@';

}

void MicrosoftCXXNameMangler::mangleNumber(int64_t Number) {

  mangleNumber(llvm::APSInt(llvm::APInt(64, Number), /*IsUnsigned*/false));

}

void MicrosoftCXXNameMangler::mangleNumber(llvm::APSInt Number) {

  // MSVC never mangles any integer wider than 64 bits. In general it appears

  // to convert every integer to signed 64 bit before mangling (including

  // unsigned 64 bit values). Do the same, but preserve bits beyond the bottom

  // 64.

  unsigned Width = std::max(Number.getBitWidth(), 64U);

  llvm::APInt Value = Number.extend(Width);

  // <non-negative integer> ::= A@              # when Number == 0

  //                        ::= <decimal digit> # when 1 <= Number <= 10

  //                        ::= <hex digit>+ @  # when Number >= 10

  //

  // <number>               ::= [?] <non-negative integer>

  if (Value.isNegative()) {

    Value = -Value;

    Out << '?';

  }

  mangleBits(Value);

}

void MicrosoftCXXNameMangler::mangleFloat(llvm::APFloat Number) {

  using llvm::APFloat;

  switch (APFloat::SemanticsToEnum(Number.getSemantics())) {

  case APFloat::S_IEEEsingle: Out << 'A'; break;

  case APFloat::S_IEEEdouble: Out << 'B'; break;

  // The following are all Clang extensions. We try to pick manglings that are

  // unlikely to conflict with MSVC's scheme.

  case APFloat::S_IEEEhalf: Out << 'V'; break;

  case APFloat::S_BFloat: Out << 'W'; break;

  case APFloat::S_x87DoubleExtended: Out << 'X'; break;

  case APFloat::S_IEEEquad: Out << 'Y'; break;

  case APFloat::S_PPCDoubleDouble: Out << 'Z'; break;

  }

  mangleBits(Number.bitcastToAPInt());

}

void MicrosoftCXXNameMangler::mangleBits(llvm::APInt Value) {

  if (Value == 0)

    Out << "A@";

  else if (Value.uge(1) && Value.ule(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'

    llvm::SmallString<32> EncodedNumberBuffer;

    for (; Value != 0; 
Value.lshrInPlace(4)10.7k
)

      EncodedNumberBuffer.push_back('A' + (Value & 0xf).getZExtValue());

    std::reverse(EncodedNumberBuffer.begin(), EncodedNumberBuffer.end());

    Out.write(EncodedNumberBuffer.data(), EncodedNumberBuffer.size());

    Out << '@';

  }

}

static GlobalDecl isTemplate(GlobalDecl GD,

                             const TemplateArgumentList *&TemplateArgs) {

  const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());

  // 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 GD.getWithDecl(TD);

    }

  }

  // Check if we have a class template.

  if (const ClassTemplateSpecializationDecl *Spec =

          dyn_cast<ClassTemplateSpecializationDecl>(ND)) {

    TemplateArgs = &Spec->getTemplateArgs();

    return GD.getWithDecl(Spec->getSpecializedTemplate());

  }

  // Check if we have a variable template.

  if (const VarTemplateSpecializationDecl *Spec =

          dyn_cast<VarTemplateSpecializationDecl>(ND)) {

    TemplateArgs = &Spec->getTemplateArgs();

    return GD.getWithDecl(Spec->getSpecializedTemplate());

  }

  return GlobalDecl();

}

void MicrosoftCXXNameMangler::mangleUnqualifiedName(GlobalDecl GD,

                                                    DeclarationName Name) {

  const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());

  //  <unqualified-name> ::= <operator-name>

  //                     ::= <ctor-dtor-name>

  //                     ::= <source-name>

  //                     ::= <template-name>

  // Check if we have a template.

  const TemplateArgumentList *TemplateArgs = nullptr;

  if (GlobalDecl TD = isTemplate(GD, 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.getDecl())) {

      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()) {

        bool IsDeviceStub =

            ND &&

            ((isa<FunctionDecl>(ND) && 
ND->hasAttr<CUDAGlobalAttr>()20.1k
) ||

             
(49.9k
isa<FunctionTemplateDecl>(ND)49.9k
 &&

              cast<FunctionTemplateDecl>(ND)

                  ->getTemplatedDecl()

                  ->hasAttr<CUDAGlobalAttr>())) &&

            
GD.getKernelReferenceKind() == KernelReferenceKind::Stub24
;

        if (IsDeviceStub)

          mangleSourceName(

              (llvm::Twine("__device_stub__") + II->getName()).str());

        else

          mangleSourceName(II->getName());

        break;

      }

      // Otherwise, an anonymous entity.  We must have a declaration.

      assert(ND && "mangling empty name without declaration");

      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");

        // 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;

      }

      if (const MSGuidDecl *GD = dyn_cast<MSGuidDecl>(ND)) {

        // Mangle a GUID object as if it were a variable with the corresponding

        // mangled name.

        SmallString<sizeof("_GUID_12345678_1234_1234_1234_1234567890ab")> GUID;

        llvm::raw_svector_ostream GUIDOS(GUID);

        Context.mangleMSGuidDecl(GD, GUIDOS);

        mangleSourceName(GUID);

        break;

      }

      if (const auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {

        Out << "?__N";

        mangleTemplateArgValue(TPO->getType().getUnqualifiedType(),

                               TPO->getValue());

        break;

      }

      // We must have an anonymous struct.

      const TagDecl *TD = cast<TagDecl>(ND);

      if (const TypedefNameDecl *D = TD->getTypedefNameForAnonDecl()) {

        assert(TD->getDeclContext() == D->getDeclContext() &&

               "Typedef should not be in another decl context!");

        assert(D->getDeclName().getAsIdentifierInfo() &&

               "Typedef was not named!");

        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())30
 : 
nullptr154
;