Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/MicrosoftMangle_8cpp_source.html below:

clang: lib/AST/MicrosoftMangle.cpp Source File

;

(

*CD = dyn_cast<CXXConstructorDecl>(DC))

(

*DD = dyn_cast<CXXDestructorDecl>(DC))

msvc_hashing_ostream :

llvm::raw_svector_ostream {

msvc_hashing_ostream(raw_ostream &OS)

:

::raw_svector_ostream(Buffer), OS(OS) {}

~msvc_hashing_ostream()

{

StringRef MangledName = str();

StartsWithEscape = MangledName.starts_with(

);

MangledName = MangledName.drop_front(1);

(MangledName.size() < 4096) {

llvm::MD5::MD5Result Hash;

Hasher.update(MangledName);

llvm::MD5::stringifyResult(Hash, HexString);

OS <<

<< HexString <<

;

getLambdaDefaultArgumentDeclContext(

*

) {

(

*RD = dyn_cast<CXXRecordDecl>(

))

(

*Parm =

dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl()))

Parm->getDeclContext();

(

*LDADC = getLambdaDefaultArgumentDeclContext(

))

(

*BD = dyn_cast<BlockDecl>(

)) {

dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl()))

ContextParam->getDeclContext();

(isa<CapturedDecl>(DC) || isa<OMPDeclareReductionDecl>(DC) ||

isa<OMPDeclareMapperDecl>(DC)) {

getEffectiveDeclContext(cast<Decl>(DC));

getEffectiveDeclContext(cast<Decl>(DC));

(

*FTD = dyn_cast<FunctionTemplateDecl>(ND))

*FD = cast<FunctionDecl>(ND);

(

*FTD = FD->getPrimaryTemplate())

FTD->getTemplatedDecl()->getCanonicalDecl();

FD->getCanonicalDecl();

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<GlobalDecl, unsigned> SEHFilterIds;

llvm::DenseMap<GlobalDecl, unsigned> SEHFinallyIds;

IsAux =

);

raw_ostream &Out)

;

ElideOverrideInfo, raw_ostream &)

;

&Thunk,

ElideOverrideInfo,

raw_ostream &)

;

raw_ostream &Out)

;

raw_ostream &Out)

;

raw_ostream &Out)

;

IsUnaligned, uint32_t NumEntries,

raw_ostream &Out)

;

raw_ostream &Out)

;

int32_t VBPtrOffset, uint32_t VBIndex,

raw_ostream &Out)

;

NormalizeIntegers)

;

uint32_t NVOffset, int32_t VBPtrOffset,

uint32_t VBTableOffset, uint32_t Flags,

raw_ostream &Out)

;

raw_ostream &Out)

;

raw_ostream &Out)

;

raw_ostream &Out)

;

NormalizeIntegers)

;

raw_ostream &)

;

raw_ostream &Out)

;

raw_ostream &Out)

;

raw_ostream &Out)

;

raw_ostream &Out)

;

