| //===------------------------- ItaniumDemangle.cpp ------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // FIXME: (possibly) incomplete list of features that clang mangles that this |
| // file does not yet support: |
| // - C++ modules TS |
| |
| #include "llvm/Demangle/Demangle.h" |
| #include "llvm/Demangle/ItaniumDemangle.h" |
| |
| #include <cassert> |
| #include <cctype> |
| #include <cstdio> |
| #include <cstdlib> |
| #include <cstring> |
| #include <functional> |
| #include <utility> |
| |
| using namespace llvm; |
| using namespace llvm::itanium_demangle; |
| |
| constexpr const char *itanium_demangle::FloatData<float>::spec; |
| constexpr const char *itanium_demangle::FloatData<double>::spec; |
| constexpr const char *itanium_demangle::FloatData<long double>::spec; |
| |
| // <discriminator> := _ <non-negative number> # when number < 10 |
| // := __ <non-negative number> _ # when number >= 10 |
| // extension := decimal-digit+ # at the end of string |
| const char *itanium_demangle::parse_discriminator(const char *first, |
| const char *last) { |
| // parse but ignore discriminator |
| if (first != last) { |
| if (*first == '_') { |
| const char *t1 = first + 1; |
| if (t1 != last) { |
| if (std::isdigit(*t1)) |
| first = t1 + 1; |
| else if (*t1 == '_') { |
| for (++t1; t1 != last && std::isdigit(*t1); ++t1) |
| ; |
| if (t1 != last && *t1 == '_') |
| first = t1 + 1; |
| } |
| } |
| } else if (std::isdigit(*first)) { |
| const char *t1 = first + 1; |
| for (; t1 != last && std::isdigit(*t1); ++t1) |
| ; |
| if (t1 == last) |
| first = last; |
| } |
| } |
| return first; |
| } |
| |
| #ifndef NDEBUG |
| namespace { |
| struct DumpVisitor { |
| unsigned Depth = 0; |
| bool PendingNewline = false; |
| |
| template<typename NodeT> static constexpr bool wantsNewline(const NodeT *) { |
| return true; |
| } |
| static bool wantsNewline(NodeArray A) { return !A.empty(); } |
| static constexpr bool wantsNewline(...) { return false; } |
| |
| template<typename ...Ts> static bool anyWantNewline(Ts ...Vs) { |
| for (bool B : {wantsNewline(Vs)...}) |
| if (B) |
| return true; |
| return false; |
| } |
| |
| void printStr(const char *S) { fprintf(stderr, "%s", S); } |
| void print(std::string_view SV) { |
| fprintf(stderr, "\"%.*s\"", (int)SV.size(), &*SV.begin()); |
| } |
| void print(const Node *N) { |
| if (N) |
| N->visit(std::ref(*this)); |
| else |
| printStr("<null>"); |
| } |
| void print(NodeArray A) { |
| ++Depth; |
| printStr("{"); |
| bool First = true; |
| for (const Node *N : A) { |
| if (First) |
| print(N); |
| else |
| printWithComma(N); |
| First = false; |
| } |
| printStr("}"); |
| --Depth; |
| } |
| |
| // Overload used when T is exactly 'bool', not merely convertible to 'bool'. |
| void print(bool B) { printStr(B ? "true" : "false"); } |
| |
| template <class T> std::enable_if_t<std::is_unsigned<T>::value> print(T N) { |
| fprintf(stderr, "%llu", (unsigned long long)N); |
| } |
| |
| template <class T> std::enable_if_t<std::is_signed<T>::value> print(T N) { |
| fprintf(stderr, "%lld", (long long)N); |
| } |
| |
| void print(ReferenceKind RK) { |
| switch (RK) { |
| case ReferenceKind::LValue: |
| return printStr("ReferenceKind::LValue"); |
| case ReferenceKind::RValue: |
| return printStr("ReferenceKind::RValue"); |
| } |
| } |
| void print(FunctionRefQual RQ) { |
| switch (RQ) { |
| case FunctionRefQual::FrefQualNone: |
| return printStr("FunctionRefQual::FrefQualNone"); |
| case FunctionRefQual::FrefQualLValue: |
| return printStr("FunctionRefQual::FrefQualLValue"); |
| case FunctionRefQual::FrefQualRValue: |
| return printStr("FunctionRefQual::FrefQualRValue"); |
| } |
| } |
| void print(Qualifiers Qs) { |
| if (!Qs) return printStr("QualNone"); |
| struct QualName { Qualifiers Q; const char *Name; } Names[] = { |
| {QualConst, "QualConst"}, |
| {QualVolatile, "QualVolatile"}, |
| {QualRestrict, "QualRestrict"}, |
| }; |
| for (QualName Name : Names) { |
| if (Qs & Name.Q) { |
| printStr(Name.Name); |
| Qs = Qualifiers(Qs & ~Name.Q); |
| if (Qs) printStr(" | "); |
| } |
| } |
| } |
| void print(SpecialSubKind SSK) { |
| switch (SSK) { |
| case SpecialSubKind::allocator: |
| return printStr("SpecialSubKind::allocator"); |
| case SpecialSubKind::basic_string: |
| return printStr("SpecialSubKind::basic_string"); |
| case SpecialSubKind::string: |
| return printStr("SpecialSubKind::string"); |
| case SpecialSubKind::istream: |
| return printStr("SpecialSubKind::istream"); |
| case SpecialSubKind::ostream: |
| return printStr("SpecialSubKind::ostream"); |
| case SpecialSubKind::iostream: |
| return printStr("SpecialSubKind::iostream"); |
| } |
| } |
| void print(TemplateParamKind TPK) { |
| switch (TPK) { |
| case TemplateParamKind::Type: |
| return printStr("TemplateParamKind::Type"); |
| case TemplateParamKind::NonType: |
| return printStr("TemplateParamKind::NonType"); |
| case TemplateParamKind::Template: |
| return printStr("TemplateParamKind::Template"); |
| } |
| } |
| void print(Node::Prec P) { |
| switch (P) { |
| case Node::Prec::Primary: |
| return printStr("Node::Prec::Primary"); |
| case Node::Prec::Postfix: |
| return printStr("Node::Prec::Postfix"); |
| case Node::Prec::Unary: |
| return printStr("Node::Prec::Unary"); |
| case Node::Prec::Cast: |
| return printStr("Node::Prec::Cast"); |
| case Node::Prec::PtrMem: |
| return printStr("Node::Prec::PtrMem"); |
| case Node::Prec::Multiplicative: |
| return printStr("Node::Prec::Multiplicative"); |
| case Node::Prec::Additive: |
| return printStr("Node::Prec::Additive"); |
| case Node::Prec::Shift: |
| return printStr("Node::Prec::Shift"); |
| case Node::Prec::Spaceship: |
| return printStr("Node::Prec::Spaceship"); |
| case Node::Prec::Relational: |
| return printStr("Node::Prec::Relational"); |
| case Node::Prec::Equality: |
| return printStr("Node::Prec::Equality"); |
| case Node::Prec::And: |
| return printStr("Node::Prec::And"); |
| case Node::Prec::Xor: |
| return printStr("Node::Prec::Xor"); |
| case Node::Prec::Ior: |
| return printStr("Node::Prec::Ior"); |
| case Node::Prec::AndIf: |
| return printStr("Node::Prec::AndIf"); |
| case Node::Prec::OrIf: |
| return printStr("Node::Prec::OrIf"); |
| case Node::Prec::Conditional: |
| return printStr("Node::Prec::Conditional"); |
| case Node::Prec::Assign: |
| return printStr("Node::Prec::Assign"); |
| case Node::Prec::Comma: |
| return printStr("Node::Prec::Comma"); |
| case Node::Prec::Default: |
| return printStr("Node::Prec::Default"); |
| } |
| } |
| |
| void newLine() { |
| printStr("\n"); |
| for (unsigned I = 0; I != Depth; ++I) |
| printStr(" "); |
| PendingNewline = false; |
| } |
| |
| template<typename T> void printWithPendingNewline(T V) { |
| print(V); |
| if (wantsNewline(V)) |
| PendingNewline = true; |
| } |
| |
| template<typename T> void printWithComma(T V) { |
| if (PendingNewline || wantsNewline(V)) { |
| printStr(","); |
| newLine(); |
| } else { |
| printStr(", "); |
| } |
| |
| printWithPendingNewline(V); |
| } |
| |
| struct CtorArgPrinter { |
| DumpVisitor &Visitor; |
| |
| template<typename T, typename ...Rest> void operator()(T V, Rest ...Vs) { |
| if (Visitor.anyWantNewline(V, Vs...)) |
| Visitor.newLine(); |
| Visitor.printWithPendingNewline(V); |
| int PrintInOrder[] = { (Visitor.printWithComma(Vs), 0)..., 0 }; |
| (void)PrintInOrder; |
| } |
| }; |
| |
| template<typename NodeT> void operator()(const NodeT *Node) { |
| Depth += 2; |
| fprintf(stderr, "%s(", itanium_demangle::NodeKind<NodeT>::name()); |
| Node->match(CtorArgPrinter{*this}); |
| fprintf(stderr, ")"); |
| Depth -= 2; |
| } |
| |
| void operator()(const ForwardTemplateReference *Node) { |
| Depth += 2; |
| fprintf(stderr, "ForwardTemplateReference("); |
| if (Node->Ref && !Node->Printing) { |
| Node->Printing = true; |
| CtorArgPrinter{*this}(Node->Ref); |
| Node->Printing = false; |
| } else { |
| CtorArgPrinter{*this}(Node->Index); |
| } |
| fprintf(stderr, ")"); |
| Depth -= 2; |
| } |
| }; |
| } |
| |
| void itanium_demangle::Node::dump() const { |
| DumpVisitor V; |
| visit(std::ref(V)); |
| V.newLine(); |
| } |
| #endif |
| |
| namespace { |
| class BumpPointerAllocator { |
| struct BlockMeta { |
| BlockMeta* Next; |
| size_t Current; |
| }; |
| |
| static constexpr size_t AllocSize = 4096; |
| static constexpr size_t UsableAllocSize = AllocSize - sizeof(BlockMeta); |
| |
| alignas(long double) char InitialBuffer[AllocSize]; |
| BlockMeta* BlockList = nullptr; |
| |
| void grow() { |
| char* NewMeta = static_cast<char *>(std::malloc(AllocSize)); |
| if (NewMeta == nullptr) |
| std::terminate(); |
| BlockList = new (NewMeta) BlockMeta{BlockList, 0}; |
| } |
| |
| void* allocateMassive(size_t NBytes) { |
| NBytes += sizeof(BlockMeta); |
| BlockMeta* NewMeta = reinterpret_cast<BlockMeta*>(std::malloc(NBytes)); |
| if (NewMeta == nullptr) |
| std::terminate(); |
| BlockList->Next = new (NewMeta) BlockMeta{BlockList->Next, 0}; |
| return static_cast<void*>(NewMeta + 1); |
| } |
| |
| public: |
| BumpPointerAllocator() |
| : BlockList(new (InitialBuffer) BlockMeta{nullptr, 0}) {} |
| |
| void* allocate(size_t N) { |
| N = (N + 15u) & ~15u; |
| if (N + BlockList->Current >= UsableAllocSize) { |
| if (N > UsableAllocSize) |
| return allocateMassive(N); |
| grow(); |
| } |
| BlockList->Current += N; |
| return static_cast<void*>(reinterpret_cast<char*>(BlockList + 1) + |
| BlockList->Current - N); |
| } |
| |
| void reset() { |
| while (BlockList) { |
| BlockMeta* Tmp = BlockList; |
| BlockList = BlockList->Next; |
| if (reinterpret_cast<char*>(Tmp) != InitialBuffer) |
| std::free(Tmp); |
| } |
| BlockList = new (InitialBuffer) BlockMeta{nullptr, 0}; |
| } |
| |
| ~BumpPointerAllocator() { reset(); } |
| }; |
| |
| class DefaultAllocator { |
| BumpPointerAllocator Alloc; |
| |
| public: |
| void reset() { Alloc.reset(); } |
| |
| template<typename T, typename ...Args> T *makeNode(Args &&...args) { |
| return new (Alloc.allocate(sizeof(T))) |
| T(std::forward<Args>(args)...); |
| } |
| |
| void *allocateNodeArray(size_t sz) { |
| return Alloc.allocate(sizeof(Node *) * sz); |
| } |
| }; |
| } // unnamed namespace |
| |
| //===----------------------------------------------------------------------===// |
| // Code beyond this point should not be synchronized with libc++abi. |
| //===----------------------------------------------------------------------===// |
| |
| using Demangler = itanium_demangle::ManglingParser<DefaultAllocator>; |
| |
| char *llvm::itaniumDemangle(std::string_view MangledName) { |
| if (MangledName.empty()) |
| return nullptr; |
| |
| Demangler Parser(MangledName.data(), |
| MangledName.data() + MangledName.length()); |
| Node *AST = Parser.parse(); |
| if (!AST) |
| return nullptr; |
| |
| OutputBuffer OB; |
| assert(Parser.ForwardTemplateRefs.empty()); |
| AST->print(OB); |
| OB += '\0'; |
| return OB.getBuffer(); |
| } |
| |
| ItaniumPartialDemangler::ItaniumPartialDemangler() |
| : RootNode(nullptr), Context(new Demangler{nullptr, nullptr}) {} |
| |
| ItaniumPartialDemangler::~ItaniumPartialDemangler() { |
| delete static_cast<Demangler *>(Context); |
| } |
| |
| ItaniumPartialDemangler::ItaniumPartialDemangler( |
| ItaniumPartialDemangler &&Other) |
| : RootNode(Other.RootNode), Context(Other.Context) { |
| Other.Context = Other.RootNode = nullptr; |
| } |
| |
| ItaniumPartialDemangler &ItaniumPartialDemangler:: |
| operator=(ItaniumPartialDemangler &&Other) { |
| std::swap(RootNode, Other.RootNode); |
| std::swap(Context, Other.Context); |
| return *this; |
| } |
| |
| // Demangle MangledName into an AST, storing it into this->RootNode. |
| bool ItaniumPartialDemangler::partialDemangle(const char *MangledName) { |
| Demangler *Parser = static_cast<Demangler *>(Context); |
| size_t Len = std::strlen(MangledName); |
| Parser->reset(MangledName, MangledName + Len); |
| RootNode = Parser->parse(); |
| return RootNode == nullptr; |
| } |
| |
| static char *printNode(const Node *RootNode, char *Buf, size_t *N) { |
| OutputBuffer OB(Buf, N); |
| RootNode->print(OB); |
| OB += '\0'; |
| if (N != nullptr) |
| *N = OB.getCurrentPosition(); |
| return OB.getBuffer(); |
| } |
| |
| char *ItaniumPartialDemangler::getFunctionBaseName(char *Buf, size_t *N) const { |
| if (!isFunction()) |
| return nullptr; |
| |
| const Node *Name = static_cast<const FunctionEncoding *>(RootNode)->getName(); |
| |
| while (true) { |
| switch (Name->getKind()) { |
| case Node::KAbiTagAttr: |
| Name = static_cast<const AbiTagAttr *>(Name)->Base; |
| continue; |
| case Node::KModuleEntity: |
| Name = static_cast<const ModuleEntity *>(Name)->Name; |
| continue; |
| case Node::KNestedName: |
| Name = static_cast<const NestedName *>(Name)->Name; |
| continue; |
| case Node::KLocalName: |
| Name = static_cast<const LocalName *>(Name)->Entity; |
| continue; |
| case Node::KNameWithTemplateArgs: |
| Name = static_cast<const NameWithTemplateArgs *>(Name)->Name; |
| continue; |
| default: |
| return printNode(Name, Buf, N); |
| } |
| } |
| } |
| |
| char *ItaniumPartialDemangler::getFunctionDeclContextName(char *Buf, |
| size_t *N) const { |
| if (!isFunction()) |
| return nullptr; |
| const Node *Name = static_cast<const FunctionEncoding *>(RootNode)->getName(); |
| |
| OutputBuffer OB(Buf, N); |
| |
| KeepGoingLocalFunction: |
| while (true) { |
| if (Name->getKind() == Node::KAbiTagAttr) { |
| Name = static_cast<const AbiTagAttr *>(Name)->Base; |
| continue; |
| } |
| if (Name->getKind() == Node::KNameWithTemplateArgs) { |
| Name = static_cast<const NameWithTemplateArgs *>(Name)->Name; |
| continue; |
| } |
| break; |
| } |
| |
| if (Name->getKind() == Node::KModuleEntity) |
| Name = static_cast<const ModuleEntity *>(Name)->Name; |
| |
| switch (Name->getKind()) { |
| case Node::KNestedName: |
| static_cast<const NestedName *>(Name)->Qual->print(OB); |
| break; |
| case Node::KLocalName: { |
| auto *LN = static_cast<const LocalName *>(Name); |
| LN->Encoding->print(OB); |
| OB += "::"; |
| Name = LN->Entity; |
| goto KeepGoingLocalFunction; |
| } |
| default: |
| break; |
| } |
| OB += '\0'; |
| if (N != nullptr) |
| *N = OB.getCurrentPosition(); |
| return OB.getBuffer(); |
| } |
| |
| char *ItaniumPartialDemangler::getFunctionName(char *Buf, size_t *N) const { |
| if (!isFunction()) |
| return nullptr; |
| auto *Name = static_cast<FunctionEncoding *>(RootNode)->getName(); |
| return printNode(Name, Buf, N); |
| } |
| |
| char *ItaniumPartialDemangler::getFunctionParameters(char *Buf, |
| size_t *N) const { |
| if (!isFunction()) |
| return nullptr; |
| NodeArray Params = static_cast<FunctionEncoding *>(RootNode)->getParams(); |
| |
| OutputBuffer OB(Buf, N); |
| |
| OB += '('; |
| Params.printWithComma(OB); |
| OB += ')'; |
| OB += '\0'; |
| if (N != nullptr) |
| *N = OB.getCurrentPosition(); |
| return OB.getBuffer(); |
| } |
| |
| char *ItaniumPartialDemangler::getFunctionReturnType( |
| char *Buf, size_t *N) const { |
| if (!isFunction()) |
| return nullptr; |
| |
| OutputBuffer OB(Buf, N); |
| |
| if (const Node *Ret = |
| static_cast<const FunctionEncoding *>(RootNode)->getReturnType()) |
| Ret->print(OB); |
| |
| OB += '\0'; |
| if (N != nullptr) |
| *N = OB.getCurrentPosition(); |
| return OB.getBuffer(); |
| } |
| |
| char *ItaniumPartialDemangler::finishDemangle(char *Buf, size_t *N) const { |
| assert(RootNode != nullptr && "must call partialDemangle()"); |
| return printNode(static_cast<Node *>(RootNode), Buf, N); |
| } |
| |
| bool ItaniumPartialDemangler::hasFunctionQualifiers() const { |
| assert(RootNode != nullptr && "must call partialDemangle()"); |
| if (!isFunction()) |
| return false; |
| auto *E = static_cast<const FunctionEncoding *>(RootNode); |
| return E->getCVQuals() != QualNone || E->getRefQual() != FrefQualNone; |
| } |
| |
| bool ItaniumPartialDemangler::isCtorOrDtor() const { |
| const Node *N = static_cast<const Node *>(RootNode); |
| while (N) { |
| switch (N->getKind()) { |
| default: |
| return false; |
| case Node::KCtorDtorName: |
| return true; |
| |
| case Node::KAbiTagAttr: |
| N = static_cast<const AbiTagAttr *>(N)->Base; |
| break; |
| case Node::KFunctionEncoding: |
| N = static_cast<const FunctionEncoding *>(N)->getName(); |
| break; |
| case Node::KLocalName: |
| N = static_cast<const LocalName *>(N)->Entity; |
| break; |
| case Node::KNameWithTemplateArgs: |
| N = static_cast<const NameWithTemplateArgs *>(N)->Name; |
| break; |
| case Node::KNestedName: |
| N = static_cast<const NestedName *>(N)->Name; |
| break; |
| case Node::KModuleEntity: |
| N = static_cast<const ModuleEntity *>(N)->Name; |
| break; |
| } |
| } |
| return false; |
| } |
| |
| bool ItaniumPartialDemangler::isFunction() const { |
| assert(RootNode != nullptr && "must call partialDemangle()"); |
| return static_cast<const Node *>(RootNode)->getKind() == |
| Node::KFunctionEncoding; |
| } |
| |
| bool ItaniumPartialDemangler::isSpecialName() const { |
| assert(RootNode != nullptr && "must call partialDemangle()"); |
| auto K = static_cast<const Node *>(RootNode)->getKind(); |
| return K == Node::KSpecialName || K == Node::KCtorVtableSpecialName; |
| } |
| |
| bool ItaniumPartialDemangler::isData() const { |
| return !isFunction() && !isSpecialName(); |
| } |