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
25using namespace llvm;
26using namespace llvm::itanium_demangle;
27
28constexpr const char *itanium_demangle::FloatData<float>::spec;
29constexpr const char *itanium_demangle::FloatData<double>::spec;
30constexpr 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
35const 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
63namespace {
64struct 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
281void itanium_demangle::Node::dump() const {
282 DumpVisitor V;
283 visit(std::ref(V));
284 V.newLine();
285}
286#endif
287
288namespace {
289class 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(size: AllocSize));
303 if (NewMeta == nullptr)
304 std::terminate();
305 BlockList = new (NewMeta) BlockMeta{.Next: BlockList, .Current: 0};
306 }
307
308 void* allocateMassive(size_t NBytes) {
309 NBytes += sizeof(BlockMeta);
310 BlockMeta* NewMeta = reinterpret_cast<BlockMeta*>(std::malloc(size: NBytes));
311 if (NewMeta == nullptr)
312 std::terminate();
313 BlockList->Next = new (NewMeta) BlockMeta{.Next: BlockList->Next, .Current: 0};
314 return static_cast<void*>(NewMeta + 1);
315 }
316
317public:
318 BumpPointerAllocator()
319 : BlockList(new (InitialBuffer) BlockMeta{.Next: nullptr, .Current: 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(NBytes: 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(ptr: Tmp);
339 }
340 BlockList = new (InitialBuffer) BlockMeta{.Next: nullptr, .Current: 0};
341 }
342
343 ~BumpPointerAllocator() { reset(); }
344};
345
346class DefaultAllocator {
347 BumpPointerAllocator Alloc;
348
349public:
350 void reset() { Alloc.reset(); }
351
352 template<typename T, typename ...Args> T *makeNode(Args &&...args) {
353 return new (Alloc.allocate(N: sizeof(T)))
354 T(std::forward<Args>(args)...);
355 }
356
357 void *allocateNodeArray(size_t sz) {
358 return Alloc.allocate(N: sizeof(Node *) * sz);
359 }
360};
361} // unnamed namespace
362
363//===----------------------------------------------------------------------===//
364// Code beyond this point should not be synchronized with libc++abi.
365//===----------------------------------------------------------------------===//
366
367using Demangler = itanium_demangle::ManglingParser<DefaultAllocator>;
368
369char *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
386ItaniumPartialDemangler::ItaniumPartialDemangler()
387 : RootNode(nullptr), Context(new Demangler{nullptr, nullptr}) {}
388
389ItaniumPartialDemangler::~ItaniumPartialDemangler() {
390 delete static_cast<Demangler *>(Context);
391}
392
393ItaniumPartialDemangler::ItaniumPartialDemangler(
394 ItaniumPartialDemangler &&Other)
395 : RootNode(Other.RootNode), Context(Other.Context) {
396 Other.Context = Other.RootNode = nullptr;
397}
398
399ItaniumPartialDemangler &ItaniumPartialDemangler::
400operator=(ItaniumPartialDemangler &&Other) {
401 std::swap(a&: RootNode, b&: Other.RootNode);
402 std::swap(a&: Context, b&: Other.Context);
403 return *this;
404}
405
406// Demangle MangledName into an AST, storing it into this->RootNode.
407bool ItaniumPartialDemangler::partialDemangle(const char *MangledName) {
408 Demangler *Parser = static_cast<Demangler *>(Context);
409 size_t Len = std::strlen(s: MangledName);
410 Parser->reset(First_: MangledName, Last_: MangledName + Len);
411 RootNode = Parser->parse();
412 return RootNode == nullptr;
413}
414static char *printNode(const Node *RootNode, OutputBuffer &OB, size_t *N) {
415 RootNode->print(OB);
416 OB += '\0';
417 if (N != nullptr)
418 *N = OB.getCurrentPosition();
419 return OB.getBuffer();
420}
421
422static char *printNode(const Node *RootNode, char *Buf, size_t *N) {
423 OutputBuffer OB(Buf, N);
424 return printNode(RootNode, OB, N);
425}
426
427char *ItaniumPartialDemangler::getFunctionBaseName(char *Buf, size_t *N) const {
428 if (!isFunction())
429 return nullptr;
430
431 const Node *Name = static_cast<const FunctionEncoding *>(RootNode)->getName();
432
433 while (true) {
434 switch (Name->getKind()) {
435 case Node::KAbiTagAttr:
436 Name = static_cast<const AbiTagAttr *>(Name)->Base;
437 continue;
438 case Node::KModuleEntity:
439 Name = static_cast<const ModuleEntity *>(Name)->Name;
440 continue;
441 case Node::KNestedName:
442 Name = static_cast<const NestedName *>(Name)->Name;
443 continue;
444 case Node::KLocalName:
445 Name = static_cast<const LocalName *>(Name)->Entity;
446 continue;
447 case Node::KNameWithTemplateArgs:
448 Name = static_cast<const NameWithTemplateArgs *>(Name)->Name;
449 continue;
450 default:
451 return printNode(RootNode: Name, Buf, N);
452 }
453 }
454}
455
456char *ItaniumPartialDemangler::getFunctionDeclContextName(char *Buf,
457 size_t *N) const {
458 if (!isFunction())
459 return nullptr;
460 const Node *Name = static_cast<const FunctionEncoding *>(RootNode)->getName();
461
462 OutputBuffer OB(Buf, N);
463
464 KeepGoingLocalFunction:
465 while (true) {
466 if (Name->getKind() == Node::KAbiTagAttr) {
467 Name = static_cast<const AbiTagAttr *>(Name)->Base;
468 continue;
469 }
470 if (Name->getKind() == Node::KNameWithTemplateArgs) {
471 Name = static_cast<const NameWithTemplateArgs *>(Name)->Name;
472 continue;
473 }
474 break;
475 }
476
477 if (Name->getKind() == Node::KModuleEntity)
478 Name = static_cast<const ModuleEntity *>(Name)->Name;
479
480 switch (Name->getKind()) {
481 case Node::KNestedName:
482 static_cast<const NestedName *>(Name)->Qual->print(OB);
483 break;
484 case Node::KLocalName: {
485 auto *LN = static_cast<const LocalName *>(Name);
486 LN->Encoding->print(OB);
487 OB += "::";
488 Name = LN->Entity;
489 goto KeepGoingLocalFunction;
490 }
491 default:
492 break;
493 }
494 OB += '\0';
495 if (N != nullptr)
496 *N = OB.getCurrentPosition();
497 return OB.getBuffer();
498}
499
500char *ItaniumPartialDemangler::getFunctionName(char *Buf, size_t *N) const {
501 if (!isFunction())
502 return nullptr;
503 auto *Name = static_cast<FunctionEncoding *>(RootNode)->getName();
504 return printNode(RootNode: Name, Buf, N);
505}
506
507char *ItaniumPartialDemangler::getFunctionParameters(char *Buf,
508 size_t *N) const {
509 if (!isFunction())
510 return nullptr;
511 NodeArray Params = static_cast<FunctionEncoding *>(RootNode)->getParams();
512
513 OutputBuffer OB(Buf, N);
514
515 OB += '(';
516 Params.printWithComma(OB);
517 OB += ')';
518 OB += '\0';
519 if (N != nullptr)
520 *N = OB.getCurrentPosition();
521 return OB.getBuffer();
522}
523
524char *ItaniumPartialDemangler::getFunctionReturnType(
525 char *Buf, size_t *N) const {
526 if (!isFunction())
527 return nullptr;
528
529 OutputBuffer OB(Buf, N);
530
531 if (const Node *Ret =
532 static_cast<const FunctionEncoding *>(RootNode)->getReturnType())
533 Ret->print(OB);
534
535 OB += '\0';
536 if (N != nullptr)
537 *N = OB.getCurrentPosition();
538 return OB.getBuffer();
539}
540
541char *ItaniumPartialDemangler::finishDemangle(char *Buf, size_t *N) const {
542 assert(RootNode != nullptr && "must call partialDemangle()");
543 return printNode(RootNode: static_cast<Node *>(RootNode), Buf, N);
544}
545
546char *ItaniumPartialDemangler::finishDemangle(void *OB) const {
547 assert(RootNode != nullptr && "must call partialDemangle()");
548 assert(OB != nullptr && "valid OutputBuffer argument required");
549 return printNode(RootNode: static_cast<Node *>(RootNode),
550 OB&: *static_cast<OutputBuffer *>(OB),
551 /*N=*/nullptr);
552}
553
554bool ItaniumPartialDemangler::hasFunctionQualifiers() const {
555 assert(RootNode != nullptr && "must call partialDemangle()");
556 if (!isFunction())
557 return false;
558 auto *E = static_cast<const FunctionEncoding *>(RootNode);
559 return E->getCVQuals() != QualNone || E->getRefQual() != FrefQualNone;
560}
561
562bool ItaniumPartialDemangler::isCtorOrDtor() const {
563 const Node *N = static_cast<const Node *>(RootNode);
564 while (N) {
565 switch (N->getKind()) {
566 default:
567 return false;
568 case Node::KCtorDtorName:
569 return true;
570
571 case Node::KAbiTagAttr:
572 N = static_cast<const AbiTagAttr *>(N)->Base;
573 break;
574 case Node::KFunctionEncoding:
575 N = static_cast<const FunctionEncoding *>(N)->getName();
576 break;
577 case Node::KLocalName:
578 N = static_cast<const LocalName *>(N)->Entity;
579 break;
580 case Node::KNameWithTemplateArgs:
581 N = static_cast<const NameWithTemplateArgs *>(N)->Name;
582 break;
583 case Node::KNestedName:
584 N = static_cast<const NestedName *>(N)->Name;
585 break;
586 case Node::KModuleEntity:
587 N = static_cast<const ModuleEntity *>(N)->Name;
588 break;
589 }
590 }
591 return false;
592}
593
594bool ItaniumPartialDemangler::isFunction() const {
595 assert(RootNode != nullptr && "must call partialDemangle()");
596 return static_cast<const Node *>(RootNode)->getKind() ==
597 Node::KFunctionEncoding;
598}
599
600bool ItaniumPartialDemangler::isSpecialName() const {
601 assert(RootNode != nullptr && "must call partialDemangle()");
602 auto K = static_cast<const Node *>(RootNode)->getKind();
603 return K == Node::KSpecialName || K == Node::KCtorVtableSpecialName;
604}
605
606bool ItaniumPartialDemangler::isData() const {
607 return !isFunction() && !isSpecialName();
608}
609