//===--- 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/SmallVector.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" #include <functional> #include <optional> usingnamespaceclang; namespace { // Get GlobalDecl of DeclContext of local entities. static GlobalDecl getGlobalDeclAsDeclContext(const DeclContext *DC) { … } struct msvc_hashing_ostream : public llvm::raw_svector_ostream { … }; static const DeclContext * getLambdaDefaultArgumentDeclContext(const Decl *D) { … } /// Retrieve the declaration context that should be used when mangling /// the given declaration. static const DeclContext *getEffectiveDeclContext(const Decl *D) { … } static const DeclContext *getEffectiveParentContext(const DeclContext *DC) { … } static const FunctionDecl *getStructor(const NamedDecl *ND) { … } /// MicrosoftMangleContextImpl - Overrides the default MangleContext for the /// Microsoft Visual C++ ABI. class MicrosoftMangleContextImpl : public MicrosoftMangleContext { … }; /// MicrosoftCXXNameMangler - Manage the mangling of a single name for the /// Microsoft Visual C++ ABI. class MicrosoftCXXNameMangler { … }; } MicrosoftMangleContextImpl::MicrosoftMangleContextImpl(ASTContext &Context, DiagnosticsEngine &Diags, bool IsAux) : … { … } bool MicrosoftMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) { … } bool MicrosoftMangleContextImpl::shouldMangleStringLiteral(const StringLiteral *SL) { … } DiagnosticBuilder MicrosoftCXXNameMangler::Error(SourceLocation loc, StringRef thing1, StringRef thing2) { … } DiagnosticBuilder MicrosoftCXXNameMangler::Error(SourceLocation loc, StringRef thingy) { … } DiagnosticBuilder MicrosoftCXXNameMangler::Error(StringRef thingy) { … } void MicrosoftCXXNameMangler::mangle(GlobalDecl GD, StringRef Prefix) { … } void MicrosoftCXXNameMangler::mangleFunctionEncoding(GlobalDecl GD, bool ShouldMangle) { … } void MicrosoftCXXNameMangler::mangleVariableEncoding(const VarDecl *VD) { … } void MicrosoftCXXNameMangler::mangleMemberDataPointer( const CXXRecordDecl *RD, const ValueDecl *VD, const NonTypeTemplateParmDecl *PD, QualType TemplateArgType, StringRef Prefix) { … } void MicrosoftCXXNameMangler::mangleMemberDataPointerInClassNTTP( const CXXRecordDecl *RD, const ValueDecl *VD) { … } void MicrosoftCXXNameMangler::mangleMemberFunctionPointer( const CXXRecordDecl *RD, const CXXMethodDecl *MD, const NonTypeTemplateParmDecl *PD, QualType TemplateArgType, StringRef Prefix) { … } void MicrosoftCXXNameMangler::mangleFunctionPointer( const FunctionDecl *FD, const NonTypeTemplateParmDecl *PD, QualType TemplateArgType) { … } void MicrosoftCXXNameMangler::mangleVarDecl(const VarDecl *VD, const NonTypeTemplateParmDecl *PD, QualType TemplateArgType) { … } void MicrosoftCXXNameMangler::mangleMemberFunctionPointerInClassNTTP( const CXXRecordDecl *RD, const CXXMethodDecl *MD) { … } void MicrosoftCXXNameMangler::mangleVirtualMemPtrThunk( const CXXMethodDecl *MD, const MethodVFTableLocation &ML) { … } void MicrosoftCXXNameMangler::mangleName(GlobalDecl GD) { … } void MicrosoftCXXNameMangler::mangleNumber(int64_t Number) { … } void MicrosoftCXXNameMangler::mangleNumber(llvm::APSInt Number) { … } void MicrosoftCXXNameMangler::mangleFloat(llvm::APFloat Number) { … } void MicrosoftCXXNameMangler::mangleBits(llvm::APInt Value) { … } static GlobalDecl isTemplate(GlobalDecl GD, const TemplateArgumentList *&TemplateArgs) { … } void MicrosoftCXXNameMangler::mangleUnqualifiedName(GlobalDecl GD, DeclarationName Name) { … } // <postfix> ::= <unqualified-name> [<postfix>] // ::= <substitution> [<postfix>] void MicrosoftCXXNameMangler::mangleNestedName(GlobalDecl GD) { … } void MicrosoftCXXNameMangler::mangleCXXDtorType(CXXDtorType T) { … } void MicrosoftCXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO, SourceLocation Loc) { … } void MicrosoftCXXNameMangler::mangleSourceName(StringRef Name) { … } void MicrosoftCXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) { … } void MicrosoftCXXNameMangler::mangleTemplateInstantiationName( GlobalDecl GD, const TemplateArgumentList &TemplateArgs) { … } void MicrosoftCXXNameMangler::mangleUnscopedTemplateName(GlobalDecl GD) { … } void MicrosoftCXXNameMangler::mangleIntegerLiteral( const llvm::APSInt &Value, const NonTypeTemplateParmDecl *PD, QualType TemplateArgType) { … } void MicrosoftCXXNameMangler::mangleExpression( const Expr *E, const NonTypeTemplateParmDecl *PD) { … } void MicrosoftCXXNameMangler::mangleTemplateArgs( const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) { … } /// If value V (with type T) represents a decayed pointer to the first element /// of an array, return that array. static ValueDecl *getAsArrayToPointerDecayedDecl(QualType T, const APValue &V) { … } void MicrosoftCXXNameMangler::mangleTemplateArg(const TemplateDecl *TD, const TemplateArgument &TA, const NamedDecl *Parm) { … } void MicrosoftCXXNameMangler::mangleTemplateArgValue(QualType T, const APValue &V, TplArgKind TAK, bool WithScalarType) { … } void MicrosoftCXXNameMangler::mangleObjCProtocol(const ObjCProtocolDecl *PD) { … } void MicrosoftCXXNameMangler::mangleObjCLifetime(const QualType Type, Qualifiers Quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleObjCKindOfType(const ObjCObjectType *T, Qualifiers Quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleQualifiers(Qualifiers Quals, bool IsMember) { … } void MicrosoftCXXNameMangler::mangleRefQualifier(RefQualifierKind RefQualifier) { … } void MicrosoftCXXNameMangler::manglePointerExtQualifiers(Qualifiers Quals, QualType PointeeType) { … } void MicrosoftCXXNameMangler::manglePointerCVQualifiers(Qualifiers Quals) { … } void MicrosoftCXXNameMangler::mangleFunctionArgumentType(QualType T, SourceRange Range) { … } void MicrosoftCXXNameMangler::manglePassObjectSizeArg( const PassObjectSizeAttr *POSA) { … } void MicrosoftCXXNameMangler::mangleAddressSpaceType(QualType T, Qualifiers Quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleAutoReturnType(QualType T, QualifierMangleMode QMM) { … } void MicrosoftCXXNameMangler::mangleType(QualType T, SourceRange Range, QualifierMangleMode QMM) { … } void MicrosoftCXXNameMangler::mangleType(const BuiltinType *T, Qualifiers, SourceRange Range) { … } // <type> ::= <function-type> void MicrosoftCXXNameMangler::mangleType(const FunctionProtoType *T, Qualifiers, SourceRange) { … } void MicrosoftCXXNameMangler::mangleType(const FunctionNoProtoType *T, Qualifiers, SourceRange) { … } void MicrosoftCXXNameMangler::mangleFunctionType(const FunctionType *T, const FunctionDecl *D, bool ForceThisQuals, bool MangleExceptionSpec) { … } void MicrosoftCXXNameMangler::mangleFunctionClass(const FunctionDecl *FD) { … } void MicrosoftCXXNameMangler::mangleCallingConvention(CallingConv CC, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleCallingConvention(const FunctionType *T, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleThrowSpecification( const FunctionProtoType *FT) { … } void MicrosoftCXXNameMangler::mangleType(const UnresolvedUsingType *T, Qualifiers, SourceRange Range) { … } // <type> ::= <union-type> | <struct-type> | <class-type> | <enum-type> // <union-type> ::= T <name> // <struct-type> ::= U <name> // <class-type> ::= V <name> // <enum-type> ::= W4 <name> void MicrosoftCXXNameMangler::mangleTagTypeKind(TagTypeKind TTK) { … } void MicrosoftCXXNameMangler::mangleType(const EnumType *T, Qualifiers, SourceRange) { … } void MicrosoftCXXNameMangler::mangleType(const RecordType *T, Qualifiers, SourceRange) { … } void MicrosoftCXXNameMangler::mangleType(const TagDecl *TD) { … } // If you add a call to this, consider updating isArtificialTagType() too. void MicrosoftCXXNameMangler::mangleArtificialTagType( TagTypeKind TK, StringRef UnqualifiedName, ArrayRef<StringRef> NestedNames) { … } // <type> ::= <array-type> // <array-type> ::= <pointer-cvr-qualifiers> <cvr-qualifiers> // [Y <dimension-count> <dimension>+] // <element-type> # as global, E is never required // It's supposed to be the other way around, but for some strange reason, it // isn't. Today this behavior is retained for the sole purpose of backwards // compatibility. void MicrosoftCXXNameMangler::mangleDecayedArrayType(const ArrayType *T) { … } void MicrosoftCXXNameMangler::mangleType(const ConstantArrayType *T, Qualifiers, SourceRange) { … } void MicrosoftCXXNameMangler::mangleType(const VariableArrayType *T, Qualifiers, SourceRange) { … } void MicrosoftCXXNameMangler::mangleType(const DependentSizedArrayType *T, Qualifiers, SourceRange) { … } void MicrosoftCXXNameMangler::mangleType(const IncompleteArrayType *T, Qualifiers, SourceRange) { … } void MicrosoftCXXNameMangler::mangleArrayType(const ArrayType *T) { … } void MicrosoftCXXNameMangler::mangleType(const ArrayParameterType *T, Qualifiers, SourceRange) { … } // <type> ::= <pointer-to-member-type> // <pointer-to-member-type> ::= <pointer-cvr-qualifiers> <cvr-qualifiers> // <class name> <type> void MicrosoftCXXNameMangler::mangleType(const MemberPointerType *T, Qualifiers Quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const TemplateTypeParmType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const SubstTemplateTypeParmPackType *T, Qualifiers, SourceRange Range) { … } // <type> ::= <pointer-type> // <pointer-type> ::= E? <pointer-cvr-qualifiers> <cvr-qualifiers> <type> // # the E is required for 64-bit non-static pointers void MicrosoftCXXNameMangler::mangleType(const PointerType *T, Qualifiers Quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const ObjCObjectPointerType *T, Qualifiers Quals, SourceRange Range) { … } // <type> ::= <reference-type> // <reference-type> ::= A E? <cvr-qualifiers> <type> // # the E is required for 64-bit non-static lvalue references void MicrosoftCXXNameMangler::mangleType(const LValueReferenceType *T, Qualifiers Quals, SourceRange Range) { … } // <type> ::= <r-value-reference-type> // <r-value-reference-type> ::= $$Q E? <cvr-qualifiers> <type> // # the E is required for 64-bit non-static rvalue references void MicrosoftCXXNameMangler::mangleType(const RValueReferenceType *T, Qualifiers Quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const ComplexType *T, Qualifiers, SourceRange Range) { … } // Returns true for types that mangleArtificialTagType() gets called for with // TagTypeKind Union, Struct, Class and where compatibility with MSVC's // mangling matters. // (It doesn't matter for Objective-C types and the like that cl.exe doesn't // support.) bool MicrosoftCXXNameMangler::isArtificialTagType(QualType T) const { … } void MicrosoftCXXNameMangler::mangleType(const VectorType *T, Qualifiers Quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const ExtVectorType *T, Qualifiers Quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const DependentVectorType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const DependentSizedExtVectorType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const ConstantMatrixType *T, Qualifiers quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const DependentSizedMatrixType *T, Qualifiers quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const DependentAddressSpaceType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const ObjCInterfaceType *T, Qualifiers, SourceRange) { … } void MicrosoftCXXNameMangler::mangleType(const ObjCObjectType *T, Qualifiers Quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const BlockPointerType *T, Qualifiers Quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const InjectedClassNameType *, Qualifiers, SourceRange) { … } void MicrosoftCXXNameMangler::mangleType(const TemplateSpecializationType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const DependentNameType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType( const DependentTemplateSpecializationType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const PackExpansionType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const PackIndexingType *T, Qualifiers Quals, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const TypeOfType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const TypeOfExprType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const DecltypeType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const UnaryTransformType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const AutoType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType( const DeducedTemplateSpecializationType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const AtomicType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const PipeType *T, Qualifiers, SourceRange Range) { … } void MicrosoftMangleContextImpl::mangleCXXName(GlobalDecl GD, raw_ostream &Out) { … } void MicrosoftCXXNameMangler::mangleType(const BitIntType *T, Qualifiers, SourceRange Range) { … } void MicrosoftCXXNameMangler::mangleType(const DependentBitIntType *T, Qualifiers, SourceRange Range) { … } // <this-adjustment> ::= <no-adjustment> | <static-adjustment> | // <virtual-adjustment> // <no-adjustment> ::= A # private near // ::= B # private far // ::= I # protected near // ::= J # protected far // ::= Q # public near // ::= R # public far // <static-adjustment> ::= G <static-offset> # private near // ::= H <static-offset> # private far // ::= O <static-offset> # protected near // ::= P <static-offset> # protected far // ::= W <static-offset> # public near // ::= X <static-offset> # public far // <virtual-adjustment> ::= $0 <virtual-shift> <static-offset> # private near // ::= $1 <virtual-shift> <static-offset> # private far // ::= $2 <virtual-shift> <static-offset> # protected near // ::= $3 <virtual-shift> <static-offset> # protected far // ::= $4 <virtual-shift> <static-offset> # public near // ::= $5 <virtual-shift> <static-offset> # public far // <virtual-shift> ::= <vtordisp-shift> | <vtordispex-shift> // <vtordisp-shift> ::= <offset-to-vtordisp> // <vtordispex-shift> ::= <offset-to-vbptr> <vbase-offset-offset> // <offset-to-vtordisp> static void mangleThunkThisAdjustment(AccessSpecifier AS, const ThisAdjustment &Adjustment, MicrosoftCXXNameMangler &Mangler, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleVirtualMemPtrThunk( const CXXMethodDecl *MD, const MethodVFTableLocation &ML, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk, bool /*ElideOverrideInfo*/, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type, const ThunkInfo &Thunk, bool /*ElideOverrideInfo*/, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXVFTable( const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXVTable(const CXXRecordDecl *Derived, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXVBTable( const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXRTTI(QualType T, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXRTTIName( QualType T, raw_ostream &Out, bool NormalizeIntegers = false) { … } void MicrosoftMangleContextImpl::mangleCXXVirtualDisplacementMap( const CXXRecordDecl *SrcRD, const CXXRecordDecl *DstRD, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXThrowInfo(QualType T, bool IsConst, bool IsVolatile, bool IsUnaligned, uint32_t NumEntries, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXCatchableTypeArray( QualType T, uint32_t NumEntries, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXCatchableType( QualType T, const CXXConstructorDecl *CD, CXXCtorType CT, uint32_t Size, uint32_t NVOffset, int32_t VBPtrOffset, uint32_t VBIndex, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassDescriptor( const CXXRecordDecl *Derived, uint32_t NVOffset, int32_t VBPtrOffset, uint32_t VBTableOffset, uint32_t Flags, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassArray( const CXXRecordDecl *Derived, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXRTTIClassHierarchyDescriptor( const CXXRecordDecl *Derived, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCXXRTTICompleteObjectLocator( const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleSEHFilterExpression( GlobalDecl EnclosingDecl, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleSEHFinallyBlock( GlobalDecl EnclosingDecl, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleCanonicalTypeName( QualType T, raw_ostream &Out, bool NormalizeIntegers = false) { … } void MicrosoftMangleContextImpl::mangleReferenceTemporary( const VarDecl *VD, unsigned ManglingNumber, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleThreadSafeStaticGuardVariable( const VarDecl *VD, unsigned GuardNum, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleStaticGuardVariable(const VarDecl *VD, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleInitFiniStub(const VarDecl *D, char CharCode, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleDynamicInitializer(const VarDecl *D, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleDynamicAtExitDestructor(const VarDecl *D, raw_ostream &Out) { … } void MicrosoftMangleContextImpl::mangleStringLiteral(const StringLiteral *SL, raw_ostream &Out) { … } void MicrosoftCXXNameMangler::mangleAutoReturnType(const MemberPointerType *T, Qualifiers Quals) { … } void MicrosoftCXXNameMangler::mangleAutoReturnType(const PointerType *T, Qualifiers Quals) { … } void MicrosoftCXXNameMangler::mangleAutoReturnType(const LValueReferenceType *T, Qualifiers Quals) { … } void MicrosoftCXXNameMangler::mangleAutoReturnType(const RValueReferenceType *T, Qualifiers Quals) { … } MicrosoftMangleContext *MicrosoftMangleContext::create(ASTContext &Context, DiagnosticsEngine &Diags, bool IsAux) { … }
Codebase Browser
llvm