36 #include "llvm/ADT/StringExtras.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/raw_ostream.h"
39 #include "llvm/TargetParser/RISCVTargetParser.h"
42 using namespace clang;
46 static bool isLocalContainerContext(
const DeclContext *DC) {
47 return isa<FunctionDecl>(DC) || isa<ObjCMethodDecl>(DC) || isa<BlockDecl>(DC);
52 return ftd->getTemplatedDecl();
59 return (fn ? getStructor(fn) :
decl);
62 static bool isLambda(
const NamedDecl *ND) {
70 static const unsigned UnknownArity = ~0
U;
73 typedef std::pair<const DeclContext*, IdentifierInfo*> DiscriminatorKeyTy;
74 llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator;
75 llvm::DenseMap<const NamedDecl*, unsigned> Uniquifier;
76 const DiscriminatorOverrideTy DiscriminatorOverride =
nullptr;
79 bool NeedsUniqueInternalLinkageNames =
false;
82 explicit ItaniumMangleContextImpl(
84 DiscriminatorOverrideTy DiscriminatorOverride,
bool IsAux =
false)
86 DiscriminatorOverride(DiscriminatorOverride) {}
91 bool shouldMangleCXXName(
const NamedDecl *
D)
override;
92 bool shouldMangleStringLiteral(
const StringLiteral *)
override {
97 void needsUniqueInternalLinkageNames()
override {
98 NeedsUniqueInternalLinkageNames =
true;
101 void mangleCXXName(
GlobalDecl GD, raw_ostream &)
override;
103 raw_ostream &)
override;
105 const ThunkInfo &Thunk,
bool, raw_ostream &)
override;
106 void mangleReferenceTemporary(
const VarDecl *
D,
unsigned ManglingNumber,
107 raw_ostream &)
override;
108 void mangleCXXVTable(
const CXXRecordDecl *RD, raw_ostream &)
override;
109 void mangleCXXVTT(
const CXXRecordDecl *RD, raw_ostream &)
override;
112 void mangleCXXRTTI(
QualType T, raw_ostream &)
override;
113 void mangleCXXRTTIName(
QualType T, raw_ostream &,
114 bool NormalizeIntegers)
override;
115 void mangleCanonicalTypeName(
QualType T, raw_ostream &,
116 bool NormalizeIntegers)
override;
120 void mangleStaticGuardVariable(
const VarDecl *
D, raw_ostream &)
override;
121 void mangleDynamicInitializer(
const VarDecl *
D, raw_ostream &Out)
override;
122 void mangleDynamicAtExitDestructor(
const VarDecl *
D,
123 raw_ostream &Out)
override;
124 void mangleDynamicStermFinalizer(
const VarDecl *
D, raw_ostream &Out)
override;
125 void mangleSEHFilterExpression(
GlobalDecl EnclosingDecl,
126 raw_ostream &Out)
override;
127 void mangleSEHFinallyBlock(
GlobalDecl EnclosingDecl,
128 raw_ostream &Out)
override;
129 void mangleItaniumThreadLocalInit(
const VarDecl *
D, raw_ostream &)
override;
130 void mangleItaniumThreadLocalWrapper(
const VarDecl *
D,
131 raw_ostream &)
override;
133 void mangleStringLiteral(
const StringLiteral *, raw_ostream &)
override;
135 void mangleLambdaSig(
const CXXRecordDecl *Lambda, raw_ostream &)
override;
137 void mangleModuleInitializer(
const Module *
Module, raw_ostream &)
override;
139 bool getNextDiscriminator(
const NamedDecl *ND,
unsigned &disc) {
145 if (
const TagDecl *Tag = dyn_cast<TagDecl>(ND)) {
146 if (
Tag->getName().empty() && !
Tag->getTypedefNameForAnonDecl())
152 unsigned discriminator = getASTContext().getManglingNumber(ND, isAux());
153 if (discriminator == 1)
155 disc = discriminator - 2;
160 unsigned &discriminator = Uniquifier[ND];
161 if (!discriminator) {
162 const DeclContext *DC = getEffectiveDeclContext(ND);
163 discriminator = ++Discriminator[std::make_pair(DC, ND->
getIdentifier())];
165 if (discriminator == 1)
167 disc = discriminator-2;
171 std::string getLambdaString(
const CXXRecordDecl *Lambda)
override {
174 assert(Lambda->
isLambda() &&
"RD must be a lambda!");
175 std::string Name(
"<lambda");
179 const ParmVarDecl *Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
184 unsigned DefaultArgNo =
186 Name += llvm::utostr(DefaultArgNo);
190 if (LambdaManglingNumber)
191 LambdaId = LambdaManglingNumber;
193 LambdaId = getAnonymousStructIdForDebugInfo(Lambda);
195 Name += llvm::utostr(LambdaId);
200 DiscriminatorOverrideTy getDiscriminatorOverride()
const override {
201 return DiscriminatorOverride;
208 return getEffectiveDeclContext(cast<Decl>(DC));
211 bool isInternalLinkageDecl(
const NamedDecl *ND);
217 class CXXNameMangler {
218 ItaniumMangleContextImpl &Context;
222 bool NormalizeIntegers =
false;
224 bool NullOut =
false;
229 bool DisableDerivedAbiTags =
false;
235 unsigned StructorType = 0;
240 unsigned TemplateDepthOffset = 0;
245 class FunctionTypeDepthState {
248 enum { InResultTypeMask = 1 };
251 FunctionTypeDepthState() =
default;
254 unsigned getDepth()
const {
259 bool isInResultType()
const {
260 return Bits & InResultTypeMask;
263 FunctionTypeDepthState push() {
264 FunctionTypeDepthState tmp = *
this;
265 Bits = (Bits & ~InResultTypeMask) + 2;
269 void enterResultType() {
270 Bits |= InResultTypeMask;
273 void leaveResultType() {
274 Bits &= ~InResultTypeMask;
277 void pop(FunctionTypeDepthState saved) {
278 assert(getDepth() == saved.getDepth() + 1);
293 class AbiTagState final {
295 explicit AbiTagState(AbiTagState *&Head) : LinkHead(Head) {
301 AbiTagState(
const AbiTagState &) =
delete;
302 AbiTagState &operator=(
const AbiTagState &) =
delete;
304 ~AbiTagState() { pop(); }
306 void write(raw_ostream &Out,
const NamedDecl *ND,
307 const AbiTagList *AdditionalAbiTags) {
309 if (!isa<FunctionDecl>(ND) && !isa<VarDecl>(ND)) {
311 !AdditionalAbiTags &&
312 "only function and variables need a list of additional abi tags");
313 if (
const auto *NS = dyn_cast<NamespaceDecl>(ND)) {
314 if (
const auto *AbiTag = NS->getAttr<AbiTagAttr>()) {
315 UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(),
316 AbiTag->tags().end());
324 if (
const auto *AbiTag = ND->
getAttr<AbiTagAttr>()) {
325 UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(),
326 AbiTag->tags().end());
327 TagList.insert(TagList.end(), AbiTag->tags().begin(),
328 AbiTag->tags().end());
331 if (AdditionalAbiTags) {
332 UsedAbiTags.insert(UsedAbiTags.end(), AdditionalAbiTags->begin(),
333 AdditionalAbiTags->end());
334 TagList.insert(TagList.end(), AdditionalAbiTags->begin(),
335 AdditionalAbiTags->end());
339 TagList.erase(std::unique(TagList.begin(), TagList.end()), TagList.end());
341 writeSortedUniqueAbiTags(Out, TagList);
344 const AbiTagList &getUsedAbiTags()
const {
return UsedAbiTags; }
345 void setUsedAbiTags(
const AbiTagList &AbiTags) {
346 UsedAbiTags = AbiTags;
349 const AbiTagList &getEmittedAbiTags()
const {
350 return EmittedAbiTags;
353 const AbiTagList &getSortedUniqueUsedAbiTags() {
354 llvm::sort(UsedAbiTags);
355 UsedAbiTags.erase(std::unique(UsedAbiTags.begin(), UsedAbiTags.end()),
362 AbiTagList UsedAbiTags;
364 AbiTagList EmittedAbiTags;
366 AbiTagState *&LinkHead;
367 AbiTagState *
Parent =
nullptr;
370 assert(LinkHead ==
this &&
371 "abi tag link head must point to us on destruction");
374 UsedAbiTags.begin(), UsedAbiTags.end());
375 Parent->EmittedAbiTags.insert(
Parent->EmittedAbiTags.end(),
376 EmittedAbiTags.begin(),
377 EmittedAbiTags.end());
382 void writeSortedUniqueAbiTags(raw_ostream &Out,
const AbiTagList &AbiTags) {
383 for (
const auto &Tag : AbiTags) {
384 EmittedAbiTags.push_back(Tag);
392 AbiTagState *AbiTags =
nullptr;
393 AbiTagState AbiTagsRoot;
395 llvm::DenseMap<uintptr_t, unsigned> Substitutions;
396 llvm::DenseMap<StringRef, unsigned> ModuleSubstitutions;
398 ASTContext &getASTContext()
const {
return Context.getASTContext(); }
401 return Context.getASTContext().
getLangOpts().getClangABICompat() <= Ver;
410 llvm::StringRef Name,
bool HasAllocator);
413 CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
414 const NamedDecl *
D =
nullptr,
bool NullOut_ =
false)
415 : Context(
C), Out(Out_), NullOut(NullOut_), Structor(getStructor(
D)),
416 AbiTagsRoot(AbiTags) {
418 assert(!
D || (!isa<CXXDestructorDecl>(
D) &&
419 !isa<CXXConstructorDecl>(
D)));
421 CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
423 : Context(
C), Out(Out_), Structor(getStructor(
D)), StructorType(
Type),
424 AbiTagsRoot(AbiTags) {}
425 CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
427 : Context(
C), Out(Out_), Structor(getStructor(
D)), StructorType(
Type),
428 AbiTagsRoot(AbiTags) {}
430 CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
431 bool NormalizeIntegers_)
432 : Context(
C), Out(Out_), NormalizeIntegers(NormalizeIntegers_),
433 NullOut(
false), Structor(nullptr), AbiTagsRoot(AbiTags) {}
434 CXXNameMangler(CXXNameMangler &Outer, raw_ostream &Out_)
435 : Context(Outer.Context), Out(Out_), Structor(Outer.Structor),
436 StructorType(Outer.StructorType), SeqID(Outer.SeqID),
437 FunctionTypeDepth(Outer.FunctionTypeDepth), AbiTagsRoot(AbiTags),
438 Substitutions(Outer.Substitutions),
439 ModuleSubstitutions(Outer.ModuleSubstitutions) {}
441 CXXNameMangler(CXXNameMangler &Outer, llvm::raw_null_ostream &Out_)
442 : CXXNameMangler(Outer, (raw_ostream &)Out_) {
446 struct WithTemplateDepthOffset {
unsigned Offset; };
447 CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out,
448 WithTemplateDepthOffset
Offset)
449 : CXXNameMangler(
C, Out) {
450 TemplateDepthOffset =
Offset.Offset;
453 raw_ostream &getStream() {
return Out; }
455 void disableDerivedAbiTags() { DisableDerivedAbiTags =
true; }
456 static bool shouldHaveAbiTags(ItaniumMangleContextImpl &C,
const VarDecl *VD);
461 void mangleNumber(
int64_t Number);
464 void mangleSeqID(
unsigned SeqID);
467 void mangleNameOrStandardSubstitution(
const NamedDecl *ND);
469 void mangleModuleNamePrefix(StringRef Name,
bool IsPartition =
false);
470 void mangleVendorQualifier(StringRef Name);
474 bool mangleSubstitution(
const NamedDecl *ND);
482 bool mangleStandardSubstitution(
const NamedDecl *ND);
484 void addSubstitution(
const NamedDecl *ND) {
487 addSubstitution(
reinterpret_cast<uintptr_t>(ND));
492 addSubstitution(
reinterpret_cast<uintptr_t>(NNS));
498 void extendSubstitutions(CXXNameMangler* Other);
501 bool recursive =
false);
505 unsigned NumTemplateArgs,
506 unsigned KnownArity = UnknownArity);
508 void mangleFunctionEncodingBareType(
const FunctionDecl *FD);
511 const AbiTagList *AdditionalAbiTags);
512 void mangleModuleName(
const NamedDecl *ND);
516 const AbiTagList *AdditionalAbiTags) {
517 mangleUnqualifiedName(GD, cast<NamedDecl>(GD.
getDecl())->getDeclName(), DC,
518 UnknownArity, AdditionalAbiTags);
522 const AbiTagList *AdditionalAbiTags);
524 const AbiTagList *AdditionalAbiTags);
526 const AbiTagList *AdditionalAbiTags);
530 void mangleSourceNameWithAbiTags(
531 const NamedDecl *ND,
const AbiTagList *AdditionalAbiTags =
nullptr);
533 const AbiTagList *AdditionalAbiTags);
534 void mangleBlockForPrefix(
const BlockDecl *Block);
535 void mangleUnqualifiedBlock(
const BlockDecl *Block);
538 void mangleTypeConstraint(
const ConceptDecl *Concept,
541 void mangleRequiresClause(
const Expr *RequiresClause);
544 const AbiTagList *AdditionalAbiTags,
545 bool NoFunction=
false);
548 void mangleNestedNameWithClosurePrefix(
GlobalDecl GD,
550 const AbiTagList *AdditionalAbiTags);
552 void manglePrefix(
const DeclContext *DC,
bool NoFunction=
false);
554 void mangleTemplatePrefix(
GlobalDecl GD,
bool NoFunction=
false);
557 void mangleClosurePrefix(
const NamedDecl *ND,
bool NoFunction =
false);
558 bool mangleUnresolvedTypeOrSimpleId(
QualType DestroyedType,
559 StringRef Prefix =
"");
568 #define ABSTRACT_TYPE(CLASS, PARENT)
569 #define NON_CANONICAL_TYPE(CLASS, PARENT)
570 #define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T);
571 #include "clang/AST/TypeNodes.inc"
573 void mangleType(
const TagType*);
575 static StringRef getCallingConvQualifierName(
CallingConv CC);
576 void mangleExtParameterInfo(FunctionProtoType::ExtParameterInfo info);
582 void mangleAArch64NeonVectorType(
const VectorType *
T);
584 void mangleAArch64FixedSveVectorType(
const VectorType *
T);
586 void mangleRISCVFixedRVVVectorType(
const VectorType *
T);
591 void mangleFixedPointLiteral();
594 void mangleMemberExprBase(
const Expr *base,
bool isArrow);
595 void mangleMemberExpr(
const Expr *base,
bool isArrow,
600 unsigned NumTemplateArgs,
601 unsigned knownArity);
602 void mangleCastExpression(
const Expr *
E, StringRef CastEncoding);
603 void mangleInitListElements(
const InitListExpr *InitList);
606 void mangleExpression(
const Expr *
E,
unsigned Arity = UnknownArity,
607 bool AsTemplateArg =
false);
611 struct TemplateArgManglingInfo;
614 unsigned NumTemplateArgs);
617 void mangleTemplateArg(TemplateArgManglingInfo &Info,
unsigned Index,
620 void mangleTemplateArgExpr(
const Expr *
E);
622 bool NeedExactType =
false);
624 void mangleTemplateParameter(
unsigned Depth,
unsigned Index);
629 const AbiTagList *AdditionalAbiTags);
632 AbiTagList makeFunctionReturnTypeTags(
const FunctionDecl *FD);
634 AbiTagList makeVariableTypeTags(
const VarDecl *VD);
642 getASTContext(), getASTContext().getTranslationUnitDecl(),
644 &getASTContext().Idents.get(
"std"),
654 ItaniumMangleContextImpl::getEffectiveDeclContext(
const Decl *
D) {
664 dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl()))
665 return ContextParam->getDeclContext();
669 if (
const BlockDecl *BD = dyn_cast<BlockDecl>(
D)) {
671 dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl()))
672 return ContextParam->getDeclContext();
680 if (
D == getASTContext().getVaListTagDecl()) {
681 const llvm::Triple &
T = getASTContext().getTargetInfo().getTriple();
682 if (
T.isARM() ||
T.isThumb() ||
T.isAArch64())
683 return getStdNamespace();
687 if (isa<CapturedDecl>(DC) || isa<OMPDeclareReductionDecl>(DC) ||
688 isa<OMPDeclareMapperDecl>(DC)) {
689 return getEffectiveDeclContext(cast<Decl>(DC));
692 if (
const auto *VD = dyn_cast<VarDecl>(
D))
694 return getASTContext().getTranslationUnitDecl();
696 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
698 return getASTContext().getTranslationUnitDecl();
701 if (FD->isMemberLikeConstrainedFriend() &&
702 getASTContext().getLangOpts().getClangABICompat() >
710 bool ItaniumMangleContextImpl::isInternalLinkageDecl(
const NamedDecl *ND) {
713 getEffectiveDeclContext(ND)->isFileContext() &&
722 if (!NeedsUniqueInternalLinkageNames || !ND)
725 const auto *FD = dyn_cast<FunctionDecl>(ND);
734 if (isInternalLinkageDecl(ND))
740 bool ItaniumMangleContextImpl::shouldMangleCXXName(
const NamedDecl *
D) {
741 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
744 if (FD->hasAttr<OverloadableAttr>())
760 if (FD->isMSVCRTEntryPoint())
774 if (!getASTContext().getLangOpts().
CPlusPlus)
777 if (
const auto *VD = dyn_cast<VarDecl>(
D)) {
779 if (isa<DecompositionDecl>(VD))
792 DC = getEffectiveParentContext(DC);
794 !CXXNameMangler::shouldHaveAbiTags(*
this, VD) &&
795 !isa<VarTemplateSpecializationDecl>(VD) &&
796 !VD->getOwningModuleForLinkage())
803 void CXXNameMangler::writeAbiTags(
const NamedDecl *ND,
804 const AbiTagList *AdditionalAbiTags) {
805 assert(AbiTags &&
"require AbiTagState");
806 AbiTags->write(Out, ND, DisableDerivedAbiTags ?
nullptr : AdditionalAbiTags);
809 void CXXNameMangler::mangleSourceNameWithAbiTags(
810 const NamedDecl *ND,
const AbiTagList *AdditionalAbiTags) {
812 writeAbiTags(ND, AdditionalAbiTags);
820 if (isa<FunctionDecl>(GD.
getDecl()))
821 mangleFunctionEncoding(GD);
826 dyn_cast<IndirectFieldDecl>(GD.
getDecl()))
827 mangleName(IFD->getAnonField());
829 llvm_unreachable(
"unexpected kind of global decl");
832 void CXXNameMangler::mangleFunctionEncoding(
GlobalDecl GD) {
837 if (!Context.shouldMangleDeclName(FD)) {
842 AbiTagList ReturnTypeAbiTags = makeFunctionReturnTypeTags(FD);
843 if (ReturnTypeAbiTags.empty()) {
852 FunctionTypeDepthState Saved = FunctionTypeDepth.push();
854 FunctionTypeDepth.pop(Saved);
855 mangleFunctionEncodingBareType(FD);
863 llvm::raw_svector_ostream FunctionEncodingStream(FunctionEncodingBuf);
864 CXXNameMangler FunctionEncodingMangler(*
this, FunctionEncodingStream);
866 FunctionEncodingMangler.disableDerivedAbiTags();
868 FunctionTypeDepthState Saved = FunctionTypeDepth.push();
869 FunctionEncodingMangler.mangleNameWithAbiTags(FD,
nullptr);
870 FunctionTypeDepth.pop(Saved);
873 size_t EncodingPositionStart = FunctionEncodingStream.str().size();
874 FunctionEncodingMangler.mangleFunctionEncodingBareType(FD);
878 const AbiTagList &UsedAbiTags =
879 FunctionEncodingMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags();
880 AbiTagList AdditionalAbiTags(ReturnTypeAbiTags.size());
881 AdditionalAbiTags.erase(
882 std::set_difference(ReturnTypeAbiTags.begin(), ReturnTypeAbiTags.end(),
883 UsedAbiTags.begin(), UsedAbiTags.end(),
884 AdditionalAbiTags.begin()),
885 AdditionalAbiTags.end());
888 Saved = FunctionTypeDepth.push();
889 mangleNameWithAbiTags(FD, &AdditionalAbiTags);
890 FunctionTypeDepth.pop(Saved);
891 Out << FunctionEncodingStream.str().substr(EncodingPositionStart);
895 extendSubstitutions(&FunctionEncodingMangler);
898 void CXXNameMangler::mangleFunctionEncodingBareType(
const FunctionDecl *FD) {
899 if (FD->
hasAttr<EnableIfAttr>()) {
900 FunctionTypeDepthState Saved = FunctionTypeDepth.push();
901 Out <<
"Ua9enable_ifI";
902 for (AttrVec::const_iterator I = FD->
getAttrs().begin(),
905 EnableIfAttr *EIA = dyn_cast<EnableIfAttr>(*I);
913 mangleExpression(EIA->getCond());
916 mangleTemplateArgExpr(EIA->getCond());
920 FunctionTypeDepth.pop(Saved);
925 if (
auto *CD = dyn_cast<CXXConstructorDecl>(FD))
926 if (
auto Inherited = CD->getInheritedConstructor())
927 FD = Inherited.getConstructor();
945 bool MangleReturnType =
false;
947 if (!(isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD) ||
948 isa<CXXConversionDecl>(FD)))
949 MangleReturnType =
true;
952 FD = PrimaryTemplate->getTemplatedDecl();
956 MangleReturnType, FD);
961 if (!Context.getEffectiveParentContext(NS)->isTranslationUnit())
965 return II && II->
isStr(
"std");
970 bool CXXNameMangler::isStdNamespace(
const DeclContext *DC) {
974 return isStd(cast<NamespaceDecl>(DC));
981 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
990 dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
991 TemplateArgs = &Spec->getTemplateArgs();
992 return GD.
getWithDecl(Spec->getSpecializedTemplate());
997 dyn_cast<VarTemplateSpecializationDecl>(ND)) {
998 TemplateArgs = &Spec->getTemplateArgs();
999 return GD.
getWithDecl(Spec->getSpecializedTemplate());
1010 void CXXNameMangler::mangleName(
GlobalDecl GD) {
1012 if (
const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
1014 AbiTagList VariableTypeAbiTags = makeVariableTypeTags(VD);
1015 if (VariableTypeAbiTags.empty()) {
1017 mangleNameWithAbiTags(VD,
nullptr);
1022 llvm::raw_null_ostream NullOutStream;
1023 CXXNameMangler VariableNameMangler(*
this, NullOutStream);
1024 VariableNameMangler.disableDerivedAbiTags();
1025 VariableNameMangler.mangleNameWithAbiTags(VD,
nullptr);
1028 const AbiTagList &UsedAbiTags =
1029 VariableNameMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags();
1030 AbiTagList AdditionalAbiTags(VariableTypeAbiTags.size());
1031 AdditionalAbiTags.erase(
1032 std::set_difference(VariableTypeAbiTags.begin(),
1033 VariableTypeAbiTags.end(), UsedAbiTags.begin(),
1034 UsedAbiTags.end(), AdditionalAbiTags.begin()),
1035 AdditionalAbiTags.end());
1038 mangleNameWithAbiTags(VD, &AdditionalAbiTags);
1040 mangleNameWithAbiTags(GD,
nullptr);
1045 const DeclContext *DC = Context.getEffectiveDeclContext(
D);
1047 if (isLocalContainerContext(DC))
1048 return dyn_cast<RecordDecl>(
D);
1050 DC = Context.getEffectiveDeclContext(
D);
1055 void CXXNameMangler::mangleNameWithAbiTags(
GlobalDecl GD,
1056 const AbiTagList *AdditionalAbiTags) {
1063 const DeclContext *DC = Context.getEffectiveDeclContext(ND);
1064 bool IsLambda = isLambda(ND);
1070 if (isLocalContainerContext(DC) && ND->
hasLinkage() && !IsLambda)
1072 DC = Context.getEffectiveParentContext(DC);
1073 else if (GetLocalClassDecl(ND) &&
1075 mangleLocalName(GD, AdditionalAbiTags);
1079 assert(!isa<LinkageSpecDecl>(DC) &&
"context cannot be LinkageSpecDecl");
1083 if (
const NamedDecl *PrefixND = getClosurePrefix(ND)) {
1084 mangleNestedNameWithClosurePrefix(GD, PrefixND, AdditionalAbiTags);
1088 if (isLocalContainerContext(DC)) {
1089 mangleLocalName(GD, AdditionalAbiTags);
1097 mangleUnscopedTemplateName(TD, DC, AdditionalAbiTags);
1102 mangleUnscopedName(GD, DC, AdditionalAbiTags);
1106 mangleNestedName(GD, DC, AdditionalAbiTags);
1109 void CXXNameMangler::mangleModuleName(
const NamedDecl *ND) {
1112 mangleModuleNamePrefix(M->getPrimaryModuleInterfaceName());
1120 void CXXNameMangler::mangleModuleNamePrefix(StringRef Name,
bool IsPartition) {
1122 auto It = ModuleSubstitutions.find(Name);
1123 if (It != ModuleSubstitutions.end()) {
1125 mangleSeqID(It->second);
1131 auto Parts = Name.rsplit(
'.');
1132 if (Parts.second.empty())
1133 Parts.second = Parts.first;
1135 mangleModuleNamePrefix(Parts.first, IsPartition);
1136 IsPartition =
false;
1142 Out << Parts.second.size() << Parts.second;
1143 ModuleSubstitutions.insert({Name, SeqID++});
1146 void CXXNameMangler::mangleTemplateName(
const TemplateDecl *TD,
1148 const DeclContext *DC = Context.getEffectiveDeclContext(TD);
1151 mangleUnscopedTemplateName(TD, DC,
nullptr);
1154 mangleNestedName(TD, Args);
1159 const AbiTagList *AdditionalAbiTags) {
1163 assert(!isa<LinkageSpecDecl>(DC) &&
"unskipped LinkageSpecDecl");
1164 if (isStdNamespace(DC))
1167 mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
1170 void CXXNameMangler::mangleUnscopedTemplateName(
1175 if (mangleSubstitution(ND))
1179 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
1180 assert(!AdditionalAbiTags &&
1181 "template template param cannot have abi tags");
1182 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
1183 }
else if (isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND)) {
1184 mangleUnscopedName(GD, DC, AdditionalAbiTags);
1190 addSubstitution(ND);
1208 unsigned numCharacters = (valueBits.getBitWidth() + 3) / 4;
1209 assert(numCharacters != 0);
1215 for (
unsigned stringIndex = 0; stringIndex != numCharacters; ++stringIndex) {
1217 unsigned digitBitIndex = 4 * (numCharacters - stringIndex - 1);
1220 uint64_t hexDigit = valueBits.getRawData()[digitBitIndex / 64];
1221 hexDigit >>= (digitBitIndex % 64);
1225 static const char charForHex[16] = {
1226 '0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
1227 '8',
'9',
'a',
'b',
'c',
'd',
'e',
'f'
1229 buffer[stringIndex] = charForHex[hexDigit];
1232 Out.write(buffer.data(), numCharacters);
1242 void CXXNameMangler::mangleFixedPointLiteral() {
1249 void CXXNameMangler::mangleNullPointer(
QualType T) {
1257 if (
Value.isSigned() &&
Value.isNegative()) {
1265 void CXXNameMangler::mangleNumber(
int64_t Number) {
1275 void CXXNameMangler::mangleCallOffset(
int64_t NonVirtual,
int64_t Virtual) {
1283 mangleNumber(NonVirtual);
1289 mangleNumber(NonVirtual);
1291 mangleNumber(Virtual);
1297 if (!mangleSubstitution(
QualType(TST, 0))) {
1298 mangleTemplatePrefix(TST->getTemplateName());
1303 mangleTemplateArgs(TST->getTemplateName(), TST->template_arguments());
1306 }
else if (
const auto *DTST =
1308 if (!mangleSubstitution(
QualType(DTST, 0))) {
1309 TemplateName Template = getASTContext().getDependentTemplateName(
1310 DTST->getQualifier(), DTST->getIdentifier());
1311 mangleTemplatePrefix(Template);
1316 mangleTemplateArgs(Template, DTST->template_arguments());
1317 addSubstitution(
QualType(DTST, 0));
1347 switch (qualifier->
getKind()) {
1359 llvm_unreachable(
"Can't mangle __super specifier");
1363 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1371 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1388 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1395 if (mangleUnresolvedTypeOrSimpleId(
QualType(
type, 0), recursive ?
"N" :
""))
1404 mangleUnresolvedPrefix(qualifier->
getPrefix(),
1422 void CXXNameMangler::mangleUnresolvedName(
1425 unsigned knownArity) {
1426 if (qualifier) mangleUnresolvedPrefix(qualifier);
1427 switch (
name.getNameKind()) {
1430 mangleSourceName(
name.getAsIdentifierInfo());
1435 mangleUnresolvedTypeOrSimpleId(
name.getCXXNameType());
1442 mangleOperatorName(
name, knownArity);
1445 llvm_unreachable(
"Can't mangle a constructor name!");
1447 llvm_unreachable(
"Can't mangle a using directive name!");
1449 llvm_unreachable(
"Can't mangle a deduction guide name!");
1453 llvm_unreachable(
"Can't mangle Objective-C selector names here!");
1459 mangleTemplateArgs(
TemplateName(), TemplateArgs, NumTemplateArgs);
1462 void CXXNameMangler::mangleUnqualifiedName(
1464 unsigned KnownArity,
const AbiTagList *AdditionalAbiTags) {
1472 mangleModuleName(ND);
1476 auto *FD = dyn_cast<FunctionDecl>(ND);
1477 auto *FTD = dyn_cast<FunctionTemplateDecl>(ND);
1479 (FTD && FTD->getTemplatedDecl()->isMemberLikeConstrainedFriend())) {
1484 unsigned Arity = KnownArity;
1485 switch (Name.getNameKind()) {
1490 if (
auto *DD = dyn_cast<DecompositionDecl>(ND)) {
1497 for (
auto *BD : DD->bindings())
1498 mangleSourceName(BD->getDeclName().getAsIdentifierInfo());
1500 writeAbiTags(ND, AdditionalAbiTags);
1504 if (
auto *GD = dyn_cast<MSGuidDecl>(ND)) {
1507 SmallString<
sizeof(
"_GUID_12345678_1234_1234_1234_1234567890ab")> GUID;
1508 llvm::raw_svector_ostream GUIDOS(GUID);
1509 Context.mangleMSGuidDecl(GD, GUIDOS);
1510 Out << GUID.size() << GUID;
1514 if (
auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
1517 mangleValueInTemplateArg(TPO->getType().getUnqualifiedType(),
1518 TPO->getValue(),
true);
1536 if (Context.isInternalLinkageDecl(ND))
1539 bool IsRegCall = FD &&
1543 FD && FD->
hasAttr<CUDAGlobalAttr>() &&
1546 mangleDeviceStubName(II);
1548 mangleRegCallName(II);
1550 mangleSourceName(II);
1552 writeAbiTags(ND, AdditionalAbiTags);
1557 assert(ND &&
"mangling empty name without declaration");
1559 if (
const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
1562 Out <<
"12_GLOBAL__N_1";
1567 if (
const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
1581 &&
"Expected anonymous struct or union!");
1588 assert(FD->
getIdentifier() &&
"Data member name isn't an identifier!");
1601 if (isa<ObjCContainerDecl>(ND))
1605 const TagDecl *TD = cast<TagDecl>(ND);
1608 "Typedef should not be in another decl context!");
1609 assert(
D->getDeclName().getAsIdentifierInfo() &&
1610 "Typedef was not named!");
1611 mangleSourceName(
D->getDeclName().getAsIdentifierInfo());
1612 assert(!AdditionalAbiTags &&
"Type cannot have additional abi tags");
1615 writeAbiTags(TD,
nullptr);
1625 std::optional<unsigned> DeviceNumber =
1626 Context.getDiscriminatorOverride()(Context.getASTContext(),
Record);
1632 if (
Record->isLambda() &&
1633 ((DeviceNumber && *DeviceNumber > 0) ||
1634 (!DeviceNumber &&
Record->getLambdaManglingNumber() > 0))) {
1635 assert(!AdditionalAbiTags &&
1636 "Lambda type cannot have additional abi tags");
1643 unsigned UnnamedMangle =
1644 getASTContext().getManglingNumber(TD, Context.isAux());
1646 if (UnnamedMangle > 1)
1647 Out << UnnamedMangle - 2;
1649 writeAbiTags(TD, AdditionalAbiTags);
1655 unsigned AnonStructId =
1657 : Context.getAnonymousStructId(TD, dyn_cast<FunctionDecl>(DC));
1664 Str += llvm::utostr(AnonStructId);
1674 llvm_unreachable(
"Can't mangle Objective-C selector names here!");
1680 if (
auto Inherited =
1681 cast<CXXConstructorDecl>(ND)->getInheritedConstructor()) {
1682 InheritedFrom = Inherited.getConstructor()->
getParent();
1683 InheritedTemplateName =
1684 TemplateName(Inherited.getConstructor()->getPrimaryTemplate());
1685 InheritedTemplateArgs =
1686 Inherited.getConstructor()->getTemplateSpecializationArgs();
1692 mangleCXXCtorType(
static_cast<CXXCtorType>(StructorType), InheritedFrom);
1700 if (InheritedTemplateArgs)
1701 mangleTemplateArgs(InheritedTemplateName, *InheritedTemplateArgs);
1703 writeAbiTags(ND, AdditionalAbiTags);
1711 mangleCXXDtorType(
static_cast<CXXDtorType>(StructorType));
1717 writeAbiTags(ND, AdditionalAbiTags);
1721 if (ND && Arity == UnknownArity) {
1722 Arity = cast<FunctionDecl>(ND)->getNumParams();
1725 if (
const auto *MD = dyn_cast<CXXMethodDecl>(ND))
1726 if (MD->isImplicitObjectMemberFunction())
1732 mangleOperatorName(Name, Arity);
1733 writeAbiTags(ND, AdditionalAbiTags);
1737 llvm_unreachable(
"Can't mangle a deduction guide name!");
1740 llvm_unreachable(
"Can't mangle a using directive name!");
1744 void CXXNameMangler::mangleRegCallName(
const IdentifierInfo *II) {
1748 if (getASTContext().getLangOpts().RegCall4)
1749 Out << II->
getLength() +
sizeof(
"__regcall4__") - 1 <<
"__regcall4__"
1752 Out << II->
getLength() +
sizeof(
"__regcall3__") - 1 <<
"__regcall3__"
1756 void CXXNameMangler::mangleDeviceStubName(
const IdentifierInfo *II) {
1760 Out << II->
getLength() +
sizeof(
"__device_stub__") - 1 <<
"__device_stub__"
1764 void CXXNameMangler::mangleSourceName(
const IdentifierInfo *II) {
1771 void CXXNameMangler::mangleNestedName(
GlobalDecl GD,
1773 const AbiTagList *AdditionalAbiTags,
1782 if (
const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND)) {
1783 Qualifiers MethodQuals = Method->getMethodQualifiers();
1786 if (Method->isExplicitObjectMemberFunction())
1789 mangleQualifiers(MethodQuals);
1790 mangleRefQualifier(Method->getRefQualifier());
1796 mangleTemplatePrefix(TD, NoFunction);
1799 manglePrefix(DC, NoFunction);
1800 mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
1805 void CXXNameMangler::mangleNestedName(
const TemplateDecl *TD,
1811 mangleTemplatePrefix(TD);
1817 void CXXNameMangler::mangleNestedNameWithClosurePrefix(
1819 const AbiTagList *AdditionalAbiTags) {
1828 mangleClosurePrefix(PrefixND);
1829 mangleUnqualifiedName(GD,
nullptr, AdditionalAbiTags);
1840 if (
auto *CD = dyn_cast<CXXConstructorDecl>(DC))
1842 else if (
auto *DD = dyn_cast<CXXDestructorDecl>(DC))
1849 void CXXNameMangler::mangleLocalName(
GlobalDecl GD,
1850 const AbiTagList *AdditionalAbiTags) {
1857 assert(isa<NamedDecl>(
D) || isa<BlockDecl>(
D));
1859 const DeclContext *DC = Context.getEffectiveDeclContext(RD ? RD :
D);
1864 AbiTagState LocalAbiTags(AbiTags);
1867 mangleObjCMethodName(MD);
1868 else if (
const BlockDecl *BD = dyn_cast<BlockDecl>(DC))
1869 mangleBlockForPrefix(BD);
1875 LocalAbiTags.setUsedAbiTags(LocalAbiTags.getEmittedAbiTags());
1898 mangleNumber(Num - 2);
1907 mangleUnqualifiedName(RD, DC, AdditionalAbiTags);
1908 }
else if (
const BlockDecl *BD = dyn_cast<BlockDecl>(
D)) {
1909 if (
const NamedDecl *PrefixND = getClosurePrefix(BD))
1910 mangleClosurePrefix(PrefixND,
true );
1912 manglePrefix(Context.getEffectiveDeclContext(BD),
true );
1913 assert(!AdditionalAbiTags &&
"Block cannot have additional abi tags");
1914 mangleUnqualifiedBlock(BD);
1917 mangleNestedName(GD, Context.getEffectiveDeclContext(ND),
1918 AdditionalAbiTags,
true );
1920 }
else if (
const BlockDecl *BD = dyn_cast<BlockDecl>(
D)) {
1924 = dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl())) {
1930 mangleNumber(Num - 2);
1935 assert(!AdditionalAbiTags &&
"Block cannot have additional abi tags");
1936 mangleUnqualifiedBlock(BD);
1938 mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
1941 if (
const NamedDecl *ND = dyn_cast<NamedDecl>(RD ? RD :
D)) {
1943 if (Context.getNextDiscriminator(ND, disc)) {
1947 Out <<
"__" << disc <<
'_';
1952 void CXXNameMangler::mangleBlockForPrefix(
const BlockDecl *
Block) {
1953 if (GetLocalClassDecl(
Block)) {
1954 mangleLocalName(
Block,
nullptr);
1958 if (isLocalContainerContext(DC)) {
1959 mangleLocalName(
Block,
nullptr);
1963 mangleClosurePrefix(PrefixND);
1966 mangleUnqualifiedBlock(
Block);
1969 void CXXNameMangler::mangleUnqualifiedBlock(
const BlockDecl *
Block) {
1972 if (
Decl *Context =
Block->getBlockManglingContextDecl()) {
1974 (isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
1975 Context->getDeclContext()->isRecord()) {
1976 const auto *ND = cast<NamedDecl>(Context);
1978 mangleSourceNameWithAbiTags(ND);
1985 unsigned Number =
Block->getBlockManglingNumber();
1989 Number = Context.getBlockId(
Block,
false);
2007 void CXXNameMangler::mangleTemplateParamDecl(
const NamedDecl *
Decl) {
2009 if (
auto *Ty = dyn_cast<TemplateTypeParmDecl>(
Decl)) {
2010 if (Ty->isParameterPack())
2016 mangleTypeConstraint(Constraint);
2020 }
else if (
auto *Tn = dyn_cast<NonTypeTemplateParmDecl>(
Decl)) {
2021 if (Tn->isExpandedParameterPack()) {
2022 for (
unsigned I = 0, N = Tn->getNumExpansionTypes(); I != N; ++I) {
2024 mangleType(Tn->getExpansionType(I));
2028 if (Tn->isParameterPack()) {
2031 T = PackExpansion->getPattern();
2036 }
else if (
auto *Tt = dyn_cast<TemplateTemplateParmDecl>(
Decl)) {
2037 if (Tt->isExpandedParameterPack()) {
2038 for (
unsigned I = 0, N = Tt->getNumExpansionTemplateParameters(); I != N;
2040 mangleTemplateParameterList(Tt->getExpansionTemplateParameters(I));
2042 if (Tt->isParameterPack())
2044 mangleTemplateParameterList(Tt->getTemplateParameters());
2049 void CXXNameMangler::mangleTemplateParameterList(
2052 for (
auto *Param : *Params)
2053 mangleTemplateParamDecl(Param);
2054 mangleRequiresClause(Params->getRequiresClause());
2058 void CXXNameMangler::mangleTypeConstraint(
2060 const DeclContext *DC = Context.getEffectiveDeclContext(Concept);
2062 mangleTemplateName(Concept, Arguments);
2064 mangleUnscopedName(Concept, DC,
nullptr);
2066 mangleNestedName(Concept, DC,
nullptr);
2069 void CXXNameMangler::mangleTypeConstraint(
const TypeConstraint *Constraint) {
2074 Args.push_back(ArgLoc.getArgument());
2079 void CXXNameMangler::mangleRequiresClause(
const Expr *RequiresClause) {
2083 mangleExpression(RequiresClause);
2087 void CXXNameMangler::mangleLambda(
const CXXRecordDecl *Lambda) {
2092 (isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
2093 !isa<ParmVarDecl>(Context)) {
2096 mangleSourceName(Name);
2106 mangleLambdaSig(Lambda);
2120 std::optional<unsigned> DeviceNumber =
2121 Context.getDiscriminatorOverride()(Context.getASTContext(), Lambda);
2125 assert(Number > 0 &&
"Lambda should be mangled as an unnamed class");
2127 mangleNumber(Number - 2);
2131 void CXXNameMangler::mangleLambdaSig(
const CXXRecordDecl *Lambda) {
2134 mangleTemplateParamDecl(
D);
2138 mangleRequiresClause(TPL->getRequiresClause());
2142 mangleBareFunctionType(Proto,
false,
2147 switch (qualifier->
getKind()) {
2153 llvm_unreachable(
"Can't mangle __super specifier");
2171 if (!Clang14Compat && mangleSubstitution(qualifier))
2182 addSubstitution(qualifier);
2186 llvm_unreachable(
"unexpected nested name specifier");
2189 void CXXNameMangler::manglePrefix(
const DeclContext *DC,
bool NoFunction) {
2197 assert(!isa<LinkageSpecDecl>(DC) &&
"prefix cannot be LinkageSpecDecl");
2202 if (NoFunction && isLocalContainerContext(DC))
2205 const NamedDecl *ND = cast<NamedDecl>(DC);
2206 if (mangleSubstitution(ND))
2212 mangleTemplatePrefix(TD);
2214 }
else if (
const NamedDecl *PrefixND = getClosurePrefix(ND)) {
2215 mangleClosurePrefix(PrefixND, NoFunction);
2216 mangleUnqualifiedName(ND,
nullptr,
nullptr);
2218 const DeclContext *DC = Context.getEffectiveDeclContext(ND);
2219 manglePrefix(DC, NoFunction);
2220 mangleUnqualifiedName(ND, DC,
nullptr);
2223 addSubstitution(ND);
2226 void CXXNameMangler::mangleTemplatePrefix(
TemplateName Template) {
2231 return mangleTemplatePrefix(TD);
2234 assert(
Dependent &&
"unexpected template name kind");
2239 if (!Clang11Compat && mangleSubstitution(Template))
2243 manglePrefix(Qualifier);
2245 if (Clang11Compat && mangleSubstitution(Template))
2249 mangleSourceName(
Id);
2251 mangleOperatorName(
Dependent->getOperator(), UnknownArity);
2253 addSubstitution(Template);
2256 void CXXNameMangler::mangleTemplatePrefix(
GlobalDecl GD,
2265 if (mangleSubstitution(ND))
2269 if (
const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
2270 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
2272 const DeclContext *DC = Context.getEffectiveDeclContext(ND);
2273 manglePrefix(DC, NoFunction);
2274 if (isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND))
2275 mangleUnqualifiedName(GD, DC,
nullptr);
2281 addSubstitution(ND);
2284 const NamedDecl *CXXNameMangler::getClosurePrefix(
const Decl *ND) {
2289 if (
auto *
Block = dyn_cast<BlockDecl>(ND)) {
2290 Context = dyn_cast_or_null<NamedDecl>(
Block->getBlockManglingContextDecl());
2291 }
else if (
auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
2293 Context = dyn_cast_or_null<NamedDecl>(RD->getLambdaContextDecl());
2300 if ((isa<VarDecl>(Context) && cast<VarDecl>(Context)->hasGlobalStorage()) ||
2301 isa<FieldDecl>(Context))
2307 void CXXNameMangler::mangleClosurePrefix(
const NamedDecl *ND,
bool NoFunction) {
2310 if (mangleSubstitution(ND))
2315 mangleTemplatePrefix(TD, NoFunction);
2318 const auto *DC = Context.getEffectiveDeclContext(ND);
2319 manglePrefix(DC, NoFunction);
2320 mangleUnqualifiedName(ND, DC,
nullptr);
2325 addSubstitution(ND);
2334 if (mangleSubstitution(TN))
2347 if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TD))
2348 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
2355 llvm_unreachable(
"can't mangle an overloaded template name as a <type>");
2363 mangleUnresolvedPrefix(
Dependent->getQualifier());
2364 mangleSourceName(
Dependent->getIdentifier());
2384 Out <<
"_SUBSTPACK_";
2389 addSubstitution(TN);
2392 bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(
QualType Ty,
2398 case Type::Adjusted:
2400 case Type::ArrayParameter:
2402 case Type::BlockPointer:
2403 case Type::LValueReference:
2404 case Type::RValueReference:
2405 case Type::MemberPointer:
2406 case Type::ConstantArray:
2407 case Type::IncompleteArray:
2408 case Type::VariableArray:
2409 case Type::DependentSizedArray:
2410 case Type::DependentAddressSpace:
2411 case Type::DependentVector:
2412 case Type::DependentSizedExtVector:
2414 case Type::ExtVector:
2415 case Type::ConstantMatrix:
2416 case Type::DependentSizedMatrix:
2417 case Type::FunctionProto:
2418 case Type::FunctionNoProto:
2420 case Type::Attributed:
2421 case Type::BTFTagAttributed:
2423 case Type::DeducedTemplateSpecialization:
2424 case Type::PackExpansion:
2425 case Type::ObjCObject:
2426 case Type::ObjCInterface:
2427 case Type::ObjCObjectPointer:
2428 case Type::ObjCTypeParam:
2431 case Type::MacroQualified:
2433 case Type::DependentBitInt:
2434 case Type::CountAttributed:
2435 llvm_unreachable(
"type is illegal as a nested name specifier");
2437 case Type::SubstTemplateTypeParmPack:
2442 Out <<
"_SUBSTPACK_";
2449 case Type::TypeOfExpr:
2451 case Type::Decltype:
2452 case Type::PackIndexing:
2453 case Type::TemplateTypeParm:
2454 case Type::UnaryTransform:
2455 case Type::SubstTemplateTypeParm:
2469 mangleSourceNameWithAbiTags(cast<TypedefType>(Ty)->getDecl());
2472 case Type::UnresolvedUsing:
2473 mangleSourceNameWithAbiTags(
2474 cast<UnresolvedUsingType>(Ty)->getDecl());
2479 mangleSourceNameWithAbiTags(cast<TagType>(Ty)->getDecl());
2482 case Type::TemplateSpecialization: {
2484 cast<TemplateSpecializationType>(Ty);
2493 assert(TD &&
"no template for template specialization type");
2494 if (isa<TemplateTemplateParmDecl>(TD))
2495 goto unresolvedType;
2497 mangleSourceNameWithAbiTags(TD);
2504 llvm_unreachable(
"invalid base for a template specialization type");
2518 Out <<
"_SUBSTPACK_";
2523 assert(TD && !isa<TemplateTemplateParmDecl>(TD));
2524 mangleSourceNameWithAbiTags(TD);
2538 case Type::InjectedClassName:
2539 mangleSourceNameWithAbiTags(
2540 cast<InjectedClassNameType>(Ty)->getDecl());
2543 case Type::DependentName:
2544 mangleSourceName(cast<DependentNameType>(Ty)->
getIdentifier());
2547 case Type::DependentTemplateSpecialization: {
2549 cast<DependentTemplateSpecializationType>(Ty);
2550 TemplateName Template = getASTContext().getDependentTemplateName(
2558 return mangleUnresolvedTypeOrSimpleId(cast<UsingType>(Ty)->desugar(),
2560 case Type::Elaborated:
2561 return mangleUnresolvedTypeOrSimpleId(
2562 cast<ElaboratedType>(Ty)->getNamedType(), Prefix);
2568 void CXXNameMangler::mangleOperatorName(
DeclarationName Name,
unsigned Arity) {
2569 switch (Name.getNameKind()) {
2578 llvm_unreachable(
"Not an operator name");
2583 mangleType(Name.getCXXNameType());
2588 mangleSourceName(Name.getCXXLiteralIdentifier());
2592 mangleOperatorName(Name.getCXXOverloadedOperator(), Arity);
2601 case OO_New: Out <<
"nw";
break;
2603 case OO_Array_New: Out <<
"na";
break;
2605 case OO_Delete: Out <<
"dl";
break;
2607 case OO_Array_Delete: Out <<
"da";
break;
2611 Out << (Arity == 1?
"ps" :
"pl");
break;
2615 Out << (Arity == 1?
"ng" :
"mi");
break;
2619 Out << (Arity == 1?
"ad" :
"an");
break;
2624 Out << (Arity == 1?
"de" :
"ml");
break;
2626 case OO_Tilde: Out <<
"co";
break;
2628 case OO_Slash: Out <<
"dv";
break;
2630 case OO_Percent: Out <<
"rm";
break;
2632 case OO_Pipe: Out <<
"or";
break;
2634 case OO_Caret: Out <<
"eo";
break;
2636 case OO_Equal: Out <<
"aS";
break;
2638 case OO_PlusEqual: Out <<
"pL";
break;
2640 case OO_MinusEqual: Out <<
"mI";
break;
2642 case OO_StarEqual: Out <<
"mL";
break;
2644 case OO_SlashEqual: Out <<
"dV";
break;
2646 case OO_PercentEqual: Out <<
"rM";
break;
2648 case OO_AmpEqual: Out <<
"aN";
break;
2650 case OO_PipeEqual: Out <<
"oR";
break;
2652 case OO_CaretEqual: Out <<
"eO";
break;
2654 case OO_LessLess: Out <<
"ls";
break;
2656 case OO_GreaterGreater: Out <<
"rs";
break;
2658 case OO_LessLessEqual: Out <<
"lS";
break;
2660 case OO_GreaterGreaterEqual: Out <<
"rS";
break;
2662 case OO_EqualEqual: Out <<
"eq";
break;
2664 case OO_ExclaimEqual: Out <<
"ne";
break;
2666 case OO_Less: Out <<
"lt";
break;
2668 case OO_Greater: Out <<
"gt";
break;
2670 case OO_LessEqual: Out <<
"le";
break;
2672 case OO_GreaterEqual: Out <<
"ge";
break;
2674 case OO_Exclaim: Out <<
"nt";
break;
2676 case OO_AmpAmp: Out <<
"aa";
break;
2678 case OO_PipePipe: Out <<
"oo";
break;
2680 case OO_PlusPlus: Out <<
"pp";
break;
2682 case OO_MinusMinus: Out <<
"mm";
break;
2684 case OO_Comma: Out <<
"cm";
break;
2686 case OO_ArrowStar: Out <<
"pm";
break;
2688 case OO_Arrow: Out <<
"pt";
break;
2690 case OO_Call: Out <<
"cl";
break;
2692 case OO_Subscript: Out <<
"ix";
break;
2697 case OO_Conditional: Out <<
"qu";
break;
2700 case OO_Coawait: Out <<
"aw";
break;
2703 case OO_Spaceship: Out <<
"ss";
break;
2707 llvm_unreachable(
"Not an overloaded operator");
2736 if (TargetAS != 0 ||
2738 ASString =
"AS" + llvm::utostr(TargetAS);
2741 default: llvm_unreachable(
"Not a language specific address space");
2746 ASString =
"CLglobal";
2749 ASString =
"CLdevice";
2752 ASString =
"CLhost";
2755 ASString =
"CLlocal";
2758 ASString =
"CLconstant";
2761 ASString =
"CLprivate";
2764 ASString =
"CLgeneric";
2769 ASString =
"SYglobal";
2772 ASString =
"SYglobaldevice";
2775 ASString =
"SYglobalhost";
2778 ASString =
"SYlocal";
2781 ASString =
"SYprivate";
2785 ASString =
"CUdevice";
2788 ASString =
"CUconstant";
2791 ASString =
"CUshared";
2795 ASString =
"ptr32_sptr";
2801 if (!getASTContext().getTargetInfo().getTriple().isOSzOS())
2802 ASString =
"ptr32_uptr";
2809 if (!ASString.empty())
2810 mangleVendorQualifier(ASString);
2823 mangleVendorQualifier(
"__weak");
2827 mangleVendorQualifier(
"__unaligned");
2839 mangleVendorQualifier(
"__strong");
2843 mangleVendorQualifier(
"__autoreleasing");
2866 void CXXNameMangler::mangleVendorQualifier(StringRef
name) {
2873 switch (RefQualifier) {
2887 void CXXNameMangler::mangleObjCMethodName(
const ObjCMethodDecl *MD) {
2888 Context.mangleObjCMethodNameAsSourceName(MD, Out);
2914 if (DeducedTST->getDeducedType().isNull())
2919 void CXXNameMangler::mangleType(
QualType T) {
2953 T =
T.getCanonicalType();
2960 = dyn_cast<TemplateSpecializationType>(
T))
2969 =
T.getSingleStepDesugaredType(Context.getASTContext());
2978 const Type *ty = split.
Ty;
2980 bool isSubstitutable =
2982 if (isSubstitutable && mangleSubstitution(
T))
2987 if (quals && isa<ArrayType>(
T)) {
2997 dyn_cast<DependentAddressSpaceType>(ty)) {
2999 mangleQualifiers(splitDAST.
Quals, DAST);
3002 mangleQualifiers(quals);
3010 #define ABSTRACT_TYPE(CLASS, PARENT)
3011 #define NON_CANONICAL_TYPE(CLASS, PARENT) \
3013 llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \
3015 #define TYPE(CLASS, PARENT) \
3017 mangleType(static_cast<const CLASS##Type*>(ty)); \
3019 #include "clang/AST/TypeNodes.inc"
3024 if (isSubstitutable)
3028 void CXXNameMangler::mangleNameOrStandardSubstitution(
const NamedDecl *ND) {
3029 if (!mangleStandardSubstitution(ND))
3033 void CXXNameMangler::mangleType(
const BuiltinType *
T) {
3075 std::string type_name;
3079 if (NormalizeIntegers &&
T->isInteger()) {
3080 if (
T->isSignedInteger()) {
3081 switch (getASTContext().getTypeSize(
T)) {
3085 if (mangleSubstitution(BuiltinType::SChar))
3088 addSubstitution(BuiltinType::SChar);
3091 if (mangleSubstitution(BuiltinType::Short))
3094 addSubstitution(BuiltinType::Short);
3097 if (mangleSubstitution(BuiltinType::Int))
3100 addSubstitution(BuiltinType::Int);
3103 if (mangleSubstitution(BuiltinType::Long))
3106 addSubstitution(BuiltinType::Long);
3109 if (mangleSubstitution(BuiltinType::Int128))
3112 addSubstitution(BuiltinType::Int128);
3115 llvm_unreachable(
"Unknown integer size for normalization");
3118 switch (getASTContext().getTypeSize(
T)) {
3120 if (mangleSubstitution(BuiltinType::UChar))
3123 addSubstitution(BuiltinType::UChar);
3126 if (mangleSubstitution(BuiltinType::UShort))
3129 addSubstitution(BuiltinType::UShort);
3132 if (mangleSubstitution(BuiltinType::UInt))
3135 addSubstitution(BuiltinType::UInt);
3138 if (mangleSubstitution(BuiltinType::ULong))
3141 addSubstitution(BuiltinType::ULong);
3144 if (mangleSubstitution(BuiltinType::UInt128))
3147 addSubstitution(BuiltinType::UInt128);
3150 llvm_unreachable(
"Unknown integer size for normalization");
3155 switch (
T->getKind()) {
3156 case BuiltinType::Void:
3159 case BuiltinType::Bool:
3162 case BuiltinType::Char_U:
3163 case BuiltinType::Char_S:
3166 case BuiltinType::UChar:
3169 case BuiltinType::UShort:
3172 case BuiltinType::UInt:
3175 case BuiltinType::ULong:
3178 case BuiltinType::ULongLong:
3181 case BuiltinType::UInt128:
3184 case BuiltinType::SChar:
3187 case BuiltinType::WChar_S:
3188 case BuiltinType::WChar_U:
3191 case BuiltinType::Char8:
3194 case BuiltinType::Char16:
3197 case BuiltinType::Char32:
3200 case BuiltinType::Short:
3203 case BuiltinType::Int:
3206 case BuiltinType::Long:
3209 case BuiltinType::LongLong:
3212 case BuiltinType::Int128:
3215 case BuiltinType::Float16:
3218 case BuiltinType::ShortAccum:
3221 case BuiltinType::Accum:
3224 case BuiltinType::LongAccum:
3227 case BuiltinType::UShortAccum:
3230 case BuiltinType::UAccum:
3233 case BuiltinType::ULongAccum:
3236 case BuiltinType::ShortFract:
3239 case BuiltinType::Fract:
3242 case BuiltinType::LongFract:
3245 case BuiltinType::UShortFract:
3248 case BuiltinType::UFract:
3251 case BuiltinType::ULongFract:
3254 case BuiltinType::SatShortAccum:
3257 case BuiltinType::SatAccum:
3260 case BuiltinType::SatLongAccum:
3263 case BuiltinType::SatUShortAccum:
3266 case BuiltinType::SatUAccum:
3269 case BuiltinType::SatULongAccum:
3272 case BuiltinType::SatShortFract:
3275 case BuiltinType::SatFract:
3278 case BuiltinType::SatLongFract:
3281 case BuiltinType::SatUShortFract:
3284 case BuiltinType::SatUFract:
3287 case BuiltinType::SatULongFract:
3290 case BuiltinType::Half:
3296 case BuiltinType::Double:
3299 case BuiltinType::LongDouble: {
3301 getASTContext().getLangOpts().OpenMP &&
3302 getASTContext().getLangOpts().OpenMPIsTargetDevice
3303 ? getASTContext().getAuxTargetInfo()
3304 : &getASTContext().getTargetInfo();
3308 case BuiltinType::Float128: {
3310 getASTContext().getLangOpts().OpenMP &&
3311 getASTContext().getLangOpts().OpenMPIsTargetDevice
3312 ? getASTContext().getAuxTargetInfo()
3313 : &getASTContext().getTargetInfo();
3317 case BuiltinType::BFloat16: {
3319 ((getASTContext().getLangOpts().OpenMP &&
3320 getASTContext().getLangOpts().OpenMPIsTargetDevice) ||
3321 getASTContext().getLangOpts().SYCLIsDevice)
3322 ? getASTContext().getAuxTargetInfo()
3323 : &getASTContext().getTargetInfo();
3327 case BuiltinType::Ibm128: {
3328 const TargetInfo *TI = &getASTContext().getTargetInfo();
3332 case BuiltinType::NullPtr:
3336 #define BUILTIN_TYPE(Id, SingletonId)
3337 #define PLACEHOLDER_TYPE(Id, SingletonId) \
3338 case BuiltinType::Id:
3339 #include "clang/AST/BuiltinTypes.def"
3340 case BuiltinType::Dependent:
3342 llvm_unreachable(
"mangling a placeholder type");
3344 case BuiltinType::ObjCId:
3345 Out <<
"11objc_object";
3347 case BuiltinType::ObjCClass:
3348 Out <<
"10objc_class";
3350 case BuiltinType::ObjCSel:
3351 Out <<
"13objc_selector";
3353 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3354 case BuiltinType::Id: \
3355 type_name = "ocl_" #ImgType "_" #Suffix; \
3356 Out << type_name.size() << type_name; \
3358 #include "clang/Basic/OpenCLImageTypes.def"
3359 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3360 case BuiltinType::Sampled##Id: \
3361 type_name = "__spirv_SampledImage__" #ImgType "_" #Suffix; \
3362 Out << type_name.size() << type_name; \
3364 #define IMAGE_WRITE_TYPE(Type, Id, Ext)
3365 #define IMAGE_READ_WRITE_TYPE(Type, Id, Ext)
3366 #include "clang/Basic/OpenCLImageTypes.def"
3367 case BuiltinType::OCLSampler:
3368 Out <<
"11ocl_sampler";
3370 case BuiltinType::OCLEvent:
3371 Out <<
"9ocl_event";
3373 case BuiltinType::OCLClkEvent:
3374 Out <<
"12ocl_clkevent";
3376 case BuiltinType::OCLQueue:
3377 Out <<
"9ocl_queue";
3379 case BuiltinType::OCLReserveID:
3380 Out <<
"13ocl_reserveid";
3382 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
3383 case BuiltinType::Id: \
3384 type_name = "ocl_" #ExtType; \
3385 Out << type_name.size() << type_name; \
3387 #include "clang/Basic/OpenCLExtensionTypes.def"
3391 #define SVE_VECTOR_TYPE(InternalName, MangledName, Id, SingletonId, NumEls, \
3392 ElBits, IsSigned, IsFP, IsBF) \
3393 case BuiltinType::Id: \
3394 if (T->getKind() == BuiltinType::SveBFloat16 && \
3395 isCompatibleWith(LangOptions::ClangABI::Ver17)) { \
3397 type_name = "__SVBFloat16_t"; \
3398 Out << "u" << type_name.size() << type_name; \
3400 type_name = MangledName; \
3401 Out << (type_name == InternalName ? "u" : "") << type_name.size() \
3405 #define SVE_PREDICATE_TYPE(InternalName, MangledName, Id, SingletonId, NumEls) \
3406 case BuiltinType::Id: \
3407 type_name = MangledName; \
3408 Out << (type_name == InternalName ? "u" : "") << type_name.size() \
3411 #define SVE_OPAQUE_TYPE(InternalName, MangledName, Id, SingletonId) \
3412 case BuiltinType::Id: \
3413 type_name = MangledName; \
3414 Out << (type_name == InternalName ? "u" : "") << type_name.size() \
3417 #include "clang/Basic/AArch64SVEACLETypes.def"
3418 #define PPC_VECTOR_TYPE(Name, Id, Size) \
3419 case BuiltinType::Id: \
3420 type_name = #Name; \
3421 Out << 'u' << type_name.size() << type_name; \
3423 #include "clang/Basic/PPCTypes.def"
3425 #define RVV_TYPE(Name, Id, SingletonId) \
3426 case BuiltinType::Id: \
3428 Out << 'u' << type_name.size() << type_name; \
3430 #include "clang/Basic/RISCVVTypes.def"
3431 #define WASM_REF_TYPE(InternalName, MangledName, Id, SingletonId, AS) \
3432 case BuiltinType::Id: \
3433 type_name = MangledName; \
3434 Out << 'u' << type_name.size() << type_name; \
3436 #include "clang/Basic/WebAssemblyReferenceTypes.def"
3437 #define AMDGPU_TYPE(Name, Id, SingletonId) \
3438 case BuiltinType::Id: \
3440 Out << 'u' << type_name.size() << type_name; \
3442 #include "clang/Basic/AMDGPUTypes.def"
3443 #define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
3444 case BuiltinType::Id: \
3445 type_name = #Name; \
3446 Out << 'u' << type_name.size() << type_name; \
3448 #include "clang/Basic/HLSLIntangibleTypes.def"
3452 StringRef CXXNameMangler::getCallingConvQualifierName(
CallingConv CC) {
3495 return "swiftasynccall";
3497 llvm_unreachable(
"bad calling convention");
3500 void CXXNameMangler::mangleExtFunctionInfo(
const FunctionType *
T) {
3509 StringRef CCQualifier = getCallingConvQualifierName(
T->
getExtInfo().
getCC());
3510 if (!CCQualifier.empty())
3511 mangleVendorQualifier(CCQualifier);
3518 CXXNameMangler::mangleExtParameterInfo(FunctionProtoType::ExtParameterInfo PI) {
3524 switch (PI.getABI()) {
3537 if (PI.isConsumed())
3538 mangleVendorQualifier(
"ns_consumed");
3540 if (PI.isNoEscape())
3541 mangleVendorQualifier(
"noescape");
3548 mangleExtFunctionInfo(
T);
3565 mangleType(ExceptTy);
3576 mangleBareFunctionType(
T,
true);
3590 FunctionTypeDepthState saved = FunctionTypeDepth.push();
3592 FunctionTypeDepth.enterResultType();
3594 FunctionTypeDepth.leaveResultType();
3596 FunctionTypeDepth.pop(saved);
3601 bool MangleReturnType,
3605 FunctionTypeDepthState saved = FunctionTypeDepth.push();
3608 if (MangleReturnType) {
3609 FunctionTypeDepth.enterResultType();
3613 mangleVendorQualifier(
"ns_returns_retained");
3618 auto SplitReturnTy = ReturnTy.
split();
3620 ReturnTy = getASTContext().getQualifiedType(SplitReturnTy);
3622 mangleType(ReturnTy);
3624 FunctionTypeDepth.leaveResultType();
3646 assert(
Attr->getType() <= 9 &&
Attr->getType() >= 0);
3647 if (
Attr->isDynamic())
3648 Out <<
"U25pass_dynamic_object_size" <<
Attr->getType();
3650 Out <<
"U17pass_object_size" <<
Attr->getType();
3661 FunctionTypeDepth.enterResultType();
3665 FunctionTypeDepth.pop(saved);
3671 mangleName(
T->getDecl());
3676 void CXXNameMangler::mangleType(
const EnumType *
T) {
3677 mangleType(
static_cast<const TagType*
>(
T));
3679 void CXXNameMangler::mangleType(
const RecordType *
T) {
3680 mangleType(
static_cast<const TagType*
>(
T));
3682 void CXXNameMangler::mangleType(
const TagType *
T) {
3683 mangleName(
T->getDecl());
3690 Out <<
'A' <<
T->getSize() <<
'_';
3691 mangleType(
T->getElementType());
3696 if (
T->getSizeExpr())
3697 mangleExpression(
T->getSizeExpr());
3699 mangleType(
T->getElementType());
3706 if (
T->getSizeExpr())
3707 mangleExpression(
T->getSizeExpr());
3709 mangleType(
T->getElementType());
3713 mangleType(
T->getElementType());
3743 mangleType(PointeeType);
3748 mangleTemplateParameter(
T->getDepth(),
T->getIndex());
3757 Out <<
"_SUBSTPACK_";
3761 void CXXNameMangler::mangleType(
const PointerType *
T) {
3783 void CXXNameMangler::mangleType(
const ComplexType *
T) {
3785 mangleType(
T->getElementType());
3791 void CXXNameMangler::mangleNeonVectorType(
const VectorType *
T) {
3793 assert(EltType->
isBuiltinType() &&
"Neon vector element not a BuiltinType");
3794 const char *EltName =
nullptr;
3796 switch (cast<BuiltinType>(EltType)->
getKind()) {
3797 case BuiltinType::SChar:
3798 case BuiltinType::UChar:
3799 EltName =
"poly8_t";
3801 case BuiltinType::Short:
3802 case BuiltinType::UShort:
3803 EltName =
"poly16_t";
3805 case BuiltinType::LongLong:
3806 case BuiltinType::ULongLong:
3807 EltName =
"poly64_t";
3809 default: llvm_unreachable(
"unexpected Neon polynomial vector element type");
3812 switch (cast<BuiltinType>(EltType)->
getKind()) {
3813 case BuiltinType::SChar: EltName =
"int8_t";
break;
3814 case BuiltinType::UChar: EltName =
"uint8_t";
break;
3815 case BuiltinType::Short: EltName =
"int16_t";
break;
3816 case BuiltinType::UShort: EltName =
"uint16_t";
break;
3817 case BuiltinType::Int: EltName =
"int32_t";
break;
3818 case BuiltinType::UInt: EltName =
"uint32_t";
break;
3819 case BuiltinType::LongLong: EltName =
"int64_t";
break;
3820 case BuiltinType::ULongLong: EltName =
"uint64_t";
break;
3821 case BuiltinType::Double: EltName =
"float64_t";
break;
3823 case BuiltinType::Half: EltName =
"float16_t";
break;
3824 case BuiltinType::BFloat16: EltName =
"bfloat16_t";
break;
3826 llvm_unreachable(
"unexpected Neon vector element type");
3829 const char *BaseName =
nullptr;
3830 unsigned BitSize = (
T->getNumElements() *
3831 getASTContext().getTypeSize(EltType));
3833 BaseName =
"__simd64_";
3835 assert(BitSize == 128 &&
"Neon vector type not 64 or 128 bits");
3836 BaseName =
"__simd128_";
3838 Out << strlen(BaseName) + strlen(EltName);
3839 Out << BaseName << EltName;
3846 "cannot mangle this dependent neon vector type yet");
3847 Diags.
Report(
T->getAttributeLoc(), DiagID);
3852 case BuiltinType::SChar:
3854 case BuiltinType::Short:
3856 case BuiltinType::Int:
3858 case BuiltinType::Long:
3859 case BuiltinType::LongLong:
3861 case BuiltinType::UChar:
3863 case BuiltinType::UShort:
3865 case BuiltinType::UInt:
3867 case BuiltinType::ULong:
3868 case BuiltinType::ULongLong:
3870 case BuiltinType::Half:
3874 case BuiltinType::Double:
3876 case BuiltinType::BFloat16:
3879 llvm_unreachable(
"Unexpected vector element base type");
3886 void CXXNameMangler::mangleAArch64NeonVectorType(
const VectorType *
T) {
3888 assert(EltType->
isBuiltinType() &&
"Neon vector element not a BuiltinType");
3890 (
T->getNumElements() * getASTContext().getTypeSize(EltType));
3893 assert((BitSize == 64 || BitSize == 128) &&
3894 "Neon vector type not 64 or 128 bits");
3898 switch (cast<BuiltinType>(EltType)->
getKind()) {
3899 case BuiltinType::UChar:
3902 case BuiltinType::UShort:
3905 case BuiltinType::ULong:
3906 case BuiltinType::ULongLong:
3910 llvm_unreachable(
"unexpected Neon polynomial vector element type");
3916 (
"__" + EltName +
"x" + Twine(
T->getNumElements()) +
"_t").str();
3923 "cannot mangle this dependent neon vector type yet");
3924 Diags.
Report(
T->getAttributeLoc(), DiagID);
3951 void CXXNameMangler::mangleAArch64FixedSveVectorType(
const VectorType *
T) {
3954 "expected fixed-length SVE vector!");
3958 "expected builtin type for fixed-length SVE vector!");
3961 switch (cast<BuiltinType>(EltType)->
getKind()) {
3962 case BuiltinType::SChar:
3965 case BuiltinType::UChar: {
3972 case BuiltinType::Short:
3975 case BuiltinType::UShort:
3978 case BuiltinType::Int:
3981 case BuiltinType::UInt:
3984 case BuiltinType::Long:
3987 case BuiltinType::ULong:
3990 case BuiltinType::Half:
3996 case BuiltinType::Double:
3999 case BuiltinType::BFloat16:
4003 llvm_unreachable(
"unexpected element type for fixed-length SVE vector!");
4006 unsigned VecSizeInBits = getASTContext().getTypeInfo(
T).Width;
4012 << VecSizeInBits <<
"EE";
4015 void CXXNameMangler::mangleAArch64FixedSveVectorType(
4020 "cannot mangle this dependent fixed-length SVE vector type yet");
4021 Diags.
Report(
T->getAttributeLoc(), DiagID);
4024 void CXXNameMangler::mangleRISCVFixedRVVVectorType(
const VectorType *
T) {
4030 "expected fixed-length RVV vector!");
4034 "expected builtin type for fixed-length RVV vector!");
4037 llvm::raw_svector_ostream TypeNameOS(TypeNameStr);
4038 TypeNameOS <<
"__rvv_";
4039 switch (cast<BuiltinType>(EltType)->
getKind()) {
4040 case BuiltinType::SChar:
4041 TypeNameOS <<
"int8";
4043 case BuiltinType::UChar:
4045 TypeNameOS <<
"uint8";
4047 TypeNameOS <<
"bool";
4049 case BuiltinType::Short:
4050 TypeNameOS <<
"int16";
4052 case BuiltinType::UShort:
4053 TypeNameOS <<
"uint16";
4055 case BuiltinType::Int:
4056 TypeNameOS <<
"int32";
4058 case BuiltinType::UInt:
4059 TypeNameOS <<
"uint32";
4061 case BuiltinType::Long:
4062 TypeNameOS <<
"int64";
4064 case BuiltinType::ULong:
4065 TypeNameOS <<
"uint64";
4067 case BuiltinType::Float16:
4068 TypeNameOS <<
"float16";
4071 TypeNameOS <<
"float32";
4073 case BuiltinType::Double:
4074 TypeNameOS <<
"float64";
4077 llvm_unreachable(
"unexpected element type for fixed-length RVV vector!");
4080 unsigned VecSizeInBits;
4081 switch (
T->getVectorKind()) {
4092 VecSizeInBits = getASTContext().getTypeInfo(
T).Width;
4097 auto VScale = getASTContext().getTargetInfo().getVScaleRange(
4098 getASTContext().getLangOpts());
4099 unsigned VLen = VScale->first * llvm::RISCV::RVVBitsPerBlock;
4103 if (VecSizeInBits >= VLen)
4104 TypeNameOS << (VecSizeInBits / VLen);
4106 TypeNameOS <<
'f' << (VLen / VecSizeInBits);
4108 TypeNameOS << (VLen / VecSizeInBits);
4112 Out <<
"9__RVV_VLSI" <<
'u' << TypeNameStr.size() << TypeNameStr <<
"Lj"
4113 << VecSizeInBits <<
"EE";
4116 void CXXNameMangler::mangleRISCVFixedRVVVectorType(
4121 "cannot mangle this dependent fixed-length RVV vector type yet");
4122 Diags.
Report(
T->getAttributeLoc(), DiagID);
4133 void CXXNameMangler::mangleType(
const VectorType *
T) {
4136 llvm::Triple
Target = getASTContext().getTargetInfo().getTriple();
4137 llvm::Triple::ArchType Arch =
4138 getASTContext().getTargetInfo().getTriple().getArch();
4139 if ((Arch == llvm::Triple::aarch64 ||
4140 Arch == llvm::Triple::aarch64_be) && !
Target.isOSDarwin())
4141 mangleAArch64NeonVectorType(
T);
4143 mangleNeonVectorType(
T);
4147 mangleAArch64FixedSveVectorType(
T);
4154 mangleRISCVFixedRVVVectorType(
T);
4157 Out <<
"Dv" <<
T->getNumElements() <<
'_';
4163 mangleType(
T->getElementType());
4169 llvm::Triple
Target = getASTContext().getTargetInfo().getTriple();
4170 llvm::Triple::ArchType Arch =
4171 getASTContext().getTargetInfo().getTriple().getArch();
4172 if ((Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_be) &&
4174 mangleAArch64NeonVectorType(
T);
4176 mangleNeonVectorType(
T);
4180 mangleAArch64FixedSveVectorType(
T);
4183 mangleRISCVFixedRVVVectorType(
T);
4188 mangleExpression(
T->getSizeExpr());
4195 mangleType(
T->getElementType());
4203 mangleExpression(
T->getSizeExpr());
4205 mangleType(
T->getElementType());
4212 StringRef VendorQualifier =
"matrix_type";
4213 Out <<
"u" << VendorQualifier.size() << VendorQualifier;
4216 auto &ASTCtx = getASTContext();
4217 unsigned BitWidth = ASTCtx.getTypeSize(ASTCtx.getSizeType());
4219 Rows =
T->getNumRows();
4220 mangleIntegerLiteral(ASTCtx.getSizeType(), Rows);
4222 Columns =
T->getNumColumns();
4223 mangleIntegerLiteral(ASTCtx.getSizeType(), Columns);
4224 mangleType(
T->getElementType());
4231 StringRef VendorQualifier =
"matrix_type";
4232 Out <<
"u" << VendorQualifier.size() << VendorQualifier;
4235 mangleTemplateArgExpr(
T->getRowExpr());
4236 mangleTemplateArgExpr(
T->getColumnExpr());
4237 mangleType(
T->getElementType());
4243 mangleQualifiers(split.
Quals,
T);
4250 mangleType(
T->getPattern());
4254 if (!
T->hasSelectedType())
4255 mangleType(
T->getPattern());
4257 mangleType(
T->getSelectedType());
4261 mangleSourceName(
T->getDecl()->getIdentifier());
4266 if (
T->isKindOfType())
4267 Out <<
"U8__kindof";
4269 if (!
T->qual_empty()) {
4272 llvm::raw_svector_ostream QualOS(QualStr);
4273 QualOS <<
"objcproto";
4274 for (
const auto *I :
T->quals()) {
4275 StringRef
name = I->getName();
4278 Out <<
'U' << QualStr.size() << QualStr;
4281 mangleType(
T->getBaseType());
4283 if (
T->isSpecialized()) {
4286 for (
auto typeArg :
T->getTypeArgs())
4287 mangleType(typeArg);
4293 Out <<
"U13block_pointer";
4301 mangleType(
T->getInjectedSpecializationType());
4305 if (
TemplateDecl *TD =
T->getTemplateName().getAsTemplateDecl()) {
4306 mangleTemplateName(TD,
T->template_arguments());
4311 mangleTemplatePrefix(
T->getTemplateName());
4316 mangleTemplateArgs(
T->getTemplateName(),
T->template_arguments());
4332 switch (
T->getKeyword()) {
4350 manglePrefix(
T->getQualifier());
4351 mangleSourceName(
T->getIdentifier());
4361 getASTContext().getDependentTemplateName(
T->getQualifier(),
4362 T->getIdentifier());
4363 mangleTemplatePrefix(Prefix);
4368 mangleTemplateArgs(Prefix,
T->template_arguments());
4372 void CXXNameMangler::mangleType(
const TypeOfType *
T) {
4385 Expr *
E =
T->getUnderlyingExpr();
4395 if (isa<DeclRefExpr>(
E) ||
4396 isa<MemberExpr>(
E) ||
4397 isa<UnresolvedLookupExpr>(
E) ||
4398 isa<DependentScopeDeclRefExpr>(
E) ||
4399 isa<CXXDependentScopeMemberExpr>(
E) ||
4400 isa<UnresolvedMemberExpr>(
E))
4404 mangleExpression(
E);
4414 StringRef BuiltinName;
4415 switch (
T->getUTTKind()) {
4416 #define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait) \
4417 case UnaryTransformType::Enum: \
4418 BuiltinName = "__" #Trait; \
4420 #include "clang/Basic/TransformTypeTraits.def"
4422 Out << BuiltinName.size() << BuiltinName;
4426 mangleType(
T->getBaseType());
4430 void CXXNameMangler::mangleType(
const AutoType *
T) {
4431 assert(
T->getDeducedType().isNull() &&
4432 "Deduced AutoType shouldn't be handled here!");
4434 "shouldn't need to mangle __auto_type!");
4440 Out << (
T->isDecltypeAuto() ?
"DK" :
"Dk");
4441 mangleTypeConstraint(
T->getTypeConstraintConcept(),
4442 T->getTypeConstraintArguments());
4444 Out << (
T->isDecltypeAuto() ?
"Dc" :
"Da");
4451 return mangleType(Deduced);
4453 TemplateDecl *TD =
T->getTemplateName().getAsTemplateDecl();
4454 assert(TD &&
"shouldn't form deduced TST unless we know we have a template");
4456 if (mangleSubstitution(TD))
4460 addSubstitution(TD);
4463 void CXXNameMangler::mangleType(
const AtomicType *
T) {
4467 mangleType(
T->getValueType());
4470 void CXXNameMangler::mangleType(
const PipeType *
T) {
4477 void CXXNameMangler::mangleType(
const BitIntType *
T) {
4481 Out <<
"D" << (
T->isUnsigned() ?
"U" :
"B") <<
T->getNumBits() <<
"_";
4488 Out <<
"D" << (
T->isUnsigned() ?
"U" :
"B");
4489 mangleExpression(
T->getNumBitsExpr());
4494 mangleType(cast<ConstantArrayType>(
T));
4497 void CXXNameMangler::mangleIntegerLiteral(
QualType T,
4505 Out << (
Value.getBoolValue() ?
'1' :
'0');
4507 mangleNumber(
Value);
4513 void CXXNameMangler::mangleMemberExprBase(
const Expr *
Base,
bool IsArrow) {
4516 if (!RT->getDecl()->isAnonymousStructOrUnion())
4518 const auto *ME = dyn_cast<MemberExpr>(
Base);
4521 Base = ME->getBase();
4522 IsArrow = ME->isArrow();
4525 if (
Base->isImplicitCXXThis()) {
4531 Out << (IsArrow ?
"pt" :
"dt");
4532 mangleExpression(
Base);
4537 void CXXNameMangler::mangleMemberExpr(
const Expr *base,
4543 unsigned NumTemplateArgs,
4548 mangleMemberExprBase(base, isArrow);
4549 mangleUnresolvedName(qualifier,
member, TemplateArgs, NumTemplateArgs, arity);
4562 if (callee == fn)
return false;
4566 if (!lookup)
return false;
4583 void CXXNameMangler::mangleCastExpression(
const Expr *
E, StringRef CastEncoding) {
4585 Out << CastEncoding;
4590 void CXXNameMangler::mangleInitListElements(
const InitListExpr *InitList) {
4592 InitList = Syntactic;
4593 for (
unsigned i = 0, e = InitList->
getNumInits(); i != e; ++i)
4594 mangleExpression(InitList->
getInit(i));
4597 void CXXNameMangler::mangleRequirement(
SourceLocation RequiresExprLoc,
4604 auto HandleSubstitutionFailure =
4609 "containing a substitution failure");
4615 case Requirement::RK_Type: {
4616 const auto *TR = cast<concepts::TypeRequirement>(Req);
4617 if (TR->isSubstitutionFailure())
4618 return HandleSubstitutionFailure(
4619 TR->getSubstitutionDiagnostic()->DiagLoc);
4622 mangleType(TR->getType()->getType());
4626 case Requirement::RK_Simple:
4627 case Requirement::RK_Compound: {
4628 const auto *ER = cast<concepts::ExprRequirement>(Req);
4629 if (ER->isExprSubstitutionFailure())
4630 return HandleSubstitutionFailure(
4631 ER->getExprSubstitutionDiagnostic()->DiagLoc);
4634 mangleExpression(ER->getExpr());
4636 if (ER->hasNoexceptRequirement())
4639 if (!ER->getReturnTypeRequirement().isEmpty()) {
4640 if (ER->getReturnTypeRequirement().isSubstitutionFailure())
4641 return HandleSubstitutionFailure(ER->getReturnTypeRequirement()
4642 .getSubstitutionDiagnostic()
4646 mangleTypeConstraint(ER->getReturnTypeRequirement().getTypeConstraint());
4651 case Requirement::RK_Nested:
4652 const auto *NR = cast<concepts::NestedRequirement>(Req);
4653 if (NR->hasInvalidConstraint()) {
4656 return HandleSubstitutionFailure(RequiresExprLoc);
4660 mangleExpression(NR->getConstraintExpr());
4665 void CXXNameMangler::mangleExpression(
const Expr *
E,
unsigned Arity,
4666 bool AsTemplateArg) {
4695 QualType ImplicitlyConvertedToType;
4699 bool IsPrimaryExpr =
true;
4700 auto NotPrimaryExpr = [&] {
4701 if (AsTemplateArg && IsPrimaryExpr)
4703 IsPrimaryExpr =
false;
4706 auto MangleDeclRefExpr = [&](
const NamedDecl *
D) {
4717 mangleFunctionParam(cast<ParmVarDecl>(
D));
4720 case Decl::EnumConstant: {
4727 case Decl::NonTypeTemplateParm:
4741 #define ABSTRACT_STMT(Type)
4742 #define EXPR(Type, Base)
4743 #define STMT(Type, Base) \
4744 case Expr::Type##Class:
4745 #include "clang/AST/StmtNodes.inc"
4750 case Expr::AddrLabelExprClass:
4751 case Expr::DesignatedInitUpdateExprClass:
4752 case Expr::ImplicitValueInitExprClass:
4753 case Expr::ArrayInitLoopExprClass:
4754 case Expr::ArrayInitIndexExprClass:
4755 case Expr::NoInitExprClass:
4756 case Expr::ParenListExprClass:
4757 case Expr::MSPropertyRefExprClass:
4758 case Expr::MSPropertySubscriptExprClass:
4759 case Expr::TypoExprClass:
4760 case Expr::RecoveryExprClass:
4761 case Expr::ArraySectionExprClass:
4762 case Expr::OMPArrayShapingExprClass:
4763 case Expr::OMPIteratorExprClass:
4764 case Expr::CXXInheritedCtorInitExprClass:
4765 case Expr::CXXParenListInitExprClass:
4766 case Expr::PackIndexingExprClass:
4767 llvm_unreachable(
"unexpected statement kind");
4769 case Expr::ConstantExprClass:
4770 E = cast<ConstantExpr>(
E)->getSubExpr();
4774 case Expr::BlockExprClass:
4775 case Expr::ChooseExprClass:
4776 case Expr::CompoundLiteralExprClass:
4777 case Expr::ExtVectorElementExprClass:
4778 case Expr::GenericSelectionExprClass:
4779 case Expr::ObjCEncodeExprClass:
4780 case Expr::ObjCIsaExprClass:
4781 case Expr::ObjCIvarRefExprClass:
4782 case Expr::ObjCMessageExprClass:
4783 case Expr::ObjCPropertyRefExprClass:
4784 case Expr::ObjCProtocolExprClass:
4785 case Expr::ObjCSelectorExprClass:
4786 case Expr::ObjCStringLiteralClass:
4787 case Expr::ObjCBoxedExprClass:
4788 case Expr::ObjCArrayLiteralClass:
4789 case Expr::ObjCDictionaryLiteralClass:
4790 case Expr::ObjCSubscriptRefExprClass:
4791 case Expr::ObjCIndirectCopyRestoreExprClass:
4792 case Expr::ObjCAvailabilityCheckExprClass:
4793 case Expr::OffsetOfExprClass:
4794 case Expr::PredefinedExprClass:
4795 case Expr::ShuffleVectorExprClass:
4796 case Expr::ConvertVectorExprClass:
4797 case Expr::StmtExprClass:
4798 case Expr::ArrayTypeTraitExprClass:
4799 case Expr::ExpressionTraitExprClass:
4800 case Expr::VAArgExprClass:
4801 case Expr::CUDAKernelCallExprClass:
4802 case Expr::AsTypeExprClass:
4803 case Expr::PseudoObjectExprClass:
4804 case Expr::AtomicExprClass:
4805 case Expr::SourceLocExprClass:
4806 case Expr::EmbedExprClass:
4807 case Expr::BuiltinBitCastExprClass:
4808 case Expr::SYCLBuiltinNumFieldsExprClass:
4809 case Expr::SYCLBuiltinFieldTypeExprClass:
4810 case Expr::SYCLBuiltinNumBasesExprClass:
4811 case Expr::SYCLBuiltinBaseTypeExprClass:
4818 "cannot yet mangle expression type %0");
4826 case Expr::CXXUuidofExprClass: {
4832 Out <<
"u8__uuidof";
4841 Out <<
"u8__uuidoft";
4845 Out <<
"u8__uuidofz";
4846 mangleExpression(UuidExp);
4853 case Expr::BinaryConditionalOperatorClass: {
4858 "?: operator with omitted middle operand cannot be mangled");
4865 case Expr::OpaqueValueExprClass:
4866 llvm_unreachable(
"cannot mangle opaque value; mangling wrong thing?");
4868 case Expr::InitListExprClass: {
4871 mangleInitListElements(cast<InitListExpr>(
E));
4876 case Expr::DesignatedInitExprClass: {
4878 auto *DIE = cast<DesignatedInitExpr>(
E);
4879 for (
const auto &
Designator : DIE->designators()) {
4885 mangleExpression(DIE->getArrayIndex(
Designator));
4888 "unknown designator kind");
4890 mangleExpression(DIE->getArrayRangeStart(
Designator));
4891 mangleExpression(DIE->getArrayRangeEnd(
Designator));
4894 mangleExpression(DIE->getInit());
4898 case Expr::CXXDefaultArgExprClass:
4899 E = cast<CXXDefaultArgExpr>(
E)->getExpr();
4902 case Expr::CXXDefaultInitExprClass:
4903 E = cast<CXXDefaultInitExpr>(
E)->getExpr();
4906 case Expr::CXXStdInitializerListExprClass:
4907 E = cast<CXXStdInitializerListExpr>(
E)->getSubExpr();
4910 case Expr::SubstNonTypeTemplateParmExprClass: {
4913 auto *SNTTPE = cast<SubstNonTypeTemplateParmExpr>(
E);
4914 if (
auto *CE = dyn_cast<ConstantExpr>(SNTTPE->getReplacement())) {
4916 QualType ParamType = SNTTPE->getParameterType(Context.getASTContext());
4917 assert(CE->hasAPValueResult() &&
"expected the NTTP to have an APValue");
4918 mangleValueInTemplateArg(ParamType, CE->getAPValueResult(),
false,
4924 E = cast<SubstNonTypeTemplateParmExpr>(
E)->getReplacement();
4928 case Expr::UserDefinedLiteralClass:
4931 case Expr::CXXMemberCallExprClass:
4932 case Expr::CallExprClass: {
4953 if (isa<PackExpansionExpr>(Arg))
4954 CallArity = UnknownArity;
4956 mangleExpression(CE->
getCallee(), CallArity);
4958 mangleExpression(Arg);
4963 case Expr::CXXNewExprClass: {
4967 Out << (New->
isArray() ?
"na" :
"nw");
4970 mangleExpression(*I);
4984 mangleExpression(*I);
4986 for (
unsigned i = 0, e = PLE->getNumExprs(); i != e; ++i)
4987 mangleExpression(PLE->getExpr(i));
4990 isa<InitListExpr>(
Init)) {
4992 mangleInitListElements(cast<InitListExpr>(
Init));
4994 mangleExpression(
Init);
5000 case Expr::CXXPseudoDestructorExprClass: {
5002 const auto *PDE = cast<CXXPseudoDestructorExpr>(
E);
5003 if (
const Expr *
Base = PDE->getBase())
5004 mangleMemberExprBase(
Base, PDE->isArrow());
5008 mangleUnresolvedPrefix(Qualifier,
5010 mangleUnresolvedTypeOrSimpleId(ScopeInfo->getType());
5014 if (!mangleUnresolvedTypeOrSimpleId(ScopeInfo->getType()))
5017 }
else if (Qualifier) {
5018 mangleUnresolvedPrefix(Qualifier);
5022 QualType DestroyedType = PDE->getDestroyedType();
5023 mangleUnresolvedTypeOrSimpleId(DestroyedType);
5027 case Expr::MemberExprClass: {
5038 case Expr::UnresolvedMemberExprClass: {
5049 case Expr::CXXDependentScopeMemberExprClass: {
5052 = cast<CXXDependentScopeMemberExpr>(
E);
5062 case Expr::UnresolvedLookupExprClass: {
5071 case Expr::CXXUnresolvedConstructExprClass: {
5077 assert(N == 1 &&
"unexpected form for list initialization");
5078 auto *IL = cast<InitListExpr>(CE->
getArg(0));
5081 mangleInitListElements(IL);
5088 if (N != 1) Out <<
'_';
5089 for (
unsigned I = 0; I != N; ++I) mangleExpression(CE->
getArg(I));
5090 if (N != 1) Out <<
'E';
5094 case Expr::CXXConstructExprClass: {
5096 const auto *CE = cast<CXXConstructExpr>(
E);
5101 "implicit CXXConstructExpr must have one argument");
5102 E = cast<CXXConstructExpr>(
E)->getArg(0);
5108 mangleExpression(
E);
5113 case Expr::CXXTemporaryObjectExprClass: {
5115 const auto *CE = cast<CXXTemporaryObjectExpr>(
E);
5124 if (!List && N != 1)
5126 if (CE->isStdInitListInitialization()) {
5132 auto *ILE = cast<InitListExpr>(SILE->getSubExpr()->IgnoreImplicit());
5133 mangleInitListElements(ILE);
5136 mangleExpression(
E);
5143 case Expr::CXXScalarValueInitExprClass:
5150 case Expr::CXXNoexceptExprClass:
5153 mangleExpression(cast<CXXNoexceptExpr>(
E)->getOperand());
5156 case Expr::UnaryExprOrTypeTraitExprClass: {
5175 : ImplicitlyConvertedToType;
5177 mangleIntegerLiteral(
T,
V);
5183 auto MangleAlignofSizeofArg = [&] {
5196 MangleAlignofSizeofArg();
5198 case UETT_PreferredAlignOf:
5203 Out <<
"u11__alignof__";
5214 MangleAlignofSizeofArg();
5216 case UETT_DataSizeOf: {
5220 "cannot yet mangle __datasizeof expression");
5224 case UETT_PtrAuthTypeDiscriminator: {
5228 "cannot yet mangle __builtin_ptrauth_type_discriminator expression");
5232 case UETT_VecStep: {
5235 "cannot yet mangle vec_step expression");
5239 case UETT_OpenMPRequiredSimdAlign: {
5243 "cannot yet mangle __builtin_omp_required_simd_align expression");
5247 case UETT_VectorElements: {
5251 "cannot yet mangle __builtin_vectorelements expression");
5259 case Expr::TypeTraitExprClass: {
5265 Out << Spelling.size() << Spelling;
5267 mangleType(TSI->getType());
5273 case Expr::CXXThrowExprClass: {
5287 case Expr::CXXTypeidExprClass: {
5302 case Expr::CXXDeleteExprClass: {
5313 case Expr::UnaryOperatorClass: {
5322 case Expr::ArraySubscriptExprClass: {
5329 mangleExpression(AE->
getLHS());
5330 mangleExpression(AE->
getRHS());
5334 case Expr::MatrixSubscriptExprClass: {
5338 mangleExpression(ME->
getBase());
5344 case Expr::CompoundAssignOperatorClass:
5345 case Expr::BinaryOperatorClass: {
5353 mangleExpression(BO->
getLHS());
5354 mangleExpression(BO->
getRHS());
5358 case Expr::CXXRewrittenBinaryOperatorClass: {
5362 cast<CXXRewrittenBinaryOperator>(
E)->getDecomposedForm();
5365 mangleExpression(Decomposed.
LHS);
5366 mangleExpression(Decomposed.
RHS);
5370 case Expr::ConditionalOperatorClass: {
5373 mangleOperatorName(OO_Conditional, 3);
5374 mangleExpression(CO->
getCond());
5375 mangleExpression(CO->
getLHS(), Arity);
5376 mangleExpression(CO->
getRHS(), Arity);
5380 case Expr::ImplicitCastExprClass: {
5381 ImplicitlyConvertedToType =
E->
getType();
5382 E = cast<ImplicitCastExpr>(
E)->getSubExpr();
5386 case Expr::ObjCBridgedCastExprClass: {
5390 StringRef
Kind = cast<ObjCBridgedCastExpr>(
E)->getBridgeKindName();
5391 Out <<
"v1U" <<
Kind.size() <<
Kind;
5392 mangleCastExpression(
E,
"cv");
5396 case Expr::CStyleCastExprClass:
5398 mangleCastExpression(
E,
"cv");
5401 case Expr::CXXFunctionalCastExprClass: {
5403 auto *
Sub = cast<ExplicitCastExpr>(
E)->getSubExpr()->IgnoreImplicit();
5405 if (
auto *CCE = dyn_cast<CXXConstructExpr>(
Sub))
5406 if (CCE->getParenOrBraceRange().isInvalid())
5407 Sub = CCE->getArg(0)->IgnoreImplicit();
5408 if (
auto *StdInitList = dyn_cast<CXXStdInitializerListExpr>(
Sub))
5409 Sub = StdInitList->getSubExpr()->IgnoreImplicit();
5410 if (
auto *IL = dyn_cast<InitListExpr>(
Sub)) {
5413 mangleInitListElements(IL);
5416 mangleCastExpression(
E,
"cv");
5421 case Expr::CXXStaticCastExprClass:
5423 mangleCastExpression(
E,
"sc");
5425 case Expr::CXXDynamicCastExprClass:
5427 mangleCastExpression(
E,
"dc");
5429 case Expr::CXXReinterpretCastExprClass:
5431 mangleCastExpression(
E,
"rc");
5433 case Expr::CXXConstCastExprClass:
5435 mangleCastExpression(
E,
"cc");
5437 case Expr::CXXAddrspaceCastExprClass:
5439 mangleCastExpression(
E,
"ac");
5442 case Expr::CXXOperatorCallExprClass: {
5451 for (
unsigned i = 0; i != NumArgs; ++i)
5452 mangleExpression(CE->
getArg(i));
5456 case Expr::ParenExprClass:
5457 E = cast<ParenExpr>(
E)->getSubExpr();
5460 case Expr::ConceptSpecializationExprClass: {
5461 auto *CSE = cast<ConceptSpecializationExpr>(
E);
5467 mangleTemplateName(CSE->getNamedConcept(), CSE->getTemplateArguments());
5473 mangleUnresolvedName(
5474 CSE->getNestedNameSpecifierLoc().getNestedNameSpecifier(),
5475 CSE->getConceptNameInfo().getName(),
5476 CSE->getTemplateArgsAsWritten()->getTemplateArgs(),
5477 CSE->getTemplateArgsAsWritten()->getNumTemplateArgs());
5481 case Expr::RequiresExprClass: {
5483 auto *RE = cast<RequiresExpr>(
E);
5487 if (RE->getLParenLoc().isValid()) {
5489 FunctionTypeDepthState saved = FunctionTypeDepth.push();
5490 if (RE->getLocalParameters().empty()) {
5493 for (
ParmVarDecl *Param : RE->getLocalParameters()) {
5501 FunctionTypeDepth.enterResultType();
5503 mangleRequirement(RE->getExprLoc(), Req);
5504 FunctionTypeDepth.pop(saved);
5509 mangleRequirement(RE->getExprLoc(), Req);
5515 case Expr::DeclRefExprClass:
5517 MangleDeclRefExpr(cast<DeclRefExpr>(
E)->getDecl());
5520 case Expr::SubstNonTypeTemplateParmPackExprClass:
5526 Out <<
"_SUBSTPACK_";
5529 case Expr::FunctionParmPackExprClass: {
5533 Out <<
"v110_SUBSTPACK";
5538 case Expr::DependentScopeDeclRefExprClass: {
5547 case Expr::CXXBindTemporaryExprClass:
5548 E = cast<CXXBindTemporaryExpr>(
E)->getSubExpr();
5551 case Expr::ExprWithCleanupsClass:
5552 E = cast<ExprWithCleanups>(
E)->getSubExpr();
5555 case Expr::FloatingLiteralClass: {
5562 case Expr::FixedPointLiteralClass:
5564 mangleFixedPointLiteral();
5567 case Expr::CharacterLiteralClass:
5571 Out << cast<CharacterLiteral>(
E)->getValue();
5576 case Expr::ObjCBoolLiteralExprClass:
5579 Out << (cast<ObjCBoolLiteralExpr>(
E)->getValue() ?
'1' :
'0');
5583 case Expr::CXXBoolLiteralExprClass:
5586 Out << (cast<CXXBoolLiteralExpr>(
E)->getValue() ?
'1' :
'0');
5590 case Expr::IntegerLiteralClass: {
5594 Value.setIsSigned(
true);
5599 case Expr::ImaginaryLiteralClass: {
5607 dyn_cast<FloatingLiteral>(IE->
getSubExpr())) {
5609 mangleFloat(
llvm::APFloat(Imag->getValue().getSemantics()));
5611 mangleFloat(Imag->getValue());
5616 Value.setIsSigned(
true);
5617 mangleNumber(
Value);
5623 case Expr::StringLiteralClass: {
5627 assert(isa<ConstantArrayType>(
E->
getType()));
5633 case Expr::GNUNullExprClass:
5639 case Expr::CXXNullPtrLiteralExprClass: {
5645 case Expr::LambdaExprClass: {
5650 mangleType(Context.getASTContext().
getRecordType(cast<LambdaExpr>(
E)->getLambdaClass()));
5655 case Expr::PackExpansionExprClass:
5658 mangleExpression(cast<PackExpansionExpr>(
E)->getPattern());
5661 case Expr::SizeOfPackExprClass: {
5663 auto *SPE = cast<SizeOfPackExpr>(
E);
5664 if (SPE->isPartiallySubstituted()) {
5666 for (
const auto &A : SPE->getPartialArguments())
5667 mangleTemplateArg(A,
false);
5675 mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
5677 = dyn_cast<NonTypeTemplateParmDecl>(Pack))
5678 mangleTemplateParameter(NTTP->getDepth(), NTTP->getIndex());
5680 = dyn_cast<TemplateTemplateParmDecl>(Pack))
5681 mangleTemplateParameter(TempTP->getDepth(), TempTP->getIndex());
5683 mangleFunctionParam(cast<ParmVarDecl>(Pack));
5687 case Expr::MaterializeTemporaryExprClass:
5688 E = cast<MaterializeTemporaryExpr>(
E)->getSubExpr();
5691 case Expr::CXXFoldExprClass: {
5693 auto *FE = cast<CXXFoldExpr>(
E);
5694 if (FE->isLeftFold())
5695 Out << (FE->getInit() ?
"fL" :
"fl");
5697 Out << (FE->getInit() ?
"fR" :
"fr");
5699 if (FE->getOperator() == BO_PtrMemD)
5707 mangleExpression(FE->getLHS());
5709 mangleExpression(FE->getRHS());
5713 case Expr::CXXThisExprClass:
5718 case Expr::CoawaitExprClass:
5721 Out <<
"v18co_await";
5722 mangleExpression(cast<CoawaitExpr>(
E)->getOperand());
5725 case Expr::DependentCoawaitExprClass:
5728 Out <<
"v18co_await";
5729 mangleExpression(cast<DependentCoawaitExpr>(
E)->getOperand());
5732 case Expr::CoyieldExprClass:
5735 Out <<
"v18co_yield";
5736 mangleExpression(cast<CoawaitExpr>(
E)->getOperand());
5738 case Expr::SYCLUniqueStableNameExprClass: {
5739 const auto *USN = cast<SYCLUniqueStableNameExpr>(
E);
5742 Out <<
"u33__builtin_sycl_unique_stable_name";
5743 mangleType(USN->getTypeSourceInfo()->getType());
5748 case Expr::SYCLUniqueStableIdExprClass: {
5749 const auto *USID = cast<SYCLUniqueStableIdExpr>(
E);
5752 Out <<
"cl31__builtin_sycl_unique_stable_id";
5753 mangleExpression(USID->getExpr());
5759 if (AsTemplateArg && !IsPrimaryExpr)
5791 void CXXNameMangler::mangleFunctionParam(
const ParmVarDecl *parm) {
5798 assert(parmDepth < FunctionTypeDepth.getDepth());
5799 unsigned nestingDepth = FunctionTypeDepth.getDepth() - parmDepth;
5800 if (FunctionTypeDepth.isInResultType())
5803 if (nestingDepth == 0) {
5806 Out <<
"fL" << (nestingDepth - 1) <<
'p';
5814 &&
"parameter's type is still an array type?");
5817 dyn_cast<DependentAddressSpaceType>(parm->
getType())) {
5824 if (parmIndex != 0) {
5825 Out << (parmIndex - 1);
5853 llvm_unreachable(
"closure constructors don't exist for the Itanium ABI!");
5856 mangleName(InheritedFrom);
5859 void CXXNameMangler::mangleCXXDtorType(
CXXDtorType T) {
5886 bool SeenPackExpansionIntoNonPack =
false;
5890 : Mangler(Mangler) {
5892 ResolvedTemplate = TD;
5910 if (
auto *FTD = dyn_cast_or_null<FunctionTemplateDecl>(ResolvedTemplate)) {
5911 auto *RD = dyn_cast<CXXRecordDecl>(FTD->getDeclContext());
5912 if (!RD || !RD->isGenericLambda())
5928 if (
auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
5929 return TTP->hasTypeConstraint();
5938 return needToMangleTemplateParam(Param, *Arg.
pack_begin());
5946 if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param))
5947 return NTTP->getType()->isInstantiationDependentType() ||
5948 NTTP->getType()->getContainedDeducedType();
5952 auto *TTP = cast<TemplateTemplateParmDecl>(Param);
5963 auto MangleTemplateParamListToString =
5965 unsigned DepthOffset) {
5966 llvm::raw_svector_ostream Stream(Buffer);
5967 CXXNameMangler(Mangler.Context, Stream,
5968 WithTemplateDepthOffset{DepthOffset})
5969 .mangleTemplateParameterList(Params);
5972 MangleTemplateParamListToString(ParamTemplateHead,
5973 TTP->getTemplateParameters(), 0);
5977 MangleTemplateParamListToString(ArgTemplateHead,
5979 TTP->getTemplateParameters()->
getDepth());
5980 return ParamTemplateHead != ArgTemplateHead;
5989 if (!ResolvedTemplate || SeenPackExpansionIntoNonPack)
5990 return {
true,
nullptr};
5993 const NamedDecl *Param = UnresolvedExpandedPack;
5996 "no parameter for argument");
6007 UnresolvedExpandedPack = Param;
6016 SeenPackExpansionIntoNonPack =
true;
6017 return {
true,
nullptr};
6022 if (isOverloadable())
6023 return {
true, needToMangleTemplateParam(Param, Arg) ? Param :
nullptr};
6032 auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param);
6033 bool NeedExactType = NTTP && NTTP->getType()->getContainedDeducedType();
6034 return {NeedExactType,
nullptr};
6040 if (!isOverloadable())
6046 void CXXNameMangler::mangleTemplateArgs(
TemplateName TN,
6048 unsigned NumTemplateArgs) {
6051 TemplateArgManglingInfo Info(*
this, TN);
6052 for (
unsigned i = 0; i != NumTemplateArgs; ++i) {
6053 mangleTemplateArg(Info, i, TemplateArgs[i].
getArgument());
6055 mangleRequiresClause(Info.getTrailingRequiresClauseToMangle());
6059 void CXXNameMangler::mangleTemplateArgs(
TemplateName TN,
6063 TemplateArgManglingInfo Info(*
this, TN);
6064 for (
unsigned i = 0, e = AL.
size(); i != e; ++i) {
6065 mangleTemplateArg(Info, i, AL[i]);
6067 mangleRequiresClause(Info.getTrailingRequiresClauseToMangle());
6071 void CXXNameMangler::mangleTemplateArgs(
TemplateName TN,
6075 TemplateArgManglingInfo Info(*
this, TN);
6076 for (
unsigned i = 0; i != Args.size(); ++i) {
6077 mangleTemplateArg(Info, i, Args[i]);
6079 mangleRequiresClause(Info.getTrailingRequiresClauseToMangle());
6083 void CXXNameMangler::mangleTemplateArg(TemplateArgManglingInfo &Info,
6085 TemplateArgManglingInfo::Info ArgInfo = Info.getArgInfo(Index, A);
6088 if (ArgInfo.TemplateParameterToMangle &&
6096 mangleTemplateParamDecl(ArgInfo.TemplateParameterToMangle);
6099 mangleTemplateArg(A, ArgInfo.NeedExactType);
6102 void CXXNameMangler::mangleTemplateArg(
TemplateArgument A,
bool NeedExactType) {
6112 llvm_unreachable(
"Cannot mangle NULL template argument");
6139 auto *TPO = cast<TemplateParamObjectDecl>(
D);
6140 mangleValueInTemplateArg(TPO->getType().getUnqualifiedType(),
6141 TPO->getValue(),
true,
6148 if (
D->isCXXInstanceMember())
6151 else if (
D->getType()->isArrayType() &&
6175 true, NeedExactType);
6181 mangleTemplateArg(
P, NeedExactType);
6187 void CXXNameMangler::mangleTemplateArgExpr(
const Expr *
E) {
6189 mangleExpression(
E, UnknownArity,
true);
6204 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(
E)) {
6206 if (isa<VarDecl>(
D) || isa<FunctionDecl>(
D)) {
6214 mangleExpression(
E);
6227 switch (
V.getKind()) {
6235 assert(RD &&
"unexpected type for record value");
6244 if (!FD->isUnnamedBitField() &&
6254 assert(RD &&
"unexpected type for union value");
6257 if (!FD->isUnnamedBitField())
6268 for (
unsigned I = 0, N =
V.getArrayInitializedElts(); I != N; ++I)
6276 for (
unsigned I = 0, N =
V.getVectorLength(); I != N; ++I)
6286 return V.getFloat().isPosZero();
6289 return !
V.getFixedPoint().getValue();
6292 return V.getComplexFloatReal().isPosZero() &&
6293 V.getComplexFloatImag().isPosZero();
6296 return !
V.getComplexIntReal() && !
V.getComplexIntImag();
6299 return V.isNullPointer();
6302 return !
V.getMemberPointerDecl();
6305 llvm_unreachable(
"Unhandled APValue::ValueKind enum");
6312 T = AT->getElementType();
6314 dyn_cast<FieldDecl>(
E.getAsBaseOrMember().getPointer()))
6318 cast<CXXRecordDecl>(
E.getAsBaseOrMember().getPointer()));
6359 Diags.
Report(UnionLoc, DiagID);
6366 bool NeedExactType) {
6369 T = getASTContext().getUnqualifiedArrayType(
T, Quals);
6372 bool IsPrimaryExpr =
true;
6373 auto NotPrimaryExpr = [&] {
6374 if (TopLevel && IsPrimaryExpr)
6376 IsPrimaryExpr =
false;
6380 switch (
V.getKind()) {
6389 llvm_unreachable(
"unexpected value kind in template argument");
6393 assert(RD &&
"unexpected type for record value");
6399 (Fields.back()->isUnnamedBitField() ||
6401 V.getStructField(Fields.back()->getFieldIndex())))) {
6405 if (Fields.empty()) {
6406 while (!Bases.empty() &&
6408 V.getStructBase(Bases.size() - 1)))
6409 Bases = Bases.drop_back();
6416 for (
unsigned I = 0, N = Bases.size(); I != N; ++I)
6417 mangleValueInTemplateArg(Bases[I].getType(),
V.getStructBase(I),
false);
6418 for (
unsigned I = 0, N = Fields.size(); I != N; ++I) {
6419 if (Fields[I]->isUnnamedBitField())
6421 mangleValueInTemplateArg(Fields[I]->getType(),
6422 V.getStructField(Fields[I]->getFieldIndex()),
6449 mangleSourceName(II);
6450 mangleValueInTemplateArg(FD->
getType(),
V.getUnionValue(),
false);
6464 unsigned N =
V.getArraySize();
6466 N =
V.getArrayInitializedElts();
6471 for (
unsigned I = 0; I != N; ++I) {
6472 const APValue &Elem = I <
V.getArrayInitializedElts()
6473 ?
V.getArrayInitializedElt(I)
6474 :
V.getArrayFiller();
6475 mangleValueInTemplateArg(ElemT, Elem,
false);
6487 unsigned N =
V.getVectorLength();
6490 for (
unsigned I = 0; I != N; ++I)
6491 mangleValueInTemplateArg(VT->
getElementType(),
V.getVectorElt(I),
false);
6497 mangleIntegerLiteral(
T,
V.getInt());
6501 mangleFloatLiteral(
T,
V.getFloat());
6505 mangleFixedPointLiteral();
6513 if (!
V.getComplexFloatReal().isPosZero() ||
6514 !
V.getComplexFloatImag().isPosZero())
6516 if (!
V.getComplexFloatImag().isPosZero())
6527 if (
V.getComplexIntReal().getBoolValue() ||
6528 V.getComplexIntImag().getBoolValue())
6530 if (
V.getComplexIntImag().getBoolValue())
6539 "unexpected type for LValue template arg");
6541 if (
V.isNullPointer()) {
6542 mangleNullPointer(
T);
6563 Out <<
Offset.getQuantity() <<
'E';
6571 if (!
V.hasLValuePath()) {
6587 bool IsArrayToPointerDecayMangledAsDecl =
false;
6588 if (TopLevel && Ctx.
getLangOpts().getClangABICompat() <=
6591 IsArrayToPointerDecayMangledAsDecl =
6592 BType->
isArrayType() &&
V.getLValuePath().size() == 1 &&
6593 V.getLValuePath()[0].getAsArrayIndex() == 0 &&
6597 if ((!
V.getLValuePath().empty() ||
V.isLValueOnePastTheEnd()) &&
6598 !IsArrayToPointerDecayMangledAsDecl) {
6615 if (NeedExactType &&
6637 mangleExpression(
E);
6641 mangleType(
QualType(TI.getType(), 0));
6644 llvm_unreachable(
"unexpected lvalue base kind in template argument");
6654 mangleNumber(
V.getLValueOffset().getQuantity());
6661 if (!
V.getLValueOffset().isZero())
6662 mangleNumber(
V.getLValueOffset().getQuantity());
6666 bool OnePastTheEnd =
V.isLValueOnePastTheEnd();
6670 if (
auto *CAT = dyn_cast<ConstantArrayType>(AT))
6671 OnePastTheEnd |= CAT->getSize() ==
E.getAsArrayIndex();
6672 TypeSoFar = AT->getElementType();
6674 const Decl *
D =
E.getAsBaseOrMember().getPointer();
6675 if (
auto *FD = dyn_cast<FieldDecl>(
D)) {
6700 if (!
V.getMemberPointerDecl()) {
6701 mangleNullPointer(
T);
6708 if (!
V.getMemberPointerPath().empty()) {
6711 }
else if (NeedExactType &&
6714 V.getMemberPointerDecl()->getType()) &&
6720 mangle(
V.getMemberPointerDecl());
6722 if (!
V.getMemberPointerPath().empty()) {
6726 mangleNumber(
Offset.getQuantity());
6732 if (TopLevel && !IsPrimaryExpr)
6736 void CXXNameMangler::mangleTemplateParameter(
unsigned Depth,
unsigned Index) {
6746 Depth += TemplateDepthOffset;
6748 Out <<
'L' << (
Depth - 1) <<
'_';
6754 void CXXNameMangler::mangleSeqID(
unsigned SeqID) {
6757 }
else if (SeqID == 1) {
6767 for (; SeqID != 0; SeqID /= 36) {
6768 unsigned C = SeqID % 36;
6769 *I++ = (
C < 10 ?
'0' +
C :
'A' +
C - 10);
6772 Out.write(I.base(), I - BufferRef.rbegin());
6777 void CXXNameMangler::mangleExistingSubstitution(
TemplateName tname) {
6778 bool result = mangleSubstitution(tname);
6779 assert(result &&
"no existing substitution for template name");
6785 bool CXXNameMangler::mangleSubstitution(
const NamedDecl *ND) {
6787 if (mangleStandardSubstitution(ND))
6791 return mangleSubstitution(
reinterpret_cast<uintptr_t>(ND));
6796 "mangleSubstitution(NestedNameSpecifier *) is only used for "
6797 "identifier nested name specifiers.");
6799 return mangleSubstitution(
reinterpret_cast<uintptr_t>(NNS));
6809 bool CXXNameMangler::mangleSubstitution(
QualType T) {
6812 return mangleSubstitution(RT->getDecl());
6817 return mangleSubstitution(TypePtr);
6820 bool CXXNameMangler::mangleSubstitution(
TemplateName Template) {
6822 return mangleSubstitution(TD);
6825 return mangleSubstitution(
6829 bool CXXNameMangler::mangleSubstitution(
uintptr_t Ptr) {
6830 llvm::DenseMap<uintptr_t, unsigned>::iterator I = Substitutions.find(Ptr);
6831 if (I == Substitutions.end())
6834 unsigned SeqID = I->second;
6843 bool CXXNameMangler::isSpecializedAs(
QualType S, llvm::StringRef Name,
6853 dyn_cast<ClassTemplateSpecializationDecl>(RT->
getDecl());
6857 if (!isStdNamespace(Context.getEffectiveDeclContext(SD)))
6861 if (TemplateArgs.
size() != 1)
6864 if (TemplateArgs[0].getAsType() != A)
6876 bool CXXNameMangler::isStdCharSpecialization(
6878 bool HasAllocator) {
6883 if (TemplateArgs.
size() != (HasAllocator ? 3 : 2))
6886 QualType A = TemplateArgs[0].getAsType();
6894 if (!isSpecializedAs(TemplateArgs[1].getAsType(),
"char_traits", A))
6898 !isSpecializedAs(TemplateArgs[2].getAsType(),
"allocator", A))
6907 bool CXXNameMangler::mangleStandardSubstitution(
const NamedDecl *ND) {
6909 if (
const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
6918 if (!isStdNamespace(Context.getEffectiveDeclContext(TD)))
6939 dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
6940 if (!isStdNamespace(Context.getEffectiveDeclContext(SD)))
6949 if (isStdCharSpecialization(SD,
"basic_string",
true)) {
6956 if (isStdCharSpecialization(SD,
"basic_istream",
false)) {
6963 if (isStdCharSpecialization(SD,
"basic_ostream",
false)) {
6970 if (isStdCharSpecialization(SD,
"basic_iostream",
false)) {
6980 void CXXNameMangler::addSubstitution(
QualType T) {
6983 addSubstitution(RT->
getDecl());
6989 addSubstitution(TypePtr);
6992 void CXXNameMangler::addSubstitution(
TemplateName Template) {
6994 return addSubstitution(TD);
7000 void CXXNameMangler::addSubstitution(
uintptr_t Ptr) {
7001 assert(!Substitutions.count(Ptr) &&
"Substitution already exists!");
7002 Substitutions[Ptr] = SeqID++;
7005 void CXXNameMangler::extendSubstitutions(CXXNameMangler* Other) {
7006 assert(
Other->SeqID >= SeqID &&
"Must be superset of substitutions!");
7007 if (
Other->SeqID > SeqID) {
7008 Substitutions.swap(
Other->Substitutions);
7009 SeqID =
Other->SeqID;
7014 CXXNameMangler::makeFunctionReturnTypeTags(
const FunctionDecl *FD) {
7016 if (DisableDerivedAbiTags)
7017 return AbiTagList();
7019 llvm::raw_null_ostream NullOutStream;
7020 CXXNameMangler TrackReturnTypeTags(*
this, NullOutStream);
7021 TrackReturnTypeTags.disableDerivedAbiTags();
7025 FunctionTypeDepthState saved = TrackReturnTypeTags.FunctionTypeDepth.push();
7026 TrackReturnTypeTags.FunctionTypeDepth.enterResultType();
7028 TrackReturnTypeTags.FunctionTypeDepth.leaveResultType();
7029 TrackReturnTypeTags.FunctionTypeDepth.pop(saved);
7031 return TrackReturnTypeTags.AbiTagsRoot.getSortedUniqueUsedAbiTags();
7035 CXXNameMangler::makeVariableTypeTags(
const VarDecl *VD) {
7037 if (DisableDerivedAbiTags)
7038 return AbiTagList();
7040 llvm::raw_null_ostream NullOutStream;
7041 CXXNameMangler TrackVariableType(*
this, NullOutStream);
7042 TrackVariableType.disableDerivedAbiTags();
7044 TrackVariableType.mangleType(VD->
getType());
7046 return TrackVariableType.AbiTagsRoot.getSortedUniqueUsedAbiTags();
7049 bool CXXNameMangler::shouldHaveAbiTags(ItaniumMangleContextImpl &C,
7051 llvm::raw_null_ostream NullOutStream;
7052 CXXNameMangler TrackAbiTags(C, NullOutStream,
nullptr,
true);
7053 TrackAbiTags.mangle(VD);
7054 return TrackAbiTags.AbiTagsRoot.getUsedAbiTags().size();
7067 void ItaniumMangleContextImpl::mangleCXXName(
GlobalDecl GD,
7070 assert((isa<FunctionDecl, VarDecl, TemplateParamObjectDecl>(
D)) &&
7071 "Invalid mangleName() call, argument is not a variable or function!");
7074 getASTContext().getSourceManager(),
7075 "Mangling declaration");
7077 if (
auto *CD = dyn_cast<CXXConstructorDecl>(
D)) {
7079 CXXNameMangler Mangler(*
this, Out, CD,
Type);
7083 if (
auto *DD = dyn_cast<CXXDestructorDecl>(
D)) {
7085 CXXNameMangler Mangler(*
this, Out, DD,
Type);
7089 CXXNameMangler Mangler(*
this, Out,
D);
7127 unsigned TypedDiscriminator =
7129 Mangler.mangleVendorQualifier(
"__vtptrauth");
7130 auto &ManglerStream = Mangler.getStream();
7131 ManglerStream <<
"I";
7132 if (
const auto *ExplicitAuth =
7133 PtrauthClassRD->
getAttr<VTablePointerAuthenticationAttr>()) {
7134 ManglerStream <<
"Lj" << ExplicitAuth->getKey();
7136 if (ExplicitAuth->getAddressDiscrimination() ==
7137 VTablePointerAuthenticationAttr::DefaultAddressDiscrimination)
7138 ManglerStream <<
"Lb" << LangOpts.PointerAuthVTPtrAddressDiscrimination;
7140 ManglerStream <<
"Lb"
7141 << (ExplicitAuth->getAddressDiscrimination() ==
7142 VTablePointerAuthenticationAttr::AddressDiscrimination);
7144 switch (ExplicitAuth->getExtraDiscrimination()) {
7145 case VTablePointerAuthenticationAttr::DefaultExtraDiscrimination: {
7146 if (LangOpts.PointerAuthVTPtrTypeDiscrimination)
7147 ManglerStream <<
"Lj" << TypedDiscriminator;
7149 ManglerStream <<
"Lj" << 0;
7152 case VTablePointerAuthenticationAttr::TypeDiscrimination:
7153 ManglerStream <<
"Lj" << TypedDiscriminator;
7155 case VTablePointerAuthenticationAttr::CustomDiscrimination:
7156 ManglerStream <<
"Lj" << ExplicitAuth->getCustomDiscriminationValue();
7158 case VTablePointerAuthenticationAttr::NoExtraDiscrimination:
7159 ManglerStream <<
"Lj" << 0;
7163 ManglerStream <<
"Lj"
7164 << (
unsigned)VTablePointerAuthenticationAttr::DefaultKey;
7165 ManglerStream <<
"Lb" << LangOpts.PointerAuthVTPtrAddressDiscrimination;
7166 if (LangOpts.PointerAuthVTPtrTypeDiscrimination)
7167 ManglerStream <<
"Lj" << TypedDiscriminator;
7169 ManglerStream <<
"Lj" << 0;
7171 ManglerStream <<
"E";
7174 void ItaniumMangleContextImpl::mangleThunk(
const CXXMethodDecl *MD,
7176 bool ElideOverrideInfo,
7185 assert(!isa<CXXDestructorDecl>(MD) &&
7186 "Use mangleCXXDtor for destructor decls!");
7187 CXXNameMangler Mangler(*
this, Out);
7188 Mangler.getStream() <<
"_ZT";
7190 Mangler.getStream() <<
'c';
7201 Mangler.mangleFunctionEncoding(MD);
7202 if (!ElideOverrideInfo)
7209 bool ElideOverrideInfo,
7213 CXXNameMangler Mangler(*
this, Out, DD,
Type);
7214 Mangler.getStream() <<
"_ZT";
7222 if (!ElideOverrideInfo)
7227 void ItaniumMangleContextImpl::mangleStaticGuardVariable(
const VarDecl *
D,
7231 CXXNameMangler Mangler(*
this, Out);
7234 Mangler.getStream() <<
"_ZGV";
7235 Mangler.mangleName(
D);
7238 void ItaniumMangleContextImpl::mangleDynamicInitializer(
const VarDecl *MD,
7243 Out <<
"__cxx_global_var_init";
7246 void ItaniumMangleContextImpl::mangleDynamicAtExitDestructor(
const VarDecl *
D,
7249 CXXNameMangler Mangler(*
this, Out);
7250 Mangler.getStream() <<
"__dtor_";
7251 if (shouldMangleDeclName(
D))
7254 Mangler.getStream() <<
D->getName();
7257 void ItaniumMangleContextImpl::mangleDynamicStermFinalizer(
const VarDecl *
D,
7261 CXXNameMangler Mangler(*
this, Out);
7262 Mangler.getStream() <<
"__finalize_";
7263 if (shouldMangleDeclName(
D))
7266 Mangler.getStream() <<
D->getName();
7269 void ItaniumMangleContextImpl::mangleSEHFilterExpression(
7270 GlobalDecl EnclosingDecl, raw_ostream &Out) {
7271 CXXNameMangler Mangler(*
this, Out);
7272 Mangler.getStream() <<
"__filt_";
7273 auto *EnclosingFD = cast<FunctionDecl>(EnclosingDecl.
getDecl());
7274 if (shouldMangleDeclName(EnclosingFD))
7275 Mangler.mangle(EnclosingDecl);
7277 Mangler.getStream() << EnclosingFD->getName();
7280 void ItaniumMangleContextImpl::mangleSEHFinallyBlock(
7281 GlobalDecl EnclosingDecl, raw_ostream &Out) {
7282 CXXNameMangler Mangler(*
this, Out);
7283 Mangler.getStream() <<
"__fin_";
7284 auto *EnclosingFD = cast<FunctionDecl>(EnclosingDecl.
getDecl());
7285 if (shouldMangleDeclName(EnclosingFD))
7286 Mangler.mangle(EnclosingDecl);
7288 Mangler.getStream() << EnclosingFD->getName();
7291 void ItaniumMangleContextImpl::mangleItaniumThreadLocalInit(
const VarDecl *
D,
7294 CXXNameMangler Mangler(*
this, Out);
7295 Mangler.getStream() <<
"_ZTH";
7296 Mangler.mangleName(
D);
7300 ItaniumMangleContextImpl::mangleItaniumThreadLocalWrapper(
const VarDecl *
D,
7303 CXXNameMangler Mangler(*
this, Out);
7304 Mangler.getStream() <<
"_ZTW";
7305 Mangler.mangleName(
D);
7308 void ItaniumMangleContextImpl::mangleReferenceTemporary(
const VarDecl *
D,
7309 unsigned ManglingNumber,
7313 CXXNameMangler Mangler(*
this, Out);
7314 Mangler.getStream() <<
"_ZGR";
7315 Mangler.mangleName(
D);
7316 assert(ManglingNumber > 0 &&
"Reference temporary mangling number is zero!");
7317 Mangler.mangleSeqID(ManglingNumber - 1);
7320 void ItaniumMangleContextImpl::mangleCXXVTable(
const CXXRecordDecl *RD,
7323 CXXNameMangler Mangler(*
this, Out);
7324 Mangler.getStream() <<
"_ZTV";
7325 Mangler.mangleNameOrStandardSubstitution(RD);
7328 void ItaniumMangleContextImpl::mangleCXXVTT(
const CXXRecordDecl *RD,
7331 CXXNameMangler Mangler(*
this, Out);
7332 Mangler.getStream() <<
"_ZTT";
7333 Mangler.mangleNameOrStandardSubstitution(RD);
7336 void ItaniumMangleContextImpl::mangleCXXCtorVTable(
const CXXRecordDecl *RD,
7341 CXXNameMangler Mangler(*
this, Out);
7342 Mangler.getStream() <<
"_ZTC";
7343 Mangler.mangleNameOrStandardSubstitution(RD);
7344 Mangler.getStream() <<
Offset;
7345 Mangler.getStream() <<
'_';
7346 Mangler.mangleNameOrStandardSubstitution(
Type);
7349 void ItaniumMangleContextImpl::mangleCXXRTTI(
QualType Ty, raw_ostream &Out) {
7351 assert(!Ty.
hasQualifiers() &&
"RTTI info cannot have top-level qualifiers");
7352 CXXNameMangler Mangler(*
this, Out);
7353 Mangler.getStream() <<
"_ZTI";
7354 Mangler.mangleType(Ty);
7357 void ItaniumMangleContextImpl::mangleCXXRTTIName(
7358 QualType Ty, raw_ostream &Out,
bool NormalizeIntegers =
false) {
7360 CXXNameMangler Mangler(*
this, Out, NormalizeIntegers);
7361 Mangler.getStream() <<
"_ZTS";
7362 Mangler.mangleType(Ty);
7365 void ItaniumMangleContextImpl::mangleCanonicalTypeName(
7366 QualType Ty, raw_ostream &Out,
bool NormalizeIntegers =
false) {
7367 mangleCXXRTTIName(Ty, Out, NormalizeIntegers);
7370 void ItaniumMangleContextImpl::mangleStringLiteral(
const StringLiteral *, raw_ostream &) {
7371 llvm_unreachable(
"Can't mangle string literals");
7374 void ItaniumMangleContextImpl::mangleLambdaSig(
const CXXRecordDecl *Lambda,
7376 CXXNameMangler Mangler(*
this, Out);
7377 Mangler.mangleLambdaSig(Lambda);
7380 void ItaniumMangleContextImpl::mangleModuleInitializer(
const Module *M,
7383 CXXNameMangler Mangler(*
this, Out);
7384 Mangler.getStream() <<
"_ZGI";
7388 auto Partition = M->
Name.find(
':');
7389 Mangler.mangleModuleNamePrefix(
7390 StringRef(&M->
Name[Partition + 1], M->
Name.size() - Partition - 1),
7398 return new ItaniumMangleContextImpl(
7401 return std::nullopt;
7410 return new ItaniumMangleContextImpl(Context, Diags, DiscriminatorOverride,
Enums/classes describing ABI related information about constructors, destructors and thunks.
Defines the clang::ASTContext interface.
enum clang::sema::@1659::IndirectLocalPathEntry::EntryKind Kind
static bool isUniqueInternalLinkageDecl(GlobalDecl GD, CodeGenModule &CGM)
static Decl::Kind getKind(const Decl *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
This file defines OpenMP nodes for declarative directives.
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines Expressions and AST nodes for C++2a concepts.
static bool isTypeSubstitutable(Qualifiers Quals, const Type *Ty, ASTContext &Ctx)
static bool hasMangledSubstitutionQualifiers(QualType T)
Determine whether the given type has any qualifiers that are relevant for substitutions.
static GlobalDecl getParentOfLocalEntity(const DeclContext *DC)
static StringRef mangleAArch64VectorBase(const BuiltinType *EltType)
static IdentifierInfo * getUnionInitName(SourceLocation UnionLoc, DiagnosticsEngine &Diags, const FieldDecl *FD)
static void mangleOverrideDiscrimination(CXXNameMangler &Mangler, ASTContext &Context, const ThunkInfo &Thunk)
Mangles the pointer authentication override attribute for classes that have explicit overrides for th...
static bool isZeroInitialized(QualType T, const APValue &V)
Determine whether a given value is equivalent to zero-initialization for the purpose of discarding a ...
static const GlobalDecl isTemplate(GlobalDecl GD, const TemplateArgumentList *&TemplateArgs)
static bool isParenthesizedADLCallee(const CallExpr *call)
Look at the callee of the given call expression and determine if it's a parenthesized id-expression w...
static TemplateName asTemplateName(GlobalDecl GD)
static QualType getLValueType(ASTContext &Ctx, const APValue &LV)
llvm::MachO::Target Target
llvm::MachO::Record Record
Defines the clang::Module class, which describes a module in the source code.
static StringRef getIdentifier(const Token &Tok)
Defines the SourceManager interface.
Enums/classes describing THUNK related information about constructors, destructors and thunks.
Defines the clang::TypeLoc interface and its subclasses.
static const TemplateArgument & getArgument(const TemplateArgument &A)
A non-discriminated union of a base, field, or array index.
static LValuePathEntry ArrayIndex(uint64_t Index)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
const LValueBase getLValueBase() const
ArrayRef< LValuePathEntry > getLValuePath() const
@ Indeterminate
This object has an indeterminate value (C++ [basic.indet]).
@ None
There is no such object (it's outside its lifetime).
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
bool hasSimilarType(QualType T1, QualType T2)
Determine if two types are similar, according to the C++ rules.
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
TemplateName getCanonicalTemplateName(const TemplateName &Name) const
Retrieves the "canonical" template name that refers to a given template.
CharUnits getMemberPointerPathAdjustment(const APValue &MP) const
Find the 'this' offset for the member path in a pointer-to-member APValue.
QualType getRecordType(const RecordDecl *Decl) const
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
const LangOptions & getLangOpts() const
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
QualType getSignatureParameterType(QualType T) const
Retrieve the parameter type as adjusted for use in the signature of a function, decaying array and fu...
bool addressSpaceMapManglingFor(LangAS AS) const
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
const CXXRecordDecl * baseForVTableAuthentication(const CXXRecordDecl *ThisClass)
Resolve the root record to be used to derive the vtable pointer authentication policy for the specifi...
unsigned getTargetAddressSpace(LangAS AS) const
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
uint16_t getPointerAuthVTablePointerDiscriminator(const CXXRecordDecl *RD)
Return the "other" discriminator used for the pointer auth schema used for vtable pointers in instanc...
Represents a constant array type that does not decay to a pointer when used as a function parameter.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Attr - This represents one attribute.
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
A builtin binary operation expression such as "x + y" or "x <= y".
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
A binding in a decomposition declaration.
A fixed int type of a specified bitwidth.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
This class is used for builtin types like 'int'.
Represents a base class of a C++ class.
Represents a call to a C++ constructor.
Represents a C++ constructor within a class.
Represents a delete expression for memory deallocation and destructor calls, e.g.
bool isGlobalDelete() const
Represents a C++ member access expression where the actual member referenced could not be resolved be...
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '.
Expr * getBase() const
Retrieve the base object of this member expressions, e.g., the x in x.m.
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the member name.
DeclarationName getMember() const
Retrieve the name of the member that this expression refers to.
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments provided as part of this template-id.
bool isImplicitAccess() const
True if this is an implicit access, i.e.
NamedDecl * getFirstQualifierFoundInScope() const
Retrieve the first part of the nested-name-specifier that was found in the scope of the member access...
Represents a C++ destructor within a class.
Represents a static or instance method of a struct/union/class.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
QualType getAllocatedType() const
arg_iterator placement_arg_end()
CXXNewInitializationStyle getInitializationStyle() const
The kind of initializer this new-expression has.
bool hasInitializer() const
Whether this new-expression has any initializer at all.
Expr * getInitializer()
The initializer of this new-expression.
arg_iterator placement_arg_begin()
A call to an overloaded operator written using operator syntax.
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Represents a C++ struct/union/class.
Decl * getLambdaContextDecl() const
Retrieve the declaration that provides additional context for a lambda, when the normal declaration c...
TemplateParameterList * getGenericLambdaTemplateParameterList() const
Retrieve the generic lambda's template parameter list.
base_class_iterator bases_end()
TypeSourceInfo * getLambdaTypeInfo() const
bool isLambda() const
Determine whether this class describes a lambda function object.
unsigned getLambdaManglingNumber() const
If this is the closure type of a lambda expression, retrieve the number to be used for name mangling ...
base_class_iterator bases_begin()
ArrayRef< NamedDecl * > getLambdaExplicitTemplateParameters() const
Retrieve the lambda template parameters that were specified explicitly.
CXXMethodDecl * getLambdaStaticInvoker() const
Retrieve the lambda static invoker, the address of which is returned by the conversion operator,...
A C++ throw-expression (C++ [except.throw]).
const Expr * getSubExpr() const
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this typeid() expression after various required adjustments (removing r...
bool isTypeOperand() const
Expr * getExprOperand() const
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
bool isListInitialization() const
Determine whether this expression models list-initialization.
Expr * getArg(unsigned I)
unsigned getNumArgs() const
Retrieve the number of arguments.
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Expr * getExprOperand() const
QualType getTypeOperand(ASTContext &Context) const
Retrieves the type operand of this __uuidof() expression after various required adjustments (removing...
bool isTypeOperand() const
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
CharUnits - This is an opaque type for sizes expressed in character units.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Declaration of a class template.
Represents a class template specialization, which refers to a class template with a given set of temp...
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
Complex values, per C99 6.2.5p11.
QualType getElementType() const
Declaration of a C++20 concept.
ConditionalOperator - The ?: ternary operator.
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
Represents the canonical version of C arrays with a specified constant size.
Represents a concrete matrix type with constant number of rows and columns.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
bool isFileContext() const
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool isTranslationUnit() const
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
bool isFunctionOrMethod() const
A reference to a declared variable, function, enum, etc.
Decl - This represents one declaration (or definition), e.g.
bool isParameterPack() const
Whether this declaration is a parameter pack.
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
SourceLocation getLocation() const
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
void setImplicit(bool I=true)
bool isInAnonymousNamespace() const
Module * getOwningModuleForLinkage() const
Get the module that owns this declaration for linkage purposes.
DeclContext * getDeclContext()
The name of a declaration.
@ CXXConversionFunctionName
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
Represents the type decltype(expr) (C++11).
Represents a C++17 deduced template specialization type.
Represents an extended address space qualifier where the input address space value is dependent.
Expr * getAddrSpaceExpr() const
QualType getPointeeType() const
Represents a qualified type name for which the type name is dependent.
A qualified reference to a name whose declaration cannot yet be resolved.
TemplateArgumentLoc const * getTemplateArgs() const
unsigned getNumTemplateArgs() const
DeclarationName getDeclName() const
Retrieve the name that this expression refers to.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies this declaration.
Represents an array type in C++ whose size is a value-dependent expression.
Represents an extended vector type where either the type or size is dependent.
Represents a matrix type where the type and the number of rows and columns is dependent on a template...
Represents a dependent template name that cannot be resolved prior to template instantiation.
Represents a template specialization type whose template cannot be resolved, e.g.
NestedNameSpecifier * getQualifier() const
const IdentifierInfo * getIdentifier() const
ArrayRef< TemplateArgument > template_arguments() const
Represents a vector type where either the type or size is dependent.
Designator - A designator in a C99 designated initializer.
bool isArrayDesignator() const
bool isArrayRangeDesignator() const
bool isFieldDesignator() const
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
An instance of this object exists for each enum constant that is defined.
llvm::APSInt getInitVal() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
ExplicitCastExpr - An explicit cast written in the source code.
This represents one expression.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
ExtVectorType - Extended vector type.
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
llvm::APFloat getValue() const
Represents a function declaration or definition.
bool isMemberLikeConstrainedFriend() const
Determine whether a function is a friend function that cannot be redeclared outside of its class,...
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
const ParmVarDecl * getParamDecl(unsigned i) const
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
VarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
Represents a prototype with parameter type info, e.g.
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
ExtParameterInfo getExtParameterInfo(unsigned I) const
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
unsigned getNumParams() const
Qualifiers getMethodQuals() const
ArrayRef< QualType > exceptions() const
QualType getParamType(unsigned i) const
bool isVariadic() const
Whether this function prototype is variadic.
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
bool hasInstantiationDependentExceptionSpec() const
Return whether this function has an instantiation-dependent exception spec.
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type?
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Declaration of a template function.
A class which abstracts out some details necessary for making a call.
CallingConv getCC() const
bool getProducesResult() const
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
QualType getReturnType() const
GlobalDecl - represents a global declaration.
CXXCtorType getCtorType() const
KernelReferenceKind getKernelReferenceKind() const
GlobalDecl getWithDecl(const Decl *D)
const Decl * getDecl() const
CXXDtorType getDtorType() const
One of these records is kept for each identifier that is lexed.
unsigned getLength() const
Efficiently return the length of this identifier info.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StringRef getName() const
Return the actual identifier string.
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
const Expr * getSubExpr() const
Represents a C array with an unspecified size.
Represents a field injected from an anonymous union/struct into the parent scope.
Describes an C or C++ initializer list.
unsigned getNumInits() const
const Expr * getInit(unsigned Init) const
InitListExpr * getSyntacticForm() const
The injected class name of a C++ class template or class template partial specialization.
static ItaniumMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags, bool IsAux=false)
std::optional< unsigned >(*)(ASTContext &, const NamedDecl *) DiscriminatorOverrideTy
An lvalue reference type, per C++11 [dcl.ref].
ClangABI
Clang versions with different platform ABI conformance.
@ Ver6
Attempt to be ABI-compatible with code generated by Clang 6.0.x (SVN r321711).
@ Ver18
Attempt to be ABI-compatible with code generated by Clang 18.0.x.
@ Ver14
Attempt to be ABI-compatible with code generated by Clang 14.0.x.
@ Ver11
Attempt to be ABI-compatible with code generated by Clang 11.0.x (git 2e10b7a39b93).
@ Ver17
Attempt to be ABI-compatible with code generated by Clang 17.0.x.
@ Ver12
Attempt to be ABI-compatible with code generated by Clang 12.0.x (git 8e464dd76bef).
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name.
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments provided as part of this template-id.
A pointer to member type per C++ 8.3.3 - Pointers to members.
QualType getPointeeType() const
Describes a module or submodule.
std::string Name
The name of this module.
StringRef getPrimaryModuleInterfaceName() const
Get the primary module interface name from a partition.
bool isModulePartition() const
Is this a module partition.
This represents a decl that may have a name.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
bool hasLinkage() const
Determine whether this declaration has linkage.
bool isExternallyVisible() const
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Represent a C++ namespace.
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested)
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
unsigned getDepth() const
Get the nesting depth of the template parameter.
Interfaces are the core concept in Objective-C for object oriented design.
ObjCMethodDecl - Represents an instance or class method declaration.
Represents a pointer to an Objective C object.
Represents a class type in Objective C.
decls_iterator decls_begin() const
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
TemplateArgumentLoc const * getTemplateArgs() const
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
unsigned getNumTemplateArgs() const
DeclarationName getName() const
Gets the name looked up.
Represents a pack expansion of types.
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
Represents a parameter to a function.
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
unsigned getFunctionScopeDepth() const
PointerType - C99 6.7.5.1 - Pointer Declarators.
PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specifi...
A (possibly-)qualified type.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
The collection of all-type qualifiers we support.
unsigned getCVRQualifiers() const
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
void removeObjCLifetime()
bool hasUnaligned() const
bool hasAddressSpace() const
ObjCLifetime getObjCLifetime() const
LangAS getAddressSpace() const
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
bool isLambda() const
Determine whether this record is a class describing a lambda function object.
const FieldDecl * findFirstNamedDataMember() const
Finds the first data member which has a name.
field_range fields() const
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Encodes a location in the source.
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
const char * getStmtClassName() const
StringLiteral - This represents a string literal expression, e.g.
A structure for storing the information associated with a substituted template template parameter.
TemplateName getReplacement() const
Represents the result of substituting a set of types for a template type parameter pack.
Represents the declaration of a struct/union/class/enum.
TypedefNameDecl * getTypedefNameForAnonDecl() const
Exposes information about the current target.
virtual const char * getIbm128Mangling() const
Return the mangled code of __ibm128.
virtual const char * getLongDoubleMangling() const
Return the mangled code of long double.
virtual const char * getFloat128Mangling() const
Return the mangled code of __float128.
virtual const char * getBFloat16Mangling() const
Return the mangled code of bfloat.
A template argument list.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Location wrapper for a TemplateArgument.
Represents a template argument.
QualType getStructuralValueType() const
Get the type of a StructuralValue.
QualType getParamTypeForDecl() const
bool isDependent() const
Whether this template argument is dependent on a template parameter such that its result can change f...
bool isInstantiationDependent() const
Whether this template argument is dependent on a template parameter.
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
QualType getAsType() const
Retrieve the type for a type template argument.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
const APValue & getAsStructuralValue() const
Get the value of a StructuralValue.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
QualType getIntegralType() const
Retrieve the type of the integral value.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion,...
The base class of all kinds of template declarations (e.g., class, function, etc.).
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
void * getAsVoidPointer() const
Retrieve the template name as a void pointer.
@ UsingTemplate
A template name that refers to a template declaration found through a specific using shadow declarati...
@ OverloadedTemplate
A set of overloaded template declarations.
@ Template
A single template declaration.
@ DependentTemplate
A dependent template name that has not been resolved to a template (or set of templates).
@ SubstTemplateTemplateParm
A template template parameter that has been substituted for some other template name.
@ SubstTemplateTemplateParmPack
A template template parameter pack that has been substituted for a template template argument pack,...
@ QualifiedTemplate
A qualified template name, where the qualification is kept to describe the source code as written.
@ AssumedTemplate
An unqualified-id that has been assumed to name a function template that will be found by ADL.
SubstTemplateTemplateParmStorage * getAsSubstTemplateTemplateParm() const
Retrieve the substituted template template parameter, if known.
A template parameter object.
Stores a list of template parameters for a TemplateDecl and its derived classes.
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
NamedDecl * getParam(unsigned Idx)
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
Represents a type template specialization; the template must be a class template, a type alias templa...
ArrayRef< TemplateArgument > template_arguments() const
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
bool isTypeAlias() const
Determine if this template specialization type is for a type alias template that has been substituted...
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Declaration of a template type parameter.
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
ConceptDecl * getNamedConcept() const
Symbolic representation of typeid(T) for some type T.
Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
A container of type source information.
QualType getType() const
Return the type wrapped by this type source info.
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
ArrayRef< TypeSourceInfo * > getArgs() const
Retrieve the argument types.
TypeTrait getTrait() const
Determine which type trait this expression uses.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBooleanType() const
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isDependentAddressSpaceType() const
bool isVoidPointerType() const
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
bool isSVESizelessBuiltinType() const
Returns true for SVE scalable vector types.
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to.
const Type * getArrayElementTypeNoTypeQual() const
If this is an array type, return the element type of the array, potentially with type qualifiers miss...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isOpenCLSpecificType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isPointerOrReferenceType() const
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
Base class for declarations which introduce a typedef-name.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
QualType getArgumentType() const
bool isArgumentType() const
UnaryExprOrTypeTrait getKind() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode.
Expr * getSubExpr() const
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
DeclarationName getMemberName() const
Retrieve the name of the member that this expression refers to.
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '.
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
Represents the dependent type named by a dependently-scoped typename using declaration,...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void print(llvm::raw_ostream &Out) const
Represents a variable declaration or definition.
Represents a variable template specialization, which refers to a variable template with a given set o...
Represents a C array with a specified size that is not an integer-constant-expression.
Represents a GCC generic vector type.
QualType getElementType() const
A static requirement that can be used in a requires-expression to check properties of types and expre...
RequirementKind getKind() const
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
bool Sub(InterpState &S, CodePtr OpPC)
bool Init(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
@ NUM_OVERLOADED_OPERATORS
CXXCtorType
C++ constructor types.
@ Ctor_Base
Base object ctor.
@ Ctor_DefaultClosure
Default closure variant of a ctor.
@ Ctor_CopyingClosure
Copying closure variant of a ctor.
@ Ctor_Complete
Complete object ctor.
@ Ctor_Comdat
The COMDAT used for ctors.
bool isa(CodeGen::Address addr)
@ GNUAutoType
__auto_type (GNU extension)
llvm::StringRef getParameterABISpelling(ParameterABI kind)
RefQualifierKind
The kind of C++11 ref-qualifier associated with a function type.
@ RQ_None
No ref-qualifier was provided.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ SwiftAsyncContext
This parameter (which must have pointer type) uses the special Swift asynchronous context-pointer ABI...
@ SwiftErrorResult
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
@ Ordinary
This parameter uses ordinary ABI rules for its type.
@ SwiftIndirectResult
This parameter (which must have pointer type) is a Swift indirect result parameter.
@ SwiftContext
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
CXXDtorType
C++ destructor types.
@ Dtor_Comdat
The COMDAT used for dtors.
@ Dtor_Base
Base object dtor.
@ Dtor_Complete
Complete object dtor.
@ Dtor_Deleting
Deleting dtor.
LangAS
Defines the address space values used by the address space qualifier of QualType.
const char * getTraitSpelling(ExpressionTrait T) LLVM_READONLY
Return the spelling of the type trait TT. Never null.
const FunctionProtoType * T
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ AltiVecBool
is AltiVec 'vector bool ...'
@ SveFixedLengthData
is AArch64 SVE fixed-length data vector
@ AltiVecPixel
is AltiVec 'vector Pixel'
@ RVVFixedLengthData
is RISC-V RVV fixed-length data vector
@ RVVFixedLengthMask
is RISC-V RVV fixed-length mask vector
@ NeonPoly
is ARM Neon polynomial vector
@ SveFixedLengthPredicate
is AArch64 SVE fixed-length predicate vector
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
@ None
No keyword precedes the qualified type name.
@ Struct
The "struct" keyword introduces the elaborated-type-specifier.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Union
The "union" keyword introduces the elaborated-type-specifier.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
@ Other
Other implicit parameter.
@ Braces
New-expression has a C++11 list-initializer.
@ EST_Dynamic
throw(T1, T2)
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Information about how to mangle a template argument.
bool NeedExactType
Do we need to mangle the template argument with an exactly correct type?
const NamedDecl * TemplateParameterToMangle
If we need to prefix the mangling with a mangling of the template parameter, the corresponding parame...
bool isOverloadable()
Determine whether the resolved template might be overloaded on its template parameter list.
TemplateArgManglingInfo(const CXXNameMangler &Mangler, TemplateName TN)
bool needToMangleTemplateParam(const NamedDecl *Param, const TemplateArgument &Arg)
Determine whether we need to prefix this <template-arg> mangling with a <template-param-decl>.
const CXXNameMangler & Mangler
const Expr * getTrailingRequiresClauseToMangle()
Determine if we should mangle a requires-clause after the template argument list.
Info getArgInfo(unsigned ParamIdx, const TemplateArgument &Arg)
Determine information about how this template argument should be mangled.
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
union clang::ReturnAdjustment::VirtualAdjustment Virtual
int64_t NonVirtual
The non-virtual adjustment from the derived object to its nearest virtual base.
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
const Type * Ty
The locally-unqualified type.
Qualifiers Quals
The local qualifiers.
Iterator for iterating over Stmt * arrays that contain only T *.
A this pointer adjustment.
union clang::ThisAdjustment::VirtualAdjustment Virtual
int64_t NonVirtual
The non-virtual adjustment from the derived object to its nearest virtual base.
The this pointer adjustment as well as an optional return adjustment for a thunk.
ThisAdjustment This
The this pointer adjustment.
ReturnAdjustment Return
The return adjustment.
int64_t VBaseOffsetOffset
The offset (in bytes), relative to the address point of the virtual base class offset.
struct clang::ReturnAdjustment::VirtualAdjustment::@189 Itanium
struct clang::ThisAdjustment::VirtualAdjustment::@191 Itanium
int64_t VCallOffsetOffset
The offset (in bytes), relative to the address point, of the virtual call offset.