|
150
|
1 //===-------------------------- cxa_demangle.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 "demangle/ItaniumDemangle.h"
|
|
|
14 #include "__cxxabi_config.h"
|
|
|
15 #include <cassert>
|
|
|
16 #include <cctype>
|
|
|
17 #include <cstdio>
|
|
|
18 #include <cstdlib>
|
|
|
19 #include <cstring>
|
|
|
20 #include <functional>
|
|
|
21 #include <numeric>
|
|
|
22 #include <utility>
|
|
|
23
|
|
|
24 using namespace itanium_demangle;
|
|
|
25
|
|
|
26 constexpr const char *itanium_demangle::FloatData<float>::spec;
|
|
|
27 constexpr const char *itanium_demangle::FloatData<double>::spec;
|
|
|
28 constexpr const char *itanium_demangle::FloatData<long double>::spec;
|
|
|
29
|
|
|
30 // <discriminator> := _ <non-negative number> # when number < 10
|
|
|
31 // := __ <non-negative number> _ # when number >= 10
|
|
|
32 // extension := decimal-digit+ # at the end of string
|
|
|
33 const char *itanium_demangle::parse_discriminator(const char *first,
|
|
|
34 const char *last) {
|
|
|
35 // parse but ignore discriminator
|
|
|
36 if (first != last) {
|
|
|
37 if (*first == '_') {
|
|
|
38 const char *t1 = first + 1;
|
|
|
39 if (t1 != last) {
|
|
|
40 if (std::isdigit(*t1))
|
|
|
41 first = t1 + 1;
|
|
|
42 else if (*t1 == '_') {
|
|
|
43 for (++t1; t1 != last && std::isdigit(*t1); ++t1)
|
|
|
44 ;
|
|
|
45 if (t1 != last && *t1 == '_')
|
|
|
46 first = t1 + 1;
|
|
|
47 }
|
|
|
48 }
|
|
|
49 } else if (std::isdigit(*first)) {
|
|
|
50 const char *t1 = first + 1;
|
|
|
51 for (; t1 != last && std::isdigit(*t1); ++t1)
|
|
|
52 ;
|
|
|
53 if (t1 == last)
|
|
|
54 first = last;
|
|
|
55 }
|
|
|
56 }
|
|
|
57 return first;
|
|
|
58 }
|
|
|
59
|
|
|
60 #ifndef NDEBUG
|
|
|
61 namespace {
|
|
|
62 struct DumpVisitor {
|
|
|
63 unsigned Depth = 0;
|
|
|
64 bool PendingNewline = false;
|
|
|
65
|
|
|
66 template<typename NodeT> static constexpr bool wantsNewline(const NodeT *) {
|
|
|
67 return true;
|
|
|
68 }
|
|
|
69 static bool wantsNewline(NodeArray A) { return !A.empty(); }
|
|
|
70 static constexpr bool wantsNewline(...) { return false; }
|
|
|
71
|
|
|
72 template<typename ...Ts> static bool anyWantNewline(Ts ...Vs) {
|
|
|
73 for (bool B : {wantsNewline(Vs)...})
|
|
|
74 if (B)
|
|
|
75 return true;
|
|
|
76 return false;
|
|
|
77 }
|
|
|
78
|
|
|
79 void printStr(const char *S) { fprintf(stderr, "%s", S); }
|
|
|
80 void print(StringView SV) {
|
|
|
81 fprintf(stderr, "\"%.*s\"", (int)SV.size(), SV.begin());
|
|
|
82 }
|
|
|
83 void print(const Node *N) {
|
|
|
84 if (N)
|
|
|
85 N->visit(std::ref(*this));
|
|
|
86 else
|
|
|
87 printStr("<null>");
|
|
|
88 }
|
|
|
89 void print(NodeArray A) {
|
|
|
90 ++Depth;
|
|
|
91 printStr("{");
|
|
|
92 bool First = true;
|
|
|
93 for (const Node *N : A) {
|
|
|
94 if (First)
|
|
|
95 print(N);
|
|
|
96 else
|
|
|
97 printWithComma(N);
|
|
|
98 First = false;
|
|
|
99 }
|
|
|
100 printStr("}");
|
|
|
101 --Depth;
|
|
|
102 }
|
|
|
103
|
|
|
104 // Overload used when T is exactly 'bool', not merely convertible to 'bool'.
|
|
|
105 void print(bool B) { printStr(B ? "true" : "false"); }
|
|
|
106
|
|
|
107 template <class T>
|
|
|
108 typename std::enable_if<std::is_unsigned<T>::value>::type print(T N) {
|
|
|
109 fprintf(stderr, "%llu", (unsigned long long)N);
|
|
|
110 }
|
|
|
111
|
|
|
112 template <class T>
|
|
|
113 typename std::enable_if<std::is_signed<T>::value>::type 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
|
|
|
177 void newLine() {
|
|
|
178 printStr("\n");
|
|
|
179 for (unsigned I = 0; I != Depth; ++I)
|
|
|
180 printStr(" ");
|
|
|
181 PendingNewline = false;
|
|
|
182 }
|
|
|
183
|
|
|
184 template<typename T> void printWithPendingNewline(T V) {
|
|
|
185 print(V);
|
|
|
186 if (wantsNewline(V))
|
|
|
187 PendingNewline = true;
|
|
|
188 }
|
|
|
189
|
|
|
190 template<typename T> void printWithComma(T V) {
|
|
|
191 if (PendingNewline || wantsNewline(V)) {
|
|
|
192 printStr(",");
|
|
|
193 newLine();
|
|
|
194 } else {
|
|
|
195 printStr(", ");
|
|
|
196 }
|
|
|
197
|
|
|
198 printWithPendingNewline(V);
|
|
|
199 }
|
|
|
200
|
|
|
201 struct CtorArgPrinter {
|
|
|
202 DumpVisitor &Visitor;
|
|
|
203
|
|
|
204 template<typename T, typename ...Rest> void operator()(T V, Rest ...Vs) {
|
|
|
205 if (Visitor.anyWantNewline(V, Vs...))
|
|
|
206 Visitor.newLine();
|
|
|
207 Visitor.printWithPendingNewline(V);
|
|
|
208 int PrintInOrder[] = { (Visitor.printWithComma(Vs), 0)..., 0 };
|
|
|
209 (void)PrintInOrder;
|
|
|
210 }
|
|
|
211 };
|
|
|
212
|
|
|
213 template<typename NodeT> void operator()(const NodeT *Node) {
|
|
|
214 Depth += 2;
|
|
|
215 fprintf(stderr, "%s(", itanium_demangle::NodeKind<NodeT>::name());
|
|
|
216 Node->match(CtorArgPrinter{*this});
|
|
|
217 fprintf(stderr, ")");
|
|
|
218 Depth -= 2;
|
|
|
219 }
|
|
|
220
|
|
|
221 void operator()(const ForwardTemplateReference *Node) {
|
|
|
222 Depth += 2;
|
|
|
223 fprintf(stderr, "ForwardTemplateReference(");
|
|
|
224 if (Node->Ref && !Node->Printing) {
|
|
|
225 Node->Printing = true;
|
|
|
226 CtorArgPrinter{*this}(Node->Ref);
|
|
|
227 Node->Printing = false;
|
|
|
228 } else {
|
|
|
229 CtorArgPrinter{*this}(Node->Index);
|
|
|
230 }
|
|
|
231 fprintf(stderr, ")");
|
|
|
232 Depth -= 2;
|
|
|
233 }
|
|
|
234 };
|
|
|
235 }
|
|
|
236
|
|
|
237 void itanium_demangle::Node::dump() const {
|
|
|
238 DumpVisitor V;
|
|
|
239 visit(std::ref(V));
|
|
|
240 V.newLine();
|
|
|
241 }
|
|
|
242 #endif
|
|
|
243
|
|
|
244 namespace {
|
|
|
245 class BumpPointerAllocator {
|
|
|
246 struct BlockMeta {
|
|
|
247 BlockMeta* Next;
|
|
|
248 size_t Current;
|
|
|
249 };
|
|
|
250
|
|
|
251 static constexpr size_t AllocSize = 4096;
|
|
|
252 static constexpr size_t UsableAllocSize = AllocSize - sizeof(BlockMeta);
|
|
|
253
|
|
|
254 alignas(long double) char InitialBuffer[AllocSize];
|
|
|
255 BlockMeta* BlockList = nullptr;
|
|
|
256
|
|
|
257 void grow() {
|
|
|
258 char* NewMeta = static_cast<char *>(std::malloc(AllocSize));
|
|
|
259 if (NewMeta == nullptr)
|
|
|
260 std::terminate();
|
|
|
261 BlockList = new (NewMeta) BlockMeta{BlockList, 0};
|
|
|
262 }
|
|
|
263
|
|
|
264 void* allocateMassive(size_t NBytes) {
|
|
|
265 NBytes += sizeof(BlockMeta);
|
|
|
266 BlockMeta* NewMeta = reinterpret_cast<BlockMeta*>(std::malloc(NBytes));
|
|
|
267 if (NewMeta == nullptr)
|
|
|
268 std::terminate();
|
|
|
269 BlockList->Next = new (NewMeta) BlockMeta{BlockList->Next, 0};
|
|
|
270 return static_cast<void*>(NewMeta + 1);
|
|
|
271 }
|
|
|
272
|
|
|
273 public:
|
|
|
274 BumpPointerAllocator()
|
|
|
275 : BlockList(new (InitialBuffer) BlockMeta{nullptr, 0}) {}
|
|
|
276
|
|
|
277 void* allocate(size_t N) {
|
|
|
278 N = (N + 15u) & ~15u;
|
|
|
279 if (N + BlockList->Current >= UsableAllocSize) {
|
|
|
280 if (N > UsableAllocSize)
|
|
|
281 return allocateMassive(N);
|
|
|
282 grow();
|
|
|
283 }
|
|
|
284 BlockList->Current += N;
|
|
|
285 return static_cast<void*>(reinterpret_cast<char*>(BlockList + 1) +
|
|
|
286 BlockList->Current - N);
|
|
|
287 }
|
|
|
288
|
|
|
289 void reset() {
|
|
|
290 while (BlockList) {
|
|
|
291 BlockMeta* Tmp = BlockList;
|
|
|
292 BlockList = BlockList->Next;
|
|
|
293 if (reinterpret_cast<char*>(Tmp) != InitialBuffer)
|
|
|
294 std::free(Tmp);
|
|
|
295 }
|
|
|
296 BlockList = new (InitialBuffer) BlockMeta{nullptr, 0};
|
|
|
297 }
|
|
|
298
|
|
|
299 ~BumpPointerAllocator() { reset(); }
|
|
|
300 };
|
|
|
301
|
|
|
302 class DefaultAllocator {
|
|
|
303 BumpPointerAllocator Alloc;
|
|
|
304
|
|
|
305 public:
|
|
|
306 void reset() { Alloc.reset(); }
|
|
|
307
|
|
|
308 template<typename T, typename ...Args> T *makeNode(Args &&...args) {
|
|
|
309 return new (Alloc.allocate(sizeof(T)))
|
|
|
310 T(std::forward<Args>(args)...);
|
|
|
311 }
|
|
|
312
|
|
|
313 void *allocateNodeArray(size_t sz) {
|
|
|
314 return Alloc.allocate(sizeof(Node *) * sz);
|
|
|
315 }
|
|
|
316 };
|
|
|
317 } // unnamed namespace
|
|
|
318
|
|
|
319 //===----------------------------------------------------------------------===//
|
|
|
320 // Code beyond this point should not be synchronized with LLVM.
|
|
|
321 //===----------------------------------------------------------------------===//
|
|
|
322
|
|
|
323 using Demangler = itanium_demangle::ManglingParser<DefaultAllocator>;
|
|
|
324
|
|
|
325 namespace {
|
|
|
326 enum : int {
|
|
|
327 demangle_invalid_args = -3,
|
|
|
328 demangle_invalid_mangled_name = -2,
|
|
|
329 demangle_memory_alloc_failure = -1,
|
|
|
330 demangle_success = 0,
|
|
|
331 };
|
|
|
332 }
|
|
|
333
|
|
|
334 namespace __cxxabiv1 {
|
|
|
335 extern "C" _LIBCXXABI_FUNC_VIS char *
|
|
|
336 __cxa_demangle(const char *MangledName, char *Buf, size_t *N, int *Status) {
|
|
|
337 if (MangledName == nullptr || (Buf != nullptr && N == nullptr)) {
|
|
|
338 if (Status)
|
|
|
339 *Status = demangle_invalid_args;
|
|
|
340 return nullptr;
|
|
|
341 }
|
|
|
342
|
|
|
343 int InternalStatus = demangle_success;
|
|
|
344 Demangler Parser(MangledName, MangledName + std::strlen(MangledName));
|
|
|
345 OutputStream S;
|
|
|
346
|
|
|
347 Node *AST = Parser.parse();
|
|
|
348
|
|
|
349 if (AST == nullptr)
|
|
|
350 InternalStatus = demangle_invalid_mangled_name;
|
|
|
351 else if (!initializeOutputStream(Buf, N, S, 1024))
|
|
|
352 InternalStatus = demangle_memory_alloc_failure;
|
|
|
353 else {
|
|
|
354 assert(Parser.ForwardTemplateRefs.empty());
|
|
|
355 AST->print(S);
|
|
|
356 S += '\0';
|
|
|
357 if (N != nullptr)
|
|
|
358 *N = S.getCurrentPosition();
|
|
|
359 Buf = S.getBuffer();
|
|
|
360 }
|
|
|
361
|
|
|
362 if (Status)
|
|
|
363 *Status = InternalStatus;
|
|
|
364 return InternalStatus == demangle_success ? Buf : nullptr;
|
|
|
365 }
|
|
|
366 } // __cxxabiv1
|
