RetroSearch Browse

().getClangABICompat() <= Ver;

408

llvm::StringRef Name,

bool

HasAllocator);

411

CXXNameMangler(ItaniumMangleContextImpl &

, raw_ostream &Out_,

412 const NamedDecl

nullptr

bool

NullOut_ =

false

)

413

: Context(

), Out(Out_), NullOut(NullOut_), Structor(getStructor(

)),

414

AbiTagsRoot(AbiTags) {

416

assert(!

|| (!isa<CXXDestructorDecl>(

) &&

417

!isa<CXXConstructorDecl>(

)));

419

CXXNameMangler(ItaniumMangleContextImpl &

, raw_ostream &Out_,

421

: Context(

), Out(Out_), Structor(getStructor(

)), StructorType(

422

AbiTagsRoot(AbiTags) {}

423

CXXNameMangler(ItaniumMangleContextImpl &

, raw_ostream &Out_,

425

: Context(

), Out(Out_), Structor(getStructor(

)), StructorType(

426

AbiTagsRoot(AbiTags) {}

428

CXXNameMangler(ItaniumMangleContextImpl &

, raw_ostream &Out_,

429 bool

NormalizeIntegers_)

430

: Context(

), Out(Out_), NormalizeIntegers(NormalizeIntegers_),

431

NullOut(

false

), Structor(nullptr), AbiTagsRoot(AbiTags) {}

432

CXXNameMangler(CXXNameMangler &Outer, raw_ostream &Out_)

433

: Context(Outer.Context), Out(Out_), Structor(Outer.Structor),

434

StructorType(Outer.StructorType), SeqID(Outer.SeqID),

435

FunctionTypeDepth(Outer.FunctionTypeDepth), AbiTagsRoot(AbiTags),

436

Substitutions(Outer.Substitutions),

437

ModuleSubstitutions(Outer.ModuleSubstitutions) {}

439

CXXNameMangler(CXXNameMangler &Outer, llvm::raw_null_ostream &Out_)

440

: CXXNameMangler(Outer, (raw_ostream &)Out_) {

444 struct

WithTemplateDepthOffset {

unsigned

Offset; };

445

CXXNameMangler(ItaniumMangleContextImpl &

, raw_ostream &Out,

446

WithTemplateDepthOffset Offset)

447

: CXXNameMangler(

, Out) {

448

TemplateDepthOffset = Offset.Offset;

451

raw_ostream &getStream() {

return

Out; }

453 void

disableDerivedAbiTags() { DisableDerivedAbiTags =

true

; }

454 static bool

shouldHaveAbiTags(ItaniumMangleContextImpl &

const VarDecl

*VD);

457 void

mangleCallOffset(int64_t NonVirtual, int64_t

Virtual

);

458 void

mangleNumber(

const

llvm::APSInt &I);

459 void

mangleNumber(int64_t Number);

460 void

mangleFloat(

const

llvm::APFloat &F);

462 void

mangleSeqID(

unsigned

SeqID);

467 void

mangleModuleNamePrefix(StringRef Name,

bool

IsPartition =

false

);

468 void

mangleVendorQualifier(StringRef Name);

469 void

mangleVendorType(StringRef Name);

473 bool

mangleSubstitution(

const NamedDecl

*ND);

481 bool

mangleStandardSubstitution(

const NamedDecl

*ND);

483 void

addSubstitution(

const NamedDecl

*ND) {

486

addSubstitution(

reinterpret_cast<uintptr_t>

(ND));

491

addSubstitution(

reinterpret_cast<uintptr_t>

(NNS));

497 void

extendSubstitutions(CXXNameMangler*

);

500 bool

recursive =

false

);

504 unsigned

NumTemplateArgs,

505 unsigned

KnownArity = UnknownArity);

507 void

mangleFunctionEncodingBareType(

const FunctionDecl

*FD);

510 const

AbiTagList *AdditionalAbiTags);

511 void

mangleModuleName(

const NamedDecl

*ND);

515 const

AbiTagList *AdditionalAbiTags) {

516

mangleUnqualifiedName(GD, cast<NamedDecl>(GD.

())->getDeclName(), DC,

517

UnknownArity, AdditionalAbiTags);

521 const

AbiTagList *AdditionalAbiTags);

523 const

AbiTagList *AdditionalAbiTags);

525 const

AbiTagList *AdditionalAbiTags);

529 void

mangleSourceNameWithAbiTags(

530 const NamedDecl

*ND,

const

AbiTagList *AdditionalAbiTags =

nullptr

);

532 const

AbiTagList *AdditionalAbiTags);

537 void

mangleTypeConstraint(

const ConceptDecl

*Concept,

540 void

mangleRequiresClause(

const Expr

*RequiresClause);

543 const

AbiTagList *AdditionalAbiTags,

544 bool

NoFunction=

false

);

547 void

mangleNestedNameWithClosurePrefix(

GD,

549 const

AbiTagList *AdditionalAbiTags);

551 void

manglePrefix(

const DeclContext

*DC,

bool

NoFunction=

false

);

553 void

mangleTemplatePrefix(

GD,

bool

NoFunction=

false

);

556 void

mangleClosurePrefix(

const NamedDecl

*ND,

bool

NoFunction =

false

);

557 bool

mangleUnresolvedTypeOrSimpleId(

DestroyedType,

558

StringRef Prefix =

""

);

567#define ABSTRACT_TYPE(CLASS, PARENT) 568#define NON_CANONICAL_TYPE(CLASS, PARENT) 569#define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T); 570#include "clang/AST/TypeNodes.inc" 572 void

mangleType(

const TagType

*);

574 static

StringRef getCallingConvQualifierName(

CallingConv

CC);

577 void

mangleSMEAttrs(

unsigned

SMEAttrs);

582 void

mangleAArch64NeonVectorType(

const VectorType

);

584 void

mangleAArch64FixedSveVectorType(

const VectorType

);

586 void

mangleRISCVFixedRVVVectorType(

const VectorType

);

589 void

mangleIntegerLiteral(

const

llvm::APSInt &

);

590 void

mangleFloatLiteral(

const

llvm::APFloat &

);

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

, StringRef CastEncoding);

603 void

mangleInitListElements(

const InitListExpr

*InitList);

606 void

mangleExpression(

const Expr

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

);

622 bool

NeedExactType =

false

);

624 void

mangleTemplateParameter(

unsigned

Depth,

unsigned

Index);

626 void

