1 //===- MicrosoftDemangle.cpp ----------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines a demangler for MSVC-style mangled symbols. 10 // 11 // This file has no dependencies on the rest of LLVM so that it can be 12 // easily reused in other programs such as libcxxabi. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "llvm/Demangle/MicrosoftDemangle.h" 17 18 #include "llvm/Demangle/Demangle.h" 19 #include "llvm/Demangle/DemangleConfig.h" 20 #include "llvm/Demangle/MicrosoftDemangleNodes.h" 21 #include "llvm/Demangle/StringViewExtras.h" 22 #include "llvm/Demangle/Utility.h" 23 24 #include <array> 25 #include <cctype> 26 #include <cstdio> 27 #include <string_view> 28 #include <tuple> 29 30 using namespace llvm; 31 using namespace ms_demangle; 32 33 static bool startsWithDigit(std::string_view S) { 34 return !S.empty() && std::isdigit(S.front()); 35 } 36 37 struct NodeList { 38 Node *N = nullptr; 39 NodeList *Next = nullptr; 40 }; 41 42 static bool consumeFront(std::string_view &S, char C) { 43 if (!llvm::itanium_demangle::starts_with(S, C)) 44 return false; 45 S.remove_prefix(1); 46 return true; 47 } 48 49 static bool consumeFront(std::string_view &S, std::string_view C) { 50 if (!llvm::itanium_demangle::starts_with(S, C)) 51 return false; 52 S.remove_prefix(C.size()); 53 return true; 54 } 55 56 static bool isMemberPointer(std::string_view MangledName, bool &Error) { 57 Error = false; 58 const char F = MangledName.front(); 59 MangledName.remove_prefix(1); 60 switch (F) { 61 case '$': 62 // This is probably an rvalue reference (e.g. $$Q), and you cannot have an 63 // rvalue reference to a member. 64 return false; 65 case 'A': 66 // 'A' indicates a reference, and you cannot have a reference to a member 67 // function or member. 68 return false; 69 case 'P': 70 case 'Q': 71 case 'R': 72 case 'S': 73 // These 4 values indicate some kind of pointer, but we still don't know 74 // what. 75 break; 76 default: 77 // isMemberPointer() is called only if isPointerType() returns true, 78 // and it rejects other prefixes. 79 DEMANGLE_UNREACHABLE; 80 } 81 82 // If it starts with a number, then 6 indicates a non-member function 83 // pointer, and 8 indicates a member function pointer. 84 if (startsWithDigit(MangledName)) { 85 if (MangledName[0] != '6' && MangledName[0] != '8') { 86 Error = true; 87 return false; 88 } 89 return (MangledName[0] == '8'); 90 } 91 92 // Remove ext qualifiers since those can appear on either type and are 93 // therefore not indicative. 94 consumeFront(MangledName, 'E'); // 64-bit 95 consumeFront(MangledName, 'I'); // restrict 96 consumeFront(MangledName, 'F'); // unaligned 97 98 if (MangledName.empty()) { 99 Error = true; 100 return false; 101 } 102 103 // The next value should be either ABCD (non-member) or QRST (member). 104 switch (MangledName.front()) { 105 case 'A': 106 case 'B': 107 case 'C': 108 case 'D': 109 return false; 110 case 'Q': 111 case 'R': 112 case 'S': 113 case 'T': 114 return true; 115 default: 116 Error = true; 117 return false; 118 } 119 } 120 121 static SpecialIntrinsicKind 122 consumeSpecialIntrinsicKind(std::string_view &MangledName) { 123 if (consumeFront(MangledName, "?_7")) 124 return SpecialIntrinsicKind::Vftable; 125 if (consumeFront(MangledName, "?_8")) 126 return SpecialIntrinsicKind::Vbtable; 127 if (consumeFront(MangledName, "?_9")) 128 return SpecialIntrinsicKind::VcallThunk; 129 if (consumeFront(MangledName, "?_A")) 130 return SpecialIntrinsicKind::Typeof; 131 if (consumeFront(MangledName, "?_B")) 132 return SpecialIntrinsicKind::LocalStaticGuard; 133 if (consumeFront(MangledName, "?_C")) 134 return SpecialIntrinsicKind::StringLiteralSymbol; 135 if (consumeFront(MangledName, "?_P")) 136 return SpecialIntrinsicKind::UdtReturning; 137 if (consumeFront(MangledName, "?_R0")) 138 return SpecialIntrinsicKind::RttiTypeDescriptor; 139 if (consumeFront(MangledName, "?_R1")) 140 return SpecialIntrinsicKind::RttiBaseClassDescriptor; 141 if (consumeFront(MangledName, "?_R2")) 142 return SpecialIntrinsicKind::RttiBaseClassArray; 143 if (consumeFront(MangledName, "?_R3")) 144 return SpecialIntrinsicKind::RttiClassHierarchyDescriptor; 145 if (consumeFront(MangledName, "?_R4")) 146 return SpecialIntrinsicKind::RttiCompleteObjLocator; 147 if (consumeFront(MangledName, "?_S")) 148 return SpecialIntrinsicKind::LocalVftable; 149 if (consumeFront(MangledName, "?__E")) 150 return SpecialIntrinsicKind::DynamicInitializer; 151 if (consumeFront(MangledName, "?__F")) 152 return SpecialIntrinsicKind::DynamicAtexitDestructor; 153 if (consumeFront(MangledName, "?__J")) 154 return SpecialIntrinsicKind::LocalStaticThreadGuard; 155 return SpecialIntrinsicKind::None; 156 } 157 158 static bool startsWithLocalScopePattern(std::string_view S) { 159 if (!consumeFront(S, '?')) 160 return false; 161 162 size_t End = S.find('?'); 163 if (End == std::string_view::npos) 164 return false; 165 std::string_view Candidate = S.substr(0, End); 166 if (Candidate.empty()) 167 return false; 168 169 // \?[0-9]\? 170 // ?@? is the discriminator 0. 171 if (Candidate.size() == 1) 172 return Candidate[0] == '@' || (Candidate[0] >= '0' && Candidate[0] <= '9'); 173 174 // If it's not 0-9, then it's an encoded number terminated with an @ 175 if (Candidate.back() != '@') 176 return false; 177 Candidate.remove_suffix(1); 178 179 // An encoded number starts with B-P and all subsequent digits are in A-P. 180 // Note that the reason the first digit cannot be A is two fold. First, it 181 // would create an ambiguity with ?A which delimits the beginning of an 182 // anonymous namespace. Second, A represents 0, and you don't start a multi 183 // digit number with a leading 0. Presumably the anonymous namespace 184 // ambiguity is also why single digit encoded numbers use 0-9 rather than A-J. 185 if (Candidate[0] < 'B' || Candidate[0] > 'P') 186 return false; 187 Candidate.remove_prefix(1); 188 while (!Candidate.empty()) { 189 if (Candidate[0] < 'A' || Candidate[0] > 'P') 190 return false; 191 Candidate.remove_prefix(1); 192 } 193 194 return true; 195 } 196 197 static bool isTagType(std::string_view S) { 198 switch (S.front()) { 199 case 'T': // union 200 case 'U': // struct 201 case 'V': // class 202 case 'W': // enum 203 return true; 204 } 205 return false; 206 } 207 208 static bool isCustomType(std::string_view S) { return S[0] == '?'; } 209 210 static bool isPointerType(std::string_view S) { 211 if (llvm::itanium_demangle::starts_with(S, "$$Q")) // foo && 212 return true; 213 214 switch (S.front()) { 215 case 'A': // foo & 216 case 'P': // foo * 217 case 'Q': // foo *const 218 case 'R': // foo *volatile 219 case 'S': // foo *const volatile 220 return true; 221 } 222 return false; 223 } 224 225 static bool isArrayType(std::string_view S) { return S[0] == 'Y'; } 226 227 static bool isFunctionType(std::string_view S) { 228 return llvm::itanium_demangle::starts_with(S, "$$A8@@") || 229 llvm::itanium_demangle::starts_with(S, "$$A6"); 230 } 231 232 static FunctionRefQualifier 233 demangleFunctionRefQualifier(std::string_view &MangledName) { 234 if (consumeFront(MangledName, 'G')) 235 return FunctionRefQualifier::Reference; 236 else if (consumeFront(MangledName, 'H')) 237 return FunctionRefQualifier::RValueReference; 238 return FunctionRefQualifier::None; 239 } 240 241 static std::pair<Qualifiers, PointerAffinity> 242 demanglePointerCVQualifiers(std::string_view &MangledName) { 243 if (consumeFront(MangledName, "$$Q")) 244 return std::make_pair(Q_None, PointerAffinity::RValueReference); 245 246 const char F = MangledName.front(); 247 MangledName.remove_prefix(1); 248 switch (F) { 249 case 'A': 250 return std::make_pair(Q_None, PointerAffinity::Reference); 251 case 'P': 252 return std::make_pair(Q_None, PointerAffinity::Pointer); 253 case 'Q': 254 return std::make_pair(Q_Const, PointerAffinity::Pointer); 255 case 'R': 256 return std::make_pair(Q_Volatile, PointerAffinity::Pointer); 257 case 'S': 258 return std::make_pair(Qualifiers(Q_Const | Q_Volatile), 259 PointerAffinity::Pointer); 260 } 261 // This function is only called if isPointerType() returns true, 262 // and it only returns true for the six cases listed above. 263 DEMANGLE_UNREACHABLE; 264 } 265 266 std::string_view Demangler::copyString(std::string_view Borrowed) { 267 char *Stable = Arena.allocUnalignedBuffer(Borrowed.size()); 268 // This is not a micro-optimization, it avoids UB, should Borrowed be an null 269 // buffer. 270 if (Borrowed.size()) 271 std::memcpy(Stable, Borrowed.data(), Borrowed.size()); 272 273 return {Stable, Borrowed.size()}; 274 } 275 276 SpecialTableSymbolNode * 277 Demangler::demangleSpecialTableSymbolNode(std::string_view &MangledName, 278 SpecialIntrinsicKind K) { 279 NamedIdentifierNode *NI = Arena.alloc<NamedIdentifierNode>(); 280 switch (K) { 281 case SpecialIntrinsicKind::Vftable: 282 NI->Name = "`vftable'"; 283 break; 284 case SpecialIntrinsicKind::Vbtable: 285 NI->Name = "`vbtable'"; 286 break; 287 case SpecialIntrinsicKind::LocalVftable: 288 NI->Name = "`local vftable'"; 289 break; 290 case SpecialIntrinsicKind::RttiCompleteObjLocator: 291 NI->Name = "`RTTI Complete Object Locator'"; 292 break; 293 default: 294 DEMANGLE_UNREACHABLE; 295 } 296 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI); 297 SpecialTableSymbolNode *STSN = Arena.alloc<SpecialTableSymbolNode>(); 298 STSN->Name = QN; 299 bool IsMember = false; 300 if (MangledName.empty()) { 301 Error = true; 302 return nullptr; 303 } 304 char Front = MangledName.front(); 305 MangledName.remove_prefix(1); 306 if (Front != '6' && Front != '7') { 307 Error = true; 308 return nullptr; 309 } 310 311 std::tie(STSN->Quals, IsMember) = demangleQualifiers(MangledName); 312 if (!consumeFront(MangledName, '@')) 313 STSN->TargetName = demangleFullyQualifiedTypeName(MangledName); 314 return STSN; 315 } 316 317 LocalStaticGuardVariableNode * 318 Demangler::demangleLocalStaticGuard(std::string_view &MangledName, 319 bool IsThread) { 320 LocalStaticGuardIdentifierNode *LSGI = 321 Arena.alloc<LocalStaticGuardIdentifierNode>(); 322 LSGI->IsThread = IsThread; 323 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, LSGI); 324 LocalStaticGuardVariableNode *LSGVN = 325 Arena.alloc<LocalStaticGuardVariableNode>(); 326 LSGVN->Name = QN; 327 328 if (consumeFront(MangledName, "4IA")) 329 LSGVN->IsVisible = false; 330 else if (consumeFront(MangledName, "5")) 331 LSGVN->IsVisible = true; 332 else { 333 Error = true; 334 return nullptr; 335 } 336 337 if (!MangledName.empty()) 338 LSGI->ScopeIndex = demangleUnsigned(MangledName); 339 return LSGVN; 340 } 341 342 static NamedIdentifierNode *synthesizeNamedIdentifier(ArenaAllocator &Arena, 343 std::string_view Name) { 344 NamedIdentifierNode *Id = Arena.alloc<NamedIdentifierNode>(); 345 Id->Name = Name; 346 return Id; 347 } 348 349 static QualifiedNameNode *synthesizeQualifiedName(ArenaAllocator &Arena, 350 IdentifierNode *Identifier) { 351 QualifiedNameNode *QN = Arena.alloc<QualifiedNameNode>(); 352 QN->Components = Arena.alloc<NodeArrayNode>(); 353 QN->Components->Count = 1; 354 QN->Components->Nodes = Arena.allocArray<Node *>(1); 355 QN->Components->Nodes[0] = Identifier; 356 return QN; 357 } 358 359 static QualifiedNameNode *synthesizeQualifiedName(ArenaAllocator &Arena, 360 std::string_view Name) { 361 NamedIdentifierNode *Id = synthesizeNamedIdentifier(Arena, Name); 362 return synthesizeQualifiedName(Arena, Id); 363 } 364 365 static VariableSymbolNode *synthesizeVariable(ArenaAllocator &Arena, 366 TypeNode *Type, 367 std::string_view VariableName) { 368 VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>(); 369 VSN->Type = Type; 370 VSN->Name = synthesizeQualifiedName(Arena, VariableName); 371 return VSN; 372 } 373 374 VariableSymbolNode * 375 Demangler::demangleUntypedVariable(ArenaAllocator &Arena, 376 std::string_view &MangledName, 377 std::string_view VariableName) { 378 NamedIdentifierNode *NI = synthesizeNamedIdentifier(Arena, VariableName); 379 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI); 380 VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>(); 381 VSN->Name = QN; 382 if (consumeFront(MangledName, "8")) 383 return VSN; 384 385 Error = true; 386 return nullptr; 387 } 388 389 VariableSymbolNode * 390 Demangler::demangleRttiBaseClassDescriptorNode(ArenaAllocator &Arena, 391 std::string_view &MangledName) { 392 RttiBaseClassDescriptorNode *RBCDN = 393 Arena.alloc<RttiBaseClassDescriptorNode>(); 394 RBCDN->NVOffset = demangleUnsigned(MangledName); 395 RBCDN->VBPtrOffset = demangleSigned(MangledName); 396 RBCDN->VBTableOffset = demangleUnsigned(MangledName); 397 RBCDN->Flags = demangleUnsigned(MangledName); 398 if (Error) 399 return nullptr; 400 401 VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>(); 402 VSN->Name = demangleNameScopeChain(MangledName, RBCDN); 403 consumeFront(MangledName, '8'); 404 return VSN; 405 } 406 407 FunctionSymbolNode * 408 Demangler::demangleInitFiniStub(std::string_view &MangledName, 409 bool IsDestructor) { 410 DynamicStructorIdentifierNode *DSIN = 411 Arena.alloc<DynamicStructorIdentifierNode>(); 412 DSIN->IsDestructor = IsDestructor; 413 414 bool IsKnownStaticDataMember = false; 415 if (consumeFront(MangledName, '?')) 416 IsKnownStaticDataMember = true; 417 418 SymbolNode *Symbol = demangleDeclarator(MangledName); 419 if (Error) 420 return nullptr; 421 422 FunctionSymbolNode *FSN = nullptr; 423 424 if (Symbol->kind() == NodeKind::VariableSymbol) { 425 DSIN->Variable = static_cast<VariableSymbolNode *>(Symbol); 426 427 // Older versions of clang mangled this type of symbol incorrectly. They 428 // would omit the leading ? and they would only emit a single @ at the end. 429 // The correct mangling is a leading ? and 2 trailing @ signs. Handle 430 // both cases. 431 int AtCount = IsKnownStaticDataMember ? 2 : 1; 432 for (int I = 0; I < AtCount; ++I) { 433 if (consumeFront(MangledName, '@')) 434 continue; 435 Error = true; 436 return nullptr; 437 } 438 439 FSN = demangleFunctionEncoding(MangledName); 440 if (FSN) 441 FSN->Name = synthesizeQualifiedName(Arena, DSIN); 442 } else { 443 if (IsKnownStaticDataMember) { 444 // This was supposed to be a static data member, but we got a function. 445 Error = true; 446 return nullptr; 447 } 448 449 FSN = static_cast<FunctionSymbolNode *>(Symbol); 450 DSIN->Name = Symbol->Name; 451 FSN->Name = synthesizeQualifiedName(Arena, DSIN); 452 } 453 454 return FSN; 455 } 456 457 SymbolNode *Demangler::demangleSpecialIntrinsic(std::string_view &MangledName) { 458 SpecialIntrinsicKind SIK = consumeSpecialIntrinsicKind(MangledName); 459 460 switch (SIK) { 461 case SpecialIntrinsicKind::None: 462 return nullptr; 463 case SpecialIntrinsicKind::StringLiteralSymbol: 464 return demangleStringLiteral(MangledName); 465 case SpecialIntrinsicKind::Vftable: 466 case SpecialIntrinsicKind::Vbtable: 467 case SpecialIntrinsicKind::LocalVftable: 468 case SpecialIntrinsicKind::RttiCompleteObjLocator: 469 return demangleSpecialTableSymbolNode(MangledName, SIK); 470 case SpecialIntrinsicKind::VcallThunk: 471 return demangleVcallThunkNode(MangledName); 472 case SpecialIntrinsicKind::LocalStaticGuard: 473 return demangleLocalStaticGuard(MangledName, /*IsThread=*/false); 474 case SpecialIntrinsicKind::LocalStaticThreadGuard: 475 return demangleLocalStaticGuard(MangledName, /*IsThread=*/true); 476 case SpecialIntrinsicKind::RttiTypeDescriptor: { 477 TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result); 478 if (Error) 479 break; 480 if (!consumeFront(MangledName, "@8")) 481 break; 482 if (!MangledName.empty()) 483 break; 484 return synthesizeVariable(Arena, T, "`RTTI Type Descriptor'"); 485 } 486 case SpecialIntrinsicKind::RttiBaseClassArray: 487 return demangleUntypedVariable(Arena, MangledName, 488 "`RTTI Base Class Array'"); 489 case SpecialIntrinsicKind::RttiClassHierarchyDescriptor: 490 return demangleUntypedVariable(Arena, MangledName, 491 "`RTTI Class Hierarchy Descriptor'"); 492 case SpecialIntrinsicKind::RttiBaseClassDescriptor: 493 return demangleRttiBaseClassDescriptorNode(Arena, MangledName); 494 case SpecialIntrinsicKind::DynamicInitializer: 495 return demangleInitFiniStub(MangledName, /*IsDestructor=*/false); 496 case SpecialIntrinsicKind::DynamicAtexitDestructor: 497 return demangleInitFiniStub(MangledName, /*IsDestructor=*/true); 498 case SpecialIntrinsicKind::Typeof: 499 case SpecialIntrinsicKind::UdtReturning: 500 // It's unclear which tools produces these manglings, so demangling 501 // support is not (yet?) implemented. 502 break; 503 case SpecialIntrinsicKind::Unknown: 504 DEMANGLE_UNREACHABLE; // Never returned by consumeSpecialIntrinsicKind. 505 } 506 Error = true; 507 return nullptr; 508 } 509 510 IdentifierNode * 511 Demangler::demangleFunctionIdentifierCode(std::string_view &MangledName) { 512 assert(llvm::itanium_demangle::starts_with(MangledName, '?')); 513 MangledName.remove_prefix(1); 514 if (MangledName.empty()) { 515 Error = true; 516 return nullptr; 517 } 518 519 if (consumeFront(MangledName, "__")) 520 return demangleFunctionIdentifierCode( 521 MangledName, FunctionIdentifierCodeGroup::DoubleUnder); 522 if (consumeFront(MangledName, "_")) 523 return demangleFunctionIdentifierCode(MangledName, 524 FunctionIdentifierCodeGroup::Under); 525 return demangleFunctionIdentifierCode(MangledName, 526 FunctionIdentifierCodeGroup::Basic); 527 } 528 529 StructorIdentifierNode * 530 Demangler::demangleStructorIdentifier(std::string_view &MangledName, 531 bool IsDestructor) { 532 StructorIdentifierNode *N = Arena.alloc<StructorIdentifierNode>(); 533 N->IsDestructor = IsDestructor; 534 return N; 535 } 536 537 ConversionOperatorIdentifierNode * 538 Demangler::demangleConversionOperatorIdentifier(std::string_view &MangledName) { 539 ConversionOperatorIdentifierNode *N = 540 Arena.alloc<ConversionOperatorIdentifierNode>(); 541 return N; 542 } 543 544 LiteralOperatorIdentifierNode * 545 Demangler::demangleLiteralOperatorIdentifier(std::string_view &MangledName) { 546 LiteralOperatorIdentifierNode *N = 547 Arena.alloc<LiteralOperatorIdentifierNode>(); 548 N->Name = demangleSimpleString(MangledName, /*Memorize=*/false); 549 return N; 550 } 551 552 IntrinsicFunctionKind 553 Demangler::translateIntrinsicFunctionCode(char CH, 554 FunctionIdentifierCodeGroup Group) { 555 using IFK = IntrinsicFunctionKind; 556 if (!(CH >= '0' && CH <= '9') && !(CH >= 'A' && CH <= 'Z')) { 557 Error = true; 558 return IFK::None; 559 } 560 561 // Not all ? identifiers are intrinsics *functions*. This function only maps 562 // operator codes for the special functions, all others are handled elsewhere, 563 // hence the IFK::None entries in the table. 564 static IFK Basic[36] = { 565 IFK::None, // ?0 # Foo::Foo() 566 IFK::None, // ?1 # Foo::~Foo() 567 IFK::New, // ?2 # operator new 568 IFK::Delete, // ?3 # operator delete 569 IFK::Assign, // ?4 # operator= 570 IFK::RightShift, // ?5 # operator>> 571 IFK::LeftShift, // ?6 # operator<< 572 IFK::LogicalNot, // ?7 # operator! 573 IFK::Equals, // ?8 # operator== 574 IFK::NotEquals, // ?9 # operator!= 575 IFK::ArraySubscript, // ?A # operator[] 576 IFK::None, // ?B # Foo::operator <type>() 577 IFK::Pointer, // ?C # operator-> 578 IFK::Dereference, // ?D # operator* 579 IFK::Increment, // ?E # operator++ 580 IFK::Decrement, // ?F # operator-- 581 IFK::Minus, // ?G # operator- 582 IFK::Plus, // ?H # operator+ 583 IFK::BitwiseAnd, // ?I # operator& 584 IFK::MemberPointer, // ?J # operator->* 585 IFK::Divide, // ?K # operator/ 586 IFK::Modulus, // ?L # operator% 587 IFK::LessThan, // ?M operator< 588 IFK::LessThanEqual, // ?N operator<= 589 IFK::GreaterThan, // ?O operator> 590 IFK::GreaterThanEqual, // ?P operator>= 591 IFK::Comma, // ?Q operator, 592 IFK::Parens, // ?R operator() 593 IFK::BitwiseNot, // ?S operator~ 594 IFK::BitwiseXor, // ?T operator^ 595 IFK::BitwiseOr, // ?U operator| 596 IFK::LogicalAnd, // ?V operator&& 597 IFK::LogicalOr, // ?W operator|| 598 IFK::TimesEqual, // ?X operator*= 599 IFK::PlusEqual, // ?Y operator+= 600 IFK::MinusEqual, // ?Z operator-= 601 }; 602 static IFK Under[36] = { 603 IFK::DivEqual, // ?_0 operator/= 604 IFK::ModEqual, // ?_1 operator%= 605 IFK::RshEqual, // ?_2 operator>>= 606 IFK::LshEqual, // ?_3 operator<<= 607 IFK::BitwiseAndEqual, // ?_4 operator&= 608 IFK::BitwiseOrEqual, // ?_5 operator|= 609 IFK::BitwiseXorEqual, // ?_6 operator^= 610 IFK::None, // ?_7 # vftable 611 IFK::None, // ?_8 # vbtable 612 IFK::None, // ?_9 # vcall 613 IFK::None, // ?_A # typeof 614 IFK::None, // ?_B # local static guard 615 IFK::None, // ?_C # string literal 616 IFK::VbaseDtor, // ?_D # vbase destructor 617 IFK::VecDelDtor, // ?_E # vector deleting destructor 618 IFK::DefaultCtorClosure, // ?_F # default constructor closure 619 IFK::ScalarDelDtor, // ?_G # scalar deleting destructor 620 IFK::VecCtorIter, // ?_H # vector constructor iterator 621 IFK::VecDtorIter, // ?_I # vector destructor iterator 622 IFK::VecVbaseCtorIter, // ?_J # vector vbase constructor iterator 623 IFK::VdispMap, // ?_K # virtual displacement map 624 IFK::EHVecCtorIter, // ?_L # eh vector constructor iterator 625 IFK::EHVecDtorIter, // ?_M # eh vector destructor iterator 626 IFK::EHVecVbaseCtorIter, // ?_N # eh vector vbase constructor iterator 627 IFK::CopyCtorClosure, // ?_O # copy constructor closure 628 IFK::None, // ?_P<name> # udt returning <name> 629 IFK::None, // ?_Q # <unknown> 630 IFK::None, // ?_R0 - ?_R4 # RTTI Codes 631 IFK::None, // ?_S # local vftable 632 IFK::LocalVftableCtorClosure, // ?_T # local vftable constructor closure 633 IFK::ArrayNew, // ?_U operator new[] 634 IFK::ArrayDelete, // ?_V operator delete[] 635 IFK::None, // ?_W <unused> 636 IFK::None, // ?_X <unused> 637 IFK::None, // ?_Y <unused> 638 IFK::None, // ?_Z <unused> 639 }; 640 static IFK DoubleUnder[36] = { 641 IFK::None, // ?__0 <unused> 642 IFK::None, // ?__1 <unused> 643 IFK::None, // ?__2 <unused> 644 IFK::None, // ?__3 <unused> 645 IFK::None, // ?__4 <unused> 646 IFK::None, // ?__5 <unused> 647 IFK::None, // ?__6 <unused> 648 IFK::None, // ?__7 <unused> 649 IFK::None, // ?__8 <unused> 650 IFK::None, // ?__9 <unused> 651 IFK::ManVectorCtorIter, // ?__A managed vector ctor iterator 652 IFK::ManVectorDtorIter, // ?__B managed vector dtor iterator 653 IFK::EHVectorCopyCtorIter, // ?__C EH vector copy ctor iterator 654 IFK::EHVectorVbaseCopyCtorIter, // ?__D EH vector vbase copy ctor iter 655 IFK::None, // ?__E dynamic initializer for `T' 656 IFK::None, // ?__F dynamic atexit destructor for `T' 657 IFK::VectorCopyCtorIter, // ?__G vector copy constructor iter 658 IFK::VectorVbaseCopyCtorIter, // ?__H vector vbase copy ctor iter 659 IFK::ManVectorVbaseCopyCtorIter, // ?__I managed vector vbase copy ctor 660 // iter 661 IFK::None, // ?__J local static thread guard 662 IFK::None, // ?__K operator ""_name 663 IFK::CoAwait, // ?__L operator co_await 664 IFK::Spaceship, // ?__M operator<=> 665 IFK::None, // ?__N <unused> 666 IFK::None, // ?__O <unused> 667 IFK::None, // ?__P <unused> 668 IFK::None, // ?__Q <unused> 669 IFK::None, // ?__R <unused> 670 IFK::None, // ?__S <unused> 671 IFK::None, // ?__T <unused> 672 IFK::None, // ?__U <unused> 673 IFK::None, // ?__V <unused> 674 IFK::None, // ?__W <unused> 675 IFK::None, // ?__X <unused> 676 IFK::None, // ?__Y <unused> 677 IFK::None, // ?__Z <unused> 678 }; 679 680 int Index = (CH >= '0' && CH <= '9') ? (CH - '0') : (CH - 'A' + 10); 681 switch (Group) { 682 case FunctionIdentifierCodeGroup::Basic: 683 return Basic[Index]; 684 case FunctionIdentifierCodeGroup::Under: 685 return Under[Index]; 686 case FunctionIdentifierCodeGroup::DoubleUnder: 687 return DoubleUnder[Index]; 688 } 689 DEMANGLE_UNREACHABLE; 690 } 691 692 IdentifierNode * 693 Demangler::demangleFunctionIdentifierCode(std::string_view &MangledName, 694 FunctionIdentifierCodeGroup Group) { 695 if (MangledName.empty()) { 696 Error = true; 697 return nullptr; 698 } 699 const char CH = MangledName.front(); 700 switch (Group) { 701 case FunctionIdentifierCodeGroup::Basic: 702 MangledName.remove_prefix(1); 703 switch (CH) { 704 case '0': 705 case '1': 706 return demangleStructorIdentifier(MangledName, CH == '1'); 707 case 'B': 708 return demangleConversionOperatorIdentifier(MangledName); 709 default: 710 return Arena.alloc<IntrinsicFunctionIdentifierNode>( 711 translateIntrinsicFunctionCode(CH, Group)); 712 } 713 case FunctionIdentifierCodeGroup::Under: 714 MangledName.remove_prefix(1); 715 return Arena.alloc<IntrinsicFunctionIdentifierNode>( 716 translateIntrinsicFunctionCode(CH, Group)); 717 case FunctionIdentifierCodeGroup::DoubleUnder: 718 MangledName.remove_prefix(1); 719 switch (CH) { 720 case 'K': 721 return demangleLiteralOperatorIdentifier(MangledName); 722 default: 723 return Arena.alloc<IntrinsicFunctionIdentifierNode>( 724 translateIntrinsicFunctionCode(CH, Group)); 725 } 726 } 727 728 DEMANGLE_UNREACHABLE; 729 } 730 731 SymbolNode *Demangler::demangleEncodedSymbol(std::string_view &MangledName, 732 QualifiedNameNode *Name) { 733 if (MangledName.empty()) { 734 Error = true; 735 return nullptr; 736 } 737 738 // Read a variable. 739 switch (MangledName.front()) { 740 case '0': 741 case '1': 742 case '2': 743 case '3': 744 case '4': { 745 StorageClass SC = demangleVariableStorageClass(MangledName); 746 return demangleVariableEncoding(MangledName, SC); 747 } 748 } 749 FunctionSymbolNode *FSN = demangleFunctionEncoding(MangledName); 750 751 IdentifierNode *UQN = Name->getUnqualifiedIdentifier(); 752 if (UQN->kind() == NodeKind::ConversionOperatorIdentifier) { 753 ConversionOperatorIdentifierNode *COIN = 754 static_cast<ConversionOperatorIdentifierNode *>(UQN); 755 if (FSN) 756 COIN->TargetType = FSN->Signature->ReturnType; 757 } 758 return FSN; 759 } 760 761 SymbolNode *Demangler::demangleDeclarator(std::string_view &MangledName) { 762 // What follows is a main symbol name. This may include namespaces or class 763 // back references. 764 QualifiedNameNode *QN = demangleFullyQualifiedSymbolName(MangledName); 765 if (Error) 766 return nullptr; 767 768 SymbolNode *Symbol = demangleEncodedSymbol(MangledName, QN); 769 if (Error) 770 return nullptr; 771 Symbol->Name = QN; 772 773 IdentifierNode *UQN = QN->getUnqualifiedIdentifier(); 774 if (UQN->kind() == NodeKind::ConversionOperatorIdentifier) { 775 ConversionOperatorIdentifierNode *COIN = 776 static_cast<ConversionOperatorIdentifierNode *>(UQN); 777 if (!COIN->TargetType) { 778 Error = true; 779 return nullptr; 780 } 781 } 782 return Symbol; 783 } 784 785 SymbolNode *Demangler::demangleMD5Name(std::string_view &MangledName) { 786 assert(llvm::itanium_demangle::starts_with(MangledName, "??@")); 787 // This is an MD5 mangled name. We can't demangle it, just return the 788 // mangled name. 789 // An MD5 mangled name is ??@ followed by 32 characters and a terminating @. 790 size_t MD5Last = MangledName.find('@', strlen("??@")); 791 if (MD5Last == std::string_view::npos) { 792 Error = true; 793 return nullptr; 794 } 795 const char *Start = MangledName.data(); 796 const size_t StartSize = MangledName.size(); 797 MangledName.remove_prefix(MD5Last + 1); 798 799 // There are two additional special cases for MD5 names: 800 // 1. For complete object locators where the object name is long enough 801 // for the object to have an MD5 name, the complete object locator is 802 // called ??@...@??_R4@ (with a trailing "??_R4@" instead of the usual 803 // leading "??_R4". This is handled here. 804 // 2. For catchable types, in versions of MSVC before 2015 (<1900) or after 805 // 2017.2 (>= 1914), the catchable type mangling is _CT??@...@??@...@8 806 // instead of_CT??@...@8 with just one MD5 name. Since we don't yet 807 // demangle catchable types anywhere, this isn't handled for MD5 names 808 // either. 809 consumeFront(MangledName, "??_R4@"); 810 811 assert(MangledName.size() < StartSize); 812 const size_t Count = StartSize - MangledName.size(); 813 std::string_view MD5(Start, Count); 814 SymbolNode *S = Arena.alloc<SymbolNode>(NodeKind::Md5Symbol); 815 S->Name = synthesizeQualifiedName(Arena, MD5); 816 817 return S; 818 } 819 820 SymbolNode *Demangler::demangleTypeinfoName(std::string_view &MangledName) { 821 assert(llvm::itanium_demangle::starts_with(MangledName, '.')); 822 consumeFront(MangledName, '.'); 823 824 TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result); 825 if (Error || !MangledName.empty()) { 826 Error = true; 827 return nullptr; 828 } 829 return synthesizeVariable(Arena, T, "`RTTI Type Descriptor Name'"); 830 } 831 832 // Parser entry point. 833 SymbolNode *Demangler::parse(std::string_view &MangledName) { 834 // Typeinfo names are strings stored in RTTI data. They're not symbol names. 835 // It's still useful to demangle them. They're the only demangled entity 836 // that doesn't start with a "?" but a ".". 837 if (llvm::itanium_demangle::starts_with(MangledName, '.')) 838 return demangleTypeinfoName(MangledName); 839 840 if (llvm::itanium_demangle::starts_with(MangledName, "??@")) 841 return demangleMD5Name(MangledName); 842 843 // MSVC-style mangled symbols must start with '?'. 844 if (!llvm::itanium_demangle::starts_with(MangledName, '?')) { 845 Error = true; 846 return nullptr; 847 } 848 849 consumeFront(MangledName, '?'); 850 851 // ?$ is a template instantiation, but all other names that start with ? are 852 // operators / special names. 853 if (SymbolNode *SI = demangleSpecialIntrinsic(MangledName)) 854 return SI; 855 856 return demangleDeclarator(MangledName); 857 } 858 859 TagTypeNode *Demangler::parseTagUniqueName(std::string_view &MangledName) { 860 if (!consumeFront(MangledName, ".?A")) { 861 Error = true; 862 return nullptr; 863 } 864 consumeFront(MangledName, ".?A"); 865 if (MangledName.empty()) { 866 Error = true; 867 return nullptr; 868 } 869 870 return demangleClassType(MangledName); 871 } 872 873 // <type-encoding> ::= <storage-class> <variable-type> 874 // <storage-class> ::= 0 # private static member 875 // ::= 1 # protected static member 876 // ::= 2 # public static member 877 // ::= 3 # global 878 // ::= 4 # static local 879 880 VariableSymbolNode * 881 Demangler::demangleVariableEncoding(std::string_view &MangledName, 882 StorageClass SC) { 883 VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>(); 884 885 VSN->Type = demangleType(MangledName, QualifierMangleMode::Drop); 886 VSN->SC = SC; 887 888 if (Error) 889 return nullptr; 890 891 // <variable-type> ::= <type> <cvr-qualifiers> 892 // ::= <type> <pointee-cvr-qualifiers> # pointers, references 893 switch (VSN->Type->kind()) { 894 case NodeKind::PointerType: { 895 PointerTypeNode *PTN = static_cast<PointerTypeNode *>(VSN->Type); 896 897 Qualifiers ExtraChildQuals = Q_None; 898 PTN->Quals = Qualifiers(VSN->Type->Quals | 899 demanglePointerExtQualifiers(MangledName)); 900 901 bool IsMember = false; 902 std::tie(ExtraChildQuals, IsMember) = demangleQualifiers(MangledName); 903 904 if (PTN->ClassParent) { 905 QualifiedNameNode *BackRefName = 906 demangleFullyQualifiedTypeName(MangledName); 907 (void)BackRefName; 908 } 909 PTN->Pointee->Quals = Qualifiers(PTN->Pointee->Quals | ExtraChildQuals); 910 911 break; 912 } 913 default: 914 VSN->Type->Quals = demangleQualifiers(MangledName).first; 915 break; 916 } 917 918 return VSN; 919 } 920 921 // Sometimes numbers are encoded in mangled symbols. For example, 922 // "int (*x)[20]" is a valid C type (x is a pointer to an array of 923 // length 20), so we need some way to embed numbers as part of symbols. 924 // This function parses it. 925 // 926 // <number> ::= [?] <non-negative integer> 927 // 928 // <non-negative integer> ::= <decimal digit> # when 1 <= Number <= 10 929 // ::= <hex digit>+ @ # when Number == 0 or >= 10 930 // 931 // <hex-digit> ::= [A-P] # A = 0, B = 1, ... 932 std::pair<uint64_t, bool> 933 Demangler::demangleNumber(std::string_view &MangledName) { 934 bool IsNegative = consumeFront(MangledName, '?'); 935 936 if (startsWithDigit(MangledName)) { 937 uint64_t Ret = MangledName[0] - '0' + 1; 938 MangledName.remove_prefix(1); 939 return {Ret, IsNegative}; 940 } 941 942 uint64_t Ret = 0; 943 for (size_t i = 0; i < MangledName.size(); ++i) { 944 char C = MangledName[i]; 945 if (C == '@') { 946 MangledName.remove_prefix(i + 1); 947 return {Ret, IsNegative}; 948 } 949 if ('A' <= C && C <= 'P') { 950 Ret = (Ret << 4) + (C - 'A'); 951 continue; 952 } 953 break; 954 } 955 956 Error = true; 957 return {0ULL, false}; 958 } 959 960 uint64_t Demangler::demangleUnsigned(std::string_view &MangledName) { 961 bool IsNegative = false; 962 uint64_t Number = 0; 963 std::tie(Number, IsNegative) = demangleNumber(MangledName); 964 if (IsNegative) 965 Error = true; 966 return Number; 967 } 968 969 int64_t Demangler::demangleSigned(std::string_view &MangledName) { 970 bool IsNegative = false; 971 uint64_t Number = 0; 972 std::tie(Number, IsNegative) = demangleNumber(MangledName); 973 if (Number > INT64_MAX) 974 Error = true; 975 int64_t I = static_cast<int64_t>(Number); 976 return IsNegative ? -I : I; 977 } 978 979 // First 10 strings can be referenced by special BackReferences ?0, ?1, ..., ?9. 980 // Memorize it. 981 void Demangler::memorizeString(std::string_view S) { 982 if (Backrefs.NamesCount >= BackrefContext::Max) 983 return; 984 for (size_t i = 0; i < Backrefs.NamesCount; ++i) 985 if (S == Backrefs.Names[i]->Name) 986 return; 987 NamedIdentifierNode *N = Arena.alloc<NamedIdentifierNode>(); 988 N->Name = S; 989 Backrefs.Names[Backrefs.NamesCount++] = N; 990 } 991 992 NamedIdentifierNode * 993 Demangler::demangleBackRefName(std::string_view &MangledName) { 994 assert(startsWithDigit(MangledName)); 995 996 size_t I = MangledName[0] - '0'; 997 if (I >= Backrefs.NamesCount) { 998 Error = true; 999 return nullptr; 1000 } 1001 1002 MangledName.remove_prefix(1); 1003 return Backrefs.Names[I]; 1004 } 1005 1006 void Demangler::memorizeIdentifier(IdentifierNode *Identifier) { 1007 // Render this class template name into a string buffer so that we can 1008 // memorize it for the purpose of back-referencing. 1009 OutputBuffer OB; 1010 Identifier->output(OB, OF_Default); 1011 std::string_view Owned = copyString(OB); 1012 memorizeString(Owned); 1013 std::free(OB.getBuffer()); 1014 } 1015 1016 IdentifierNode * 1017 Demangler::demangleTemplateInstantiationName(std::string_view &MangledName, 1018 NameBackrefBehavior NBB) { 1019 assert(llvm::itanium_demangle::starts_with(MangledName, "?$")); 1020 consumeFront(MangledName, "?$"); 1021 1022 BackrefContext OuterContext; 1023 std::swap(OuterContext, Backrefs); 1024 1025 IdentifierNode *Identifier = 1026 demangleUnqualifiedSymbolName(MangledName, NBB_Simple); 1027 if (!Error) 1028 Identifier->TemplateParams = demangleTemplateParameterList(MangledName); 1029 1030 std::swap(OuterContext, Backrefs); 1031 if (Error) 1032 return nullptr; 1033 1034 if (NBB & NBB_Template) { 1035 // NBB_Template is only set for types and non-leaf names ("a::" in "a::b"). 1036 // Structors and conversion operators only makes sense in a leaf name, so 1037 // reject them in NBB_Template contexts. 1038 if (Identifier->kind() == NodeKind::ConversionOperatorIdentifier || 1039 Identifier->kind() == NodeKind::StructorIdentifier) { 1040 Error = true; 1041 return nullptr; 1042 } 1043 1044 memorizeIdentifier(Identifier); 1045 } 1046 1047 return Identifier; 1048 } 1049 1050 NamedIdentifierNode * 1051 Demangler::demangleSimpleName(std::string_view &MangledName, bool Memorize) { 1052 std::string_view S = demangleSimpleString(MangledName, Memorize); 1053 if (Error) 1054 return nullptr; 1055 1056 NamedIdentifierNode *Name = Arena.alloc<NamedIdentifierNode>(); 1057 Name->Name = S; 1058 return Name; 1059 } 1060 1061 static bool isRebasedHexDigit(char C) { return (C >= 'A' && C <= 'P'); } 1062 1063 static uint8_t rebasedHexDigitToNumber(char C) { 1064 assert(isRebasedHexDigit(C)); 1065 return (C <= 'J') ? (C - 'A') : (10 + C - 'K'); 1066 } 1067 1068 uint8_t Demangler::demangleCharLiteral(std::string_view &MangledName) { 1069 assert(!MangledName.empty()); 1070 if (!llvm::itanium_demangle::starts_with(MangledName, '?')) { 1071 const uint8_t F = MangledName.front(); 1072 MangledName.remove_prefix(1); 1073 return F; 1074 } 1075 1076 MangledName.remove_prefix(1); 1077 if (MangledName.empty()) 1078 goto CharLiteralError; 1079 1080 if (consumeFront(MangledName, '$')) { 1081 // Two hex digits 1082 if (MangledName.size() < 2) 1083 goto CharLiteralError; 1084 std::string_view Nibbles = MangledName.substr(0, 2); 1085 if (!isRebasedHexDigit(Nibbles[0]) || !isRebasedHexDigit(Nibbles[1])) 1086 goto CharLiteralError; 1087 // Don't append the null terminator. 1088 uint8_t C1 = rebasedHexDigitToNumber(Nibbles[0]); 1089 uint8_t C2 = rebasedHexDigitToNumber(Nibbles[1]); 1090 MangledName.remove_prefix(2); 1091 return (C1 << 4) | C2; 1092 } 1093 1094 if (startsWithDigit(MangledName)) { 1095 const char *Lookup = ",/\\:. \n\t'-"; 1096 char C = Lookup[MangledName[0] - '0']; 1097 MangledName.remove_prefix(1); 1098 return C; 1099 } 1100 1101 if (MangledName[0] >= 'a' && MangledName[0] <= 'z') { 1102 char Lookup[26] = {'\xE1', '\xE2', '\xE3', '\xE4', '\xE5', '\xE6', '\xE7', 1103 '\xE8', '\xE9', '\xEA', '\xEB', '\xEC', '\xED', '\xEE', 1104 '\xEF', '\xF0', '\xF1', '\xF2', '\xF3', '\xF4', '\xF5', 1105 '\xF6', '\xF7', '\xF8', '\xF9', '\xFA'}; 1106 char C = Lookup[MangledName[0] - 'a']; 1107 MangledName.remove_prefix(1); 1108 return C; 1109 } 1110 1111 if (MangledName[0] >= 'A' && MangledName[0] <= 'Z') { 1112 char Lookup[26] = {'\xC1', '\xC2', '\xC3', '\xC4', '\xC5', '\xC6', '\xC7', 1113 '\xC8', '\xC9', '\xCA', '\xCB', '\xCC', '\xCD', '\xCE', 1114 '\xCF', '\xD0', '\xD1', '\xD2', '\xD3', '\xD4', '\xD5', 1115 '\xD6', '\xD7', '\xD8', '\xD9', '\xDA'}; 1116 char C = Lookup[MangledName[0] - 'A']; 1117 MangledName.remove_prefix(1); 1118 return C; 1119 } 1120 1121 CharLiteralError: 1122 Error = true; 1123 return '\0'; 1124 } 1125 1126 wchar_t Demangler::demangleWcharLiteral(std::string_view &MangledName) { 1127 uint8_t C1, C2; 1128 1129 C1 = demangleCharLiteral(MangledName); 1130 if (Error || MangledName.empty()) 1131 goto WCharLiteralError; 1132 C2 = demangleCharLiteral(MangledName); 1133 if (Error) 1134 goto WCharLiteralError; 1135 1136 return ((wchar_t)C1 << 8) | (wchar_t)C2; 1137 1138 WCharLiteralError: 1139 Error = true; 1140 return L'\0'; 1141 } 1142 1143 static void writeHexDigit(char *Buffer, uint8_t Digit) { 1144 assert(Digit <= 15); 1145 *Buffer = (Digit < 10) ? ('0' + Digit) : ('A' + Digit - 10); 1146 } 1147 1148 static void outputHex(OutputBuffer &OB, unsigned C) { 1149 assert (C != 0); 1150 1151 // It's easier to do the math if we can work from right to left, but we need 1152 // to print the numbers from left to right. So render this into a temporary 1153 // buffer first, then output the temporary buffer. Each byte is of the form 1154 // \xAB, which means that each byte needs 4 characters. Since there are at 1155 // most 4 bytes, we need a 4*4+1 = 17 character temporary buffer. 1156 char TempBuffer[17]; 1157 1158 ::memset(TempBuffer, 0, sizeof(TempBuffer)); 1159 constexpr int MaxPos = sizeof(TempBuffer) - 1; 1160 1161 int Pos = MaxPos - 1; // TempBuffer[MaxPos] is the terminating \0. 1162 while (C != 0) { 1163 for (int I = 0; I < 2; ++I) { 1164 writeHexDigit(&TempBuffer[Pos--], C % 16); 1165 C /= 16; 1166 } 1167 } 1168 TempBuffer[Pos--] = 'x'; 1169 assert(Pos >= 0); 1170 TempBuffer[Pos--] = '\\'; 1171 OB << std::string_view(&TempBuffer[Pos + 1]); 1172 } 1173 1174 static void outputEscapedChar(OutputBuffer &OB, unsigned C) { 1175 switch (C) { 1176 case '\0': // nul 1177 OB << "\\0"; 1178 return; 1179 case '\'': // single quote 1180 OB << "\\\'"; 1181 return; 1182 case '\"': // double quote 1183 OB << "\\\""; 1184 return; 1185 case '\\': // backslash 1186 OB << "\\\\"; 1187 return; 1188 case '\a': // bell 1189 OB << "\\a"; 1190 return; 1191 case '\b': // backspace 1192 OB << "\\b"; 1193 return; 1194 case '\f': // form feed 1195 OB << "\\f"; 1196 return; 1197 case '\n': // new line 1198 OB << "\\n"; 1199 return; 1200 case '\r': // carriage return 1201 OB << "\\r"; 1202 return; 1203 case '\t': // tab 1204 OB << "\\t"; 1205 return; 1206 case '\v': // vertical tab 1207 OB << "\\v"; 1208 return; 1209 default: 1210 break; 1211 } 1212 1213 if (C > 0x1F && C < 0x7F) { 1214 // Standard ascii char. 1215 OB << (char)C; 1216 return; 1217 } 1218 1219 outputHex(OB, C); 1220 } 1221 1222 static unsigned countTrailingNullBytes(const uint8_t *StringBytes, int Length) { 1223 const uint8_t *End = StringBytes + Length - 1; 1224 unsigned Count = 0; 1225 while (Length > 0 && *End == 0) { 1226 --Length; 1227 --End; 1228 ++Count; 1229 } 1230 return Count; 1231 } 1232 1233 static unsigned countEmbeddedNulls(const uint8_t *StringBytes, 1234 unsigned Length) { 1235 unsigned Result = 0; 1236 for (unsigned I = 0; I < Length; ++I) { 1237 if (*StringBytes++ == 0) 1238 ++Result; 1239 } 1240 return Result; 1241 } 1242 1243 // A mangled (non-wide) string literal stores the total length of the string it 1244 // refers to (passed in NumBytes), and it contains up to 32 bytes of actual text 1245 // (passed in StringBytes, NumChars). 1246 static unsigned guessCharByteSize(const uint8_t *StringBytes, unsigned NumChars, 1247 uint64_t NumBytes) { 1248 assert(NumBytes > 0); 1249 1250 // If the number of bytes is odd, this is guaranteed to be a char string. 1251 if (NumBytes % 2 == 1) 1252 return 1; 1253 1254 // All strings can encode at most 32 bytes of data. If it's less than that, 1255 // then we encoded the entire string. In this case we check for a 1-byte, 1256 // 2-byte, or 4-byte null terminator. 1257 if (NumBytes < 32) { 1258 unsigned TrailingNulls = countTrailingNullBytes(StringBytes, NumChars); 1259 if (TrailingNulls >= 4 && NumBytes % 4 == 0) 1260 return 4; 1261 if (TrailingNulls >= 2) 1262 return 2; 1263 return 1; 1264 } 1265 1266 // The whole string was not able to be encoded. Try to look at embedded null 1267 // terminators to guess. The heuristic is that we count all embedded null 1268 // terminators. If more than 2/3 are null, it's a char32. If more than 1/3 1269 // are null, it's a char16. Otherwise it's a char8. This obviously isn't 1270 // perfect and is biased towards languages that have ascii alphabets, but this 1271 // was always going to be best effort since the encoding is lossy. 1272 unsigned Nulls = countEmbeddedNulls(StringBytes, NumChars); 1273 if (Nulls >= 2 * NumChars / 3 && NumBytes % 4 == 0) 1274 return 4; 1275 if (Nulls >= NumChars / 3) 1276 return 2; 1277 return 1; 1278 } 1279 1280 static unsigned decodeMultiByteChar(const uint8_t *StringBytes, 1281 unsigned CharIndex, unsigned CharBytes) { 1282 assert(CharBytes == 1 || CharBytes == 2 || CharBytes == 4); 1283 unsigned Offset = CharIndex * CharBytes; 1284 unsigned Result = 0; 1285 StringBytes = StringBytes + Offset; 1286 for (unsigned I = 0; I < CharBytes; ++I) { 1287 unsigned C = static_cast<unsigned>(StringBytes[I]); 1288 Result |= C << (8 * I); 1289 } 1290 return Result; 1291 } 1292 1293 FunctionSymbolNode * 1294 Demangler::demangleVcallThunkNode(std::string_view &MangledName) { 1295 FunctionSymbolNode *FSN = Arena.alloc<FunctionSymbolNode>(); 1296 VcallThunkIdentifierNode *VTIN = Arena.alloc<VcallThunkIdentifierNode>(); 1297 FSN->Signature = Arena.alloc<ThunkSignatureNode>(); 1298 FSN->Signature->FunctionClass = FC_NoParameterList; 1299 1300 FSN->Name = demangleNameScopeChain(MangledName, VTIN); 1301 if (!Error) 1302 Error = !consumeFront(MangledName, "$B"); 1303 if (!Error) 1304 VTIN->OffsetInVTable = demangleUnsigned(MangledName); 1305 if (!Error) 1306 Error = !consumeFront(MangledName, 'A'); 1307 if (!Error) 1308 FSN->Signature->CallConvention = demangleCallingConvention(MangledName); 1309 return (Error) ? nullptr : FSN; 1310 } 1311 1312 EncodedStringLiteralNode * 1313 Demangler::demangleStringLiteral(std::string_view &MangledName) { 1314 // This function uses goto, so declare all variables up front. 1315 OutputBuffer OB; 1316 std::string_view CRC; 1317 uint64_t StringByteSize; 1318 bool IsWcharT = false; 1319 bool IsNegative = false; 1320 size_t CrcEndPos = 0; 1321 char F; 1322 1323 EncodedStringLiteralNode *Result = Arena.alloc<EncodedStringLiteralNode>(); 1324 1325 // Prefix indicating the beginning of a string literal 1326 if (!consumeFront(MangledName, "@_")) 1327 goto StringLiteralError; 1328 if (MangledName.empty()) 1329 goto StringLiteralError; 1330 1331 // Char Type (regular or wchar_t) 1332 F = MangledName.front(); 1333 MangledName.remove_prefix(1); 1334 switch (F) { 1335 case '1': 1336 IsWcharT = true; 1337 DEMANGLE_FALLTHROUGH; 1338 case '0': 1339 break; 1340 default: 1341 goto StringLiteralError; 1342 } 1343 1344 // Encoded Length 1345 std::tie(StringByteSize, IsNegative) = demangleNumber(MangledName); 1346 if (Error || IsNegative || StringByteSize < (IsWcharT ? 2 : 1)) 1347 goto StringLiteralError; 1348 1349 // CRC 32 (always 8 characters plus a terminator) 1350 CrcEndPos = MangledName.find('@'); 1351 if (CrcEndPos == std::string_view::npos) 1352 goto StringLiteralError; 1353 CRC = MangledName.substr(0, CrcEndPos); 1354 MangledName.remove_prefix(CrcEndPos + 1); 1355 if (MangledName.empty()) 1356 goto StringLiteralError; 1357 1358 if (IsWcharT) { 1359 Result->Char = CharKind::Wchar; 1360 if (StringByteSize > 64) 1361 Result->IsTruncated = true; 1362 1363 while (!consumeFront(MangledName, '@')) { 1364 if (MangledName.size() < 2) 1365 goto StringLiteralError; 1366 wchar_t W = demangleWcharLiteral(MangledName); 1367 if (StringByteSize != 2 || Result->IsTruncated) 1368 outputEscapedChar(OB, W); 1369 StringByteSize -= 2; 1370 if (Error) 1371 goto StringLiteralError; 1372 } 1373 } else { 1374 // The max byte length is actually 32, but some compilers mangled strings 1375 // incorrectly, so we have to assume it can go higher. 1376 constexpr unsigned MaxStringByteLength = 32 * 4; 1377 uint8_t StringBytes[MaxStringByteLength]; 1378 1379 unsigned BytesDecoded = 0; 1380 while (!consumeFront(MangledName, '@')) { 1381 if (MangledName.size() < 1 || BytesDecoded >= MaxStringByteLength) 1382 goto StringLiteralError; 1383 StringBytes[BytesDecoded++] = demangleCharLiteral(MangledName); 1384 } 1385 1386 if (StringByteSize > BytesDecoded) 1387 Result->IsTruncated = true; 1388 1389 unsigned CharBytes = 1390 guessCharByteSize(StringBytes, BytesDecoded, StringByteSize); 1391 assert(StringByteSize % CharBytes == 0); 1392 switch (CharBytes) { 1393 case 1: 1394 Result->Char = CharKind::Char; 1395 break; 1396 case 2: 1397 Result->Char = CharKind::Char16; 1398 break; 1399 case 4: 1400 Result->Char = CharKind::Char32; 1401 break; 1402 default: 1403 DEMANGLE_UNREACHABLE; 1404 } 1405 const unsigned NumChars = BytesDecoded / CharBytes; 1406 for (unsigned CharIndex = 0; CharIndex < NumChars; ++CharIndex) { 1407 unsigned NextChar = 1408 decodeMultiByteChar(StringBytes, CharIndex, CharBytes); 1409 if (CharIndex + 1 < NumChars || Result->IsTruncated) 1410 outputEscapedChar(OB, NextChar); 1411 } 1412 } 1413 1414 Result->DecodedString = copyString(OB); 1415 std::free(OB.getBuffer()); 1416 return Result; 1417 1418 StringLiteralError: 1419 Error = true; 1420 std::free(OB.getBuffer()); 1421 return nullptr; 1422 } 1423 1424 // Returns MangledName's prefix before the first '@', or an error if 1425 // MangledName contains no '@' or the prefix has length 0. 1426 std::string_view Demangler::demangleSimpleString(std::string_view &MangledName, 1427 bool Memorize) { 1428 std::string_view S; 1429 for (size_t i = 0; i < MangledName.size(); ++i) { 1430 if (MangledName[i] != '@') 1431 continue; 1432 if (i == 0) 1433 break; 1434 S = MangledName.substr(0, i); 1435 MangledName.remove_prefix(i + 1); 1436 1437 if (Memorize) 1438 memorizeString(S); 1439 return S; 1440 } 1441 1442 Error = true; 1443 return {}; 1444 } 1445 1446 NamedIdentifierNode * 1447 Demangler::demangleAnonymousNamespaceName(std::string_view &MangledName) { 1448 assert(llvm::itanium_demangle::starts_with(MangledName, "?A")); 1449 consumeFront(MangledName, "?A"); 1450 1451 NamedIdentifierNode *Node = Arena.alloc<NamedIdentifierNode>(); 1452 Node->Name = "`anonymous namespace'"; 1453 size_t EndPos = MangledName.find('@'); 1454 if (EndPos == std::string_view::npos) { 1455 Error = true; 1456 return nullptr; 1457 } 1458 std::string_view NamespaceKey = MangledName.substr(0, EndPos); 1459 memorizeString(NamespaceKey); 1460 MangledName = MangledName.substr(EndPos + 1); 1461 return Node; 1462 } 1463 1464 NamedIdentifierNode * 1465 Demangler::demangleLocallyScopedNamePiece(std::string_view &MangledName) { 1466 assert(startsWithLocalScopePattern(MangledName)); 1467 1468 NamedIdentifierNode *Identifier = Arena.alloc<NamedIdentifierNode>(); 1469 consumeFront(MangledName, '?'); 1470 uint64_t Number = 0; 1471 bool IsNegative = false; 1472 std::tie(Number, IsNegative) = demangleNumber(MangledName); 1473 assert(!IsNegative); 1474 1475 // One ? to terminate the number 1476 consumeFront(MangledName, '?'); 1477 1478 assert(!Error); 1479 Node *Scope = parse(MangledName); 1480 if (Error) 1481 return nullptr; 1482 1483 // Render the parent symbol's name into a buffer. 1484 OutputBuffer OB; 1485 OB << '`'; 1486 Scope->output(OB, OF_Default); 1487 OB << '\''; 1488 OB << "::`" << Number << "'"; 1489 1490 Identifier->Name = copyString(OB); 1491 std::free(OB.getBuffer()); 1492 return Identifier; 1493 } 1494 1495 // Parses a type name in the form of A@B@C@@ which represents C::B::A. 1496 QualifiedNameNode * 1497 Demangler::demangleFullyQualifiedTypeName(std::string_view &MangledName) { 1498 IdentifierNode *Identifier = 1499 demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true); 1500 if (Error) 1501 return nullptr; 1502 assert(Identifier); 1503 1504 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, Identifier); 1505 if (Error) 1506 return nullptr; 1507 assert(QN); 1508 return QN; 1509 } 1510 1511 // Parses a symbol name in the form of A@B@C@@ which represents C::B::A. 1512 // Symbol names have slightly different rules regarding what can appear 1513 // so we separate out the implementations for flexibility. 1514 QualifiedNameNode * 1515 Demangler::demangleFullyQualifiedSymbolName(std::string_view &MangledName) { 1516 // This is the final component of a symbol name (i.e. the leftmost component 1517 // of a mangled name. Since the only possible template instantiation that 1518 // can appear in this context is a function template, and since those are 1519 // not saved for the purposes of name backreferences, only backref simple 1520 // names. 1521 IdentifierNode *Identifier = 1522 demangleUnqualifiedSymbolName(MangledName, NBB_Simple); 1523 if (Error) 1524 return nullptr; 1525 1526 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, Identifier); 1527 if (Error) 1528 return nullptr; 1529 1530 if (Identifier->kind() == NodeKind::StructorIdentifier) { 1531 if (QN->Components->Count < 2) { 1532 Error = true; 1533 return nullptr; 1534 } 1535 StructorIdentifierNode *SIN = 1536 static_cast<StructorIdentifierNode *>(Identifier); 1537 Node *ClassNode = QN->Components->Nodes[QN->Components->Count - 2]; 1538 SIN->Class = static_cast<IdentifierNode *>(ClassNode); 1539 } 1540 assert(QN); 1541 return QN; 1542 } 1543 1544 IdentifierNode * 1545 Demangler::demangleUnqualifiedTypeName(std::string_view &MangledName, 1546 bool Memorize) { 1547 // An inner-most name can be a back-reference, because a fully-qualified name 1548 // (e.g. Scope + Inner) can contain other fully qualified names inside of 1549 // them (for example template parameters), and these nested parameters can 1550 // refer to previously mangled types. 1551 if (startsWithDigit(MangledName)) 1552 return demangleBackRefName(MangledName); 1553 1554 if (llvm::itanium_demangle::starts_with(MangledName, "?$")) 1555 return demangleTemplateInstantiationName(MangledName, NBB_Template); 1556 1557 return demangleSimpleName(MangledName, Memorize); 1558 } 1559 1560 IdentifierNode * 1561 Demangler::demangleUnqualifiedSymbolName(std::string_view &MangledName, 1562 NameBackrefBehavior NBB) { 1563 if (startsWithDigit(MangledName)) 1564 return demangleBackRefName(MangledName); 1565 if (llvm::itanium_demangle::starts_with(MangledName, "?$")) 1566 return demangleTemplateInstantiationName(MangledName, NBB); 1567 if (llvm::itanium_demangle::starts_with(MangledName, '?')) 1568 return demangleFunctionIdentifierCode(MangledName); 1569 return demangleSimpleName(MangledName, /*Memorize=*/(NBB & NBB_Simple) != 0); 1570 } 1571 1572 IdentifierNode * 1573 Demangler::demangleNameScopePiece(std::string_view &MangledName) { 1574 if (startsWithDigit(MangledName)) 1575 return demangleBackRefName(MangledName); 1576 1577 if (llvm::itanium_demangle::starts_with(MangledName, "?$")) 1578 return demangleTemplateInstantiationName(MangledName, NBB_Template); 1579 1580 if (llvm::itanium_demangle::starts_with(MangledName, "?A")) 1581 return demangleAnonymousNamespaceName(MangledName); 1582 1583 if (startsWithLocalScopePattern(MangledName)) 1584 return demangleLocallyScopedNamePiece(MangledName); 1585 1586 return demangleSimpleName(MangledName, /*Memorize=*/true); 1587 } 1588 1589 static NodeArrayNode *nodeListToNodeArray(ArenaAllocator &Arena, NodeList *Head, 1590 size_t Count) { 1591 NodeArrayNode *N = Arena.alloc<NodeArrayNode>(); 1592 N->Count = Count; 1593 N->Nodes = Arena.allocArray<Node *>(Count); 1594 for (size_t I = 0; I < Count; ++I) { 1595 N->Nodes[I] = Head->N; 1596 Head = Head->Next; 1597 } 1598 return N; 1599 } 1600 1601 QualifiedNameNode * 1602 Demangler::demangleNameScopeChain(std::string_view &MangledName, 1603 IdentifierNode *UnqualifiedName) { 1604 NodeList *Head = Arena.alloc<NodeList>(); 1605 1606 Head->N = UnqualifiedName; 1607 1608 size_t Count = 1; 1609 while (!consumeFront(MangledName, "@")) { 1610 ++Count; 1611 NodeList *NewHead = Arena.alloc<NodeList>(); 1612 NewHead->Next = Head; 1613 Head = NewHead; 1614 1615 if (MangledName.empty()) { 1616 Error = true; 1617 return nullptr; 1618 } 1619 1620 assert(!Error); 1621 IdentifierNode *Elem = demangleNameScopePiece(MangledName); 1622 if (Error) 1623 return nullptr; 1624 1625 Head->N = Elem; 1626 } 1627 1628 QualifiedNameNode *QN = Arena.alloc<QualifiedNameNode>(); 1629 QN->Components = nodeListToNodeArray(Arena, Head, Count); 1630 return QN; 1631 } 1632 1633 FuncClass Demangler::demangleFunctionClass(std::string_view &MangledName) { 1634 const char F = MangledName.front(); 1635 MangledName.remove_prefix(1); 1636 switch (F) { 1637 case '9': 1638 return FuncClass(FC_ExternC | FC_NoParameterList); 1639 case 'A': 1640 return FC_Private; 1641 case 'B': 1642 return FuncClass(FC_Private | FC_Far); 1643 case 'C': 1644 return FuncClass(FC_Private | FC_Static); 1645 case 'D': 1646 return FuncClass(FC_Private | FC_Static | FC_Far); 1647 case 'E': 1648 return FuncClass(FC_Private | FC_Virtual); 1649 case 'F': 1650 return FuncClass(FC_Private | FC_Virtual | FC_Far); 1651 case 'G': 1652 return FuncClass(FC_Private | FC_StaticThisAdjust); 1653 case 'H': 1654 return FuncClass(FC_Private | FC_StaticThisAdjust | FC_Far); 1655 case 'I': 1656 return FuncClass(FC_Protected); 1657 case 'J': 1658 return FuncClass(FC_Protected | FC_Far); 1659 case 'K': 1660 return FuncClass(FC_Protected | FC_Static); 1661 case 'L': 1662 return FuncClass(FC_Protected | FC_Static | FC_Far); 1663 case 'M': 1664 return FuncClass(FC_Protected | FC_Virtual); 1665 case 'N': 1666 return FuncClass(FC_Protected | FC_Virtual | FC_Far); 1667 case 'O': 1668 return FuncClass(FC_Protected | FC_Virtual | FC_StaticThisAdjust); 1669 case 'P': 1670 return FuncClass(FC_Protected | FC_Virtual | FC_StaticThisAdjust | FC_Far); 1671 case 'Q': 1672 return FuncClass(FC_Public); 1673 case 'R': 1674 return FuncClass(FC_Public | FC_Far); 1675 case 'S': 1676 return FuncClass(FC_Public | FC_Static); 1677 case 'T': 1678 return FuncClass(FC_Public | FC_Static | FC_Far); 1679 case 'U': 1680 return FuncClass(FC_Public | FC_Virtual); 1681 case 'V': 1682 return FuncClass(FC_Public | FC_Virtual | FC_Far); 1683 case 'W': 1684 return FuncClass(FC_Public | FC_Virtual | FC_StaticThisAdjust); 1685 case 'X': 1686 return FuncClass(FC_Public | FC_Virtual | FC_StaticThisAdjust | FC_Far); 1687 case 'Y': 1688 return FuncClass(FC_Global); 1689 case 'Z': 1690 return FuncClass(FC_Global | FC_Far); 1691 case '$': { 1692 FuncClass VFlag = FC_VirtualThisAdjust; 1693 if (consumeFront(MangledName, 'R')) 1694 VFlag = FuncClass(VFlag | FC_VirtualThisAdjustEx); 1695 if (MangledName.empty()) 1696 break; 1697 const char F = MangledName.front(); 1698 MangledName.remove_prefix(1); 1699 switch (F) { 1700 case '0': 1701 return FuncClass(FC_Private | FC_Virtual | VFlag); 1702 case '1': 1703 return FuncClass(FC_Private | FC_Virtual | VFlag | FC_Far); 1704 case '2': 1705 return FuncClass(FC_Protected | FC_Virtual | VFlag); 1706 case '3': 1707 return FuncClass(FC_Protected | FC_Virtual | VFlag | FC_Far); 1708 case '4': 1709 return FuncClass(FC_Public | FC_Virtual | VFlag); 1710 case '5': 1711 return FuncClass(FC_Public | FC_Virtual | VFlag | FC_Far); 1712 } 1713 } 1714 } 1715 1716 Error = true; 1717 return FC_Public; 1718 } 1719 1720 CallingConv 1721 Demangler::demangleCallingConvention(std::string_view &MangledName) { 1722 if (MangledName.empty()) { 1723 Error = true; 1724 return CallingConv::None; 1725 } 1726 1727 const char F = MangledName.front(); 1728 MangledName.remove_prefix(1); 1729 switch (F) { 1730 case 'A': 1731 case 'B': 1732 return CallingConv::Cdecl; 1733 case 'C': 1734 case 'D': 1735 return CallingConv::Pascal; 1736 case 'E': 1737 case 'F': 1738 return CallingConv::Thiscall; 1739 case 'G': 1740 case 'H': 1741 return CallingConv::Stdcall; 1742 case 'I': 1743 case 'J': 1744 return CallingConv::Fastcall; 1745 case 'M': 1746 case 'N': 1747 return CallingConv::Clrcall; 1748 case 'O': 1749 case 'P': 1750 return CallingConv::Eabi; 1751 case 'Q': 1752 return CallingConv::Vectorcall; 1753 case 'S': 1754 return CallingConv::Swift; 1755 case 'W': 1756 return CallingConv::SwiftAsync; 1757 } 1758 1759 return CallingConv::None; 1760 } 1761 1762 StorageClass 1763 Demangler::demangleVariableStorageClass(std::string_view &MangledName) { 1764 assert(MangledName.front() >= '0' && MangledName.front() <= '4'); 1765 1766 const char F = MangledName.front(); 1767 MangledName.remove_prefix(1); 1768 switch (F) { 1769 case '0': 1770 return StorageClass::PrivateStatic; 1771 case '1': 1772 return StorageClass::ProtectedStatic; 1773 case '2': 1774 return StorageClass::PublicStatic; 1775 case '3': 1776 return StorageClass::Global; 1777 case '4': 1778 return StorageClass::FunctionLocalStatic; 1779 } 1780 DEMANGLE_UNREACHABLE; 1781 } 1782 1783 std::pair<Qualifiers, bool> 1784 Demangler::demangleQualifiers(std::string_view &MangledName) { 1785 if (MangledName.empty()) { 1786 Error = true; 1787 return std::make_pair(Q_None, false); 1788 } 1789 1790 const char F = MangledName.front(); 1791 MangledName.remove_prefix(1); 1792 switch (F) { 1793 // Member qualifiers 1794 case 'Q': 1795 return std::make_pair(Q_None, true); 1796 case 'R': 1797 return std::make_pair(Q_Const, true); 1798 case 'S': 1799 return std::make_pair(Q_Volatile, true); 1800 case 'T': 1801 return std::make_pair(Qualifiers(Q_Const | Q_Volatile), true); 1802 // Non-Member qualifiers 1803 case 'A': 1804 return std::make_pair(Q_None, false); 1805 case 'B': 1806 return std::make_pair(Q_Const, false); 1807 case 'C': 1808 return std::make_pair(Q_Volatile, false); 1809 case 'D': 1810 return std::make_pair(Qualifiers(Q_Const | Q_Volatile), false); 1811 } 1812 Error = true; 1813 return std::make_pair(Q_None, false); 1814 } 1815 1816 // <variable-type> ::= <type> <cvr-qualifiers> 1817 // ::= <type> <pointee-cvr-qualifiers> # pointers, references 1818 TypeNode *Demangler::demangleType(std::string_view &MangledName, 1819 QualifierMangleMode QMM) { 1820 Qualifiers Quals = Q_None; 1821 bool IsMember = false; 1822 if (QMM == QualifierMangleMode::Mangle) { 1823 std::tie(Quals, IsMember) = demangleQualifiers(MangledName); 1824 } else if (QMM == QualifierMangleMode::Result) { 1825 if (consumeFront(MangledName, '?')) 1826 std::tie(Quals, IsMember) = demangleQualifiers(MangledName); 1827 } 1828 1829 if (MangledName.empty()) { 1830 Error = true; 1831 return nullptr; 1832 } 1833 1834 TypeNode *Ty = nullptr; 1835 if (isTagType(MangledName)) 1836 Ty = demangleClassType(MangledName); 1837 else if (isPointerType(MangledName)) { 1838 if (isMemberPointer(MangledName, Error)) 1839 Ty = demangleMemberPointerType(MangledName); 1840 else if (!Error) 1841 Ty = demanglePointerType(MangledName); 1842 else 1843 return nullptr; 1844 } else if (isArrayType(MangledName)) 1845 Ty = demangleArrayType(MangledName); 1846 else if (isFunctionType(MangledName)) { 1847 if (consumeFront(MangledName, "$$A8@@")) 1848 Ty = demangleFunctionType(MangledName, true); 1849 else { 1850 assert(llvm::itanium_demangle::starts_with(MangledName, "$$A6")); 1851 consumeFront(MangledName, "$$A6"); 1852 Ty = demangleFunctionType(MangledName, false); 1853 } 1854 } else if (isCustomType(MangledName)) { 1855 Ty = demangleCustomType(MangledName); 1856 } else { 1857 Ty = demanglePrimitiveType(MangledName); 1858 } 1859 1860 if (!Ty || Error) 1861 return Ty; 1862 Ty->Quals = Qualifiers(Ty->Quals | Quals); 1863 return Ty; 1864 } 1865 1866 bool Demangler::demangleThrowSpecification(std::string_view &MangledName) { 1867 if (consumeFront(MangledName, "_E")) 1868 return true; 1869 if (consumeFront(MangledName, 'Z')) 1870 return false; 1871 1872 Error = true; 1873 return false; 1874 } 1875 1876 FunctionSignatureNode * 1877 Demangler::demangleFunctionType(std::string_view &MangledName, 1878 bool HasThisQuals) { 1879 FunctionSignatureNode *FTy = Arena.alloc<FunctionSignatureNode>(); 1880 1881 if (HasThisQuals) { 1882 FTy->Quals = demanglePointerExtQualifiers(MangledName); 1883 FTy->RefQualifier = demangleFunctionRefQualifier(MangledName); 1884 FTy->Quals = Qualifiers(FTy->Quals | demangleQualifiers(MangledName).first); 1885 } 1886 1887 // Fields that appear on both member and non-member functions. 1888 FTy->CallConvention = demangleCallingConvention(MangledName); 1889 1890 // <return-type> ::= <type> 1891 // ::= @ # structors (they have no declared return type) 1892 bool IsStructor = consumeFront(MangledName, '@'); 1893 if (!IsStructor) 1894 FTy->ReturnType = demangleType(MangledName, QualifierMangleMode::Result); 1895 1896 FTy->Params = demangleFunctionParameterList(MangledName, FTy->IsVariadic); 1897 1898 FTy->IsNoexcept = demangleThrowSpecification(MangledName); 1899 1900 return FTy; 1901 } 1902 1903 FunctionSymbolNode * 1904 Demangler::demangleFunctionEncoding(std::string_view &MangledName) { 1905 FuncClass ExtraFlags = FC_None; 1906 if (consumeFront(MangledName, "$$J0")) 1907 ExtraFlags = FC_ExternC; 1908 1909 if (MangledName.empty()) { 1910 Error = true; 1911 return nullptr; 1912 } 1913 1914 FuncClass FC = demangleFunctionClass(MangledName); 1915 FC = FuncClass(ExtraFlags | FC); 1916 1917 FunctionSignatureNode *FSN = nullptr; 1918 ThunkSignatureNode *TTN = nullptr; 1919 if (FC & FC_StaticThisAdjust) { 1920 TTN = Arena.alloc<ThunkSignatureNode>(); 1921 TTN->ThisAdjust.StaticOffset = demangleSigned(MangledName); 1922 } else if (FC & FC_VirtualThisAdjust) { 1923 TTN = Arena.alloc<ThunkSignatureNode>(); 1924 if (FC & FC_VirtualThisAdjustEx) { 1925 TTN->ThisAdjust.VBPtrOffset = demangleSigned(MangledName); 1926 TTN->ThisAdjust.VBOffsetOffset = demangleSigned(MangledName); 1927 } 1928 TTN->ThisAdjust.VtordispOffset = demangleSigned(MangledName); 1929 TTN->ThisAdjust.StaticOffset = demangleSigned(MangledName); 1930 } 1931 1932 if (FC & FC_NoParameterList) { 1933 // This is an extern "C" function whose full signature hasn't been mangled. 1934 // This happens when we need to mangle a local symbol inside of an extern 1935 // "C" function. 1936 FSN = Arena.alloc<FunctionSignatureNode>(); 1937 } else { 1938 bool HasThisQuals = !(FC & (FC_Global | FC_Static)); 1939 FSN = demangleFunctionType(MangledName, HasThisQuals); 1940 } 1941 1942 if (Error) 1943 return nullptr; 1944 1945 if (TTN) { 1946 *static_cast<FunctionSignatureNode *>(TTN) = *FSN; 1947 FSN = TTN; 1948 } 1949 FSN->FunctionClass = FC; 1950 1951 FunctionSymbolNode *Symbol = Arena.alloc<FunctionSymbolNode>(); 1952 Symbol->Signature = FSN; 1953 return Symbol; 1954 } 1955 1956 CustomTypeNode *Demangler::demangleCustomType(std::string_view &MangledName) { 1957 assert(llvm::itanium_demangle::starts_with(MangledName, '?')); 1958 MangledName.remove_prefix(1); 1959 1960 CustomTypeNode *CTN = Arena.alloc<CustomTypeNode>(); 1961 CTN->Identifier = demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true); 1962 if (!consumeFront(MangledName, '@')) 1963 Error = true; 1964 if (Error) 1965 return nullptr; 1966 return CTN; 1967 } 1968 1969 // Reads a primitive type. 1970 PrimitiveTypeNode * 1971 Demangler::demanglePrimitiveType(std::string_view &MangledName) { 1972 if (consumeFront(MangledName, "$$T")) 1973 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Nullptr); 1974 1975 const char F = MangledName.front(); 1976 MangledName.remove_prefix(1); 1977 switch (F) { 1978 case 'X': 1979 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Void); 1980 case 'D': 1981 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char); 1982 case 'C': 1983 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Schar); 1984 case 'E': 1985 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Uchar); 1986 case 'F': 1987 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Short); 1988 case 'G': 1989 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Ushort); 1990 case 'H': 1991 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Int); 1992 case 'I': 1993 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Uint); 1994 case 'J': 1995 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Long); 1996 case 'K': 1997 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Ulong); 1998 case 'M': 1999 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Float); 2000 case 'N': 2001 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Double); 2002 case 'O': 2003 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Ldouble); 2004 case '_': { 2005 if (MangledName.empty()) { 2006 Error = true; 2007 return nullptr; 2008 } 2009 const char F = MangledName.front(); 2010 MangledName.remove_prefix(1); 2011 switch (F) { 2012 case 'N': 2013 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Bool); 2014 case 'J': 2015 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Int64); 2016 case 'K': 2017 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Uint64); 2018 case 'W': 2019 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Wchar); 2020 case 'Q': 2021 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char8); 2022 case 'S': 2023 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char16); 2024 case 'U': 2025 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char32); 2026 } 2027 break; 2028 } 2029 } 2030 Error = true; 2031 return nullptr; 2032 } 2033 2034 TagTypeNode *Demangler::demangleClassType(std::string_view &MangledName) { 2035 TagTypeNode *TT = nullptr; 2036 2037 const char F = MangledName.front(); 2038 MangledName.remove_prefix(1); 2039 switch (F) { 2040 case 'T': 2041 TT = Arena.alloc<TagTypeNode>(TagKind::Union); 2042 break; 2043 case 'U': 2044 TT = Arena.alloc<TagTypeNode>(TagKind::Struct); 2045 break; 2046 case 'V': 2047 TT = Arena.alloc<TagTypeNode>(TagKind::Class); 2048 break; 2049 case 'W': 2050 if (!consumeFront(MangledName, '4')) { 2051 Error = true; 2052 return nullptr; 2053 } 2054 TT = Arena.alloc<TagTypeNode>(TagKind::Enum); 2055 break; 2056 default: 2057 assert(false); 2058 } 2059 2060 TT->QualifiedName = demangleFullyQualifiedTypeName(MangledName); 2061 return TT; 2062 } 2063 2064 // <pointer-type> ::= E? <pointer-cvr-qualifiers> <ext-qualifiers> <type> 2065 // # the E is required for 64-bit non-static pointers 2066 PointerTypeNode *Demangler::demanglePointerType(std::string_view &MangledName) { 2067 PointerTypeNode *Pointer = Arena.alloc<PointerTypeNode>(); 2068 2069 std::tie(Pointer->Quals, Pointer->Affinity) = 2070 demanglePointerCVQualifiers(MangledName); 2071 2072 if (consumeFront(MangledName, "6")) { 2073 Pointer->Pointee = demangleFunctionType(MangledName, false); 2074 return Pointer; 2075 } 2076 2077 Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName); 2078 Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals); 2079 2080 Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Mangle); 2081 return Pointer; 2082 } 2083 2084 PointerTypeNode * 2085 Demangler::demangleMemberPointerType(std::string_view &MangledName) { 2086 PointerTypeNode *Pointer = Arena.alloc<PointerTypeNode>(); 2087 2088 std::tie(Pointer->Quals, Pointer->Affinity) = 2089 demanglePointerCVQualifiers(MangledName); 2090 assert(Pointer->Affinity == PointerAffinity::Pointer); 2091 2092 Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName); 2093 Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals); 2094 2095 // isMemberPointer() only returns true if there is at least one character 2096 // after the qualifiers. 2097 if (consumeFront(MangledName, "8")) { 2098 Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName); 2099 Pointer->Pointee = demangleFunctionType(MangledName, true); 2100 } else { 2101 Qualifiers PointeeQuals = Q_None; 2102 bool IsMember = false; 2103 std::tie(PointeeQuals, IsMember) = demangleQualifiers(MangledName); 2104 assert(IsMember || Error); 2105 Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName); 2106 2107 Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Drop); 2108 if (Pointer->Pointee) 2109 Pointer->Pointee->Quals = PointeeQuals; 2110 } 2111 2112 return Pointer; 2113 } 2114 2115 Qualifiers 2116 Demangler::demanglePointerExtQualifiers(std::string_view &MangledName) { 2117 Qualifiers Quals = Q_None; 2118 if (consumeFront(MangledName, 'E')) 2119 Quals = Qualifiers(Quals | Q_Pointer64); 2120 if (consumeFront(MangledName, 'I')) 2121 Quals = Qualifiers(Quals | Q_Restrict); 2122 if (consumeFront(MangledName, 'F')) 2123 Quals = Qualifiers(Quals | Q_Unaligned); 2124 2125 return Quals; 2126 } 2127 2128 ArrayTypeNode *Demangler::demangleArrayType(std::string_view &MangledName) { 2129 assert(MangledName.front() == 'Y'); 2130 MangledName.remove_prefix(1); 2131 2132 uint64_t Rank = 0; 2133 bool IsNegative = false; 2134 std::tie(Rank, IsNegative) = demangleNumber(MangledName); 2135 if (IsNegative || Rank == 0) { 2136 Error = true; 2137 return nullptr; 2138 } 2139 2140 ArrayTypeNode *ATy = Arena.alloc<ArrayTypeNode>(); 2141 NodeList *Head = Arena.alloc<NodeList>(); 2142 NodeList *Tail = Head; 2143 2144 for (uint64_t I = 0; I < Rank; ++I) { 2145 uint64_t D = 0; 2146 std::tie(D, IsNegative) = demangleNumber(MangledName); 2147 if (Error || IsNegative) { 2148 Error = true; 2149 return nullptr; 2150 } 2151 Tail->N = Arena.alloc<IntegerLiteralNode>(D, IsNegative); 2152 if (I + 1 < Rank) { 2153 Tail->Next = Arena.alloc<NodeList>(); 2154 Tail = Tail->Next; 2155 } 2156 } 2157 ATy->Dimensions = nodeListToNodeArray(Arena, Head, Rank); 2158 2159 if (consumeFront(MangledName, "$$C")) { 2160 bool IsMember = false; 2161 std::tie(ATy->Quals, IsMember) = demangleQualifiers(MangledName); 2162 if (IsMember) { 2163 Error = true; 2164 return nullptr; 2165 } 2166 } 2167 2168 ATy->ElementType = demangleType(MangledName, QualifierMangleMode::Drop); 2169 return ATy; 2170 } 2171 2172 // Reads a function's parameters. 2173 NodeArrayNode * 2174 Demangler::demangleFunctionParameterList(std::string_view &MangledName, 2175 bool &IsVariadic) { 2176 // Empty parameter list. 2177 if (consumeFront(MangledName, 'X')) 2178 return nullptr; 2179 2180 NodeList *Head = Arena.alloc<NodeList>(); 2181 NodeList **Current = &Head; 2182 size_t Count = 0; 2183 while (!Error && !llvm::itanium_demangle::starts_with(MangledName, '@') && 2184 !llvm::itanium_demangle::starts_with(MangledName, 'Z')) { 2185 ++Count; 2186 2187 if (startsWithDigit(MangledName)) { 2188 size_t N = MangledName[0] - '0'; 2189 if (N >= Backrefs.FunctionParamCount) { 2190 Error = true; 2191 return nullptr; 2192 } 2193 MangledName.remove_prefix(1); 2194 2195 *Current = Arena.alloc<NodeList>(); 2196 (*Current)->N = Backrefs.FunctionParams[N]; 2197 Current = &(*Current)->Next; 2198 continue; 2199 } 2200 2201 size_t OldSize = MangledName.size(); 2202 2203 *Current = Arena.alloc<NodeList>(); 2204 TypeNode *TN = demangleType(MangledName, QualifierMangleMode::Drop); 2205 if (!TN || Error) 2206 return nullptr; 2207 2208 (*Current)->N = TN; 2209 2210 size_t CharsConsumed = OldSize - MangledName.size(); 2211 assert(CharsConsumed != 0); 2212 2213 // Single-letter types are ignored for backreferences because memorizing 2214 // them doesn't save anything. 2215 if (Backrefs.FunctionParamCount <= 9 && CharsConsumed > 1) 2216 Backrefs.FunctionParams[Backrefs.FunctionParamCount++] = TN; 2217 2218 Current = &(*Current)->Next; 2219 } 2220 2221 if (Error) 2222 return nullptr; 2223 2224 NodeArrayNode *NA = nodeListToNodeArray(Arena, Head, Count); 2225 // A non-empty parameter list is terminated by either 'Z' (variadic) parameter 2226 // list or '@' (non variadic). Careful not to consume "@Z", as in that case 2227 // the following Z could be a throw specifier. 2228 if (consumeFront(MangledName, '@')) 2229 return NA; 2230 2231 if (consumeFront(MangledName, 'Z')) { 2232 IsVariadic = true; 2233 return NA; 2234 } 2235 2236 DEMANGLE_UNREACHABLE; 2237 } 2238 2239 NodeArrayNode * 2240 Demangler::demangleTemplateParameterList(std::string_view &MangledName) { 2241 NodeList *Head = nullptr; 2242 NodeList **Current = &Head; 2243 size_t Count = 0; 2244 2245 while (!llvm::itanium_demangle::starts_with(MangledName, '@')) { 2246 if (consumeFront(MangledName, "$S") || consumeFront(MangledName, "$$V") || 2247 consumeFront(MangledName, "$$$V") || consumeFront(MangledName, "$$Z")) { 2248 // parameter pack separator 2249 continue; 2250 } 2251 2252 ++Count; 2253 2254 // Template parameter lists don't participate in back-referencing. 2255 *Current = Arena.alloc<NodeList>(); 2256 2257 NodeList &TP = **Current; 2258 2259 TemplateParameterReferenceNode *TPRN = nullptr; 2260 if (consumeFront(MangledName, "$$Y")) { 2261 // Template alias 2262 TP.N = demangleFullyQualifiedTypeName(MangledName); 2263 } else if (consumeFront(MangledName, "$$B")) { 2264 // Array 2265 TP.N = demangleType(MangledName, QualifierMangleMode::Drop); 2266 } else if (consumeFront(MangledName, "$$C")) { 2267 // Type has qualifiers. 2268 TP.N = demangleType(MangledName, QualifierMangleMode::Mangle); 2269 } else if (llvm::itanium_demangle::starts_with(MangledName, "$1") || 2270 llvm::itanium_demangle::starts_with(MangledName, "$H") || 2271 llvm::itanium_demangle::starts_with(MangledName, "$I") || 2272 llvm::itanium_demangle::starts_with(MangledName, "$J")) { 2273 // Pointer to member 2274 TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>(); 2275 TPRN->IsMemberPointer = true; 2276 2277 MangledName.remove_prefix(1); 2278 // 1 - single inheritance <name> 2279 // H - multiple inheritance <name> <number> 2280 // I - virtual inheritance <name> <number> <number> 2281 // J - unspecified inheritance <name> <number> <number> <number> 2282 char InheritanceSpecifier = MangledName.front(); 2283 MangledName.remove_prefix(1); 2284 SymbolNode *S = nullptr; 2285 if (llvm::itanium_demangle::starts_with(MangledName, '?')) { 2286 S = parse(MangledName); 2287 if (Error || !S->Name) { 2288 Error = true; 2289 return nullptr; 2290 } 2291 memorizeIdentifier(S->Name->getUnqualifiedIdentifier()); 2292 } 2293 2294 switch (InheritanceSpecifier) { 2295 case 'J': 2296 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = 2297 demangleSigned(MangledName); 2298 DEMANGLE_FALLTHROUGH; 2299 case 'I': 2300 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = 2301 demangleSigned(MangledName); 2302 DEMANGLE_FALLTHROUGH; 2303 case 'H': 2304 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = 2305 demangleSigned(MangledName); 2306 DEMANGLE_FALLTHROUGH; 2307 case '1': 2308 break; 2309 default: 2310 DEMANGLE_UNREACHABLE; 2311 } 2312 TPRN->Affinity = PointerAffinity::Pointer; 2313 TPRN->Symbol = S; 2314 } else if (llvm::itanium_demangle::starts_with(MangledName, "$E?")) { 2315 consumeFront(MangledName, "$E"); 2316 // Reference to symbol 2317 TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>(); 2318 TPRN->Symbol = parse(MangledName); 2319 TPRN->Affinity = PointerAffinity::Reference; 2320 } else if (llvm::itanium_demangle::starts_with(MangledName, "$F") || 2321 llvm::itanium_demangle::starts_with(MangledName, "$G")) { 2322 TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>(); 2323 2324 // Data member pointer. 2325 MangledName.remove_prefix(1); 2326 char InheritanceSpecifier = MangledName.front(); 2327 MangledName.remove_prefix(1); 2328 2329 switch (InheritanceSpecifier) { 2330 case 'G': 2331 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = 2332 demangleSigned(MangledName); 2333 DEMANGLE_FALLTHROUGH; 2334 case 'F': 2335 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = 2336 demangleSigned(MangledName); 2337 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] = 2338 demangleSigned(MangledName); 2339 break; 2340 default: 2341 DEMANGLE_UNREACHABLE; 2342 } 2343 TPRN->IsMemberPointer = true; 2344 2345 } else if (consumeFront(MangledName, "$0")) { 2346 // Integral non-type template parameter 2347 bool IsNegative = false; 2348 uint64_t Value = 0; 2349 std::tie(Value, IsNegative) = demangleNumber(MangledName); 2350 2351 TP.N = Arena.alloc<IntegerLiteralNode>(Value, IsNegative); 2352 } else { 2353 TP.N = demangleType(MangledName, QualifierMangleMode::Drop); 2354 } 2355 if (Error) 2356 return nullptr; 2357 2358 Current = &TP.Next; 2359 } 2360 2361 // The loop above returns nullptr on Error. 2362 assert(!Error); 2363 2364 // Template parameter lists cannot be variadic, so it can only be terminated 2365 // by @ (as opposed to 'Z' in the function parameter case). 2366 assert(llvm::itanium_demangle::starts_with( 2367 MangledName, '@')); // The above loop exits only on '@'. 2368 consumeFront(MangledName, '@'); 2369 return nodeListToNodeArray(Arena, Head, Count); 2370 } 2371 2372 void Demangler::dumpBackReferences() { 2373 std::printf("%d function parameter backreferences\n", 2374 (int)Backrefs.FunctionParamCount); 2375 2376 // Create an output stream so we can render each type. 2377 OutputBuffer OB; 2378 for (size_t I = 0; I < Backrefs.FunctionParamCount; ++I) { 2379 OB.setCurrentPosition(0); 2380 2381 TypeNode *T = Backrefs.FunctionParams[I]; 2382 T->output(OB, OF_Default); 2383 2384 std::string_view B = OB; 2385 std::printf(" [%d] - %.*s\n", (int)I, (int)B.size(), B.data()); 2386 } 2387 std::free(OB.getBuffer()); 2388 2389 if (Backrefs.FunctionParamCount > 0) 2390 std::printf("\n"); 2391 std::printf("%d name backreferences\n", (int)Backrefs.NamesCount); 2392 for (size_t I = 0; I < Backrefs.NamesCount; ++I) { 2393 std::printf(" [%d] - %.*s\n", (int)I, (int)Backrefs.Names[I]->Name.size(), 2394 Backrefs.Names[I]->Name.data()); 2395 } 2396 if (Backrefs.NamesCount > 0) 2397 std::printf("\n"); 2398 } 2399 2400 char *llvm::microsoftDemangle(std::string_view MangledName, size_t *NMangled, 2401 int *Status, MSDemangleFlags Flags) { 2402 Demangler D; 2403 2404 std::string_view Name{MangledName}; 2405 SymbolNode *AST = D.parse(Name); 2406 if (!D.Error && NMangled) 2407 *NMangled = MangledName.size() - Name.size(); 2408 2409 if (Flags & MSDF_DumpBackrefs) 2410 D.dumpBackReferences(); 2411 2412 OutputFlags OF = OF_Default; 2413 if (Flags & MSDF_NoCallingConvention) 2414 OF = OutputFlags(OF | OF_NoCallingConvention); 2415 if (Flags & MSDF_NoAccessSpecifier) 2416 OF = OutputFlags(OF | OF_NoAccessSpecifier); 2417 if (Flags & MSDF_NoReturnType) 2418 OF = OutputFlags(OF | OF_NoReturnType); 2419 if (Flags & MSDF_NoMemberType) 2420 OF = OutputFlags(OF | OF_NoMemberType); 2421 if (Flags & MSDF_NoVariableType) 2422 OF = OutputFlags(OF | OF_NoVariableType); 2423 2424 int InternalStatus = demangle_success; 2425 char *Buf; 2426 if (D.Error) 2427 InternalStatus = demangle_invalid_mangled_name; 2428 else { 2429 OutputBuffer OB; 2430 AST->output(OB, OF); 2431 OB += '\0'; 2432 Buf = OB.getBuffer(); 2433 } 2434 2435 if (Status) 2436 *Status = InternalStatus; 2437 return InternalStatus == demangle_success ? Buf : nullptr; 2438 } 2439