Lines Matching defs:MangledName
69 static bool isMemberPointer(std::string_view MangledName, bool &Error) {
71 const char F = MangledName.front();
72 MangledName.remove_prefix(1);
97 if (startsWithDigit(MangledName)) {
98 if (MangledName[0] != '6' && MangledName[0] != '8') {
102 return (MangledName[0] == '8');
107 consumeFront(MangledName, 'E'); // 64-bit
108 consumeFront(MangledName, 'I'); // restrict
109 consumeFront(MangledName, 'F'); // unaligned
111 if (MangledName.empty()) {
117 switch (MangledName.front()) {
135 consumeSpecialIntrinsicKind(std::string_view &MangledName) {
136 if (consumeFront(MangledName, "?_7"))
138 if (consumeFront(MangledName, "?_8"))
140 if (consumeFront(MangledName, "?_9"))
142 if (consumeFront(MangledName, "?_A"))
144 if (consumeFront(MangledName, "?_B"))
146 if (consumeFront(MangledName, "?_C"))
148 if (consumeFront(MangledName, "?_P"))
150 if (consumeFront(MangledName, "?_R0"))
152 if (consumeFront(MangledName, "?_R1"))
154 if (consumeFront(MangledName, "?_R2"))
156 if (consumeFront(MangledName, "?_R3"))
158 if (consumeFront(MangledName, "?_R4"))
160 if (consumeFront(MangledName, "?_S"))
162 if (consumeFront(MangledName, "?__E"))
164 if (consumeFront(MangledName, "?__F"))
166 if (consumeFront(MangledName, "?__J"))
246 demangleFunctionRefQualifier(std::string_view &MangledName) {
247 if (consumeFront(MangledName, 'G'))
249 else if (consumeFront(MangledName, 'H'))
255 demanglePointerCVQualifiers(std::string_view &MangledName) {
256 if (consumeFront(MangledName, "$$Q"))
259 const char F = MangledName.front();
260 MangledName.remove_prefix(1);
290 Demangler::demangleSpecialTableSymbolNode(std::string_view &MangledName,
309 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI);
313 if (MangledName.empty()) {
317 char Front = MangledName.front();
318 MangledName.remove_prefix(1);
324 std::tie(STSN->Quals, IsMember) = demangleQualifiers(MangledName);
325 if (!consumeFront(MangledName, '@'))
326 STSN->TargetName = demangleFullyQualifiedTypeName(MangledName);
331 Demangler::demangleLocalStaticGuard(std::string_view &MangledName,
336 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, LSGI);
341 if (consumeFront(MangledName, "4IA"))
343 else if (consumeFront(MangledName, "5"))
350 if (!MangledName.empty())
351 LSGI->ScopeIndex = demangleUnsigned(MangledName);
389 std::string_view &MangledName,
392 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI);
395 if (consumeFront(MangledName, "8"))
404 std::string_view &MangledName) {
407 RBCDN->NVOffset = demangleUnsigned(MangledName);
408 RBCDN->VBPtrOffset = demangleSigned(MangledName);
409 RBCDN->VBTableOffset = demangleUnsigned(MangledName);
410 RBCDN->Flags = demangleUnsigned(MangledName);
415 VSN->Name = demangleNameScopeChain(MangledName, RBCDN);
416 consumeFront(MangledName, '8');
421 Demangler::demangleInitFiniStub(std::string_view &MangledName,
428 if (consumeFront(MangledName, '?'))
431 SymbolNode *Symbol = demangleDeclarator(MangledName);
446 if (consumeFront(MangledName, '@'))
452 FSN = demangleFunctionEncoding(MangledName);
470 SymbolNode *Demangler::demangleSpecialIntrinsic(std::string_view &MangledName) {
471 SpecialIntrinsicKind SIK = consumeSpecialIntrinsicKind(MangledName);
477 return demangleStringLiteral(MangledName);
482 return demangleSpecialTableSymbolNode(MangledName, SIK);
484 return demangleVcallThunkNode(MangledName);
486 return demangleLocalStaticGuard(MangledName, /*IsThread=*/false);
488 return demangleLocalStaticGuard(MangledName, /*IsThread=*/true);
490 TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result);
493 if (!consumeFront(MangledName, "@8"))
495 if (!MangledName.empty())
500 return demangleUntypedVariable(Arena, MangledName,
503 return demangleUntypedVariable(Arena, MangledName,
506 return demangleRttiBaseClassDescriptorNode(Arena, MangledName);
508 return demangleInitFiniStub(MangledName, /*IsDestructor=*/false);
510 return demangleInitFiniStub(MangledName, /*IsDestructor=*/true);
524 Demangler::demangleFunctionIdentifierCode(std::string_view &MangledName) {
525 assert(llvm::itanium_demangle::starts_with(MangledName, '?'));
526 MangledName.remove_prefix(1);
527 if (MangledName.empty()) {
532 if (consumeFront(MangledName, "__"))
534 MangledName, FunctionIdentifierCodeGroup::DoubleUnder);
535 if (consumeFront(MangledName, "_"))
536 return demangleFunctionIdentifierCode(MangledName,
538 return demangleFunctionIdentifierCode(MangledName,
543 Demangler::demangleStructorIdentifier(std::string_view &MangledName,
551 Demangler::demangleConversionOperatorIdentifier(std::string_view &MangledName) {
558 Demangler::demangleLiteralOperatorIdentifier(std::string_view &MangledName) {
561 N->Name = demangleSimpleString(MangledName, /*Memorize=*/false);
706 Demangler::demangleFunctionIdentifierCode(std::string_view &MangledName,
708 if (MangledName.empty()) {
712 const char CH = MangledName.front();
715 MangledName.remove_prefix(1);
719 return demangleStructorIdentifier(MangledName, CH == '1');
721 return demangleConversionOperatorIdentifier(MangledName);
727 MangledName.remove_prefix(1);
731 MangledName.remove_prefix(1);
734 return demangleLiteralOperatorIdentifier(MangledName);
744 SymbolNode *Demangler::demangleEncodedSymbol(std::string_view &MangledName,
746 if (MangledName.empty()) {
752 switch (MangledName.front()) {
758 StorageClass SC = demangleVariableStorageClass(MangledName);
759 return demangleVariableEncoding(MangledName, SC);
762 FunctionSymbolNode *FSN = demangleFunctionEncoding(MangledName);
774 SymbolNode *Demangler::demangleDeclarator(std::string_view &MangledName) {
777 QualifiedNameNode *QN = demangleFullyQualifiedSymbolName(MangledName);
781 SymbolNode *Symbol = demangleEncodedSymbol(MangledName, QN);
798 SymbolNode *Demangler::demangleMD5Name(std::string_view &MangledName) {
799 assert(llvm::itanium_demangle::starts_with(MangledName, "??@"));
803 size_t MD5Last = MangledName.find('@', strlen("??@"));
808 const char *Start = MangledName.data();
809 const size_t StartSize = MangledName.size();
810 MangledName.remove_prefix(MD5Last + 1);
822 consumeFront(MangledName, "??_R4@");
824 assert(MangledName.size() < StartSize);
825 const size_t Count = StartSize - MangledName.size();
833 SymbolNode *Demangler::demangleTypeinfoName(std::string_view &MangledName) {
834 assert(llvm::itanium_demangle::starts_with(MangledName, '.'));
835 consumeFront(MangledName, '.');
837 TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result);
838 if (Error || !MangledName.empty()) {
846 SymbolNode *Demangler::parse(std::string_view &MangledName) {
850 if (llvm::itanium_demangle::starts_with(MangledName, '.'))
851 return demangleTypeinfoName(MangledName);
853 if (llvm::itanium_demangle::starts_with(MangledName, "??@"))
854 return demangleMD5Name(MangledName);
857 if (!llvm::itanium_demangle::starts_with(MangledName, '?')) {
862 consumeFront(MangledName, '?');
866 if (SymbolNode *SI = demangleSpecialIntrinsic(MangledName))
869 return demangleDeclarator(MangledName);
872 TagTypeNode *Demangler::parseTagUniqueName(std::string_view &MangledName) {
873 if (!consumeFront(MangledName, ".?A")) {
877 consumeFront(MangledName, ".?A");
878 if (MangledName.empty()) {
883 return demangleClassType(MangledName);
894 Demangler::demangleVariableEncoding(std::string_view &MangledName,
898 VSN->Type = demangleType(MangledName, QualifierMangleMode::Drop);
912 demanglePointerExtQualifiers(MangledName));
915 std::tie(ExtraChildQuals, IsMember) = demangleQualifiers(MangledName);
919 demangleFullyQualifiedTypeName(MangledName);
927 VSN->Type->Quals = demangleQualifiers(MangledName).first;
946 Demangler::demangleNumber(std::string_view &MangledName) {
947 bool IsNegative = consumeFront(MangledName, '?');
949 if (startsWithDigit(MangledName)) {
950 uint64_t Ret = MangledName[0] - '0' + 1;
951 MangledName.remove_prefix(1);
956 for (size_t i = 0; i < MangledName.size(); ++i) {
957 char C = MangledName[i];
959 MangledName.remove_prefix(i + 1);
973 uint64_t Demangler::demangleUnsigned(std::string_view &MangledName) {
976 std::tie(Number, IsNegative) = demangleNumber(MangledName);
982 int64_t Demangler::demangleSigned(std::string_view &MangledName) {
985 std::tie(Number, IsNegative) = demangleNumber(MangledName);
1006 Demangler::demangleBackRefName(std::string_view &MangledName) {
1007 assert(startsWithDigit(MangledName));
1009 size_t I = MangledName[0] - '0';
1015 MangledName.remove_prefix(1);
1030 Demangler::demangleTemplateInstantiationName(std::string_view &MangledName,
1032 assert(llvm::itanium_demangle::starts_with(MangledName, "?$"));
1033 consumeFront(MangledName, "?$");
1039 demangleUnqualifiedSymbolName(MangledName, NBB_Simple);
1041 Identifier->TemplateParams = demangleTemplateParameterList(MangledName);
1064 Demangler::demangleSimpleName(std::string_view &MangledName, bool Memorize) {
1065 std::string_view S = demangleSimpleString(MangledName, Memorize);
1081 uint8_t Demangler::demangleCharLiteral(std::string_view &MangledName) {
1082 assert(!MangledName.empty());
1083 if (!llvm::itanium_demangle::starts_with(MangledName, '?')) {
1084 const uint8_t F = MangledName.front();
1085 MangledName.remove_prefix(1);
1089 MangledName.remove_prefix(1);
1090 if (MangledName.empty())
1093 if (consumeFront(MangledName, '$')) {
1095 if (MangledName.size() < 2)
1097 std::string_view Nibbles = MangledName.substr(0, 2);
1103 MangledName.remove_prefix(2);
1107 if (startsWithDigit(MangledName)) {
1109 char C = Lookup[MangledName[0] - '0'];
1110 MangledName.remove_prefix(1);
1114 if (MangledName[0] >= 'a' && MangledName[0] <= 'z') {
1119 char C = Lookup[MangledName[0] - 'a'];
1120 MangledName.remove_prefix(1);
1124 if (MangledName[0] >= 'A' && MangledName[0] <= 'Z') {
1129 char C = Lookup[MangledName[0] - 'A'];
1130 MangledName.remove_prefix(1);
1139 wchar_t Demangler::demangleWcharLiteral(std::string_view &MangledName) {
1142 C1 = demangleCharLiteral(MangledName);
1143 if (Error || MangledName.empty())
1145 C2 = demangleCharLiteral(MangledName);
1307 Demangler::demangleVcallThunkNode(std::string_view &MangledName) {
1313 FSN->Name = demangleNameScopeChain(MangledName, VTIN);
1315 Error = !consumeFront(MangledName, "$B");
1317 VTIN->OffsetInVTable = demangleUnsigned(MangledName);
1319 Error = !consumeFront(MangledName, 'A');
1321 FSN->Signature->CallConvention = demangleCallingConvention(MangledName);
1326 Demangler::demangleStringLiteral(std::string_view &MangledName) {
1339 if (!consumeFront(MangledName, "@_"))
1341 if (MangledName.empty())
1345 F = MangledName.front();
1346 MangledName.remove_prefix(1);
1358 std::tie(StringByteSize, IsNegative) = demangleNumber(MangledName);
1363 CrcEndPos = MangledName.find('@');
1366 CRC = MangledName.substr(0, CrcEndPos);
1367 MangledName.remove_prefix(CrcEndPos + 1);
1368 if (MangledName.empty())
1376 while (!consumeFront(MangledName, '@')) {
1377 if (MangledName.size() < 2)
1379 wchar_t W = demangleWcharLiteral(MangledName);
1393 while (!consumeFront(MangledName, '@')) {
1394 if (MangledName.size() < 1 || BytesDecoded >= MaxStringByteLength)
1396 StringBytes[BytesDecoded++] = demangleCharLiteral(MangledName);
1437 // Returns MangledName's prefix before the first '@', or an error if
1438 // MangledName contains no '@' or the prefix has length 0.
1439 std::string_view Demangler::demangleSimpleString(std::string_view &MangledName,
1442 for (size_t i = 0; i < MangledName.size(); ++i) {
1443 if (MangledName[i] != '@')
1447 S = MangledName.substr(0, i);
1448 MangledName.remove_prefix(i + 1);
1460 Demangler::demangleAnonymousNamespaceName(std::string_view &MangledName) {
1461 assert(llvm::itanium_demangle::starts_with(MangledName, "?A"));
1462 consumeFront(MangledName, "?A");
1466 size_t EndPos = MangledName.find('@');
1471 std::string_view NamespaceKey = MangledName.substr(0, EndPos);
1473 MangledName = MangledName.substr(EndPos + 1);
1478 Demangler::demangleLocallyScopedNamePiece(std::string_view &MangledName) {
1479 assert(startsWithLocalScopePattern(MangledName));
1482 consumeFront(MangledName, '?');
1485 std::tie(Number, IsNegative) = demangleNumber(MangledName);
1489 consumeFront(MangledName, '?');
1492 Node *Scope = parse(MangledName);
1510 Demangler::demangleFullyQualifiedTypeName(std::string_view &MangledName) {
1512 demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true);
1517 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, Identifier);
1528 Demangler::demangleFullyQualifiedSymbolName(std::string_view &MangledName) {
1535 demangleUnqualifiedSymbolName(MangledName, NBB_Simple);
1539 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, Identifier);
1558 Demangler::demangleUnqualifiedTypeName(std::string_view &MangledName,
1564 if (startsWithDigit(MangledName))
1565 return demangleBackRefName(MangledName);
1567 if (llvm::itanium_demangle::starts_with(MangledName, "?$"))
1568 return demangleTemplateInstantiationName(MangledName, NBB_Template);
1570 return demangleSimpleName(MangledName, Memorize);
1574 Demangler::demangleUnqualifiedSymbolName(std::string_view &MangledName,
1576 if (startsWithDigit(MangledName))
1577 return demangleBackRefName(MangledName);
1578 if (llvm::itanium_demangle::starts_with(MangledName, "?$"))
1579 return demangleTemplateInstantiationName(MangledName, NBB);
1580 if (llvm::itanium_demangle::starts_with(MangledName, '?'))
1581 return demangleFunctionIdentifierCode(MangledName);
1582 return demangleSimpleName(MangledName, /*Memorize=*/(NBB & NBB_Simple) != 0);
1586 Demangler::demangleNameScopePiece(std::string_view &MangledName) {
1587 if (startsWithDigit(MangledName))
1588 return demangleBackRefName(MangledName);
1590 if (llvm::itanium_demangle::starts_with(MangledName, "?$"))
1591 return demangleTemplateInstantiationName(MangledName, NBB_Template);
1593 if (llvm::itanium_demangle::starts_with(MangledName, "?A"))
1594 return demangleAnonymousNamespaceName(MangledName);
1596 if (startsWithLocalScopePattern(MangledName))
1597 return demangleLocallyScopedNamePiece(MangledName);
1599 return demangleSimpleName(MangledName, /*Memorize=*/true);
1615 Demangler::demangleNameScopeChain(std::string_view &MangledName,
1622 while (!consumeFront(MangledName, "@")) {
1628 if (MangledName.empty()) {
1634 IdentifierNode *Elem = demangleNameScopePiece(MangledName);
1646 FuncClass Demangler::demangleFunctionClass(std::string_view &MangledName) {
1647 const char F = MangledName.front();
1648 MangledName.remove_prefix(1);
1706 if (consumeFront(MangledName, 'R'))
1708 if (MangledName.empty())
1710 const char F = MangledName.front();
1711 MangledName.remove_prefix(1);
1734 Demangler::demangleCallingConvention(std::string_view &MangledName) {
1735 if (MangledName.empty()) {
1740 const char F = MangledName.front();
1741 MangledName.remove_prefix(1);
1776 Demangler::demangleVariableStorageClass(std::string_view &MangledName) {
1777 assert(MangledName.front() >= '0' && MangledName.front() <= '4');
1779 const char F = MangledName.front();
1780 MangledName.remove_prefix(1);
1797 Demangler::demangleQualifiers(std::string_view &MangledName) {
1798 if (MangledName.empty()) {
1803 const char F = MangledName.front();
1804 MangledName.remove_prefix(1);
1831 TypeNode *Demangler::demangleType(std::string_view &MangledName,
1836 std::tie(Quals, IsMember) = demangleQualifiers(MangledName);
1838 if (consumeFront(MangledName, '?'))
1839 std::tie(Quals, IsMember) = demangleQualifiers(MangledName);
1842 if (MangledName.empty()) {
1848 if (isTagType(MangledName))
1849 Ty = demangleClassType(MangledName);
1850 else if (isPointerType(MangledName)) {
1851 if (isMemberPointer(MangledName, Error))
1852 Ty = demangleMemberPointerType(MangledName);
1854 Ty = demanglePointerType(MangledName);
1857 } else if (isArrayType(MangledName))
1858 Ty = demangleArrayType(MangledName);
1859 else if (isFunctionType(MangledName)) {
1860 if (consumeFront(MangledName, "$$A8@@"))
1861 Ty = demangleFunctionType(MangledName, true);
1863 assert(llvm::itanium_demangle::starts_with(MangledName, "$$A6"));
1864 consumeFront(MangledName, "$$A6");
1865 Ty = demangleFunctionType(MangledName, false);
1867 } else if (isCustomType(MangledName)) {
1868 Ty = demangleCustomType(MangledName);
1870 Ty = demanglePrimitiveType(MangledName);
1879 bool Demangler::demangleThrowSpecification(std::string_view &MangledName) {
1880 if (consumeFront(MangledName, "_E"))
1882 if (consumeFront(MangledName, 'Z'))
1890 Demangler::demangleFunctionType(std::string_view &MangledName,
1895 FTy->Quals = demanglePointerExtQualifiers(MangledName);
1896 FTy->RefQualifier = demangleFunctionRefQualifier(MangledName);
1897 FTy->Quals = Qualifiers(FTy->Quals | demangleQualifiers(MangledName).first);
1901 FTy->CallConvention = demangleCallingConvention(MangledName);
1905 bool IsStructor = consumeFront(MangledName, '@');
1907 FTy->ReturnType = demangleType(MangledName, QualifierMangleMode::Result);
1909 FTy->Params = demangleFunctionParameterList(MangledName, FTy->IsVariadic);
1911 FTy->IsNoexcept = demangleThrowSpecification(MangledName);
1917 Demangler::demangleFunctionEncoding(std::string_view &MangledName) {
1919 if (consumeFront(MangledName, "$$J0"))
1922 if (MangledName.empty()) {
1927 FuncClass FC = demangleFunctionClass(MangledName);
1934 TTN->ThisAdjust.StaticOffset = demangleSigned(MangledName);
1938 TTN->ThisAdjust.VBPtrOffset = demangleSigned(MangledName);
1939 TTN->ThisAdjust.VBOffsetOffset = demangleSigned(MangledName);
1941 TTN->ThisAdjust.VtordispOffset = demangleSigned(MangledName);
1942 TTN->ThisAdjust.StaticOffset = demangleSigned(MangledName);
1952 FSN = demangleFunctionType(MangledName, HasThisQuals);
1969 CustomTypeNode *Demangler::demangleCustomType(std::string_view &MangledName) {
1970 assert(llvm::itanium_demangle::starts_with(MangledName, '?'));
1971 MangledName.remove_prefix(1);
1974 CTN->Identifier = demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true);
1975 if (!consumeFront(MangledName, '@'))
1984 Demangler::demanglePrimitiveType(std::string_view &MangledName) {
1985 if (consumeFront(MangledName, "$$T"))
1988 const char F = MangledName.front();
1989 MangledName.remove_prefix(1);
2018 if (MangledName.empty()) {
2022 const char F = MangledName.front();
2023 MangledName.remove_prefix(1);
2051 TagTypeNode *Demangler::demangleClassType(std::string_view &MangledName) {
2054 const char F = MangledName.front();
2055 MangledName.remove_prefix(1);
2067 if (!consumeFront(MangledName, '4')) {
2077 TT->QualifiedName = demangleFullyQualifiedTypeName(MangledName);
2083 PointerTypeNode *Demangler::demanglePointerType(std::string_view &MangledName) {
2087 demanglePointerCVQualifiers(MangledName);
2089 if (consumeFront(MangledName, "6")) {
2090 Pointer->Pointee = demangleFunctionType(MangledName, false);
2094 Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName);
2097 Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Mangle);
2102 Demangler::demangleMemberPointerType(std::string_view &MangledName) {
2106 demanglePointerCVQualifiers(MangledName);
2109 Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName);
2114 if (consumeFront(MangledName, "8")) {
2115 Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName);
2116 Pointer->Pointee = demangleFunctionType(MangledName, true);
2120 std::tie(PointeeQuals, IsMember) = demangleQualifiers(MangledName);
2122 Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName);
2124 Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Drop);
2133 Demangler::demanglePointerExtQualifiers(std::string_view &MangledName) {
2135 if (consumeFront(MangledName, 'E'))
2137 if (consumeFront(MangledName, 'I'))
2139 if (consumeFront(MangledName, 'F'))
2145 ArrayTypeNode *Demangler::demangleArrayType(std::string_view &MangledName) {
2146 assert(MangledName.front() == 'Y');
2147 MangledName.remove_prefix(1);
2151 std::tie(Rank, IsNegative) = demangleNumber(MangledName);
2163 std::tie(D, IsNegative) = demangleNumber(MangledName);
2176 if (consumeFront(MangledName, "$$C")) {
2178 std::tie(ATy->Quals, IsMember) = demangleQualifiers(MangledName);
2185 ATy->ElementType = demangleType(MangledName, QualifierMangleMode::Drop);
2191 Demangler::demangleFunctionParameterList(std::string_view &MangledName,
2194 if (consumeFront(MangledName, 'X'))
2200 while (!Error && !llvm::itanium_demangle::starts_with(MangledName, '@') &&
2201 !llvm::itanium_demangle::starts_with(MangledName, 'Z')) {
2204 if (startsWithDigit(MangledName)) {
2205 size_t N = MangledName[0] - '0';
2210 MangledName.remove_prefix(1);
2218 size_t OldSize = MangledName.size();
2221 TypeNode *TN = demangleType(MangledName, QualifierMangleMode::Drop);
2227 size_t CharsConsumed = OldSize - MangledName.size();
2245 if (consumeFront(MangledName, '@'))
2248 if (consumeFront(MangledName, 'Z')) {
2257 Demangler::demangleTemplateParameterList(std::string_view &MangledName) {
2262 while (!llvm::itanium_demangle::starts_with(MangledName, '@')) {
2263 if (consumeFront(MangledName, "$S") || consumeFront(MangledName, "$$V") ||
2264 consumeFront(MangledName, "$$$V") || consumeFront(MangledName, "$$Z")) {
2277 const bool IsAutoNTTP = consumeFront(MangledName, "$M");
2283 (void)demangleType(MangledName, QualifierMangleMode::Drop);
2289 if (consumeFront(MangledName, "$$Y")) {
2291 TP.N = demangleFullyQualifiedTypeName(MangledName);
2292 } else if (consumeFront(MangledName, "$$B")) {
2294 TP.N = demangleType(MangledName, QualifierMangleMode::Drop);
2295 } else if (consumeFront(MangledName, "$$C")) {
2297 TP.N = demangleType(MangledName, QualifierMangleMode::Mangle);
2298 } else if (startsWith(MangledName, "$1", "1", !IsAutoNTTP) ||
2299 startsWith(MangledName, "$H", "H", !IsAutoNTTP) ||
2300 startsWith(MangledName, "$I", "I", !IsAutoNTTP) ||
2301 startsWith(MangledName, "$J", "J", !IsAutoNTTP)) {
2307 MangledName.remove_prefix(1); // Remove leading '$'
2313 char InheritanceSpecifier = MangledName.front();
2314 MangledName.remove_prefix(1);
2316 if (llvm::itanium_demangle::starts_with(MangledName, '?')) {
2317 S = parse(MangledName);
2328 demangleSigned(MangledName);
2332 demangleSigned(MangledName);
2336 demangleSigned(MangledName);
2345 } else if (llvm::itanium_demangle::starts_with(MangledName, "$E?")) {
2346 consumeFront(MangledName, "$E");
2349 TPRN->Symbol = parse(MangledName);
2351 } else if (startsWith(MangledName, "$F", "F", !IsAutoNTTP) ||
2352 startsWith(MangledName, "$G", "G", !IsAutoNTTP)) {
2357 MangledName.remove_prefix(1); // Remove leading '$'
2358 char InheritanceSpecifier = MangledName.front();
2359 MangledName.remove_prefix(1);
2364 demangleSigned(MangledName);
2368 demangleSigned(MangledName);
2370 demangleSigned(MangledName);
2377 } else if (consumeFront(MangledName, "$0", "0", !IsAutoNTTP)) {
2381 std::tie(Value, IsNegative) = demangleNumber(MangledName);
2385 TP.N = demangleType(MangledName, QualifierMangleMode::Drop);
2399 MangledName, '@')); // The above loop exits only on '@'.
2400 consumeFront(MangledName, '@');
2433 llvm::getArm64ECInsertionPointInMangledName(std::string_view MangledName) {
2434 std::string_view ProcessedName{MangledName};
2447 return MangledName.length() - ProcessedName.length();
2450 char *llvm::microsoftDemangle(std::string_view MangledName, size_t *NMangled,
2454 std::string_view Name{MangledName};
2457 *NMangled = MangledName.size() - Name.size();