1 //===------------------------- ItaniumDemangle.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 // FIXME: (possibly) incomplete list of features that clang mangles that this 10 // file does not yet support: 11 // - C++ modules TS 12 13 #include "llvm/Demangle/Demangle.h" 14 #include "llvm/Demangle/ItaniumDemangle.h" 15 16 #include <cassert> 17 #include <cctype> 18 #include <cstdio> 19 #include <cstdlib> 20 #include <cstring> 21 #include <exception> 22 #include <functional> 23 #include <utility> 24 25 using namespace llvm; 26 using namespace llvm::itanium_demangle; 27 28 constexpr const char *itanium_demangle::FloatData<float>::spec; 29 constexpr const char *itanium_demangle::FloatData<double>::spec; 30 constexpr const char *itanium_demangle::FloatData<long double>::spec; 31 32 // <discriminator> := _ <non-negative number> # when number < 10 33 // := __ <non-negative number> _ # when number >= 10 34 // extension := decimal-digit+ # at the end of string 35 const char *itanium_demangle::parse_discriminator(const char *first, 36 const char *last) { 37 // parse but ignore discriminator 38 if (first != last) { 39 if (*first == '_') { 40 const char *t1 = first + 1; 41 if (t1 != last) { 42 if (std::isdigit(*t1)) 43 first = t1 + 1; 44 else if (*t1 == '_') { 45 for (++t1; t1 != last && std::isdigit(*t1); ++t1) 46 ; 47 if (t1 != last && *t1 == '_') 48 first = t1 + 1; 49 } 50 } 51 } else if (std::isdigit(*first)) { 52 const char *t1 = first + 1; 53 for (; t1 != last && std::isdigit(*t1); ++t1) 54 ; 55 if (t1 == last) 56 first = last; 57 } 58 } 59 return first; 60 } 61 62 #ifndef NDEBUG 63 namespace { 64 struct DumpVisitor { 65 unsigned Depth = 0; 66 bool PendingNewline = false; 67 68 template<typename NodeT> static constexpr bool wantsNewline(const NodeT *) { 69 return true; 70 } 71 static bool wantsNewline(NodeArray A) { return !A.empty(); } 72 static constexpr bool wantsNewline(...) { return false; } 73 74 template<typename ...Ts> static bool anyWantNewline(Ts ...Vs) { 75 for (bool B : {wantsNewline(Vs)...}) 76 if (B) 77 return true; 78 return false; 79 } 80 81 void printStr(const char *S) { fprintf(stderr, "%s", S); } 82 void print(std::string_view SV) { 83 fprintf(stderr, "\"%.*s\"", (int)SV.size(), SV.data()); 84 } 85 void print(const Node *N) { 86 if (N) 87 N->visit(std::ref(*this)); 88 else 89 printStr("<null>"); 90 } 91 void print(NodeArray A) { 92 ++Depth; 93 printStr("{"); 94 bool First = true; 95 for (const Node *N : A) { 96 if (First) 97 print(N); 98 else 99 printWithComma(N); 100 First = false; 101 } 102 printStr("}"); 103 --Depth; 104 } 105 106 // Overload used when T is exactly 'bool', not merely convertible to 'bool'. 107 void print(bool B) { printStr(B ? "true" : "false"); } 108 109 template <class T> std::enable_if_t<std::is_unsigned<T>::value> print(T N) { 110 fprintf(stderr, "%llu", (unsigned long long)N); 111 } 112 113 template <class T> std::enable_if_t<std::is_signed<T>::value> print(T N) { 114 fprintf(stderr, "%lld", (long long)N); 115 } 116 117 void print(ReferenceKind RK) { 118 switch (RK) { 119 case ReferenceKind::LValue: 120 return printStr("ReferenceKind::LValue"); 121 case ReferenceKind::RValue: 122 return printStr("ReferenceKind::RValue"); 123 } 124 } 125 void print(FunctionRefQual RQ) { 126 switch (RQ) { 127 case FunctionRefQual::FrefQualNone: 128 return printStr("FunctionRefQual::FrefQualNone"); 129 case FunctionRefQual::FrefQualLValue: 130 return printStr("FunctionRefQual::FrefQualLValue"); 131 case FunctionRefQual::FrefQualRValue: 132 return printStr("FunctionRefQual::FrefQualRValue"); 133 } 134 } 135 void print(Qualifiers Qs) { 136 if (!Qs) return printStr("QualNone"); 137 struct QualName { Qualifiers Q; const char *Name; } Names[] = { 138 {QualConst, "QualConst"}, 139 {QualVolatile, "QualVolatile"}, 140 {QualRestrict, "QualRestrict"}, 141 }; 142 for (QualName Name : Names) { 143 if (Qs & Name.Q) { 144 printStr(Name.Name); 145 Qs = Qualifiers(Qs & ~Name.Q); 146 if (Qs) printStr(" | "); 147 } 148 } 149 } 150 void print(SpecialSubKind SSK) { 151 switch (SSK) { 152 case SpecialSubKind::allocator: 153 return printStr("SpecialSubKind::allocator"); 154 case SpecialSubKind::basic_string: 155 return printStr("SpecialSubKind::basic_string"); 156 case SpecialSubKind::string: 157 return printStr("SpecialSubKind::string"); 158 case SpecialSubKind::istream: 159 return printStr("SpecialSubKind::istream"); 160 case SpecialSubKind::ostream: 161 return printStr("SpecialSubKind::ostream"); 162 case SpecialSubKind::iostream: 163 return printStr("SpecialSubKind::iostream"); 164 } 165 } 166 void print(TemplateParamKind TPK) { 167 switch (TPK) { 168 case TemplateParamKind::Type: 169 return printStr("TemplateParamKind::Type"); 170 case TemplateParamKind::NonType: 171 return printStr("TemplateParamKind::NonType"); 172 case TemplateParamKind::Template: 173 return printStr("TemplateParamKind::Template"); 174 } 175 } 176 void print(Node::Prec P) { 177 switch (P) { 178 case Node::Prec::Primary: 179 return printStr("Node::Prec::Primary"); 180 case Node::Prec::Postfix: 181 return printStr("Node::Prec::Postfix"); 182 case Node::Prec::Unary: 183 return printStr("Node::Prec::Unary"); 184 case Node::Prec::Cast: 185 return printStr("Node::Prec::Cast"); 186 case Node::Prec::PtrMem: 187 return printStr("Node::Prec::PtrMem"); 188 case Node::Prec::Multiplicative: 189 return printStr("Node::Prec::Multiplicative"); 190 case Node::Prec::Additive: 191 return printStr("Node::Prec::Additive"); 192 case Node::Prec::Shift: 193 return printStr("Node::Prec::Shift"); 194 case Node::Prec::Spaceship: 195 return printStr("Node::Prec::Spaceship"); 196 case Node::Prec::Relational: 197 return printStr("Node::Prec::Relational"); 198 case Node::Prec::Equality: 199 return printStr("Node::Prec::Equality"); 200 case Node::Prec::And: 201 return printStr("Node::Prec::And"); 202 case Node::Prec::Xor: 203 return printStr("Node::Prec::Xor"); 204 case Node::Prec::Ior: 205 return printStr("Node::Prec::Ior"); 206 case Node::Prec::AndIf: 207 return printStr("Node::Prec::AndIf"); 208 case Node::Prec::OrIf: 209 return printStr("Node::Prec::OrIf"); 210 case Node::Prec::Conditional: 211 return printStr("Node::Prec::Conditional"); 212 case Node::Prec::Assign: 213 return printStr("Node::Prec::Assign"); 214 case Node::Prec::Comma: 215 return printStr("Node::Prec::Comma"); 216 case Node::Prec::Default: 217 return printStr("Node::Prec::Default"); 218 } 219 } 220 221 void newLine() { 222 printStr("\n"); 223 for (unsigned I = 0; I != Depth; ++I) 224 printStr(" "); 225 PendingNewline = false; 226 } 227 228 template<typename T> void printWithPendingNewline(T V) { 229 print(V); 230 if (wantsNewline(V)) 231 PendingNewline = true; 232 } 233 234 template<typename T> void printWithComma(T V) { 235 if (PendingNewline || wantsNewline(V)) { 236 printStr(","); 237 newLine(); 238 } else { 239 printStr(", "); 240 } 241 242 printWithPendingNewline(V); 243 } 244 245 struct CtorArgPrinter { 246 DumpVisitor &Visitor; 247 248 template<typename T, typename ...Rest> void operator()(T V, Rest ...Vs) { 249 if (Visitor.anyWantNewline(V, Vs...)) 250 Visitor.newLine(); 251 Visitor.printWithPendingNewline(V); 252 int PrintInOrder[] = { (Visitor.printWithComma(Vs), 0)..., 0 }; 253 (void)PrintInOrder; 254 } 255 }; 256 257 template<typename NodeT> void operator()(const NodeT *Node) { 258 Depth += 2; 259 fprintf(stderr, "%s(", itanium_demangle::NodeKind<NodeT>::name()); 260 Node->match(CtorArgPrinter{*this}); 261 fprintf(stderr, ")"); 262 Depth -= 2; 263 } 264 265 void operator()(const ForwardTemplateReference *Node) { 266 Depth += 2; 267 fprintf(stderr, "ForwardTemplateReference("); 268 if (Node->Ref && !Node->Printing) { 269 Node->Printing = true; 270 CtorArgPrinter{*this}(Node->Ref); 271 Node->Printing = false; 272 } else { 273 CtorArgPrinter{*this}(Node->Index); 274 } 275 fprintf(stderr, ")"); 276 Depth -= 2; 277 } 278 }; 279 } 280 281 void itanium_demangle::Node::dump() const { 282 DumpVisitor V; 283 visit(std::ref(V)); 284 V.newLine(); 285 } 286 #endif 287 288 namespace { 289 class BumpPointerAllocator { 290 struct BlockMeta { 291 BlockMeta* Next; 292 size_t Current; 293 }; 294 295 static constexpr size_t AllocSize = 4096; 296 static constexpr size_t UsableAllocSize = AllocSize - sizeof(BlockMeta); 297 298 alignas(long double) char InitialBuffer[AllocSize]; 299 BlockMeta* BlockList = nullptr; 300 301 void grow() { 302 char* NewMeta = static_cast<char *>(std::malloc(AllocSize)); 303 if (NewMeta == nullptr) 304 std::terminate(); 305 BlockList = new (NewMeta) BlockMeta{BlockList, 0}; 306 } 307 308 void* allocateMassive(size_t NBytes) { 309 NBytes += sizeof(BlockMeta); 310 BlockMeta* NewMeta = reinterpret_cast<BlockMeta*>(std::malloc(NBytes)); 311 if (NewMeta == nullptr) 312 std::terminate(); 313 BlockList->Next = new (NewMeta) BlockMeta{BlockList->Next, 0}; 314 return static_cast<void*>(NewMeta + 1); 315 } 316 317 public: 318 BumpPointerAllocator() 319 : BlockList(new (InitialBuffer) BlockMeta{nullptr, 0}) {} 320 321 void* allocate(size_t N) { 322 N = (N + 15u) & ~15u; 323 if (N + BlockList->Current >= UsableAllocSize) { 324 if (N > UsableAllocSize) 325 return allocateMassive(N); 326 grow(); 327 } 328 BlockList->Current += N; 329 return static_cast<void*>(reinterpret_cast<char*>(BlockList + 1) + 330 BlockList->Current - N); 331 } 332 333 void reset() { 334 while (BlockList) { 335 BlockMeta* Tmp = BlockList; 336 BlockList = BlockList->Next; 337 if (reinterpret_cast<char*>(Tmp) != InitialBuffer) 338 std::free(Tmp); 339 } 340 BlockList = new (InitialBuffer) BlockMeta{nullptr, 0}; 341 } 342 343 ~BumpPointerAllocator() { reset(); } 344 }; 345 346 class DefaultAllocator { 347 BumpPointerAllocator Alloc; 348 349 public: 350 void reset() { Alloc.reset(); } 351 352 template<typename T, typename ...Args> T *makeNode(Args &&...args) { 353 return new (Alloc.allocate(sizeof(T))) 354 T(std::forward<Args>(args)...); 355 } 356 357 void *allocateNodeArray(size_t sz) { 358 return Alloc.allocate(sizeof(Node *) * sz); 359 } 360 }; 361 } // unnamed namespace 362 363 //===----------------------------------------------------------------------===// 364 // Code beyond this point should not be synchronized with libc++abi. 365 //===----------------------------------------------------------------------===// 366 367 using Demangler = itanium_demangle::ManglingParser<DefaultAllocator>; 368 369 char *llvm::itaniumDemangle(std::string_view MangledName) { 370 if (MangledName.empty()) 371 return nullptr; 372 373 Demangler Parser(MangledName.data(), 374 MangledName.data() + MangledName.length()); 375 Node *AST = Parser.parse(); 376 if (!AST) 377 return nullptr; 378 379 OutputBuffer OB; 380 assert(Parser.ForwardTemplateRefs.empty()); 381 AST->print(OB); 382 OB += '\0'; 383 return OB.getBuffer(); 384 } 385 386 ItaniumPartialDemangler::ItaniumPartialDemangler() 387 : RootNode(nullptr), Context(new Demangler{nullptr, nullptr}) {} 388 389 ItaniumPartialDemangler::~ItaniumPartialDemangler() { 390 delete static_cast<Demangler *>(Context); 391 } 392 393 ItaniumPartialDemangler::ItaniumPartialDemangler( 394 ItaniumPartialDemangler &&Other) 395 : RootNode(Other.RootNode), Context(Other.Context) { 396 Other.Context = Other.RootNode = nullptr; 397 } 398 399 ItaniumPartialDemangler &ItaniumPartialDemangler:: 400 operator=(ItaniumPartialDemangler &&Other) { 401 std::swap(RootNode, Other.RootNode); 402 std::swap(Context, Other.Context); 403 return *this; 404 } 405 406 // Demangle MangledName into an AST, storing it into this->RootNode. 407 bool ItaniumPartialDemangler::partialDemangle(const char *MangledName) { 408 Demangler *Parser = static_cast<Demangler *>(Context); 409 size_t Len = std::strlen(MangledName); 410 Parser->reset(MangledName, MangledName + Len); 411 RootNode = Parser->parse(); 412 return RootNode == nullptr; 413 } 414 415 static char *printNode(const Node *RootNode, char *Buf, size_t *N) { 416 OutputBuffer OB(Buf, N); 417 RootNode->print(OB); 418 OB += '\0'; 419 if (N != nullptr) 420 *N = OB.getCurrentPosition(); 421 return OB.getBuffer(); 422 } 423 424 char *ItaniumPartialDemangler::getFunctionBaseName(char *Buf, size_t *N) const { 425 if (!isFunction()) 426 return nullptr; 427 428 const Node *Name = static_cast<const FunctionEncoding *>(RootNode)->getName(); 429 430 while (true) { 431 switch (Name->getKind()) { 432 case Node::KAbiTagAttr: 433 Name = static_cast<const AbiTagAttr *>(Name)->Base; 434 continue; 435 case Node::KModuleEntity: 436 Name = static_cast<const ModuleEntity *>(Name)->Name; 437 continue; 438 case Node::KNestedName: 439 Name = static_cast<const NestedName *>(Name)->Name; 440 continue; 441 case Node::KLocalName: 442 Name = static_cast<const LocalName *>(Name)->Entity; 443 continue; 444 case Node::KNameWithTemplateArgs: 445 Name = static_cast<const NameWithTemplateArgs *>(Name)->Name; 446 continue; 447 default: 448 return printNode(Name, Buf, N); 449 } 450 } 451 } 452 453 char *ItaniumPartialDemangler::getFunctionDeclContextName(char *Buf, 454 size_t *N) const { 455 if (!isFunction()) 456 return nullptr; 457 const Node *Name = static_cast<const FunctionEncoding *>(RootNode)->getName(); 458 459 OutputBuffer OB(Buf, N); 460 461 KeepGoingLocalFunction: 462 while (true) { 463 if (Name->getKind() == Node::KAbiTagAttr) { 464 Name = static_cast<const AbiTagAttr *>(Name)->Base; 465 continue; 466 } 467 if (Name->getKind() == Node::KNameWithTemplateArgs) { 468 Name = static_cast<const NameWithTemplateArgs *>(Name)->Name; 469 continue; 470 } 471 break; 472 } 473 474 if (Name->getKind() == Node::KModuleEntity) 475 Name = static_cast<const ModuleEntity *>(Name)->Name; 476 477 switch (Name->getKind()) { 478 case Node::KNestedName: 479 static_cast<const NestedName *>(Name)->Qual->print(OB); 480 break; 481 case Node::KLocalName: { 482 auto *LN = static_cast<const LocalName *>(Name); 483 LN->Encoding->print(OB); 484 OB += "::"; 485 Name = LN->Entity; 486 goto KeepGoingLocalFunction; 487 } 488 default: 489 break; 490 } 491 OB += '\0'; 492 if (N != nullptr) 493 *N = OB.getCurrentPosition(); 494 return OB.getBuffer(); 495 } 496 497 char *ItaniumPartialDemangler::getFunctionName(char *Buf, size_t *N) const { 498 if (!isFunction()) 499 return nullptr; 500 auto *Name = static_cast<FunctionEncoding *>(RootNode)->getName(); 501 return printNode(Name, Buf, N); 502 } 503 504 char *ItaniumPartialDemangler::getFunctionParameters(char *Buf, 505 size_t *N) const { 506 if (!isFunction()) 507 return nullptr; 508 NodeArray Params = static_cast<FunctionEncoding *>(RootNode)->getParams(); 509 510 OutputBuffer OB(Buf, N); 511 512 OB += '('; 513 Params.printWithComma(OB); 514 OB += ')'; 515 OB += '\0'; 516 if (N != nullptr) 517 *N = OB.getCurrentPosition(); 518 return OB.getBuffer(); 519 } 520 521 char *ItaniumPartialDemangler::getFunctionReturnType( 522 char *Buf, size_t *N) const { 523 if (!isFunction()) 524 return nullptr; 525 526 OutputBuffer OB(Buf, N); 527 528 if (const Node *Ret = 529 static_cast<const FunctionEncoding *>(RootNode)->getReturnType()) 530 Ret->print(OB); 531 532 OB += '\0'; 533 if (N != nullptr) 534 *N = OB.getCurrentPosition(); 535 return OB.getBuffer(); 536 } 537 538 char *ItaniumPartialDemangler::finishDemangle(char *Buf, size_t *N) const { 539 assert(RootNode != nullptr && "must call partialDemangle()"); 540 return printNode(static_cast<Node *>(RootNode), Buf, N); 541 } 542 543 bool ItaniumPartialDemangler::hasFunctionQualifiers() const { 544 assert(RootNode != nullptr && "must call partialDemangle()"); 545 if (!isFunction()) 546 return false; 547 auto *E = static_cast<const FunctionEncoding *>(RootNode); 548 return E->getCVQuals() != QualNone || E->getRefQual() != FrefQualNone; 549 } 550 551 bool ItaniumPartialDemangler::isCtorOrDtor() const { 552 const Node *N = static_cast<const Node *>(RootNode); 553 while (N) { 554 switch (N->getKind()) { 555 default: 556 return false; 557 case Node::KCtorDtorName: 558 return true; 559 560 case Node::KAbiTagAttr: 561 N = static_cast<const AbiTagAttr *>(N)->Base; 562 break; 563 case Node::KFunctionEncoding: 564 N = static_cast<const FunctionEncoding *>(N)->getName(); 565 break; 566 case Node::KLocalName: 567 N = static_cast<const LocalName *>(N)->Entity; 568 break; 569 case Node::KNameWithTemplateArgs: 570 N = static_cast<const NameWithTemplateArgs *>(N)->Name; 571 break; 572 case Node::KNestedName: 573 N = static_cast<const NestedName *>(N)->Name; 574 break; 575 case Node::KModuleEntity: 576 N = static_cast<const ModuleEntity *>(N)->Name; 577 break; 578 } 579 } 580 return false; 581 } 582 583 bool ItaniumPartialDemangler::isFunction() const { 584 assert(RootNode != nullptr && "must call partialDemangle()"); 585 return static_cast<const Node *>(RootNode)->getKind() == 586 Node::KFunctionEncoding; 587 } 588 589 bool ItaniumPartialDemangler::isSpecialName() const { 590 assert(RootNode != nullptr && "must call partialDemangle()"); 591 auto K = static_cast<const Node *>(RootNode)->getKind(); 592 return K == Node::KSpecialName || K == Node::KCtorVtableSpecialName; 593 } 594 595 bool ItaniumPartialDemangler::isData() const { 596 return !isFunction() && !isSpecialName(); 597 } 598