35 #include "llvm/ADT/StringExtras.h"
36 #include "llvm/Support/ErrorHandling.h"
37 #include "llvm/Support/raw_ostream.h"
39 using namespace clang;
43 static bool isLocalContainerContext(
const DeclContext *DC) {
44 return isa<FunctionDecl>(DC) || isa<ObjCMethodDecl>(DC) || isa<BlockDecl>(DC);
49 return ftd->getTemplatedDecl();
56 return (fn ? getStructor(fn) :
decl);
59 static bool isLambda(
const NamedDecl *ND) {
67 static const unsigned UnknownArity = ~0
U;
70 typedef std::pair<const DeclContext*, IdentifierInfo*> DiscriminatorKeyTy;
71 llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator;
72 llvm::DenseMap<const NamedDecl*, unsigned> Uniquifier;
73 const DiscriminatorOverrideTy DiscriminatorOverride =
nullptr;
76 bool NeedsUniqueInternalLinkageNames =
false;
79 explicit ItaniumMangleContextImpl(
81 DiscriminatorOverrideTy DiscriminatorOverride,
bool IsAux =
false)
83 DiscriminatorOverride(DiscriminatorOverride) {}
88 bool shouldMangleCXXName(
const NamedDecl *D)
override;
89 bool shouldMangleStringLiteral(
const StringLiteral *)
override {
94 void needsUniqueInternalLinkageNames()
override {
95 NeedsUniqueInternalLinkageNames =
true;
98 void mangleCXXName(
GlobalDecl GD, raw_ostream &)
override;
100 raw_ostream &)
override;
103 raw_ostream &)
override;
104 void mangleReferenceTemporary(
const VarDecl *D,
unsigned ManglingNumber,
105 raw_ostream &)
override;
106 void mangleCXXVTable(
const CXXRecordDecl *RD, raw_ostream &)
override;
107 void mangleCXXVTT(
const CXXRecordDecl *RD, raw_ostream &)
override;
110 void mangleCXXRTTI(
QualType T, raw_ostream &)
override;
111 void mangleCXXRTTIName(
QualType T, raw_ostream &)
override;
112 void mangleTypeName(
QualType T, raw_ostream &)
override;
116 void mangleStaticGuardVariable(
const VarDecl *D, raw_ostream &)
override;
117 void mangleDynamicInitializer(
const VarDecl *D, raw_ostream &Out)
override;
118 void mangleDynamicAtExitDestructor(
const VarDecl *D,
119 raw_ostream &Out)
override;
120 void mangleDynamicStermFinalizer(
const VarDecl *D, raw_ostream &Out)
override;
121 void mangleSEHFilterExpression(
const NamedDecl *EnclosingDecl,
122 raw_ostream &Out)
override;
123 void mangleSEHFinallyBlock(
const NamedDecl *EnclosingDecl,
124 raw_ostream &Out)
override;
125 void mangleItaniumThreadLocalInit(
const VarDecl *D, raw_ostream &)
override;
126 void mangleItaniumThreadLocalWrapper(
const VarDecl *D,
127 raw_ostream &)
override;
129 void mangleStringLiteral(
const StringLiteral *, raw_ostream &)
override;
131 void mangleLambdaSig(
const CXXRecordDecl *Lambda, raw_ostream &)
override;
133 void mangleModuleInitializer(
const Module *
Module, raw_ostream &)
override;
135 bool getNextDiscriminator(
const NamedDecl *ND,
unsigned &disc) {
141 if (
const TagDecl *Tag = dyn_cast<TagDecl>(ND)) {
142 if (Tag->getName().empty() && !Tag->getTypedefNameForAnonDecl())
148 unsigned discriminator = getASTContext().getManglingNumber(ND, isAux());
149 if (discriminator == 1)
151 disc = discriminator - 2;
156 unsigned &discriminator = Uniquifier[ND];
157 if (!discriminator) {
158 const DeclContext *DC = getEffectiveDeclContext(ND);
159 discriminator = ++Discriminator[std::make_pair(DC, ND->
getIdentifier())];
161 if (discriminator == 1)
163 disc = discriminator-2;
170 assert(Lambda->
isLambda() &&
"RD must be a lambda!");
175 const ParmVarDecl *Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
180 unsigned DefaultArgNo =
182 Name += llvm::utostr(DefaultArgNo);
186 if (LambdaManglingNumber)
187 LambdaId = LambdaManglingNumber;
189 LambdaId = getAnonymousStructIdForDebugInfo(Lambda);
191 Name += llvm::utostr(LambdaId);
196 DiscriminatorOverrideTy getDiscriminatorOverride()
const override {
197 return DiscriminatorOverride;
204 return getEffectiveDeclContext(cast<Decl>(DC));
207 bool isInternalLinkageDecl(
const NamedDecl *ND);
214 class CXXNameMangler {
215 ItaniumMangleContextImpl &Context;
217 bool NullOut =
false;
222 bool DisableDerivedAbiTags =
false;
228 unsigned StructorType = 0;
233 class FunctionTypeDepthState {
236 enum { InResultTypeMask = 1 };
239 FunctionTypeDepthState() : Bits(0) {}
242 unsigned getDepth()
const {
247 bool isInResultType()
const {
248 return Bits & InResultTypeMask;
251 FunctionTypeDepthState push() {
252 FunctionTypeDepthState tmp = *
this;
253 Bits = (Bits & ~InResultTypeMask) + 2;
257 void enterResultType() {
258 Bits |= InResultTypeMask;
261 void leaveResultType() {
262 Bits &= ~InResultTypeMask;
265 void pop(FunctionTypeDepthState saved) {
266 assert(getDepth() == saved.getDepth() + 1);
281 class AbiTagState final {
283 explicit AbiTagState(AbiTagState *&Head) : LinkHead(Head) {
289 AbiTagState(
const AbiTagState &) =
delete;
290 AbiTagState &operator=(
const AbiTagState &) =
delete;
292 ~AbiTagState() { pop(); }
294 void write(raw_ostream &Out,
const NamedDecl *ND,
295 const AbiTagList *AdditionalAbiTags) {
297 if (!isa<FunctionDecl>(ND) && !isa<VarDecl>(ND)) {
299 !AdditionalAbiTags &&
300 "only function and variables need a list of additional abi tags");
301 if (
const auto *NS = dyn_cast<NamespaceDecl>(ND)) {
302 if (
const auto *AbiTag = NS->getAttr<AbiTagAttr>()) {
303 UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(),
304 AbiTag->tags().end());
312 if (
const auto *AbiTag = ND->
getAttr<AbiTagAttr>()) {
313 UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(),
314 AbiTag->tags().end());
315 TagList.insert(TagList.end(), AbiTag->tags().begin(),
316 AbiTag->tags().end());
319 if (AdditionalAbiTags) {
320 UsedAbiTags.insert(UsedAbiTags.end(), AdditionalAbiTags->begin(),
321 AdditionalAbiTags->end());
322 TagList.insert(TagList.end(), AdditionalAbiTags->begin(),
323 AdditionalAbiTags->end());
327 TagList.erase(std::unique(TagList.begin(), TagList.end()), TagList.end());
329 writeSortedUniqueAbiTags(Out, TagList);
332 const AbiTagList &getUsedAbiTags()
const {
return UsedAbiTags; }
333 void setUsedAbiTags(
const AbiTagList &AbiTags) {
334 UsedAbiTags = AbiTags;
337 const AbiTagList &getEmittedAbiTags()
const {
338 return EmittedAbiTags;
341 const AbiTagList &getSortedUniqueUsedAbiTags() {
342 llvm::sort(UsedAbiTags);
343 UsedAbiTags.erase(std::unique(UsedAbiTags.begin(), UsedAbiTags.end()),
350 AbiTagList UsedAbiTags;
352 AbiTagList EmittedAbiTags;
354 AbiTagState *&LinkHead;
355 AbiTagState *
Parent =
nullptr;
358 assert(LinkHead ==
this &&
359 "abi tag link head must point to us on destruction");
362 UsedAbiTags.begin(), UsedAbiTags.end());
363 Parent->EmittedAbiTags.insert(
Parent->EmittedAbiTags.end(),
364 EmittedAbiTags.begin(),
365 EmittedAbiTags.end());
370 void writeSortedUniqueAbiTags(raw_ostream &Out,
const AbiTagList &AbiTags) {
371 for (
const auto &Tag : AbiTags) {
372 EmittedAbiTags.push_back(Tag);
380 AbiTagState *AbiTags =
nullptr;
381 AbiTagState AbiTagsRoot;
383 llvm::DenseMap<uintptr_t, unsigned> Substitutions;
384 llvm::DenseMap<StringRef, unsigned> ModuleSubstitutions;
386 ASTContext &getASTContext()
const {
return Context.getASTContext(); }
395 llvm::StringRef Name,
bool HasAllocator);
398 CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
399 const NamedDecl *D =
nullptr,
bool NullOut_ =
false)
400 : Context(
C), Out(Out_), NullOut(NullOut_), Structor(getStructor(D)),
401 AbiTagsRoot(AbiTags) {
403 assert(!D || (!isa<CXXDestructorDecl>(D) &&
404 !isa<CXXConstructorDecl>(D)));
406 CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
408 : Context(
C), Out(Out_), Structor(getStructor(D)), StructorType(
Type),
409 AbiTagsRoot(AbiTags) {}
410 CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
412 : Context(
C), Out(Out_), Structor(getStructor(D)), StructorType(
Type),
413 AbiTagsRoot(AbiTags) {}
415 CXXNameMangler(CXXNameMangler &Outer, raw_ostream &Out_)
416 : Context(Outer.Context), Out(Out_), Structor(Outer.Structor),
417 StructorType(Outer.StructorType), SeqID(Outer.SeqID),
418 FunctionTypeDepth(Outer.FunctionTypeDepth), AbiTagsRoot(AbiTags),
419 Substitutions(Outer.Substitutions),
420 ModuleSubstitutions(Outer.ModuleSubstitutions) {}
422 CXXNameMangler(CXXNameMangler &Outer, llvm::raw_null_ostream &Out_)
423 : CXXNameMangler(Outer, (raw_ostream &)Out_) {
427 raw_ostream &getStream() {
return Out; }
429 void disableDerivedAbiTags() { DisableDerivedAbiTags =
true; }
430 static bool shouldHaveAbiTags(ItaniumMangleContextImpl &C,
const VarDecl *VD);
433 void mangleCallOffset(int64_t NonVirtual, int64_t Virtual);
435 void mangleNumber(int64_t Number);
436 void mangleFloat(
const llvm::APFloat &F);
438 void mangleSeqID(
unsigned SeqID);
441 void mangleNameOrStandardSubstitution(
const NamedDecl *ND);
443 void mangleModuleNamePrefix(StringRef Name,
bool IsPartition =
false);
447 bool mangleSubstitution(
const NamedDecl *ND);
449 bool mangleSubstitution(
QualType T);
455 bool mangleStandardSubstitution(
const NamedDecl *ND);
457 void addSubstitution(
const NamedDecl *ND) {
460 addSubstitution(
reinterpret_cast<uintptr_t>(ND));
465 addSubstitution(
reinterpret_cast<uintptr_t>(NNS));
471 void extendSubstitutions(CXXNameMangler* Other);
474 bool recursive =
false);
478 unsigned NumTemplateArgs,
479 unsigned KnownArity = UnknownArity);
481 void mangleFunctionEncodingBareType(
const FunctionDecl *FD);
484 const AbiTagList *AdditionalAbiTags);
485 void mangleModuleName(
const NamedDecl *ND);
488 unsigned NumTemplateArgs);
490 const AbiTagList *AdditionalAbiTags) {
491 mangleUnqualifiedName(GD, cast<NamedDecl>(GD.
getDecl())->getDeclName(), DC,
492 UnknownArity, AdditionalAbiTags);
496 const AbiTagList *AdditionalAbiTags);
498 const AbiTagList *AdditionalAbiTags);
500 const AbiTagList *AdditionalAbiTags);
504 void mangleSourceNameWithAbiTags(
505 const NamedDecl *ND,
const AbiTagList *AdditionalAbiTags =
nullptr);
507 const AbiTagList *AdditionalAbiTags);
508 void mangleBlockForPrefix(
const BlockDecl *Block);
509 void mangleUnqualifiedBlock(
const BlockDecl *Block);
513 const AbiTagList *AdditionalAbiTags,
514 bool NoFunction=
false);
517 unsigned NumTemplateArgs);
518 void mangleNestedNameWithClosurePrefix(
GlobalDecl GD,
520 const AbiTagList *AdditionalAbiTags);
522 void manglePrefix(
const DeclContext *DC,
bool NoFunction=
false);
524 void mangleTemplatePrefix(
GlobalDecl GD,
bool NoFunction=
false);
527 void mangleClosurePrefix(
const NamedDecl *ND,
bool NoFunction =
false);
528 bool mangleUnresolvedTypeOrSimpleId(
QualType DestroyedType,
529 StringRef Prefix =
"");
532 void mangleVendorQualifier(StringRef qualifier);
539 #define ABSTRACT_TYPE(CLASS, PARENT)
540 #define NON_CANONICAL_TYPE(CLASS, PARENT)
541 #define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T);
542 #include "clang/AST/TypeNodes.inc"
544 void mangleType(
const TagType*);
546 static StringRef getCallingConvQualifierName(
CallingConv CC);
547 void mangleExtParameterInfo(FunctionProtoType::ExtParameterInfo info);
551 void mangleNeonVectorType(
const VectorType *T);
553 void mangleAArch64NeonVectorType(
const VectorType *T);
555 void mangleAArch64FixedSveVectorType(
const VectorType *T);
559 void mangleFloatLiteral(
QualType T,
const llvm::APFloat &
V);
560 void mangleFixedPointLiteral();
563 void mangleMemberExprBase(
const Expr *base,
bool isArrow);
564 void mangleMemberExpr(
const Expr *base,
bool isArrow,
569 unsigned NumTemplateArgs,
570 unsigned knownArity);
571 void mangleCastExpression(
const Expr *E, StringRef CastEncoding);
572 void mangleInitListElements(
const InitListExpr *InitList);
573 void mangleExpression(
const Expr *E,
unsigned Arity = UnknownArity,
574 bool AsTemplateArg =
false);
580 unsigned NumTemplateArgs);
582 unsigned NumTemplateArgs);
585 void mangleTemplateArgExpr(
const Expr *E);
587 bool NeedExactType =
false);
589 void mangleTemplateParameter(
unsigned Depth,
unsigned Index);
594 const AbiTagList *AdditionalAbiTags);
597 AbiTagList makeFunctionReturnTypeTags(
const FunctionDecl *FD);
599 AbiTagList makeVariableTypeTags(
const VarDecl *VD);
607 getASTContext(), getASTContext().getTranslationUnitDecl(),
609 &getASTContext().Idents.get(
"std"),
619 ItaniumMangleContextImpl::getEffectiveDeclContext(
const Decl *D) {
629 dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl()))
630 return ContextParam->getDeclContext();
634 if (
const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
636 dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl()))
637 return ContextParam->getDeclContext();
645 if (D == getASTContext().getVaListTagDecl()) {
646 const llvm::Triple &T = getASTContext().getTargetInfo().getTriple();
647 if (T.isARM() || T.isThumb() || T.isAArch64())
648 return getStdNamespace();
652 if (isa<CapturedDecl>(DC) || isa<OMPDeclareReductionDecl>(DC) ||
653 isa<OMPDeclareMapperDecl>(DC)) {
654 return getEffectiveDeclContext(cast<Decl>(DC));
657 if (
const auto *VD = dyn_cast<VarDecl>(D))
659 return getASTContext().getTranslationUnitDecl();
661 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
663 return getASTContext().getTranslationUnitDecl();
668 bool ItaniumMangleContextImpl::isInternalLinkageDecl(
const NamedDecl *ND) {
671 getEffectiveDeclContext(ND)->isFileContext() &&
680 if (!NeedsUniqueInternalLinkageNames || !ND)
683 const auto *FD = dyn_cast<FunctionDecl>(ND);
692 if (isInternalLinkageDecl(ND))
698 bool ItaniumMangleContextImpl::shouldMangleCXXName(
const NamedDecl *D) {
699 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
702 if (FD->hasAttr<OverloadableAttr>())
718 if (FD->isMSVCRTEntryPoint())
732 if (!getASTContext().getLangOpts().
CPlusPlus)
735 if (
const auto *VD = dyn_cast<VarDecl>(D)) {
737 if (isa<DecompositionDecl>(VD))
746 const DeclContext *DC = getEffectiveDeclContext(D);
750 DC = getEffectiveParentContext(DC);
752 !CXXNameMangler::shouldHaveAbiTags(*
this, VD) &&
753 !isa<VarTemplateSpecializationDecl>(VD) &&
754 !VD->getOwningModuleForLinkage())
761 void CXXNameMangler::writeAbiTags(
const NamedDecl *ND,
762 const AbiTagList *AdditionalAbiTags) {
763 assert(AbiTags &&
"require AbiTagState");
764 AbiTags->write(Out, ND, DisableDerivedAbiTags ?
nullptr : AdditionalAbiTags);
767 void CXXNameMangler::mangleSourceNameWithAbiTags(
768 const NamedDecl *ND,
const AbiTagList *AdditionalAbiTags) {
770 writeAbiTags(ND, AdditionalAbiTags);
778 if (isa<FunctionDecl>(GD.
getDecl()))
779 mangleFunctionEncoding(GD);
784 dyn_cast<IndirectFieldDecl>(GD.
getDecl()))
785 mangleName(IFD->getAnonField());
787 llvm_unreachable(
"unexpected kind of global decl");
790 void CXXNameMangler::mangleFunctionEncoding(
GlobalDecl GD) {
795 if (!Context.shouldMangleDeclName(FD)) {
800 AbiTagList ReturnTypeAbiTags = makeFunctionReturnTypeTags(FD);
801 if (ReturnTypeAbiTags.empty()) {
804 mangleFunctionEncodingBareType(FD);
812 llvm::raw_svector_ostream FunctionEncodingStream(FunctionEncodingBuf);
813 CXXNameMangler FunctionEncodingMangler(*
this, FunctionEncodingStream);
815 FunctionEncodingMangler.disableDerivedAbiTags();
816 FunctionEncodingMangler.mangleNameWithAbiTags(FD,
nullptr);
819 size_t EncodingPositionStart = FunctionEncodingStream.str().size();
820 FunctionEncodingMangler.mangleFunctionEncodingBareType(FD);
824 const AbiTagList &UsedAbiTags =
825 FunctionEncodingMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags();
826 AbiTagList AdditionalAbiTags(ReturnTypeAbiTags.size());
827 AdditionalAbiTags.erase(
828 std::set_difference(ReturnTypeAbiTags.begin(), ReturnTypeAbiTags.end(),
829 UsedAbiTags.begin(), UsedAbiTags.end(),
830 AdditionalAbiTags.begin()),
831 AdditionalAbiTags.end());
834 mangleNameWithAbiTags(FD, &AdditionalAbiTags);
835 Out << FunctionEncodingStream.str().substr(EncodingPositionStart);
839 extendSubstitutions(&FunctionEncodingMangler);
842 void CXXNameMangler::mangleFunctionEncodingBareType(
const FunctionDecl *FD) {
843 if (FD->
hasAttr<EnableIfAttr>()) {
844 FunctionTypeDepthState Saved = FunctionTypeDepth.push();
845 Out <<
"Ua9enable_ifI";
846 for (AttrVec::const_iterator I = FD->
getAttrs().begin(),
849 EnableIfAttr *EIA = dyn_cast<EnableIfAttr>(*I);
852 if (Context.getASTContext().
getLangOpts().getClangABICompat() >
854 mangleTemplateArgExpr(EIA->getCond());
860 mangleExpression(EIA->getCond());
865 FunctionTypeDepth.pop(Saved);
870 if (
auto *CD = dyn_cast<CXXConstructorDecl>(FD))
871 if (
auto Inherited = CD->getInheritedConstructor())
872 FD = Inherited.getConstructor();
890 bool MangleReturnType =
false;
892 if (!(isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD) ||
893 isa<CXXConversionDecl>(FD)))
894 MangleReturnType =
true;
897 FD = PrimaryTemplate->getTemplatedDecl();
901 MangleReturnType, FD);
906 if (!Context.getEffectiveParentContext(NS)->isTranslationUnit())
910 return II && II->
isStr(
"std");
915 bool CXXNameMangler::isStdNamespace(
const DeclContext *DC) {
919 return isStd(cast<NamespaceDecl>(DC));
926 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
935 dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
936 TemplateArgs = &Spec->getTemplateArgs();
937 return GD.
getWithDecl(Spec->getSpecializedTemplate());
942 dyn_cast<VarTemplateSpecializationDecl>(ND)) {
943 TemplateArgs = &Spec->getTemplateArgs();
944 return GD.
getWithDecl(Spec->getSpecializedTemplate());
955 void CXXNameMangler::mangleName(
GlobalDecl GD) {
957 if (
const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
959 AbiTagList VariableTypeAbiTags = makeVariableTypeTags(VD);
960 if (VariableTypeAbiTags.empty()) {
962 mangleNameWithAbiTags(VD,
nullptr);
967 llvm::raw_null_ostream NullOutStream;
968 CXXNameMangler VariableNameMangler(*
this, NullOutStream);
969 VariableNameMangler.disableDerivedAbiTags();
970 VariableNameMangler.mangleNameWithAbiTags(VD,
nullptr);
973 const AbiTagList &UsedAbiTags =
974 VariableNameMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags();
975 AbiTagList AdditionalAbiTags(VariableTypeAbiTags.size());
976 AdditionalAbiTags.erase(
977 std::set_difference(VariableTypeAbiTags.begin(),
978 VariableTypeAbiTags.end(), UsedAbiTags.begin(),
979 UsedAbiTags.end(), AdditionalAbiTags.begin()),
980 AdditionalAbiTags.end());
983 mangleNameWithAbiTags(VD, &AdditionalAbiTags);
985 mangleNameWithAbiTags(GD,
nullptr);
989 const RecordDecl *CXXNameMangler::GetLocalClassDecl(
const Decl *D) {
990 const DeclContext *DC = Context.getEffectiveDeclContext(D);
992 if (isLocalContainerContext(DC))
993 return dyn_cast<RecordDecl>(D);
995 DC = Context.getEffectiveDeclContext(D);
1000 void CXXNameMangler::mangleNameWithAbiTags(
GlobalDecl GD,
1001 const AbiTagList *AdditionalAbiTags) {
1008 const DeclContext *DC = Context.getEffectiveDeclContext(ND);
1014 if (isLocalContainerContext(DC) && ND->
hasLinkage() && !isLambda(ND))
1016 DC = Context.getEffectiveParentContext(DC);
1017 else if (GetLocalClassDecl(ND)) {
1018 mangleLocalName(GD, AdditionalAbiTags);
1022 assert(!isa<LinkageSpecDecl>(DC) &&
"context cannot be LinkageSpecDecl");
1024 if (isLocalContainerContext(DC)) {
1025 mangleLocalName(GD, AdditionalAbiTags);
1031 if (
const NamedDecl *PrefixND = getClosurePrefix(ND)) {
1032 mangleNestedNameWithClosurePrefix(GD, PrefixND, AdditionalAbiTags);
1040 mangleUnscopedTemplateName(TD, DC, AdditionalAbiTags);
1045 mangleUnscopedName(GD, DC, AdditionalAbiTags);
1049 mangleNestedName(GD, DC, AdditionalAbiTags);
1052 void CXXNameMangler::mangleModuleName(
const NamedDecl *ND) {
1055 mangleModuleNamePrefix(M->getPrimaryModuleInterfaceName());
1063 void CXXNameMangler::mangleModuleNamePrefix(StringRef Name,
bool IsPartition) {
1065 auto It = ModuleSubstitutions.find(Name);
1066 if (It != ModuleSubstitutions.end()) {
1068 mangleSeqID(It->second);
1074 auto Parts = Name.rsplit(
'.');
1075 if (Parts.second.empty())
1076 Parts.second = Parts.first;
1078 mangleModuleNamePrefix(Parts.first, IsPartition);
1079 IsPartition =
false;
1085 Out << Parts.second.size() << Parts.second;
1086 ModuleSubstitutions.insert({Name, SeqID++});
1089 void CXXNameMangler::mangleTemplateName(
const TemplateDecl *TD,
1091 unsigned NumTemplateArgs) {
1092 const DeclContext *DC = Context.getEffectiveDeclContext(TD);
1095 mangleUnscopedTemplateName(TD, DC,
nullptr);
1096 mangleTemplateArgs(
asTemplateName(TD), TemplateArgs, NumTemplateArgs);
1098 mangleNestedName(TD, TemplateArgs, NumTemplateArgs);
1103 const AbiTagList *AdditionalAbiTags) {
1107 assert(!isa<LinkageSpecDecl>(DC) &&
"unskipped LinkageSpecDecl");
1108 if (isStdNamespace(DC))
1111 mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
1114 void CXXNameMangler::mangleUnscopedTemplateName(
1119 if (mangleSubstitution(ND))
1123 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
1124 assert(!AdditionalAbiTags &&
1125 "template template param cannot have abi tags");
1126 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
1127 }
else if (isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND)) {
1128 mangleUnscopedName(GD, DC, AdditionalAbiTags);
1134 addSubstitution(ND);
1137 void CXXNameMangler::mangleFloat(
const llvm::APFloat &f) {
1152 unsigned numCharacters = (valueBits.getBitWidth() + 3) / 4;
1153 assert(numCharacters != 0);
1159 for (
unsigned stringIndex = 0; stringIndex != numCharacters; ++stringIndex) {
1161 unsigned digitBitIndex = 4 * (numCharacters - stringIndex - 1);
1164 uint64_t hexDigit = valueBits.getRawData()[digitBitIndex / 64];
1165 hexDigit >>= (digitBitIndex % 64);
1169 static const char charForHex[16] = {
1170 '0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
1171 '8',
'9',
'a',
'b',
'c',
'd',
'e',
'f'
1173 buffer[stringIndex] = charForHex[hexDigit];
1176 Out.write(buffer.data(), numCharacters);
1179 void CXXNameMangler::mangleFloatLiteral(
QualType T,
const llvm::APFloat &
V) {
1186 void CXXNameMangler::mangleFixedPointLiteral() {
1193 void CXXNameMangler::mangleNullPointer(
QualType T) {
1201 if (
Value.isSigned() &&
Value.isNegative()) {
1203 Value.abs().print(Out,
false);
1205 Value.print(Out,
false);
1209 void CXXNameMangler::mangleNumber(int64_t Number) {
1219 void CXXNameMangler::mangleCallOffset(int64_t NonVirtual, int64_t Virtual) {
1227 mangleNumber(NonVirtual);
1233 mangleNumber(NonVirtual);
1235 mangleNumber(Virtual);
1241 if (!mangleSubstitution(
QualType(TST, 0))) {
1242 mangleTemplatePrefix(TST->getTemplateName());
1247 mangleTemplateArgs(TST->getTemplateName(), TST->getArgs(),
1251 }
else if (
const auto *DTST =
1253 if (!mangleSubstitution(
QualType(DTST, 0))) {
1254 TemplateName Template = getASTContext().getDependentTemplateName(
1255 DTST->getQualifier(), DTST->getIdentifier());
1256 mangleTemplatePrefix(Template);
1261 mangleTemplateArgs(Template, DTST->getArgs(), DTST->getNumArgs());
1262 addSubstitution(
QualType(DTST, 0));
1292 switch (qualifier->
getKind()) {
1304 llvm_unreachable(
"Can't mangle __super specifier");
1308 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1316 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1333 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1340 if (mangleUnresolvedTypeOrSimpleId(
QualType(
type, 0), recursive ?
"N" :
""))
1349 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1367 void CXXNameMangler::mangleUnresolvedName(
1370 unsigned knownArity) {
1371 if (qualifier) mangleUnresolvedPrefix(qualifier);
1372 switch (
name.getNameKind()) {
1375 mangleSourceName(
name.getAsIdentifierInfo());
1380 mangleUnresolvedTypeOrSimpleId(
name.getCXXNameType());
1387 mangleOperatorName(
name, knownArity);
1390 llvm_unreachable(
"Can't mangle a constructor name!");
1392 llvm_unreachable(
"Can't mangle a using directive name!");
1394 llvm_unreachable(
"Can't mangle a deduction guide name!");
1398 llvm_unreachable(
"Can't mangle Objective-C selector names here!");
1404 mangleTemplateArgs(
TemplateName(), TemplateArgs, NumTemplateArgs);
1407 void CXXNameMangler::mangleUnqualifiedName(
1409 unsigned KnownArity,
const AbiTagList *AdditionalAbiTags) {
1417 mangleModuleName(ND);
1419 unsigned Arity = KnownArity;
1420 switch (Name.getNameKind()) {
1425 if (
auto *DD = dyn_cast<DecompositionDecl>(ND)) {
1432 for (
auto *BD : DD->bindings())
1433 mangleSourceName(BD->getDeclName().getAsIdentifierInfo());
1435 writeAbiTags(ND, AdditionalAbiTags);
1439 if (
auto *GD = dyn_cast<MSGuidDecl>(ND)) {
1442 SmallString<
sizeof(
"_GUID_12345678_1234_1234_1234_1234567890ab")> GUID;
1443 llvm::raw_svector_ostream GUIDOS(GUID);
1444 Context.mangleMSGuidDecl(GD, GUIDOS);
1445 Out << GUID.size() << GUID;
1449 if (
auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
1452 mangleValueInTemplateArg(TPO->getType().getUnqualifiedType(),
1453 TPO->getValue(),
true);
1471 if (Context.isInternalLinkageDecl(ND))
1474 auto *FD = dyn_cast<FunctionDecl>(ND);
1475 bool IsRegCall = FD &&
1479 FD && FD->
hasAttr<CUDAGlobalAttr>() &&
1482 mangleDeviceStubName(II);
1484 mangleRegCallName(II);
1486 mangleSourceName(II);
1488 writeAbiTags(ND, AdditionalAbiTags);
1493 assert(ND &&
"mangling empty name without declaration");
1495 if (
const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
1498 Out <<
"12_GLOBAL__N_1";
1503 if (
const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
1517 &&
"Expected anonymous struct or union!");
1524 assert(FD->
getIdentifier() &&
"Data member name isn't an identifier!");
1537 if (isa<ObjCContainerDecl>(ND))
1541 const TagDecl *TD = cast<TagDecl>(ND);
1544 "Typedef should not be in another decl context!");
1545 assert(D->getDeclName().getAsIdentifierInfo() &&
1546 "Typedef was not named!");
1547 mangleSourceName(D->getDeclName().getAsIdentifierInfo());
1548 assert(!AdditionalAbiTags &&
"Type cannot have additional abi tags");
1551 writeAbiTags(TD,
nullptr);
1560 if (
const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) {
1562 Context.getDiscriminatorOverride()(Context.getASTContext(), Record);
1569 ((DeviceNumber && *DeviceNumber > 0) ||
1571 assert(!AdditionalAbiTags &&
1572 "Lambda type cannot have additional abi tags");
1573 mangleLambda(Record);
1579 unsigned UnnamedMangle =
1580 getASTContext().getManglingNumber(TD, Context.isAux());
1582 if (UnnamedMangle > 1)
1583 Out << UnnamedMangle - 2;
1585 writeAbiTags(TD, AdditionalAbiTags);
1591 unsigned AnonStructId = NullOut ? 0 : Context.getAnonymousStructId(TD);
1598 Str += llvm::utostr(AnonStructId);
1608 llvm_unreachable(
"Can't mangle Objective-C selector names here!");
1614 if (
auto Inherited =
1615 cast<CXXConstructorDecl>(ND)->getInheritedConstructor()) {
1616 InheritedFrom = Inherited.getConstructor()->
getParent();
1617 InheritedTemplateName =
1618 TemplateName(Inherited.getConstructor()->getPrimaryTemplate());
1619 InheritedTemplateArgs =
1620 Inherited.getConstructor()->getTemplateSpecializationArgs();
1626 mangleCXXCtorType(
static_cast<CXXCtorType>(StructorType), InheritedFrom);
1634 if (InheritedTemplateArgs)
1635 mangleTemplateArgs(InheritedTemplateName, *InheritedTemplateArgs);
1637 writeAbiTags(ND, AdditionalAbiTags);
1645 mangleCXXDtorType(
static_cast<CXXDtorType>(StructorType));
1650 writeAbiTags(ND, AdditionalAbiTags);
1654 if (ND && Arity == UnknownArity) {
1655 Arity = cast<FunctionDecl>(ND)->getNumParams();
1658 if (
const auto *MD = dyn_cast<CXXMethodDecl>(ND))
1659 if (!MD->isStatic())
1665 mangleOperatorName(Name, Arity);
1666 writeAbiTags(ND, AdditionalAbiTags);
1670 llvm_unreachable(
"Can't mangle a deduction guide name!");
1673 llvm_unreachable(
"Can't mangle a using directive name!");
1677 void CXXNameMangler::mangleRegCallName(
const IdentifierInfo *II) {
1681 Out << II->
getLength() +
sizeof(
"__regcall3__") - 1 <<
"__regcall3__"
1685 void CXXNameMangler::mangleDeviceStubName(
const IdentifierInfo *II) {
1689 Out << II->
getLength() +
sizeof(
"__device_stub__") - 1 <<
"__device_stub__"
1693 void CXXNameMangler::mangleSourceName(
const IdentifierInfo *II) {
1700 void CXXNameMangler::mangleNestedName(
GlobalDecl GD,
1702 const AbiTagList *AdditionalAbiTags,
1711 if (
const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND)) {
1712 Qualifiers MethodQuals = Method->getMethodQualifiers();
1716 mangleQualifiers(MethodQuals);
1717 mangleRefQualifier(Method->getRefQualifier());
1723 mangleTemplatePrefix(TD, NoFunction);
1726 manglePrefix(DC, NoFunction);
1727 mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
1732 void CXXNameMangler::mangleNestedName(
const TemplateDecl *TD,
1734 unsigned NumTemplateArgs) {
1739 mangleTemplatePrefix(TD);
1740 mangleTemplateArgs(
asTemplateName(TD), TemplateArgs, NumTemplateArgs);
1745 void CXXNameMangler::mangleNestedNameWithClosurePrefix(
1747 const AbiTagList *AdditionalAbiTags) {
1756 mangleClosurePrefix(PrefixND);
1757 mangleUnqualifiedName(GD,
nullptr, AdditionalAbiTags);
1768 if (
auto *CD = dyn_cast<CXXConstructorDecl>(DC))
1770 else if (
auto *DD = dyn_cast<CXXDestructorDecl>(DC))
1777 void CXXNameMangler::mangleLocalName(
GlobalDecl GD,
1778 const AbiTagList *AdditionalAbiTags) {
1785 assert(isa<NamedDecl>(D) || isa<BlockDecl>(D));
1787 const DeclContext *DC = Context.getEffectiveDeclContext(RD ? RD : D);
1792 AbiTagState LocalAbiTags(AbiTags);
1795 mangleObjCMethodName(MD);
1796 else if (
const BlockDecl *BD = dyn_cast<BlockDecl>(DC))
1797 mangleBlockForPrefix(BD);
1803 LocalAbiTags.setUsedAbiTags(LocalAbiTags.getEmittedAbiTags());
1826 mangleNumber(Num - 2);
1835 mangleUnqualifiedName(RD, DC, AdditionalAbiTags);
1836 }
else if (
const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
1837 if (
const NamedDecl *PrefixND = getClosurePrefix(BD))
1838 mangleClosurePrefix(PrefixND,
true );
1840 manglePrefix(Context.getEffectiveDeclContext(BD),
true );
1841 assert(!AdditionalAbiTags &&
"Block cannot have additional abi tags");
1842 mangleUnqualifiedBlock(BD);
1844 const NamedDecl *ND = cast<NamedDecl>(D);
1845 mangleNestedName(GD, Context.getEffectiveDeclContext(ND),
1846 AdditionalAbiTags,
true );
1848 }
else if (
const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
1852 = dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl())) {
1858 mangleNumber(Num - 2);
1863 assert(!AdditionalAbiTags &&
"Block cannot have additional abi tags");
1864 mangleUnqualifiedBlock(BD);
1866 mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
1869 if (
const NamedDecl *ND = dyn_cast<NamedDecl>(RD ? RD : D)) {
1871 if (Context.getNextDiscriminator(ND, disc)) {
1875 Out <<
"__" << disc <<
'_';
1880 void CXXNameMangler::mangleBlockForPrefix(
const BlockDecl *Block) {
1881 if (GetLocalClassDecl(Block)) {
1882 mangleLocalName(Block,
nullptr);
1885 const DeclContext *DC = Context.getEffectiveDeclContext(Block);
1886 if (isLocalContainerContext(DC)) {
1887 mangleLocalName(Block,
nullptr);
1890 if (
const NamedDecl *PrefixND = getClosurePrefix(Block))
1891 mangleClosurePrefix(PrefixND);
1894 mangleUnqualifiedBlock(Block);
1897 void CXXNameMangler::mangleUnqualifiedBlock(
const BlockDecl *Block) {
1900 if (
Decl *Context =
Block->getBlockManglingContextDecl()) {
1901 if (getASTContext().getLangOpts().getClangABICompat() <=
1903 (isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
1904 Context->getDeclContext()->isRecord()) {
1905 const auto *ND = cast<NamedDecl>(Context);
1907 mangleSourceNameWithAbiTags(ND);
1914 unsigned Number =
Block->getBlockManglingNumber();
1918 Number = Context.getBlockId(Block,
false);
1934 void CXXNameMangler::mangleTemplateParamDecl(
const NamedDecl *
Decl) {
1935 if (
auto *Ty = dyn_cast<TemplateTypeParmDecl>(
Decl)) {
1936 if (Ty->isParameterPack())
1939 }
else if (
auto *Tn = dyn_cast<NonTypeTemplateParmDecl>(
Decl)) {
1940 if (Tn->isExpandedParameterPack()) {
1941 for (
unsigned I = 0, N = Tn->getNumExpansionTypes(); I != N; ++I) {
1943 mangleType(Tn->getExpansionType(I));
1947 if (Tn->isParameterPack()) {
1950 T = PackExpansion->getPattern();
1955 }
else if (
auto *Tt = dyn_cast<TemplateTemplateParmDecl>(
Decl)) {
1956 if (Tt->isExpandedParameterPack()) {
1957 for (
unsigned I = 0, N = Tt->getNumExpansionTemplateParameters(); I != N;
1960 for (
auto *Param : *Tt->getExpansionTemplateParameters(I))
1961 mangleTemplateParamDecl(Param);
1965 if (Tt->isParameterPack())
1968 for (
auto *Param : *Tt->getTemplateParameters())
1969 mangleTemplateParamDecl(Param);
1975 void CXXNameMangler::mangleLambda(
const CXXRecordDecl *Lambda) {
1979 if (getASTContext().getLangOpts().getClangABICompat() <=
1981 (isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
1982 !isa<ParmVarDecl>(Context)) {
1985 mangleSourceName(Name);
1995 mangleLambdaSig(Lambda);
2010 Context.getDiscriminatorOverride()(Context.getASTContext(), Lambda);
2014 assert(Number > 0 &&
"Lambda should be mangled as an unnamed class");
2016 mangleNumber(Number - 2);
2020 void CXXNameMangler::mangleLambdaSig(
const CXXRecordDecl *Lambda) {
2022 mangleTemplateParamDecl(D);
2025 mangleBareFunctionType(Proto,
false,
2030 switch (qualifier->
getKind()) {
2036 llvm_unreachable(
"Can't mangle __super specifier");
2053 bool Clang14Compat = getASTContext().getLangOpts().getClangABICompat() <=
2055 if (!Clang14Compat && mangleSubstitution(qualifier))
2066 addSubstitution(qualifier);
2070 llvm_unreachable(
"unexpected nested name specifier");
2073 void CXXNameMangler::manglePrefix(
const DeclContext *DC,
bool NoFunction) {
2081 assert(!isa<LinkageSpecDecl>(DC) &&
"prefix cannot be LinkageSpecDecl");
2086 if (NoFunction && isLocalContainerContext(DC))
2089 assert(!isLocalContainerContext(DC));
2091 const NamedDecl *ND = cast<NamedDecl>(DC);
2092 if (mangleSubstitution(ND))
2098 mangleTemplatePrefix(TD);
2100 }
else if (
const NamedDecl *PrefixND = getClosurePrefix(ND)) {
2101 mangleClosurePrefix(PrefixND, NoFunction);
2102 mangleUnqualifiedName(ND,
nullptr,
nullptr);
2104 const DeclContext *DC = Context.getEffectiveDeclContext(ND);
2105 manglePrefix(DC, NoFunction);
2106 mangleUnqualifiedName(ND, DC,
nullptr);
2109 addSubstitution(ND);
2112 void CXXNameMangler::mangleTemplatePrefix(
TemplateName Template) {
2117 return mangleTemplatePrefix(TD);
2120 assert(Dependent &&
"unexpected template name kind");
2124 bool Clang11Compat = getASTContext().getLangOpts().getClangABICompat() <=
2126 if (!Clang11Compat && mangleSubstitution(Template))
2130 manglePrefix(Qualifier);
2132 if (Clang11Compat && mangleSubstitution(Template))
2136 mangleSourceName(
Id);
2138 mangleOperatorName(Dependent->getOperator(), UnknownArity);
2140 addSubstitution(Template);
2143 void CXXNameMangler::mangleTemplatePrefix(
GlobalDecl GD,
2152 if (mangleSubstitution(ND))
2156 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
2157 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
2159 const DeclContext *DC = Context.getEffectiveDeclContext(ND);
2160 manglePrefix(DC, NoFunction);
2161 if (isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND))
2162 mangleUnqualifiedName(GD, DC,
nullptr);
2168 addSubstitution(ND);
2171 const NamedDecl *CXXNameMangler::getClosurePrefix(
const Decl *ND) {
2172 if (getASTContext().getLangOpts().getClangABICompat() <=
2177 if (
auto *Block = dyn_cast<BlockDecl>(ND)) {
2178 Context = dyn_cast_or_null<NamedDecl>(
Block->getBlockManglingContextDecl());
2179 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
2181 Context = dyn_cast_or_null<NamedDecl>(RD->getLambdaContextDecl());
2188 if ((isa<VarDecl>(Context) && cast<VarDecl>(Context)->hasGlobalStorage()) ||
2189 isa<FieldDecl>(Context))
2195 void CXXNameMangler::mangleClosurePrefix(
const NamedDecl *ND,
bool NoFunction) {
2198 if (mangleSubstitution(ND))
2203 mangleTemplatePrefix(TD, NoFunction);
2206 const auto *DC = Context.getEffectiveDeclContext(ND);
2207 manglePrefix(DC, NoFunction);
2208 mangleUnqualifiedName(ND, DC,
nullptr);
2213 addSubstitution(ND);
2222 if (mangleSubstitution(TN))
2235 if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TD))
2236 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
2243 llvm_unreachable(
"can't mangle an overloaded template name as a <type>");
2247 assert(Dependent->isIdentifier());
2251 mangleUnresolvedPrefix(Dependent->getQualifier());
2252 mangleSourceName(Dependent->getIdentifier());
2272 Out <<
"_SUBSTPACK_";
2277 addSubstitution(TN);
2280 bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(
QualType Ty,
2286 case Type::Adjusted:
2289 case Type::BlockPointer:
2290 case Type::LValueReference:
2291 case Type::RValueReference:
2292 case Type::MemberPointer:
2293 case Type::ConstantArray:
2294 case Type::IncompleteArray:
2295 case Type::VariableArray:
2296 case Type::DependentSizedArray:
2297 case Type::DependentAddressSpace:
2298 case Type::DependentVector:
2299 case Type::DependentSizedExtVector:
2301 case Type::ExtVector:
2302 case Type::ConstantMatrix:
2303 case Type::DependentSizedMatrix:
2304 case Type::FunctionProto:
2305 case Type::FunctionNoProto:
2307 case Type::Attributed:
2308 case Type::BTFTagAttributed:
2310 case Type::DeducedTemplateSpecialization:
2311 case Type::PackExpansion:
2312 case Type::ObjCObject:
2313 case Type::ObjCInterface:
2314 case Type::ObjCObjectPointer:
2315 case Type::ObjCTypeParam:
2318 case Type::MacroQualified:
2320 case Type::DependentBitInt:
2321 llvm_unreachable(
"type is illegal as a nested name specifier");
2323 case Type::SubstTemplateTypeParmPack:
2328 Out <<
"_SUBSTPACK_";
2335 case Type::TypeOfExpr:
2337 case Type::Decltype:
2338 case Type::TemplateTypeParm:
2339 case Type::UnaryTransform:
2340 case Type::SubstTemplateTypeParm:
2354 mangleSourceNameWithAbiTags(cast<TypedefType>(Ty)->getDecl());
2357 case Type::UnresolvedUsing:
2358 mangleSourceNameWithAbiTags(
2359 cast<UnresolvedUsingType>(Ty)->getDecl());
2364 mangleSourceNameWithAbiTags(cast<TagType>(Ty)->getDecl());
2367 case Type::TemplateSpecialization: {
2369 cast<TemplateSpecializationType>(Ty);
2378 assert(TD &&
"no template for template specialization type");
2379 if (isa<TemplateTemplateParmDecl>(TD))
2380 goto unresolvedType;
2382 mangleSourceNameWithAbiTags(TD);
2389 llvm_unreachable(
"invalid base for a template specialization type");
2403 Out <<
"_SUBSTPACK_";
2408 assert(TD && !isa<TemplateTemplateParmDecl>(TD));
2409 mangleSourceNameWithAbiTags(TD);
2423 case Type::InjectedClassName:
2424 mangleSourceNameWithAbiTags(
2425 cast<InjectedClassNameType>(Ty)->getDecl());
2428 case Type::DependentName:
2429 mangleSourceName(cast<DependentNameType>(Ty)->
getIdentifier());
2432 case Type::DependentTemplateSpecialization: {
2434 cast<DependentTemplateSpecializationType>(Ty);
2435 TemplateName Template = getASTContext().getDependentTemplateName(
2443 return mangleUnresolvedTypeOrSimpleId(cast<UsingType>(Ty)->desugar(),
2445 case Type::Elaborated:
2446 return mangleUnresolvedTypeOrSimpleId(
2447 cast<ElaboratedType>(Ty)->getNamedType(), Prefix);
2453 void CXXNameMangler::mangleOperatorName(
DeclarationName Name,
unsigned Arity) {
2454 switch (Name.getNameKind()) {
2463 llvm_unreachable(
"Not an operator name");
2468 mangleType(Name.getCXXNameType());
2473 mangleSourceName(Name.getCXXLiteralIdentifier());
2477 mangleOperatorName(Name.getCXXOverloadedOperator(), Arity);
2486 case OO_New: Out <<
"nw";
break;
2488 case OO_Array_New: Out <<
"na";
break;
2490 case OO_Delete: Out <<
"dl";
break;
2492 case OO_Array_Delete: Out <<
"da";
break;
2496 Out << (Arity == 1?
"ps" :
"pl");
break;
2500 Out << (Arity == 1?
"ng" :
"mi");
break;
2504 Out << (Arity == 1?
"ad" :
"an");
break;
2509 Out << (Arity == 1?
"de" :
"ml");
break;
2511 case OO_Tilde: Out <<
"co";
break;
2513 case OO_Slash: Out <<
"dv";
break;
2515 case OO_Percent: Out <<
"rm";
break;
2517 case OO_Pipe: Out <<
"or";
break;
2519 case OO_Caret: Out <<
"eo";
break;
2521 case OO_Equal: Out <<
"aS";
break;
2523 case OO_PlusEqual: Out <<
"pL";
break;
2525 case OO_MinusEqual: Out <<
"mI";
break;
2527 case OO_StarEqual: Out <<
"mL";
break;
2529 case OO_SlashEqual: Out <<
"dV";
break;
2531 case OO_PercentEqual: Out <<
"rM";
break;
2533 case OO_AmpEqual: Out <<
"aN";
break;
2535 case OO_PipeEqual: Out <<
"oR";
break;
2537 case OO_CaretEqual: Out <<
"eO";
break;
2539 case OO_LessLess: Out <<
"ls";
break;
2541 case OO_GreaterGreater: Out <<
"rs";
break;
2543 case OO_LessLessEqual: Out <<
"lS";
break;
2545 case OO_GreaterGreaterEqual: Out <<
"rS";
break;
2547 case OO_EqualEqual: Out <<
"eq";
break;
2549 case OO_ExclaimEqual: Out <<
"ne";
break;
2551 case OO_Less: Out <<
"lt";
break;
2553 case OO_Greater: Out <<
"gt";
break;
2555 case OO_LessEqual: Out <<
"le";
break;
2557 case OO_GreaterEqual: Out <<
"ge";
break;
2559 case OO_Exclaim: Out <<
"nt";
break;
2561 case OO_AmpAmp: Out <<
"aa";
break;
2563 case OO_PipePipe: Out <<
"oo";
break;
2565 case OO_PlusPlus: Out <<
"pp";
break;
2567 case OO_MinusMinus: Out <<
"mm";
break;
2569 case OO_Comma: Out <<
"cm";
break;
2571 case OO_ArrowStar: Out <<
"pm";
break;
2573 case OO_Arrow: Out <<
"pt";
break;
2575 case OO_Call: Out <<
"cl";
break;
2577 case OO_Subscript: Out <<
"ix";
break;
2582 case OO_Conditional: Out <<
"qu";
break;
2585 case OO_Coawait: Out <<
"aw";
break;
2588 case OO_Spaceship: Out <<
"ss";
break;
2592 llvm_unreachable(
"Not an overloaded operator");
2621 if (TargetAS != 0 ||
2623 ASString =
"AS" + llvm::utostr(TargetAS);
2626 default: llvm_unreachable(
"Not a language specific address space");
2631 ASString =
"CLglobal";
2634 ASString =
"CLdevice";
2637 ASString =
"CLhost";
2640 ASString =
"CLlocal";
2643 ASString =
"CLconstant";
2646 ASString =
"CLprivate";
2649 ASString =
"CLgeneric";
2654 ASString =
"SYglobal";
2657 ASString =
"SYdevice";
2660 ASString =
"SYhost";
2663 ASString =
"SYlocal";
2666 ASString =
"SYprivate";
2670 ASString =
"CUdevice";
2673 ASString =
"CUconstant";
2676 ASString =
"CUshared";
2680 ASString =
"ptr32_sptr";
2683 ASString =
"ptr32_uptr";
2690 if (!ASString.empty())
2691 mangleVendorQualifier(ASString);
2704 mangleVendorQualifier(
"__weak");
2708 mangleVendorQualifier(
"__unaligned");
2720 mangleVendorQualifier(
"__strong");
2724 mangleVendorQualifier(
"__autoreleasing");
2747 void CXXNameMangler::mangleVendorQualifier(StringRef
name) {
2754 switch (RefQualifier) {
2768 void CXXNameMangler::mangleObjCMethodName(
const ObjCMethodDecl *MD) {
2769 Context.mangleObjCMethodNameAsSourceName(MD, Out);
2791 if (DeducedTST->getDeducedType().isNull())
2796 void CXXNameMangler::mangleType(
QualType T) {
2837 = dyn_cast<TemplateSpecializationType>(T))
2855 const Type *ty = split.
Ty;
2857 bool isSubstitutable =
2859 if (isSubstitutable && mangleSubstitution(T))
2864 if (quals && isa<ArrayType>(T)) {
2874 dyn_cast<DependentAddressSpaceType>(ty)) {
2876 mangleQualifiers(splitDAST.
Quals, DAST);
2879 mangleQualifiers(quals);
2887 #define ABSTRACT_TYPE(CLASS, PARENT)
2888 #define NON_CANONICAL_TYPE(CLASS, PARENT) \
2890 llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \
2892 #define TYPE(CLASS, PARENT) \
2894 mangleType(static_cast<const CLASS##Type*>(ty)); \
2896 #include "clang/AST/TypeNodes.inc"
2901 if (isSubstitutable)
2905 void CXXNameMangler::mangleNameOrStandardSubstitution(
const NamedDecl *ND) {
2906 if (!mangleStandardSubstitution(ND))
2910 void CXXNameMangler::mangleType(
const BuiltinType *T) {
2944 case BuiltinType::Void:
2947 case BuiltinType::Bool:
2950 case BuiltinType::Char_U:
2951 case BuiltinType::Char_S:
2954 case BuiltinType::UChar:
2957 case BuiltinType::UShort:
2960 case BuiltinType::UInt:
2963 case BuiltinType::ULong:
2966 case BuiltinType::ULongLong:
2969 case BuiltinType::UInt128:
2972 case BuiltinType::SChar:
2975 case BuiltinType::WChar_S:
2976 case BuiltinType::WChar_U:
2979 case BuiltinType::Char8:
2982 case BuiltinType::Char16:
2985 case BuiltinType::Char32:
2988 case BuiltinType::Short:
2991 case BuiltinType::Int:
2994 case BuiltinType::Long:
2997 case BuiltinType::LongLong:
3000 case BuiltinType::Int128:
3003 case BuiltinType::Float16:
3006 case BuiltinType::ShortAccum:
3007 case BuiltinType::Accum:
3008 case BuiltinType::LongAccum:
3009 case BuiltinType::UShortAccum:
3010 case BuiltinType::UAccum:
3011 case BuiltinType::ULongAccum:
3012 case BuiltinType::ShortFract:
3013 case BuiltinType::Fract:
3014 case BuiltinType::LongFract:
3015 case BuiltinType::UShortFract:
3016 case BuiltinType::UFract:
3017 case BuiltinType::ULongFract:
3018 case BuiltinType::SatShortAccum:
3019 case BuiltinType::SatAccum:
3020 case BuiltinType::SatLongAccum:
3021 case BuiltinType::SatUShortAccum:
3022 case BuiltinType::SatUAccum:
3023 case BuiltinType::SatULongAccum:
3024 case BuiltinType::SatShortFract:
3025 case BuiltinType::SatFract:
3026 case BuiltinType::SatLongFract:
3027 case BuiltinType::SatUShortFract:
3028 case BuiltinType::SatUFract:
3029 case BuiltinType::SatULongFract:
3030 llvm_unreachable(
"Fixed point types are disabled for c++");
3031 case BuiltinType::Half:
3037 case BuiltinType::Double:
3040 case BuiltinType::LongDouble: {
3041 const TargetInfo *TI = getASTContext().getLangOpts().OpenMP &&
3042 getASTContext().getLangOpts().OpenMPIsDevice
3043 ? getASTContext().getAuxTargetInfo()
3044 : &getASTContext().getTargetInfo();
3048 case BuiltinType::Float128: {
3049 const TargetInfo *TI = getASTContext().getLangOpts().OpenMP &&
3050 getASTContext().getLangOpts().OpenMPIsDevice
3051 ? getASTContext().getAuxTargetInfo()
3052 : &getASTContext().getTargetInfo();
3056 case BuiltinType::BFloat16: {
3057 const TargetInfo *TI = &getASTContext().getTargetInfo();
3061 case BuiltinType::Ibm128: {
3062 const TargetInfo *TI = &getASTContext().getTargetInfo();
3066 case BuiltinType::NullPtr:
3070 #define BUILTIN_TYPE(Id, SingletonId)
3071 #define PLACEHOLDER_TYPE(Id, SingletonId) \
3072 case BuiltinType::Id:
3073 #include "clang/AST/BuiltinTypes.def"
3074 case BuiltinType::Dependent:
3076 llvm_unreachable(
"mangling a placeholder type");
3078 case BuiltinType::ObjCId:
3079 Out <<
"11objc_object";
3081 case BuiltinType::ObjCClass:
3082 Out <<
"10objc_class";
3084 case BuiltinType::ObjCSel:
3085 Out <<
"13objc_selector";
3087 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3088 case BuiltinType::Id: \
3089 type_name = "ocl_" #ImgType "_" #Suffix; \
3090 Out << type_name.size() << type_name; \
3092 #include "clang/Basic/OpenCLImageTypes.def"
3093 case BuiltinType::OCLSampler:
3094 Out <<
"11ocl_sampler";
3096 case BuiltinType::OCLEvent:
3097 Out <<
"9ocl_event";
3099 case BuiltinType::OCLClkEvent:
3100 Out <<
"12ocl_clkevent";
3102 case BuiltinType::OCLQueue:
3103 Out <<
"9ocl_queue";
3105 case BuiltinType::OCLReserveID:
3106 Out <<
"13ocl_reserveid";
3108 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
3109 case BuiltinType::Id: \
3110 type_name = "ocl_" #ExtType; \
3111 Out << type_name.size() << type_name; \
3113 #include "clang/Basic/OpenCLExtensionTypes.def"
3117 #define SVE_VECTOR_TYPE(InternalName, MangledName, Id, SingletonId, NumEls, \
3118 ElBits, IsSigned, IsFP, IsBF) \
3119 case BuiltinType::Id: \
3120 type_name = MangledName; \
3121 Out << (type_name == InternalName ? "u" : "") << type_name.size() \
3124 #define SVE_PREDICATE_TYPE(InternalName, MangledName, Id, SingletonId, NumEls) \
3125 case BuiltinType::Id: \
3126 type_name = MangledName; \
3127 Out << (type_name == InternalName ? "u" : "") << type_name.size() \
3130 #include "clang/Basic/AArch64SVEACLETypes.def"
3131 #define PPC_VECTOR_TYPE(Name, Id, Size) \
3132 case BuiltinType::Id: \
3133 type_name = #Name; \
3134 Out << 'u' << type_name.size() << type_name; \
3136 #include "clang/Basic/PPCTypes.def"
3138 #define RVV_TYPE(Name, Id, SingletonId) \
3139 case BuiltinType::Id: \
3141 Out << 'u' << type_name.size() << type_name; \
3143 #include "clang/Basic/RISCVVTypes.def"
3147 StringRef CXXNameMangler::getCallingConvQualifierName(
CallingConv CC) {
3187 return "swiftasynccall";
3189 llvm_unreachable(
"bad calling convention");
3192 void CXXNameMangler::mangleExtFunctionInfo(
const FunctionType *T) {
3201 StringRef CCQualifier = getCallingConvQualifierName(T->
getExtInfo().
getCC());
3202 if (!CCQualifier.empty())
3203 mangleVendorQualifier(CCQualifier);
3210 CXXNameMangler::mangleExtParameterInfo(FunctionProtoType::ExtParameterInfo PI) {
3216 switch (PI.getABI()) {
3229 if (PI.isConsumed())
3230 mangleVendorQualifier(
"ns_consumed");
3232 if (PI.isNoEscape())
3233 mangleVendorQualifier(
"noescape");
3240 mangleExtFunctionInfo(T);
3257 mangleType(ExceptTy);
3268 mangleBareFunctionType(T,
true);
3282 FunctionTypeDepthState saved = FunctionTypeDepth.push();
3284 FunctionTypeDepth.enterResultType();
3286 FunctionTypeDepth.leaveResultType();
3288 FunctionTypeDepth.pop(saved);
3293 bool MangleReturnType,
3297 FunctionTypeDepthState saved = FunctionTypeDepth.push();
3300 if (MangleReturnType) {
3301 FunctionTypeDepth.enterResultType();
3305 mangleVendorQualifier(
"ns_returns_retained");
3310 auto SplitReturnTy = ReturnTy.
split();
3312 ReturnTy = getASTContext().getQualifiedType(SplitReturnTy);
3314 mangleType(ReturnTy);
3316 FunctionTypeDepth.leaveResultType();
3323 FunctionTypeDepth.pop(saved);
3328 for (
unsigned I = 0, E = Proto->
getNumParams(); I != E; ++I) {
3341 assert(
Attr->getType() <= 9 &&
Attr->getType() >= 0);
3342 if (
Attr->isDynamic())
3343 Out <<
"U25pass_dynamic_object_size" <<
Attr->getType();
3345 Out <<
"U17pass_object_size" <<
Attr->getType();
3350 FunctionTypeDepth.pop(saved);
3365 void CXXNameMangler::mangleType(
const EnumType *T) {
3366 mangleType(
static_cast<const TagType*
>(T));
3368 void CXXNameMangler::mangleType(
const RecordType *T) {
3369 mangleType(
static_cast<const TagType*
>(T));
3371 void CXXNameMangler::mangleType(
const TagType *T) {
3379 Out <<
'A' << T->
getSize() <<
'_';
3432 mangleType(PointeeType);
3446 Out <<
"_SUBSTPACK_";
3450 void CXXNameMangler::mangleType(
const PointerType *T) {
3472 void CXXNameMangler::mangleType(
const ComplexType *T) {
3480 void CXXNameMangler::mangleNeonVectorType(
const VectorType *T) {
3482 assert(EltType->
isBuiltinType() &&
"Neon vector element not a BuiltinType");
3483 const char *EltName =
nullptr;
3485 switch (cast<BuiltinType>(EltType)->
getKind()) {
3486 case BuiltinType::SChar:
3487 case BuiltinType::UChar:
3488 EltName =
"poly8_t";
3490 case BuiltinType::Short:
3491 case BuiltinType::UShort:
3492 EltName =
"poly16_t";
3494 case BuiltinType::LongLong:
3495 case BuiltinType::ULongLong:
3496 EltName =
"poly64_t";
3498 default: llvm_unreachable(
"unexpected Neon polynomial vector element type");
3501 switch (cast<BuiltinType>(EltType)->
getKind()) {
3502 case BuiltinType::SChar: EltName =
"int8_t";
break;
3503 case BuiltinType::UChar: EltName =
"uint8_t";
break;
3504 case BuiltinType::Short: EltName =
"int16_t";
break;
3505 case BuiltinType::UShort: EltName =
"uint16_t";
break;
3506 case BuiltinType::Int: EltName =
"int32_t";
break;
3507 case BuiltinType::UInt: EltName =
"uint32_t";
break;
3508 case BuiltinType::LongLong: EltName =
"int64_t";
break;
3509 case BuiltinType::ULongLong: EltName =
"uint64_t";
break;
3510 case BuiltinType::Double: EltName =
"float64_t";
break;
3512 case BuiltinType::Half: EltName =
"float16_t";
break;
3513 case BuiltinType::BFloat16: EltName =
"bfloat16_t";
break;
3515 llvm_unreachable(
"unexpected Neon vector element type");
3518 const char *BaseName =
nullptr;
3520 getASTContext().getTypeSize(EltType));
3522 BaseName =
"__simd64_";
3524 assert(BitSize == 128 &&
"Neon vector type not 64 or 128 bits");
3525 BaseName =
"__simd128_";
3527 Out << strlen(BaseName) + strlen(EltName);
3528 Out << BaseName << EltName;
3535 "cannot mangle this dependent neon vector type yet");
3541 case BuiltinType::SChar:
3543 case BuiltinType::Short:
3545 case BuiltinType::Int:
3547 case BuiltinType::Long:
3548 case BuiltinType::LongLong:
3550 case BuiltinType::UChar:
3552 case BuiltinType::UShort:
3554 case BuiltinType::UInt:
3556 case BuiltinType::ULong:
3557 case BuiltinType::ULongLong:
3559 case BuiltinType::Half:
3563 case BuiltinType::Double:
3565 case BuiltinType::BFloat16:
3568 llvm_unreachable(
"Unexpected vector element base type");
3575 void CXXNameMangler::mangleAArch64NeonVectorType(
const VectorType *T) {
3577 assert(EltType->
isBuiltinType() &&
"Neon vector element not a BuiltinType");
3582 assert((BitSize == 64 || BitSize == 128) &&
3583 "Neon vector type not 64 or 128 bits");
3587 switch (cast<BuiltinType>(EltType)->
getKind()) {
3588 case BuiltinType::UChar:
3591 case BuiltinType::UShort:
3594 case BuiltinType::ULong:
3595 case BuiltinType::ULongLong:
3599 llvm_unreachable(
"unexpected Neon polynomial vector element type");
3605 (
"__" + EltName +
"x" + Twine(T->
getNumElements()) +
"_t").str();
3612 "cannot mangle this dependent neon vector type yet");
3640 void CXXNameMangler::mangleAArch64FixedSveVectorType(
const VectorType *T) {
3643 "expected fixed-length SVE vector!");
3647 "expected builtin type for fixed-length SVE vector!");
3650 switch (cast<BuiltinType>(EltType)->
getKind()) {
3651 case BuiltinType::SChar:
3654 case BuiltinType::UChar: {
3661 case BuiltinType::Short:
3664 case BuiltinType::UShort:
3667 case BuiltinType::Int:
3670 case BuiltinType::UInt:
3673 case BuiltinType::Long:
3676 case BuiltinType::ULong:
3679 case BuiltinType::Half:
3685 case BuiltinType::Double:
3688 case BuiltinType::BFloat16:
3692 llvm_unreachable(
"unexpected element type for fixed-length SVE vector!");
3695 unsigned VecSizeInBits = getASTContext().getTypeInfo(T).Width;
3701 << VecSizeInBits <<
"EE";
3704 void CXXNameMangler::mangleAArch64FixedSveVectorType(
3709 "cannot mangle this dependent fixed-length SVE vector type yet");
3721 void CXXNameMangler::mangleType(
const VectorType *T) {
3724 llvm::Triple
Target = getASTContext().getTargetInfo().getTriple();
3725 llvm::Triple::ArchType Arch =
3726 getASTContext().getTargetInfo().getTriple().getArch();
3727 if ((Arch == llvm::Triple::aarch64 ||
3728 Arch == llvm::Triple::aarch64_be) && !
Target.isOSDarwin())
3729 mangleAArch64NeonVectorType(T);
3731 mangleNeonVectorType(T);
3735 mangleAArch64FixedSveVectorType(T);
3750 llvm::Triple
Target = getASTContext().getTargetInfo().getTriple();
3751 llvm::Triple::ArchType Arch =
3752 getASTContext().getTargetInfo().getTriple().getArch();
3753 if ((Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_be) &&
3755 mangleAArch64NeonVectorType(T);
3757 mangleNeonVectorType(T);
3761 mangleAArch64FixedSveVectorType(T);
3777 mangleType(
static_cast<const VectorType*
>(T));
3790 StringRef VendorQualifier =
"matrix_type";
3791 Out <<
"u" << VendorQualifier.size() << VendorQualifier;
3794 auto &ASTCtx = getASTContext();
3795 unsigned BitWidth = ASTCtx.getTypeSize(ASTCtx.getSizeType());
3798 mangleIntegerLiteral(ASTCtx.getSizeType(), Rows);
3801 mangleIntegerLiteral(ASTCtx.getSizeType(), Columns);
3809 StringRef VendorQualifier =
"matrix_type";
3810 Out <<
"u" << VendorQualifier.size() << VendorQualifier;
3821 mangleQualifiers(split.
Quals, T);
3838 Out <<
"U8__kindof";
3843 llvm::raw_svector_ostream QualOS(QualStr);
3844 QualOS <<
"objcproto";
3845 for (
const auto *I : T->
quals()) {
3846 StringRef
name = I->getName();
3849 Out <<
'U' << QualStr.size() << QualStr;
3858 mangleType(typeArg);
3864 Out <<
"U13block_pointer";
3879 if (mangleSubstitution(
QualType(T, 0)))
3932 getASTContext().getDependentTemplateName(T->
getQualifier(),
3934 mangleTemplatePrefix(Prefix);
3943 void CXXNameMangler::mangleType(
const TypeOfType *T) {
3955 void CXXNameMangler::mangleType(
const DecltypeType *T) {
3966 if (isa<DeclRefExpr>(E) ||
3967 isa<MemberExpr>(E) ||
3968 isa<UnresolvedLookupExpr>(E) ||
3969 isa<DependentScopeDeclRefExpr>(E) ||
3970 isa<CXXDependentScopeMemberExpr>(E) ||
3971 isa<UnresolvedMemberExpr>(E))
3975 mangleExpression(E);
3995 void CXXNameMangler::mangleType(
const AutoType *T) {
3997 "Deduced AutoType shouldn't be handled here!");
3999 "shouldn't need to mangle __auto_type!");
4008 return mangleType(Deduced);
4011 assert(TD &&
"shouldn't form deduced TST unless we know we have a template");
4013 if (mangleSubstitution(TD))
4017 addSubstitution(TD);
4020 void CXXNameMangler::mangleType(
const AtomicType *T) {
4027 void CXXNameMangler::mangleType(
const PipeType *T) {
4034 void CXXNameMangler::mangleType(
const BitIntType *T) {
4050 void CXXNameMangler::mangleIntegerLiteral(
QualType T,
4058 Out << (
Value.getBoolValue() ?
'1' :
'0');
4060 mangleNumber(
Value);
4066 void CXXNameMangler::mangleMemberExprBase(
const Expr *
Base,
bool IsArrow) {
4069 if (!RT->getDecl()->isAnonymousStructOrUnion())
4071 const auto *ME = dyn_cast<MemberExpr>(
Base);
4074 Base = ME->getBase();
4075 IsArrow = ME->isArrow();
4078 if (
Base->isImplicitCXXThis()) {
4084 Out << (IsArrow ?
"pt" :
"dt");
4085 mangleExpression(
Base);
4090 void CXXNameMangler::mangleMemberExpr(
const Expr *base,
4096 unsigned NumTemplateArgs,
4101 mangleMemberExprBase(base, isArrow);
4102 mangleUnresolvedName(qualifier,
member, TemplateArgs, NumTemplateArgs, arity);
4115 if (callee == fn)
return false;
4119 if (!lookup)
return false;
4136 void CXXNameMangler::mangleCastExpression(
const Expr *E, StringRef CastEncoding) {
4138 Out << CastEncoding;
4143 void CXXNameMangler::mangleInitListElements(
const InitListExpr *InitList) {
4145 InitList = Syntactic;
4146 for (
unsigned i = 0, e = InitList->
getNumInits(); i != e; ++i)
4147 mangleExpression(InitList->
getInit(i));
4150 void CXXNameMangler::mangleExpression(
const Expr *E,
unsigned Arity,
4151 bool AsTemplateArg) {
4180 QualType ImplicitlyConvertedToType;
4184 bool IsPrimaryExpr =
true;
4185 auto NotPrimaryExpr = [&] {
4186 if (AsTemplateArg && IsPrimaryExpr)
4188 IsPrimaryExpr =
false;
4191 auto MangleDeclRefExpr = [&](
const NamedDecl *D) {
4192 switch (D->getKind()) {
4202 mangleFunctionParam(cast<ParmVarDecl>(D));
4205 case Decl::EnumConstant: {
4212 case Decl::NonTypeTemplateParm:
4226 #define ABSTRACT_STMT(Type)
4227 #define EXPR(Type, Base)
4228 #define STMT(Type, Base) \
4229 case Expr::Type##Class:
4230 #include "clang/AST/StmtNodes.inc"
4235 case Expr::AddrLabelExprClass:
4236 case Expr::DesignatedInitUpdateExprClass:
4237 case Expr::ImplicitValueInitExprClass:
4238 case Expr::ArrayInitLoopExprClass:
4239 case Expr::ArrayInitIndexExprClass:
4240 case Expr::NoInitExprClass:
4241 case Expr::ParenListExprClass:
4242 case Expr::MSPropertyRefExprClass:
4243 case Expr::MSPropertySubscriptExprClass:
4244 case Expr::TypoExprClass:
4245 case Expr::RecoveryExprClass:
4246 case Expr::OMPArraySectionExprClass:
4247 case Expr::OMPArrayShapingExprClass:
4248 case Expr::OMPIteratorExprClass:
4249 case Expr::CXXInheritedCtorInitExprClass:
4250 llvm_unreachable(
"unexpected statement kind");
4252 case Expr::ConstantExprClass:
4253 E = cast<ConstantExpr>(E)->getSubExpr();
4257 case Expr::BlockExprClass:
4258 case Expr::ChooseExprClass:
4259 case Expr::CompoundLiteralExprClass:
4260 case Expr::ExtVectorElementExprClass:
4261 case Expr::GenericSelectionExprClass:
4262 case Expr::ObjCEncodeExprClass:
4263 case Expr::ObjCIsaExprClass:
4264 case Expr::ObjCIvarRefExprClass:
4265 case Expr::ObjCMessageExprClass:
4266 case Expr::ObjCPropertyRefExprClass:
4267 case Expr::ObjCProtocolExprClass:
4268 case Expr::ObjCSelectorExprClass:
4269 case Expr::ObjCStringLiteralClass:
4270 case Expr::ObjCBoxedExprClass:
4271 case Expr::ObjCArrayLiteralClass:
4272 case Expr::ObjCDictionaryLiteralClass:
4273 case Expr::ObjCSubscriptRefExprClass:
4274 case Expr::ObjCIndirectCopyRestoreExprClass:
4275 case Expr::ObjCAvailabilityCheckExprClass:
4276 case Expr::OffsetOfExprClass:
4277 case Expr::PredefinedExprClass:
4278 case Expr::ShuffleVectorExprClass:
4279 case Expr::ConvertVectorExprClass:
4280 case Expr::StmtExprClass:
4281 case Expr::TypeTraitExprClass:
4282 case Expr::RequiresExprClass:
4283 case Expr::ArrayTypeTraitExprClass:
4284 case Expr::ExpressionTraitExprClass:
4285 case Expr::VAArgExprClass:
4286 case Expr::CUDAKernelCallExprClass:
4287 case Expr::AsTypeExprClass:
4288 case Expr::PseudoObjectExprClass:
4289 case Expr::AtomicExprClass:
4290 case Expr::SourceLocExprClass:
4291 case Expr::BuiltinBitCastExprClass:
4298 "cannot yet mangle expression type %0");
4306 case Expr::CXXUuidofExprClass: {
4311 if (Context.getASTContext().
getLangOpts().getClangABICompat() >
4313 Out <<
"u8__uuidof";
4322 Out <<
"u8__uuidoft";
4326 Out <<
"u8__uuidofz";
4327 mangleExpression(UuidExp);
4334 case Expr::BinaryConditionalOperatorClass: {
4339 "?: operator with omitted middle operand cannot be mangled");
4346 case Expr::OpaqueValueExprClass:
4347 llvm_unreachable(
"cannot mangle opaque value; mangling wrong thing?");
4349 case Expr::InitListExprClass: {
4352 mangleInitListElements(cast<InitListExpr>(E));
4357 case Expr::DesignatedInitExprClass: {
4359 auto *DIE = cast<DesignatedInitExpr>(E);
4360 for (
const auto &
Designator : DIE->designators()) {
4366 mangleExpression(DIE->getArrayIndex(
Designator));
4369 "unknown designator kind");
4371 mangleExpression(DIE->getArrayRangeStart(
Designator));
4372 mangleExpression(DIE->getArrayRangeEnd(
Designator));
4375 mangleExpression(DIE->getInit());
4379 case Expr::CXXDefaultArgExprClass:
4380 E = cast<CXXDefaultArgExpr>(E)->getExpr();
4383 case Expr::CXXDefaultInitExprClass:
4384 E = cast<CXXDefaultInitExpr>(E)->getExpr();
4387 case Expr::CXXStdInitializerListExprClass:
4388 E = cast<CXXStdInitializerListExpr>(E)->getSubExpr();
4391 case Expr::SubstNonTypeTemplateParmExprClass:
4392 E = cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement();
4395 case Expr::UserDefinedLiteralClass:
4398 case Expr::CXXMemberCallExprClass:
4399 case Expr::CallExprClass: {
4401 const CallExpr *CE = cast<CallExpr>(E);
4420 if (isa<PackExpansionExpr>(Arg))
4421 CallArity = UnknownArity;
4423 mangleExpression(CE->
getCallee(), CallArity);
4425 mangleExpression(Arg);
4430 case Expr::CXXNewExprClass: {
4434 Out << (New->
isArray() ?
"na" :
"nw");
4437 mangleExpression(*I);
4451 mangleExpression(*I);
4452 }
else if (
const ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init)) {
4453 for (
unsigned i = 0, e = PLE->getNumExprs(); i != e; ++i)
4454 mangleExpression(PLE->getExpr(i));
4456 isa<InitListExpr>(Init)) {
4458 mangleInitListElements(cast<InitListExpr>(Init));
4460 mangleExpression(Init);
4466 case Expr::CXXPseudoDestructorExprClass: {
4468 const auto *PDE = cast<CXXPseudoDestructorExpr>(E);
4469 if (
const Expr *
Base = PDE->getBase())
4470 mangleMemberExprBase(
Base, PDE->isArrow());
4474 mangleUnresolvedPrefix(Qualifier,
4476 mangleUnresolvedTypeOrSimpleId(ScopeInfo->getType());
4480 if (!mangleUnresolvedTypeOrSimpleId(ScopeInfo->getType()))
4483 }
else if (Qualifier) {
4484 mangleUnresolvedPrefix(Qualifier);
4488 QualType DestroyedType = PDE->getDestroyedType();
4489 mangleUnresolvedTypeOrSimpleId(DestroyedType);
4493 case Expr::MemberExprClass: {
4504 case Expr::UnresolvedMemberExprClass: {
4515 case Expr::CXXDependentScopeMemberExprClass: {
4518 = cast<CXXDependentScopeMemberExpr>(E);
4528 case Expr::UnresolvedLookupExprClass: {
4537 case Expr::CXXUnresolvedConstructExprClass: {
4543 assert(N == 1 &&
"unexpected form for list initialization");
4544 auto *IL = cast<InitListExpr>(CE->
getArg(0));
4547 mangleInitListElements(IL);
4554 if (N != 1) Out <<
'_';
4555 for (
unsigned I = 0; I != N; ++I) mangleExpression(CE->
getArg(I));
4556 if (N != 1) Out <<
'E';
4560 case Expr::CXXConstructExprClass: {
4562 const auto *CE = cast<CXXConstructExpr>(E);
4567 "implicit CXXConstructExpr must have one argument");
4568 E = cast<CXXConstructExpr>(E)->getArg(0);
4574 mangleExpression(E);
4579 case Expr::CXXTemporaryObjectExprClass: {
4581 const auto *CE = cast<CXXTemporaryObjectExpr>(E);
4590 if (!List && N != 1)
4592 if (CE->isStdInitListInitialization()) {
4598 auto *ILE = cast<InitListExpr>(SILE->getSubExpr()->IgnoreImplicit());
4599 mangleInitListElements(ILE);
4602 mangleExpression(E);
4609 case Expr::CXXScalarValueInitExprClass:
4616 case Expr::CXXNoexceptExprClass:
4619 mangleExpression(cast<CXXNoexceptExpr>(E)->getOperand());
4622 case Expr::UnaryExprOrTypeTraitExprClass: {
4637 : ImplicitlyConvertedToType;
4639 mangleIntegerLiteral(T,
V);
4645 auto MangleAlignofSizeofArg = [&] {
4658 MangleAlignofSizeofArg();
4660 case UETT_PreferredAlignOf:
4664 if (Context.getASTContext().
getLangOpts().getClangABICompat() >
4666 Out <<
"u11__alignof__";
4677 MangleAlignofSizeofArg();
4679 case UETT_VecStep: {
4682 "cannot yet mangle vec_step expression");
4686 case UETT_OpenMPRequiredSimdAlign: {
4690 "cannot yet mangle __builtin_omp_required_simd_align expression");
4698 case Expr::CXXThrowExprClass: {
4712 case Expr::CXXTypeidExprClass: {
4727 case Expr::CXXDeleteExprClass: {
4738 case Expr::UnaryOperatorClass: {
4747 case Expr::ArraySubscriptExprClass: {
4754 mangleExpression(AE->
getLHS());
4755 mangleExpression(AE->
getRHS());
4759 case Expr::MatrixSubscriptExprClass: {
4763 mangleExpression(ME->
getBase());
4769 case Expr::CompoundAssignOperatorClass:
4770 case Expr::BinaryOperatorClass: {
4778 mangleExpression(BO->
getLHS());
4779 mangleExpression(BO->
getRHS());
4783 case Expr::CXXRewrittenBinaryOperatorClass: {
4787 cast<CXXRewrittenBinaryOperator>(E)->getDecomposedForm();
4790 mangleExpression(Decomposed.
LHS);
4791 mangleExpression(Decomposed.
RHS);
4795 case Expr::ConditionalOperatorClass: {
4798 mangleOperatorName(OO_Conditional, 3);
4799 mangleExpression(CO->
getCond());
4800 mangleExpression(CO->
getLHS(), Arity);
4801 mangleExpression(CO->
getRHS(), Arity);
4805 case Expr::ImplicitCastExprClass: {
4806 ImplicitlyConvertedToType = E->
getType();
4807 E = cast<ImplicitCastExpr>(E)->getSubExpr();
4811 case Expr::ObjCBridgedCastExprClass: {
4815 StringRef
Kind = cast<ObjCBridgedCastExpr>(E)->getBridgeKindName();
4816 Out <<
"v1U" <<
Kind.size() <<
Kind;
4817 mangleCastExpression(E,
"cv");
4821 case Expr::CStyleCastExprClass:
4823 mangleCastExpression(E,
"cv");
4826 case Expr::CXXFunctionalCastExprClass: {
4828 auto *
Sub = cast<ExplicitCastExpr>(E)->getSubExpr()->IgnoreImplicit();
4830 if (
auto *CCE = dyn_cast<CXXConstructExpr>(
Sub))
4831 if (CCE->getParenOrBraceRange().isInvalid())
4832 Sub = CCE->getArg(0)->IgnoreImplicit();
4833 if (
auto *StdInitList = dyn_cast<CXXStdInitializerListExpr>(
Sub))
4834 Sub = StdInitList->getSubExpr()->IgnoreImplicit();
4835 if (
auto *IL = dyn_cast<InitListExpr>(
Sub)) {
4838 mangleInitListElements(IL);
4841 mangleCastExpression(E,
"cv");
4846 case Expr::CXXStaticCastExprClass:
4848 mangleCastExpression(E,
"sc");
4850 case Expr::CXXDynamicCastExprClass:
4852 mangleCastExpression(E,
"dc");
4854 case Expr::CXXReinterpretCastExprClass:
4856 mangleCastExpression(E,
"rc");
4858 case Expr::CXXConstCastExprClass:
4860 mangleCastExpression(E,
"cc");
4862 case Expr::CXXAddrspaceCastExprClass:
4864 mangleCastExpression(E,
"ac");
4867 case Expr::CXXOperatorCallExprClass: {
4876 for (
unsigned i = 0; i != NumArgs; ++i)
4877 mangleExpression(CE->
getArg(i));
4881 case Expr::ParenExprClass:
4882 E = cast<ParenExpr>(E)->getSubExpr();
4885 case Expr::ConceptSpecializationExprClass: {
4888 auto *CSE = cast<ConceptSpecializationExpr>(E);
4889 mangleTemplateName(CSE->getNamedConcept(),
4890 CSE->getTemplateArguments().data(),
4891 CSE->getTemplateArguments().size());
4896 case Expr::DeclRefExprClass:
4898 MangleDeclRefExpr(cast<DeclRefExpr>(E)->getDecl());
4901 case Expr::SubstNonTypeTemplateParmPackExprClass:
4907 Out <<
"_SUBSTPACK_";
4910 case Expr::FunctionParmPackExprClass: {
4914 Out <<
"v110_SUBSTPACK";
4919 case Expr::DependentScopeDeclRefExprClass: {
4928 case Expr::CXXBindTemporaryExprClass:
4929 E = cast<CXXBindTemporaryExpr>(E)->getSubExpr();
4932 case Expr::ExprWithCleanupsClass:
4933 E = cast<ExprWithCleanups>(E)->getSubExpr();
4936 case Expr::FloatingLiteralClass: {
4943 case Expr::FixedPointLiteralClass:
4945 mangleFixedPointLiteral();
4948 case Expr::CharacterLiteralClass:
4952 Out << cast<CharacterLiteral>(E)->getValue();
4957 case Expr::ObjCBoolLiteralExprClass:
4960 Out << (cast<ObjCBoolLiteralExpr>(E)->getValue() ?
'1' :
'0');
4964 case Expr::CXXBoolLiteralExprClass:
4967 Out << (cast<CXXBoolLiteralExpr>(E)->getValue() ?
'1' :
'0');
4971 case Expr::IntegerLiteralClass: {
4975 Value.setIsSigned(
true);
4980 case Expr::ImaginaryLiteralClass: {
4988 dyn_cast<FloatingLiteral>(IE->
getSubExpr())) {
4990 mangleFloat(llvm::APFloat(Imag->getValue().getSemantics()));
4992 mangleFloat(Imag->getValue());
4997 Value.setIsSigned(
true);
4998 mangleNumber(
Value);
5004 case Expr::StringLiteralClass: {
5008 assert(isa<ConstantArrayType>(E->
getType()));
5014 case Expr::GNUNullExprClass:
5020 case Expr::CXXNullPtrLiteralExprClass: {
5026 case Expr::LambdaExprClass: {
5031 mangleType(Context.getASTContext().
getRecordType(cast<LambdaExpr>(E)->getLambdaClass()));
5036 case Expr::PackExpansionExprClass:
5039 mangleExpression(cast<PackExpansionExpr>(E)->getPattern());
5042 case Expr::SizeOfPackExprClass: {
5044 auto *SPE = cast<SizeOfPackExpr>(E);
5045 if (SPE->isPartiallySubstituted()) {
5047 for (
const auto &A : SPE->getPartialArguments())
5048 mangleTemplateArg(A,
false);
5056 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
5058 = dyn_cast<NonTypeTemplateParmDecl>(Pack))
5059 mangleTemplateParameter(NTTP->getDepth(), NTTP->getIndex());
5061 = dyn_cast<TemplateTemplateParmDecl>(Pack))
5062 mangleTemplateParameter(TempTP->getDepth(), TempTP->getIndex());
5064 mangleFunctionParam(cast<ParmVarDecl>(Pack));
5068 case Expr::MaterializeTemporaryExprClass:
5069 E = cast<MaterializeTemporaryExpr>(E)->getSubExpr();
5072 case Expr::CXXFoldExprClass: {
5074 auto *FE = cast<CXXFoldExpr>(E);
5075 if (FE->isLeftFold())
5076 Out << (FE->getInit() ?
"fL" :
"fl");
5078 Out << (FE->getInit() ?
"fR" :
"fr");
5080 if (FE->getOperator() == BO_PtrMemD)
5088 mangleExpression(FE->getLHS());
5090 mangleExpression(FE->getRHS());
5094 case Expr::CXXThisExprClass:
5099 case Expr::CoawaitExprClass:
5102 Out <<
"v18co_await";
5103 mangleExpression(cast<CoawaitExpr>(E)->getOperand());
5106 case Expr::DependentCoawaitExprClass:
5109 Out <<
"v18co_await";
5110 mangleExpression(cast<DependentCoawaitExpr>(E)->getOperand());
5113 case Expr::CoyieldExprClass:
5116 Out <<
"v18co_yield";
5117 mangleExpression(cast<CoawaitExpr>(E)->getOperand());
5119 case Expr::SYCLUniqueStableNameExprClass: {
5120 const auto *USN = cast<SYCLUniqueStableNameExpr>(E);
5123 Out <<
"u33__builtin_sycl_unique_stable_name";
5124 mangleType(USN->getTypeSourceInfo()->getType());
5131 if (AsTemplateArg && !IsPrimaryExpr)
5163 void CXXNameMangler::mangleFunctionParam(
const ParmVarDecl *parm) {
5170 assert(parmDepth < FunctionTypeDepth.getDepth());
5171 unsigned nestingDepth = FunctionTypeDepth.getDepth() - parmDepth;
5172 if (FunctionTypeDepth.isInResultType())
5175 if (nestingDepth == 0) {
5178 Out <<
"fL" << (nestingDepth - 1) <<
'p';
5186 &&
"parameter's type is still an array type?");
5189 dyn_cast<DependentAddressSpaceType>(parm->
getType())) {
5196 if (parmIndex != 0) {
5197 Out << (parmIndex - 1);
5202 void CXXNameMangler::mangleCXXCtorType(
CXXCtorType T,
5225 llvm_unreachable(
"closure constructors don't exist for the Itanium ABI!");
5228 mangleName(InheritedFrom);
5231 void CXXNameMangler::mangleCXXDtorType(
CXXDtorType T) {
5256 struct TemplateArgManglingInfo {
5258 bool SeenPackExpansionIntoNonPack =
false;
5259 const NamedDecl *UnresolvedExpandedPack =
nullptr;
5263 ResolvedTemplate = TD;
5273 if (!ResolvedTemplate || SeenPackExpansionIntoNonPack)
5277 const NamedDecl *Param = UnresolvedExpandedPack;
5280 "no parameter for argument");
5289 "failed to form pack argument for parameter pack");
5290 UnresolvedExpandedPack = Param;
5299 SeenPackExpansionIntoNonPack =
true;
5306 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(ResolvedTemplate)) {
5307 auto *RD = dyn_cast<CXXRecordDecl>(FTD->getDeclContext());
5308 if (!RD || !RD->isGenericLambda())
5319 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param);
5320 return NTTP && NTTP->getType()->getContainedDeducedType();
5325 void CXXNameMangler::mangleTemplateArgs(
TemplateName TN,
5327 unsigned NumTemplateArgs) {
5330 TemplateArgManglingInfo Info(TN);
5331 for (
unsigned i = 0; i != NumTemplateArgs; ++i)
5333 Info.needExactType(i, TemplateArgs[i].getArgument()));
5337 void CXXNameMangler::mangleTemplateArgs(
TemplateName TN,
5341 TemplateArgManglingInfo Info(TN);
5342 for (
unsigned i = 0, e = AL.
size(); i != e; ++i)
5343 mangleTemplateArg(AL[i], Info.needExactType(i, AL[i]));
5347 void CXXNameMangler::mangleTemplateArgs(
TemplateName TN,
5349 unsigned NumTemplateArgs) {
5352 TemplateArgManglingInfo Info(TN);
5353 for (
unsigned i = 0; i != NumTemplateArgs; ++i)
5354 mangleTemplateArg(TemplateArgs[i], Info.needExactType(i, TemplateArgs[i]));
5358 void CXXNameMangler::mangleTemplateArg(
TemplateArgument A,
bool NeedExactType) {
5368 llvm_unreachable(
"Cannot mangle NULL template argument");
5395 auto *TPO = cast<TemplateParamObjectDecl>(D);
5396 mangleValueInTemplateArg(TPO->getType().getUnqualifiedType(),
5397 TPO->getValue(),
true,
5433 mangleTemplateArg(
P, NeedExactType);
5439 void CXXNameMangler::mangleTemplateArgExpr(
const Expr *E) {
5442 mangleExpression(E, UnknownArity,
true);
5457 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
5459 if (isa<VarDecl>(D) || isa<FunctionDecl>(D)) {
5467 mangleExpression(E);
5480 switch (
V.getKind()) {
5488 assert(RD &&
"unexpected type for record value");
5497 if (!FD->isUnnamedBitfield() &&
5507 assert(RD &&
"unexpected type for union value");
5510 if (!FD->isUnnamedBitfield())
5521 for (
unsigned I = 0, N =
V.getArrayInitializedElts(); I != N; ++I)
5529 for (
unsigned I = 0, N =
V.getVectorLength(); I != N; ++I)
5539 return V.getFloat().isPosZero();
5542 return !
V.getFixedPoint().getValue();
5545 return V.getComplexFloatReal().isPosZero() &&
5546 V.getComplexFloatImag().isPosZero();
5549 return !
V.getComplexIntReal() && !
V.getComplexIntImag();
5552 return V.isNullPointer();
5555 return !
V.getMemberPointerDecl();
5558 llvm_unreachable(
"Unhandled APValue::ValueKind enum");
5565 T = AT->getElementType();
5567 dyn_cast<FieldDecl>(E.getAsBaseOrMember().getPointer()))
5571 cast<CXXRecordDecl>(E.getAsBaseOrMember().getPointer()));
5612 Diags.
Report(UnionLoc, DiagID);
5617 void CXXNameMangler::mangleValueInTemplateArg(
QualType T,
const APValue &
V,
5619 bool NeedExactType) {
5622 T = getASTContext().getUnqualifiedArrayType(T, Quals);
5625 bool IsPrimaryExpr =
true;
5626 auto NotPrimaryExpr = [&] {
5627 if (TopLevel && IsPrimaryExpr)
5629 IsPrimaryExpr =
false;
5633 switch (
V.getKind()) {
5642 llvm_unreachable(
"unexpected value kind in template argument");
5646 assert(RD &&
"unexpected type for record value");
5653 (Fields.back()->isUnnamedBitfield() ||
5655 V.getStructField(Fields.back()->getFieldIndex())))) {
5659 if (Fields.empty()) {
5660 while (!Bases.empty() &&
5662 V.getStructBase(Bases.size() - 1)))
5663 Bases = Bases.drop_back();
5670 for (
unsigned I = 0, N = Bases.size(); I != N; ++I)
5671 mangleValueInTemplateArg(Bases[I].getType(),
V.getStructBase(I),
false);
5672 for (
unsigned I = 0, N = Fields.size(); I != N; ++I) {
5673 if (Fields[I]->isUnnamedBitfield())
5675 mangleValueInTemplateArg(Fields[I]->getType(),
5676 V.getStructField(Fields[I]->getFieldIndex()),
5703 mangleSourceName(II);
5704 mangleValueInTemplateArg(FD->
getType(),
V.getUnionValue(),
false);
5718 unsigned N =
V.getArraySize();
5720 N =
V.getArrayInitializedElts();
5725 for (
unsigned I = 0; I != N; ++I) {
5726 const APValue &Elem = I <
V.getArrayInitializedElts()
5727 ?
V.getArrayInitializedElt(I)
5728 :
V.getArrayFiller();
5729 mangleValueInTemplateArg(ElemT, Elem,
false);
5741 unsigned N =
V.getVectorLength();
5744 for (
unsigned I = 0; I != N; ++I)
5745 mangleValueInTemplateArg(VT->
getElementType(),
V.getVectorElt(I),
false);
5751 mangleIntegerLiteral(T,
V.getInt());
5755 mangleFloatLiteral(T,
V.getFloat());
5759 mangleFixedPointLiteral();
5767 if (!
V.getComplexFloatReal().isPosZero() ||
5768 !
V.getComplexFloatImag().isPosZero())
5770 if (!
V.getComplexFloatImag().isPosZero())
5781 if (
V.getComplexIntReal().getBoolValue() ||
5782 V.getComplexIntImag().getBoolValue())
5784 if (
V.getComplexIntImag().getBoolValue())
5793 "unexpected type for LValue template arg");
5795 if (
V.isNullPointer()) {
5796 mangleNullPointer(T);
5817 Out <<
Offset.getQuantity() <<
'E';
5825 if (!
V.hasLValuePath()) {
5839 if (!
V.getLValuePath().empty() ||
V.isLValueOnePastTheEnd()) {
5856 if (NeedExactType &&
5879 mangleExpression(E);
5883 mangleType(
QualType(TI.getType(), 0));
5886 llvm_unreachable(
"unexpected lvalue base kind in template argument");
5896 mangleNumber(
V.getLValueOffset().getQuantity());
5903 if (!
V.getLValueOffset().isZero())
5904 mangleNumber(
V.getLValueOffset().getQuantity());
5908 bool OnePastTheEnd =
V.isLValueOnePastTheEnd();
5912 if (
auto *CAT = dyn_cast<ConstantArrayType>(AT))
5913 OnePastTheEnd |= CAT->getSize() == E.getAsArrayIndex();
5914 TypeSoFar = AT->getElementType();
5916 const Decl *D = E.getAsBaseOrMember().getPointer();
5917 if (
auto *FD = dyn_cast<FieldDecl>(D)) {
5942 if (!
V.getMemberPointerDecl()) {
5943 mangleNullPointer(T);
5950 if (!
V.getMemberPointerPath().empty()) {
5953 }
else if (NeedExactType &&
5956 V.getMemberPointerDecl()->getType()) &&
5963 mangle(
V.getMemberPointerDecl());
5965 if (!
V.getMemberPointerPath().empty()) {
5969 mangleNumber(
Offset.getQuantity());
5975 if (TopLevel && !IsPrimaryExpr)
5979 void CXXNameMangler::mangleTemplateParameter(
unsigned Depth,
unsigned Index) {
5990 Out <<
'L' << (
Depth - 1) <<
'_';
5996 void CXXNameMangler::mangleSeqID(
unsigned SeqID) {
5999 }
else if (SeqID == 1) {
6009 for (; SeqID != 0; SeqID /= 36) {
6010 unsigned C = SeqID % 36;
6011 *I++ = (
C < 10 ?
'0' +
C :
'A' +
C - 10);
6014 Out.write(I.base(), I - BufferRef.rbegin());
6019 void CXXNameMangler::mangleExistingSubstitution(
TemplateName tname) {
6020 bool result = mangleSubstitution(tname);
6021 assert(result &&
"no existing substitution for template name");
6027 bool CXXNameMangler::mangleSubstitution(
const NamedDecl *ND) {
6029 if (mangleStandardSubstitution(ND))
6033 return mangleSubstitution(
reinterpret_cast<uintptr_t>(ND));
6038 "mangleSubstitution(NestedNameSpecifier *) is only used for "
6039 "identifier nested name specifiers.");
6041 return mangleSubstitution(
reinterpret_cast<uintptr_t>(NNS));
6051 bool CXXNameMangler::mangleSubstitution(
QualType T) {
6054 return mangleSubstitution(RT->getDecl());
6059 return mangleSubstitution(TypePtr);
6062 bool CXXNameMangler::mangleSubstitution(
TemplateName Template) {
6064 return mangleSubstitution(TD);
6067 return mangleSubstitution(