35#include "llvm/ADT/StringExtras.h"
36#include "llvm/Support/ErrorHandling.h"
37#include "llvm/Support/raw_ostream.h"
44static bool isLocalContainerContext(
const DeclContext *DC) {
45 return isa<FunctionDecl>(DC) || isa<ObjCMethodDecl>(DC) || isa<BlockDecl>(DC);
50 return ftd->getTemplatedDecl();
57 return (fn ? getStructor(fn) :
decl);
60static bool isLambda(
const NamedDecl *ND) {
68static const unsigned UnknownArity = ~0
U;
71 typedef std::pair<const DeclContext*, IdentifierInfo*> DiscriminatorKeyTy;
72 llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator;
73 llvm::DenseMap<const NamedDecl*, unsigned> Uniquifier;
74 const DiscriminatorOverrideTy DiscriminatorOverride =
nullptr;
77 bool NeedsUniqueInternalLinkageNames =
false;
80 explicit ItaniumMangleContextImpl(
82 DiscriminatorOverrideTy DiscriminatorOverride,
bool IsAux =
false)
84 DiscriminatorOverride(DiscriminatorOverride) {}
96 NeedsUniqueInternalLinkageNames =
true;
101 raw_ostream &)
override;
104 raw_ostream &)
override;
106 raw_ostream &)
override;
113 bool NormalizeIntegers)
override;
115 bool NormalizeIntegers)
override;
122 raw_ostream &Out)
override;
125 raw_ostream &Out)
override;
127 raw_ostream &Out)
override;
130 raw_ostream &)
override;
138 bool getNextDiscriminator(
const NamedDecl *ND,
unsigned &disc) {
144 if (
const TagDecl *Tag = dyn_cast<TagDecl>(ND)) {
145 if (Tag->getName().empty() && !Tag->getTypedefNameForAnonDecl())
152 if (discriminator == 1)
154 disc = discriminator - 2;
159 unsigned &discriminator = Uniquifier[ND];
160 if (!discriminator) {
161 const DeclContext *DC = getEffectiveDeclContext(ND);
162 discriminator = ++Discriminator[std::make_pair(DC, ND->
getIdentifier())];
164 if (discriminator == 1)
166 disc = discriminator-2;
173 assert(Lambda->
isLambda() &&
"RD must be a lambda!");
174 std::string Name(
"<lambda");
178 const ParmVarDecl *Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
183 unsigned DefaultArgNo =
185 Name += llvm::utostr(DefaultArgNo);
189 if (LambdaManglingNumber)
190 LambdaId = LambdaManglingNumber;
194 Name += llvm::utostr(LambdaId);
200 return DiscriminatorOverride;
207 return getEffectiveDeclContext(cast<Decl>(DC));
210 bool isInternalLinkageDecl(
const NamedDecl *ND);
217class CXXNameMangler {
218 ItaniumMangleContextImpl &Context;
222 bool NormalizeIntegers =
false;
224 bool NullOut =
false;
229 bool DisableDerivedAbiTags =
false;
235 unsigned StructorType = 0;
240 class FunctionTypeDepthState {
243 enum { InResultTypeMask = 1 };
246 FunctionTypeDepthState() : Bits(0) {}
249 unsigned getDepth()
const {
254 bool isInResultType()
const {
255 return Bits & InResultTypeMask;
258 FunctionTypeDepthState push() {
259 FunctionTypeDepthState tmp = *
this;
260 Bits = (Bits & ~InResultTypeMask) + 2;
264 void enterResultType() {
265 Bits |= InResultTypeMask;
268 void leaveResultType() {
269 Bits &= ~InResultTypeMask;
272 void pop(FunctionTypeDepthState saved) {
273 assert(getDepth() == saved.getDepth() + 1);
288 class AbiTagState final {
290 explicit AbiTagState(AbiTagState *&Head) : LinkHead(Head) {
296 AbiTagState(
const AbiTagState &) =
delete;
297 AbiTagState &operator=(
const AbiTagState &) =
delete;
299 ~AbiTagState() { pop(); }
301 void write(raw_ostream &Out,
const NamedDecl *ND,
302 const AbiTagList *AdditionalAbiTags) {
304 if (!isa<FunctionDecl>(ND) && !isa<VarDecl>(ND)) {
306 !AdditionalAbiTags &&
307 "only function and variables need a list of additional abi tags");
308 if (
const auto *NS = dyn_cast<NamespaceDecl>(ND)) {
309 if (
const auto *AbiTag = NS->getAttr<AbiTagAttr>()) {
310 UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(),
311 AbiTag->tags().end());
319 if (
const auto *AbiTag = ND->
getAttr<AbiTagAttr>()) {
320 UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(),
321 AbiTag->tags().end());
322 TagList.insert(TagList.end(), AbiTag->tags().begin(),
323 AbiTag->tags().end());
326 if (AdditionalAbiTags) {
327 UsedAbiTags.insert(UsedAbiTags.end(), AdditionalAbiTags->begin(),
328 AdditionalAbiTags->end());
329 TagList.insert(TagList.end(), AdditionalAbiTags->begin(),
330 AdditionalAbiTags->end());
334 TagList.erase(std::unique(TagList.begin(), TagList.end()), TagList.end());
336 writeSortedUniqueAbiTags(Out, TagList);
339 const AbiTagList &getUsedAbiTags()
const {
return UsedAbiTags; }
340 void setUsedAbiTags(
const AbiTagList &AbiTags) {
341 UsedAbiTags = AbiTags;
344 const AbiTagList &getEmittedAbiTags()
const {
345 return EmittedAbiTags;
348 const AbiTagList &getSortedUniqueUsedAbiTags() {
349 llvm::sort(UsedAbiTags);
350 UsedAbiTags.erase(std::unique(UsedAbiTags.begin(), UsedAbiTags.end()),
357 AbiTagList UsedAbiTags;
359 AbiTagList EmittedAbiTags;
361 AbiTagState *&LinkHead;
362 AbiTagState *
Parent =
nullptr;
365 assert(LinkHead ==
this &&
366 "abi tag link head must point to us on destruction");
369 UsedAbiTags.begin(), UsedAbiTags.end());
370 Parent->EmittedAbiTags.insert(
Parent->EmittedAbiTags.end(),
371 EmittedAbiTags.begin(),
372 EmittedAbiTags.end());
377 void writeSortedUniqueAbiTags(raw_ostream &Out,
const AbiTagList &AbiTags) {
378 for (
const auto &Tag : AbiTags) {
379 EmittedAbiTags.push_back(Tag);
387 AbiTagState *AbiTags =
nullptr;
388 AbiTagState AbiTagsRoot;
390 llvm::DenseMap<uintptr_t, unsigned> Substitutions;
391 llvm::DenseMap<StringRef, unsigned> ModuleSubstitutions;
393 ASTContext &getASTContext()
const {
return Context.getASTContext(); }
402 llvm::StringRef Name,
bool HasAllocator);
405 CXXNameMangler(ItaniumMangleContextImpl &
C, raw_ostream &Out_,
406 const NamedDecl *D =
nullptr,
bool NullOut_ =
false)
407 : Context(
C), Out(Out_), NullOut(NullOut_), Structor(getStructor(D)),
408 AbiTagsRoot(AbiTags) {
410 assert(!D || (!isa<CXXDestructorDecl>(D) &&
411 !isa<CXXConstructorDecl>(D)));
413 CXXNameMangler(ItaniumMangleContextImpl &
C, raw_ostream &Out_,
415 : Context(
C), Out(Out_), Structor(getStructor(D)), StructorType(
Type),
416 AbiTagsRoot(AbiTags) {}
417 CXXNameMangler(ItaniumMangleContextImpl &
C, raw_ostream &Out_,
419 : Context(
C), Out(Out_), Structor(getStructor(D)), StructorType(
Type),
420 AbiTagsRoot(AbiTags) {}
422 CXXNameMangler(ItaniumMangleContextImpl &
C, raw_ostream &Out_,
423 bool NormalizeIntegers_)
424 : Context(
C), Out(Out_), NormalizeIntegers(NormalizeIntegers_),
425 NullOut(
false), Structor(nullptr), AbiTagsRoot(AbiTags) {}
426 CXXNameMangler(CXXNameMangler &Outer, raw_ostream &Out_)
427 : Context(Outer.Context), Out(Out_), Structor(Outer.Structor),
428 StructorType(Outer.StructorType), SeqID(Outer.SeqID),
429 FunctionTypeDepth(Outer.FunctionTypeDepth), AbiTagsRoot(AbiTags),
430 Substitutions(Outer.Substitutions),
431 ModuleSubstitutions(Outer.ModuleSubstitutions) {}
433 CXXNameMangler(CXXNameMangler &Outer, llvm::raw_null_ostream &Out_)
434 : CXXNameMangler(Outer, (raw_ostream &)Out_) {
438 raw_ostream &getStream() {
return Out; }
440 void disableDerivedAbiTags() { DisableDerivedAbiTags =
true; }
441 static bool shouldHaveAbiTags(ItaniumMangleContextImpl &
C,
const VarDecl *VD);
444 void mangleCallOffset(int64_t NonVirtual, int64_t
Virtual);
445 void mangleNumber(
const llvm::APSInt &I);
446 void mangleNumber(int64_t Number);
447 void mangleFloat(
const llvm::APFloat &F);
449 void mangleSeqID(
unsigned SeqID);
452 void mangleNameOrStandardSubstitution(
const NamedDecl *ND);
454 void mangleModuleNamePrefix(StringRef Name,
bool IsPartition =
false);
458 bool mangleSubstitution(
const NamedDecl *ND);
460 bool mangleSubstitution(
QualType T);
466 bool mangleStandardSubstitution(
const NamedDecl *ND);
468 void addSubstitution(
const NamedDecl *ND) {
471 addSubstitution(
reinterpret_cast<uintptr_t>(ND));
476 addSubstitution(
reinterpret_cast<uintptr_t>(NNS));
482 void extendSubstitutions(CXXNameMangler* Other);
485 bool recursive =
false);
489 unsigned NumTemplateArgs,
490 unsigned KnownArity = UnknownArity);
492 void mangleFunctionEncodingBareType(
const FunctionDecl *FD);
495 const AbiTagList *AdditionalAbiTags);
496 void mangleModuleName(
const NamedDecl *ND);
500 const AbiTagList *AdditionalAbiTags) {
501 mangleUnqualifiedName(GD, cast<NamedDecl>(GD.
getDecl())->getDeclName(), DC,
502 UnknownArity, AdditionalAbiTags);
506 const AbiTagList *AdditionalAbiTags);
508 const AbiTagList *AdditionalAbiTags);
510 const AbiTagList *AdditionalAbiTags);
514 void mangleSourceNameWithAbiTags(
515 const NamedDecl *ND,
const AbiTagList *AdditionalAbiTags =
nullptr);
517 const AbiTagList *AdditionalAbiTags);
523 const AbiTagList *AdditionalAbiTags,
524 bool NoFunction=
false);
527 void mangleNestedNameWithClosurePrefix(
GlobalDecl GD,
529 const AbiTagList *AdditionalAbiTags);
531 void manglePrefix(
const DeclContext *DC,
bool NoFunction=
false);
533 void mangleTemplatePrefix(
GlobalDecl GD,
bool NoFunction=
false);
536 void mangleClosurePrefix(
const NamedDecl *ND,
bool NoFunction =
false);
537 bool mangleUnresolvedTypeOrSimpleId(
QualType DestroyedType,
538 StringRef Prefix =
"");
541 void mangleVendorQualifier(StringRef qualifier);
548#define ABSTRACT_TYPE(CLASS, PARENT)
549#define NON_CANONICAL_TYPE(CLASS, PARENT)
550#define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T);
551#include "clang/AST/TypeNodes.inc"
553 void mangleType(
const TagType*);
555 static StringRef getCallingConvQualifierName(
CallingConv CC);
560 void mangleNeonVectorType(
const VectorType *T);
562 void mangleAArch64NeonVectorType(
const VectorType *T);
564 void mangleAArch64FixedSveVectorType(
const VectorType *T);
567 void mangleIntegerLiteral(
QualType T,
const llvm::APSInt &
Value);
568 void mangleFloatLiteral(
QualType T,
const llvm::APFloat &
V);
569 void mangleFixedPointLiteral();
572 void mangleMemberExprBase(
const Expr *base,
bool isArrow);
573 void mangleMemberExpr(
const Expr *base,
bool isArrow,
578 unsigned NumTemplateArgs,
579 unsigned knownArity);
580 void mangleCastExpression(
const Expr *E, StringRef CastEncoding);
581 void mangleInitListElements(
const InitListExpr *InitList);
582 void mangleExpression(
const Expr *E,
unsigned Arity = UnknownArity,
583 bool AsTemplateArg =
false);
589 unsigned NumTemplateArgs);
593 void mangleTemplateArgExpr(
const Expr *E);
595 bool NeedExactType =
false);
597 void mangleTemplateParameter(
unsigned Depth,
unsigned Index);
602 const AbiTagList *AdditionalAbiTags);
605 AbiTagList makeFunctionReturnTypeTags(
const FunctionDecl *FD);
607 AbiTagList makeVariableTypeTags(
const VarDecl *VD);
615 getASTContext(), getASTContext().getTranslationUnitDecl(),
617 &getASTContext().Idents.get(
"std"),
627ItaniumMangleContextImpl::getEffectiveDeclContext(
const Decl *D) {
637 dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl()))
638 return ContextParam->getDeclContext();
642 if (
const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
644 dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl()))
645 return ContextParam->getDeclContext();
653 if (D == getASTContext().getVaListTagDecl()) {
654 const llvm::Triple &T = getASTContext().getTargetInfo().getTriple();
655 if (T.isARM() || T.isThumb() || T.isAArch64())
656 return getStdNamespace();
660 if (isa<CapturedDecl>(DC) || isa<OMPDeclareReductionDecl>(DC) ||
661 isa<OMPDeclareMapperDecl>(DC)) {
662 return getEffectiveDeclContext(cast<Decl>(DC));
665 if (
const auto *VD = dyn_cast<VarDecl>(D))
667 return getASTContext().getTranslationUnitDecl();
669 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
671 return getASTContext().getTranslationUnitDecl();
676bool ItaniumMangleContextImpl::isInternalLinkageDecl(
const NamedDecl *ND) {
679 getEffectiveDeclContext(ND)->isFileContext() &&
686bool ItaniumMangleContextImpl::isUniqueInternalLinkageDecl(
688 if (!NeedsUniqueInternalLinkageNames || !ND)
691 const auto *FD = dyn_cast<FunctionDecl>(ND);
700 if (isInternalLinkageDecl(ND))
706bool ItaniumMangleContextImpl::shouldMangleCXXName(
const NamedDecl *D) {
707 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
710 if (FD->hasAttr<OverloadableAttr>())
726 if (FD->isMSVCRTEntryPoint())
740 if (!getASTContext().getLangOpts().
CPlusPlus)
743 if (
const auto *VD = dyn_cast<VarDecl>(D)) {
745 if (isa<DecompositionDecl>(VD))
754 const DeclContext *DC = getEffectiveDeclContext(D);
758 DC = getEffectiveParentContext(DC);
760 !CXXNameMangler::shouldHaveAbiTags(*
this, VD) &&
761 !isa<VarTemplateSpecializationDecl>(VD) &&
762 !VD->getOwningModuleForLinkage())
769void CXXNameMangler::writeAbiTags(
const NamedDecl *ND,
770 const AbiTagList *AdditionalAbiTags) {
771 assert(AbiTags &&
"require AbiTagState");
772 AbiTags->write(Out, ND, DisableDerivedAbiTags ?
nullptr : AdditionalAbiTags);
775void CXXNameMangler::mangleSourceNameWithAbiTags(
776 const NamedDecl *ND,
const AbiTagList *AdditionalAbiTags) {
778 writeAbiTags(ND, AdditionalAbiTags);
786 if (isa<FunctionDecl>(GD.
getDecl()))
787 mangleFunctionEncoding(GD);
792 dyn_cast<IndirectFieldDecl>(GD.
getDecl()))
793 mangleName(IFD->getAnonField());
795 llvm_unreachable(
"unexpected kind of global decl");
798void CXXNameMangler::mangleFunctionEncoding(
GlobalDecl GD) {
803 if (!Context.shouldMangleDeclName(FD)) {
808 AbiTagList ReturnTypeAbiTags = makeFunctionReturnTypeTags(FD);
809 if (ReturnTypeAbiTags.empty()) {
812 mangleFunctionEncodingBareType(FD);
820 llvm::raw_svector_ostream FunctionEncodingStream(FunctionEncodingBuf);
821 CXXNameMangler FunctionEncodingMangler(*
this, FunctionEncodingStream);
823 FunctionEncodingMangler.disableDerivedAbiTags();
824 FunctionEncodingMangler.mangleNameWithAbiTags(FD,
nullptr);
827 size_t EncodingPositionStart = FunctionEncodingStream.str().size();
828 FunctionEncodingMangler.mangleFunctionEncodingBareType(FD);
832 const AbiTagList &UsedAbiTags =
833 FunctionEncodingMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags();
834 AbiTagList AdditionalAbiTags(ReturnTypeAbiTags.size());
835 AdditionalAbiTags.erase(
836 std::set_difference(ReturnTypeAbiTags.begin(), ReturnTypeAbiTags.end(),
837 UsedAbiTags.begin(), UsedAbiTags.end(),
838 AdditionalAbiTags.begin()),
839 AdditionalAbiTags.end());
842 mangleNameWithAbiTags(FD, &AdditionalAbiTags);
843 Out << FunctionEncodingStream.str().substr(EncodingPositionStart);
847 extendSubstitutions(&FunctionEncodingMangler);
850void CXXNameMangler::mangleFunctionEncodingBareType(
const FunctionDecl *FD) {
851 if (FD->
hasAttr<EnableIfAttr>()) {
852 FunctionTypeDepthState Saved = FunctionTypeDepth.push();
853 Out <<
"Ua9enable_ifI";
854 for (AttrVec::const_iterator I = FD->
getAttrs().begin(),
857 EnableIfAttr *EIA = dyn_cast<EnableIfAttr>(*I);
860 if (Context.getASTContext().
getLangOpts().getClangABICompat() >
861 LangOptions::ClangABI::Ver11) {
862 mangleTemplateArgExpr(EIA->getCond());
868 mangleExpression(EIA->getCond());
873 FunctionTypeDepth.pop(Saved);
878 if (
auto *CD = dyn_cast<CXXConstructorDecl>(FD))
879 if (
auto Inherited = CD->getInheritedConstructor())
880 FD = Inherited.getConstructor();
898 bool MangleReturnType =
false;
900 if (!(isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD) ||
901 isa<CXXConversionDecl>(FD)))
902 MangleReturnType =
true;
905 FD = PrimaryTemplate->getTemplatedDecl();
909 MangleReturnType, FD);
914 if (!Context.getEffectiveParentContext(NS)->isTranslationUnit())
918 return II && II->
isStr(
"std");
923bool CXXNameMangler::isStdNamespace(
const DeclContext *DC) {
927 return isStd(cast<NamespaceDecl>(DC));
934 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
943 dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
944 TemplateArgs = &Spec->getTemplateArgs();
945 return GD.
getWithDecl(Spec->getSpecializedTemplate());
950 dyn_cast<VarTemplateSpecializationDecl>(ND)) {
951 TemplateArgs = &Spec->getTemplateArgs();
952 return GD.
getWithDecl(Spec->getSpecializedTemplate());
963void CXXNameMangler::mangleName(
GlobalDecl GD) {
965 if (
const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
967 AbiTagList VariableTypeAbiTags = makeVariableTypeTags(VD);
968 if (VariableTypeAbiTags.empty()) {
970 mangleNameWithAbiTags(VD,
nullptr);
975 llvm::raw_null_ostream NullOutStream;
976 CXXNameMangler VariableNameMangler(*
this, NullOutStream);
977 VariableNameMangler.disableDerivedAbiTags();
978 VariableNameMangler.mangleNameWithAbiTags(VD,
nullptr);
981 const AbiTagList &UsedAbiTags =
982 VariableNameMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags();
983 AbiTagList AdditionalAbiTags(VariableTypeAbiTags.size());
984 AdditionalAbiTags.erase(
985 std::set_difference(VariableTypeAbiTags.begin(),
986 VariableTypeAbiTags.end(), UsedAbiTags.begin(),
987 UsedAbiTags.end(), AdditionalAbiTags.begin()),
988 AdditionalAbiTags.end());
991 mangleNameWithAbiTags(VD, &AdditionalAbiTags);
993 mangleNameWithAbiTags(GD,
nullptr);
997const RecordDecl *CXXNameMangler::GetLocalClassDecl(
const Decl *D) {
998 const DeclContext *DC = Context.getEffectiveDeclContext(D);
1000 if (isLocalContainerContext(DC))
1001 return dyn_cast<RecordDecl>(D);
1003 DC = Context.getEffectiveDeclContext(D);
1008void CXXNameMangler::mangleNameWithAbiTags(
GlobalDecl GD,
1009 const AbiTagList *AdditionalAbiTags) {
1016 const DeclContext *DC = Context.getEffectiveDeclContext(ND);
1022 if (isLocalContainerContext(DC) && ND->
hasLinkage() && !isLambda(ND))
1024 DC = Context.getEffectiveParentContext(DC);
1025 else if (GetLocalClassDecl(ND)) {
1026 mangleLocalName(GD, AdditionalAbiTags);
1030 assert(!isa<LinkageSpecDecl>(DC) &&
"context cannot be LinkageSpecDecl");
1032 if (isLocalContainerContext(DC)) {
1033 mangleLocalName(GD, AdditionalAbiTags);
1039 if (
const NamedDecl *PrefixND = getClosurePrefix(ND)) {
1040 mangleNestedNameWithClosurePrefix(GD, PrefixND, AdditionalAbiTags);
1048 mangleUnscopedTemplateName(TD, DC, AdditionalAbiTags);
1053 mangleUnscopedName(GD, DC, AdditionalAbiTags);
1057 mangleNestedName(GD, DC, AdditionalAbiTags);
1060void CXXNameMangler::mangleModuleName(
const NamedDecl *ND) {
1063 mangleModuleNamePrefix(M->getPrimaryModuleInterfaceName());
1071void CXXNameMangler::mangleModuleNamePrefix(StringRef Name,
bool IsPartition) {
1073 auto It = ModuleSubstitutions.find(Name);
1074 if (It != ModuleSubstitutions.end()) {
1076 mangleSeqID(It->second);
1082 auto Parts = Name.rsplit(
'.');
1083 if (Parts.second.empty())
1084 Parts.second = Parts.first;
1086 mangleModuleNamePrefix(Parts.first, IsPartition);
1087 IsPartition =
false;
1093 Out << Parts.second.size() << Parts.second;
1094 ModuleSubstitutions.insert({Name, SeqID++});
1097void CXXNameMangler::mangleTemplateName(
const TemplateDecl *TD,
1099 const DeclContext *DC = Context.getEffectiveDeclContext(TD);
1102 mangleUnscopedTemplateName(TD, DC,
nullptr);
1105 mangleNestedName(TD, Args);
1110 const AbiTagList *AdditionalAbiTags) {
1114 assert(!isa<LinkageSpecDecl>(DC) &&
"unskipped LinkageSpecDecl");
1115 if (isStdNamespace(DC))
1118 mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
1121void CXXNameMangler::mangleUnscopedTemplateName(
1126 if (mangleSubstitution(ND))
1130 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
1131 assert(!AdditionalAbiTags &&
1132 "template template param cannot have abi tags");
1133 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
1134 }
else if (isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND)) {
1135 mangleUnscopedName(GD, DC, AdditionalAbiTags);
1141 addSubstitution(ND);
1144void CXXNameMangler::mangleFloat(
const llvm::APFloat &f) {
1158 llvm::APInt valueBits = f.bitcastToAPInt();
1159 unsigned numCharacters = (valueBits.getBitWidth() + 3) / 4;
1160 assert(numCharacters != 0);
1166 for (
unsigned stringIndex = 0; stringIndex != numCharacters; ++stringIndex) {
1168 unsigned digitBitIndex = 4 * (numCharacters - stringIndex - 1);
1171 uint64_t hexDigit = valueBits.getRawData()[digitBitIndex / 64];
1172 hexDigit >>= (digitBitIndex % 64);
1176 static const char charForHex[16] = {
1177 '0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
1178 '8',
'9',
'a',
'b',
'c',
'd',
'e',
'f'
1180 buffer[stringIndex] = charForHex[hexDigit];
1183 Out.write(buffer.data(), numCharacters);
1186void CXXNameMangler::mangleFloatLiteral(
QualType T,
const llvm::APFloat &
V) {
1193void CXXNameMangler::mangleFixedPointLiteral() {
1200void CXXNameMangler::mangleNullPointer(
QualType T) {
1207void CXXNameMangler::mangleNumber(
const llvm::APSInt &
Value) {
1208 if (
Value.isSigned() &&
Value.isNegative()) {
1210 Value.abs().print(Out,
false);
1212 Value.print(Out,
false);
1216void CXXNameMangler::mangleNumber(int64_t Number) {
1226void CXXNameMangler::mangleCallOffset(int64_t NonVirtual, int64_t
Virtual) {
1234 mangleNumber(NonVirtual);
1240 mangleNumber(NonVirtual);
1248 if (!mangleSubstitution(
QualType(TST, 0))) {
1249 mangleTemplatePrefix(TST->getTemplateName());
1254 mangleTemplateArgs(TST->getTemplateName(), TST->template_arguments());
1257 }
else if (
const auto *DTST =
1259 if (!mangleSubstitution(
QualType(DTST, 0))) {
1260 TemplateName Template = getASTContext().getDependentTemplateName(
1261 DTST->getQualifier(), DTST->getIdentifier());
1262 mangleTemplatePrefix(Template);
1267 mangleTemplateArgs(Template, DTST->template_arguments());
1268 addSubstitution(
QualType(DTST, 0));
1298 switch (qualifier->
getKind()) {
1310 llvm_unreachable(
"Can't mangle __super specifier");
1314 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1322 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1339 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1346 if (mangleUnresolvedTypeOrSimpleId(
QualType(
type, 0), recursive ?
"N" :
""))
1355 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1373void CXXNameMangler::mangleUnresolvedName(
1376 unsigned knownArity) {
1377 if (qualifier) mangleUnresolvedPrefix(qualifier);
1378 switch (
name.getNameKind()) {
1381 mangleSourceName(
name.getAsIdentifierInfo());
1386 mangleUnresolvedTypeOrSimpleId(
name.getCXXNameType());
1393 mangleOperatorName(name, knownArity);
1396 llvm_unreachable(
"Can't mangle a constructor name!");
1398 llvm_unreachable(
"Can't mangle a using directive name!");
1400 llvm_unreachable(
"Can't mangle a deduction guide name!");
1404 llvm_unreachable(
"Can't mangle Objective-C selector names here!");
1410 mangleTemplateArgs(
TemplateName(), TemplateArgs, NumTemplateArgs);
1413void CXXNameMangler::mangleUnqualifiedName(
1415 unsigned KnownArity,
const AbiTagList *AdditionalAbiTags) {
1423 mangleModuleName(ND);
1425 unsigned Arity = KnownArity;
1426 switch (Name.getNameKind()) {
1431 if (
auto *DD = dyn_cast<DecompositionDecl>(ND)) {
1438 for (
auto *BD : DD->bindings())
1439 mangleSourceName(BD->getDeclName().getAsIdentifierInfo());
1441 writeAbiTags(ND, AdditionalAbiTags);
1445 if (
auto *GD = dyn_cast<MSGuidDecl>(ND)) {
1448 SmallString<
sizeof(
"_GUID_12345678_1234_1234_1234_1234567890ab")> GUID;
1449 llvm::raw_svector_ostream GUIDOS(GUID);
1450 Context.mangleMSGuidDecl(GD, GUIDOS);
1451 Out << GUID.size() << GUID;
1455 if (
auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
1458 mangleValueInTemplateArg(TPO->getType().getUnqualifiedType(),
1459 TPO->getValue(),
true);
1477 if (Context.isInternalLinkageDecl(ND))
1480 auto *FD = dyn_cast<FunctionDecl>(ND);
1481 bool IsRegCall = FD &&
1485 FD && FD->
hasAttr<CUDAGlobalAttr>() &&
1488 mangleDeviceStubName(II);
1490 mangleRegCallName(II);
1492 mangleSourceName(II);
1494 writeAbiTags(ND, AdditionalAbiTags);
1499 assert(ND &&
"mangling empty name without declaration");
1501 if (
const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
1504 Out <<
"12_GLOBAL__N_1";
1509 if (
const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
1523 &&
"Expected anonymous struct or union!");
1530 assert(FD->
getIdentifier() &&
"Data member name isn't an identifier!");
1543 if (isa<ObjCContainerDecl>(ND))
1547 const TagDecl *TD = cast<TagDecl>(ND);
1550 "Typedef should not be in another decl context!");
1551 assert(D->getDeclName().getAsIdentifierInfo() &&
1552 "Typedef was not named!");
1553 mangleSourceName(D->getDeclName().getAsIdentifierInfo());
1554 assert(!AdditionalAbiTags &&
"Type cannot have additional abi tags");
1557 writeAbiTags(TD,
nullptr);
1566 if (
const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) {
1567 std::optional<unsigned> DeviceNumber =
1568 Context.getDiscriminatorOverride()(Context.getASTContext(),
Record);
1574 if (
Record->isLambda() &&
1575 ((DeviceNumber && *DeviceNumber > 0) ||
1576 (!DeviceNumber &&
Record->getLambdaManglingNumber() > 0))) {
1577 assert(!AdditionalAbiTags &&
1578 "Lambda type cannot have additional abi tags");
1579 mangleLambda(Record);
1585 unsigned UnnamedMangle =
1586 getASTContext().getManglingNumber(TD, Context.isAux());
1588 if (UnnamedMangle > 1)
1589 Out << UnnamedMangle - 2;
1591 writeAbiTags(TD, AdditionalAbiTags);
1597 unsigned AnonStructId =
1599 : Context.getAnonymousStructId(TD, dyn_cast<FunctionDecl>(DC));
1606 Str += llvm::utostr(AnonStructId);
1616 llvm_unreachable(
"Can't mangle Objective-C selector names here!");
1622 if (
auto Inherited =
1623 cast<CXXConstructorDecl>(ND)->getInheritedConstructor()) {
1624 InheritedFrom = Inherited.getConstructor()->
getParent();
1625 InheritedTemplateName =
1626 TemplateName(Inherited.getConstructor()->getPrimaryTemplate());
1627 InheritedTemplateArgs =
1628 Inherited.getConstructor()->getTemplateSpecializationArgs();
1634 mangleCXXCtorType(
static_cast<CXXCtorType>(StructorType), InheritedFrom);
1642 if (InheritedTemplateArgs)
1643 mangleTemplateArgs(InheritedTemplateName, *InheritedTemplateArgs);
1645 writeAbiTags(ND, AdditionalAbiTags);
1653 mangleCXXDtorType(
static_cast<CXXDtorType>(StructorType));
1658 writeAbiTags(ND, AdditionalAbiTags);
1662 if (ND && Arity == UnknownArity) {
1663 Arity = cast<FunctionDecl>(ND)->getNumParams();
1666 if (
const auto *MD = dyn_cast<CXXMethodDecl>(ND))
1667 if (!MD->isStatic())
1673 mangleOperatorName(Name, Arity);
1674 writeAbiTags(ND, AdditionalAbiTags);
1678 llvm_unreachable(
"Can't mangle a deduction guide name!");
1681 llvm_unreachable(
"Can't mangle a using directive name!");
1685void CXXNameMangler::mangleRegCallName(
const IdentifierInfo *II) {
1689 Out << II->
getLength() +
sizeof(
"__regcall3__") - 1 <<
"__regcall3__"
1693void CXXNameMangler::mangleDeviceStubName(
const IdentifierInfo *II) {
1697 Out << II->
getLength() +
sizeof(
"__device_stub__") - 1 <<
"__device_stub__"
1708void CXXNameMangler::mangleNestedName(
GlobalDecl GD,
1710 const AbiTagList *AdditionalAbiTags,
1719 if (
const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND)) {
1720 Qualifiers MethodQuals = Method->getMethodQualifiers();
1724 mangleQualifiers(MethodQuals);
1725 mangleRefQualifier(Method->getRefQualifier());
1731 mangleTemplatePrefix(TD, NoFunction);
1734 manglePrefix(DC, NoFunction);
1735 mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
1740void CXXNameMangler::mangleNestedName(
const TemplateDecl *TD,
1746 mangleTemplatePrefix(TD);
1752void CXXNameMangler::mangleNestedNameWithClosurePrefix(
1754 const AbiTagList *AdditionalAbiTags) {
1763 mangleClosurePrefix(PrefixND);
1764 mangleUnqualifiedName(GD,
nullptr, AdditionalAbiTags);
1775 if (
auto *CD = dyn_cast<CXXConstructorDecl>(DC))
1777 else if (
auto *DD = dyn_cast<CXXDestructorDecl>(DC))
1784void CXXNameMangler::mangleLocalName(
GlobalDecl GD,
1785 const AbiTagList *AdditionalAbiTags) {
1792 assert(isa<NamedDecl>(D) || isa<BlockDecl>(D));
1794 const DeclContext *DC = Context.getEffectiveDeclContext(RD ? RD : D);
1799 AbiTagState LocalAbiTags(AbiTags);
1802 mangleObjCMethodName(MD);
1803 else if (
const BlockDecl *BD = dyn_cast<BlockDecl>(DC))
1804 mangleBlockForPrefix(BD);
1810 LocalAbiTags.setUsedAbiTags(LocalAbiTags.getEmittedAbiTags());
1833 mangleNumber(Num - 2);
1842 mangleUnqualifiedName(RD, DC, AdditionalAbiTags);
1843 }
else if (
const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
1844 if (
const NamedDecl *PrefixND = getClosurePrefix(BD))
1845 mangleClosurePrefix(PrefixND,
true );
1847 manglePrefix(Context.getEffectiveDeclContext(BD),
true );
1848 assert(!AdditionalAbiTags &&
"Block cannot have additional abi tags");
1849 mangleUnqualifiedBlock(BD);
1851 const NamedDecl *ND = cast<NamedDecl>(D);
1852 mangleNestedName(GD, Context.getEffectiveDeclContext(ND),
1853 AdditionalAbiTags,
true );
1855 }
else if (
const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
1859 = dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl())) {
1865 mangleNumber(Num - 2);
1870 assert(!AdditionalAbiTags &&
"Block cannot have additional abi tags");
1871 mangleUnqualifiedBlock(BD);
1873 mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
1876 if (
const NamedDecl *ND = dyn_cast<NamedDecl>(RD ? RD : D)) {
1878 if (Context.getNextDiscriminator(ND, disc)) {
1882 Out <<
"__" << disc <<
'_';
1887void CXXNameMangler::mangleBlockForPrefix(
const BlockDecl *
Block) {
1888 if (GetLocalClassDecl(
Block)) {
1889 mangleLocalName(
Block,
nullptr);
1893 if (isLocalContainerContext(DC)) {
1894 mangleLocalName(
Block,
nullptr);
1898 mangleClosurePrefix(PrefixND);
1901 mangleUnqualifiedBlock(
Block);
1904void CXXNameMangler::mangleUnqualifiedBlock(
const BlockDecl *
Block) {
1907 if (
Decl *Context =
Block->getBlockManglingContextDecl()) {
1908 if (getASTContext().getLangOpts().getClangABICompat() <=
1909 LangOptions::ClangABI::Ver12 &&
1910 (isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
1911 Context->getDeclContext()->isRecord()) {
1912 const auto *ND = cast<NamedDecl>(Context);
1914 mangleSourceNameWithAbiTags(ND);
1921 unsigned Number =
Block->getBlockManglingNumber();
1925 Number = Context.getBlockId(
Block,
false);
1941void CXXNameMangler::mangleTemplateParamDecl(
const NamedDecl *
Decl) {
1942 if (
auto *Ty = dyn_cast<TemplateTypeParmDecl>(
Decl)) {
1943 if (Ty->isParameterPack())
1946 }
else if (
auto *Tn = dyn_cast<NonTypeTemplateParmDecl>(
Decl)) {
1947 if (Tn->isExpandedParameterPack()) {
1948 for (
unsigned I = 0, N = Tn->getNumExpansionTypes(); I != N; ++I) {
1950 mangleType(Tn->getExpansionType(I));
1954 if (Tn->isParameterPack()) {
1957 T = PackExpansion->getPattern();
1962 }
else if (
auto *Tt = dyn_cast<TemplateTemplateParmDecl>(
Decl)) {
1963 if (Tt->isExpandedParameterPack()) {
1964 for (
unsigned I = 0, N = Tt->getNumExpansionTemplateParameters(); I != N;
1967 for (
auto *Param : *Tt->getExpansionTemplateParameters(I))
1968 mangleTemplateParamDecl(Param);
1972 if (Tt->isParameterPack())
1975 for (
auto *Param : *Tt->getTemplateParameters())
1976 mangleTemplateParamDecl(Param);
1982void CXXNameMangler::mangleLambda(
const CXXRecordDecl *Lambda) {
1986 if (getASTContext().getLangOpts().getClangABICompat() <=
1987 LangOptions::ClangABI::Ver12 &&
1988 (isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
1989 !isa<ParmVarDecl>(Context)) {
1992 mangleSourceName(Name);
2002 mangleLambdaSig(Lambda);
2016 std::optional<unsigned> DeviceNumber =
2017 Context.getDiscriminatorOverride()(Context.getASTContext(), Lambda);
2021 assert(Number > 0 &&
"Lambda should be mangled as an unnamed class");
2023 mangleNumber(Number - 2);
2027void CXXNameMangler::mangleLambdaSig(
const CXXRecordDecl *Lambda) {
2029 mangleTemplateParamDecl(D);
2032 mangleBareFunctionType(Proto,
false,
2037 switch (qualifier->
getKind()) {
2043 llvm_unreachable(
"Can't mangle __super specifier");
2060 bool Clang14Compat = getASTContext().getLangOpts().getClangABICompat() <=
2061 LangOptions::ClangABI::Ver14;
2062 if (!Clang14Compat && mangleSubstitution(qualifier))
2073 addSubstitution(qualifier);
2077 llvm_unreachable(
"unexpected nested name specifier");
2080void CXXNameMangler::manglePrefix(
const DeclContext *DC,
bool NoFunction) {
2088 assert(!isa<LinkageSpecDecl>(DC) &&
"prefix cannot be LinkageSpecDecl");
2093 if (NoFunction && isLocalContainerContext(DC))
2096 assert(!isLocalContainerContext(DC));
2098 const NamedDecl *ND = cast<NamedDecl>(DC);
2099 if (mangleSubstitution(ND))
2105 mangleTemplatePrefix(TD);
2107 }
else if (
const NamedDecl *PrefixND = getClosurePrefix(ND)) {
2108 mangleClosurePrefix(PrefixND, NoFunction);
2109 mangleUnqualifiedName(ND,
nullptr,
nullptr);
2111 const DeclContext *DC = Context.getEffectiveDeclContext(ND);
2112 manglePrefix(DC, NoFunction);
2113 mangleUnqualifiedName(ND, DC,
nullptr);
2116 addSubstitution(ND);
2119void CXXNameMangler::mangleTemplatePrefix(
TemplateName Template) {
2124 return mangleTemplatePrefix(TD);
2127 assert(Dependent &&
"unexpected template name kind");
2131 bool Clang11Compat = getASTContext().getLangOpts().getClangABICompat() <=
2132 LangOptions::ClangABI::Ver11;
2133 if (!Clang11Compat && mangleSubstitution(Template))
2137 manglePrefix(Qualifier);
2139 if (Clang11Compat && mangleSubstitution(Template))
2143 mangleSourceName(
Id);
2145 mangleOperatorName(Dependent->getOperator(), UnknownArity);
2147 addSubstitution(Template);
2150void CXXNameMangler::mangleTemplatePrefix(
GlobalDecl GD,
2159 if (mangleSubstitution(ND))
2163 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
2164 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
2166 const DeclContext *DC = Context.getEffectiveDeclContext(ND);
2167 manglePrefix(DC, NoFunction);
2168 if (isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND))
2169 mangleUnqualifiedName(GD, DC,
nullptr);
2175 addSubstitution(ND);
2178const NamedDecl *CXXNameMangler::getClosurePrefix(
const Decl *ND) {
2179 if (getASTContext().getLangOpts().getClangABICompat() <=
2180 LangOptions::ClangABI::Ver12)
2184 if (
auto *
Block = dyn_cast<BlockDecl>(ND)) {
2185 Context = dyn_cast_or_null<NamedDecl>(
Block->getBlockManglingContextDecl());
2186 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
2188 Context = dyn_cast_or_null<NamedDecl>(RD->getLambdaContextDecl());
2195 if ((isa<VarDecl>(Context) && cast<VarDecl>(Context)->hasGlobalStorage()) ||
2196 isa<FieldDecl>(Context))
2202void CXXNameMangler::mangleClosurePrefix(
const NamedDecl *ND,
bool NoFunction) {
2205 if (mangleSubstitution(ND))
2210 mangleTemplatePrefix(TD, NoFunction);
2213 const auto *DC = Context.getEffectiveDeclContext(ND);
2214 manglePrefix(DC, NoFunction);
2215 mangleUnqualifiedName(ND, DC,
nullptr);
2220 addSubstitution(ND);
2229 if (mangleSubstitution(TN))
2242 if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TD))
2243 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
2250 llvm_unreachable(
"can't mangle an overloaded template name as a <type>");
2254 assert(Dependent->isIdentifier());
2258 mangleUnresolvedPrefix(Dependent->getQualifier());
2259 mangleSourceName(Dependent->getIdentifier());
2279 Out <<
"_SUBSTPACK_";
2284 addSubstitution(TN);
2287bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(
QualType Ty,
2293 case Type::Adjusted:
2296 case Type::BlockPointer:
2297 case Type::LValueReference:
2298 case Type::RValueReference:
2299 case Type::MemberPointer:
2300 case Type::ConstantArray:
2301 case Type::IncompleteArray:
2302 case Type::VariableArray:
2303 case Type::DependentSizedArray:
2304 case Type::DependentAddressSpace:
2305 case Type::DependentVector:
2306 case Type::DependentSizedExtVector:
2308 case Type::ExtVector:
2309 case Type::ConstantMatrix:
2310 case Type::DependentSizedMatrix:
2311 case Type::FunctionProto:
2312 case Type::FunctionNoProto:
2314 case Type::Attributed:
2315 case Type::BTFTagAttributed:
2317 case Type::DeducedTemplateSpecialization:
2318 case Type::PackExpansion:
2319 case Type::ObjCObject:
2320 case Type::ObjCInterface:
2321 case Type::ObjCObjectPointer:
2322 case Type::ObjCTypeParam:
2325 case Type::MacroQualified:
2327 case Type::DependentBitInt:
2328 llvm_unreachable(
"type is illegal as a nested name specifier");
2330 case Type::SubstTemplateTypeParmPack:
2335 Out <<
"_SUBSTPACK_";
2342 case Type::TypeOfExpr:
2344 case Type::Decltype:
2345 case Type::TemplateTypeParm:
2346 case Type::UnaryTransform:
2347 case Type::SubstTemplateTypeParm:
2361 mangleSourceNameWithAbiTags(cast<TypedefType>(Ty)->getDecl());
2364 case Type::UnresolvedUsing:
2365 mangleSourceNameWithAbiTags(
2366 cast<UnresolvedUsingType>(Ty)->getDecl());
2371 mangleSourceNameWithAbiTags(cast<TagType>(Ty)->getDecl());
2374 case Type::TemplateSpecialization: {
2376 cast<TemplateSpecializationType>(Ty);
2385 assert(TD &&
"no template for template specialization type");
2386 if (isa<TemplateTemplateParmDecl>(TD))
2387 goto unresolvedType;
2389 mangleSourceNameWithAbiTags(TD);
2396 llvm_unreachable(
"invalid base for a template specialization type");
2410 Out <<
"_SUBSTPACK_";
2415 assert(TD && !isa<TemplateTemplateParmDecl>(TD));
2416 mangleSourceNameWithAbiTags(TD);
2430 case Type::InjectedClassName:
2431 mangleSourceNameWithAbiTags(
2432 cast<InjectedClassNameType>(Ty)->getDecl());
2435 case Type::DependentName:
2436 mangleSourceName(cast<DependentNameType>(Ty)->
getIdentifier());
2439 case Type::DependentTemplateSpecialization: {
2441 cast<DependentTemplateSpecializationType>(Ty);
2442 TemplateName Template = getASTContext().getDependentTemplateName(
2450 return mangleUnresolvedTypeOrSimpleId(cast<UsingType>(Ty)->desugar(),
2452 case Type::Elaborated:
2453 return mangleUnresolvedTypeOrSimpleId(
2454 cast<ElaboratedType>(Ty)->getNamedType(), Prefix);
2460void CXXNameMangler::mangleOperatorName(
DeclarationName Name,
unsigned Arity) {
2461 switch (Name.getNameKind()) {
2470 llvm_unreachable(
"Not an operator name");
2475 mangleType(Name.getCXXNameType());
2480 mangleSourceName(Name.getCXXLiteralIdentifier());
2484 mangleOperatorName(Name.getCXXOverloadedOperator(), Arity);
2493 case OO_New: Out <<
"nw";
break;
2495 case OO_Array_New: Out <<
"na";
break;
2497 case OO_Delete: Out <<
"dl";
break;
2499 case OO_Array_Delete: Out <<
"da";
break;
2503 Out << (Arity == 1?
"ps" :
"pl");
break;
2507 Out << (Arity == 1?
"ng" :
"mi");
break;
2511 Out << (Arity == 1?
"ad" :
"an");
break;
2516 Out << (Arity == 1?
"de" :
"ml");
break;
2518 case OO_Tilde: Out <<
"co";
break;
2520 case OO_Slash: Out <<
"dv";
break;
2522 case OO_Percent: Out <<
"rm";
break;
2524 case OO_Pipe: Out <<
"or";
break;
2526 case OO_Caret: Out <<
"eo";
break;
2528 case OO_Equal: Out <<
"aS";
break;
2530 case OO_PlusEqual: Out <<
"pL";
break;
2532 case OO_MinusEqual: Out <<
"mI";
break;
2534 case OO_StarEqual: Out <<
"mL";
break;
2536 case OO_SlashEqual: Out <<
"dV";
break;
2538 case OO_PercentEqual: Out <<
"rM";
break;
2540 case OO_AmpEqual: Out <<
"aN";
break;
2542 case OO_PipeEqual: Out <<
"oR";
break;
2544 case OO_CaretEqual: Out <<
"eO";
break;
2546 case OO_LessLess: Out <<
"ls";
break;
2548 case OO_GreaterGreater: Out <<
"rs";
break;
2550 case OO_LessLessEqual: Out <<
"lS";
break;
2552 case OO_GreaterGreaterEqual: Out <<
"rS";
break;
2554 case OO_EqualEqual: Out <<
"eq";
break;
2556 case OO_ExclaimEqual: Out <<
"ne";
break;
2558 case OO_Less: Out <<
"lt";
break;
2560 case OO_Greater: Out <<
"gt";
break;
2562 case OO_LessEqual: Out <<
"le";
break;
2564 case OO_GreaterEqual: Out <<
"ge";
break;
2566 case OO_Exclaim: Out <<
"nt";
break;
2568 case OO_AmpAmp: Out <<
"aa";
break;
2570 case OO_PipePipe: Out <<
"oo";
break;
2572 case OO_PlusPlus: Out <<
"pp";
break;
2574 case OO_MinusMinus: Out <<
"mm";
break;
2576 case OO_Comma: Out <<
"cm";
break;
2578 case OO_ArrowStar: Out <<
"pm";
break;
2580 case OO_Arrow: Out <<
"pt";
break;
2582 case OO_Call: Out <<
"cl";
break;
2584 case OO_Subscript: Out <<
"ix";
break;
2589 case OO_Conditional: Out <<
"qu";
break;
2592 case OO_Coawait: Out <<
"aw";
break;
2595 case OO_Spaceship: Out <<
"ss";
break;
2599 llvm_unreachable(
"Not an overloaded operator");
2628 if (TargetAS != 0 ||
2630 ASString =
"AS" + llvm::utostr(TargetAS);
2633 default: llvm_unreachable(
"Not a language specific address space");
2637 case LangAS::opencl_global:
2638 ASString =
"CLglobal";
2640 case LangAS::opencl_global_device:
2641 ASString =
"CLdevice";
2643 case LangAS::opencl_global_host:
2644 ASString =
"CLhost";
2646 case LangAS::opencl_local:
2647 ASString =
"CLlocal";
2649 case LangAS::opencl_constant:
2650 ASString =
"CLconstant";
2652 case LangAS::opencl_private:
2653 ASString =
"CLprivate";
2655 case LangAS::opencl_generic:
2656 ASString =
"CLgeneric";
2660 case LangAS::sycl_global:
2661 ASString =
"SYglobal";
2663 case LangAS::sycl_global_device:
2664 ASString =
"SYdevice";
2666 case LangAS::sycl_global_host:
2667 ASString =
"SYhost";
2669 case LangAS::sycl_local:
2670 ASString =
"SYlocal";
2672 case LangAS::sycl_private:
2673 ASString =
"SYprivate";
2676 case LangAS::cuda_device:
2677 ASString =
"CUdevice";
2679 case LangAS::cuda_constant:
2680 ASString =
"CUconstant";
2682 case LangAS::cuda_shared:
2683 ASString =
"CUshared";
2686 case LangAS::ptr32_sptr:
2687 ASString =
"ptr32_sptr";
2689 case LangAS::ptr32_uptr:
2690 ASString =
"ptr32_uptr";
2697 if (!ASString.empty())
2698 mangleVendorQualifier(ASString);
2711 mangleVendorQualifier(
"__weak");
2715 mangleVendorQualifier(
"__unaligned");
2727 mangleVendorQualifier(
"__strong");
2731 mangleVendorQualifier(
"__autoreleasing");
2754void CXXNameMangler::mangleVendorQualifier(StringRef name) {
2761 switch (RefQualifier) {
2775void CXXNameMangler::mangleObjCMethodName(
const ObjCMethodDecl *MD) {
2776 Context.mangleObjCMethodNameAsSourceName(MD, Out);
2791 if (Ctx.
getLangOpts().getClangABICompat() > LangOptions::ClangABI::Ver6 &&
2798 if (DeducedTST->getDeducedType().isNull())
2803void CXXNameMangler::mangleType(
QualType T) {
2844 = dyn_cast<TemplateSpecializationType>(T))
2862 const Type *ty = split.
Ty;
2864 bool isSubstitutable =
2866 if (isSubstitutable && mangleSubstitution(T))
2871 if (quals && isa<ArrayType>(T)) {
2881 dyn_cast<DependentAddressSpaceType>(ty)) {
2883 mangleQualifiers(splitDAST.
Quals, DAST);
2886 mangleQualifiers(quals);
2894#define ABSTRACT_TYPE(CLASS, PARENT)
2895#define NON_CANONICAL_TYPE(CLASS, PARENT) \
2897 llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \
2899#define TYPE(CLASS, PARENT) \
2901 mangleType(static_cast<const CLASS##Type*>(ty)); \
2903#include "clang/AST/TypeNodes.inc"
2908 if (isSubstitutable)
2912void CXXNameMangler::mangleNameOrStandardSubstitution(
const NamedDecl *ND) {
2913 if (!mangleStandardSubstitution(ND))
2917void CXXNameMangler::mangleType(
const BuiltinType *T) {
2949 std::string type_name;
2953 if (NormalizeIntegers && T->
isInteger()) {
2955 switch (getASTContext().getTypeSize(T)) {
2959 if (mangleSubstitution(BuiltinType::SChar))
2962 addSubstitution(BuiltinType::SChar);
2965 if (mangleSubstitution(BuiltinType::Short))
2968 addSubstitution(BuiltinType::Short);
2971 if (mangleSubstitution(BuiltinType::Int))
2974 addSubstitution(BuiltinType::Int);
2977 if (mangleSubstitution(BuiltinType::Long))
2980 addSubstitution(BuiltinType::Long);
2983 if (mangleSubstitution(BuiltinType::Int128))
2986 addSubstitution(BuiltinType::Int128);
2989 llvm_unreachable(
"Unknown integer size for normalization");
2992 switch (getASTContext().getTypeSize(T)) {
2994 if (mangleSubstitution(BuiltinType::UChar))
2997 addSubstitution(BuiltinType::UChar);
3000 if (mangleSubstitution(BuiltinType::UShort))
3003 addSubstitution(BuiltinType::UShort);
3006 if (mangleSubstitution(BuiltinType::UInt))
3009 addSubstitution(BuiltinType::UInt);
3012 if (mangleSubstitution(BuiltinType::ULong))
3015 addSubstitution(BuiltinType::ULong);
3018 if (mangleSubstitution(BuiltinType::UInt128))
3021 addSubstitution(BuiltinType::UInt128);
3024 llvm_unreachable(
"Unknown integer size for normalization");
3030 case BuiltinType::Void:
3033 case BuiltinType::Bool:
3036 case BuiltinType::Char_U:
3037 case BuiltinType::Char_S:
3040 case BuiltinType::UChar:
3043 case BuiltinType::UShort:
3046 case BuiltinType::UInt:
3049 case BuiltinType::ULong:
3052 case BuiltinType::ULongLong:
3055 case BuiltinType::UInt128:
3058 case BuiltinType::SChar:
3061 case BuiltinType::WChar_S:
3062 case BuiltinType::WChar_U:
3065 case BuiltinType::Char8:
3068 case BuiltinType::Char16:
3071 case BuiltinType::Char32:
3074 case BuiltinType::Short:
3077 case BuiltinType::Int:
3080 case BuiltinType::Long:
3083 case BuiltinType::LongLong:
3086 case BuiltinType::Int128:
3089 case BuiltinType::Float16:
3092 case BuiltinType::ShortAccum:
3093 case BuiltinType::Accum:
3094 case BuiltinType::LongAccum:
3095 case BuiltinType::UShortAccum:
3096 case BuiltinType::UAccum:
3097 case BuiltinType::ULongAccum:
3098 case BuiltinType::ShortFract:
3099 case BuiltinType::Fract:
3100 case BuiltinType::LongFract:
3101 case BuiltinType::UShortFract:
3102 case BuiltinType::UFract:
3103 case BuiltinType::ULongFract:
3104 case BuiltinType::SatShortAccum:
3105 case BuiltinType::SatAccum:
3106 case BuiltinType::SatLongAccum:
3107 case BuiltinType::SatUShortAccum:
3108 case BuiltinType::SatUAccum:
3109 case BuiltinType::SatULongAccum:
3110 case BuiltinType::SatShortFract:
3111 case BuiltinType::SatFract:
3112 case BuiltinType::SatLongFract:
3113 case BuiltinType::SatUShortFract:
3114 case BuiltinType::SatUFract:
3115 case BuiltinType::SatULongFract:
3116 llvm_unreachable(
"Fixed point types are disabled for c++");
3117 case BuiltinType::Half:
3120 case BuiltinType::Float:
3123 case BuiltinType::Double:
3126 case BuiltinType::LongDouble: {
3127 const TargetInfo *TI = getASTContext().getLangOpts().OpenMP &&
3128 getASTContext().getLangOpts().OpenMPIsDevice
3129 ? getASTContext().getAuxTargetInfo()
3130 : &getASTContext().getTargetInfo();
3134 case BuiltinType::Float128: {
3135 const TargetInfo *TI = getASTContext().getLangOpts().OpenMP &&
3136 getASTContext().getLangOpts().OpenMPIsDevice
3137 ? getASTContext().getAuxTargetInfo()
3138 : &getASTContext().getTargetInfo();
3142 case BuiltinType::BFloat16: {
3143 const TargetInfo *TI = ((getASTContext().getLangOpts().OpenMP &&
3144 getASTContext().getLangOpts().OpenMPIsDevice) ||
3145 getASTContext().getLangOpts().SYCLIsDevice)
3146 ? getASTContext().getAuxTargetInfo()
3147 : &getASTContext().getTargetInfo();
3151 case BuiltinType::Ibm128: {
3152 const TargetInfo *TI = &getASTContext().getTargetInfo();
3156 case BuiltinType::NullPtr:
3160#define BUILTIN_TYPE(Id, SingletonId)
3161#define PLACEHOLDER_TYPE(Id, SingletonId) \
3162 case BuiltinType::Id:
3163#include "clang/AST/BuiltinTypes.def"
3164 case BuiltinType::Dependent:
3166 llvm_unreachable(
"mangling a placeholder type");
3168 case BuiltinType::ObjCId:
3169 Out <<
"11objc_object";
3171 case BuiltinType::ObjCClass:
3172 Out <<
"10objc_class";
3174 case BuiltinType::ObjCSel:
3175 Out <<
"13objc_selector";
3177#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3178 case BuiltinType::Id: \
3179 type_name = "ocl_" #ImgType "_" #Suffix; \
3180 Out << type_name.size() << type_name; \
3182#include "clang/Basic/OpenCLImageTypes.def"
3183 case BuiltinType::OCLSampler:
3184 Out <<
"11ocl_sampler";
3186 case BuiltinType::OCLEvent:
3187 Out <<
"9ocl_event";
3189 case BuiltinType::OCLClkEvent:
3190 Out <<
"12ocl_clkevent";
3192 case BuiltinType::OCLQueue:
3193 Out <<
"9ocl_queue";
3195 case BuiltinType::OCLReserveID:
3196 Out <<
"13ocl_reserveid";
3198#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
3199 case BuiltinType::Id: \
3200 type_name = "ocl_" #ExtType; \
3201 Out << type_name.size() << type_name; \
3203#include "clang/Basic/OpenCLExtensionTypes.def"
3207#define SVE_VECTOR_TYPE(InternalName, MangledName, Id, SingletonId, NumEls, \
3208 ElBits, IsSigned, IsFP, IsBF) \
3209 case BuiltinType::Id: \
3210 type_name = MangledName; \
3211 Out << (type_name == InternalName ? "u" : "") << type_name.size() \
3214#define SVE_PREDICATE_TYPE(InternalName, MangledName, Id, SingletonId, NumEls) \
3215 case BuiltinType::Id: \
3216 type_name = MangledName; \
3217 Out << (type_name == InternalName ? "u" : "") << type_name.size() \
3220#define SVE_OPAQUE_TYPE(InternalName, MangledName, Id, SingletonId) \
3221 case BuiltinType::Id: \
3222 type_name = MangledName; \
3223 Out << (type_name == InternalName ? "u" : "") << type_name.size() \
3226#include "clang/Basic/AArch64SVEACLETypes.def"
3227#define PPC_VECTOR_TYPE(Name, Id, Size) \
3228 case BuiltinType::Id: \
3229 type_name = #Name; \
3230 Out << 'u' << type_name.size() << type_name; \
3232#include "clang/Basic/PPCTypes.def"
3234#define RVV_TYPE(Name, Id, SingletonId) \
3235 case BuiltinType::Id: \
3237 Out << 'u' << type_name.size() << type_name; \
3239#include "clang/Basic/RISCVVTypes.def"
3240#define WASM_REF_TYPE(InternalName, MangledName, Id, SingletonId, AS) \
3241 case BuiltinType::Id: \
3242 type_name = MangledName; \
3243 Out << 'u' << type_name.size() << type_name; \
3245#include "clang/Basic/WebAssemblyReferenceTypes.def"
3249StringRef CXXNameMangler::getCallingConvQualifierName(
CallingConv CC) {
3289 return "swiftasynccall";
3291 llvm_unreachable(
"bad calling convention");
3294void CXXNameMangler::mangleExtFunctionInfo(
const FunctionType *T) {
3303 StringRef CCQualifier = getCallingConvQualifierName(T->
getExtInfo().
getCC());
3304 if (!CCQualifier.empty())
3305 mangleVendorQualifier(CCQualifier);
3319 case ParameterABI::Ordinary:
3323 case ParameterABI::SwiftContext:
3324 case ParameterABI::SwiftAsyncContext:
3325 case ParameterABI::SwiftErrorResult:
3326 case ParameterABI::SwiftIndirectResult:
3332 mangleVendorQualifier(
"ns_consumed");
3335 mangleVendorQualifier(
"noescape");
3342 mangleExtFunctionInfo(T);
3359 mangleType(ExceptTy);
3370 mangleBareFunctionType(T,
true);
3384 FunctionTypeDepthState saved = FunctionTypeDepth.push();
3386 FunctionTypeDepth.enterResultType();
3388 FunctionTypeDepth.leaveResultType();
3390 FunctionTypeDepth.pop(saved);
3395 bool MangleReturnType,
3399 FunctionTypeDepthState saved = FunctionTypeDepth.push();
3402 if (MangleReturnType) {
3403 FunctionTypeDepth.enterResultType();
3407 mangleVendorQualifier(
"ns_returns_retained");
3412 auto SplitReturnTy = ReturnTy.
split();
3414 ReturnTy = getASTContext().getQualifiedType(SplitReturnTy);
3416 mangleType(ReturnTy);
3418 FunctionTypeDepth.leaveResultType();
3425 FunctionTypeDepth.pop(saved);
3430 for (
unsigned I = 0, E = Proto->
getNumParams(); I != E; ++I) {
3443 assert(
Attr->getType() <= 9 &&
Attr->getType() >= 0);
3444 if (
Attr->isDynamic())
3445 Out <<
"U25pass_dynamic_object_size" <<
Attr->getType();
3447 Out <<
"U17pass_object_size" <<
Attr->getType();
3452 FunctionTypeDepth.pop(saved);
3467void CXXNameMangler::mangleType(
const EnumType *T) {
3468 mangleType(
static_cast<const TagType*
>(T));
3470void CXXNameMangler::mangleType(
const RecordType *T) {
3471 mangleType(
static_cast<const TagType*
>(T));
3473void CXXNameMangler::mangleType(
const TagType *T) {
3481 Out <<
'A' << T->
getSize() <<
'_';
3534 mangleType(PointeeType);
3548 Out <<
"_SUBSTPACK_";
3552void CXXNameMangler::mangleType(
const PointerType *T) {
3574void CXXNameMangler::mangleType(
const ComplexType *T) {
3582void CXXNameMangler::mangleNeonVectorType(
const VectorType *T) {
3584 assert(EltType->
isBuiltinType() &&
"Neon vector element not a BuiltinType");
3585 const char *EltName =
nullptr;
3587 switch (cast<BuiltinType>(EltType)->
getKind()) {
3588 case BuiltinType::SChar:
3589 case BuiltinType::UChar:
3590 EltName =
"poly8_t";
3592 case BuiltinType::Short:
3593 case BuiltinType::UShort:
3594 EltName =
"poly16_t";
3596 case BuiltinType::LongLong:
3597 case BuiltinType::ULongLong:
3598 EltName =
"poly64_t";
3600 default: llvm_unreachable(
"unexpected Neon polynomial vector element type");
3603 switch (cast<BuiltinType>(EltType)->
getKind()) {
3604 case BuiltinType::SChar: EltName =
"int8_t";
break;
3605 case BuiltinType::UChar: EltName =
"uint8_t";
break;
3606 case BuiltinType::Short: EltName =
"int16_t";
break;
3607 case BuiltinType::UShort: EltName =
"uint16_t";
break;
3608 case BuiltinType::Int: EltName =
"int32_t";
break;
3609 case BuiltinType::UInt: EltName =
"uint32_t";
break;
3610 case BuiltinType::LongLong: EltName =
"int64_t";
break;
3611 case BuiltinType::ULongLong: EltName =
"uint64_t";
break;
3612 case BuiltinType::Double: EltName =
"float64_t";
break;
3613 case BuiltinType::Float: EltName =
"float32_t";
break;
3614 case BuiltinType::Half: EltName =
"float16_t";
break;
3615 case BuiltinType::BFloat16: EltName =
"bfloat16_t";
break;
3617 llvm_unreachable(
"unexpected Neon vector element type");
3620 const char *BaseName =
nullptr;
3622 getASTContext().getTypeSize(EltType));
3624 BaseName =
"__simd64_";
3626 assert(BitSize == 128 &&
"Neon vector type not 64 or 128 bits");
3627 BaseName =
"__simd128_";
3629 Out << strlen(BaseName) + strlen(EltName);
3630 Out << BaseName << EltName;
3637 "cannot mangle this dependent neon vector type yet");
3643 case BuiltinType::SChar:
3645 case BuiltinType::Short:
3647 case BuiltinType::Int:
3649 case BuiltinType::Long:
3650 case BuiltinType::LongLong:
3652 case BuiltinType::UChar:
3654 case BuiltinType::UShort:
3656 case BuiltinType::UInt:
3658 case BuiltinType::ULong:
3659 case BuiltinType::ULongLong:
3661 case BuiltinType::Half:
3663 case BuiltinType::Float:
3665 case BuiltinType::Double:
3667 case BuiltinType::BFloat16:
3670 llvm_unreachable(
"Unexpected vector element base type");
3677void CXXNameMangler::mangleAArch64NeonVectorType(
const VectorType *T) {
3679 assert(EltType->
isBuiltinType() &&
"Neon vector element not a BuiltinType");
3684 assert((BitSize == 64 || BitSize == 128) &&
3685 "Neon vector type not 64 or 128 bits");
3689 switch (cast<BuiltinType>(EltType)->
getKind()) {
3690 case BuiltinType::UChar:
3693 case BuiltinType::UShort:
3696 case BuiltinType::ULong:
3697 case BuiltinType::ULongLong:
3701 llvm_unreachable(
"unexpected Neon polynomial vector element type");
3707 (
"__" + EltName +
"x" + Twine(T->
getNumElements()) +
"_t").str();
3714 "cannot mangle this dependent neon vector type yet");
3742void CXXNameMangler::mangleAArch64FixedSveVectorType(
const VectorType *T) {
3745 "expected fixed-length SVE vector!");
3749 "expected builtin type for fixed-length SVE vector!");
3752 switch (cast<BuiltinType>(EltType)->
getKind()) {
3753 case BuiltinType::SChar:
3756 case BuiltinType::UChar: {
3763 case BuiltinType::Short:
3766 case BuiltinType::UShort:
3769 case BuiltinType::Int:
3772 case BuiltinType::UInt:
3775 case BuiltinType::Long:
3778 case BuiltinType::ULong:
3781 case BuiltinType::Half:
3784 case BuiltinType::Float:
3787 case BuiltinType::Double:
3790 case BuiltinType::BFloat16:
3794 llvm_unreachable(
"unexpected element type for fixed-length SVE vector!");
3797 unsigned VecSizeInBits = getASTContext().getTypeInfo(T).Width;
3803 << VecSizeInBits <<
"EE";
3806void CXXNameMangler::mangleAArch64FixedSveVectorType(
3811 "cannot mangle this dependent fixed-length SVE vector type yet");
3823void CXXNameMangler::mangleType(
const VectorType *T) {
3826 llvm::Triple
Target = getASTContext().getTargetInfo().getTriple();
3827 llvm::Triple::ArchType Arch =
3828 getASTContext().getTargetInfo().getTriple().getArch();
3829 if ((Arch == llvm::Triple::aarch64 ||
3830 Arch == llvm::Triple::aarch64_be) && !
Target.isOSDarwin())
3831 mangleAArch64NeonVectorType(T);
3833 mangleNeonVectorType(T);
3837 mangleAArch64FixedSveVectorType(T);
3852 llvm::Triple
Target = getASTContext().getTargetInfo().getTriple();
3853 llvm::Triple::ArchType Arch =
3854 getASTContext().getTargetInfo().getTriple().getArch();
3855 if ((Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_be) &&
3857 mangleAArch64NeonVectorType(T);
3859 mangleNeonVectorType(T);
3863 mangleAArch64FixedSveVectorType(T);
3879 mangleType(
static_cast<const VectorType*
>(T));
3892 StringRef VendorQualifier =
"matrix_type";
3893 Out <<
"u" << VendorQualifier.size() << VendorQualifier;
3896 auto &ASTCtx = getASTContext();
3897 unsigned BitWidth = ASTCtx.getTypeSize(ASTCtx.getSizeType());
3898 llvm::APSInt Rows(BitWidth);
3900 mangleIntegerLiteral(ASTCtx.getSizeType(), Rows);
3901 llvm::APSInt Columns(BitWidth);
3903 mangleIntegerLiteral(ASTCtx.getSizeType(), Columns);
3911 StringRef VendorQualifier =
"matrix_type";
3912 Out <<
"u" << VendorQualifier.size() << VendorQualifier;
3923 mangleQualifiers(split.
Quals, T);
3940 Out <<
"U8__kindof";
3945 llvm::raw_svector_ostream QualOS(QualStr);
3946 QualOS <<
"objcproto";
3947 for (
const auto *I : T->
quals()) {
3948 StringRef
name = I->getName();
3951 Out <<
'U' << QualStr.size() << QualStr;
3960 mangleType(typeArg);
3966 Out <<
"U13block_pointer";
3981 if (mangleSubstitution(
QualType(T, 0)))
4034 getASTContext().getDependentTemplateName(T->
getQualifier(),
4036 mangleTemplatePrefix(Prefix);
4045void CXXNameMangler::mangleType(
const TypeOfType *T) {
4057void CXXNameMangler::mangleType(
const DecltypeType *T) {
4068 if (isa<DeclRefExpr>(E) ||
4069 isa<MemberExpr>(E) ||
4070 isa<UnresolvedLookupExpr>(E) ||
4071 isa<DependentScopeDeclRefExpr>(E) ||
4072 isa<CXXDependentScopeMemberExpr>(E) ||
4073 isa<UnresolvedMemberExpr>(E))
4077 mangleExpression(E);
4087 StringRef BuiltinName;
4089#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait) \
4090 case UnaryTransformType::Enum: \
4091 BuiltinName = "__" #Trait; \
4093#include "clang/Basic/TransformTypeTraits.def"
4095 Out << BuiltinName.size() << BuiltinName;
4103void CXXNameMangler::mangleType(
const AutoType *T) {
4105 "Deduced AutoType shouldn't be handled here!");
4106 assert(T->
getKeyword() != AutoTypeKeyword::GNUAutoType &&
4107 "shouldn't need to mangle __auto_type!");
4116 return mangleType(Deduced);
4119 assert(TD &&
"shouldn't form deduced TST unless we know we have a template");
4121 if (mangleSubstitution(TD))
4125 addSubstitution(TD);
4128void CXXNameMangler::mangleType(
const AtomicType *T) {
4135void CXXNameMangler::mangleType(
const PipeType *T) {
4142void CXXNameMangler::mangleType(
const BitIntType *T) {
4158void CXXNameMangler::mangleIntegerLiteral(
QualType T,
4159 const llvm::APSInt &
Value) {
4166 Out << (
Value.getBoolValue() ?
'1' :
'0');
4168 mangleNumber(
Value);
4174void CXXNameMangler::mangleMemberExprBase(
const Expr *
Base,
bool IsArrow) {
4177 if (!RT->getDecl()->isAnonymousStructOrUnion())
4179 const auto *ME = dyn_cast<MemberExpr>(
Base);
4182 Base = ME->getBase();
4183 IsArrow = ME->isArrow();
4186 if (
Base->isImplicitCXXThis()) {
4192 Out << (IsArrow ?
"pt" :
"dt");
4193 mangleExpression(
Base);
4198void CXXNameMangler::mangleMemberExpr(
const Expr *base,
4204 unsigned NumTemplateArgs,
4209 mangleMemberExprBase(base, isArrow);
4210 mangleUnresolvedName(qualifier, member, TemplateArgs, NumTemplateArgs, arity);
4223 if (callee == fn)
return false;
4227 if (!lookup)
return false;
4244void CXXNameMangler::mangleCastExpression(
const Expr *E, StringRef CastEncoding) {
4246 Out << CastEncoding;
4251void CXXNameMangler::mangleInitListElements(
const InitListExpr *InitList) {
4253 InitList = Syntactic;
4254 for (
unsigned i = 0, e = InitList->
getNumInits(); i != e; ++i)
4255 mangleExpression(InitList->
getInit(i));
4258void CXXNameMangler::mangleExpression(
const Expr *E,
unsigned Arity,
4259 bool AsTemplateArg) {
4288 QualType ImplicitlyConvertedToType;
4292 bool IsPrimaryExpr =
true;
4293 auto NotPrimaryExpr = [&] {
4294 if (AsTemplateArg && IsPrimaryExpr)
4296 IsPrimaryExpr =
false;
4299 auto MangleDeclRefExpr = [&](
const NamedDecl *D) {
4300 switch (D->getKind()) {
4310 mangleFunctionParam(cast<ParmVarDecl>(D));
4313 case Decl::EnumConstant: {
4320 case Decl::NonTypeTemplateParm:
4333 case Expr::NoStmtClass:
4334#define ABSTRACT_STMT(Type)
4335#define EXPR(Type, Base)
4336#define STMT(Type, Base) \
4337 case Expr::Type##Class:
4338#include "clang/AST/StmtNodes.inc"
4343 case Expr::AddrLabelExprClass:
4344 case Expr::DesignatedInitUpdateExprClass:
4345 case Expr::ImplicitValueInitExprClass:
4346 case Expr::ArrayInitLoopExprClass:
4347 case Expr::ArrayInitIndexExprClass:
4348 case Expr::NoInitExprClass:
4349 case Expr::ParenListExprClass:
4350 case Expr::MSPropertyRefExprClass:
4351 case Expr::MSPropertySubscriptExprClass:
4352 case Expr::TypoExprClass:
4353 case Expr::RecoveryExprClass:
4354 case Expr::OMPArraySectionExprClass:
4355 case Expr::OMPArrayShapingExprClass:
4356 case Expr::OMPIteratorExprClass:
4357 case Expr::CXXInheritedCtorInitExprClass:
4358 case Expr::CXXParenListInitExprClass:
4359 llvm_unreachable(
"unexpected statement kind");
4361 case Expr::ConstantExprClass:
4362 E = cast<ConstantExpr>(E)->getSubExpr();
4366 case Expr::BlockExprClass:
4367 case Expr::ChooseExprClass:
4368 case Expr::CompoundLiteralExprClass:
4369 case Expr::ExtVectorElementExprClass:
4370 case Expr::GenericSelectionExprClass:
4371 case Expr::ObjCEncodeExprClass:
4372 case Expr::ObjCIsaExprClass:
4373 case Expr::ObjCIvarRefExprClass:
4374 case Expr::ObjCMessageExprClass:
4375 case Expr::ObjCPropertyRefExprClass:
4376 case Expr::ObjCProtocolExprClass:
4377 case Expr::ObjCSelectorExprClass:
4378 case Expr::ObjCStringLiteralClass:
4379 case Expr::ObjCBoxedExprClass:
4380 case Expr::ObjCArrayLiteralClass:
4381 case Expr::ObjCDictionaryLiteralClass:
4382 case Expr::ObjCSubscriptRefExprClass:
4383 case Expr::ObjCIndirectCopyRestoreExprClass:
4384 case Expr::ObjCAvailabilityCheckExprClass:
4385 case Expr::OffsetOfExprClass:
4386 case Expr::PredefinedExprClass:
4387 case Expr::ShuffleVectorExprClass:
4388 case Expr::ConvertVectorExprClass:
4389 case Expr::StmtExprClass:
4390 case Expr::TypeTraitExprClass:
4391 case Expr::RequiresExprClass:
4392 case Expr::ArrayTypeTraitExprClass:
4393 case Expr::ExpressionTraitExprClass:
4394 case Expr::VAArgExprClass:
4395 case Expr::CUDAKernelCallExprClass:
4396 case Expr::AsTypeExprClass:
4397 case Expr::PseudoObjectExprClass:
4398 case Expr::AtomicExprClass:
4399 case Expr::SourceLocExprClass:
4400 case Expr::BuiltinBitCastExprClass:
4407 "cannot yet mangle expression type %0");
4415 case Expr::CXXUuidofExprClass: {
4420 if (Context.getASTContext().
getLangOpts().getClangABICompat() >
4421 LangOptions::ClangABI::Ver11) {
4422 Out <<
"u8__uuidof";
4431 Out <<
"u8__uuidoft";
4435 Out <<
"u8__uuidofz";
4436 mangleExpression(UuidExp);
4443 case Expr::BinaryConditionalOperatorClass: {
4448 "?: operator with omitted middle operand cannot be mangled");
4455 case Expr::OpaqueValueExprClass:
4456 llvm_unreachable(
"cannot mangle opaque value; mangling wrong thing?");
4458 case Expr::InitListExprClass: {
4461 mangleInitListElements(cast<InitListExpr>(E));
4466 case Expr::DesignatedInitExprClass: {
4468 auto *DIE = cast<DesignatedInitExpr>(E);
4469 for (
const auto &
Designator : DIE->designators()) {
4475 mangleExpression(DIE->getArrayIndex(
Designator));
4478 "unknown designator kind");
4480 mangleExpression(DIE->getArrayRangeStart(
Designator));
4481 mangleExpression(DIE->getArrayRangeEnd(
Designator));
4484 mangleExpression(DIE->getInit());
4488 case Expr::CXXDefaultArgExprClass:
4489 E = cast<CXXDefaultArgExpr>(E)->getExpr();
4492 case Expr::CXXDefaultInitExprClass:
4493 E = cast<CXXDefaultInitExpr>(E)->getExpr();
4496 case Expr::CXXStdInitializerListExprClass:
4497 E = cast<CXXStdInitializerListExpr>(E)->getSubExpr();
4500 case Expr::SubstNonTypeTemplateParmExprClass:
4501 E = cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement();
4504 case Expr::UserDefinedLiteralClass:
4507 case Expr::CXXMemberCallExprClass:
4508 case Expr::CallExprClass: {
4510 const CallExpr *CE = cast<CallExpr>(E);
4529 if (isa<PackExpansionExpr>(Arg))
4530 CallArity = UnknownArity;
4532 mangleExpression(CE->
getCallee(), CallArity);
4534 mangleExpression(Arg);
4539 case Expr::CXXNewExprClass: {
4543 Out << (New->
isArray() ?
"na" :
"nw");
4546 mangleExpression(*I);
4560 mangleExpression(*I);
4561 }
else if (
const ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init)) {
4562 for (
unsigned i = 0, e = PLE->getNumExprs(); i != e; ++i)
4563 mangleExpression(PLE->getExpr(i));
4565 isa<InitListExpr>(Init)) {
4567 mangleInitListElements(cast<InitListExpr>(Init));
4569 mangleExpression(Init);
4575 case Expr::CXXPseudoDestructorExprClass: {
4577 const auto *PDE = cast<CXXPseudoDestructorExpr>(E);
4578 if (
const Expr *
Base = PDE->getBase())
4579 mangleMemberExprBase(
Base, PDE->isArrow());
4583 mangleUnresolvedPrefix(Qualifier,
4585 mangleUnresolvedTypeOrSimpleId(ScopeInfo->getType());
4589 if (!mangleUnresolvedTypeOrSimpleId(ScopeInfo->getType()))
4592 }
else if (Qualifier) {
4593 mangleUnresolvedPrefix(Qualifier);
4597 QualType DestroyedType = PDE->getDestroyedType();
4598 mangleUnresolvedTypeOrSimpleId(DestroyedType);
4602 case Expr::MemberExprClass: {
4613 case Expr::UnresolvedMemberExprClass: {
4624 case Expr::CXXDependentScopeMemberExprClass: {
4627 = cast<CXXDependentScopeMemberExpr>(E);
4637 case Expr::UnresolvedLookupExprClass: {
4646 case Expr::CXXUnresolvedConstructExprClass: {
4652 assert(N == 1 &&
"unexpected form for list initialization");
4653 auto *IL = cast<InitListExpr>(CE->
getArg(0));
4656 mangleInitListElements(IL);
4663 if (N != 1) Out <<
'_';
4664 for (
unsigned I = 0; I != N; ++I) mangleExpression(CE->
getArg(I));
4665 if (N != 1) Out <<
'E';
4669 case Expr::CXXConstructExprClass: {
4671 const auto *CE = cast<CXXConstructExpr>(E);
4676 "implicit CXXConstructExpr must have one argument");
4677 E = cast<CXXConstructExpr>(E)->getArg(0);
4683 mangleExpression(E);
4688 case Expr::CXXTemporaryObjectExprClass: {
4690 const auto *CE = cast<CXXTemporaryObjectExpr>(E);
4699 if (!List && N != 1)
4701 if (CE->isStdInitListInitialization()) {
4707 auto *ILE = cast<InitListExpr>(SILE->getSubExpr()->IgnoreImplicit());
4708 mangleInitListElements(ILE);
4711 mangleExpression(E);
4718 case Expr::CXXScalarValueInitExprClass:
4725 case Expr::CXXNoexceptExprClass:
4728 mangleExpression(cast<CXXNoexceptExpr>(E)->getOperand());
4731 case Expr::UnaryExprOrTypeTraitExprClass: {
4746 : ImplicitlyConvertedToType;
4748 mangleIntegerLiteral(T,
V);
4754 auto MangleAlignofSizeofArg = [&] {
4767 MangleAlignofSizeofArg();
4769 case UETT_PreferredAlignOf:
4773 if (Context.getASTContext().
getLangOpts().getClangABICompat() >
4774 LangOptions::ClangABI::Ver11) {
4775 Out <<
"u11__alignof__";
4786 MangleAlignofSizeofArg();
4788 case UETT_VecStep: {
4791 "cannot yet mangle vec_step expression");
4795 case UETT_OpenMPRequiredSimdAlign: {
4799 "cannot yet mangle __builtin_omp_required_simd_align expression");
4807 case Expr::CXXThrowExprClass: {
4821 case Expr::CXXTypeidExprClass: {
4836 case Expr::CXXDeleteExprClass: {
4847 case Expr::UnaryOperatorClass: {
4856 case Expr::ArraySubscriptExprClass: {
4863 mangleExpression(AE->
getLHS());
4864 mangleExpression(AE->
getRHS());
4868 case Expr::MatrixSubscriptExprClass: {
4872 mangleExpression(ME->
getBase());
4878 case Expr::CompoundAssignOperatorClass:
4879 case Expr::BinaryOperatorClass: {
4887 mangleExpression(BO->
getLHS());
4888 mangleExpression(BO->
getRHS());
4892 case Expr::CXXRewrittenBinaryOperatorClass: {
4896 cast<CXXRewrittenBinaryOperator>(E)->getDecomposedForm();
4899 mangleExpression(Decomposed.
LHS);
4900 mangleExpression(Decomposed.
RHS);
4904 case Expr::ConditionalOperatorClass: {
4907 mangleOperatorName(OO_Conditional, 3);
4908 mangleExpression(CO->
getCond());
4909 mangleExpression(CO->
getLHS(), Arity);
4910 mangleExpression(CO->
getRHS(), Arity);
4914 case Expr::ImplicitCastExprClass: {
4915 ImplicitlyConvertedToType = E->
getType();
4916 E = cast<ImplicitCastExpr>(E)->getSubExpr();
4920 case Expr::ObjCBridgedCastExprClass: {
4924 StringRef
Kind = cast<ObjCBridgedCastExpr>(E)->getBridgeKindName();
4925 Out <<
"v1U" <<
Kind.size() <<
Kind;
4926 mangleCastExpression(E,
"cv");
4930 case Expr::CStyleCastExprClass:
4932 mangleCastExpression(E,
"cv");
4935 case Expr::CXXFunctionalCastExprClass: {
4937 auto *
Sub = cast<ExplicitCastExpr>(E)->getSubExpr()->IgnoreImplicit();
4939 if (
auto *CCE = dyn_cast<CXXConstructExpr>(Sub))
4940 if (CCE->getParenOrBraceRange().isInvalid())
4941 Sub = CCE->getArg(0)->IgnoreImplicit();
4942 if (
auto *StdInitList = dyn_cast<CXXStdInitializerListExpr>(Sub))
4943 Sub = StdInitList->getSubExpr()->IgnoreImplicit();
4944 if (
auto *IL = dyn_cast<InitListExpr>(Sub)) {
4947 mangleInitListElements(IL);
4950 mangleCastExpression(E,
"cv");
4955 case Expr::CXXStaticCastExprClass:
4957 mangleCastExpression(E,
"sc");
4959 case Expr::CXXDynamicCastExprClass:
4961 mangleCastExpression(E,
"dc");
4963 case Expr::CXXReinterpretCastExprClass:
4965 mangleCastExpression(E,
"rc");
4967 case Expr::CXXConstCastExprClass:
4969 mangleCastExpression(E,
"cc");
4971 case Expr::CXXAddrspaceCastExprClass:
4973 mangleCastExpression(E,
"ac");
4976 case Expr::CXXOperatorCallExprClass: {
4985 for (
unsigned i = 0; i != NumArgs; ++i)
4986 mangleExpression(CE->
getArg(i));
4990 case Expr::ParenExprClass:
4991 E = cast<ParenExpr>(E)->getSubExpr();
4994 case Expr::ConceptSpecializationExprClass: {
4997 auto *CSE = cast<ConceptSpecializationExpr>(E);
4998 mangleTemplateName(CSE->getNamedConcept(), CSE->getTemplateArguments());
5003 case Expr::DeclRefExprClass:
5005 MangleDeclRefExpr(cast<DeclRefExpr>(E)->getDecl());
5008 case Expr::SubstNonTypeTemplateParmPackExprClass:
5014 Out <<
"_SUBSTPACK_";
5017 case Expr::FunctionParmPackExprClass: {
5021 Out <<
"v110_SUBSTPACK";
5026 case Expr::DependentScopeDeclRefExprClass: {
5035 case Expr::CXXBindTemporaryExprClass:
5036 E = cast<CXXBindTemporaryExpr>(E)->getSubExpr();
5039 case Expr::ExprWithCleanupsClass:
5040 E = cast<ExprWithCleanups>(E)->getSubExpr();
5043 case Expr::FloatingLiteralClass: {
5050 case Expr::FixedPointLiteralClass:
5052 mangleFixedPointLiteral();
5055 case Expr::CharacterLiteralClass:
5059 Out << cast<CharacterLiteral>(E)->getValue();
5064 case Expr::ObjCBoolLiteralExprClass:
5067 Out << (cast<ObjCBoolLiteralExpr>(E)->getValue() ?
'1' :
'0');
5071 case Expr::CXXBoolLiteralExprClass:
5074 Out << (cast<CXXBoolLiteralExpr>(E)->getValue() ?
'1' :
'0');
5078 case Expr::IntegerLiteralClass: {
5082 Value.setIsSigned(
true);
5087 case Expr::ImaginaryLiteralClass: {
5095 dyn_cast<FloatingLiteral>(IE->
getSubExpr())) {
5097 mangleFloat(llvm::APFloat(Imag->getValue().getSemantics()));
5099 mangleFloat(Imag->getValue());
5102 llvm::APSInt
Value(cast<IntegerLiteral>(IE->
getSubExpr())->getValue());
5104 Value.setIsSigned(
true);
5105 mangleNumber(
Value);
5111 case Expr::StringLiteralClass: {
5115 assert(isa<ConstantArrayType>(E->
getType()));
5121 case Expr::GNUNullExprClass:
5124 mangleIntegerLiteral(E->
getType(), llvm::APSInt(32));
5127 case Expr::CXXNullPtrLiteralExprClass: {
5133 case Expr::LambdaExprClass: {
5138 mangleType(Context.getASTContext().
getRecordType(cast<LambdaExpr>(E)->getLambdaClass()));
5143 case Expr::PackExpansionExprClass:
5146 mangleExpression(cast<PackExpansionExpr>(E)->getPattern());
5149 case Expr::SizeOfPackExprClass: {
5151 auto *SPE = cast<SizeOfPackExpr>(E);
5152 if (SPE->isPartiallySubstituted()) {
5154 for (
const auto &A : SPE->getPartialArguments())
5155 mangleTemplateArg(A,
false);
5163 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
5165 = dyn_cast<NonTypeTemplateParmDecl>(Pack))
5166 mangleTemplateParameter(NTTP->getDepth(), NTTP->getIndex());
5168 = dyn_cast<TemplateTemplateParmDecl>(Pack))
5169 mangleTemplateParameter(TempTP->getDepth(), TempTP->getIndex());
5171 mangleFunctionParam(cast<ParmVarDecl>(Pack));
5175 case Expr::MaterializeTemporaryExprClass:
5176 E = cast<MaterializeTemporaryExpr>(E)->getSubExpr();
5179 case Expr::CXXFoldExprClass: {
5181 auto *FE = cast<CXXFoldExpr>(E);
5182 if (FE->isLeftFold())
5183 Out << (FE->getInit() ?
"fL" :
"fl");
5185 Out << (FE->getInit() ?
"fR" :
"fr");
5187 if (FE->getOperator() == BO_PtrMemD)
5195 mangleExpression(FE->getLHS());
5197 mangleExpression(FE->getRHS());
5201 case Expr::CXXThisExprClass:
5206 case Expr::CoawaitExprClass:
5209 Out <<
"v18co_await";
5210 mangleExpression(cast<CoawaitExpr>(E)->getOperand());
5213 case Expr::DependentCoawaitExprClass:
5216 Out <<
"v18co_await";
5217 mangleExpression(cast<DependentCoawaitExpr>(E)->getOperand());
5220 case Expr::CoyieldExprClass:
5223 Out <<
"v18co_yield";
5224 mangleExpression(cast<CoawaitExpr>(E)->getOperand());
5226 case Expr::SYCLUniqueStableNameExprClass: {
5227 const auto *USN = cast<SYCLUniqueStableNameExpr>(E);
5230 Out <<
"u33__builtin_sycl_unique_stable_name";
5231 mangleType(USN->getTypeSourceInfo()->getType());
5238 if (AsTemplateArg && !IsPrimaryExpr)
5270void CXXNameMangler::mangleFunctionParam(
const ParmVarDecl *parm) {
5277 assert(parmDepth < FunctionTypeDepth.getDepth());
5278 unsigned nestingDepth = FunctionTypeDepth.getDepth() - parmDepth;
5279 if (FunctionTypeDepth.isInResultType())
5282 if (nestingDepth == 0) {
5285 Out <<
"fL" << (nestingDepth - 1) <<
'p';
5293 &&
"parameter's type is still an array type?");
5296 dyn_cast<DependentAddressSpaceType>(parm->
getType())) {
5303 if (parmIndex != 0) {
5304 Out << (parmIndex - 1);
5309void CXXNameMangler::mangleCXXCtorType(
CXXCtorType T,
5332 llvm_unreachable(
"closure constructors don't exist for the Itanium ABI!");
5335 mangleName(InheritedFrom);
5338void CXXNameMangler::mangleCXXDtorType(
CXXDtorType T) {
5363struct TemplateArgManglingInfo {
5365 bool SeenPackExpansionIntoNonPack =
false;
5366 const NamedDecl *UnresolvedExpandedPack =
nullptr;
5370 ResolvedTemplate = TD;
5380 if (!ResolvedTemplate || SeenPackExpansionIntoNonPack)
5384 const NamedDecl *Param = UnresolvedExpandedPack;
5386 assert(ParamIdx < ResolvedTemplate->getTemplateParameters()->size() &&
5387 "no parameter for argument");
5396 "failed to form pack argument for parameter pack");
5397 UnresolvedExpandedPack = Param;
5406 SeenPackExpansionIntoNonPack =
true;
5413 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(ResolvedTemplate)) {
5414 auto *RD = dyn_cast<CXXRecordDecl>(FTD->getDeclContext());
5415 if (!RD || !RD->isGenericLambda())
5426 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param);
5427 return NTTP && NTTP->getType()->getContainedDeducedType();
5432void CXXNameMangler::mangleTemplateArgs(
TemplateName TN,
5434 unsigned NumTemplateArgs) {
5437 TemplateArgManglingInfo Info(TN);
5438 for (
unsigned i = 0; i != NumTemplateArgs; ++i)
5440 Info.needExactType(i, TemplateArgs[i].getArgument()));
5444void CXXNameMangler::mangleTemplateArgs(
TemplateName TN,
5448 TemplateArgManglingInfo Info(TN);
5449 for (
unsigned i = 0, e = AL.
size(); i != e; ++i)
5450 mangleTemplateArg(AL[i], Info.needExactType(i, AL[i]));
5454void CXXNameMangler::mangleTemplateArgs(
TemplateName TN,
5458 TemplateArgManglingInfo Info(TN);
5459 for (
unsigned i = 0; i != Args.size(); ++i)
5460 mangleTemplateArg(Args[i], Info.needExactType(i, Args[i]));
5464void CXXNameMangler::mangleTemplateArg(
TemplateArgument A,
bool NeedExactType) {
5474 llvm_unreachable(
"Cannot mangle NULL template argument");
5501 auto *TPO = cast<TemplateParamObjectDecl>(D);
5502 mangleValueInTemplateArg(TPO->getType().getUnqualifiedType(),
5503 TPO->getValue(),
true,
5517 LangOptions::ClangABI::Ver11)
5539 mangleTemplateArg(
P, NeedExactType);
5545void CXXNameMangler::mangleTemplateArgExpr(
const Expr *E) {
5547 if (Ctx.
getLangOpts().getClangABICompat() > LangOptions::ClangABI::Ver11) {
5548 mangleExpression(E, UnknownArity,
true);
5563 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
5565 if (isa<VarDecl>(D) || isa<FunctionDecl>(D)) {
5573 mangleExpression(E);
5586 switch (
V.getKind()) {
5594 assert(RD &&
"unexpected type for record value");
5603 if (!FD->isUnnamedBitfield() &&
5613 assert(RD &&
"unexpected type for union value");
5616 if (!FD->isUnnamedBitfield())
5627 for (
unsigned I = 0, N =
V.getArrayInitializedElts(); I != N; ++I)
5635 for (
unsigned I = 0, N =
V.getVectorLength(); I != N; ++I)
5645 return V.getFloat().isPosZero();
5648 return !
V.getFixedPoint().getValue();
5651 return V.getComplexFloatReal().isPosZero() &&
5652 V.getComplexFloatImag().isPosZero();
5655 return !
V.getComplexIntReal() && !
V.getComplexIntImag();
5658 return V.isNullPointer();
5661 return !
V.getMemberPointerDecl();
5664 llvm_unreachable(
"Unhandled APValue::ValueKind enum");
5671 T = AT->getElementType();
5673 dyn_cast<FieldDecl>(E.getAsBaseOrMember().getPointer()))
5677 cast<CXXRecordDecl>(E.getAsBaseOrMember().getPointer()));
5718 Diags.
Report(UnionLoc, DiagID);
5725 bool NeedExactType) {
5728 T = getASTContext().getUnqualifiedArrayType(T, Quals);
5731 bool IsPrimaryExpr =
true;
5732 auto NotPrimaryExpr = [&] {
5733 if (TopLevel && IsPrimaryExpr)
5735 IsPrimaryExpr =
false;
5739 switch (
V.getKind()) {
5748 llvm_unreachable(
"unexpected value kind in template argument");
5752 assert(RD &&
"unexpected type for record value");
5758 (Fields.back()->isUnnamedBitfield() ||
5760 V.getStructField(Fields.back()->getFieldIndex())))) {
5764 if (Fields.empty()) {
5765 while (!Bases.empty() &&
5767 V.getStructBase(Bases.size() - 1)))
5768 Bases = Bases.drop_back();
5775 for (
unsigned I = 0, N = Bases.size(); I != N; ++I)
5776 mangleValueInTemplateArg(Bases[I].getType(),
V.getStructBase(I),
false);
5777 for (
unsigned I = 0, N = Fields.size(); I != N; ++I) {
5778 if (Fields[I]->isUnnamedBitfield())
5780 mangleValueInTemplateArg(Fields[I]->getType(),
5781 V.getStructField(Fields[I]->getFieldIndex()),