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
parse_discriminator(const char * first,const char * last)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
wantsNewline__anon39624eb80111::DumpVisitor68 template<typename NodeT> static constexpr bool wantsNewline(const NodeT *) {
69 return true;
70 }
wantsNewline__anon39624eb80111::DumpVisitor71 static bool wantsNewline(NodeArray A) { return !A.empty(); }
wantsNewline__anon39624eb80111::DumpVisitor72 static constexpr bool wantsNewline(...) { return false; }
73
anyWantNewline__anon39624eb80111::DumpVisitor74 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
printStr__anon39624eb80111::DumpVisitor81 void printStr(const char *S) { fprintf(stderr, "%s", S); }
print__anon39624eb80111::DumpVisitor82 void print(std::string_view SV) {
83 fprintf(stderr, "\"%.*s\"", (int)SV.size(), SV.data());
84 }
print__anon39624eb80111::DumpVisitor85 void print(const Node *N) {
86 if (N)
87 N->visit(std::ref(*this));
88 else
89 printStr("<null>");
90 }
print__anon39624eb80111::DumpVisitor91 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'.
print__anon39624eb80111::DumpVisitor107 void print(bool B) { printStr(B ? "true" : "false"); }
108
print__anon39624eb80111::DumpVisitor109 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
print__anon39624eb80111::DumpVisitor113 template <class T> std::enable_if_t<std::is_signed<T>::value> print(T N) {
114 fprintf(stderr, "%lld", (long long)N);
115 }
116
print__anon39624eb80111::DumpVisitor117 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 }
print__anon39624eb80111::DumpVisitor125 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 }
print__anon39624eb80111::DumpVisitor135 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 }
print__anon39624eb80111::DumpVisitor150 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 }
print__anon39624eb80111::DumpVisitor166 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 }
print__anon39624eb80111::DumpVisitor176 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
newLine__anon39624eb80111::DumpVisitor221 void newLine() {
222 printStr("\n");
223 for (unsigned I = 0; I != Depth; ++I)
224 printStr(" ");
225 PendingNewline = false;
226 }
227
printWithPendingNewline__anon39624eb80111::DumpVisitor228 template<typename T> void printWithPendingNewline(T V) {
229 print(V);
230 if (wantsNewline(V))
231 PendingNewline = true;
232 }
233
printWithComma__anon39624eb80111::DumpVisitor234 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
operator ()__anon39624eb80111::DumpVisitor::CtorArgPrinter248 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
operator ()__anon39624eb80111::DumpVisitor257 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
operator ()__anon39624eb80111::DumpVisitor265 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
dump() const281 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
grow()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
allocateMassive(size_t NBytes)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:
BumpPointerAllocator()318 BumpPointerAllocator()
319 : BlockList(new (InitialBuffer) BlockMeta{nullptr, 0}) {}
320
allocate(size_t N)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
reset()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
~BumpPointerAllocator()343 ~BumpPointerAllocator() { reset(); }
344 };
345
346 class DefaultAllocator {
347 BumpPointerAllocator Alloc;
348
349 public:
reset()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
allocateNodeArray(size_t sz)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
itaniumDemangle(std::string_view MangledName,bool ParseParams)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
ItaniumPartialDemangler()386 ItaniumPartialDemangler::ItaniumPartialDemangler()
387 : RootNode(nullptr), Context(new Demangler{nullptr, nullptr}) {}
388
~ItaniumPartialDemangler()389 ItaniumPartialDemangler::~ItaniumPartialDemangler() {
390 delete static_cast<Demangler *>(Context);
391 }
392
ItaniumPartialDemangler(ItaniumPartialDemangler && Other)393 ItaniumPartialDemangler::ItaniumPartialDemangler(
394 ItaniumPartialDemangler &&Other)
395 : RootNode(Other.RootNode), Context(Other.Context) {
396 Other.Context = Other.RootNode = nullptr;
397 }
398
399 ItaniumPartialDemangler &ItaniumPartialDemangler::
operator =(ItaniumPartialDemangler && Other)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.
partialDemangle(const char * MangledName)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
printNode(const Node * RootNode,char * Buf,size_t * N)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
getFunctionBaseName(char * Buf,size_t * N) const424 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
getFunctionDeclContextName(char * Buf,size_t * N) const453 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
getFunctionName(char * Buf,size_t * N) const497 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
getFunctionParameters(char * Buf,size_t * N) const504 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
getFunctionReturnType(char * Buf,size_t * N) const521 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
finishDemangle(char * Buf,size_t * N) const538 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
hasFunctionQualifiers() const543 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
isCtorOrDtor() const551 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
isFunction() const583 bool ItaniumPartialDemangler::isFunction() const {
584 assert(RootNode != nullptr && "must call partialDemangle()");
585 return static_cast<const Node *>(RootNode)->getKind() ==
586 Node::KFunctionEncoding;
587 }
588
isSpecialName() const589 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
isData() const595 bool ItaniumPartialDemangler::isData() const {
596 return !isFunction() && !isSpecialName();
597 }
598