mangleFunctionParam(

const ParmVarDecl

*parm);

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

) {

664

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

665 return

ContextParam->getDeclContext();

669 if

(

const BlockDecl

*BD = dyn_cast<BlockDecl>(

)) {

671

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

672 return

ContextParam->getDeclContext();

680 if

(

== getASTContext().getVaListTagDecl()) {

681 const

llvm::Triple &

= getASTContext().getTargetInfo().getTriple();

682 if

(

.isARM() ||

.isThumb() ||

.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>(

))

694 return

getASTContext().getTranslationUnitDecl();

696 if

(

const auto

*FD = getASTContext().getLangOpts().getClangABICompat() >

697

LangOptions::ClangABI::Ver19

699

: dyn_cast<FunctionDecl>(

)) {

701 return

getASTContext().getTranslationUnitDecl();

704 if

(FD->isMemberLikeConstrainedFriend() &&

705

getASTContext().getLangOpts().getClangABICompat() >

706

LangOptions::ClangABI::Ver17)

713bool

ItaniumMangleContextImpl::isInternalLinkageDecl(

const NamedDecl

*ND) {

716

getEffectiveDeclContext(ND)->isFileContext() &&

723bool

ItaniumMangleContextImpl::isUniqueInternalLinkageDecl(

725 if

(!NeedsUniqueInternalLinkageNames || !ND)

728 const auto

*FD = dyn_cast<FunctionDecl>(ND);

737 if

(isInternalLinkageDecl(ND))

743bool

ItaniumMangleContextImpl::shouldMangleCXXName(

const NamedDecl

) {

744 if

(

const auto

*FD = dyn_cast<FunctionDecl>(

)) {

747 if

(FD->hasAttr<OverloadableAttr>())

763 if

(FD->isMSVCRTEntryPoint())

777 if

(!getASTContext().getLangOpts().

CPlusPlus

)

780 if

(

const auto

*VD = dyn_cast<VarDecl>(

)) {

782 if

(isa<DecompositionDecl>(VD))

795

DC = getEffectiveParentContext(DC);

797

!CXXNameMangler::shouldHaveAbiTags(*

this

, VD) &&

798

!isa<VarTemplateSpecializationDecl>(VD) &&

806void

CXXNameMangler::writeAbiTags(

const NamedDecl

*ND,

807 const

AbiTagList *AdditionalAbiTags) {

808

assert(AbiTags &&

"require AbiTagState"

);

809

AbiTags->write(Out, ND, DisableDerivedAbiTags ?

nullptr

: AdditionalAbiTags);

812void

CXXNameMangler::mangleSourceNameWithAbiTags(

813 const NamedDecl

*ND,

const

AbiTagList *AdditionalAbiTags) {

815

writeAbiTags(ND, AdditionalAbiTags);

823 if

(isa<FunctionDecl>(GD.

()))

824

mangleFunctionEncoding(GD);

829

dyn_cast<IndirectFieldDecl>(GD.

()))

830

mangleName(IFD->getAnonField());

832

llvm_unreachable(

"unexpected kind of global decl"

);

835void

CXXNameMangler::mangleFunctionEncoding(

GD) {

840 if

(!Context.shouldMangleDeclName(FD)) {

845

AbiTagList ReturnTypeAbiTags = makeFunctionReturnTypeTags(FD);

846 if

(ReturnTypeAbiTags.empty()) {

855

FunctionTypeDepthState Saved = FunctionTypeDepth.push();

857

FunctionTypeDepth.pop(Saved);

858

mangleFunctionEncodingBareType(FD);

866

llvm::raw_svector_ostream FunctionEncodingStream(FunctionEncodingBuf);

867

CXXNameMangler FunctionEncodingMangler(*

this

, FunctionEncodingStream);

869

FunctionEncodingMangler.disableDerivedAbiTags();

871

FunctionTypeDepthState Saved = FunctionTypeDepth.push();

872

FunctionEncodingMangler.mangleNameWithAbiTags(FD,

nullptr

);

873

FunctionTypeDepth.pop(Saved);

876 size_t

EncodingPositionStart = FunctionEncodingStream.str().size();

877

FunctionEncodingMangler.mangleFunctionEncodingBareType(FD);

881 const

AbiTagList &UsedAbiTags =

882

FunctionEncodingMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags();

883

AbiTagList AdditionalAbiTags(ReturnTypeAbiTags.size());

884

AdditionalAbiTags.erase(

885

std::set_difference(ReturnTypeAbiTags.begin(), ReturnTypeAbiTags.end(),

886

UsedAbiTags.begin(), UsedAbiTags.end(),

887

AdditionalAbiTags.begin()),

888

AdditionalAbiTags.end());

891

Saved = FunctionTypeDepth.push();

892

mangleNameWithAbiTags(FD, &AdditionalAbiTags);

893

FunctionTypeDepth.pop(Saved);

894

Out << FunctionEncodingStream.str().substr(EncodingPositionStart);

898

extendSubstitutions(&FunctionEncodingMangler);

901void

CXXNameMangler::mangleFunctionEncodingBareType(

const FunctionDecl

*FD) {

902 if

(FD->

hasAttr

<EnableIfAttr>()) {

903

FunctionTypeDepthState Saved = FunctionTypeDepth.push();

904

Out <<

"Ua9enable_ifI"

;

905 for

(AttrVec::const_iterator I = FD->

getAttrs

().begin(),

908

EnableIfAttr *EIA = dyn_cast<EnableIfAttr>(*I);

911 if

(isCompatibleWith(LangOptions::ClangABI::Ver11)) {

916

mangleExpression(EIA->getCond());

919

mangleTemplateArgExpr(EIA->getCond());

923

FunctionTypeDepth.pop(Saved);

928 if

(

auto

*CD = dyn_cast<CXXConstructorDecl>(FD))

929 if

(

auto

Inherited = CD->getInheritedConstructor())

930

FD = Inherited.getConstructor();

948 bool

MangleReturnType =

false

;

950 if

(!(isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD) ||

951

isa<CXXConversionDecl>(FD)))

952

MangleReturnType =

true

;

955

FD = PrimaryTemplate->getTemplatedDecl();

959

MangleReturnType, FD);

964 if

(!Context.getEffectiveParentContext(NS)->isTranslationUnit())

968 return

II && II->

isStr

(

"std"

);

973bool

CXXNameMangler::isStdNamespace(

const DeclContext

*DC) {

977 return

isStd(cast<NamespaceDecl>(DC));

984 if

(

const FunctionDecl

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

993

dyn_cast<ClassTemplateSpecializationDecl>(ND)) {

994

TemplateArgs = &Spec->getTemplateArgs();

995 return

GD.

getWithDecl

(Spec->getSpecializedTemplate());

1000

dyn_cast<VarTemplateSpecializationDecl>(ND)) {

1001

TemplateArgs = &Spec->getTemplateArgs();

1002 return

GD.

getWithDecl

(Spec->getSpecializedTemplate());

1013void

CXXNameMangler::mangleName(

GD) {

1015 if

(

const VarDecl

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

1017

AbiTagList VariableTypeAbiTags = makeVariableTypeTags(VD);

1018 if

(VariableTypeAbiTags.empty()) {

1020

mangleNameWithAbiTags(VD,

nullptr

);

1025

llvm::raw_null_ostream NullOutStream;

1026

CXXNameMangler VariableNameMangler(*

this

, NullOutStream);

1027

VariableNameMangler.disableDerivedAbiTags();

1028

VariableNameMangler.mangleNameWithAbiTags(VD,

nullptr

);

1031 const

AbiTagList &UsedAbiTags =

1032

VariableNameMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags();

1033

AbiTagList AdditionalAbiTags(VariableTypeAbiTags.size());

1034

AdditionalAbiTags.erase(

1035

std::set_difference(VariableTypeAbiTags.begin(),

1036

VariableTypeAbiTags.end(), UsedAbiTags.begin(),

1037

UsedAbiTags.end(), AdditionalAbiTags.begin()),

1038

AdditionalAbiTags.end());

1041

mangleNameWithAbiTags(VD, &AdditionalAbiTags);

1043

mangleNameWithAbiTags(GD,

nullptr

);

1047const RecordDecl

*CXXNameMangler::GetLocalClassDecl(

const Decl

) {

1048 const DeclContext

*DC = Context.getEffectiveDeclContext(

);

1050 if

(isLocalContainerContext(DC))

1051 return

dyn_cast<RecordDecl>(

);

1053

DC = Context.getEffectiveDeclContext(

);

1058void

CXXNameMangler::mangleNameWithAbiTags(

GD,

1059 const

AbiTagList *AdditionalAbiTags) {

1066 const DeclContext

*DC = Context.getEffectiveDeclContext(ND);

1067 bool

IsLambda = isLambda(ND);

1073 if

(isLocalContainerContext(DC) && ND->

hasLinkage

() && !IsLambda)

1075

DC = Context.getEffectiveParentContext(DC);

1076 else if

(GetLocalClassDecl(ND) &&

1077

(!IsLambda || isCompatibleWith(LangOptions::ClangABI::Ver18))) {

1078

mangleLocalName(GD, AdditionalAbiTags);

1082

assert(!isa<LinkageSpecDecl>(DC) &&

"context cannot be LinkageSpecDecl"

);

1086 if

(

const NamedDecl

*PrefixND = getClosurePrefix(ND)) {

1087

mangleNestedNameWithClosurePrefix(GD, PrefixND, AdditionalAbiTags);

1091 if

(isLocalContainerContext(DC)) {

1092

mangleLocalName(GD, AdditionalAbiTags);

1100

mangleUnscopedTemplateName(TD, DC, AdditionalAbiTags);

1105

mangleUnscopedName(GD, DC, AdditionalAbiTags);

1109

mangleNestedName(GD, DC, AdditionalAbiTags);

1112void

CXXNameMangler::mangleModuleName(

const NamedDecl

*ND) {

1115

mangleModuleNamePrefix(M->getPrimaryModuleInterfaceName());

1123void

CXXNameMangler::mangleModuleNamePrefix(StringRef Name,

bool

IsPartition) {

1125 auto

It = ModuleSubstitutions.find(Name);

1126 if

(It != ModuleSubstitutions.end()) {

1128

mangleSeqID(It->second);

1134 auto

Parts = Name.rsplit(

'.'

);

1135 if

(Parts.second.empty())

1136

Parts.second = Parts.first;

1138

mangleModuleNamePrefix(Parts.first, IsPartition);

1139

IsPartition =

false

;

1145

Out << Parts.second.size() << Parts.second;

1146

ModuleSubstitutions.insert({Name, SeqID++});

1149void

CXXNameMangler::mangleTemplateName(

const TemplateDecl

*TD,

1151 const DeclContext

*DC = Context.getEffectiveDeclContext(TD);

1154

mangleUnscopedTemplateName(TD, DC,

nullptr

);

1157

mangleNestedName(TD, Args);

1162 const

AbiTagList *AdditionalAbiTags) {

1166

assert(!isa<LinkageSpecDecl>(DC) &&

"unskipped LinkageSpecDecl"

);

1167 if

(isStdNamespace(DC)) {

1168 if

(getASTContext().getTargetInfo().getTriple().isOSSolaris()) {

1170 if

(

const RecordDecl

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

1177 if

(llvm::is_contained({

"div_t"

"ldiv_t"

"lconv"

"tm"

type

)) {

1187

mangleUnqualifiedName(GD, DC, AdditionalAbiTags);

1190void

CXXNameMangler::mangleUnscopedTemplateName(

1195 if

(mangleSubstitution(ND))

1199 if

(

const auto

*TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {

1200

assert(!AdditionalAbiTags &&

1201 "template template param cannot have abi tags"

);

1202

mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());

1203

}

else if

(isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND)) {

1204

mangleUnscopedName(GD, DC, AdditionalAbiTags);

1210

addSubstitution(ND);

1213void

CXXNameMangler::mangleFloat(

const

llvm::APFloat &f) {

1227

llvm::APInt valueBits = f.bitcastToAPInt();

1228 unsigned

numCharacters = (valueBits.getBitWidth() + 3) / 4;

1229

assert(numCharacters != 0);

1235 for

(

unsigned

stringIndex = 0; stringIndex != numCharacters; ++stringIndex) {

1237 unsigned

digitBitIndex = 4 * (numCharacters - stringIndex - 1);

1240 uint64_t

hexDigit = valueBits.getRawData()[digitBitIndex / 64];

1241

hexDigit >>= (digitBitIndex % 64);

1245 static const char

charForHex[16] = {

1246 '0'

'1'

'2'

'3'

'4'

'5'

'6'

'7'

1247 '8'

'9'

'a'

'b'

'c'

'd'

'e'

'f' 1249

buffer[stringIndex] = charForHex[hexDigit];

1252

Out.write(buffer.data(), numCharacters);

1255void

CXXNameMangler::mangleFloatLiteral(

const

llvm::APFloat &

) {

1262void

CXXNameMangler::mangleFixedPointLiteral() {

1269void

CXXNameMangler::mangleNullPointer(

) {

1276void

CXXNameMangler::mangleNumber(

const

llvm::APSInt &

) {

1277 if

(

.isSigned() &&

.isNegative()) {

1285void

CXXNameMangler::mangleNumber(int64_t Number) {

1295void

CXXNameMangler::mangleCallOffset(int64_t NonVirtual, int64_t

Virtual

) {

1303

mangleNumber(NonVirtual);

1309

mangleNumber(NonVirtual);

1317 if

(!mangleSubstitution(

(TST, 0))) {

1318

mangleTemplatePrefix(TST->getTemplateName());

1323

mangleTemplateArgs(TST->getTemplateName(), TST->template_arguments());

1324

addSubstitution(

(TST, 0));

1326

}

else if

(

const auto

*DTST =

1328 if

(!mangleSubstitution(

(DTST, 0))) {

1329 TemplateName

Template = getASTContext().getDependentTemplateName(

1330

DTST->getQualifier(), DTST->getIdentifier());

1331

mangleTemplatePrefix(Template);

1336

mangleTemplateArgs(Template, DTST->template_arguments());

1337

addSubstitution(

(DTST, 0));

1367 switch

(qualifier->

()) {

1379

llvm_unreachable(

"Can't mangle __super specifier"

);

1383

mangleUnresolvedPrefix(qualifier->

(),

1391

mangleUnresolvedPrefix(qualifier->

(),

1408

mangleUnresolvedPrefix(qualifier->

(),

1415 if

(mangleUnresolvedTypeOrSimpleId(

(

type

, 0), recursive ?

"N"

""

))

1424

mangleUnresolvedPrefix(qualifier->

(),

1442void

CXXNameMangler::mangleUnresolvedName(

1445 unsigned

knownArity) {

1446 if

(qualifier) mangleUnresolvedPrefix(qualifier);

1447 switch

(

.getNameKind()) {

1450

mangleSourceName(

.getAsIdentifierInfo());

1455

mangleUnresolvedTypeOrSimpleId(

.getCXXNameType());

1462

mangleOperatorName(name, knownArity);

1465

llvm_unreachable(

"Can't mangle a constructor name!"

);

1467

llvm_unreachable(

"Can't mangle a using directive name!"

);

1469

llvm_unreachable(

"Can't mangle a deduction guide name!"

);

1473

llvm_unreachable(

"Can't mangle Objective-C selector names here!"

);

1479

mangleTemplateArgs(

(), TemplateArgs, NumTemplateArgs);

1482void

CXXNameMangler::mangleUnqualifiedName(

1484 unsigned

KnownArity,

const

AbiTagList *AdditionalAbiTags) {

1492

mangleModuleName(ND);

1496 auto

*FD = dyn_cast<FunctionDecl>(ND);

1497 auto

*FTD = dyn_cast<FunctionTemplateDecl>(ND);

1499

(FTD && FTD->getTemplatedDecl()->isMemberLikeConstrainedFriend())) {

1500 if

(!isCompatibleWith(LangOptions::ClangABI::Ver17))

1504 unsigned

Arity = KnownArity;

1505 switch

(Name.getNameKind()) {

1510 if

(

auto

*DD = dyn_cast<DecompositionDecl>(ND)) {

1517 for

(

auto

*BD : DD->bindings())

1518

mangleSourceName(BD->getDeclName().getAsIdentifierInfo());

1520

writeAbiTags(ND, AdditionalAbiTags);

1524 if

(

auto

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

1527 SmallString

sizeof

(

"_GUID_12345678_1234_1234_1234_1234567890ab"

)> GUID;

1528

llvm::raw_svector_ostream GUIDOS(GUID);

1529

Context.mangleMSGuidDecl(GD, GUIDOS);

1530

Out << GUID.size() << GUID;

1534 if

(

auto

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

1537

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

1538

TPO->getValue(),

true

);

1556 if

(Context.isInternalLinkageDecl(ND))

1559 bool

IsRegCall = FD &&

1563

FD && FD->

hasAttr

<CUDAGlobalAttr>() &&

1566

mangleDeviceStubName(II);

1568

mangleRegCallName(II);

1570

mangleSourceName(II);

1572

writeAbiTags(ND, AdditionalAbiTags);

1577

assert(ND &&

"mangling empty name without declaration"

);

1579 if

(

const NamespaceDecl

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

1582

Out <<

"12_GLOBAL__N_1"

;

1587 if

(

const VarDecl

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

1601

"Expected anonymous struct or union!"

);

1608

assert(FD->

getIdentifier

() &&

"Data member name isn't an identifier!"

);

1621 if

(isa<ObjCContainerDecl>(ND))

1625 const TagDecl

*TD = cast<TagDecl>(ND);

1628 "Typedef should not be in another decl context!"

);

1629

assert(

->getDeclName().getAsIdentifierInfo() &&

1630 "Typedef was not named!"

);

1631

mangleSourceName(

->getDeclName().getAsIdentifierInfo());

1632

assert(!AdditionalAbiTags &&

"Type cannot have additional abi tags"

);

1635

writeAbiTags(TD,

nullptr

);

1645

std::optional<unsigned> DeviceNumber =

1646

Context.getDiscriminatorOverride()(Context.getASTContext(),

);

1652 if

(

->isLambda() &&

1653

((DeviceNumber && *DeviceNumber > 0) ||

1654

(!DeviceNumber &&

->getLambdaManglingNumber() > 0))) {

1655

assert(!AdditionalAbiTags &&

1656 "Lambda type cannot have additional abi tags"

);

1663 unsigned

UnnamedMangle =

1664

getASTContext().getManglingNumber(TD, Context.isAux());

1666 if

(UnnamedMangle > 1)

1667

Out << UnnamedMangle - 2;

1669

writeAbiTags(TD, AdditionalAbiTags);

1675 unsigned

AnonStructId =

1677

: Context.getAnonymousStructId(TD, dyn_cast<FunctionDecl>(DC));

1684

Str += llvm::utostr(AnonStructId);

1694

llvm_unreachable(

"Can't mangle Objective-C selector names here!"

);

1700 if

(

auto

Inherited =

1701

cast<CXXConstructorDecl>(ND)->getInheritedConstructor()) {

1702

InheritedFrom = Inherited.getConstructor()->

getParent

();

1703

InheritedTemplateName =

1704 TemplateName

(Inherited.getConstructor()->getPrimaryTemplate());

1705

InheritedTemplateArgs =

1706

Inherited.getConstructor()->getTemplateSpecializationArgs();

1712

mangleCXXCtorType(

static_cast<CXXCtorType>

(StructorType), InheritedFrom);

1720 if

(InheritedTemplateArgs)

1721

mangleTemplateArgs(InheritedTemplateName, *InheritedTemplateArgs);

1723

writeAbiTags(ND, AdditionalAbiTags);

1731

mangleCXXDtorType(

static_cast<CXXDtorType>

(StructorType));

1737

writeAbiTags(ND, AdditionalAbiTags);

1741 if

(ND && Arity == UnknownArity) {

1742

Arity = cast<FunctionDecl>(ND)->getNumParams();

1745 if

(

const auto

*MD = dyn_cast<CXXMethodDecl>(ND))

1746 if

(MD->isImplicitObjectMemberFunction())

1752

mangleOperatorName(Name, Arity);

1753

writeAbiTags(ND, AdditionalAbiTags);

1757

llvm_unreachable(

"Can't mangle a deduction guide name!"

);

1760

llvm_unreachable(

"Can't mangle a using directive name!"

);

1764void

CXXNameMangler::mangleRegCallName(

const IdentifierInfo

*II) {

1768 if

(getASTContext().getLangOpts().RegCall4)

1769

Out << II->

getLength

() +

sizeof

(

"__regcall4__"

) - 1 <<

"__regcall4__" 1772

Out << II->

getLength

() +

sizeof

(

"__regcall3__"

) - 1 <<

"__regcall3__" 1776void

CXXNameMangler::mangleDeviceStubName(

const IdentifierInfo

*II) {

1780

Out << II->

getLength

() +

sizeof

(

"__device_stub__"

) - 1 <<

"__device_stub__" 1784void

CXXNameMangler::mangleSourceName(

const IdentifierInfo

*II) {

1791void

CXXNameMangler::mangleNestedName(

GD,

1793 const

AbiTagList *AdditionalAbiTags,

1802 if

(

const CXXMethodDecl

*Method = dyn_cast<CXXMethodDecl>(ND)) {

1803 Qualifiers

MethodQuals = Method->getMethodQualifiers();

1806 if

(Method->isExplicitObjectMemberFunction())

1809

mangleQualifiers(MethodQuals);

1810

mangleRefQualifier(Method->getRefQualifier());

1816

mangleTemplatePrefix(TD, NoFunction);

1819

manglePrefix(DC, NoFunction);

1820

mangleUnqualifiedName(GD, DC, AdditionalAbiTags);

1825void

CXXNameMangler::mangleNestedName(

const TemplateDecl

*TD,

1831

mangleTemplatePrefix(TD);

1837void

CXXNameMangler::mangleNestedNameWithClosurePrefix(

1839 const

AbiTagList *AdditionalAbiTags) {

1848

mangleClosurePrefix(PrefixND);

1849

mangleUnqualifiedName(GD,

nullptr

, AdditionalAbiTags);

1860 if

(

auto

*CD = dyn_cast<CXXConstructorDecl>(DC))

1862 else if

(

auto

*DD = dyn_cast<CXXDestructorDecl>(DC))

1869void

CXXNameMangler::mangleLocalName(

GD,

1870 const

AbiTagList *AdditionalAbiTags) {

1877

assert(isa<NamedDecl>(

) || isa<BlockDecl>(

));

1879 const DeclContext

*DC = Context.getEffectiveDeclContext(RD ? RD :

);

1884

AbiTagState LocalAbiTags(AbiTags);

1887

mangleObjCMethodName(MD);

1888 else if

(

const BlockDecl

*BD = dyn_cast<BlockDecl>(DC))

1889

mangleBlockForPrefix(BD);

1895

LocalAbiTags.setUsedAbiTags(LocalAbiTags.getEmittedAbiTags());

1910 if

(CXXRD && CXXRD->

isLambda

()) {

1918

mangleNumber(

Num

- 2);

1927

mangleUnqualifiedName(RD, DC, AdditionalAbiTags);

1928

}

else if

(

const BlockDecl

*BD = dyn_cast<BlockDecl>(

)) {

1929 if

(

const NamedDecl

*PrefixND = getClosurePrefix(BD))

1930

mangleClosurePrefix(PrefixND,

true

);

1932

manglePrefix(Context.getEffectiveDeclContext(BD),

true

);

1933

assert(!AdditionalAbiTags &&

"Block cannot have additional abi tags"

);

1934

mangleUnqualifiedBlock(BD);

1937

mangleNestedName(GD, Context.getEffectiveDeclContext(ND),

1938

AdditionalAbiTags,

true

);

1940

}

else if

(

const BlockDecl

*BD = dyn_cast<BlockDecl>(

)) {

1944

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

1950

mangleNumber(

Num

- 2);

1955

assert(!AdditionalAbiTags &&

"Block cannot have additional abi tags"

);

1956

mangleUnqualifiedBlock(BD);

1958

mangleUnqualifiedName(GD, DC, AdditionalAbiTags);

1961 if

(

const NamedDecl

*ND = dyn_cast<NamedDecl>(RD ? RD :

)) {

1963 if

(Context.getNextDiscriminator(ND, disc)) {

1967

Out <<

"__"

<< disc <<

'_'

;

1972void

CXXNameMangler::mangleBlockForPrefix(

const BlockDecl

) {

1973 if

(GetLocalClassDecl(

)) {

1974

mangleLocalName(

nullptr

);

1978 if

(isLocalContainerContext(DC)) {

1979

mangleLocalName(

nullptr

);

1983

mangleClosurePrefix(PrefixND);

1986

mangleUnqualifiedBlock(

);

1989void

CXXNameMangler::mangleUnqualifiedBlock(

const BlockDecl

) {

1992 if

(

*Context =

->getBlockManglingContextDecl()) {

1993 if

(isCompatibleWith(LangOptions::ClangABI::Ver12) &&

1994

(isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&

1995

Context->getDeclContext()->isRecord()) {

1996 const auto

*ND = cast<NamedDecl>(Context);

1998

mangleSourceNameWithAbiTags(ND);

2005 unsigned

Number =

->getBlockManglingNumber();

2009

Number = Context.getBlockId(

false

);

2027void

CXXNameMangler::mangleTemplateParamDecl(

const NamedDecl

) {

2029 if

(

auto

*Ty = dyn_cast<TemplateTypeParmDecl>(

)) {

2030 if

(Ty->isParameterPack())

2033 if

(Constraint && !isCompatibleWith(LangOptions::ClangABI::Ver17)) {

2036

mangleTypeConstraint(Constraint);

2040

}

else if

(

auto

*Tn = dyn_cast<NonTypeTemplateParmDecl>(

)) {

2041 if

(Tn->isExpandedParameterPack()) {

2042 for

(

unsigned

I = 0, N = Tn->getNumExpansionTypes(); I != N; ++I) {

2044

mangleType(Tn->getExpansionType(I));

2048 if

(Tn->isParameterPack()) {

2051 T

= PackExpansion->getPattern();

2056

}

else if

(

auto

*Tt = dyn_cast<TemplateTemplateParmDecl>(

)) {

2057 if

(Tt->isExpandedParameterPack()) {

2058 for

(

unsigned

I = 0, N = Tt->getNumExpansionTemplateParameters(); I != N;

2060

mangleTemplateParameterList(Tt->getExpansionTemplateParameters(I));

2062 if

(Tt->isParameterPack())

2064

mangleTemplateParameterList(Tt->getTemplateParameters());

2069void

CXXNameMangler::mangleTemplateParameterList(

2072 for

(

auto

*Param : *Params)

2073

mangleTemplateParamDecl(Param);

2074

mangleRequiresClause(Params->getRequiresClause());

2078void

CXXNameMangler::mangleTypeConstraint(

2080 const DeclContext

*DC = Context.getEffectiveDeclContext(Concept);

2082

mangleTemplateName(Concept, Arguments);

2084

mangleUnscopedName(Concept, DC,

nullptr

);

2086

mangleNestedName(Concept, DC,

nullptr

);

2089void

CXXNameMangler::mangleTypeConstraint(

const TypeConstraint

*Constraint) {

2094

Args.push_back(ArgLoc.getArgument());

2099void

CXXNameMangler::mangleRequiresClause(

const Expr

*RequiresClause) {

2101 if

(RequiresClause && !isCompatibleWith(LangOptions::ClangABI::Ver17)) {

2103

mangleExpression(RequiresClause);

2107void

CXXNameMangler::mangleLambda(

const CXXRecordDecl

*Lambda) {

2111 if

(isCompatibleWith(LangOptions::ClangABI::Ver12) &&

2112

(isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&

2113

!isa<ParmVarDecl>(Context)) {

2116

mangleSourceName(Name);

2126

mangleLambdaSig(Lambda);

2140

std::optional<unsigned> DeviceNumber =

2141

Context.getDiscriminatorOverride()(Context.getASTContext(), Lambda);

2145

assert(Number > 0 &&

"Lambda should be mangled as an unnamed class"

);

2147

mangleNumber(Number - 2);

2151void

CXXNameMangler::mangleLambdaSig(

const CXXRecordDecl

*Lambda) {

2154

mangleTemplateParamDecl(

);

2158

mangleRequiresClause(TPL->getRequiresClause());

2162

mangleBareFunctionType(Proto,

false

2167 switch

(qualifier->

()) {

2173

llvm_unreachable(

"Can't mangle __super specifier"

);

2190 bool

Clang14Compat = isCompatibleWith(LangOptions::ClangABI::Ver14);

2191 if

(!Clang14Compat && mangleSubstitution(qualifier))

2202

addSubstitution(qualifier);

2206

llvm_unreachable(

"unexpected nested name specifier"

);

2209void

CXXNameMangler::manglePrefix(

const DeclContext

*DC,

bool

NoFunction) {

2217

assert(!isa<LinkageSpecDecl>(DC) &&

"prefix cannot be LinkageSpecDecl"

);

2222 if

(NoFunction && isLocalContainerContext(DC))

2225 const NamedDecl

*ND = cast<NamedDecl>(DC);

2226 if

(mangleSubstitution(ND))

2232

mangleTemplatePrefix(TD);

2234

}

else if

(

const NamedDecl

*PrefixND = getClosurePrefix(ND)) {

2235

mangleClosurePrefix(PrefixND, NoFunction);

2236

mangleUnqualifiedName(ND,

nullptr

);

2238 const DeclContext

*DC = Context.getEffectiveDeclContext(ND);

2239

manglePrefix(DC, NoFunction);

2240

mangleUnqualifiedName(ND, DC,

nullptr

);

2243

addSubstitution(ND);

2246void

CXXNameMangler::mangleTemplatePrefix(

Template) {

2251 return

mangleTemplatePrefix(TD);

2254

assert(

"unexpected template name kind"

);

2258 bool

Clang11Compat = isCompatibleWith(LangOptions::ClangABI::Ver11);

2259 if

(!Clang11Compat && mangleSubstitution(Template))

2263

manglePrefix(Qualifier);

2265 if

(Clang11Compat && mangleSubstitution(Template))

2269

mangleSourceName(

);

2271

mangleOperatorName(

->getOperator(), UnknownArity);

2273

addSubstitution(Template);

2276void

CXXNameMangler::mangleTemplatePrefix(

GD,

2285 if

(mangleSubstitution(ND))

2289 if

(

const auto

*TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {

2290

mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());

2292 const DeclContext

*DC = Context.getEffectiveDeclContext(ND);

2293

manglePrefix(DC, NoFunction);

2294 if

(isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND))

2295

mangleUnqualifiedName(GD, DC,

nullptr

);

2301

addSubstitution(ND);

2304const NamedDecl

*CXXNameMangler::getClosurePrefix(

const Decl

*ND) {

2305 if

(isCompatibleWith(LangOptions::ClangABI::Ver12))

2309 if

(

auto

= dyn_cast<BlockDecl>(ND)) {

2310

Context = dyn_cast_or_null<NamedDecl>(

->getBlockManglingContextDecl());

2311

}

else if

(

auto

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

2313

Context = dyn_cast_or_null<NamedDecl>(RD->getLambdaContextDecl());

2320 if

((isa<VarDecl>(Context) && cast<VarDecl>(Context)->hasGlobalStorage()) ||

2321

isa<FieldDecl>(Context))

2327void

CXXNameMangler::mangleClosurePrefix(

const NamedDecl

*ND,

bool

NoFunction) {

2330 if

(mangleSubstitution(ND))

2335

mangleTemplatePrefix(TD, NoFunction);

2338 const auto

*DC = Context.getEffectiveDeclContext(ND);

2339

manglePrefix(DC, NoFunction);

2340

mangleUnqualifiedName(ND, DC,

nullptr

);

2345

addSubstitution(ND);

2354 if

(mangleSubstitution(TN))

2367 if

(

auto

*TTP = dyn_cast<TemplateTemplateParmDecl>(TD))

2368

mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());

2375

llvm_unreachable(

"can't mangle an overloaded template name as a <type>"

);

2383

mangleUnresolvedPrefix(

->getQualifier());

2384

mangleSourceName(

->getIdentifier());

2404

Out <<

"_SUBSTPACK_"

;

2408

llvm_unreachable(

"Unexpected DeducedTemplate"

);

2411

addSubstitution(TN);

2414bool

CXXNameMangler::mangleUnresolvedTypeOrSimpleId(

Ty,

2420 case

Type::Adjusted:

2422 case

Type::ArrayParameter:

2424 case

Type::BlockPointer:

2425 case

Type::LValueReference:

2426 case

Type::RValueReference:

2427 case

Type::MemberPointer:

2428 case

Type::ConstantArray:

2429 case

Type::IncompleteArray:

2430 case

Type::VariableArray:

2431 case

Type::DependentSizedArray:

2432 case

Type::DependentAddressSpace:

2433 case

Type::DependentVector:

2434 case

Type::DependentSizedExtVector:

2436 case

Type::ExtVector:

2437 case

Type::ConstantMatrix:

2438 case

Type::DependentSizedMatrix:

2439 case

Type::FunctionProto:

2440 case

Type::FunctionNoProto:

2442 case

Type::Attributed:

2443 case

Type::BTFTagAttributed:

2444 case

Type::HLSLAttributedResource:

2446 case

Type::DeducedTemplateSpecialization:

2447 case

Type::PackExpansion:

2448 case

Type::ObjCObject:

2449 case

Type::ObjCInterface:

2450 case

Type::ObjCObjectPointer:

2451 case

Type::ObjCTypeParam:

2454 case

Type::MacroQualified:

2456 case

Type::DependentBitInt:

2457 case

Type::CountAttributed:

2458

llvm_unreachable(

"type is illegal as a nested name specifier"

);

2460 case

Type::SubstTemplateTypeParmPack:

2465

Out <<

"_SUBSTPACK_"

;

2472 case

Type::TypeOfExpr:

2474 case

Type::Decltype:

2475 case

Type::PackIndexing:

2476 case

Type::TemplateTypeParm:

2477 case

Type::UnaryTransform:

2478 case

Type::SubstTemplateTypeParm:

2492

mangleSourceNameWithAbiTags(cast<TypedefType>(Ty)->getDecl());

2495 case

Type::UnresolvedUsing:

2496

mangleSourceNameWithAbiTags(

2497

cast<UnresolvedUsingType>(Ty)->getDecl());

2502

mangleSourceNameWithAbiTags(cast<TagType>(Ty)->getDecl());

2505 case

Type::TemplateSpecialization: {

2507

cast<TemplateSpecializationType>(Ty);

2516

assert(TD &&

"no template for template specialization type"

);

2517 if

(isa<TemplateTemplateParmDecl>(TD))

2518 goto

unresolvedType;

2520

mangleSourceNameWithAbiTags(TD);

2528

llvm_unreachable(

"invalid base for a template specialization type"

);

2542

Out <<

"_SUBSTPACK_"

;

2547

assert(TD && !isa<TemplateTemplateParmDecl>(TD));

2548

mangleSourceNameWithAbiTags(TD);

2562 case

Type::InjectedClassName:

2563

mangleSourceNameWithAbiTags(

2564

cast<InjectedClassNameType>(Ty)->getDecl());

2567 case

Type::DependentName:

2568

mangleSourceName(cast<DependentNameType>(Ty)->

getIdentifier

());

2571 case

Type::DependentTemplateSpecialization: {

2573

cast<DependentTemplateSpecializationType>(Ty);

2574 TemplateName

Template = getASTContext().getDependentTemplateName(

2582 return

mangleUnresolvedTypeOrSimpleId(cast<UsingType>(Ty)->desugar(),

2584 case

Type::Elaborated:

2585 return

mangleUnresolvedTypeOrSimpleId(

2586

cast<ElaboratedType>(Ty)->getNamedType(), Prefix);

2592void

CXXNameMangler::mangleOperatorName(

DeclarationName

Name,

unsigned

Arity) {

2593 switch

(Name.getNameKind()) {

2602

llvm_unreachable(

"Not an operator name"

);

2607

mangleType(Name.getCXXNameType());

2612

mangleSourceName(Name.getCXXLiteralIdentifier());

2616

mangleOperatorName(Name.getCXXOverloadedOperator(), Arity);

2625 case

OO_New: Out <<

"nw"

;

break

;

2627 case

OO_Array_New: Out <<

"na"

;

break

;

2629 case

OO_Delete: Out <<

"dl"

;

break

;

2631 case

OO_Array_Delete: Out <<

"da"

;

break

;

2635

Out << (Arity == 1?

"ps"

"pl"

);

break

;

2639

Out << (Arity == 1?

"ng"

"mi"

);

break

;

2643

Out << (Arity == 1?

"ad"

"an"

);

break

;

2648

Out << (Arity == 1?

"de"

"ml"

);

break

;

2650 case

OO_Tilde: Out <<

"co"

;

break

;

2652 case

OO_Slash: Out <<

"dv"

;

break

;

2654 case

OO_Percent: Out <<

"rm"

;

break

;

2656 case

OO_Pipe: Out <<

"or"

;

break

;

2658 case

OO_Caret: Out <<

"eo"

;

break

;

2660 case

OO_Equal: Out <<

"aS"

;

break

;

2662 case

OO_PlusEqual: Out <<

"pL"

;

break

;

2664 case

OO_MinusEqual: Out <<

"mI"

;

break

;

2666 case

OO_StarEqual: Out <<

"mL"

;

break

;

2668 case

OO_SlashEqual: Out <<

"dV"

;

break

;

2670 case

OO_PercentEqual: Out <<

"rM"

;

break

;

2672 case

OO_AmpEqual: Out <<

"aN"

;

break

;

2674 case

OO_PipeEqual: Out <<

"oR"

;

break

;

2676 case

OO_CaretEqual: Out <<

"eO"

;

break

;

2678 case

OO_LessLess: Out <<

"ls"

;

break

;

2680 case

OO_GreaterGreater: Out <<

"rs"

;

break

;

2682 case

OO_LessLessEqual: Out <<

"lS"

;

break

;

2684 case

OO_GreaterGreaterEqual: Out <<

"rS"

;

break

;

2686 case

OO_EqualEqual: Out <<

"eq"

;

break

;

2688 case

OO_ExclaimEqual: Out <<

"ne"

;

break

;

2690 case

OO_Less: Out <<

"lt"

;

break

;

2692 case

OO_Greater: Out <<

"gt"

;

break

;

2694 case

OO_LessEqual: Out <<

"le"

;

break

;

2696 case

OO_GreaterEqual: Out <<

"ge"

;

break

;

2698 case

OO_Exclaim: Out <<

"nt"

;

break

;

2700 case

OO_AmpAmp: Out <<

"aa"

;

break

;

2702 case

OO_PipePipe: Out <<

"oo"

;

break

;

2704 case

OO_PlusPlus: Out <<

"pp"

;

break

;

2706 case

OO_MinusMinus: Out <<

"mm"

;

break

;

2708 case

OO_Comma: Out <<

"cm"

;

break

;

2710 case

OO_ArrowStar: Out <<

"pm"

;

break

;

2712 case

OO_Arrow: Out <<

"pt"

;

break

;

2714 case

OO_Call: Out <<

"cl"

;

break

;

2716 case

OO_Subscript: Out <<

"ix"

;

break

;

2721 case

OO_Conditional: Out <<

"qu"

;

break

;

2724 case

OO_Coawait: Out <<

"aw"

;

break

;

2727 case

OO_Spaceship: Out <<

"ss"

;

break

;

2731

llvm_unreachable(

"Not an overloaded operator"

);

2760 if

(TargetAS != 0 ||

2762

ASString =

"AS"

+ llvm::utostr(TargetAS);

2765 default

: llvm_unreachable(

"Not a language specific address space"

);

2769 case

LangAS::opencl_global:

2770

ASString =

"CLglobal"

;

2772 case

LangAS::opencl_global_device:

2773

ASString =

"CLdevice"

;

2775 case

LangAS::opencl_global_host:

2776

ASString =

"CLhost"

;

2778 case

LangAS::opencl_local:

2779

ASString =

"CLlocal"

;

2781 case

LangAS::opencl_constant:

2782

ASString =

"CLconstant"

;

2784 case

LangAS::opencl_private:

2785

ASString =

"CLprivate"

;

2787 case

LangAS::opencl_generic:

2788

ASString =

"CLgeneric"

;

2792 case

LangAS::sycl_global:

2793

ASString =

"SYglobal"

;

2795 case

LangAS::sycl_global_device:

2796

ASString =

"SYdevice"

;

2798 case

LangAS::sycl_global_host:

2799

ASString =

"SYhost"

;

2801 case

LangAS::sycl_local:

2802

ASString =

"SYlocal"

;

2804 case

LangAS::sycl_private:

2805

ASString =

"SYprivate"

;

2808 case

LangAS::cuda_device:

2809

ASString =

"CUdevice"

;

2811 case

LangAS::cuda_constant:

2812

ASString =

"CUconstant"

;

2814 case

LangAS::cuda_shared:

2815

ASString =

"CUshared"

;

2818 case

LangAS::ptr32_sptr:

2819

ASString =

"ptr32_sptr"

;

2821 case

LangAS::ptr32_uptr:

2825 if

(!getASTContext().getTargetInfo().getTriple().isOSzOS())

2826

ASString =

"ptr32_uptr"

;

2829

ASString =

"ptr64"

;

2833 if

(!ASString.empty())

2834

mangleVendorQualifier(ASString);

2847

mangleVendorQualifier(

"__weak"

);

2851

mangleVendorQualifier(

"__unaligned"

);

2863

mangleVendorQualifier(

"__strong"

);

2867

mangleVendorQualifier(

"__autoreleasing"

);

2890void

CXXNameMangler::mangleVendorQualifier(StringRef name) {

2891

Out <<

'U'

.size() <<

;

2894void

CXXNameMangler::mangleVendorType(StringRef name) {

2895

Out <<

'u'

.size() <<

;

2901 switch

(RefQualifier) {

2915void

CXXNameMangler::mangleObjCMethodName(

const ObjCMethodDecl

*MD) {

2916

Context.mangleObjCMethodNameAsSourceName(MD, Out);

2929

Ctx.

().getClangABICompat() > LangOptions::ClangABI::Ver17)

2935 if

(Ctx.

().getClangABICompat() > LangOptions::ClangABI::Ver6 &&

2942 if

(DeducedTST->getDeducedType().isNull())

2947void

CXXNameMangler::mangleType(

) {

2981 T

.getCanonicalType();

2988

= dyn_cast<TemplateSpecializationType>(

))

2997

.getSingleStepDesugaredType(Context.getASTContext());

2998 if

(Desugared ==

)

3006 const Type

*ty = split.

;

3008 bool

isSubstitutable =

3010 if

(isSubstitutable && mangleSubstitution(

))

3015 if

(quals && isa<ArrayType>(

)) {

3025

dyn_cast<DependentAddressSpaceType>(ty)) {

3027

mangleQualifiers(splitDAST.

Quals

, DAST);

3030

mangleQualifiers(quals);

3038#define ABSTRACT_TYPE(CLASS, PARENT) 3039#define NON_CANONICAL_TYPE(CLASS, PARENT) \ 3041 llvm_unreachable("can't mangle non-canonical type "

#CLASS "Type"); \

3043#define TYPE(CLASS, PARENT) \ 3045 mangleType(static_cast<const CLASS##Type*>(ty)); \ 3047#include "clang/AST/TypeNodes.inc" 3052 if

(isSubstitutable)

3053

addSubstitution(

);

3057 if

(mangleSubstitution(

))

3060 if

(isCompatibleWith(LangOptions::ClangABI::Ver19))

3062

addSubstitution(

);

3065void

CXXNameMangler::mangleType(

const BuiltinType

) {

3107

std::string type_name;

3111 if

(NormalizeIntegers &&

->isInteger()) {

3112 if

(

->isSignedInteger()) {

3113 switch

(getASTContext().getTypeSize(

)) {

3117 if

(mangleSubstitution(BuiltinType::SChar))

3120

addSubstitution(BuiltinType::SChar);

3123 if

(mangleSubstitution(BuiltinType::Short))

3126

addSubstitution(BuiltinType::Short);

3129 if

(mangleSubstitution(BuiltinType::Int))

3132

addSubstitution(BuiltinType::Int);

3135 if

(mangleSubstitution(BuiltinType::Long))

3138

addSubstitution(BuiltinType::Long);

3141 if

(mangleSubstitution(BuiltinType::Int128))

3144

addSubstitution(BuiltinType::Int128);

3147

llvm_unreachable(

"Unknown integer size for normalization"

);

3150 switch

(getASTContext().getTypeSize(

)) {

3152 if

(mangleSubstitution(BuiltinType::UChar))

3155

addSubstitution(BuiltinType::UChar);

3158 if

(mangleSubstitution(BuiltinType::UShort))

3161

addSubstitution(BuiltinType::UShort);

3164 if

(mangleSubstitution(BuiltinType::UInt))

3167

addSubstitution(BuiltinType::UInt);

3170 if

(mangleSubstitution(BuiltinType::ULong))

3173

addSubstitution(BuiltinType::ULong);

3176 if

(mangleSubstitution(BuiltinType::UInt128))

3179

addSubstitution(BuiltinType::UInt128);

3182

llvm_unreachable(

"Unknown integer size for normalization"

);

3187 switch

(

->getKind()) {

3188 case

BuiltinType::Void:

3191 case

BuiltinType::Bool:

3194 case

BuiltinType::Char_U:

3195 case

BuiltinType::Char_S:

3198 case

BuiltinType::UChar:

3201 case

BuiltinType::UShort:

3204 case

BuiltinType::UInt:

3207 case

BuiltinType::ULong:

3210 case

BuiltinType::ULongLong:

3213 case

BuiltinType::UInt128:

3216 case

BuiltinType::SChar:

3219 case

BuiltinType::WChar_S:

3220 case

BuiltinType::WChar_U:

3223 case

BuiltinType::Char8:

3226 case

BuiltinType::Char16:

3229 case

BuiltinType::Char32:

3232 case

BuiltinType::Short:

3235 case

BuiltinType::Int:

3238 case

BuiltinType::Long:

3241 case

BuiltinType::LongLong:

3244 case

BuiltinType::Int128:

3247 case

BuiltinType::Float16:

3250 case

BuiltinType::ShortAccum:

3253 case

BuiltinType::Accum:

3256 case

BuiltinType::LongAccum:

3259 case

BuiltinType::UShortAccum:

3262 case

BuiltinType::UAccum:

3265 case

BuiltinType::ULongAccum:

3268 case

BuiltinType::ShortFract:

3271 case

BuiltinType::Fract:

3274 case

BuiltinType::LongFract:

3277 case

BuiltinType::UShortFract:

3280 case

BuiltinType::UFract:

3283 case

BuiltinType::ULongFract:

3286 case

BuiltinType::SatShortAccum:

3289 case

BuiltinType::SatAccum:

3292 case

BuiltinType::SatLongAccum:

3295 case

BuiltinType::SatUShortAccum:

3298 case

BuiltinType::SatUAccum:

3301 case

BuiltinType::SatULongAccum:

3304 case

BuiltinType::SatShortFract:

3307 case

BuiltinType::SatFract:

3310 case

BuiltinType::SatLongFract:

3313 case

BuiltinType::SatUShortFract:

3316 case

BuiltinType::SatUFract:

3319 case

BuiltinType::SatULongFract:

3322 case

BuiltinType::Half:

3325 case

BuiltinType::Float:

3328 case

BuiltinType::Double:

3331 case

BuiltinType::LongDouble: {

3333

getASTContext().getLangOpts().OpenMP &&

3334

getASTContext().getLangOpts().OpenMPIsTargetDevice

3335

? getASTContext().getAuxTargetInfo()

3336

: &getASTContext().getTargetInfo();

3340 case

BuiltinType::Float128: {

3342

getASTContext().getLangOpts().OpenMP &&

3343

getASTContext().getLangOpts().OpenMPIsTargetDevice

3344

? getASTContext().getAuxTargetInfo()

3345

: &getASTContext().getTargetInfo();

3349 case

BuiltinType::BFloat16: {

3351

((getASTContext().getLangOpts().OpenMP &&

3352

getASTContext().getLangOpts().OpenMPIsTargetDevice) ||

3353

getASTContext().getLangOpts().SYCLIsDevice)

3354

? getASTContext().getAuxTargetInfo()

3355

: &getASTContext().getTargetInfo();

3359 case

BuiltinType::Ibm128: {

3360 const TargetInfo

*TI = &getASTContext().getTargetInfo();

3364 case

BuiltinType::NullPtr:

3368#define BUILTIN_TYPE(Id, SingletonId) 3369#define PLACEHOLDER_TYPE(Id, SingletonId) \ 3370 case BuiltinType::Id: 3371#include "clang/AST/BuiltinTypes.def" 3372 case

BuiltinType::Dependent:

3374

llvm_unreachable(

"mangling a placeholder type"

);

3376 case

BuiltinType::ObjCId:

3377

Out <<

"11objc_object"

;

3379 case

BuiltinType::ObjCClass:

3380

Out <<

"10objc_class"

;

3382 case

BuiltinType::ObjCSel:

3383

Out <<

"13objc_selector"

;

3385#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 3386 case BuiltinType::Id: \ 3387 type_name = "ocl_"

#ImgType "_" #Suffix; \

3388

Out << type_name.size() << type_name; \

3390#include "clang/Basic/OpenCLImageTypes.def" 3391 case

BuiltinType::OCLSampler:

3392

Out <<

"11ocl_sampler"

;

3394 case

BuiltinType::OCLEvent:

3395

Out <<

"9ocl_event"

;

3397 case

BuiltinType::OCLClkEvent:

3398

Out <<

"12ocl_clkevent"

;

3400 case

BuiltinType::OCLQueue:

3401

Out <<

"9ocl_queue"

;

3403 case

BuiltinType::OCLReserveID:

3404

Out <<

"13ocl_reserveid"

;

3406#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 3407 case BuiltinType::Id: \ 3408 type_name = "ocl_"

#ExtType; \

3409

Out << type_name.size() << type_name; \

3411#include "clang/Basic/OpenCLExtensionTypes.def" 3415#define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId) \ 3416 case BuiltinType::Id: \ 3417 if (T->getKind() == BuiltinType::SveBFloat16 && \ 3418 isCompatibleWith(LangOptions::ClangABI::Ver17)) { \ 3420 mangleVendorType("__SVBFloat16_t"

); \

3422

type_name = #MangledName; \

3423

Out << (type_name == #Name ? "u" : "") << type_name.size() << type_name; \

3426#define SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId) \ 3427 case BuiltinType::Id: \ 3428 type_name = #MangledName; \ 3429 Out << (type_name == #Name ? "u"

: "") << type_name.size() << type_name; \

3431#define SVE_OPAQUE_TYPE(Name, MangledName, Id, SingletonId) \ 3432 case BuiltinType::Id: \ 3433 type_name = #MangledName; \ 3434 Out << (type_name == #Name ? "u"

: "") << type_name.size() << type_name; \

3436#define SVE_SCALAR_TYPE(Name, MangledName, Id, SingletonId, Bits) \ 3437 case BuiltinType::Id: \ 3438 type_name = #MangledName; \ 3439 Out << (type_name == #Name ? "u"

: "") << type_name.size() << type_name; \

3441#include "clang/Basic/AArch64SVEACLETypes.def" 3442#define PPC_VECTOR_TYPE(Name, Id, Size) \ 3443 case BuiltinType::Id: \ 3444 mangleVendorType(#Name); \ 3446#include "clang/Basic/PPCTypes.def" 3448#define RVV_TYPE(Name, Id, SingletonId) \ 3449 case BuiltinType::Id: \ 3450 mangleVendorType(Name); \ 3452#include "clang/Basic/RISCVVTypes.def" 3453#define WASM_REF_TYPE(InternalName, MangledName, Id, SingletonId, AS) \ 3454 case BuiltinType::Id: \ 3455 mangleVendorType(MangledName); \ 3457#include "clang/Basic/WebAssemblyReferenceTypes.def" 3458#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) \ 3459 case BuiltinType::Id: \ 3460 mangleVendorType(Name); \ 3462#include "clang/Basic/AMDGPUTypes.def" 3463#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \ 3464 case BuiltinType::Id: \ 3465 mangleVendorType(#Name); \ 3467#include "clang/Basic/HLSLIntangibleTypes.def" 3471

StringRef CXXNameMangler::getCallingConvQualifierName(

CallingConv

CC) {

3512 return "swiftcall"

;

3514 return "swiftasynccall"

;

3516

llvm_unreachable(

"bad calling convention"

);

3519void

CXXNameMangler::mangleExtFunctionInfo(

const FunctionType

) {

3528

StringRef CCQualifier = getCallingConvQualifierName(

getExtInfo

().

getCC

());

3529 if

(!CCQualifier.empty())

3530

mangleVendorQualifier(CCQualifier);

3563

llvm_unreachable(

"Unrecognised SME attribute"

);

3578void

CXXNameMangler::mangleSMEAttrs(

unsigned

SMEAttrs) {

3598

Out <<

"Lj"

static_cast<unsigned>

(Bitmask) <<

"EE"

;

3609 case

ParameterABI::Ordinary:

3613 case

ParameterABI::HLSLOut:

3614 case

ParameterABI::HLSLInOut:

3619 case

ParameterABI::SwiftContext:

3620 case

ParameterABI::SwiftAsyncContext:

3621 case

ParameterABI::SwiftErrorResult:

3622 case

ParameterABI::SwiftIndirectResult:

3628

mangleVendorQualifier(

"ns_consumed"

);

3631

mangleVendorQualifier(

"noescape"

);

3641

Out <<

"11__SME_ATTRSI"

;

3643

mangleExtFunctionInfo(

);

3660

mangleType(ExceptTy);

3671

mangleBareFunctionType(

true

);

3678

mangleSMEAttrs(SMEAttrs);

3687

FunctionTypeDepthState saved = FunctionTypeDepth.push();

3689

FunctionTypeDepth.enterResultType();

3691

FunctionTypeDepth.leaveResultType();

3693

FunctionTypeDepth.pop(saved);

3698 bool

MangleReturnType,

3702

FunctionTypeDepthState saved = FunctionTypeDepth.push();

3705 if

(MangleReturnType) {

3706

FunctionTypeDepth.enterResultType();

3710

mangleVendorQualifier(

"ns_returns_retained"

);

3715 auto

SplitReturnTy = ReturnTy.

split

();

3717

ReturnTy = getASTContext().getQualifiedType(SplitReturnTy);

3719

mangleType(ReturnTy);

3721

FunctionTypeDepth.leaveResultType();

3729 for

(

unsigned

I = 0,

= Proto->

getNumParams

(); I !=

; ++I) {

3743

assert(

->getType() <= 9 &&

->getType() >= 0);

3744 if

(

->isDynamic())

3745

Out <<

"U25pass_dynamic_object_size"

->getType();

3747

Out <<

"U17pass_object_size"

->getType();

3758

FunctionTypeDepth.enterResultType();

3762

FunctionTypeDepth.pop(saved);

3768

mangleName(

->getDecl());

3773void

CXXNameMangler::mangleType(

const EnumType

) {

3774

mangleType(

static_cast<const TagType

>

(

));

3776void

CXXNameMangler::mangleType(

const RecordType

) {

3777

mangleType(

static_cast<const TagType

>

(

));

3779void

CXXNameMangler::mangleType(

const TagType

) {

3780

mangleName(

->getDecl());

3787

Out <<

'A'

->getSize() <<

'_'

;

3788

mangleType(

->getElementType());

3793 if

(

->getSizeExpr())

3794

mangleExpression(

->getSizeExpr());

3796

mangleType(

->getElementType());

3803 if

(

->getSizeExpr())

3804

mangleExpression(

->getSizeExpr());

3806

mangleType(

->getElementType());

3810

mangleType(

->getElementType());

3817

mangleType(

(

->getClass(), 0));

3840

mangleType(PointeeType);

3845

mangleTemplateParameter(

->getDepth(),

->getIndex());

3854

Out <<

"_SUBSTPACK_"

;

3858void

CXXNameMangler::mangleType(

const PointerType

) {

3880void

CXXNameMangler::mangleType(

const ComplexType

) {

3882

mangleType(

->getElementType());

3888void

CXXNameMangler::mangleNeonVectorType(

const VectorType

) {

3889 QualType

EltType =

->getElementType();

3890

assert(EltType->

isBuiltinType

() &&

"Neon vector element not a BuiltinType"

);

3891 const char

*EltName =

nullptr

;

3892 if

(

->getVectorKind() == VectorKind::NeonPoly) {

3893 switch

(cast<BuiltinType>(EltType)->

()) {

3894 case

BuiltinType::SChar:

3895 case

BuiltinType::UChar:

3896

EltName =

"poly8_t"

;

3898 case

BuiltinType::Short:

3899 case

BuiltinType::UShort:

3900

EltName =

"poly16_t"

;

3902 case

BuiltinType::LongLong:

3903 case

BuiltinType::ULongLong:

3904

EltName =

"poly64_t"

;

3906 default

: llvm_unreachable(

"unexpected Neon polynomial vector element type"

);

3909 switch

(cast<BuiltinType>(EltType)->

()) {

3910 case

BuiltinType::SChar: EltName =

"int8_t"

;

break

;

3911 case

BuiltinType::UChar: EltName =

"uint8_t"

;

break

;

3912 case

BuiltinType::Short: EltName =

"int16_t"

;

break

;

3913 case

BuiltinType::UShort: EltName =

"uint16_t"

;

break

;

3914 case

BuiltinType::Int: EltName =

"int32_t"

;

break

;

3915 case

BuiltinType::UInt: EltName =

"uint32_t"

;

break

;

3916 case

BuiltinType::LongLong: EltName =

"int64_t"

;

break

;

3917 case

BuiltinType::ULongLong: EltName =

"uint64_t"

;

break

;

3918 case

BuiltinType::Double: EltName =

"float64_t"

;

break

;

3919 case

BuiltinType::Float: EltName =

"float32_t"

;

break

;

3920 case

BuiltinType::Half: EltName =

"float16_t"

;

break

;

3921 case

BuiltinType::BFloat16: EltName =

"bfloat16_t"

;

break

;

3922 case

BuiltinType::MFloat8:

3923

EltName =

"mfloat8_t"

;

3926

llvm_unreachable(

"unexpected Neon vector element type"

);

3929 const char

*BaseName =

nullptr

;

3930 unsigned

BitSize = (

->getNumElements() *

3931

getASTContext().getTypeSize(EltType));

3933

BaseName =

"__simd64_"

;

3935

assert(BitSize == 128 &&

"Neon vector type not 64 or 128 bits"

);

3936

BaseName =

"__simd128_"

;

3938

Out << strlen(BaseName) + strlen(EltName);

3939

Out << BaseName << EltName;

3946 "cannot mangle this dependent neon vector type yet"

);

3947

Diags.

(

->getAttributeLoc(), DiagID);

3951 switch

(EltType->

()) {

3952 case

BuiltinType::SChar:

3954 case

BuiltinType::Short:

3956 case

BuiltinType::Int:

3958 case

BuiltinType::Long:

3959 case

BuiltinType::LongLong:

3961 case

BuiltinType::UChar:

3963 case

BuiltinType::UShort:

3965 case

BuiltinType::UInt:

3967 case

BuiltinType::ULong:

3968 case

BuiltinType::ULongLong:

3970 case

BuiltinType::Half:

3972 case

BuiltinType::Float:

3974 case

BuiltinType::Double:

3976 case

BuiltinType::BFloat16:

3978 case

BuiltinType::MFloat8:

3981

llvm_unreachable(

"Unexpected vector element base type"

);

3988void

CXXNameMangler::mangleAArch64NeonVectorType(

const VectorType

) {

3989 QualType

EltType =

->getElementType();

3990

assert(EltType->

isBuiltinType

() &&

"Neon vector element not a BuiltinType"

);

3992

(

->getNumElements() * getASTContext().getTypeSize(EltType));

3995

assert((BitSize == 64 || BitSize == 128) &&

3996 "Neon vector type not 64 or 128 bits"

);

3999 if

(

->getVectorKind() == VectorKind::NeonPoly) {

4000 switch

(cast<BuiltinType>(EltType)->

()) {

4001 case

BuiltinType::UChar:

4004 case

BuiltinType::UShort:

4005

EltName =

"Poly16"

;

4007 case

BuiltinType::ULong:

4008 case

BuiltinType::ULongLong:

4009

EltName =

"Poly64"

;

4012

llvm_unreachable(

"unexpected Neon polynomial vector element type"

);

4018

(

"__"

+ EltName +

"x"

+ Twine(

->getNumElements()) +

"_t"

).str();

4025 "cannot mangle this dependent neon vector type yet"

);

4026

Diags.

(

->getAttributeLoc(), DiagID);

4053void

CXXNameMangler::mangleAArch64FixedSveVectorType(

const VectorType

) {

4054

assert((

->getVectorKind() == VectorKind::SveFixedLengthData ||

4055 T

->getVectorKind() == VectorKind::SveFixedLengthPredicate) &&

4056 "expected fixed-length SVE vector!"

);

4058 QualType

EltType =

->getElementType();

4060 "expected builtin type for fixed-length SVE vector!"

);

4063 switch

(cast<BuiltinType>(EltType)->

()) {

4064 case

BuiltinType::SChar:

4067 case

BuiltinType::UChar: {

4068 if

(

->getVectorKind() == VectorKind::SveFixedLengthData)

4074 case

BuiltinType::Short:

4077 case

BuiltinType::UShort:

4080 case

BuiltinType::Int:

4083 case

BuiltinType::UInt:

4086 case

BuiltinType::Long:

4089 case

BuiltinType::ULong:

4092 case

BuiltinType::Half:

4095 case

BuiltinType::Float:

4098 case

BuiltinType::Double:

4101 case

BuiltinType::BFloat16:

4105

llvm_unreachable(

"unexpected element type for fixed-length SVE vector!"

);

4108 unsigned

VecSizeInBits = getASTContext().getTypeInfo(

).Width;

4110 if

(

->getVectorKind() == VectorKind::SveFixedLengthPredicate)

4113

Out <<

"9__SVE_VLSI"

;

4114

mangleVendorType(TypeName);

4115

Out <<

"Lj"

<< VecSizeInBits <<

"EE"

;

4118void

CXXNameMangler::mangleAArch64FixedSveVectorType(

4123 "cannot mangle this dependent fixed-length SVE vector type yet"

);

4124

Diags.

(

->getAttributeLoc(), DiagID);

4127void

CXXNameMangler::mangleRISCVFixedRVVVectorType(

const VectorType

) {

4128

assert((

->getVectorKind() == VectorKind::RVVFixedLengthData ||

4129 T

->getVectorKind() == VectorKind::RVVFixedLengthMask ||

4130 T

->getVectorKind() == VectorKind::RVVFixedLengthMask_1 ||

4131 T

->getVectorKind() == VectorKind::RVVFixedLengthMask_2 ||

4132 T

->getVectorKind() == VectorKind::RVVFixedLengthMask_4) &&

4133 "expected fixed-length RVV vector!"

);

4135 QualType

EltType =

->getElementType();

4137 "expected builtin type for fixed-length RVV vector!"

);

4140

llvm::raw_svector_ostream TypeNameOS(TypeNameStr);

4141

TypeNameOS <<

"__rvv_"

;

4142 switch

(cast<BuiltinType>(EltType)->

()) {

4143 case

BuiltinType::SChar:

4144

TypeNameOS <<

"int8"

;

4146 case

BuiltinType::UChar:

4147 if

(

->getVectorKind() == VectorKind::RVVFixedLengthData)

4148

TypeNameOS <<

"uint8"

;

4150

TypeNameOS <<

"bool"

;

4152 case

BuiltinType::Short:

4153

TypeNameOS <<

"int16"

;

4155 case

BuiltinType::UShort:

4156

TypeNameOS <<

"uint16"

;

4158 case

BuiltinType::Int:

4159

TypeNameOS <<

"int32"

;

4161 case

BuiltinType::UInt:

4162

TypeNameOS <<

"uint32"

;

4164 case

BuiltinType::Long:

4165

TypeNameOS <<

"int64"

;

4167 case

BuiltinType::ULong:

4168

TypeNameOS <<

"uint64"

;

4170 case

BuiltinType::Float16:

4171

TypeNameOS <<

"float16"

;

4173 case

BuiltinType::Float:

4174

TypeNameOS <<

"float32"

;

4176 case

BuiltinType::Double:

4177

TypeNameOS <<

"float64"

;

4180

llvm_unreachable(

"unexpected element type for fixed-length RVV vector!"

);

4183 unsigned

VecSizeInBits;

4184 switch

(

->getVectorKind()) {

4185 case

VectorKind::RVVFixedLengthMask_1:

4188 case

VectorKind::RVVFixedLengthMask_2:

4191 case

VectorKind::RVVFixedLengthMask_4:

4195

VecSizeInBits = getASTContext().getTypeInfo(

).Width;

4200 auto

VScale = getASTContext().getTargetInfo().getVScaleRange(

4201

getASTContext().getLangOpts(),

false

);

4202 unsigned

VLen = VScale->first * llvm::RISCV::RVVBitsPerBlock;

4204 if

(

->getVectorKind() == VectorKind::RVVFixedLengthData) {

4206 if

(VecSizeInBits >= VLen)

4207

TypeNameOS << (VecSizeInBits / VLen);

4209

TypeNameOS <<

'f'

<< (VLen / VecSizeInBits);

4211

TypeNameOS << (VLen / VecSizeInBits);

4213

TypeNameOS <<

"_t"

;

4215

Out <<

"9__RVV_VLSI"

;

4216

mangleVendorType(TypeNameStr);

4217

Out <<

"Lj"

<< VecSizeInBits <<

"EE"

;

4220void

CXXNameMangler::mangleRISCVFixedRVVVectorType(

4225 "cannot mangle this dependent fixed-length RVV vector type yet"

);

4226

Diags.

(

->getAttributeLoc(), DiagID);

4237void

CXXNameMangler::mangleType(

const VectorType

) {

4238 if

((

->getVectorKind() == VectorKind::Neon ||

4239 T

->getVectorKind() == VectorKind::NeonPoly)) {

4240

llvm::Triple

Target

= getASTContext().getTargetInfo().getTriple();

4241

llvm::Triple::ArchType Arch =

4242

getASTContext().getTargetInfo().getTriple().getArch();

4243 if

((Arch == llvm::Triple::aarch64 ||

4244

Arch == llvm::Triple::aarch64_be) && !

Target

.isOSDarwin())

4245

mangleAArch64NeonVectorType(

);

4247

mangleNeonVectorType(

);

4249

}

else if

(

->getVectorKind() == VectorKind::SveFixedLengthData ||

4250 T

->getVectorKind() == VectorKind::SveFixedLengthPredicate) {

4251

mangleAArch64FixedSveVectorType(

);

4253

}

else if

(

->getVectorKind() == VectorKind::RVVFixedLengthData ||

4254 T

->getVectorKind() == VectorKind::RVVFixedLengthMask ||

4255 T

->getVectorKind() == VectorKind::RVVFixedLengthMask_1 ||

4256 T

->getVectorKind() == VectorKind::RVVFixedLengthMask_2 ||

4257 T

->getVectorKind() == VectorKind::RVVFixedLengthMask_4) {

4258

mangleRISCVFixedRVVVectorType(

);

4261

Out <<

"Dv"

->getNumElements() <<

'_'

;

4262 if

(

->getVectorKind() == VectorKind::AltiVecPixel)

4264 else if

(

->getVectorKind() == VectorKind::AltiVecBool)

4267

mangleType(

->getElementType());

4271 if

((

->getVectorKind() == VectorKind::Neon ||

4272 T

->getVectorKind() == VectorKind::NeonPoly)) {

4273

llvm::Triple

Target

= getASTContext().getTargetInfo().getTriple();

4274

llvm::Triple::ArchType Arch =

4275

getASTContext().getTargetInfo().getTriple().getArch();

4276 if

((Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_be) &&

4278

mangleAArch64NeonVectorType(

);

4280

mangleNeonVectorType(

);

4282

}

else if

(

->getVectorKind() == VectorKind::SveFixedLengthData ||

4283 T

->getVectorKind() == VectorKind::SveFixedLengthPredicate) {

4284

mangleAArch64FixedSveVectorType(

);

4286

}

else if

(

->getVectorKind() == VectorKind::RVVFixedLengthData) {

4287

mangleRISCVFixedRVVVectorType(

);

4292

mangleExpression(

->getSizeExpr());

4294 if

(

->getVectorKind() == VectorKind::AltiVecPixel)

4296 else if

(

->getVectorKind() == VectorKind::AltiVecBool)

4299

mangleType(

->getElementType());

4303

mangleType(

static_cast<const VectorType

>

(

));

4307

mangleExpression(

->getSizeExpr());

4309

mangleType(

->getElementType());

4316

mangleVendorType(

"matrix_type"

);

4319 auto

&ASTCtx = getASTContext();

4320 unsigned

BitWidth = ASTCtx.getTypeSize(ASTCtx.getSizeType());

4321

llvm::APSInt Rows(BitWidth);

4322

Rows =

->getNumRows();

4323

mangleIntegerLiteral(ASTCtx.getSizeType(), Rows);

4324

llvm::APSInt Columns(BitWidth);

4325

Columns =

->getNumColumns();

4326

mangleIntegerLiteral(ASTCtx.getSizeType(), Columns);

4327

mangleType(

->getElementType());

4334

mangleVendorType(

"matrix_type"

);

4337

mangleTemplateArgExpr(

->getRowExpr());

4338

mangleTemplateArgExpr(

->getColumnExpr());

4339

mangleType(

->getElementType());

4345

mangleQualifiers(split.

Quals

);

4352

mangleType(

->getPattern());

4356 if

->hasSelectedType())

4357

mangleType(

->getPattern());

4359

mangleType(

->getSelectedType());

4363

mangleSourceName(

->getDecl()->getIdentifier());

4368 if

(

->isKindOfType())

4369

Out <<

"U8__kindof"

;

4371 if

->qual_empty()) {

4374

llvm::raw_svector_ostream QualOS(QualStr);

4375

QualOS <<

"objcproto"

;

4376 for

(

const auto

*I :

->quals()) {

4377

StringRef

= I->getName();

4380

mangleVendorQualifier(QualStr);

4383

mangleType(

->getBaseType());

4385 if

(

->isSpecialized()) {

4388 for

(

auto

typeArg :

->getTypeArgs())

4389

mangleType(typeArg);

4395

Out <<

"U13block_pointer"

;

4403

mangleType(

->getInjectedSpecializationType());

4407 if

(

TemplateDecl

*TD =

->getTemplateName().getAsTemplateDecl()) {

4408

mangleTemplateName(TD,

->template_arguments());

4410 if

(mangleSubstitution(

(

, 0)))

4413

mangleTemplatePrefix(

->getTemplateName());

4418

mangleTemplateArgs(

->getTemplateName(),

->template_arguments());

4434 switch

(

->getKeyword()) {

4435 case

ElaboratedTypeKeyword::None:

4436 case

ElaboratedTypeKeyword::Typename:

4438 case

ElaboratedTypeKeyword::Struct:

4439 case

ElaboratedTypeKeyword::Class:

4440 case

ElaboratedTypeKeyword::Interface:

4443 case

ElaboratedTypeKeyword::Union:

4446 case

ElaboratedTypeKeyword::Enum:

4452

manglePrefix(

->getQualifier());

4453

mangleSourceName(

->getIdentifier());

4463

getASTContext().getDependentTemplateName(

->getQualifier(),

4464 T

->getIdentifier());

4465

mangleTemplatePrefix(Prefix);

4470

mangleTemplateArgs(Prefix,

->template_arguments());

4474void

CXXNameMangler::mangleType(

const TypeOfType

) {

4487 Expr

->getUnderlyingExpr();

4497 if

(isa<DeclRefExpr>(

) ||

4498

isa<MemberExpr>(

) ||

4499

isa<UnresolvedLookupExpr>(

) ||

4500

isa<DependentScopeDeclRefExpr>(

) ||

4501

isa<CXXDependentScopeMemberExpr>(

) ||

4502

isa<UnresolvedMemberExpr>(

))

4506

mangleExpression(

);

4514

StringRef BuiltinName;

4515 switch

(

->getUTTKind()) {

4516#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait) \ 4517 case UnaryTransformType::Enum: \ 4518 BuiltinName = "__"

#Trait; \

4520#include "clang/Basic/TransformTypeTraits.def" 4522

mangleVendorType(BuiltinName);

4526

mangleType(

->getBaseType());

4530void

CXXNameMangler::mangleType(

const AutoType

) {

4531

assert(

->getDeducedType().isNull() &&

4532 "Deduced AutoType shouldn't be handled here!"

);

4533

assert(

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

4534 "shouldn't need to mangle __auto_type!"

);

4539 if

(

->isConstrained() && !isCompatibleWith(LangOptions::ClangABI::Ver17)) {

4540

Out << (

->isDecltypeAuto() ?

"DK"

"Dk"

);

4541

mangleTypeConstraint(

->getTypeConstraintConcept(),

4542 T

->getTypeConstraintArguments());

4544

Out << (

->isDecltypeAuto() ?

"Dc"

"Da"

);

4549 QualType

Deduced =

->getDeducedType();

4551 return

mangleType(Deduced);

4555 "shouldn't form deduced TST unless we know we have a template"

);

4559void

CXXNameMangler::mangleType(

const AtomicType

) {

4562

Out <<

"U7_Atomic"

;

4563

mangleType(

->getValueType());

4566void

CXXNameMangler::mangleType(

const PipeType

) {

4570

Out <<

"8ocl_pipe"

;

4573void

CXXNameMangler::mangleType(

const BitIntType

) {

4577

Out <<

"D"

<< (

->isUnsigned() ?

"U"

"B"

) <<

->getNumBits() <<

"_"

;

4584

Out <<

"D"

<< (

->isUnsigned() ?

"U"

"B"

);

4585

mangleExpression(

->getNumBitsExpr());

4590

mangleType(cast<ConstantArrayType>(

));

4598 case

llvm::dxil::ResourceClass::UAV:

4601 case

llvm::dxil::ResourceClass::SRV:

4604 case

llvm::dxil::ResourceClass::CBuffer:

4607 case

llvm::dxil::ResourceClass::Sampler:

4615 if

(

->hasContainedType())

4617

mangleVendorQualifier(Str);

4619 if

(

->hasContainedType()) {

4620

mangleType(

->getContainedType());

4622

mangleType(

->getWrappedType());

4625void

CXXNameMangler::mangleIntegerLiteral(

4626 const

llvm::APSInt &

) {

4633

Out << (

.getBoolValue() ?

'1'

'0'

);

4635

mangleNumber(

);

4641void

CXXNameMangler::mangleMemberExprBase(

const Expr

bool

IsArrow) {

4643 while

(

const auto

*RT =

->getType()->getAs<

RecordType

>()) {

4644 if

(!RT->getDecl()->isAnonymousStructOrUnion())

4646 const auto

*ME = dyn_cast<MemberExpr>(

);

4649 Base

= ME->getBase();

4650

IsArrow = ME->isArrow();

4653 if

(

->isImplicitCXXThis()) {

4659

Out << (IsArrow ?

"pt"

"dt"

);

4660

mangleExpression(

);

4665void

CXXNameMangler::mangleMemberExpr(

const Expr

*base,

4671 unsigned

NumTemplateArgs,

4676

mangleMemberExprBase(base, isArrow);

4677

mangleUnresolvedName(qualifier, member, TemplateArgs, NumTemplateArgs, arity);

4690 if

(callee == fn)

return false

;

4694 if

(!lookup)

return false

;

4711void

CXXNameMangler::mangleCastExpression(

const Expr

, StringRef CastEncoding) {

4713

Out << CastEncoding;

4718void

CXXNameMangler::mangleInitListElements(

const InitListExpr

*InitList) {

4720

InitList = Syntactic;

4721 for

(

unsigned

i = 0, e = InitList->

getNumInits

(); i != e; ++i)

4722

mangleExpression(InitList->

getInit

(i));

4725void

CXXNameMangler::mangleRequirement(

SourceLocation

RequiresExprLoc,

4732 auto

HandleSubstitutionFailure =

4737 "containing a substitution failure"

);

4743 case

Requirement::RK_Type: {

4744 const auto

*TR = cast<concepts::TypeRequirement>(Req);

4745 if

(TR->isSubstitutionFailure())

4746 return

HandleSubstitutionFailure(

4747

TR->getSubstitutionDiagnostic()->DiagLoc);

4750

mangleType(TR->getType()->getType());

4754 case

Requirement::RK_Simple:

4755 case

Requirement::RK_Compound: {

4756 const auto

*ER = cast<concepts::ExprRequirement>(Req);

4757 if

(ER->isExprSubstitutionFailure())

4758 return

HandleSubstitutionFailure(

4759

ER->getExprSubstitutionDiagnostic()->DiagLoc);

4762

mangleExpression(ER->getExpr());

4764 if

(ER->hasNoexceptRequirement())

4767 if

(!ER->getReturnTypeRequirement().isEmpty()) {

4768 if

(ER->getReturnTypeRequirement().isSubstitutionFailure())

4769 return

HandleSubstitutionFailure(ER->getReturnTypeRequirement()

4770

.getSubstitutionDiagnostic()

4774

mangleTypeConstraint(ER->getReturnTypeRequirement().getTypeConstraint());

4779 case

Requirement::RK_Nested:

4780 const auto

*NR = cast<concepts::NestedRequirement>(Req);

4781 if

(NR->hasInvalidConstraint()) {

4784 return

HandleSubstitutionFailure(RequiresExprLoc);

4788

mangleExpression(NR->getConstraintExpr());

4793void

CXXNameMangler::mangleExpression(

const Expr

unsigned

Arity,

4794 bool

AsTemplateArg) {

4823 QualType

ImplicitlyConvertedToType;

4827 bool

IsPrimaryExpr =

true

;

4828 auto

NotPrimaryExpr = [&] {

4829 if

(AsTemplateArg && IsPrimaryExpr)

4831

IsPrimaryExpr =

false

;

4834 auto

MangleDeclRefExpr = [&](

const NamedDecl

) {

4845

mangleFunctionParam(cast<ParmVarDecl>(

));

4848 case

Decl::EnumConstant: {

4855 case

Decl::NonTypeTemplateParm:

4868 case

Expr::NoStmtClass:

4869#define ABSTRACT_STMT(Type) 4870#define EXPR(Type, Base) 4871#define STMT(Type, Base) \ 4872 case Expr::Type##Class: 4873#include "clang/AST/StmtNodes.inc" 4878 case

Expr::AddrLabelExprClass:

4879 case

Expr::DesignatedInitUpdateExprClass:

4880 case

Expr::ImplicitValueInitExprClass:

4881 case

Expr::ArrayInitLoopExprClass:

4882 case

Expr::ArrayInitIndexExprClass:

4883 case

Expr::NoInitExprClass:

4884 case

Expr::ParenListExprClass:

4885 case

Expr::MSPropertyRefExprClass:

4886 case

Expr::MSPropertySubscriptExprClass:

4887 case

Expr::TypoExprClass:

4888 case

Expr::RecoveryExprClass:

4889 case

Expr::ArraySectionExprClass:

4890 case

Expr::OMPArrayShapingExprClass:

4891 case

Expr::OMPIteratorExprClass:

4892 case

Expr::CXXInheritedCtorInitExprClass:

4893 case

Expr::CXXParenListInitExprClass:

4894 case

Expr::PackIndexingExprClass:

4895

llvm_unreachable(

"unexpected statement kind"

);

4897 case

Expr::ConstantExprClass:

4898 E

= cast<ConstantExpr>(

)->getSubExpr();

4902 case

Expr::BlockExprClass:

4903 case

Expr::ChooseExprClass:

4904 case

Expr::CompoundLiteralExprClass:

4905 case

Expr::ExtVectorElementExprClass:

4906 case

Expr::GenericSelectionExprClass:

4907 case

Expr::ObjCEncodeExprClass:

4908 case

Expr::ObjCIsaExprClass:

4909 case

Expr::ObjCIvarRefExprClass:

4910 case

Expr::ObjCMessageExprClass:

4911 case

Expr::ObjCPropertyRefExprClass:

4912 case

Expr::ObjCProtocolExprClass:

4913 case

Expr::ObjCSelectorExprClass:

4914 case

Expr::ObjCStringLiteralClass:

4915 case

Expr::ObjCBoxedExprClass:

4916 case

Expr::ObjCArrayLiteralClass:

4917 case

Expr::ObjCDictionaryLiteralClass:

4918 case

Expr::ObjCSubscriptRefExprClass:

4919 case

Expr::ObjCIndirectCopyRestoreExprClass:

4920 case

Expr::ObjCAvailabilityCheckExprClass:

4921 case

Expr::OffsetOfExprClass:

4922 case

Expr::PredefinedExprClass:

4923 case

Expr::ShuffleVectorExprClass:

4924 case

Expr::ConvertVectorExprClass:

4925 case

Expr::StmtExprClass:

4926 case

Expr::ArrayTypeTraitExprClass:

4927 case

Expr::ExpressionTraitExprClass:

4928 case

Expr::VAArgExprClass:

4929 case

Expr::CUDAKernelCallExprClass:

4930 case

Expr::AsTypeExprClass:

4931 case

Expr::PseudoObjectExprClass:

4932 case

Expr::AtomicExprClass:

4933 case

Expr::SourceLocExprClass:

4934 case

Expr::EmbedExprClass:

4935 case

Expr::BuiltinBitCastExprClass:

4936 case

Expr::ResolvedUnexpandedPackExprClass: {

4942 "cannot yet mangle expression type %0"

);

4950 case

Expr::CXXUuidofExprClass: {

4955 if

(!isCompatibleWith(LangOptions::ClangABI::Ver11)) {

4956

Out <<

"u8__uuidof"

;

4965

Out <<

"u8__uuidoft"

;

4969

Out <<

"u8__uuidofz"

;

4970

mangleExpression(UuidExp);

4977 case

Expr::BinaryConditionalOperatorClass: {

4982 "?: operator with omitted middle operand cannot be mangled"

);

4989 case

Expr::OpaqueValueExprClass:

4990

llvm_unreachable(

"cannot mangle opaque value; mangling wrong thing?"

);

4992 case

Expr::InitListExprClass: {

4995

mangleInitListElements(cast<InitListExpr>(

));

5000 case

Expr::DesignatedInitExprClass: {

5002 auto

*DIE = cast<DesignatedInitExpr>(

);

5003 for

(

const auto

: DIE->designators()) {

5006

mangleSourceName(

.getFieldName());

5009

mangleExpression(DIE->getArrayIndex(

));

5012 "unknown designator kind"

);

5014

mangleExpression(DIE->getArrayRangeStart(

));

5015

mangleExpression(DIE->getArrayRangeEnd(

));

5018

mangleExpression(DIE->getInit());

5022 case

Expr::CXXDefaultArgExprClass:

5023 E

= cast<CXXDefaultArgExpr>(

)->getExpr();

5026 case

Expr::CXXDefaultInitExprClass:

5027 E

= cast<CXXDefaultInitExpr>(

)->getExpr();

5030 case

Expr::CXXStdInitializerListExprClass:

5031 E

= cast<CXXStdInitializerListExpr>(

)->getSubExpr();

5034 case

Expr::SubstNonTypeTemplateParmExprClass: {

5037 auto

*SNTTPE = cast<SubstNonTypeTemplateParmExpr>(

);

5038 if

(

auto

*CE = dyn_cast<ConstantExpr>(SNTTPE->getReplacement())) {

5040 QualType

ParamType = SNTTPE->getParameterType(Context.getASTContext());

5041

assert(CE->hasAPValueResult() &&

"expected the NTTP to have an APValue"

);

5042

mangleValueInTemplateArg(ParamType, CE->getAPValueResult(),

false

5048 E

= cast<SubstNonTypeTemplateParmExpr>(

)->getReplacement();

5052 case

Expr::UserDefinedLiteralClass:

5055 case

Expr::CXXMemberCallExprClass:

5056 case

Expr::CallExprClass: {

5058 const CallExpr

*CE = cast<CallExpr>(

);

5077 if

(isa<PackExpansionExpr>(Arg))

5078

CallArity = UnknownArity;

5080

mangleExpression(CE->

getCallee

(), CallArity);

5082

mangleExpression(Arg);

5087 case

Expr::CXXNewExprClass: {

5091

Out << (New->

isArray

() ?

"na"

"nw"

);

5094

mangleExpression(*I);

5108

mangleExpression(*I);

5110 for

(

unsigned

i = 0, e = PLE->getNumExprs(); i != e; ++i)

5111

mangleExpression(PLE->getExpr(i));

5113

CXXNewInitializationStyle::Braces &&

5114

isa<InitListExpr>(

Init

)) {

5116

mangleInitListElements(cast<InitListExpr>(

Init

));

5118

mangleExpression(

Init

);

5124 case

Expr::CXXPseudoDestructorExprClass: {

5126 const auto

*PDE = cast<CXXPseudoDestructorExpr>(

);

5127 if

(

const Expr

= PDE->getBase())

5128

mangleMemberExprBase(

, PDE->isArrow());

5132

mangleUnresolvedPrefix(Qualifier,

5134

mangleUnresolvedTypeOrSimpleId(ScopeInfo->getType());

5138 if

(!mangleUnresolvedTypeOrSimpleId(ScopeInfo->getType()))

5141

}

else if

(Qualifier) {

5142

mangleUnresolvedPrefix(Qualifier);

5146 QualType

DestroyedType = PDE->getDestroyedType();

5147

mangleUnresolvedTypeOrSimpleId(DestroyedType);

5151 case

Expr::MemberExprClass: {

5162 case

Expr::UnresolvedMemberExprClass: {

5173 case

Expr::CXXDependentScopeMemberExprClass: {

5176

= cast<CXXDependentScopeMemberExpr>(

);

5186 case

Expr::UnresolvedLookupExprClass: {

5195 case

Expr::CXXUnresolvedConstructExprClass: {

5201

assert(N == 1 &&

"unexpected form for list initialization"

);

5202 auto

*IL = cast<InitListExpr>(CE->

getArg

(0));

5205

mangleInitListElements(IL);

5212 if

(N != 1) Out <<

'_'

;

5213 for

(

unsigned

I = 0; I != N; ++I) mangleExpression(CE->

getArg

(I));

5214 if

(N != 1) Out <<

'E'

;

5218 case

Expr::CXXConstructExprClass: {

5220 const auto

*CE = cast<CXXConstructExpr>(

);

5225 "implicit CXXConstructExpr must have one argument"

);

5226 E

= cast<CXXConstructExpr>(

)->getArg(0);

5232

mangleExpression(

);

5237 case

Expr::CXXTemporaryObjectExprClass: {

5239 const auto

*CE = cast<CXXTemporaryObjectExpr>(

);

5248 if

(!List && N != 1)

5250 if

(CE->isStdInitListInitialization()) {

5256 auto

*ILE = cast<InitListExpr>(SILE->getSubExpr()->IgnoreImplicit());

5257

mangleInitListElements(ILE);

5260

mangleExpression(

);

5267 case

Expr::CXXScalarValueInitExprClass:

5274 case

Expr::CXXNoexceptExprClass:

5277

mangleExpression(cast<CXXNoexceptExpr>(

)->getOperand());

5280 case

Expr::UnaryExprOrTypeTraitExprClass: {

5299

: ImplicitlyConvertedToType;

5301

mangleIntegerLiteral(

);

5307 auto

MangleAlignofSizeofArg = [&] {

5320

MangleAlignofSizeofArg();

5322 case

UETT_PreferredAlignOf:

5326 if

(!isCompatibleWith(LangOptions::ClangABI::Ver11)) {

5327

Out <<

"u11__alignof__"

;

5338

MangleAlignofSizeofArg();

5340 case

UETT_DataSizeOf: {

5344 "cannot yet mangle __datasizeof expression"

);

5348 case

UETT_PtrAuthTypeDiscriminator: {

5352 "cannot yet mangle __builtin_ptrauth_type_discriminator expression"

);

5356 case

UETT_VecStep: {

5359 "cannot yet mangle vec_step expression"

);

5363 case

UETT_OpenMPRequiredSimdAlign: {

5367 "cannot yet mangle __builtin_omp_required_simd_align expression"

);

5371 case

UETT_VectorElements: {

5375 "cannot yet mangle __builtin_vectorelements expression"

);

5383 case

Expr::TypeTraitExprClass: {

5388

mangleVendorType(Spelling);

5390

mangleType(TSI->getType());

5396 case

Expr::CXXThrowExprClass: {

5410 case

Expr::CXXTypeidExprClass: {

5425 case

Expr::CXXDeleteExprClass: {

5436 case

Expr::UnaryOperatorClass: {

5445 case

Expr::ArraySubscriptExprClass: {

5452

mangleExpression(AE->

getLHS

());

5453

mangleExpression(AE->

getRHS

());

5457 case

Expr::MatrixSubscriptExprClass: {

5461

mangleExpression(ME->

getBase

());

5467 case

Expr::CompoundAssignOperatorClass:

5468 case

Expr::BinaryOperatorClass: {

5476

mangleExpression(BO->

getLHS

());

5477

mangleExpression(BO->

getRHS

());

5481 case

Expr::CXXRewrittenBinaryOperatorClass: {

5485

cast<CXXRewrittenBinaryOperator>(

)->getDecomposedForm();

5488

mangleExpression(Decomposed.

LHS

);

5489

mangleExpression(Decomposed.

RHS

);

5493 case

Expr::ConditionalOperatorClass: {

5496

mangleOperatorName(OO_Conditional,

3);

5497

mangleExpression(CO->

getCond

());

5498

mangleExpression(CO->

getLHS

(), Arity);

5499

mangleExpression(CO->

getRHS

(), Arity);

5503 case

Expr::ImplicitCastExprClass: {

5504

ImplicitlyConvertedToType =

();

5505 E

= cast<ImplicitCastExpr>(

)->getSubExpr();

5509 case

Expr::ObjCBridgedCastExprClass: {

5513

StringRef

Kind

= cast<ObjCBridgedCastExpr>(

)->getBridgeKindName();

5514

Out <<

"v1U"

Kind

.size() <<

Kind

;

5515

mangleCastExpression(

"cv"

);

5519 case

Expr::CStyleCastExprClass:

5521

mangleCastExpression(

"cv"

);

5524 case

Expr::CXXFunctionalCastExprClass: {

5526 auto

Sub

= cast<ExplicitCastExpr>(

)->getSubExpr()->IgnoreImplicit();

5528 if

(

auto

*CCE = dyn_cast<CXXConstructExpr>(Sub))

5529 if

(CCE->getParenOrBraceRange().isInvalid())

5530 Sub

= CCE->getArg(0)->IgnoreImplicit();

5531 if

(

auto

*StdInitList = dyn_cast<CXXStdInitializerListExpr>(Sub))

5532 Sub

= StdInitList->getSubExpr()->IgnoreImplicit();

5533 if

(

auto

*IL = dyn_cast<InitListExpr>(Sub)) {

5536

mangleInitListElements(IL);

5539

mangleCastExpression(

"cv"

);

5544 case

Expr::CXXStaticCastExprClass:

5546

mangleCastExpression(

"sc"

);

5548 case

Expr::CXXDynamicCastExprClass:

5550

mangleCastExpression(

"dc"

);

5552 case

Expr::CXXReinterpretCastExprClass:

5554

mangleCastExpression(

"rc"

);

5556 case

Expr::CXXConstCastExprClass:

5558

mangleCastExpression(

"cc"

);

5560 case

Expr::CXXAddrspaceCastExprClass:

5562

mangleCastExpression(

"ac"

);

5565 case

Expr::CXXOperatorCallExprClass: {

5574 for

(

unsigned

i = 0; i != NumArgs; ++i)

5575

mangleExpression(CE->

getArg

(i));

5579 case

Expr::ParenExprClass:

5580 E

= cast<ParenExpr>(

)->getSubExpr();

5583 case

Expr::ConceptSpecializationExprClass: {

5584 auto

*CSE = cast<ConceptSpecializationExpr>(

);

5585 if

(isCompatibleWith(LangOptions::ClangABI::Ver17)) {

5590

mangleTemplateName(CSE->getNamedConcept(), CSE->getTemplateArguments());

5596

mangleUnresolvedName(

5597

CSE->getNestedNameSpecifierLoc().getNestedNameSpecifier(),

5598

CSE->getConceptNameInfo().getName(),

5599

CSE->getTemplateArgsAsWritten()->getTemplateArgs(),

5600

CSE->getTemplateArgsAsWritten()->getNumTemplateArgs());

5604 case

Expr::RequiresExprClass: {

5606 auto

*RE = cast<RequiresExpr>(

);

5610 if

(RE->getLParenLoc().isValid()) {

5612

FunctionTypeDepthState saved = FunctionTypeDepth.push();

5613 if

(RE->getLocalParameters().empty()) {

5616 for

(

ParmVarDecl

*Param : RE->getLocalParameters()) {

5624

FunctionTypeDepth.enterResultType();

5626

mangleRequirement(RE->getExprLoc(), Req);

5627

FunctionTypeDepth.pop(saved);

5632

mangleRequirement(RE->getExprLoc(), Req);

5638 case

Expr::DeclRefExprClass:

5640

MangleDeclRefExpr(cast<DeclRefExpr>(

)->getDecl());

5643 case

Expr::SubstNonTypeTemplateParmPackExprClass:

5649

Out <<

"_SUBSTPACK_"

;

5652 case

Expr::FunctionParmPackExprClass: {

5656

Out <<

"v110_SUBSTPACK"

;

5661 case

Expr::DependentScopeDeclRefExprClass: {

5670 case

Expr::CXXBindTemporaryExprClass:

5671 E

= cast<CXXBindTemporaryExpr>(

)->getSubExpr();

5674 case

Expr::ExprWithCleanupsClass:

5675 E

= cast<ExprWithCleanups>(

)->getSubExpr();

5678 case

Expr::FloatingLiteralClass: {

5685 case

Expr::FixedPointLiteralClass:

5687

mangleFixedPointLiteral();

5690 case

Expr::CharacterLiteralClass:

5694

Out << cast<CharacterLiteral>(

)->getValue();

5699 case

Expr::ObjCBoolLiteralExprClass:

5702

Out << (cast<ObjCBoolLiteralExpr>(

)->getValue() ?

'1'

'0'

);

5706 case

Expr::CXXBoolLiteralExprClass:

5709

Out << (cast<CXXBoolLiteralExpr>(

)->getValue() ?

'1'

'0'

);

5713 case

Expr::IntegerLiteralClass: {

5715

llvm::APSInt

(cast<IntegerLiteral>(

)->getValue());

5717 Value

.setIsSigned(

true

);

5722 case

Expr::ImaginaryLiteralClass: {

5730

dyn_cast<FloatingLiteral>(IE->

getSubExpr

())) {

5732

mangleFloat(llvm::APFloat(Imag->getValue().getSemantics()));

5734

mangleFloat(Imag->getValue());

5737

llvm::APSInt

(cast<IntegerLiteral>(IE->

getSubExpr

())->getValue());

5739 Value

.setIsSigned(

true

);

5740

mangleNumber(

);

5746 case

Expr::StringLiteralClass: {

5750

assert(isa<ConstantArrayType>(

()));

5756 case

Expr::GNUNullExprClass:

5759

mangleIntegerLiteral(

(), llvm::APSInt(32));

5762 case

Expr::CXXNullPtrLiteralExprClass: {

5768 case

Expr::LambdaExprClass: {

5773

mangleType(Context.getASTContext().

getRecordType

(cast<LambdaExpr>(

)->getLambdaClass()));

5778 case

Expr::PackExpansionExprClass:

5781

mangleExpression(cast<PackExpansionExpr>(

)->getPattern());

5784 case

Expr::SizeOfPackExprClass: {

5786 auto

*SPE = cast<SizeOfPackExpr>(

);

5787 if

(SPE->isPartiallySubstituted()) {

5789 for

(

const auto

&A : SPE->getPartialArguments())

5790

mangleTemplateArg(A,

false

);

5798

mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());

5800

= dyn_cast<NonTypeTemplateParmDecl>(Pack))

5801

mangleTemplateParameter(NTTP->getDepth(), NTTP->getIndex());

5803

= dyn_cast<TemplateTemplateParmDecl>(Pack))

5804

mangleTemplateParameter(TempTP->getDepth(), TempTP->getIndex());

5806

mangleFunctionParam(cast<ParmVarDecl>(Pack));

5810 case

Expr::MaterializeTemporaryExprClass:

5811 E

= cast<MaterializeTemporaryExpr>(

)->getSubExpr();

5814 case

Expr::CXXFoldExprClass: {

5816 auto

*FE = cast<CXXFoldExpr>(

);

5817 if

(FE->isLeftFold())

5818

Out << (FE->getInit() ?

"fL"

"fl"

);

5820

Out << (FE->getInit() ?

"fR"

"fr"

);

5822 if

(FE->getOperator() == BO_PtrMemD)

5830

mangleExpression(FE->getLHS());

5832

mangleExpression(FE->getRHS());

5836 case

Expr::CXXThisExprClass:

5841 case

Expr::CoawaitExprClass:

5844

Out <<

"v18co_await"

;

5845

mangleExpression(cast<CoawaitExpr>(

)->getOperand());

5848 case

Expr::DependentCoawaitExprClass:

5851

Out <<

"v18co_await"

;

5852

mangleExpression(cast<DependentCoawaitExpr>(

)->getOperand());

5855 case

Expr::CoyieldExprClass:

5858

Out <<

"v18co_yield"

;

5859

mangleExpression(cast<CoawaitExpr>(

)->getOperand());

5861 case

Expr::SYCLUniqueStableNameExprClass: {

5862 const auto

*USN = cast<SYCLUniqueStableNameExpr>(

);

5865

Out <<

"u33__builtin_sycl_unique_stable_name"

;

5866

mangleType(USN->getTypeSourceInfo()->getType());

5871 case

Expr::HLSLOutArgExprClass:

5873 "cannot mangle hlsl temporary value; mangling wrong thing?"

);

5874 case

Expr::OpenACCAsteriskSizeExprClass: {

5879 "cannot yet mangle OpenACC Asterisk Size expression"

);

5885 if

(AsTemplateArg && !IsPrimaryExpr)

5917void

CXXNameMangler::mangleFunctionParam(

const ParmVarDecl

*parm) {

5924

assert(parmDepth < FunctionTypeDepth.getDepth());

5925 unsigned

nestingDepth = FunctionTypeDepth.getDepth() - parmDepth;

5926 if

(FunctionTypeDepth.isInResultType())

5929 if

(nestingDepth == 0) {

5932

Out <<

"fL"

<< (nestingDepth - 1) <<

'p'

;

5940

"parameter's type is still an array type?"

);

5943

dyn_cast<DependentAddressSpaceType>(parm->

())) {

5950 if

(parmIndex != 0) {

5951

Out << (parmIndex - 1);

5979

llvm_unreachable(

"closure constructors don't exist for the Itanium ABI!"

);

5982

mangleName(InheritedFrom);

5985void

CXXNameMangler::mangleCXXDtorType(

CXXDtorType T

) {

6036 if

(

auto

*FTD = dyn_cast_or_null<FunctionTemplateDecl>(

ResolvedTemplate

)) {

6037 auto

*RD = dyn_cast<CXXRecordDecl>(FTD->getDeclContext());

6038 if

(!RD || !RD->isGenericLambda())

6054 if

(

auto

*TTP = dyn_cast<TemplateTypeParmDecl>(Param))

6055 return

TTP->hasTypeConstraint();

6072 if

(

auto

*NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param))

6073 return

NTTP->getType()->isInstantiationDependentType() ||

6074

NTTP->getType()->getContainedDeducedType();

6078 auto

*TTP = cast<TemplateTemplateParmDecl>(Param);

6081 "A DeducedTemplateName shouldn't escape partial ordering"

);

6092 auto

MangleTemplateParamListToString =

6094 unsigned

DepthOffset) {

6095

llvm::raw_svector_ostream Stream(Buffer);

6096

CXXNameMangler(

Mangler

.Context, Stream,

6097

WithTemplateDepthOffset{DepthOffset})

6098

.mangleTemplateParameterList(Params);

6101

MangleTemplateParamListToString(ParamTemplateHead,

6102

TTP->getTemplateParameters(), 0);

6106

MangleTemplateParamListToString(ArgTemplateHead,

6108

TTP->getTemplateParameters()->

getDepth

());

6109 return

ParamTemplateHead != ArgTemplateHead;

6119 return

{

true

nullptr

};

6124

assert(ParamIdx < ResolvedTemplate->getTemplateParameters()->size() &&

6125 "no parameter for argument"

);

6146 return

{

true

nullptr

};

6161 auto

*NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param);

6162 bool

NeedExactType = NTTP && NTTP->getType()->getContainedDeducedType();

6163 return

{NeedExactType,

nullptr

};

6175void

CXXNameMangler::mangleTemplateArgs(

TN,

6177 unsigned

NumTemplateArgs) {

6180

TemplateArgManglingInfo Info(*

this

, TN);

6181 for

(

unsigned

i = 0; i != NumTemplateArgs; ++i) {

6182

mangleTemplateArg(Info, i, TemplateArgs[i].

getArgument

());

6184

mangleRequiresClause(Info.getTrailingRequiresClauseToMangle());

6188void

CXXNameMangler::mangleTemplateArgs(

TN,

6192

TemplateArgManglingInfo Info(*

this

, TN);

6193 for

(

unsigned

i = 0, e = AL.

size

(); i != e; ++i) {

6194

mangleTemplateArg(Info, i, AL[i]);

6196

mangleRequiresClause(Info.getTrailingRequiresClauseToMangle());

6200void

CXXNameMangler::mangleTemplateArgs(

TN,

6204

TemplateArgManglingInfo Info(*

this

, TN);

6205 for

(

unsigned

i = 0; i != Args.size(); ++i) {

6206

mangleTemplateArg(Info, i, Args[i]);

6208

mangleRequiresClause(Info.getTrailingRequiresClauseToMangle());

6212void

CXXNameMangler::mangleTemplateArg(TemplateArgManglingInfo &Info,

6214

TemplateArgManglingInfo::Info ArgInfo = Info.getArgInfo(Index, A);

6217 if

(ArgInfo.TemplateParameterToMangle &&

6218

!isCompatibleWith(LangOptions::ClangABI::Ver17)) {

6225

mangleTemplateParamDecl(ArgInfo.TemplateParameterToMangle);

6228

mangleTemplateArg(A, ArgInfo.NeedExactType);

6231void

CXXNameMangler::mangleTemplateArg(

TemplateArgument

bool

NeedExactType) {

6241

llvm_unreachable(

"Cannot mangle NULL template argument"

);

6268 auto

*TPO = cast<TemplateParamObjectDecl>(

);

6269

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

6270

TPO->getValue(),

true

6277 if

(

->isCXXInstanceMember())

6280 else if

(

->getType()->isArrayType() &&

6283

!isCompatibleWith(LangOptions::ClangABI::Ver11))

6304 true

, NeedExactType);

6310

mangleTemplateArg(

, NeedExactType);

6316void

CXXNameMangler::mangleTemplateArgExpr(

const Expr

) {

6317 if

(!isCompatibleWith(LangOptions::ClangABI::Ver11)) {

6318

mangleExpression(

, UnknownArity,

true

);

6333 if

(

const DeclRefExpr

*DRE = dyn_cast<DeclRefExpr>(

)) {

6335 if

(isa<VarDecl>(

) || isa<FunctionDecl>(

)) {

6343

mangleExpression(

);

6356 switch

(

.getKind()) {

6364

assert(RD &&

"unexpected type for record value"

);

6373 if

(!FD->isUnnamedBitField() &&

6383

assert(RD &&

"unexpected type for union value"

);

6386 if

(!FD->isUnnamedBitField())

6397 for

(

unsigned

I = 0, N =

.getArrayInitializedElts(); I != N; ++I)

6405 for

(

unsigned

I = 0, N =

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

6412 return

.getInt();

6415 return V

.getFloat().isPosZero();

6418 return

.getFixedPoint().getValue();

6421 return V

.getComplexFloatReal().isPosZero() &&

6422 V

.getComplexFloatImag().isPosZero();

6425 return

.getComplexIntReal() && !

.getComplexIntImag();

6428 return V

.isNullPointer();

6431 return

.getMemberPointerDecl();

6434

llvm_unreachable(

"Unhandled APValue::ValueKind enum"

);

6441 T

= AT->getElementType();

6443

dyn_cast<FieldDecl>(

.getAsBaseOrMember().getPointer()))

6447

cast<CXXRecordDecl>(

.getAsBaseOrMember().getPointer()));

6488

Diags.

(UnionLoc, DiagID);

6495 bool

NeedExactType) {

6498 T

= getASTContext().getUnqualifiedArrayType(

, Quals);

6501 bool

IsPrimaryExpr =

true

;

6502 auto

NotPrimaryExpr = [&] {

6503 if

(TopLevel && IsPrimaryExpr)

6505

IsPrimaryExpr =

false

;

6509 switch

(

.getKind()) {

6518

llvm_unreachable(

"unexpected value kind in template argument"

);

6522

assert(RD &&

"unexpected type for record value"

);

6528

(Fields.back()->isUnnamedBitField() ||

6530 V

.getStructField(Fields.back()->getFieldIndex())))) {

6534 if

(Fields.empty()) {

6535 while

(!Bases.empty() &&

6537 V

.getStructBase(Bases.size() - 1)))

6538

Bases = Bases.drop_back();

6545 for

(

unsigned

I = 0, N = Bases.size(); I != N; ++I)

6546

mangleValueInTemplateArg(Bases[I].getType(),

.getStructBase(I),

false

);

6547 for

(

unsigned

I = 0, N = Fields.size(); I != N; ++I) {

6548 if

(Fields[I]->isUnnamedBitField())

6550

mangleValueInTemplateArg(Fields[I]->getType(),

6551 V

.getStructField(Fields[I]->getFieldIndex()),

6578

mangleSourceName(II);

6579

mangleValueInTemplateArg(FD->

(),

.getUnionValue(),

false

);

6593 unsigned

N =

.getArraySize();

6595

N =

.getArrayInitializedElts();

6600 for

(

unsigned

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

6601 const APValue

&Elem = I <

.getArrayInitializedElts()

6602

.getArrayInitializedElt(I)

6603

.getArrayFiller();

6604

mangleValueInTemplateArg(ElemT, Elem,

false

);

6616 unsigned

N =

.getVectorLength();

6619 for

(

unsigned

I = 0; I != N; ++I)

6620

mangleValueInTemplateArg(VT->

getElementType

(),

.getVectorElt(I),

false

);

6626

mangleIntegerLiteral(

.getInt());

6630

mangleFloatLiteral(

.getFloat());

6634

mangleFixedPointLiteral();

6642 if

.getComplexFloatReal().isPosZero() ||

6643

.getComplexFloatImag().isPosZero())

6645 if

.getComplexFloatImag().isPosZero())

6656 if

(

.getComplexIntReal().getBoolValue() ||

6657 V

.getComplexIntImag().getBoolValue())

6659 if

(

.getComplexIntImag().getBoolValue())

6668 "unexpected type for LValue template arg"

);

6670 if

(

.isNullPointer()) {

6671

mangleNullPointer(

);

6680 if

(Offset.isZero()) {

6692

Out << Offset.getQuantity() <<

'E'

;

6700 if

.hasLValuePath()) {

6716 bool

IsArrayToPointerDecayMangledAsDecl =

false

;

6717 if

(TopLevel && Ctx.

().getClangABICompat() <=

6718

LangOptions::ClangABI::Ver11) {

6720

IsArrayToPointerDecayMangledAsDecl =

6721

BType->

isArrayType

() &&

.getLValuePath().size() == 1 &&

6722 V

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

6726 if

((!

.getLValuePath().empty() ||

.isLValueOnePastTheEnd()) &&

6727

!IsArrayToPointerDecayMangledAsDecl) {

6744 if

(NeedExactType &&

6746

!isCompatibleWith(LangOptions::ClangABI::Ver11)) {

6766

mangleExpression(

);

6770

mangleType(

(TI.getType(), 0));

6773

llvm_unreachable(

"unexpected lvalue base kind in template argument"

);

6783

mangleNumber(

.getLValueOffset().getQuantity());

6790 if

.getLValueOffset().isZero())

6791

mangleNumber(

.getLValueOffset().getQuantity());

6795 bool

OnePastTheEnd =

.isLValueOnePastTheEnd();

6799 if

(

auto

*CAT = dyn_cast<ConstantArrayType>(AT))

6800

OnePastTheEnd |= CAT->getSize() ==

.getAsArrayIndex();

6801

TypeSoFar = AT->getElementType();

6803 const Decl

.getAsBaseOrMember().getPointer();

6804 if

(

auto

*FD = dyn_cast<FieldDecl>(

)) {

6829 if

.getMemberPointerDecl()) {

6830

mangleNullPointer(

);

6837 if

.getMemberPointerPath().empty()) {

6840

}

else if

(NeedExactType &&

6843 V

.getMemberPointerDecl()->getType()) &&

6844

!isCompatibleWith(LangOptions::ClangABI::Ver11)) {

6849

mangle(

.getMemberPointerDecl());

6851 if

.getMemberPointerPath().empty()) {

6854 if

(!Offset.isZero())

6855

mangleNumber(Offset.getQuantity());

6861 if

(TopLevel && !IsPrimaryExpr)

6865void

CXXNameMangler::mangleTemplateParameter(

unsigned

Depth,

unsigned

Index) {

6875

Depth += TemplateDepthOffset;

6877

Out <<

'L'

<< (Depth - 1) <<

'_'

;

6883void

CXXNameMangler::mangleSeqID(

unsigned

SeqID) {

6886

}

else if

(SeqID == 1) {

6896 for

(; SeqID != 0; SeqID /= 36) {

6897 unsigned C

= SeqID % 36;

6898

*I++ = (

< 10 ?

'0'

'A'

- 10);

6901

Out.write(I.base(), I - BufferRef.rbegin());

6906void

CXXNameMangler::mangleExistingSubstitution(

tname) {

6907 bool

result = mangleSubstitution(tname);

6908

assert(result &&

"no existing substitution for template name"

);

6914bool

CXXNameMangler::mangleSubstitution(

const NamedDecl

*ND) {

6916 if

(mangleStandardSubstitution(ND))

6920 return

mangleSubstitution(

reinterpret_cast<uintptr_t>

(ND));

6925 "mangleSubstitution(NestedNameSpecifier *) is only used for " 6926 "identifier nested name specifiers."

);

6928 return

mangleSubstitution(

reinterpret_cast<uintptr_t>

(NNS));

6938bool

CXXNameMangler::mangleSubstitution(

) {

6941 return

mangleSubstitution(RT->getDecl());

6946 return

mangleSubstitution(TypePtr);

6949bool

CXXNameMangler::mangleSubstitution(

Template) {

6951 return

mangleSubstitution(TD);

6954 return

mangleSubstitution(

6958bool

CXXNameMangler::mangleSubstitution(

uintptr_t

Ptr) {

6959

llvm::DenseMap<uintptr_t, unsigned>::iterator I = Substitutions.find(Ptr);

6960 if

(I == Substitutions.end())

6963 unsigned

SeqID = I->second;

6972bool

CXXNameMangler::isSpecializedAs(

S, llvm::StringRef Name,

6982

dyn_cast<ClassTemplateSpecializationDecl>(RT->

());

6986 if

(!isStdNamespace(Context.getEffectiveDeclContext(SD)))

6990 if

(TemplateArgs.

size

() != 1)

6993 if

(TemplateArgs[0].getAsType() != A)

7005bool

CXXNameMangler::isStdCharSpecialization(

7007 bool

HasAllocator) {

7012 if

(TemplateArgs.

size

() != (HasAllocator ? 3 : 2))

7015 QualType

A = TemplateArgs[0].getAsType();

7023 if

(!isSpecializedAs(TemplateArgs[1].getAsType(),

"char_traits"

, A))

7027

!isSpecializedAs(TemplateArgs[2].getAsType(),

"allocator"

, A))

7036bool

CXXNameMangler::mangleStandardSubstitution(

const NamedDecl

*ND) {

7038 if

(

const NamespaceDecl

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

7047 if

(!isStdNamespace(Context.getEffectiveDeclContext(TD)))

7068

dyn_cast<ClassTemplateSpecializationDecl>(ND)) {

7069 if

(!isStdNamespace(Context.getEffectiveDeclContext(SD)))

7078 if

(isStdCharSpecialization(SD,

"basic_string"

true

)) {

7085 if

(isStdCharSpecialization(SD,

"basic_istream"

false

)) {

7092 if

(isStdCharSpecialization(SD,

"basic_ostream"

false

)) {

7099 if

(isStdCharSpecialization(SD,

"basic_iostream"

false

)) {

7109void

CXXNameMangler::addSubstitution(

) {

7112

addSubstitution(RT->

());

7118

addSubstitution(TypePtr);

7121void

CXXNameMangler::addSubstitution(

Template) {

7123 return

addSubstitution(TD);

7129void

CXXNameMangler::addSubstitution(

uintptr_t

Ptr) {

7130

assert(!Substitutions.count(Ptr) &&

"Substitution already exists!"

);

7131

Substitutions[Ptr] = SeqID++;

7134void

CXXNameMangler::extendSubstitutions(CXXNameMangler*

) {

7135

assert(

->SeqID >= SeqID &&

"Must be superset of substitutions!"

);

7136 if

(

->SeqID > SeqID) {

7137

Substitutions.swap(

->Substitutions);

7138

SeqID =

->SeqID;

7143

CXXNameMangler::makeFunctionReturnTypeTags(

const FunctionDecl

*FD) {

7145 if

(DisableDerivedAbiTags)

7146 return

AbiTagList();

7148

llvm::raw_null_ostream NullOutStream;

7149

CXXNameMangler TrackReturnTypeTags(*

this

, NullOutStream);

7150

TrackReturnTypeTags.disableDerivedAbiTags();

7154

FunctionTypeDepthState saved = TrackReturnTypeTags.FunctionTypeDepth.push();

7155

TrackReturnTypeTags.FunctionTypeDepth.enterResultType();

7157

TrackReturnTypeTags.FunctionTypeDepth.leaveResultType();

7158

TrackReturnTypeTags.FunctionTypeDepth.pop(saved);

7160 return

TrackReturnTypeTags.AbiTagsRoot.getSortedUniqueUsedAbiTags();

7164

CXXNameMangler::makeVariableTypeTags(

const VarDecl

*VD) {

7166 if

(DisableDerivedAbiTags)

7167 return

AbiTagList();

7169

llvm::raw_null_ostream NullOutStream;

7170

CXXNameMangler TrackVariableType(*

this

, NullOutStream);

7171

TrackVariableType.disableDerivedAbiTags();

7173

TrackVariableType.mangleType(VD->

());

7175 return

TrackVariableType.AbiTagsRoot.getSortedUniqueUsedAbiTags();

7178bool

CXXNameMangler::shouldHaveAbiTags(ItaniumMangleContextImpl &

7180

llvm::raw_null_ostream NullOutStream;

7181

CXXNameMangler TrackAbiTags(

, NullOutStream,

nullptr

true

);

7182

TrackAbiTags.mangle(VD);

7183 return

TrackAbiTags.AbiTagsRoot.getUsedAbiTags().size();

7196void

ItaniumMangleContextImpl::mangleCXXName(

GD,

7199

assert((isa<FunctionDecl, VarDecl, TemplateParamObjectDecl>(

)) &&

7200 "Invalid mangleName() call, argument is not a variable or function!"

);

7203

getASTContext().getSourceManager(),

7204 "Mangling declaration"

);

7206 if

(

auto

*CD = dyn_cast<CXXConstructorDecl>(

)) {

7208

CXXNameMangler Mangler(*

this

, Out, CD,

);

7212 if

(

auto

*DD = dyn_cast<CXXDestructorDecl>(

)) {

7214

CXXNameMangler Mangler(*

this

, Out, DD,

);

7218

CXXNameMangler Mangler(*

this

, Out,

);

7224

CXXNameMangler Mangler(*

this

, Out,

Ctor_Comdat

);

7230

CXXNameMangler Mangler(*

this

, Out,

Dtor_Comdat

);

7256 unsigned

TypedDiscriminator =

7258

Mangler.mangleVendorQualifier(

"__vtptrauth"

);

7259 auto

&ManglerStream = Mangler.getStream();

7260

ManglerStream <<

"I"

;

7261 if

(

const auto

*ExplicitAuth =

7262

PtrauthClassRD->

getAttr

<VTablePointerAuthenticationAttr>()) {

7263

ManglerStream <<

"Lj"

<< ExplicitAuth->getKey();

7265 if

(ExplicitAuth->getAddressDiscrimination() ==

7266

VTablePointerAuthenticationAttr::DefaultAddressDiscrimination)

7267

ManglerStream <<

"Lb"

<< LangOpts.PointerAuthVTPtrAddressDiscrimination;

7269

ManglerStream <<

"Lb" 7270

<< (ExplicitAuth->getAddressDiscrimination() ==

7271

VTablePointerAuthenticationAttr::AddressDiscrimination);

7273 switch

(ExplicitAuth->getExtraDiscrimination()) {

7274 case

VTablePointerAuthenticationAttr::DefaultExtraDiscrimination: {

7275 if

(LangOpts.PointerAuthVTPtrTypeDiscrimination)

7276

ManglerStream <<

"Lj"

<< TypedDiscriminator;

7278

ManglerStream <<

"Lj"

<< 0;

7281 case

VTablePointerAuthenticationAttr::TypeDiscrimination:

7282

ManglerStream <<

"Lj"

<< TypedDiscriminator;

7284 case

VTablePointerAuthenticationAttr::CustomDiscrimination:

7285

ManglerStream <<

"Lj"

<< ExplicitAuth->getCustomDiscriminationValue();

7287 case

VTablePointerAuthenticationAttr::NoExtraDiscrimination:

7288

ManglerStream <<

"Lj"

<< 0;

7292

ManglerStream <<

"Lj" 7293

<< (

unsigned

)VTablePointerAuthenticationAttr::DefaultKey;

7294

ManglerStream <<

"Lb"

<< LangOpts.PointerAuthVTPtrAddressDiscrimination;

7295 if

(LangOpts.PointerAuthVTPtrTypeDiscrimination)

7296

ManglerStream <<

"Lj"

<< TypedDiscriminator;

7298

ManglerStream <<

"Lj"

<< 0;

7300

ManglerStream <<

"E"

;

7303void

ItaniumMangleContextImpl::mangleThunk(

const CXXMethodDecl

*MD,

7305 bool

ElideOverrideInfo,

7314

assert(!isa<CXXDestructorDecl>(MD) &&

7315 "Use mangleCXXDtor for destructor decls!"

);

7316

CXXNameMangler Mangler(*

this

, Out);

7317

Mangler.getStream() <<

"_ZT"

;

7319

Mangler.getStream() <<

'c'

;

7330

Mangler.mangleFunctionEncoding(MD);

7331 if

(!ElideOverrideInfo)

7338 bool

ElideOverrideInfo,

7342

CXXNameMangler Mangler(*

this

, Out, DD,

);

7343

Mangler.getStream() <<

"_ZT"

;

7351 if

(!ElideOverrideInfo)

7356void

ItaniumMangleContextImpl::mangleStaticGuardVariable(

const VarDecl

7360

CXXNameMangler Mangler(*

this

, Out);

7363

Mangler.getStream() <<

"_ZGV"

;

7364

Mangler.mangleName(

);

7367void

ItaniumMangleContextImpl::mangleDynamicInitializer(

const VarDecl

*MD,

7372

Out <<

"__cxx_global_var_init"

;

7375void

ItaniumMangleContextImpl::mangleDynamicAtExitDestructor(

const VarDecl

7378

CXXNameMangler Mangler(*

this

, Out);

7379

Mangler.getStream() <<

"__dtor_"

;

7380 if

(shouldMangleDeclName(

))

7381

Mangler.mangle(

);

7383

Mangler.getStream() <<

->getName();

7386void

ItaniumMangleContextImpl::mangleDynamicStermFinalizer(

const VarDecl

7390

CXXNameMangler Mangler(*

this

, Out);

7391

Mangler.getStream() <<

"__finalize_"

;

7392 if

(shouldMangleDeclName(

))

7393

Mangler.mangle(

);

7395

Mangler.getStream() <<

->getName();

7398void

ItaniumMangleContextImpl::mangleSEHFilterExpression(

7399 GlobalDecl

EnclosingDecl, raw_ostream &Out) {

7400

CXXNameMangler Mangler(*

this

, Out);

7401

Mangler.getStream() <<

"__filt_"

;

7402 auto

*EnclosingFD = cast<FunctionDecl>(EnclosingDecl.

());

7403 if

(shouldMangleDeclName(EnclosingFD))

7404

Mangler.mangle(EnclosingDecl);

7406

Mangler.getStream() << EnclosingFD->getName();

7409void

ItaniumMangleContextImpl::mangleSEHFinallyBlock(

7410 GlobalDecl

EnclosingDecl, raw_ostream &Out) {

7411

CXXNameMangler Mangler(*

this

, Out);

7412

Mangler.getStream() <<

"__fin_"

;

7413 auto

*EnclosingFD = cast<FunctionDecl>(EnclosingDecl.

());

7414 if

(shouldMangleDeclName(EnclosingFD))

7415

Mangler.mangle(EnclosingDecl);

7417

Mangler.getStream() << EnclosingFD->getName();

7420void

ItaniumMangleContextImpl::mangleItaniumThreadLocalInit(

const VarDecl

7423

CXXNameMangler Mangler(*

this

, Out);

7424

Mangler.getStream() <<

"_ZTH"

;

7425

Mangler.mangleName(

);

7429

ItaniumMangleContextImpl::mangleItaniumThreadLocalWrapper(

const VarDecl

7432

CXXNameMangler Mangler(*

this

, Out);

7433

Mangler.getStream() <<

"_ZTW"

;

7434

Mangler.mangleName(

);

7437void

ItaniumMangleContextImpl::mangleReferenceTemporary(

const VarDecl

7438 unsigned

ManglingNumber,

7442

CXXNameMangler Mangler(*

this

, Out);

7443

Mangler.getStream() <<

"_ZGR"

;

7444

Mangler.mangleName(

);

7445

assert(ManglingNumber > 0 &&

"Reference temporary mangling number is zero!"

);

7446

Mangler.mangleSeqID(ManglingNumber - 1);

7449void

ItaniumMangleContextImpl::mangleCXXVTable(

const CXXRecordDecl

*RD,

7452

CXXNameMangler Mangler(*

this

, Out);

7453

Mangler.getStream() <<

"_ZTV"

;

7454

Mangler.mangleCXXRecordDecl(RD);

7457void

ItaniumMangleContextImpl::mangleCXXVTT(

const CXXRecordDecl

*RD,

7460

CXXNameMangler Mangler(*

this

, Out);

7461

Mangler.getStream() <<

"_ZTT"

;

7462

Mangler.mangleCXXRecordDecl(RD);

7465void

ItaniumMangleContextImpl::mangleCXXCtorVTable(

const CXXRecordDecl

*RD,

7470

CXXNameMangler Mangler(*

this

, Out);

7471

Mangler.getStream() <<

"_ZTC"

;

7472

Mangler.mangleCXXRecordDecl(RD);

7473

Mangler.getStream() << Offset;

7474

Mangler.getStream() <<

'_'

;

7475

Mangler.mangleCXXRecordDecl(

);

7478void

ItaniumMangleContextImpl::mangleCXXRTTI(