llvm/lib/Demangle/ItaniumDemangle.cpp

   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, bool ParseParams) {
 370   if (MangledName.empty())
 371     return nullptr;
 372
 373   Demangler Parser(MangledName.data(),
 374                    MangledName.data() + MangledName.length());
 375   Node *AST = Parser.parse(ParseParams);
 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 }