getNextDiscriminator(

*ND,

&disc) {

*DC = getEffectiveDeclContext(ND);

(

*RD = dyn_cast<CXXRecordDecl>(ND)) {

(RD->isLambda()) {

(

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

(!

->hasNameForLinkage() &&

!getASTContext().getDeclaratorForUnnamedTagDecl(Tag) &&

&discriminator = Uniquifier[ND];

discriminator = ++Discriminator[std::make_pair(DC, ND->

())];

disc = discriminator + 1;

assert(Lambda->

() &&

);

std::string Name(

);

*Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);

Parm ? dyn_cast<FunctionDecl>(Parm->

()) : nullptr;

DefaultArgNo =

Name += llvm::utostr(DefaultArgNo);

(LambdaManglingNumber)

LambdaId = LambdaManglingNumber;

LambdaId = getLambdaIdForDebugInfo(Lambda);

Name += llvm::utostr(LambdaId);

assert(RD->

() &&

);

);

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

>

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

Result.first->second;

assert(RD->

() &&

);

);

LambdaIds.lookup(RD);

StringRef getAnonymousNamespaceHash()

{

AnonymousNamespaceHash;

mangleInitFiniStub(

*

,

CharCode, raw_ostream &Out);

MicrosoftCXXNameMangler {

MicrosoftMangleContextImpl &Context;

StructorType;

BackRefVec NameBackReferences;

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

ArgBackRefMap FunArgBackReferences;

ArgBackRefMap TemplateArgBackReferences;

llvm::DenseMap<const void *, StringRef> TemplateArgStringMap;

TemplateArgStringMap TemplateArgStrings;

llvm::BumpPtrAllocator TemplateArgStringStorageAlloc;

llvm::StringSaver TemplateArgStringStorage;

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

PassObjectSizeArgsSet PassObjectSizeArgs;

&getASTContext()

{

Context.getASTContext(); }

PointersAre64Bit;

QualifierMangleMode { QMM_Drop, QMM_Mangle, QMM_Escape, QMM_Result };

TplArgKind { ClassNTTP, StructuralValue };

MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &

, raw_ostream &Out_)

: Context(

), Out(Out_), Structor(nullptr), StructorType(-1),

TemplateArgStringStorage(TemplateArgStringStorageAlloc),

PointersAre64Bit(

.getASTContext().getTargetInfo().getPointerWidth(

MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &

, raw_ostream &Out_,

: Context(

), Out(Out_), Structor(getStructor(

)), StructorType(

),

TemplateArgStringStorage(TemplateArgStringStorageAlloc),

PointersAre64Bit(

.getASTContext().getTargetInfo().getPointerWidth(

MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &

, raw_ostream &Out_,

: Context(

), Out(Out_), Structor(getStructor(

)), StructorType(

),

TemplateArgStringStorage(TemplateArgStringStorageAlloc),

PointersAre64Bit(

.getASTContext().getTargetInfo().getPointerWidth(

raw_ostream &getStream()

{

Out; }

mangle(

GD, StringRef Prefix =

);

mangleFunctionEncoding(

GD,

ShouldMangle);

mangleVariableEncoding(

*VD);

StringRef Prefix =

);

mangleMemberDataPointerInClassNTTP(

*,

StringRef Prefix =

);

mangleMemberFunctionPointerInClassNTTP(

*RD,

mangleNumber(int64_t Number);

mangleNumber(llvm::APSInt Number);

mangleFloat(llvm::APFloat Number);

mangleBits(llvm::APInt Number);

mangleArtificialTagType(

TK, StringRef UnqualifiedName,

QualifierMangleMode QMM = QMM_Mangle);

ForceThisQuals =

,

MangleExceptionSpec =

);

mangleSourceName(StringRef Name);

mangleAutoReturnType(

, QualifierMangleMode QMM);

isStructorDecl(

*ND)

{

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

is64BitPointer(

Quals)

{

AddrSpace == LangAS::ptr64 ||

(PointersAre64Bit && !(AddrSpace == LangAS::ptr32_sptr ||

AddrSpace == LangAS::ptr32_uptr));

mangleUnqualifiedName(GD, cast<NamedDecl>(GD.

())->getDeclName());

mangleQualifiers(

Quals,

IsMember);

manglePointerCVQualifiers(

Quals);

mangleUnscopedTemplateName(

GD);

mangleTemplateInstantiationName(

GD,

manglePassObjectSizeArg(

PassObjectSizeAttr *POSA);

isArtificialTagType(

)

;

mangleType(

*TD);

mangleDecayedArrayType(

*

);

mangleIntegerLiteral(

llvm::APSInt &Number,

WithScalarType =

);

MicrosoftMangleContextImpl::MicrosoftMangleContextImpl(

&Context,

AnonymousNamespaceHash = llvm::utohexstr(TruncatedHash);

AnonymousNamespaceHash =

;

MicrosoftMangleContextImpl::shouldMangleCXXName(

*

) {

(FD->hasAttr<OverloadableAttr>())

(FD->isMSVCRTEntryPoint())

(!getASTContext().getLangOpts().

)

*VD = dyn_cast<VarDecl>(

);

(VD && !isa<DecompositionDecl>(

)) {

DC = getEffectiveParentContext(DC);

!isa<VarTemplateSpecializationDecl>(

) &&

->getIdentifier() !=

)

MicrosoftMangleContextImpl::shouldMangleStringLiteral(

*SL) {

);

Diags.

(loc, DiagID) << thing1 << thing2;

);

Diags.

(loc, DiagID) << thingy;

);

Diags.

(DiagID) << thingy;

MicrosoftCXXNameMangler::mangle(

GD, StringRef Prefix) {

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

(

*VD = dyn_cast<VarDecl>(

))

mangleVariableEncoding(VD);

(isa<MSGuidDecl>(

))

Out <<

;

(isa<TemplateParamObjectDecl>(

)) {

llvm_unreachable(

);

MicrosoftCXXNameMangler::mangleFunctionEncoding(

GD,

mangleFunctionClass(FD);

mangleFunctionType(FT, FD,

,

);

MicrosoftCXXNameMangler::mangleVariableEncoding(

*VD) {

mangleType(Ty, SR, QMM_Drop);

manglePointerExtQualifiers(

mangleQualifiers(MPT->getPointeeType().getQualifiers(),

);

mangleName(MPT->getClass()->getAsCXXRecordDecl());

}

(

*AT = getASTContext().getAsArrayType(Ty)) {

mangleDecayedArrayType(AT);

(AT->getElementType()->isArrayType())

mangleType(Ty, SR, QMM_Drop);

MicrosoftCXXNameMangler::mangleMemberDataPointer(

FieldOffset = getASTContext().getFieldOffset(VD);

assert(FieldOffset % getASTContext().

() == 0 &&

);

FieldOffset /= getASTContext().getCharWidth();

(IM == MSInheritanceModel::Virtual)

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

MSInheritanceModel::Single: Code =

;

;

MSInheritanceModel::Multiple: Code =

;

;

MSInheritanceModel::Virtual: Code =

;

;

MSInheritanceModel::Unspecified: Code =

;

;

getASTContext().getLangOpts().isCompatibleWithMSVC(

LangOptions::MSVC2019) &&

!TemplateArgType.

()) {

mangleType(TemplateArgType,

(), QMM_Drop);

mangleNumber(FieldOffset);

mangleNumber(VBTableOffset);

MicrosoftCXXNameMangler::mangleMemberDataPointerInClassNTTP(

(IM != MSInheritanceModel::Single && IM != MSInheritanceModel::Multiple)

mangleMemberDataPointer(RD, VD,

,

(),

);

mangleNestedName(VD);

mangleUnqualifiedName(VD);

MicrosoftCXXNameMangler::mangleMemberFunctionPointer(

MSInheritanceModel::Single: Code =

;

;

MSInheritanceModel::Multiple: Code =

;

;

MSInheritanceModel::Virtual: Code =

;

;

MSInheritanceModel::Unspecified: Code =

;

;

(getASTContext().getLangOpts().isCompatibleWithMSVC(

LangOptions::MSVC2019) &&

!TemplateArgType.

()) {

mangleType(TemplateArgType,

(), QMM_Drop);

cast<MicrosoftVTableContext>(getASTContext().getVTableContext());

mangleVirtualMemPtrThunk(MD, ML);

&Layout = getASTContext().getASTRecordLayout(RD);

mangleFunctionEncoding(MD,

);

(VBTableOffset == 0 && IM == MSInheritanceModel::Virtual)

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

(IM == MSInheritanceModel::Single) {

Out << Prefix <<

;

(IM == MSInheritanceModel::Unspecified)

Out << Prefix << Code;

mangleNumber(

(NVOffset));

mangleNumber(VBPtrOffset);

mangleNumber(VBTableOffset);

MicrosoftCXXNameMangler::mangleFunctionPointer(

(getASTContext().getLangOpts().isCompatibleWithMSVC(

LangOptions::MSVC2019) &&

!TemplateArgType.

()) {

mangleType(TemplateArgType,

(), QMM_Drop);

mangleFunctionEncoding(FD,

);

MicrosoftCXXNameMangler::mangleVarDecl(

*VD,

(getASTContext().getLangOpts().isCompatibleWithMSVC(

LangOptions::MSVC2019) &&

!TemplateArgType.

()) {

mangleType(TemplateArgType,

(), QMM_Drop);

mangleVariableEncoding(VD);

MicrosoftCXXNameMangler::mangleMemberFunctionPointerInClassNTTP(

mangleMemberFunctionPointer(RD, MD,

,

(),

);

cast<MicrosoftVTableContext>(getASTContext().getVTableContext());

mangleVirtualMemPtrThunk(MD, ML);

mangleFunctionEncoding(MD,

);

MicrosoftCXXNameMangler::mangleVirtualMemPtrThunk(

PointerWidth = getASTContext().toCharUnitsFromBits(

getASTContext().getTargetInfo().getPointerWidth(LangAS::Default));

mangleNumber(OffsetInVFTable);

MicrosoftCXXNameMangler::mangleName(

GD) {

mangleUnqualifiedName(GD);

mangleNestedName(GD);

MicrosoftCXXNameMangler::mangleNumber(int64_t Number) {

mangleNumber(llvm::APSInt(llvm::APInt(64, Number),

));

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

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

llvm::APInt

= Number.extend(Width);

(

.isNegative()) {

mangleBits(

);

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

llvm::APFloat;

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

APFloat::S_IEEEsingle: Out <<

;

;

APFloat::S_IEEEdouble: Out <<

;

;

APFloat::S_IEEEhalf: Out <<

;

;

APFloat::S_BFloat: Out <<

;

;

APFloat::S_x87DoubleExtended: Out <<

;

;

APFloat::S_IEEEquad: Out <<

;

;

APFloat::S_PPCDoubleDouble: Out <<

;

;

APFloat::S_PPCDoubleDoubleLegacy:

APFloat::S_Float8E5M2:

APFloat::S_Float8E4M3:

APFloat::S_Float8E4M3FN:

APFloat::S_Float8E5M2FNUZ:

APFloat::S_Float8E4M3FNUZ:

APFloat::S_Float8E4M3B11FNUZ:

APFloat::S_Float8E3M4:

APFloat::S_FloatTF32:

APFloat::S_Float8E8M0FNU:

APFloat::S_Float6E3M2FN:

APFloat::S_Float6E2M3FN:

APFloat::S_Float4E2M1FN:

llvm_unreachable(

);

mangleBits(Number.bitcastToAPInt());

MicrosoftCXXNameMangler::mangleBits(llvm::APInt

) {

Out << (

- 1);

EncodedNumberBuffer.push_back(

+ (

& 0xf).getZExtValue());

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

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

(

*FD = dyn_cast<FunctionDecl>(ND)) {

dyn_cast<ClassTemplateSpecializationDecl>(ND)) {

TemplateArgs = &Spec->getTemplateArgs();

GD.

(Spec->getSpecializedTemplate());

dyn_cast<VarTemplateSpecializationDecl>(ND)) {

TemplateArgs = &Spec->getTemplateArgs();

GD.

(Spec->getSpecializedTemplate());

MicrosoftCXXNameMangler::mangleUnqualifiedName(

GD,

(isa<FunctionTemplateDecl>(TD.getDecl())) {

mangleTemplateInstantiationName(TD, *TemplateArgs);

ArgBackRefMap::iterator

= TemplateArgBackReferences.find(ND);

(

== TemplateArgBackReferences.end()) {

TemplateArgStringMap::iterator

= TemplateArgStrings.find(ND);

(

== TemplateArgStrings.end()) {

llvm::raw_svector_ostream Stream(TemplateMangling);

MicrosoftCXXNameMangler Extra(Context, Stream);

Extra.mangleTemplateInstantiationName(TD, *TemplateArgs);

mangleSourceName(TemplateMangling);

BackRefVec::iterator StringFound =

llvm::find(NameBackReferences, TemplateMangling);

(StringFound != NameBackReferences.end()) {

TemplateArgBackReferences[ND] =

StringFound - NameBackReferences.begin();

TemplateArgStrings[ND] =

TemplateArgStringStorage.save(TemplateMangling.str());

Out <<

->second <<

;

Out <<

->second;

(Name.getNameKind()) {

((isa<FunctionDecl>(ND) && ND->

<CUDAGlobalAttr>()) ||

(isa<FunctionTemplateDecl>(ND) &&

cast<FunctionTemplateDecl>(ND)

->getTemplatedDecl()

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

(llvm::Twine(

) + II->getName()).str());

mangleSourceName(II->getName());

assert(ND &&

);

(

*NS = dyn_cast<NamespaceDecl>(ND)) {

(NS->isAnonymousNamespace()) {

Out <<

<< Context.getAnonymousNamespaceHash() <<

;

Name += llvm::utostr(Context.getAnonymousStructId(DD) + 1);

mangleSourceName(Name);

(

*VD = dyn_cast<VarDecl>(ND)) {

assert(RD &&

);

Name += llvm::utostr(Context.getAnonymousStructId(RD) + 1);

mangleSourceName(Name.str());

(

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

<

(

)> GUID;

llvm::raw_svector_ostream GUIDOS(GUID);

Context.mangleMSGuidDecl(GD, GUIDOS);

mangleSourceName(GUID);

(

*TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {

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

TPO->getValue(), TplArgKind::ClassNTTP);

*TD = cast<TagDecl>(ND);

);

assert(

->getDeclName().getAsIdentifierInfo() &&

);

mangleSourceName(

->getDeclName().getAsIdentifierInfo()->getName());

(

->isLambda()) {

*LambdaContextDecl =

->getLambdaContextDecl();

LambdaManglingNumber =

->getLambdaManglingNumber();

dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);

Parm ? dyn_cast<FunctionDecl>(Parm->

()) : nullptr;

DefaultArgNo =

Name += llvm::utostr(DefaultArgNo);

(LambdaManglingNumber)

LambdaId = LambdaManglingNumber;

LambdaId = Context.getLambdaId(

);

Name += llvm::utostr(LambdaId);

mangleSourceName(Name);

(LambdaManglingNumber && LambdaContextDecl) {

((isa<VarDecl>(LambdaContextDecl) ||

isa<FieldDecl>(LambdaContextDecl)) &&

!isa<ParmVarDecl>(LambdaContextDecl)) {

mangleUnqualifiedName(cast<NamedDecl>(LambdaContextDecl));

Name +=

;

Name += DD->getName();

Name +=

;

Name += TND->getName();

}

(isa<EnumDecl>(TD) &&

cast<EnumDecl>(TD)->enumerator_begin() !=

cast<EnumDecl>(TD)->enumerator_end()) {

*ED = cast<EnumDecl>(TD);

Name +=

;

Name += ED->enumerator_begin()->getName();

Name +=

;

Name += llvm::utostr(Context.getAnonymousStructId(TD) + 1);

mangleSourceName(Name.str());

mangleSourceName(Name.str());

(isStructorDecl(ND)) {

(isStructorDecl(ND))

mangleCXXDtorType(

(StructorType));

mangleOperatorName(Name.getCXXOverloadedOperator(), ND->

());

mangleSourceName(Name.getCXXLiteralIdentifier()->getName());

llvm_unreachable(

);

llvm_unreachable(

);

MicrosoftCXXNameMangler::mangleNestedName(

GD) {

(

*ID = dyn_cast<IndirectFieldDecl>(ND))

(

I = 1, IE =

->getChainingSize(); I < IE; ++I)

mangleSourceName(

);

*DC = getEffectiveDeclContext(ND);

(isa<TagDecl>(ND) || isa<VarDecl>(ND)) {

(Context.getNextDiscriminator(ND, Disc)) {

(

*BD = dyn_cast<BlockDecl>(DC)) {

[](StringRef Name,

Discriminator,

ParameterDiscriminator) -> std::string {

llvm::raw_string_ostream Stream(Buffer);

Stream <<

<< Discriminator;

(ParameterDiscriminator)

Stream <<

<< ParameterDiscriminator;

Discriminator = BD->getBlockManglingNumber();

Discriminator = Context.getBlockId(BD,

);

ParameterDiscriminator = 0;

(

*MC = BD->getBlockManglingContextDecl())

(

*

= dyn_cast<ParmVarDecl>(MC))

(

*F = dyn_cast<FunctionDecl>(

->getDeclContext()))

ParameterDiscriminator =

F->getNumParams() -

->getFunctionScopeIndex();

DC = getEffectiveDeclContext(BD);

mangleSourceName(Discriminate(

, Discriminator,

ParameterDiscriminator));

(

*MC = BD->getBlockManglingContextDecl())

(!isa<ParmVarDecl>(MC))

(

*ND = dyn_cast<NamedDecl>(MC))

mangleUnqualifiedName(ND);

(

*RD = dyn_cast<RecordDecl>(DC))

(PointersAre64Bit)

mangleArtificialTagType(TagTypeKind::Struct,

Discriminate(

, Discriminator,

ParameterDiscriminator));

(isa<RecordDecl>(DC))

}

(

*Method = dyn_cast<ObjCMethodDecl>(DC)) {

mangleObjCMethodName(Method);

}

(isa<NamedDecl>(DC)) {

ND = cast<NamedDecl>(DC);

(

*FD = dyn_cast<FunctionDecl>(ND)) {

mangle(getGlobalDeclAsDeclContext(FD),

);

mangleUnqualifiedName(ND);

(

*LDADC = getLambdaDefaultArgumentDeclContext(ND)) {

MicrosoftCXXNameMangler::mangleCXXDtorType(

) {

llvm_unreachable(

);

llvm_unreachable(

);

OO_New: Out <<

;

;

OO_Delete: Out <<

;

;

OO_Equal: Out <<

;

;

OO_GreaterGreater: Out <<

;

;

OO_LessLess: Out <<

;

;

OO_Exclaim: Out <<

;

;

OO_EqualEqual: Out <<

;

;

OO_ExclaimEqual: Out <<

;

;

OO_Subscript: Out <<

;

;

OO_Arrow: Out <<

;

;

OO_Star: Out <<

;

;

OO_PlusPlus: Out <<

;

;

OO_MinusMinus: Out <<

;

;

OO_Minus: Out <<

;

;

OO_Plus: Out <<

;

;

OO_Amp: Out <<

;

;

OO_ArrowStar: Out <<

;

;

OO_Slash: Out <<

;

;

OO_Percent: Out <<

;

;

OO_Less: Out <<

;

;

OO_LessEqual: Out <<

;

;

OO_Greater: Out <<

;

;

OO_GreaterEqual: Out <<

;

;

OO_Comma: Out <<

;

;

OO_Call: Out <<

;

;

OO_Tilde: Out <<

;

;

OO_Caret: Out <<

;

;

OO_Pipe: Out <<

;

;

OO_AmpAmp: Out <<

;

;

OO_PipePipe: Out <<

;

;

OO_StarEqual: Out <<

;

;

OO_PlusEqual: Out <<

;

;

OO_MinusEqual: Out <<

;

;

OO_SlashEqual: Out <<

;

;

OO_PercentEqual: Out <<

;

;

OO_GreaterGreaterEqual: Out <<

;

;

OO_LessLessEqual: Out <<

;

;

OO_AmpEqual: Out <<

;

;

OO_PipeEqual: Out <<

;

;

OO_CaretEqual: Out <<

;

;

OO_Array_New: Out <<

;

;

OO_Array_Delete: Out <<

;

;

OO_Coawait: Out <<

;

;

OO_Spaceship: Out <<

;

;

OO_Conditional: {

(

,

);

llvm_unreachable(

);

MicrosoftCXXNameMangler::mangleSourceName(StringRef Name) {

BackRefVec::iterator

= llvm::find(NameBackReferences, Name);

(

== NameBackReferences.end()) {

(NameBackReferences.size() < 10)

NameBackReferences.push_back(std::string(Name));

Out << Name <<

;

Out << (

- NameBackReferences.begin());

MicrosoftCXXNameMangler::mangleObjCMethodName(

*MD) {

Context.mangleObjCMethodNameAsSourceName(MD, Out);

MicrosoftCXXNameMangler::mangleTemplateInstantiationName(

ArgBackRefMap OuterFunArgsContext;

ArgBackRefMap OuterTemplateArgsContext;

BackRefVec OuterTemplateContext;

PassObjectSizeArgsSet OuterPassObjectSizeArgs;

NameBackReferences.swap(OuterTemplateContext);

FunArgBackReferences.swap(OuterFunArgsContext);

TemplateArgBackReferences.swap(OuterTemplateArgsContext);

PassObjectSizeArgs.swap(OuterPassObjectSizeArgs);

mangleUnscopedTemplateName(GD);

mangleTemplateArgs(cast<TemplateDecl>(GD.

()), TemplateArgs);

NameBackReferences.swap(OuterTemplateContext);

FunArgBackReferences.swap(OuterFunArgsContext);

TemplateArgBackReferences.swap(OuterTemplateArgsContext);

PassObjectSizeArgs.swap(OuterPassObjectSizeArgs);

MicrosoftCXXNameMangler::mangleUnscopedTemplateName(

GD) {

mangleUnqualifiedName(GD);

MicrosoftCXXNameMangler::mangleIntegerLiteral(

(getASTContext().getLangOpts().isCompatibleWithMSVC(

LangOptions::MSVC2019) &&

!TemplateArgType.

()) {

mangleType(TemplateArgType,

(), QMM_Drop);

mangleNumber(

);

MicrosoftCXXNameMangler::mangleExpression(

(std::optional<llvm::APSInt>

=

MicrosoftCXXNameMangler::mangleTemplateArgs(

assert(TPL->

() == TemplateArgs.

() &&

);

(

i = 0; i < TemplateArgs.

(); ++i) {

mangleTemplateArg(TD, TA, TPL->

(i));

!

.getLValueBase())

BaseT =

.getLValueBase().getType();

(!BaseT->

() ||

.getLValuePath().size() != 1 ||

.getLValuePath()[0].getAsArrayIndex() != 0)

.getLValueBase().dyn_cast<

*>());

MicrosoftCXXNameMangler::mangleTemplateArg(

*TD,

llvm_unreachable(

);

llvm_unreachable(

);

(isa<FieldDecl>(ND) || isa<IndirectFieldDecl>(ND)) {

mangleMemberDataPointer(cast<CXXRecordDecl>(ND->

())

->getMostRecentNonInjectedDecl(),

cast<ValueDecl>(ND),

cast<NonTypeTemplateParmDecl>(Parm),

}

(

*FD = dyn_cast<FunctionDecl>(ND)) {

mangleMemberFunctionPointer(

mangleFunctionPointer(FD, cast<NonTypeTemplateParmDecl>(Parm),

*TPO = cast<TemplateParamObjectDecl>(ND);

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

TPO->getValue(), TplArgKind::ClassNTTP);

}

(

*VD = dyn_cast<VarDecl>(ND)) {

mangleVarDecl(VD, cast<NonTypeTemplateParmDecl>(Parm),

cast<NonTypeTemplateParmDecl>(Parm),

);

*RD = MPT->getMostRecentCXXRecordDecl();

(MPT->isMemberFunctionPointerType() &&

!isa<FunctionTemplateDecl>(TD)) {

mangleMemberFunctionPointer(RD,

,

,

());

(MPT->isMemberDataPointer()) {

(!isa<FunctionTemplateDecl>(TD)) {

mangleMemberDataPointer(RD,

,

,

());

mangleIntegerLiteral(llvm::APSInt::get(-1),

cast<NonTypeTemplateParmDecl>(Parm),

);

mangleIntegerLiteral(llvm::APSInt::getUnsigned(0),

cast<NonTypeTemplateParmDecl>(Parm),

);

mangleTemplateArg(

(cast<NonTypeTemplateParmDecl>(Parm)

->getContainedDeducedType()) {

TplArgKind::StructuralValue,

mangleExpression(TA.

(), cast<NonTypeTemplateParmDecl>(Parm));

(TemplateArgs.empty()) {

(isa<TemplateTypeParmDecl>(Parm) ||

isa<TemplateTemplateParmDecl>(Parm))

LangOptions::MSVC2015)

(isa<NonTypeTemplateParmDecl>(Parm))

llvm_unreachable(

);

mangleTemplateArg(TD, PA, Parm);

(

*TD = dyn_cast<TagDecl>(ND)) {

}

(isa<TypeAliasDecl>(ND)) {

llvm_unreachable(

);

MicrosoftCXXNameMangler::mangleTemplateArgValue(

,

WithScalarType) {

(

.getKind()) {

mangleNumber(

.getInt());

mangleFloat(

.getFloat());

(

.isLValueOnePastTheEnd()) {

(!

.hasLValuePath() ||

.getLValuePath().empty()) {

(

.isNull()) {

mangleNumber(

.getLValueOffset().getQuantity());

}

(!

.hasLValuePath()) {

(

);

}

(

*VD =

.dyn_cast<

*>()) {

(

);

<std::function<void()>, 2> EntryManglers;

EntryTypes.push_back(

);

EntryManglers.push_back([

, I =

.getAsArrayIndex()] {

ET = AT->getElementType();

*

=

.getAsBaseOrMember().getPointer();

(

*FD = dyn_cast<FieldDecl>(

)) {

ET = getASTContext().getRecordType(cast<CXXRecordDecl>(

));

EntryTypes.push_back(

);

EntryManglers.push_back([

,

] {

mangleUnqualifiedName(cast<NamedDecl>(

));

(

I = EntryTypes.rbegin(),

= EntryTypes.rend(); I !=

; ++I)

(

);

Out << (TAK == TplArgKind::ClassNTTP ?

:

);

(

std::function<

()> &Mangler : EntryManglers)

(TAK == TplArgKind::ClassNTTP) {

mangleMemberDataPointerInClassNTTP(RD,

);

mangleMemberFunctionPointerInClassNTTP(RD,

cast_or_null<CXXMethodDecl>(

));

mangleMemberDataPointer(RD,

,

,

(),

);

mangleMemberFunctionPointer(RD, cast_or_null<CXXMethodDecl>(

),

,

assert(RD &&

);

BaseIndex = 0;

mangleTemplateArgValue(B.getType(),

.getStructBase(BaseIndex++), TAK);

(!FD->isUnnamedBitField())

mangleTemplateArgValue(FD->

(),

.getStructField(FD->getFieldIndex()), TAK,

(

*FD =

.getUnionField()) {

mangleUnqualifiedName(FD);

mangleTemplateArgValue(FD->

(),

.getUnionValue(), TAK);

mangleNumber(

.getComplexIntReal());

mangleNumber(

.getComplexIntImag());

mangleFloat(

.getComplexFloatReal());

mangleFloat(

.getComplexFloatImag());

ElemT = getASTContext().getAsArrayType(

)->getElementType();

(

I = 0, N =

.getArraySize(); I != N; ++I) {

&ElemV = I <

.getArrayInitializedElts()

?

.getArrayInitializedElt(I)

:

.getArrayFiller();

mangleTemplateArgValue(ElemT, ElemV, TAK);

(

I = 0, N =

.getVectorLength(); I != N; ++I) {

&ElemV =

.getVectorElt(I);

mangleTemplateArgValue(ElemT, ElemV, TAK);

(

);

(

);

MicrosoftCXXNameMangler::mangleObjCProtocol(

*PD) {

llvm::raw_svector_ostream Stream(TemplateMangling);

MicrosoftCXXNameMangler Extra(Context, Stream);

Extra.mangleSourceName(

);

Extra.mangleArtificialTagType(TagTypeKind::Struct, PD->

());

mangleArtificialTagType(TagTypeKind::Struct, TemplateMangling, {

});

MicrosoftCXXNameMangler::mangleObjCLifetime(

,

llvm::raw_svector_ostream Stream(TemplateMangling);

MicrosoftCXXNameMangler Extra(Context, Stream);

Extra.mangleSourceName(

);

Extra.mangleSourceName(

);

Extra.mangleSourceName(

);

Extra.manglePointerCVQualifiers(Quals);

Extra.manglePointerExtQualifiers(Quals,

);

mangleArtificialTagType(TagTypeKind::Struct, TemplateMangling, {

});

MicrosoftCXXNameMangler::mangleObjCKindOfType(

*

,

llvm::raw_svector_ostream Stream(TemplateMangling);

MicrosoftCXXNameMangler Extra(Context, Stream);

Extra.mangleSourceName(

);

.stripObjCKindOfType(getASTContext())

->castAs<ObjCObjectType>(),

mangleArtificialTagType(TagTypeKind::Struct, TemplateMangling, {

});

MicrosoftCXXNameMangler::mangleQualifiers(

Quals,

HasConst = Quals.

(),

(HasConst && HasVolatile) {

}

(HasVolatile) {

}

(HasConst) {

(HasConst && HasVolatile) {

}

(HasVolatile) {

}

(HasConst) {

MicrosoftCXXNameMangler::mangleRefQualifier(

RefQualifier) {

(RefQualifier) {

MicrosoftCXXNameMangler::manglePointerExtQualifiers(

Quals,

is64Bit = PointeeType.

() ? PointersAre64Bit :

MicrosoftCXXNameMangler::manglePointerCVQualifiers(

Quals) {

HasConst = Quals.

(),

(HasConst && HasVolatile) {

}

(HasVolatile) {

}

(HasConst) {

MicrosoftCXXNameMangler::mangleFunctionArgumentType(

,

OriginalType = DT->getOriginalType();

(

*AT = getASTContext().getAsArrayType(OriginalType))

OriginalType = getASTContext().getIncompleteArrayType(

AT->getElementType(), AT->getSizeModifier(),

AT->getIndexTypeCVRQualifiers());

TypePtr =

.getCanonicalType().getAsOpaquePtr();

ArgBackRefMap::iterator

= FunArgBackReferences.find(TypePtr);

(

== FunArgBackReferences.end()) {

OutSizeBefore = Out.tell();

mangleType(

,

, QMM_Drop);

LongerThanOneChar = (Out.tell() - OutSizeBefore > 1);

(LongerThanOneChar && FunArgBackReferences.size() < 10) {

= FunArgBackReferences.size();

FunArgBackReferences[TypePtr] =

;

Out <<

->second;

MicrosoftCXXNameMangler::manglePassObjectSizeArg(

PassObjectSizeAttr *POSA) {

= POSA->getType();

= POSA->isDynamic();

*TypePtr = (

*)&*

;

ArgBackRefMap::iterator

= FunArgBackReferences.find(TypePtr);

(

== FunArgBackReferences.end()) {

?

:

;

mangleArtificialTagType(TagTypeKind::Enum, Name + llvm::utostr(

),

(FunArgBackReferences.size() < 10) {

= FunArgBackReferences.size();

FunArgBackReferences[TypePtr] =

;

Out <<

->second;

MicrosoftCXXNameMangler::mangleAddressSpaceType(

,

assert(Quals.

() &&

);

llvm::raw_svector_ostream Stream(ASMangling);

MicrosoftCXXNameMangler Extra(Context, Stream);

Extra.mangleSourceName(

);

Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(TargetAS));

llvm_unreachable(

);

LangAS::opencl_global:

Extra.mangleSourceName(

);

LangAS::opencl_global_device:

Extra.mangleSourceName(

);

LangAS::opencl_global_host:

Extra.mangleSourceName(

);

LangAS::opencl_local:

Extra.mangleSourceName(

);

LangAS::opencl_constant:

Extra.mangleSourceName(

);

LangAS::opencl_private:

Extra.mangleSourceName(

);

LangAS::opencl_generic:

Extra.mangleSourceName(

);

LangAS::cuda_device:

Extra.mangleSourceName(

);

LangAS::cuda_constant:

Extra.mangleSourceName(

);

LangAS::cuda_shared:

Extra.mangleSourceName(

);

LangAS::ptr32_sptr:

LangAS::ptr32_uptr:

llvm_unreachable(

);

Extra.mangleType(

,

, QMM_Escape);

mangleArtificialTagType(TagTypeKind::Struct, ASMangling, {

});

MicrosoftCXXNameMangler::mangleAutoReturnType(

,

QualifierMangleMode QMM) {

assert(getASTContext().getLangOpts().isCompatibleWithMSVC(

LangOptions::MSVC2019) &&

);

(isa<AutoType>(

)) {

(QMM == QMM_Result)

(QMM != QMM_Drop)

mangleQualifiers(Quals,

);

Out << (AT->isDecltypeAuto() ?

:

);

=

.getDesugaredType(getASTContext());

mangleQualifiers(Quals,

);

llvm_unreachable(

);

*ty =

.getTypePtr();

Type::MemberPointer:

mangleAutoReturnType(cast<MemberPointerType>(ty), Quals);

mangleAutoReturnType(cast<PointerType>(ty), Quals);

Type::LValueReference:

mangleAutoReturnType(cast<LValueReferenceType>(ty), Quals);

Type::RValueReference:

mangleAutoReturnType(cast<RValueReferenceType>(ty), Quals);

llvm_unreachable(

);

QualifierMangleMode QMM) {

=

.getDesugaredType(getASTContext());

(

*AT = getASTContext().getAsArrayType(

)) {

(QMM == QMM_Mangle)

(QMM == QMM_Escape || QMM == QMM_Result)

mangleArrayType(AT);

(

*FT = dyn_cast<FunctionType>(

)) {

mangleFunctionType(FT);

mangleQualifiers(Quals,

);

(!IsPointer && Quals) {

mangleQualifiers(Quals,

);

((!IsPointer && Quals) || isa<TagType>(

) || isArtificialTagType(

)) {

mangleQualifiers(Quals,

);

*ty =

.getTypePtr();

#CLASS "Type"); \

(

->getKind()) {

BuiltinType::Void:

BuiltinType::SChar:

BuiltinType::Char_U:

BuiltinType::Char_S:

BuiltinType::UChar:

BuiltinType::Short:

BuiltinType::UShort:

BuiltinType::Int:

BuiltinType::UInt:

BuiltinType::Long:

BuiltinType::ULong:

BuiltinType::Float:

BuiltinType::Double:

BuiltinType::LongDouble:

BuiltinType::LongLong:

BuiltinType::ULongLong:

BuiltinType::Int128:

BuiltinType::UInt128:

BuiltinType::Bool:

BuiltinType::Char8:

BuiltinType::Char16:

BuiltinType::Char32:

BuiltinType::WChar_S:

BuiltinType::WChar_U:

BuiltinType::Dependent:

llvm_unreachable(

);

BuiltinType::ObjCId:

mangleArtificialTagType(TagTypeKind::Struct,

);

BuiltinType::ObjCClass:

mangleArtificialTagType(TagTypeKind::Struct,

);

BuiltinType::ObjCSel:

mangleArtificialTagType(TagTypeKind::Struct,

);

#ImgType "_" #Suffix "@@"; \

BuiltinType::OCLSampler:

mangleArtificialTagType(TagTypeKind::Struct,

);

BuiltinType::OCLEvent:

mangleArtificialTagType(TagTypeKind::Struct,

);

BuiltinType::OCLClkEvent:

mangleArtificialTagType(TagTypeKind::Struct,

);

BuiltinType::OCLQueue:

mangleArtificialTagType(TagTypeKind::Struct,

);

BuiltinType::OCLReserveID:

mangleArtificialTagType(TagTypeKind::Struct,

);

#ExtType); \

BuiltinType::NullPtr:

BuiltinType::Float16:

mangleArtificialTagType(TagTypeKind::Struct,

, {

});

BuiltinType::Half:

(!getASTContext().getLangOpts().

)

mangleArtificialTagType(TagTypeKind::Struct,

, {

});

(getASTContext().getLangOpts().NativeHalfType)

BuiltinType::BFloat16:

mangleArtificialTagType(TagTypeKind::Struct,

, {

});

BuiltinType::MFloat8:

mangleArtificialTagType(TagTypeKind::Struct,

, {

});

}); \

mangleFunctionType(

,

,

);

mangleFunctionType(

);

mangleFunctionType(

);

MicrosoftCXXNameMangler::mangleFunctionType(

*

,

ForceThisQuals,

MangleExceptionSpec) {

IsInLambda =

;

IsStructor =

, HasThisQuals = ForceThisQuals, IsCtorClosure =

;

(

*MD = dyn_cast_or_null<CXXMethodDecl>(

)) {

HasThisQuals =

;

(isa<CXXDestructorDecl>(MD)) {

}

(isa<CXXConstructorDecl>(MD)) {

CC = getASTContext().getDefaultCallingConvention(

manglePointerExtQualifiers(Quals,

());

mangleQualifiers(Quals,

);

mangleCallingConvention(CC,

);

(isa<CXXDestructorDecl>(

) && isStructorDecl(

)) {

Out << (PointersAre64Bit ?

:

);

(IsCtorClosure) {

mangleFunctionArgumentType(getASTContext().getLValueReferenceType(

llvm_unreachable(

);

}

(IsInLambda && isa_and_nonnull<CXXConversionDecl>(

)) {

(IsInLambda && isa<CXXConversionDecl>(

)) {

mangleType(ResultType,

, QMM_Result);

}

(IsInLambda) {

assert(AT->getKeyword() != AutoTypeKeyword::GNUAutoType &&

);

mangleSourceName(AT->isDecltypeAuto() ?

:

);

assert(AT->getKeyword() != AutoTypeKeyword::GNUAutoType &&

);

UseClangMangling = [](

ResultType) {

(isa<PointerType>(

.getTypePtr())) {

(

.getQualifiers().hasAddressSpace())

(getASTContext().getLangOpts().isCompatibleWithMSVC(

LangOptions::MSVC2019) &&

!UseClangMangling(ResultType)) {

(

&& !

->getPrimaryTemplate()) {

(

&&

->getPrimaryTemplate()) {

->getTemplatedDecl()

mangleAutoReturnType(ResultType, QMM_Result);

mangleSourceName(AT->isDecltypeAuto() ?

:

);

mangleType(ResultType,

, QMM_Result);

(

I = 0,

= Proto->

(); I !=

; ++I) {

(I == 0 &&

&&

->getParamDecl(I)->isExplicitObjectParameter())

(

*

=

->getParamDecl(I)->

<PassObjectSizeAttr>())

manglePassObjectSizeArg(

);

(MangleExceptionSpec && getASTContext().getLangOpts().

&&

getASTContext().getLangOpts().isCompatibleWithMSVC(

LangOptions::MSVC2017_5))

mangleThrowSpecification(Proto);

MicrosoftCXXNameMangler::mangleFunctionClass(

*FD) {

(

*MD = dyn_cast<CXXMethodDecl>(FD)) {

(isa<CXXDestructorDecl>(MD) && isStructorDecl(MD) &&

llvm_unreachable(

);

MicrosoftCXXNameMangler::mangleCallingConvention(

CC,

(getASTContext().getLangOpts().RegCall4)

MicrosoftCXXNameMangler::mangleCallingConvention(

*

,

MicrosoftCXXNameMangler::mangleThrowSpecification(

MicrosoftCXXNameMangler::mangleTagTypeKind(

TTK) {

TagTypeKind::Union:

TagTypeKind::Struct:

TagTypeKind::Interface:

TagTypeKind::Class:

TagTypeKind::Enum:

mangleType(cast<TagType>(

)->getDecl());

mangleType(cast<TagType>(

)->getDecl());

MicrosoftCXXNameMangler::mangleType(

*TD) {

MicrosoftCXXNameMangler::mangleArtificialTagType(

mangleTagTypeKind(TK);

mangleSourceName(UnqualifiedName);

(StringRef N : llvm::reverse(NestedNames))

mangleSourceName(N);

MicrosoftCXXNameMangler::mangleDecayedArrayType(

*

) {

manglePointerCVQualifiers(

->getElementType().getQualifiers());

llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

MicrosoftCXXNameMangler::mangleArrayType(

*

) {

(ElementTy->isConstantArrayType()) {

getASTContext().getAsConstantArrayType(ElementTy);

Dimensions.push_back(CAT->

());

}

(ElementTy->isIncompleteArrayType()) {

getASTContext().getAsIncompleteArrayType(ElementTy);

Dimensions.push_back(llvm::APInt(32, 0));

}

(ElementTy->isVariableArrayType()) {

getASTContext().getAsVariableArrayType(ElementTy);

Dimensions.push_back(llvm::APInt(32, 0));

}

(ElementTy->isDependentSizedArrayType()) {

getASTContext().getAsDependentSizedArrayType(ElementTy);

mangleNumber(Dimensions.size());

(

llvm::APInt &Dimension : Dimensions)

mangleNumber(Dimension.getLimitedValue());

mangleType(ElementTy,

(), QMM_Escape);

mangleArrayType(cast<ConstantArrayType>(

));

manglePointerCVQualifiers(Quals);

manglePointerExtQualifiers(Quals, PointeeType);

mangleFunctionType(FPT,

,

);

mangleType(PointeeType,

, QMM_Drop);

Name += llvm::utostr(

->getDepth());

Name += llvm::utostr(

->getIndex());

mangleSourceName(Name);

manglePointerCVQualifiers(Quals);

manglePointerExtQualifiers(Quals, PointeeType);

mangleType(PointeeType,

);

mangleObjCLifetime(PointeeType, Quals,

);

manglePointerCVQualifiers(Quals);

manglePointerExtQualifiers(Quals, PointeeType);

mangleType(PointeeType,

);

manglePointerExtQualifiers(Quals, PointeeType);

mangleType(PointeeType,

);

manglePointerExtQualifiers(Quals, PointeeType);

mangleType(PointeeType,

);

ElementType =

->getElementType();

llvm::raw_svector_ostream Stream(TemplateMangling);

MicrosoftCXXNameMangler Extra(Context, Stream);

Extra.mangleSourceName(

);

Extra.mangleType(ElementType,

, QMM_Escape);

mangleArtificialTagType(TagTypeKind::Struct, TemplateMangling, {

});

MicrosoftCXXNameMangler::isArtificialTagType(

)

{

*ty =

.getTypePtr();

Type::Vector: {

assert((ET || BitIntTy) &&

);

Width = getASTContext().getTypeSize(

);

OutSizeBefore = Out.tell();

(!isa<ExtVectorType>(

)) {

(getASTContext().getTargetInfo().getTriple().isX86() && ET) {

(Width == 64 && ET->

() == BuiltinType::LongLong) {

mangleArtificialTagType(TagTypeKind::Union,

);

}

(Width >= 128) {

(ET->

() == BuiltinType::Float)

mangleArtificialTagType(TagTypeKind::Union,

+ llvm::utostr(Width));

(ET->

() == BuiltinType::LongLong)

mangleArtificialTagType(TagTypeKind::Union,

+ llvm::utostr(Width) +

);

(ET->

() == BuiltinType::Double)

mangleArtificialTagType(TagTypeKind::Struct,

+ llvm::utostr(Width) +

);

IsBuiltin = Out.tell() != OutSizeBefore;

llvm::raw_svector_ostream Stream(TemplateMangling);

MicrosoftCXXNameMangler Extra(Context, Stream);

Extra.mangleSourceName(

);

Extra.mangleType(

(ET ?

*

(ET) : BitIntTy, 0),

, QMM_Escape);

Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(

->getNumElements()));

mangleArtificialTagType(TagTypeKind::Union, TemplateMangling, {

});

MicrosoftCXXNameMangler::mangleType(

*

,

mangleTagTypeKind(TagTypeKind::Struct);

mangleName(

->getDecl());

(

->isKindOfType())

mangleObjCKindOfType(

, Quals,

);

(

->qual_empty() && !

->isSpecialized())

mangleType(

->getBaseType(),

, QMM_Drop);

ArgBackRefMap OuterFunArgsContext;

ArgBackRefMap OuterTemplateArgsContext;

BackRefVec OuterTemplateContext;

FunArgBackReferences.swap(OuterFunArgsContext);

TemplateArgBackReferences.swap(OuterTemplateArgsContext);

NameBackReferences.swap(OuterTemplateContext);

mangleTagTypeKind(TagTypeKind::Struct);

(

->isObjCId())

mangleSourceName(

);

(

->isObjCClass())

mangleSourceName(

);

mangleSourceName(

->getInterface()->getName());

(

&Q :

->quals())

mangleObjCProtocol(Q);

(

->isSpecialized())

(

&TA :

->getTypeArgs())

mangleType(TA,

, QMM_Drop);

FunArgBackReferences.swap(OuterFunArgsContext);

TemplateArgBackReferences.swap(OuterTemplateArgsContext);

NameBackReferences.swap(OuterTemplateContext);

manglePointerCVQualifiers(Quals);

manglePointerExtQualifiers(Quals, PointeeType);

llvm_unreachable(

);

MicrosoftCXXNameMangler::mangleType(

manglePointerCVQualifiers(Quals);

mangleType(

->getSelectedType(),

);

assert(

->getDeducedType().isNull() &&

);

MicrosoftCXXNameMangler::mangleType(

assert(

->getDeducedType().isNull() &&

);

ValueType =

->getValueType();

llvm::raw_svector_ostream Stream(TemplateMangling);

MicrosoftCXXNameMangler Extra(Context, Stream);

Extra.mangleSourceName(

);

Extra.mangleType(ValueType,

, QMM_Escape);

mangleArtificialTagType(TagTypeKind::Struct, TemplateMangling, {

});

ElementType =

->getElementType();

llvm::raw_svector_ostream Stream(TemplateMangling);

MicrosoftCXXNameMangler Extra(Context, Stream);

Extra.mangleSourceName(

);

Extra.mangleType(ElementType,

, QMM_Escape);

Extra.mangleIntegerLiteral(llvm::APSInt::get(

->isReadOnly()));

mangleArtificialTagType(TagTypeKind::Struct, TemplateMangling, {

});

MicrosoftMangleContextImpl::mangleCXXName(

GD,

getASTContext().getSourceManager(),

);

msvc_hashing_ostream MHO(Out);

(

*CD = dyn_cast<CXXConstructorDecl>(

)) {

MicrosoftCXXNameMangler mangler(*

, MHO, CD,

);

mangler.mangle(GD);

(

*DD = dyn_cast<CXXDestructorDecl>(

)) {

MicrosoftCXXNameMangler mangler(*

, MHO, DD,

);

mangler.mangle(GD);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.mangle(GD);

llvm::raw_svector_ostream Stream(TemplateMangling);

MicrosoftCXXNameMangler Extra(Context, Stream);

(

->isUnsigned())

Extra.mangleSourceName(

);

Extra.mangleSourceName(

);

Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(

->getNumBits()));

mangleArtificialTagType(TagTypeKind::Struct, TemplateMangling, {

});

llvm_unreachable(

);

MicrosoftCXXNameMangler &Mangler,

llvm_unreachable(

);

Out <<

<< AccessSpec;

Mangler.mangleNumber(

Mangler.mangleNumber(

Mangler.mangleNumber(

Mangler.mangleNumber(

uint32_t

(Adjustment.

));

Mangler.mangleNumber(

Mangler.mangleNumber(-

uint32_t

(Adjustment.

));

llvm_unreachable(

);

Mangler.mangleNumber(-

uint32_t

(Adjustment.

));

llvm_unreachable(

);

MicrosoftMangleContextImpl::mangleVirtualMemPtrThunk(

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.mangleVirtualMemPtrThunk(MD, ML);

MicrosoftMangleContextImpl::mangleThunk(

*MD,

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.mangleName(MD);

assert(Thunk.

!=

&&

);

Mangler.mangleFunctionType(

MicrosoftMangleContextImpl::mangleCXXDtorThunk(

*DD,

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO, DD,

);

Mangler.getStream() <<

;

&Adjustment = Thunk.

;

MicrosoftMangleContextImpl::mangleCXXVFTable(

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

(Derived->

<DLLImportAttr>())

Mangler.getStream() <<

;

Mangler.getStream() <<

;

Mangler.mangleName(Derived);

Mangler.getStream() <<

;

Mangler.mangleName(RD);

Mangler.getStream() <<

;

MicrosoftMangleContextImpl::mangleCXXVTable(

*Derived,

mangleCXXVFTable(Derived, {}, Out);

MicrosoftMangleContextImpl::mangleCXXVBTable(

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.mangleName(Derived);

Mangler.getStream() <<

;

Mangler.mangleName(RD);

Mangler.getStream() <<

;

MicrosoftMangleContextImpl::mangleCXXRTTI(

, raw_ostream &Out) {

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.mangleType(

,

(), MicrosoftCXXNameMangler::QMM_Result);

Mangler.getStream() <<

;

MicrosoftMangleContextImpl::mangleCXXRTTIName(

, raw_ostream &Out,

NormalizeIntegers =

) {

MicrosoftCXXNameMangler Mangler(*

, Out);

Mangler.getStream() <<

;

Mangler.mangleType(

,

(), MicrosoftCXXNameMangler::QMM_Result);

MicrosoftMangleContextImpl::mangleCXXVirtualDisplacementMap(

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.mangleName(SrcRD);

Mangler.getStream() <<

;

Mangler.mangleName(DstRD);

MicrosoftMangleContextImpl::mangleCXXThrowInfo(

,

IsConst,

uint32_t NumEntries,

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.getStream() <<

;

Mangler.getStream() <<

;

Mangler.getStream() <<

;

Mangler.getStream() << NumEntries;

Mangler.mangleType(

,

(), MicrosoftCXXNameMangler::QMM_Result);

MicrosoftMangleContextImpl::mangleCXXCatchableTypeArray(

, uint32_t NumEntries, raw_ostream &Out) {

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.getStream() << NumEntries;

Mangler.mangleType(

,

(), MicrosoftCXXNameMangler::QMM_Result);

MicrosoftMangleContextImpl::mangleCXXCatchableType(

uint32_t NVOffset, int32_t VBPtrOffset, uint32_t VBIndex,

MicrosoftCXXNameMangler Mangler(*

, Out);

Mangler.getStream() <<

;

llvm::raw_svector_ostream Stream(RTTIMangling);

msvc_hashing_ostream MHO(Stream);

mangleCXXRTTI(

, MHO);

Mangler.getStream() << RTTIMangling;

OmitCopyCtor = getASTContext().getLangOpts().isCompatibleWithMSVC(

LangOptions::MSVC2015) &&

!getASTContext().getLangOpts().isCompatibleWithMSVC(

LangOptions::MSVC2017_7);

(!OmitCopyCtor && CD) {

llvm::raw_svector_ostream Stream(CopyCtorMangling);

msvc_hashing_ostream MHO(Stream);

Mangler.getStream() << CopyCtorMangling;

Mangler.getStream() <<

;

(VBPtrOffset == -1) {

Mangler.getStream() << NVOffset;

Mangler.getStream() << NVOffset;

Mangler.getStream() << VBPtrOffset;

Mangler.getStream() << VBIndex;

MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassDescriptor(

*Derived, uint32_t NVOffset, int32_t VBPtrOffset,

uint32_t VBTableOffset, uint32_t Flags, raw_ostream &Out) {

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.mangleNumber(NVOffset);

Mangler.mangleNumber(VBPtrOffset);

Mangler.mangleNumber(VBTableOffset);

Mangler.mangleNumber(Flags);

Mangler.mangleName(Derived);

Mangler.getStream() <<

;

MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassArray(

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.mangleName(Derived);

Mangler.getStream() <<

;

MicrosoftMangleContextImpl::mangleCXXRTTIClassHierarchyDescriptor(

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.mangleName(Derived);

Mangler.getStream() <<

;

MicrosoftMangleContextImpl::mangleCXXRTTICompleteObjectLocator(

llvm::raw_svector_ostream Stream(VFTableMangling);

mangleCXXVFTable(Derived, BasePath, Stream);

(VFTableMangling.starts_with(

)) {

assert(VFTableMangling.ends_with(

));

Out << VFTableMangling <<

;

assert(VFTableMangling.starts_with(

) ||

VFTableMangling.starts_with(

));

Out <<

<< VFTableMangling.str().drop_front(4);

MicrosoftMangleContextImpl::mangleSEHFilterExpression(

EnclosingDecl, raw_ostream &Out) {

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

<< SEHFilterIds[EnclosingDecl]++ <<

;

Mangler.mangleName(EnclosingDecl);

MicrosoftMangleContextImpl::mangleSEHFinallyBlock(

EnclosingDecl, raw_ostream &Out) {

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

<< SEHFinallyIds[EnclosingDecl]++ <<

;

Mangler.mangleName(EnclosingDecl);

MicrosoftMangleContextImpl::mangleCanonicalTypeName(

, raw_ostream &Out,

NormalizeIntegers =

) {

MicrosoftCXXNameMangler Mangler(*

, Out);

Mangler.getStream() <<

;

Mangler.mangleType(

.getCanonicalType(),

());

MicrosoftMangleContextImpl::mangleReferenceTemporary(

*VD,

ManglingNumber, raw_ostream &Out) {

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.mangleSourceName(

+ llvm::utostr(ManglingNumber));

Mangler.mangle(VD,

);

MicrosoftMangleContextImpl::mangleThreadSafeStaticGuardVariable(

*VD,

GuardNum, raw_ostream &Out) {

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

;

Mangler.mangleSourceName(

+ llvm::utostr(GuardNum));

Mangler.mangleNestedName(VD);

Mangler.getStream() <<

;

MicrosoftMangleContextImpl::mangleStaticGuardVariable(

*VD,

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() << (VD->

() ?

:

);

Mangler.getStream() <<

;

ScopeDepth = 0;

(Visible && !getNextDiscriminator(VD, ScopeDepth))

Mangler.mangle(VD,

);

Mangler.mangleNestedName(VD);

Mangler.getStream() << (Visible ?

:

);

Mangler.mangleNumber(ScopeDepth);

MicrosoftMangleContextImpl::mangleInitFiniStub(

*

,

msvc_hashing_ostream MHO(Out);

MicrosoftCXXNameMangler Mangler(*

, MHO);

Mangler.getStream() <<

<< CharCode;

(

->isStaticDataMember()) {

Mangler.getStream() <<

;

Mangler.mangleName(

);

Mangler.mangleVariableEncoding(

);

Mangler.getStream() <<

;

Mangler.mangleName(

);

Mangler.getStream() <<

;

MicrosoftMangleContextImpl::mangleDynamicInitializer(

*

,

mangleInitFiniStub(

,

, Out);

MicrosoftMangleContextImpl::mangleDynamicAtExitDestructor(

*

,

mangleInitFiniStub(

,

, Out);

MicrosoftMangleContextImpl::mangleStringLiteral(

*SL,

MicrosoftCXXNameMangler Mangler(*

, Out);

Mangler.getStream() <<

;

StringLength =

getASTContext().getAsConstantArrayType(SL->

())->getZExtSize();

Mangler.getStream() <<

;

Mangler.getStream() <<

;

Mangler.mangleNumber(StringByteLength);

GetLittleEndianByte = [&SL](

Index) {

(Index / CharByteWidth >= SL->

())

(0);

OffsetInCodeUnit = Index % CharByteWidth;

((CodeUnit >> (8 * OffsetInCodeUnit)) & 0xff);

GetBigEndianByte = [&SL](

Index) {

(Index / CharByteWidth >= SL->

())

(0);

OffsetInCodeUnit = (CharByteWidth - 1) - (Index % CharByteWidth);

((CodeUnit >> (8 * OffsetInCodeUnit)) & 0xff);

(

I = 0,

= StringByteLength; I !=

; ++I)

JC.update(GetLittleEndianByte(I));

Mangler.mangleNumber(JC.getCRC());

MangleByte = [&Mangler](

Byte) {

Mangler.getStream() << Byte;

}

(

(Byte & 0x7f)) {

Mangler.getStream() <<

<<

(Byte & 0x7f);

SpecialChars[] = {

,

,

,

,

,

,

,

,

,

};

*Pos = llvm::find(SpecialChars, Byte);

(Pos != std::end(SpecialChars)) {

Mangler.getStream() <<

<< (Pos - std::begin(SpecialChars));

Mangler.getStream() <<

;

Mangler.getStream() <<

(

+ ((Byte >> 4) & 0xf));

Mangler.getStream() <<

(

+ (Byte & 0xf));

MaxBytesToMangle = SL->

() ? 64U : 32U;

NumBytesToMangle = std::min(MaxBytesToMangle, StringByteLength);

(

I = 0; I != NumBytesToMangle; ++I) {

MangleByte(GetBigEndianByte(I));

MangleByte(GetLittleEndianByte(I));

Mangler.getStream() <<

;

manglePointerCVQualifiers(Quals);

manglePointerExtQualifiers(Quals, PointeeType);

mangleFunctionType(FPT,

,

);

mangleAutoReturnType(PointeeType, QMM_Drop);

MicrosoftCXXNameMangler::mangleAutoReturnType(

*

,

);

manglePointerCVQualifiers(Quals);

manglePointerExtQualifiers(Quals, PointeeType);

mangleFunctionType(FPT);

mangleAutoReturnType(PointeeType, QMM_Mangle);

manglePointerExtQualifiers(Quals, PointeeType);

mangleAutoReturnType(PointeeType, QMM_Mangle);

manglePointerExtQualifiers(Quals, PointeeType);

mangleAutoReturnType(PointeeType, QMM_Mangle);

MicrosoftMangleContextImpl(Context, Diags, IsAux);

Enums/classes describing ABI related information about constructors, destructors and thunks.

Defines the clang::ASTContext interface.

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

This file defines OpenMP nodes for declarative directives.

Defines the C++ template declaration subclasses.

Defines the clang::Expr interface and subclasses for C++ expressions.

static unsigned getCharWidth(tok::TokenKind kind, const TargetInfo &Target)

llvm::MachO::Record Record

static GlobalDecl isTemplate(GlobalDecl GD, const TemplateArgumentList *&TemplateArgs)

static ValueDecl * getAsArrayToPointerDecayedDecl(QualType T, const APValue &V)

If value V (with type T) represents a decayed pointer to the first element of an array,...

static void mangleThunkThisAdjustment(AccessSpecifier AS, const ThisAdjustment &Adjustment, MicrosoftCXXNameMangler &Mangler, raw_ostream &Out)

Defines the SourceManager interface.

A non-discriminated union of a base, field, or array index.

APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...

@ Indeterminate

This object has an indeterminate value (C++ [basic.indet]).

@ None

There is no such object (it's outside its lifetime).

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

SourceManager & getSourceManager()

unsigned getManglingNumber(const NamedDecl *ND, bool ForAuxTarget=false) const

TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)

const LangOptions & getLangOpts() const

bool addressSpaceMapManglingFor(LangAS AS) const

const clang::PrintingPolicy & getPrintingPolicy() const

DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)

unsigned getTargetAddressSpace(LangAS AS) const

ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...

CharUnits getVBPtrOffset() const

getVBPtrOffset - Get the offset for virtual base table pointer.

Represents a constant array type that does not decay to a pointer when used as a function parameter.

Represents an array type, per C99 6.7.5.2 - Array Declarators.

QualType getElementType() const

Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.

A fixed int type of a specified bitwidth.

Represents a block literal declaration, which is like an unnamed FunctionDecl.

This class is used for builtin types like 'int'.

Represents a base class of a C++ class.

Represents a C++ constructor within a class.

Represents a C++ destructor within a class.

Represents a static or instance method of a struct/union/class.

bool isImplicitObjectMemberFunction() const

[C++2b][dcl.fct]/p7 An implicit object member function is a non-static member function without an exp...

const CXXRecordDecl * getParent() const

Return the parent of this method declaration, which is the class in which this method is defined.

Represents a C++ struct/union/class.

Decl * getLambdaContextDecl() const

Retrieve the declaration that provides additional context for a lambda, when the normal declaration c...

bool isLambda() const

Determine whether this class describes a lambda function object.

unsigned getLambdaManglingNumber() const

If this is the closure type of a lambda expression, retrieve the number to be used for name mangling ...

CXXRecordDecl * getMostRecentNonInjectedDecl()

MSInheritanceModel getMSInheritanceModel() const

Returns the inheritance model used for this record.

bool nullFieldOffsetIsZero() const

In the Microsoft C++ ABI, use zero for the field offset of a null data member pointer if we can guara...

CharUnits - This is an opaque type for sizes expressed in character units.

QuantityType getQuantity() const

getQuantity - Get the raw integer representation of this quantity.

Represents a class template specialization, which refers to a class template with a given set of temp...

Complex values, per C99 6.2.5p11.

Represents the canonical version of C arrays with a specified constant size.

llvm::APInt getSize() const

Return the constant array size as an APInt.

Represents a concrete matrix type with constant number of rows and columns.

Represents a pointer type decayed from an array or function type.

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

DeclContext * getParent()

getParent - Returns the containing DeclContext.

bool isTranslationUnit() const

DeclContext * getRedeclContext()

getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...

bool isFunctionOrMethod() const

Decl - This represents one declaration (or definition), e.g.

SourceLocation getLocation() const

DeclContext * getDeclContext()

AccessSpecifier getAccess() const

virtual SourceRange getSourceRange() const LLVM_READONLY

Source range that this declaration covers.

The name of a declaration.

@ CXXConversionFunctionName

Represents a ValueDecl that came out of a declarator.

Represents the type decltype(expr) (C++11).

A decomposition declaration.

Represents a C++17 deduced template specialization type.

Represents an extended address space qualifier where the input address space value is dependent.

Represents a qualified type name for which the type name is dependent.

Represents an array type in C++ whose size is a value-dependent expression.

SourceRange getBracketsRange() const

Expr * getSizeExpr() const

Represents an extended vector type where either the type or size is dependent.

Represents a matrix type where the type and the number of rows and columns is dependent on a template...

Represents a template specialization type whose template cannot be resolved, e.g.

Represents a vector type where either the type or size is dependent.

A little helper class used to produce diagnostics.

Concrete class used by the front-end to report problems and issues.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

unsigned getCustomDiagID(Level L, const char(&FormatString)[N])

Return an ID for a diagnostic with the specified format string and level.

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.

This represents one expression.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const

isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.

ExtVectorType - Extended vector type.

Represents a member of a struct/union/class.

Represents a function declaration or definition.

FunctionTemplateDecl * getPrimaryTemplate() const

Retrieve the primary template that this function template specialization either specializes or was in...

FunctionDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

const TemplateArgumentList * getTemplateSpecializationArgs() const

Retrieve the template arguments used to produce this function template specialization from the primar...

bool isExternC() const

Determines whether this function is a function with external, C linkage.

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

Represents a K&R-style 'int foo()' function, which has no information available about its arguments.

Represents a prototype with parameter type info, e.g.

unsigned getNumParams() const

Qualifiers getMethodQuals() const

QualType getParamType(unsigned i) const

CanThrowResult canThrow() const

Determine whether this function type has a non-throwing exception specification.

bool isVariadic() const

Whether this function prototype is variadic.

RefQualifierKind getRefQualifier() const

Retrieve the ref-qualifier associated with this function type.

FunctionType - C99 6.7.5.3 - Function Declarators.

CallingConv getCallConv() const

QualType getReturnType() const

GlobalDecl - represents a global declaration.

CXXCtorType getCtorType() const

KernelReferenceKind getKernelReferenceKind() const

GlobalDecl getWithDecl(const Decl *D)

CXXDtorType getDtorType() const

const Decl * getDecl() const

One of these records is kept for each identifier that is lexed.

Represents a C array with an unspecified size.

The injected class name of a C++ class template or class template partial specialization.

An lvalue reference type, per C++11 [dcl.ref].

bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const

virtual void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type, const ThunkInfo &Thunk, bool ElideOverrideInfo, raw_ostream &)=0

virtual void mangleCXXRTTI(QualType T, raw_ostream &)=0

virtual std::string getLambdaString(const CXXRecordDecl *Lambda)=0

virtual bool shouldMangleStringLiteral(const StringLiteral *SL)=0

ASTContext & getASTContext() const

virtual void mangleDynamicAtExitDestructor(const VarDecl *D, raw_ostream &)=0

virtual void mangleSEHFilterExpression(GlobalDecl EnclosingDecl, raw_ostream &Out)=0

virtual void mangleThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk, bool ElideOverrideInfo, raw_ostream &)=0

virtual void mangleCanonicalTypeName(QualType T, raw_ostream &, bool NormalizeIntegers=false)=0

Generates a unique string for an externally visible type for use with TBAA or type uniquing.

virtual void mangleStringLiteral(const StringLiteral *SL, raw_ostream &)=0

virtual void mangleCXXName(GlobalDecl GD, raw_ostream &)=0

virtual void mangleReferenceTemporary(const VarDecl *D, unsigned ManglingNumber, raw_ostream &)=0

virtual bool shouldMangleCXXName(const NamedDecl *D)=0

virtual void mangleCXXRTTIName(QualType T, raw_ostream &, bool NormalizeIntegers=false)=0

virtual void mangleDynamicInitializer(const VarDecl *D, raw_ostream &)=0

virtual void mangleCXXVTable(const CXXRecordDecl *RD, raw_ostream &)=0

virtual void mangleSEHFinallyBlock(GlobalDecl EnclosingDecl, raw_ostream &Out)=0

virtual void mangleStaticGuardVariable(const VarDecl *D, raw_ostream &)=0

A pointer to member type per C++ 8.3.3 - Pointers to members.

virtual void mangleCXXVFTable(const CXXRecordDecl *Derived, ArrayRef< const CXXRecordDecl * > BasePath, raw_ostream &Out)=0

Mangle vftable symbols.

virtual void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD, const MethodVFTableLocation &ML, raw_ostream &Out)=0

virtual void mangleCXXRTTICompleteObjectLocator(const CXXRecordDecl *Derived, ArrayRef< const CXXRecordDecl * > BasePath, raw_ostream &Out)=0

virtual void mangleCXXThrowInfo(QualType T, bool IsConst, bool IsVolatile, bool IsUnaligned, uint32_t NumEntries, raw_ostream &Out)=0

virtual void mangleCXXVBTable(const CXXRecordDecl *Derived, ArrayRef< const CXXRecordDecl * > BasePath, raw_ostream &Out)=0

Mangle vbtable symbols.

virtual void mangleCXXRTTIClassHierarchyDescriptor(const CXXRecordDecl *Derived, raw_ostream &Out)=0

virtual void mangleThreadSafeStaticGuardVariable(const VarDecl *VD, unsigned GuardNum, raw_ostream &Out)=0

static MicrosoftMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags, bool IsAux=false)

virtual void mangleCXXCatchableTypeArray(QualType T, uint32_t NumEntries, raw_ostream &Out)=0

virtual void mangleCXXRTTIBaseClassDescriptor(const CXXRecordDecl *Derived, uint32_t NVOffset, int32_t VBPtrOffset, uint32_t VBTableOffset, uint32_t Flags, raw_ostream &Out)=0

virtual void mangleCXXCatchableType(QualType T, const CXXConstructorDecl *CD, CXXCtorType CT, uint32_t Size, uint32_t NVOffset, int32_t VBPtrOffset, uint32_t VBIndex, raw_ostream &Out)=0

virtual void mangleCXXRTTIBaseClassArray(const CXXRecordDecl *Derived, raw_ostream &Out)=0

virtual void mangleCXXVirtualDisplacementMap(const CXXRecordDecl *SrcRD, const CXXRecordDecl *DstRD, raw_ostream &Out)=0

MethodVFTableLocation getMethodVFTableLocation(GlobalDecl GD)

This represents a decl that may have a name.

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

StringRef getName() const

Get the name of identifier for this declaration as a StringRef.

bool isExternallyVisible() const

Represent a C++ namespace.

NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.

Interfaces are the core concept in Objective-C for object oriented design.

ObjCMethodDecl - Represents an instance or class method declaration.

Represents a pointer to an Objective C object.

Represents a class type in Objective C.

Represents an Objective-C protocol declaration.

Represents a pack expansion of types.

Represents a parameter to a function.

unsigned getFunctionScopeIndex() const

Returns the index of this parameter in its prototype or method scope.

PointerType - C99 6.7.5.1 - Pointer Declarators.

PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specifi...

A (possibly-)qualified type.

QualType getDesugaredType(const ASTContext &Context) const

Return the specified type with any "sugar" removed from the type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

Qualifiers getQualifiers() const

Retrieve the set of qualifiers applied to this type.

QualType getCanonicalType() const

QualType getUnqualifiedType() const

Retrieve the unqualified variant of the given type, removing as little sugar as possible.

void * getAsOpaquePtr() const

Qualifiers getLocalQualifiers() const

Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...

The collection of all-type qualifiers we support.

@ OCL_Strong

Assigning into this object requires the old value to be released and the new value to be retained.

@ OCL_ExplicitNone

This object can be modified without requiring retains or releases.

@ OCL_None

There is no lifetime qualification on this type.

@ OCL_Weak

Reading or writing from this object requires a barrier call.

@ OCL_Autoreleasing

Assigning into this object requires a lifetime extension.

bool hasUnaligned() const

bool hasAddressSpace() const

bool hasObjCLifetime() const

ObjCLifetime getObjCLifetime() const

Qualifiers withoutObjCLifetime() const

LangAS getAddressSpace() const

An rvalue reference type, per C++11 [dcl.ref].

field_range fields() const

bool isAnonymousStructOrUnion() const

Whether this is an anonymous struct or union.

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

RecordDecl * getDecl() const

decl_type * getFirstDecl()

Return the first declaration of this declaration or itself if this is the only declaration.

QualType getPointeeType() const

Encodes a location in the source.

This class handles loading and caching of source files into memory.

A trivial tuple used to represent a source range.

SourceLocation getBegin() const

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

const char * getStmtClassName() const

StringLiteral - This represents a string literal expression, e.g.

unsigned getLength() const

uint32_t getCodeUnit(size_t i) const

unsigned getCharByteWidth() const

Represents the result of substituting a set of types for a template type parameter pack.

Represents the declaration of a struct/union/class/enum.

TypedefNameDecl * getTypedefNameForAnonDecl() const

TagKind getTagKind() const

A template argument list.

unsigned size() const

Retrieve the number of template arguments in this template argument list.

Represents a template argument.

ArrayRef< TemplateArgument > getPackAsArray() const

Return the array of arguments in this template argument pack.

QualType getStructuralValueType() const

Get the type of a StructuralValue.

QualType getParamTypeForDecl() const

Expr * getAsExpr() const

Retrieve the template argument as an expression.

QualType getNonTypeTemplateArgumentType() const

If this is a non-type template argument, get its type.

QualType getAsType() const

Retrieve the type for a type template argument.

llvm::APSInt getAsIntegral() const

Retrieve the template argument as an integral value.

QualType getNullPtrType() const

Retrieve the type for null non-type template argument.

TemplateName getAsTemplate() const

Retrieve the template name for a template name argument.

QualType getIntegralType() const

Retrieve the type of the integral value.

ValueDecl * getAsDecl() const

Retrieve the declaration for a declaration non-type template argument.

@ Declaration

The template argument is a declaration that was provided for a pointer, reference,...

@ Template

The template argument is a template name that was provided for a template template parameter.

@ StructuralValue

The template argument is a non-type template argument that can't be represented by the special-case D...

@ Pack

The template argument is actually a parameter pack.

@ TemplateExpansion

The template argument is a pack expansion of a template name that was provided for a template templat...

@ NullPtr

The template argument is a null pointer or null pointer to member that was provided for a non-type te...

@ Type

The template argument is a type.

@ Null

Represents an empty template argument, e.g., one that has not been deduced.

@ Integral

The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...

@ Expression

The template argument is an expression, and we've not resolved it to one of the other forms yet,...

ArgKind getKind() const

Return the kind of stored template argument.

const APValue & getAsStructuralValue() const

Get the value of a StructuralValue.

The base class of all kinds of template declarations (e.g., class, function, etc.).

NamedDecl * getTemplatedDecl() const

Get the underlying, templated declaration.

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) const

Retrieve the underlying template declaration that this template name refers to, if known.

Stores a list of template parameters for a TemplateDecl and its derived classes.

NamedDecl * getParam(unsigned Idx)

Represents a type template specialization; the template must be a class template, a type alias templa...

Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...

Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...

The base class of the type hierarchy.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

bool isBlockPointerType() const

bool isPointerType() const

const T * castAs() const

Member-template castAs<specific type>.

bool isReferenceType() const

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

AutoType * getContainedAutoType() const

Get the AutoType whose type will be deduced for a variable with an initializer of this type.

bool isMemberDataPointerType() const

bool isMemberPointerType() const

const ArrayType * getAsArrayTypeUnsafe() const

A variant of getAs<> for array types which silently discards qualifiers from the outermost type.

bool isFunctionType() const

bool isAnyPointerType() const

TypeClass getTypeClass() const

const T * getAs() const

Member-template getAs<specific type>'.

bool isRecordType() const

RecordDecl * getAsRecordDecl() const

Retrieves the RecordDecl this type refers to.

Base class for declarations which introduce a typedef-name.

A unary type transform, which is a type constructed from another.

Represents the dependent type named by a dependently-scoped typename using declaration,...

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Represents a variable declaration or definition.

TLSKind getTLSKind() const

SourceRange getSourceRange() const override LLVM_READONLY

Source range that this declaration covers.

bool isStaticDataMember() const

Determines whether this is a static data member.

bool isStaticLocal() const

Returns true if a variable with function scope is a static local variable.

bool isExternC() const

Determines whether this variable is a variable with external, C linkage.

Represents a variable template specialization, which refers to a variable template with a given set o...

Represents a C array with a specified size that is not an integer-constant-expression.

Represents a GCC generic vector type.

Defines the clang::TargetInfo interface.

The JSON file list parser is used to communicate input to InstallAPI.

OverloadedOperatorKind

Enumeration specifying the different kinds of C++ overloaded operators.

@ OO_None

Not an overloaded operator.

@ NUM_OVERLOADED_OPERATORS

CXXCtorType

C++ constructor types.

@ Ctor_DefaultClosure

Default closure variant of a ctor.

@ Ctor_CopyingClosure

Copying closure variant of a ctor.

@ Ctor_Complete

Complete object ctor.

LLVM_READONLY bool isAsciiIdentifierContinue(unsigned char c)

RefQualifierKind

The kind of C++11 ref-qualifier associated with a function type.

@ RQ_None

No ref-qualifier was provided.

@ RQ_LValue

An lvalue ref-qualifier was provided (&).

@ RQ_RValue

An rvalue ref-qualifier was provided (&&).

bool inheritanceModelHasNVOffsetField(bool IsMemberFunction, MSInheritanceModel Inheritance)

LanguageLinkage

Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have.

bool inheritanceModelHasVBPtrOffsetField(MSInheritanceModel Inheritance)

LLVM_READONLY bool isLetter(unsigned char c)

Return true if this character is an ASCII letter: [a-zA-Z].

bool inheritanceModelHasVBTableOffsetField(MSInheritanceModel Inheritance)

CXXDtorType

C++ destructor types.

@ Dtor_Comdat

The COMDAT used for dtors.

@ Dtor_Base

Base object dtor.

@ Dtor_Complete

Complete object dtor.

@ Dtor_Deleting

Deleting dtor.

TagTypeKind

The kind of a tag type.

LangAS

Defines the address space values used by the address space qualifier of QualType.

bool isPtrSizeAddressSpace(LangAS AS)

const FunctionProtoType * T

MSInheritanceModel

Assigned inheritance model for a class in the MS C++ ABI.

CallingConv

CallingConv - Specifies the calling convention that a function uses.

AccessSpecifier

A C++ access specifier (public, private, protected), plus the special value "none" which means differ...

Diagnostic wrappers for TextAPI types for error reporting.

const CXXRecordDecl * VBase

If nonnull, holds the last vbase which contains the vfptr that the method definition is adjusted to.

CharUnits VFPtrOffset

This is the offset of the vfptr from the start of the last vbase, or the complete type if there are n...

uint64_t VBTableIndex

If nonzero, holds the vbtable index of the virtual base with the vfptr.

uint64_t Index

Method's index in the vftable.

A this pointer adjustment.

union clang::ThisAdjustment::VirtualAdjustment Virtual

int64_t NonVirtual

The non-virtual adjustment from the derived object to its nearest virtual base.

The this pointer adjustment as well as an optional return adjustment for a thunk.

ThisAdjustment This

The this pointer adjustment.

const CXXMethodDecl * Method

Holds a pointer to the overridden method this thunk is for, if needed by the ABI to distinguish diffe...

ReturnAdjustment Return

The return adjustment.

int32_t VtordispOffset

The offset of the vtordisp (in bytes), relative to the ECX.

int32_t VBOffsetOffset

The offset (in bytes) of the vbase offset in the vbtable.

int32_t VBPtrOffset

The offset of the vbptr of the derived class (in bytes), relative to the ECX after vtordisp adjustmen...

struct clang::ThisAdjustment::VirtualAdjustment::@195 Microsoft

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4