30using namespace ms_demangle;
69 if (MangledName[0] !=
'6' && MangledName[0] !=
'8') {
73 return (MangledName[0] ==
'8');
82 if (MangledName.
empty()) {
88 switch (MangledName.
front()) {
108 return SpecialIntrinsicKind::Vftable;
110 return SpecialIntrinsicKind::Vbtable;
112 return SpecialIntrinsicKind::VcallThunk;
114 return SpecialIntrinsicKind::Typeof;
116 return SpecialIntrinsicKind::LocalStaticGuard;
118 return SpecialIntrinsicKind::StringLiteralSymbol;
120 return SpecialIntrinsicKind::UdtReturning;
122 return SpecialIntrinsicKind::RttiTypeDescriptor;
124 return SpecialIntrinsicKind::RttiBaseClassDescriptor;
126 return SpecialIntrinsicKind::RttiBaseClassArray;
128 return SpecialIntrinsicKind::RttiClassHierarchyDescriptor;
130 return SpecialIntrinsicKind::RttiCompleteObjLocator;
132 return SpecialIntrinsicKind::LocalVftable;
134 return SpecialIntrinsicKind::DynamicInitializer;
136 return SpecialIntrinsicKind::DynamicAtexitDestructor;
138 return SpecialIntrinsicKind::LocalStaticThreadGuard;
139 return SpecialIntrinsicKind::None;
146 size_t End = S.
find(
'?');
150 if (Candidate.
empty())
155 if (Candidate.
size() == 1)
156 return Candidate[0] ==
'@' || (Candidate[0] >=
'0' && Candidate[0] <=
'9');
159 if (Candidate.
back() !=
'@')
169 if (Candidate[0] <
'B' || Candidate[0] >
'P')
172 while (!Candidate.
empty()) {
173 if (Candidate[0] <
'A' || Candidate[0] >
'P')
218 return FunctionRefQualifier::Reference;
220 return FunctionRefQualifier::RValueReference;
221 return FunctionRefQualifier::None;
224static std::pair<Qualifiers, PointerAffinity>
227 return std::make_pair(
Q_None, PointerAffinity::RValueReference);
231 return std::make_pair(
Q_None, PointerAffinity::Reference);
233 return std::make_pair(
Q_None, PointerAffinity::Pointer);
235 return std::make_pair(
Q_Const, PointerAffinity::Pointer);
237 return std::make_pair(
Q_Volatile, PointerAffinity::Pointer);
240 PointerAffinity::Pointer);
252 std::memcpy(Stable, Borrowed.
begin(), Borrowed.
size());
254 return {Stable, Borrowed.
size()};
258Demangler::demangleSpecialTableSymbolNode(
StringView &MangledName,
263 NI->
Name =
"`vftable'";
266 NI->
Name =
"`vbtable'";
269 NI->
Name =
"`local vftable'";
272 NI->
Name =
"`RTTI Complete Object Locator'";
281 if (MangledName.
empty()) {
285 char Front = MangledName.
popFront();
286 if (Front !=
'6' && Front !=
'7') {
291 std::tie(STSN->
Quals, IsMember) = demangleQualifiers(MangledName);
293 STSN->
TargetName = demangleFullyQualifiedTypeName(MangledName);
298Demangler::demangleLocalStaticGuard(
StringView &MangledName,
bool IsThread) {
316 if (!MangledName.
empty())
317 LSGI->
ScopeIndex = demangleUnsigned(MangledName);
367Demangler::demangleRttiBaseClassDescriptorNode(
ArenaAllocator &Arena,
371 RBCDN->
NVOffset = demangleUnsigned(MangledName);
374 RBCDN->
Flags = demangleUnsigned(MangledName);
379 VSN->
Name = demangleNameScopeChain(MangledName, RBCDN);
390 bool IsKnownStaticDataMember =
false;
392 IsKnownStaticDataMember =
true;
407 int AtCount = IsKnownStaticDataMember ? 2 : 1;
408 for (
int I = 0;
I < AtCount; ++
I) {
415 FSN = demangleFunctionEncoding(MangledName);
419 if (IsKnownStaticDataMember) {
440 return demangleStringLiteral(MangledName);
445 return demangleSpecialTableSymbolNode(MangledName, SIK);
447 return demangleVcallThunkNode(MangledName);
449 return demangleLocalStaticGuard(MangledName,
false);
451 return demangleLocalStaticGuard(MangledName,
true);
458 if (!MangledName.
empty())
463 return demangleUntypedVariable(Arena, MangledName,
464 "`RTTI Base Class Array'");
466 return demangleUntypedVariable(Arena, MangledName,
467 "`RTTI Class Hierarchy Descriptor'");
469 return demangleRttiBaseClassDescriptorNode(Arena, MangledName);
471 return demangleInitFiniStub(MangledName,
false);
473 return demangleInitFiniStub(MangledName,
true);
487Demangler::demangleFunctionIdentifierCode(
StringView &MangledName) {
490 if (MangledName.
empty()) {
496 return demangleFunctionIdentifierCode(
499 return demangleFunctionIdentifierCode(MangledName,
501 return demangleFunctionIdentifierCode(MangledName,
506Demangler::demangleStructorIdentifier(
StringView &MangledName,
509 N->IsDestructor = IsDestructor;
514Demangler::demangleConversionOperatorIdentifier(
StringView &MangledName) {
521Demangler::demangleLiteralOperatorIdentifier(
StringView &MangledName) {
524 N->Name = demangleSimpleString(MangledName,
false);
529Demangler::translateIntrinsicFunctionCode(
char CH,
532 if (!(
CH >=
'0' &&
CH <=
'9') && !(
CH >=
'A' &&
CH <=
'Z')) {
540 static IFK
Basic[36] = {
566 IFK::GreaterThanEqual,
578 static IFK
Under[36] = {
583 IFK::BitwiseAndEqual,
585 IFK::BitwiseXorEqual,
594 IFK::DefaultCtorClosure,
598 IFK::VecVbaseCtorIter,
602 IFK::EHVecVbaseCtorIter,
603 IFK::CopyCtorClosure,
608 IFK::LocalVftableCtorClosure,
627 IFK::ManVectorCtorIter,
628 IFK::ManVectorDtorIter,
629 IFK::EHVectorCopyCtorIter,
630 IFK::EHVectorVbaseCopyCtorIter,
633 IFK::VectorCopyCtorIter,
634 IFK::VectorVbaseCopyCtorIter,
635 IFK::ManVectorVbaseCopyCtorIter,
656 int Index = (
CH >=
'0' &&
CH <=
'9') ? (
CH -
'0') : (
CH -
'A' + 10);
669Demangler::demangleFunctionIdentifierCode(
StringView &MangledName,
671 if (MangledName.
empty()) {
680 return demangleStructorIdentifier(MangledName,
CH ==
'1');
682 return demangleConversionOperatorIdentifier(MangledName);
685 translateIntrinsicFunctionCode(
CH, Group));
689 translateIntrinsicFunctionCode(MangledName.
popFront(), Group));
693 return demangleLiteralOperatorIdentifier(MangledName);
696 translateIntrinsicFunctionCode(
CH, Group));
705 if (MangledName.
empty()) {
711 switch (MangledName.
front()) {
718 return demangleVariableEncoding(MangledName, SC);
762 size_t MD5Last = MangledName.
find(
'@', strlen(
"??@"));
767 const char *Start = MangledName.
begin();
768 MangledName = MangledName.
dropFront(MD5Last + 1);
806 if (MangledName.startsWith(
'.'))
807 return demangleTypeinfoName(MangledName);
809 if (MangledName.startsWith(
"??@"))
810 return demangleMD5Name(MangledName);
813 if (!MangledName.startsWith(
'?')) {
818 MangledName.consumeFront(
'?');
822 if (
SymbolNode *
SI = demangleSpecialIntrinsic(MangledName))
825 return demangleDeclarator(MangledName);
828TagTypeNode *Demangler::parseTagUniqueName(StringView &MangledName) {
829 if (!MangledName.consumeFront(
".?A")) {
833 MangledName.consumeFront(
".?A");
834 if (MangledName.empty()) {
839 return demangleClassType(MangledName);
867 demanglePointerExtQualifiers(MangledName));
869 bool IsMember =
false;
870 std::tie(ExtraChildQuals, IsMember) = demangleQualifiers(MangledName);
874 demangleFullyQualifiedTypeName(MangledName);
882 VSN->
Type->
Quals = demangleQualifiers(MangledName).first;
900std::pair<uint64_t, bool> Demangler::demangleNumber(
StringView &MangledName) {
906 return {
Ret, IsNegative};
910 for (
size_t i = 0; i < MangledName.
size(); ++i) {
911 char C = MangledName[i];
913 MangledName = MangledName.
dropFront(i + 1);
914 return {
Ret, IsNegative};
916 if (
'A' <=
C &&
C <=
'P') {
924 return {0ULL,
false};
928 bool IsNegative =
false;
930 std::tie(
Number, IsNegative) = demangleNumber(MangledName);
936int64_t Demangler::demangleSigned(
StringView &MangledName) {
937 bool IsNegative =
false;
939 std::tie(
Number, IsNegative) = demangleNumber(MangledName);
942 int64_t
I =
static_cast<int64_t
>(
Number);
943 return IsNegative ? -
I :
I;
951 for (
size_t i = 0; i < Backrefs.
NamesCount; ++i)
962 size_t I = MangledName[0] -
'0';
978 memorizeString(Owned);
979 std::free(
OB.getBuffer());
983Demangler::demangleTemplateInstantiationName(
StringView &MangledName,
992 demangleUnqualifiedSymbolName(MangledName,
NBB_Simple);
994 Identifier->TemplateParams = demangleTemplateParameterList(MangledName);
1018 StringView S = demangleSimpleString(MangledName, Memorize);
1031 return (
C <=
'J') ? (
C -
'A') : (10 +
C -
'K');
1034uint8_t Demangler::demangleCharLiteral(
StringView &MangledName) {
1040 if (MangledName.
empty())
1041 goto CharLiteralError;
1045 if (MangledName.
size() < 2)
1046 goto CharLiteralError;
1049 goto CharLiteralError;
1054 return (C1 << 4) | C2;
1058 const char *
Lookup =
",/\\:. \n\t'-";
1059 char C =
Lookup[MangledName[0] -
'0'];
1060 MangledName = MangledName.dropFront();
1064 if (MangledName[0] >=
'a' && MangledName[0] <=
'z') {
1065 char Lookup[26] = {
'\xE1',
'\xE2',
'\xE3',
'\xE4',
'\xE5',
'\xE6',
'\xE7',
1066 '\xE8',
'\xE9',
'\xEA',
'\xEB',
'\xEC',
'\xED',
'\xEE',
1067 '\xEF',
'\xF0',
'\xF1',
'\xF2',
'\xF3',
'\xF4',
'\xF5',
1068 '\xF6',
'\xF7',
'\xF8',
'\xF9',
'\xFA'};
1069 char C =
Lookup[MangledName[0] -
'a'];
1070 MangledName = MangledName.dropFront();
1074 if (MangledName[0] >=
'A' && MangledName[0] <=
'Z') {
1075 char Lookup[26] = {
'\xC1',
'\xC2',
'\xC3',
'\xC4',
'\xC5',
'\xC6',
'\xC7',
1076 '\xC8',
'\xC9',
'\xCA',
'\xCB',
'\xCC',
'\xCD',
'\xCE',
1077 '\xCF',
'\xD0',
'\xD1',
'\xD2',
'\xD3',
'\xD4',
'\xD5',
1078 '\xD6',
'\xD7',
'\xD8',
'\xD9',
'\xDA'};
1079 char C =
Lookup[MangledName[0] -
'A'];
1080 MangledName = MangledName.dropFront();
1089wchar_t Demangler::demangleWcharLiteral(
StringView &MangledName) {
1092 C1 = demangleCharLiteral(MangledName);
1094 goto WCharLiteralError;
1095 C2 = demangleCharLiteral(MangledName);
1097 goto WCharLiteralError;
1099 return ((
wchar_t)C1 << 8) | (wchar_t)C2;
1108 *Buffer = (Digit < 10) ? (
'0' + Digit) : (
'A' + Digit - 10);
1119 char TempBuffer[17];
1121 ::memset(TempBuffer, 0,
sizeof(TempBuffer));
1122 constexpr int MaxPos =
sizeof(TempBuffer) - 1;
1124 int Pos = MaxPos - 1;
1126 for (
int I = 0;
I < 2; ++
I) {
1131 TempBuffer[Pos--] =
'x';
1133 TempBuffer[Pos--] =
'\\';
1176 if (
C > 0x1F &&
C < 0x7F) {
1186 const uint8_t *End = StringBytes +
Length - 1;
1188 while (
Length > 0 && *End == 0) {
1200 if (*StringBytes++ == 0)
1214 if (NumBytes % 2 == 1)
1220 if (NumBytes < 32) {
1222 if (TrailingNulls >= 4 && NumBytes % 4 == 0)
1224 if (TrailingNulls >= 2)
1236 if (Nulls >= 2 * NumChars / 3 && NumBytes % 4 == 0)
1238 if (Nulls >= NumChars / 3)
1244 unsigned CharIndex,
unsigned CharBytes) {
1245 assert(CharBytes == 1 || CharBytes == 2 || CharBytes == 4);
1246 unsigned Offset = CharIndex * CharBytes;
1248 StringBytes = StringBytes +
Offset;
1249 for (
unsigned I = 0;
I < CharBytes; ++
I) {
1250 unsigned C =
static_cast<unsigned>(StringBytes[
I]);
1262 FSN->
Name = demangleNameScopeChain(MangledName, VTIN);
1266 VTIN->OffsetInVTable = demangleUnsigned(MangledName);
1271 return (
Error) ? nullptr : FSN;
1275Demangler::demangleStringLiteral(
StringView &MangledName) {
1280 bool IsWcharT =
false;
1281 bool IsNegative =
false;
1282 size_t CrcEndPos = 0;
1288 goto StringLiteralError;
1289 if (MangledName.
empty())
1290 goto StringLiteralError;
1300 goto StringLiteralError;
1304 std::tie(StringByteSize, IsNegative) = demangleNumber(MangledName);
1305 if (
Error || IsNegative || StringByteSize < (IsWcharT ? 2 : 1))
1306 goto StringLiteralError;
1309 CrcEndPos = MangledName.
find(
'@');
1311 goto StringLiteralError;
1312 CRC = MangledName.
substr(0, CrcEndPos);
1313 MangledName = MangledName.
dropFront(CrcEndPos + 1);
1314 if (MangledName.
empty())
1315 goto StringLiteralError;
1319 if (StringByteSize > 64)
1320 Result->IsTruncated =
true;
1323 if (MangledName.
size() < 2)
1324 goto StringLiteralError;
1325 wchar_t W = demangleWcharLiteral(MangledName);
1326 if (StringByteSize != 2 ||
Result->IsTruncated)
1328 StringByteSize -= 2;
1330 goto StringLiteralError;
1335 constexpr unsigned MaxStringByteLength = 32 * 4;
1336 uint8_t StringBytes[MaxStringByteLength];
1338 unsigned BytesDecoded = 0;
1340 if (MangledName.
size() < 1 || BytesDecoded >= MaxStringByteLength)
1341 goto StringLiteralError;
1342 StringBytes[BytesDecoded++] = demangleCharLiteral(MangledName);
1345 if (StringByteSize > BytesDecoded)
1346 Result->IsTruncated =
true;
1348 unsigned CharBytes =
1350 assert(StringByteSize % CharBytes == 0);
1351 switch (CharBytes) {
1364 const unsigned NumChars = BytesDecoded / CharBytes;
1365 for (
unsigned CharIndex = 0; CharIndex < NumChars; ++CharIndex) {
1368 if (CharIndex + 1 < NumChars ||
Result->IsTruncated)
1373 Result->DecodedString = copyString(OB);
1374 std::free(
OB.getBuffer());
1379 std::free(
OB.getBuffer());
1388 for (
size_t i = 0; i < MangledName.
size(); ++i) {
1389 if (MangledName[i] !=
'@')
1393 S = MangledName.
substr(0, i);
1394 MangledName = MangledName.
dropFront(i + 1);
1406Demangler::demangleAnonymousNamespaceName(
StringView &MangledName) {
1411 Node->Name =
"`anonymous namespace'";
1412 size_t EndPos = MangledName.
find(
'@');
1418 memorizeString(NamespaceKey);
1419 MangledName = MangledName.
substr(EndPos + 1);
1424Demangler::demangleLocallyScopedNamePiece(
StringView &MangledName) {
1430 bool IsNegative =
false;
1431 std::tie(
Number, IsNegative) = demangleNumber(MangledName);
1450 std::free(
OB.getBuffer());
1456Demangler::demangleFullyQualifiedTypeName(
StringView &MangledName) {
1458 demangleUnqualifiedTypeName(MangledName,
true);
1474Demangler::demangleFullyQualifiedSymbolName(
StringView &MangledName) {
1481 demangleUnqualifiedSymbolName(MangledName,
NBB_Simple);
1510 return demangleBackRefName(MangledName);
1513 return demangleTemplateInstantiationName(MangledName,
NBB_Template);
1515 return demangleSimpleName(MangledName, Memorize);
1519Demangler::demangleUnqualifiedSymbolName(
StringView &MangledName,
1522 return demangleBackRefName(MangledName);
1524 return demangleTemplateInstantiationName(MangledName, NBB);
1526 return demangleFunctionIdentifierCode(MangledName);
1527 return demangleSimpleName(MangledName, (NBB &
NBB_Simple) != 0);
1532 return demangleBackRefName(MangledName);
1535 return demangleTemplateInstantiationName(MangledName,
NBB_Template);
1538 return demangleAnonymousNamespaceName(MangledName);
1541 return demangleLocallyScopedNamePiece(MangledName);
1543 return demangleSimpleName(MangledName,
true);
1551 for (
size_t I = 0;
I < Count; ++
I) {
1552 N->Nodes[
I] = Head->
N;
1559Demangler::demangleNameScopeChain(
StringView &MangledName,
1563 Head->
N = UnqualifiedName;
1569 NewHead->
Next = Head;
1572 if (MangledName.
empty()) {
1650 if (MangledName.
empty())
1674 if (MangledName.
empty()) {
1730std::pair<Qualifiers, bool>
1731Demangler::demangleQualifiers(
StringView &MangledName) {
1732 if (MangledName.
empty()) {
1734 return std::make_pair(
Q_None,
false);
1740 return std::make_pair(
Q_None,
true);
1742 return std::make_pair(
Q_Const,
true);
1749 return std::make_pair(
Q_None,
false);
1751 return std::make_pair(
Q_Const,
false);
1758 return std::make_pair(
Q_None,
false);
1768 std::tie(Quals, IsMember) = demangleQualifiers(MangledName);
1771 std::tie(Quals, IsMember) = demangleQualifiers(MangledName);
1774 if (MangledName.
empty()) {
1781 Ty = demangleClassType(MangledName);
1784 Ty = demangleMemberPointerType(MangledName);
1786 Ty = demanglePointerType(MangledName);
1790 Ty = demangleArrayType(MangledName);
1793 Ty = demangleFunctionType(MangledName,
true);
1797 Ty = demangleFunctionType(MangledName,
false);
1800 Ty = demangleCustomType(MangledName);
1802 Ty = demanglePrimitiveType(MangledName);
1811bool Demangler::demangleThrowSpecification(
StringView &MangledName) {
1822 bool HasThisQuals) {
1826 FTy->
Quals = demanglePointerExtQualifiers(MangledName);
1842 FTy->
IsNoexcept = demangleThrowSpecification(MangledName);
1848Demangler::demangleFunctionEncoding(
StringView &MangledName) {
1853 if (MangledName.
empty()) {
1858 FuncClass FC = demangleFunctionClass(MangledName);
1883 FSN = demangleFunctionType(MangledName, HasThisQuals);
1905 CTN->
Identifier = demangleUnqualifiedTypeName(MangledName,
true);
1946 if (MangledName.
empty()) {
1997 TT->QualifiedName = demangleFullyQualifiedTypeName(MangledName);
2010 Pointer->Pointee = demangleFunctionType(MangledName,
false);
2014 Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName);
2028 Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName);
2034 Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName);
2035 Pointer->Pointee = demangleFunctionType(MangledName,
true);
2039 std::tie(PointeeQuals, IsMember) = demangleQualifiers(MangledName);
2041 Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName);
2045 Pointer->Pointee->Quals = PointeeQuals;
2068 bool IsNegative =
false;
2069 std::tie(Rank, IsNegative) = demangleNumber(MangledName);
2070 if (IsNegative || Rank == 0) {
2081 std::tie(
D, IsNegative) = demangleNumber(MangledName);
2082 if (
Error || IsNegative) {
2096 std::tie(ATy->
Quals, IsMember) = demangleQualifiers(MangledName);
2122 size_t N = MangledName[0] -
'0';
2131 Current = &(*Current)->Next;
2135 size_t OldSize = MangledName.
size();
2144 size_t CharsConsumed = OldSize - MangledName.
size();
2145 assert(CharsConsumed != 0);
2152 Current = &(*Current)->Next;
2174Demangler::demangleTemplateParameterList(
StringView &MangledName) {
2196 TP.N = demangleFullyQualifiedTypeName(MangledName);
2214 char InheritanceSpecifier = MangledName.
popFront();
2217 S =
parse(MangledName);
2225 switch (InheritanceSpecifier) {
2228 demangleSigned(MangledName);
2232 demangleSigned(MangledName);
2236 demangleSigned(MangledName);
2255 MangledName = MangledName.dropFront();
2256 char InheritanceSpecifier = MangledName.popFront();
2258 switch (InheritanceSpecifier) {
2261 demangleSigned(MangledName);
2265 demangleSigned(MangledName);
2267 demangleSigned(MangledName);
2274 }
else if (MangledName.consumeFront(
"$0")) {
2276 bool IsNegative =
false;
2278 std::tie(
Value, IsNegative) = demangleNumber(MangledName);
2295 assert(MangledName.startsWith(
'@'));
2296 MangledName.consumeFront(
'@');
2300void Demangler::dumpBackReferences() {
2301 std::printf(
"%d function parameter backreferences\n",
2307 OB.setCurrentPosition(0);
2313 std::printf(
" [%d] - %.*s\n", (
int)
I, (
int)
B.size(),
B.begin());
2315 std::free(OB.getBuffer());
2319 std::printf(
"%d name backreferences\n", (
int)Backrefs.
NamesCount);
2321 std::printf(
" [%d] - %.*s\n", (
int)
I, (
int)Backrefs.
Names[
I]->
Name.size(),
2329 char *Buf,
size_t *
N,
2333 StringView
Name{MangledName};
2335 if (!
D.Error && NMangled)
2336 *NMangled =
Name.begin() - MangledName;
2339 D.dumpBackReferences();
2357 OutputBuffer OB(Buf,
N);
2361 *
N = OB.getCurrentPosition();
2362 Buf = OB.getBuffer();
2366 *
Status = InternalStatus;
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
#define DEMANGLE_FALLTHROUGH
#define DEMANGLE_UNREACHABLE
static unsigned countEmbeddedNulls(const uint8_t *StringBytes, unsigned Length)
static SpecialIntrinsicKind consumeSpecialIntrinsicKind(StringView &MangledName)
static bool isPointerType(StringView S)
static NamedIdentifierNode * synthesizeNamedIdentifier(ArenaAllocator &Arena, StringView Name)
static QualifiedNameNode * synthesizeQualifiedName(ArenaAllocator &Arena, IdentifierNode *Identifier)
static bool startsWithDigit(StringView S)
static void outputEscapedChar(OutputBuffer &OB, unsigned C)
static bool startsWithLocalScopePattern(StringView S)
static bool isCustomType(StringView S)
static void outputHex(OutputBuffer &OB, unsigned C)
static std::pair< Qualifiers, PointerAffinity > demanglePointerCVQualifiers(StringView &MangledName)
static bool isFunctionType(StringView S)
static unsigned decodeMultiByteChar(const uint8_t *StringBytes, unsigned CharIndex, unsigned CharBytes)
static void writeHexDigit(char *Buffer, uint8_t Digit)
static bool isArrayType(StringView S)
static bool isRebasedHexDigit(char C)
static NodeArrayNode * nodeListToNodeArray(ArenaAllocator &Arena, NodeList *Head, size_t Count)
static bool isMemberPointer(StringView MangledName, bool &Error)
static FunctionRefQualifier demangleFunctionRefQualifier(StringView &MangledName)
static uint8_t rebasedHexDigitToNumber(char C)
static unsigned countTrailingNullBytes(const uint8_t *StringBytes, int Length)
static bool isTagType(StringView S)
static unsigned guessCharByteSize(const uint8_t *StringBytes, unsigned NumChars, uint64_t NumBytes)
static VariableSymbolNode * synthesizeVariable(ArenaAllocator &Arena, TypeNode *Type, StringView VariableName)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static bool isMemberPointer(uint32_t Attrs)
static int Lookup(ArrayRef< TableEntry > Table, unsigned Opcode)
StringView dropBack(size_t N=1) const
bool startsWith(char C) const
bool consumeFront(char C)
StringView substr(size_t Pos, size_t Len=npos) const
StringView dropFront(size_t N=1) const
const char * begin() const
size_t find(char C, size_t From=0) const
Lightweight error class with error context and mandatory checking.
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM Value Representation.
T * alloc(Args &&... ConstructorArgs)
char * allocUnalignedBuffer(size_t Size)
T * allocArray(size_t Count)
@ Tail
Attemps to make calls as fast as possible while guaranteeing that tail call optimization can always b...
@ C
The default llvm calling convention, compatible with C.
@ SC
CHAIN = SC CHAIN, Imm128 - System call.
Scope
Defines the scope in which this symbol should be visible: Default – Visible in the public interface o...
FunctionIdentifierCodeGroup
@ ConversionOperatorIdentifier
@ RttiBaseClassDescriptor
@ DynamicAtexitDestructor
@ RttiClassHierarchyDescriptor
This is an optimization pass for GlobalISel generic memory operations.
char * microsoftDemangle(const char *mangled_name, size_t *n_read, char *buf, size_t *n_buf, int *status, MSDemangleFlags Flags=MSDF_None)
Demangles the Microsoft symbol pointed at by mangled_name and returns it.
@ MSDF_NoCallingConvention
@ demangle_invalid_mangled_name
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
NodeArrayNode * Dimensions
static constexpr size_t Max
NamedIdentifierNode * Names[Max]
TypeNode * FunctionParams[Max]
size_t FunctionParamCount
IdentifierNode * Identifier
VariableSymbolNode * Variable
FunctionRefQualifier RefQualifier
CallingConv CallConvention
FunctionSignatureNode * Signature
QualifiedNameNode * ClassParent
IdentifierNode * getUnqualifiedIdentifier()
NodeArrayNode * Components
QualifiedNameNode * TargetName
void output(OutputBuffer &OB, OutputFlags Flags) const override
std::array< int64_t, 3 > ThunkOffsets