yuzu

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-FileCopyrightText: Part of the LLVM Project
6
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7
//
8
//===----------------------------------------------------------------------===//
9

10
// FIXME: (possibly) incomplete list of features that clang mangles that this
11
// file does not yet support:
12
//   - C++ modules TS
13

14
#include "llvm/Demangle/Demangle.h"
15
#include "llvm/Demangle/ItaniumDemangle.h"
16

17
#include <cassert>
18
#include <cctype>
19
#include <cstdio>
20
#include <cstdlib>
21
#include <cstring>
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