?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[RISCV] Fix mgather -> riscv.masked.strided.load combine not extending indices (...
[llvm-project.git] / llvm / lib / Demangle / MicrosoftDemangle.cpp
blobcd7ff40d63a492807bc59bade52ea4c7488570ec
1 //===- MicrosoftDemangle.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 // This file defines a demangler for MSVC-style mangled symbols.
10 //
11 // This file has no dependencies on the rest of LLVM so that it can be
12 // easily reused in other programs such as libcxxabi.
13 //
14 //===----------------------------------------------------------------------===//
15
16 #include "llvm/Demangle/MicrosoftDemangle.h"
17
18 #include "llvm/Demangle/Demangle.h"
19 #include "llvm/Demangle/DemangleConfig.h"
20 #include "llvm/Demangle/MicrosoftDemangleNodes.h"
21 #include "llvm/Demangle/StringViewExtras.h"
22 #include "llvm/Demangle/Utility.h"
23
24 #include <array>
25 #include <cctype>
26 #include <cstdio>
27 #include <string_view>
28 #include <tuple>
29
30 using namespace llvm;
31 using namespace ms_demangle;
32
33 static bool startsWithDigit(std::string_view S) {
34 return !S.empty() && std::isdigit(S.front());
35 }
36
37 struct NodeList {
38 Node *N = nullptr;
39 NodeList *Next = nullptr;
40 };
41
42 static bool consumeFront(std::string_view &S, char C) {
43 if (!llvm::itanium_demangle::starts_with(S, C))
44 return false;
45 S.remove_prefix(1);
46 return true;
47 }
48
49 static bool consumeFront(std::string_view &S, std::string_view C) {
50 if (!llvm::itanium_demangle::starts_with(S, C))
51 return false;
52 S.remove_prefix(C.size());
53 return true;
54 }
55
56 static bool isMemberPointer(std::string_view MangledName, bool &Error) {
57 Error = false;
58 const char F = MangledName.front();
59 MangledName.remove_prefix(1);
60 switch (F) {
61 case '$':
62 // This is probably an rvalue reference (e.g. $$Q), and you cannot have an
63 // rvalue reference to a member.
64 return false;
65 case 'A':
66 // 'A' indicates a reference, and you cannot have a reference to a member
67 // function or member.
68 return false;
69 case 'P':
70 case 'Q':
71 case 'R':
72 case 'S':
73 // These 4 values indicate some kind of pointer, but we still don't know
74 // what.
75 break;
76 default:
77 // isMemberPointer() is called only if isPointerType() returns true,
78 // and it rejects other prefixes.
79 DEMANGLE_UNREACHABLE;
80 }
81
82 // If it starts with a number, then 6 indicates a non-member function
83 // pointer, and 8 indicates a member function pointer.
84 if (startsWithDigit(MangledName)) {
85 if (MangledName[0] != '6' && MangledName[0] != '8') {
86 Error = true;
87 return false;
88 }
89 return (MangledName[0] == '8');
90 }
91
92 // Remove ext qualifiers since those can appear on either type and are
93 // therefore not indicative.
94 consumeFront(MangledName, 'E'); // 64-bit
95 consumeFront(MangledName, 'I'); // restrict
96 consumeFront(MangledName, 'F'); // unaligned
97
98 if (MangledName.empty()) {
99 Error = true;
100 return false;
101 }
102
103 // The next value should be either ABCD (non-member) or QRST (member).
104 switch (MangledName.front()) {
105 case 'A':
106 case 'B':
107 case 'C':
108 case 'D':
109 return false;
110 case 'Q':
111 case 'R':
112 case 'S':
113 case 'T':
114 return true;
115 default:
116 Error = true;
117 return false;
118 }
119 }
120
121 static SpecialIntrinsicKind
122 consumeSpecialIntrinsicKind(std::string_view &MangledName) {
123 if (consumeFront(MangledName, "?_7"))
124 return SpecialIntrinsicKind::Vftable;
125 if (consumeFront(MangledName, "?_8"))
126 return SpecialIntrinsicKind::Vbtable;
127 if (consumeFront(MangledName, "?_9"))
128 return SpecialIntrinsicKind::VcallThunk;
129 if (consumeFront(MangledName, "?_A"))
130 return SpecialIntrinsicKind::Typeof;
131 if (consumeFront(MangledName, "?_B"))
132 return SpecialIntrinsicKind::LocalStaticGuard;
133 if (consumeFront(MangledName, "?_C"))
134 return SpecialIntrinsicKind::StringLiteralSymbol;
135 if (consumeFront(MangledName, "?_P"))
136 return SpecialIntrinsicKind::UdtReturning;
137 if (consumeFront(MangledName, "?_R0"))
138 return SpecialIntrinsicKind::RttiTypeDescriptor;
139 if (consumeFront(MangledName, "?_R1"))
140 return SpecialIntrinsicKind::RttiBaseClassDescriptor;
141 if (consumeFront(MangledName, "?_R2"))
142 return SpecialIntrinsicKind::RttiBaseClassArray;
143 if (consumeFront(MangledName, "?_R3"))
144 return SpecialIntrinsicKind::RttiClassHierarchyDescriptor;
145 if (consumeFront(MangledName, "?_R4"))
146 return SpecialIntrinsicKind::RttiCompleteObjLocator;
147 if (consumeFront(MangledName, "?_S"))
148 return SpecialIntrinsicKind::LocalVftable;
149 if (consumeFront(MangledName, "?__E"))
150 return SpecialIntrinsicKind::DynamicInitializer;
151 if (consumeFront(MangledName, "?__F"))
152 return SpecialIntrinsicKind::DynamicAtexitDestructor;
153 if (consumeFront(MangledName, "?__J"))
154 return SpecialIntrinsicKind::LocalStaticThreadGuard;
155 return SpecialIntrinsicKind::None;
156 }
157
158 static bool startsWithLocalScopePattern(std::string_view S) {
159 if (!consumeFront(S, '?'))
160 return false;
161
162 size_t End = S.find('?');
163 if (End == std::string_view::npos)
164 return false;
165 std::string_view Candidate = S.substr(0, End);
166 if (Candidate.empty())
167 return false;
168
169 // \?[0-9]\?
170 // ?@? is the discriminator 0.
171 if (Candidate.size() == 1)
172 return Candidate[0] == '@' || (Candidate[0] >= '0' && Candidate[0] <= '9');
173
174 // If it's not 0-9, then it's an encoded number terminated with an @
175 if (Candidate.back() != '@')
176 return false;
177 Candidate.remove_suffix(1);
178
179 // An encoded number starts with B-P and all subsequent digits are in A-P.
180 // Note that the reason the first digit cannot be A is two fold. First, it
181 // would create an ambiguity with ?A which delimits the beginning of an
182 // anonymous namespace. Second, A represents 0, and you don't start a multi
183 // digit number with a leading 0. Presumably the anonymous namespace
184 // ambiguity is also why single digit encoded numbers use 0-9 rather than A-J.
185 if (Candidate[0] < 'B' || Candidate[0] > 'P')
186 return false;
187 Candidate.remove_prefix(1);
188 while (!Candidate.empty()) {
189 if (Candidate[0] < 'A' || Candidate[0] > 'P')
190 return false;
191 Candidate.remove_prefix(1);
192 }
193
194 return true;
195 }
196
197 static bool isTagType(std::string_view S) {
198 switch (S.front()) {
199 case 'T': // union
200 case 'U': // struct
201 case 'V': // class
202 case 'W': // enum
203 return true;
204 }
205 return false;
206 }
207
208 static bool isCustomType(std::string_view S) { return S[0] == '?'; }
209
210 static bool isPointerType(std::string_view S) {
211 if (llvm::itanium_demangle::starts_with(S, "$$Q")) // foo &&
212 return true;
213
214 switch (S.front()) {
215 case 'A': // foo &
216 case 'P': // foo *
217 case 'Q': // foo *const
218 case 'R': // foo *volatile
219 case 'S': // foo *const volatile
220 return true;
221 }
222 return false;
223 }
224
225 static bool isArrayType(std::string_view S) { return S[0] == 'Y'; }
226
227 static bool isFunctionType(std::string_view S) {
228 return llvm::itanium_demangle::starts_with(S, "$$A8@@") ||
229 llvm::itanium_demangle::starts_with(S, "$$A6");
230 }
231
232 static FunctionRefQualifier
233 demangleFunctionRefQualifier(std::string_view &MangledName) {
234 if (consumeFront(MangledName, 'G'))
235 return FunctionRefQualifier::Reference;
236 else if (consumeFront(MangledName, 'H'))
237 return FunctionRefQualifier::RValueReference;
238 return FunctionRefQualifier::None;
239 }
240
241 static std::pair<Qualifiers, PointerAffinity>
242 demanglePointerCVQualifiers(std::string_view &MangledName) {
243 if (consumeFront(MangledName, "$$Q"))
244 return std::make_pair(Q_None, PointerAffinity::RValueReference);
245
246 const char F = MangledName.front();
247 MangledName.remove_prefix(1);
248 switch (F) {
249 case 'A':
250 return std::make_pair(Q_None, PointerAffinity::Reference);
251 case 'P':
252 return std::make_pair(Q_None, PointerAffinity::Pointer);
253 case 'Q':
254 return std::make_pair(Q_Const, PointerAffinity::Pointer);
255 case 'R':
256 return std::make_pair(Q_Volatile, PointerAffinity::Pointer);
257 case 'S':
258 return std::make_pair(Qualifiers(Q_Const | Q_Volatile),
259 PointerAffinity::Pointer);
260 }
261 // This function is only called if isPointerType() returns true,
262 // and it only returns true for the six cases listed above.
263 DEMANGLE_UNREACHABLE;
264 }
265
266 std::string_view Demangler::copyString(std::string_view Borrowed) {
267 char *Stable = Arena.allocUnalignedBuffer(Borrowed.size());
268 // This is not a micro-optimization, it avoids UB, should Borrowed be an null
269 // buffer.
270 if (Borrowed.size())
271 std::memcpy(Stable, Borrowed.data(), Borrowed.size());
272
273 return {Stable, Borrowed.size()};
274 }
275
276 SpecialTableSymbolNode *
277 Demangler::demangleSpecialTableSymbolNode(std::string_view &MangledName,
278 SpecialIntrinsicKind K) {
279 NamedIdentifierNode *NI = Arena.alloc<NamedIdentifierNode>();
280 switch (K) {
281 case SpecialIntrinsicKind::Vftable:
282 NI->Name = "`vftable'";
283 break;
284 case SpecialIntrinsicKind::Vbtable:
285 NI->Name = "`vbtable'";
286 break;
287 case SpecialIntrinsicKind::LocalVftable:
288 NI->Name = "`local vftable'";
289 break;
290 case SpecialIntrinsicKind::RttiCompleteObjLocator:
291 NI->Name = "`RTTI Complete Object Locator'";
292 break;
293 default:
294 DEMANGLE_UNREACHABLE;
295 }
296 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI);
297 SpecialTableSymbolNode *STSN = Arena.alloc<SpecialTableSymbolNode>();
298 STSN->Name = QN;
299 bool IsMember = false;
300 if (MangledName.empty()) {
301 Error = true;
302 return nullptr;
303 }
304 char Front = MangledName.front();
305 MangledName.remove_prefix(1);
306 if (Front != '6' && Front != '7') {
307 Error = true;
308 return nullptr;
309 }
310
311 std::tie(STSN->Quals, IsMember) = demangleQualifiers(MangledName);
312 if (!consumeFront(MangledName, '@'))
313 STSN->TargetName = demangleFullyQualifiedTypeName(MangledName);
314 return STSN;
315 }
316
317 LocalStaticGuardVariableNode *
318 Demangler::demangleLocalStaticGuard(std::string_view &MangledName,
319 bool IsThread) {
320 LocalStaticGuardIdentifierNode *LSGI =
321 Arena.alloc<LocalStaticGuardIdentifierNode>();
322 LSGI->IsThread = IsThread;
323 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, LSGI);
324 LocalStaticGuardVariableNode *LSGVN =
325 Arena.alloc<LocalStaticGuardVariableNode>();
326 LSGVN->Name = QN;
327
328 if (consumeFront(MangledName, "4IA"))
329 LSGVN->IsVisible = false;
330 else if (consumeFront(MangledName, "5"))
331 LSGVN->IsVisible = true;
332 else {
333 Error = true;
334 return nullptr;
335 }
336
337 if (!MangledName.empty())
338 LSGI->ScopeIndex = demangleUnsigned(MangledName);
339 return LSGVN;
340 }
341
342 static NamedIdentifierNode *synthesizeNamedIdentifier(ArenaAllocator &Arena,
343 std::string_view Name) {
344 NamedIdentifierNode *Id = Arena.alloc<NamedIdentifierNode>();
345 Id->Name = Name;
346 return Id;
347 }
348
349 static QualifiedNameNode *synthesizeQualifiedName(ArenaAllocator &Arena,
350 IdentifierNode *Identifier) {
351 QualifiedNameNode *QN = Arena.alloc<QualifiedNameNode>();
352 QN->Components = Arena.alloc<NodeArrayNode>();
353 QN->Components->Count = 1;
354 QN->Components->Nodes = Arena.allocArray<Node *>(1);
355 QN->Components->Nodes[0] = Identifier;
356 return QN;
357 }
358
359 static QualifiedNameNode *synthesizeQualifiedName(ArenaAllocator &Arena,
360 std::string_view Name) {
361 NamedIdentifierNode *Id = synthesizeNamedIdentifier(Arena, Name);
362 return synthesizeQualifiedName(Arena, Id);
363 }
364
365 static VariableSymbolNode *synthesizeVariable(ArenaAllocator &Arena,
366 TypeNode *Type,
367 std::string_view VariableName) {
368 VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();
369 VSN->Type = Type;
370 VSN->Name = synthesizeQualifiedName(Arena, VariableName);
371 return VSN;
372 }
373
374 VariableSymbolNode *
375 Demangler::demangleUntypedVariable(ArenaAllocator &Arena,
376 std::string_view &MangledName,
377 std::string_view VariableName) {
378 NamedIdentifierNode *NI = synthesizeNamedIdentifier(Arena, VariableName);
379 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, NI);
380 VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();
381 VSN->Name = QN;
382 if (consumeFront(MangledName, "8"))
383 return VSN;
384
385 Error = true;
386 return nullptr;
387 }
388
389 VariableSymbolNode *
390 Demangler::demangleRttiBaseClassDescriptorNode(ArenaAllocator &Arena,
391 std::string_view &MangledName) {
392 RttiBaseClassDescriptorNode *RBCDN =
393 Arena.alloc<RttiBaseClassDescriptorNode>();
394 RBCDN->NVOffset = demangleUnsigned(MangledName);
395 RBCDN->VBPtrOffset = demangleSigned(MangledName);
396 RBCDN->VBTableOffset = demangleUnsigned(MangledName);
397 RBCDN->Flags = demangleUnsigned(MangledName);
398 if (Error)
399 return nullptr;
400
401 VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();
402 VSN->Name = demangleNameScopeChain(MangledName, RBCDN);
403 consumeFront(MangledName, '8');
404 return VSN;
405 }
406
407 FunctionSymbolNode *
408 Demangler::demangleInitFiniStub(std::string_view &MangledName,
409 bool IsDestructor) {
410 DynamicStructorIdentifierNode *DSIN =
411 Arena.alloc<DynamicStructorIdentifierNode>();
412 DSIN->IsDestructor = IsDestructor;
413
414 bool IsKnownStaticDataMember = false;
415 if (consumeFront(MangledName, '?'))
416 IsKnownStaticDataMember = true;
417
418 SymbolNode *Symbol = demangleDeclarator(MangledName);
419 if (Error)
420 return nullptr;
421
422 FunctionSymbolNode *FSN = nullptr;
423
424 if (Symbol->kind() == NodeKind::VariableSymbol) {
425 DSIN->Variable = static_cast<VariableSymbolNode *>(Symbol);
426
427 // Older versions of clang mangled this type of symbol incorrectly. They
428 // would omit the leading ? and they would only emit a single @ at the end.
429 // The correct mangling is a leading ? and 2 trailing @ signs. Handle
430 // both cases.
431 int AtCount = IsKnownStaticDataMember ? 2 : 1;
432 for (int I = 0; I < AtCount; ++I) {
433 if (consumeFront(MangledName, '@'))
434 continue;
435 Error = true;
436 return nullptr;
437 }
438
439 FSN = demangleFunctionEncoding(MangledName);
440 if (FSN)
441 FSN->Name = synthesizeQualifiedName(Arena, DSIN);
442 } else {
443 if (IsKnownStaticDataMember) {
444 // This was supposed to be a static data member, but we got a function.
445 Error = true;
446 return nullptr;
447 }
448
449 FSN = static_cast<FunctionSymbolNode *>(Symbol);
450 DSIN->Name = Symbol->Name;
451 FSN->Name = synthesizeQualifiedName(Arena, DSIN);
452 }
453
454 return FSN;
455 }
456
457 SymbolNode *Demangler::demangleSpecialIntrinsic(std::string_view &MangledName) {
458 SpecialIntrinsicKind SIK = consumeSpecialIntrinsicKind(MangledName);
459
460 switch (SIK) {
461 case SpecialIntrinsicKind::None:
462 return nullptr;
463 case SpecialIntrinsicKind::StringLiteralSymbol:
464 return demangleStringLiteral(MangledName);
465 case SpecialIntrinsicKind::Vftable:
466 case SpecialIntrinsicKind::Vbtable:
467 case SpecialIntrinsicKind::LocalVftable:
468 case SpecialIntrinsicKind::RttiCompleteObjLocator:
469 return demangleSpecialTableSymbolNode(MangledName, SIK);
470 case SpecialIntrinsicKind::VcallThunk:
471 return demangleVcallThunkNode(MangledName);
472 case SpecialIntrinsicKind::LocalStaticGuard:
473 return demangleLocalStaticGuard(MangledName, /*IsThread=*/false);
474 case SpecialIntrinsicKind::LocalStaticThreadGuard:
475 return demangleLocalStaticGuard(MangledName, /*IsThread=*/true);
476 case SpecialIntrinsicKind::RttiTypeDescriptor: {
477 TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result);
478 if (Error)
479 break;
480 if (!consumeFront(MangledName, "@8"))
481 break;
482 if (!MangledName.empty())
483 break;
484 return synthesizeVariable(Arena, T, "`RTTI Type Descriptor'");
485 }
486 case SpecialIntrinsicKind::RttiBaseClassArray:
487 return demangleUntypedVariable(Arena, MangledName,
488 "`RTTI Base Class Array'");
489 case SpecialIntrinsicKind::RttiClassHierarchyDescriptor:
490 return demangleUntypedVariable(Arena, MangledName,
491 "`RTTI Class Hierarchy Descriptor'");
492 case SpecialIntrinsicKind::RttiBaseClassDescriptor:
493 return demangleRttiBaseClassDescriptorNode(Arena, MangledName);
494 case SpecialIntrinsicKind::DynamicInitializer:
495 return demangleInitFiniStub(MangledName, /*IsDestructor=*/false);
496 case SpecialIntrinsicKind::DynamicAtexitDestructor:
497 return demangleInitFiniStub(MangledName, /*IsDestructor=*/true);
498 case SpecialIntrinsicKind::Typeof:
499 case SpecialIntrinsicKind::UdtReturning:
500 // It's unclear which tools produces these manglings, so demangling
501 // support is not (yet?) implemented.
502 break;
503 case SpecialIntrinsicKind::Unknown:
504 DEMANGLE_UNREACHABLE; // Never returned by consumeSpecialIntrinsicKind.
505 }
506 Error = true;
507 return nullptr;
508 }
509
510 IdentifierNode *
511 Demangler::demangleFunctionIdentifierCode(std::string_view &MangledName) {
512 assert(llvm::itanium_demangle::starts_with(MangledName, '?'));
513 MangledName.remove_prefix(1);
514 if (MangledName.empty()) {
515 Error = true;
516 return nullptr;
517 }
518
519 if (consumeFront(MangledName, "__"))
520 return demangleFunctionIdentifierCode(
521 MangledName, FunctionIdentifierCodeGroup::DoubleUnder);
522 if (consumeFront(MangledName, "_"))
523 return demangleFunctionIdentifierCode(MangledName,
524 FunctionIdentifierCodeGroup::Under);
525 return demangleFunctionIdentifierCode(MangledName,
526 FunctionIdentifierCodeGroup::Basic);
527 }
528
529 StructorIdentifierNode *
530 Demangler::demangleStructorIdentifier(std::string_view &MangledName,
531 bool IsDestructor) {
532 StructorIdentifierNode *N = Arena.alloc<StructorIdentifierNode>();
533 N->IsDestructor = IsDestructor;
534 return N;
535 }
536
537 ConversionOperatorIdentifierNode *
538 Demangler::demangleConversionOperatorIdentifier(std::string_view &MangledName) {
539 ConversionOperatorIdentifierNode *N =
540 Arena.alloc<ConversionOperatorIdentifierNode>();
541 return N;
542 }
543
544 LiteralOperatorIdentifierNode *
545 Demangler::demangleLiteralOperatorIdentifier(std::string_view &MangledName) {
546 LiteralOperatorIdentifierNode *N =
547 Arena.alloc<LiteralOperatorIdentifierNode>();
548 N->Name = demangleSimpleString(MangledName, /*Memorize=*/false);
549 return N;
550 }
551
552 IntrinsicFunctionKind
553 Demangler::translateIntrinsicFunctionCode(char CH,
554 FunctionIdentifierCodeGroup Group) {
555 using IFK = IntrinsicFunctionKind;
556 if (!(CH >= '0' && CH <= '9') && !(CH >= 'A' && CH <= 'Z')) {
557 Error = true;
558 return IFK::None;
559 }
560
561 // Not all ? identifiers are intrinsics *functions*. This function only maps
562 // operator codes for the special functions, all others are handled elsewhere,
563 // hence the IFK::None entries in the table.
564 static IFK Basic[36] = {
565 IFK::None, // ?0 # Foo::Foo()
566 IFK::None, // ?1 # Foo::~Foo()
567 IFK::New, // ?2 # operator new
568 IFK::Delete, // ?3 # operator delete
569 IFK::Assign, // ?4 # operator=
570 IFK::RightShift, // ?5 # operator>>
571 IFK::LeftShift, // ?6 # operator<<
572 IFK::LogicalNot, // ?7 # operator!
573 IFK::Equals, // ?8 # operator==
574 IFK::NotEquals, // ?9 # operator!=
575 IFK::ArraySubscript, // ?A # operator[]
576 IFK::None, // ?B # Foo::operator <type>()
577 IFK::Pointer, // ?C # operator->
578 IFK::Dereference, // ?D # operator*
579 IFK::Increment, // ?E # operator++
580 IFK::Decrement, // ?F # operator--
581 IFK::Minus, // ?G # operator-
582 IFK::Plus, // ?H # operator+
583 IFK::BitwiseAnd, // ?I # operator&
584 IFK::MemberPointer, // ?J # operator->*
585 IFK::Divide, // ?K # operator/
586 IFK::Modulus, // ?L # operator%
587 IFK::LessThan, // ?M operator<
588 IFK::LessThanEqual, // ?N operator<=
589 IFK::GreaterThan, // ?O operator>
590 IFK::GreaterThanEqual, // ?P operator>=
591 IFK::Comma, // ?Q operator,
592 IFK::Parens, // ?R operator()
593 IFK::BitwiseNot, // ?S operator~
594 IFK::BitwiseXor, // ?T operator^
595 IFK::BitwiseOr, // ?U operator|
596 IFK::LogicalAnd, // ?V operator&&
597 IFK::LogicalOr, // ?W operator||
598 IFK::TimesEqual, // ?X operator*=
599 IFK::PlusEqual, // ?Y operator+=
600 IFK::MinusEqual, // ?Z operator-=
601 };
602 static IFK Under[36] = {
603 IFK::DivEqual, // ?_0 operator/=
604 IFK::ModEqual, // ?_1 operator%=
605 IFK::RshEqual, // ?_2 operator>>=
606 IFK::LshEqual, // ?_3 operator<<=
607 IFK::BitwiseAndEqual, // ?_4 operator&=
608 IFK::BitwiseOrEqual, // ?_5 operator|=
609 IFK::BitwiseXorEqual, // ?_6 operator^=
610 IFK::None, // ?_7 # vftable
611 IFK::None, // ?_8 # vbtable
612 IFK::None, // ?_9 # vcall
613 IFK::None, // ?_A # typeof
614 IFK::None, // ?_B # local static guard
615 IFK::None, // ?_C # string literal
616 IFK::VbaseDtor, // ?_D # vbase destructor
617 IFK::VecDelDtor, // ?_E # vector deleting destructor
618 IFK::DefaultCtorClosure, // ?_F # default constructor closure
619 IFK::ScalarDelDtor, // ?_G # scalar deleting destructor
620 IFK::VecCtorIter, // ?_H # vector constructor iterator
621 IFK::VecDtorIter, // ?_I # vector destructor iterator
622 IFK::VecVbaseCtorIter, // ?_J # vector vbase constructor iterator
623 IFK::VdispMap, // ?_K # virtual displacement map
624 IFK::EHVecCtorIter, // ?_L # eh vector constructor iterator
625 IFK::EHVecDtorIter, // ?_M # eh vector destructor iterator
626 IFK::EHVecVbaseCtorIter, // ?_N # eh vector vbase constructor iterator
627 IFK::CopyCtorClosure, // ?_O # copy constructor closure
628 IFK::None, // ?_P<name> # udt returning <name>
629 IFK::None, // ?_Q # <unknown>
630 IFK::None, // ?_R0 - ?_R4 # RTTI Codes
631 IFK::None, // ?_S # local vftable
632 IFK::LocalVftableCtorClosure, // ?_T # local vftable constructor closure
633 IFK::ArrayNew, // ?_U operator new[]
634 IFK::ArrayDelete, // ?_V operator delete[]
635 IFK::None, // ?_W <unused>
636 IFK::None, // ?_X <unused>
637 IFK::None, // ?_Y <unused>
638 IFK::None, // ?_Z <unused>
639 };
640 static IFK DoubleUnder[36] = {
641 IFK::None, // ?__0 <unused>
642 IFK::None, // ?__1 <unused>
643 IFK::None, // ?__2 <unused>
644 IFK::None, // ?__3 <unused>
645 IFK::None, // ?__4 <unused>
646 IFK::None, // ?__5 <unused>
647 IFK::None, // ?__6 <unused>
648 IFK::None, // ?__7 <unused>
649 IFK::None, // ?__8 <unused>
650 IFK::None, // ?__9 <unused>
651 IFK::ManVectorCtorIter, // ?__A managed vector ctor iterator
652 IFK::ManVectorDtorIter, // ?__B managed vector dtor iterator
653 IFK::EHVectorCopyCtorIter, // ?__C EH vector copy ctor iterator
654 IFK::EHVectorVbaseCopyCtorIter, // ?__D EH vector vbase copy ctor iter
655 IFK::None, // ?__E dynamic initializer for `T'
656 IFK::None, // ?__F dynamic atexit destructor for `T'
657 IFK::VectorCopyCtorIter, // ?__G vector copy constructor iter
658 IFK::VectorVbaseCopyCtorIter, // ?__H vector vbase copy ctor iter
659 IFK::ManVectorVbaseCopyCtorIter, // ?__I managed vector vbase copy ctor
660 // iter
661 IFK::None, // ?__J local static thread guard
662 IFK::None, // ?__K operator ""_name
663 IFK::CoAwait, // ?__L operator co_await
664 IFK::Spaceship, // ?__M operator<=>
665 IFK::None, // ?__N <unused>
666 IFK::None, // ?__O <unused>
667 IFK::None, // ?__P <unused>
668 IFK::None, // ?__Q <unused>
669 IFK::None, // ?__R <unused>
670 IFK::None, // ?__S <unused>
671 IFK::None, // ?__T <unused>
672 IFK::None, // ?__U <unused>
673 IFK::None, // ?__V <unused>
674 IFK::None, // ?__W <unused>
675 IFK::None, // ?__X <unused>
676 IFK::None, // ?__Y <unused>
677 IFK::None, // ?__Z <unused>
678 };
679
680 int Index = (CH >= '0' && CH <= '9') ? (CH - '0') : (CH - 'A' + 10);
681 switch (Group) {
682 case FunctionIdentifierCodeGroup::Basic:
683 return Basic[Index];
684 case FunctionIdentifierCodeGroup::Under:
685 return Under[Index];
686 case FunctionIdentifierCodeGroup::DoubleUnder:
687 return DoubleUnder[Index];
688 }
689 DEMANGLE_UNREACHABLE;
690 }
691
692 IdentifierNode *
693 Demangler::demangleFunctionIdentifierCode(std::string_view &MangledName,
694 FunctionIdentifierCodeGroup Group) {
695 if (MangledName.empty()) {
696 Error = true;
697 return nullptr;
698 }
699 const char CH = MangledName.front();
700 switch (Group) {
701 case FunctionIdentifierCodeGroup::Basic:
702 MangledName.remove_prefix(1);
703 switch (CH) {
704 case '0':
705 case '1':
706 return demangleStructorIdentifier(MangledName, CH == '1');
707 case 'B':
708 return demangleConversionOperatorIdentifier(MangledName);
709 default:
710 return Arena.alloc<IntrinsicFunctionIdentifierNode>(
711 translateIntrinsicFunctionCode(CH, Group));
712 }
713 case FunctionIdentifierCodeGroup::Under:
714 MangledName.remove_prefix(1);
715 return Arena.alloc<IntrinsicFunctionIdentifierNode>(
716 translateIntrinsicFunctionCode(CH, Group));
717 case FunctionIdentifierCodeGroup::DoubleUnder:
718 MangledName.remove_prefix(1);
719 switch (CH) {
720 case 'K':
721 return demangleLiteralOperatorIdentifier(MangledName);
722 default:
723 return Arena.alloc<IntrinsicFunctionIdentifierNode>(
724 translateIntrinsicFunctionCode(CH, Group));
725 }
726 }
727
728 DEMANGLE_UNREACHABLE;
729 }
730
731 SymbolNode *Demangler::demangleEncodedSymbol(std::string_view &MangledName,
732 QualifiedNameNode *Name) {
733 if (MangledName.empty()) {
734 Error = true;
735 return nullptr;
736 }
737
738 // Read a variable.
739 switch (MangledName.front()) {
740 case '0':
741 case '1':
742 case '2':
743 case '3':
744 case '4': {
745 StorageClass SC = demangleVariableStorageClass(MangledName);
746 return demangleVariableEncoding(MangledName, SC);
747 }
748 }
749 FunctionSymbolNode *FSN = demangleFunctionEncoding(MangledName);
750
751 IdentifierNode *UQN = Name->getUnqualifiedIdentifier();
752 if (UQN->kind() == NodeKind::ConversionOperatorIdentifier) {
753 ConversionOperatorIdentifierNode *COIN =
754 static_cast<ConversionOperatorIdentifierNode *>(UQN);
755 if (FSN)
756 COIN->TargetType = FSN->Signature->ReturnType;
757 }
758 return FSN;
759 }
760
761 SymbolNode *Demangler::demangleDeclarator(std::string_view &MangledName) {
762 // What follows is a main symbol name. This may include namespaces or class
763 // back references.
764 QualifiedNameNode *QN = demangleFullyQualifiedSymbolName(MangledName);
765 if (Error)
766 return nullptr;
767
768 SymbolNode *Symbol = demangleEncodedSymbol(MangledName, QN);
769 if (Error)
770 return nullptr;
771 Symbol->Name = QN;
772
773 IdentifierNode *UQN = QN->getUnqualifiedIdentifier();
774 if (UQN->kind() == NodeKind::ConversionOperatorIdentifier) {
775 ConversionOperatorIdentifierNode *COIN =
776 static_cast<ConversionOperatorIdentifierNode *>(UQN);
777 if (!COIN->TargetType) {
778 Error = true;
779 return nullptr;
780 }
781 }
782 return Symbol;
783 }
784
785 SymbolNode *Demangler::demangleMD5Name(std::string_view &MangledName) {
786 assert(llvm::itanium_demangle::starts_with(MangledName, "??@"));
787 // This is an MD5 mangled name. We can't demangle it, just return the
788 // mangled name.
789 // An MD5 mangled name is ??@ followed by 32 characters and a terminating @.
790 size_t MD5Last = MangledName.find('@', strlen("??@"));
791 if (MD5Last == std::string_view::npos) {
792 Error = true;
793 return nullptr;
794 }
795 const char *Start = MangledName.data();
796 const size_t StartSize = MangledName.size();
797 MangledName.remove_prefix(MD5Last + 1);
798
799 // There are two additional special cases for MD5 names:
800 // 1. For complete object locators where the object name is long enough
801 // for the object to have an MD5 name, the complete object locator is
802 // called ??@...@??_R4@ (with a trailing "??_R4@" instead of the usual
803 // leading "??_R4". This is handled here.
804 // 2. For catchable types, in versions of MSVC before 2015 (<1900) or after
805 // 2017.2 (>= 1914), the catchable type mangling is _CT??@...@??@...@8
806 // instead of_CT??@...@8 with just one MD5 name. Since we don't yet
807 // demangle catchable types anywhere, this isn't handled for MD5 names
808 // either.
809 consumeFront(MangledName, "??_R4@");
810
811 assert(MangledName.size() < StartSize);
812 const size_t Count = StartSize - MangledName.size();
813 std::string_view MD5(Start, Count);
814 SymbolNode *S = Arena.alloc<SymbolNode>(NodeKind::Md5Symbol);
815 S->Name = synthesizeQualifiedName(Arena, MD5);
816
817 return S;
818 }
819
820 SymbolNode *Demangler::demangleTypeinfoName(std::string_view &MangledName) {
821 assert(llvm::itanium_demangle::starts_with(MangledName, '.'));
822 consumeFront(MangledName, '.');
823
824 TypeNode *T = demangleType(MangledName, QualifierMangleMode::Result);
825 if (Error || !MangledName.empty()) {
826 Error = true;
827 return nullptr;
828 }
829 return synthesizeVariable(Arena, T, "`RTTI Type Descriptor Name'");
830 }
831
832 // Parser entry point.
833 SymbolNode *Demangler::parse(std::string_view &MangledName) {
834 // Typeinfo names are strings stored in RTTI data. They're not symbol names.
835 // It's still useful to demangle them. They're the only demangled entity
836 // that doesn't start with a "?" but a ".".
837 if (llvm::itanium_demangle::starts_with(MangledName, '.'))
838 return demangleTypeinfoName(MangledName);
839
840 if (llvm::itanium_demangle::starts_with(MangledName, "??@"))
841 return demangleMD5Name(MangledName);
842
843 // MSVC-style mangled symbols must start with '?'.
844 if (!llvm::itanium_demangle::starts_with(MangledName, '?')) {
845 Error = true;
846 return nullptr;
847 }
848
849 consumeFront(MangledName, '?');
850
851 // ?$ is a template instantiation, but all other names that start with ? are
852 // operators / special names.
853 if (SymbolNode *SI = demangleSpecialIntrinsic(MangledName))
854 return SI;
855
856 return demangleDeclarator(MangledName);
857 }
858
859 TagTypeNode *Demangler::parseTagUniqueName(std::string_view &MangledName) {
860 if (!consumeFront(MangledName, ".?A")) {
861 Error = true;
862 return nullptr;
863 }
864 consumeFront(MangledName, ".?A");
865 if (MangledName.empty()) {
866 Error = true;
867 return nullptr;
868 }
869
870 return demangleClassType(MangledName);
871 }
872
873 // <type-encoding> ::= <storage-class> <variable-type>
874 // <storage-class> ::= 0 # private static member
875 // ::= 1 # protected static member
876 // ::= 2 # public static member
877 // ::= 3 # global
878 // ::= 4 # static local
879
880 VariableSymbolNode *
881 Demangler::demangleVariableEncoding(std::string_view &MangledName,
882 StorageClass SC) {
883 VariableSymbolNode *VSN = Arena.alloc<VariableSymbolNode>();
884
885 VSN->Type = demangleType(MangledName, QualifierMangleMode::Drop);
886 VSN->SC = SC;
887
888 if (Error)
889 return nullptr;
890
891 // <variable-type> ::= <type> <cvr-qualifiers>
892 // ::= <type> <pointee-cvr-qualifiers> # pointers, references
893 switch (VSN->Type->kind()) {
894 case NodeKind::PointerType: {
895 PointerTypeNode *PTN = static_cast<PointerTypeNode *>(VSN->Type);
896
897 Qualifiers ExtraChildQuals = Q_None;
898 PTN->Quals = Qualifiers(VSN->Type->Quals |
899 demanglePointerExtQualifiers(MangledName));
900
901 bool IsMember = false;
902 std::tie(ExtraChildQuals, IsMember) = demangleQualifiers(MangledName);
903
904 if (PTN->ClassParent) {
905 QualifiedNameNode *BackRefName =
906 demangleFullyQualifiedTypeName(MangledName);
907 (void)BackRefName;
908 }
909 PTN->Pointee->Quals = Qualifiers(PTN->Pointee->Quals | ExtraChildQuals);
910
911 break;
912 }
913 default:
914 VSN->Type->Quals = demangleQualifiers(MangledName).first;
915 break;
916 }
917
918 return VSN;
919 }
920
921 // Sometimes numbers are encoded in mangled symbols. For example,
922 // "int (*x)[20]" is a valid C type (x is a pointer to an array of
923 // length 20), so we need some way to embed numbers as part of symbols.
924 // This function parses it.
925 //
926 // <number> ::= [?] <non-negative integer>
927 //
928 // <non-negative integer> ::= <decimal digit> # when 1 <= Number <= 10
929 // ::= <hex digit>+ @ # when Number == 0 or >= 10
930 //
931 // <hex-digit> ::= [A-P] # A = 0, B = 1, ...
932 std::pair<uint64_t, bool>
933 Demangler::demangleNumber(std::string_view &MangledName) {
934 bool IsNegative = consumeFront(MangledName, '?');
935
936 if (startsWithDigit(MangledName)) {
937 uint64_t Ret = MangledName[0] - '0' + 1;
938 MangledName.remove_prefix(1);
939 return {Ret, IsNegative};
940 }
941
942 uint64_t Ret = 0;
943 for (size_t i = 0; i < MangledName.size(); ++i) {
944 char C = MangledName[i];
945 if (C == '@') {
946 MangledName.remove_prefix(i + 1);
947 return {Ret, IsNegative};
948 }
949 if ('A' <= C && C <= 'P') {
950 Ret = (Ret << 4) + (C - 'A');
951 continue;
952 }
953 break;
954 }
955
956 Error = true;
957 return {0ULL, false};
958 }
959
960 uint64_t Demangler::demangleUnsigned(std::string_view &MangledName) {
961 bool IsNegative = false;
962 uint64_t Number = 0;
963 std::tie(Number, IsNegative) = demangleNumber(MangledName);
964 if (IsNegative)
965 Error = true;
966 return Number;
967 }
968
969 int64_t Demangler::demangleSigned(std::string_view &MangledName) {
970 bool IsNegative = false;
971 uint64_t Number = 0;
972 std::tie(Number, IsNegative) = demangleNumber(MangledName);
973 if (Number > INT64_MAX)
974 Error = true;
975 int64_t I = static_cast<int64_t>(Number);
976 return IsNegative ? -I : I;
977 }
978
979 // First 10 strings can be referenced by special BackReferences ?0, ?1, ..., ?9.
980 // Memorize it.
981 void Demangler::memorizeString(std::string_view S) {
982 if (Backrefs.NamesCount >= BackrefContext::Max)
983 return;
984 for (size_t i = 0; i < Backrefs.NamesCount; ++i)
985 if (S == Backrefs.Names[i]->Name)
986 return;
987 NamedIdentifierNode *N = Arena.alloc<NamedIdentifierNode>();
988 N->Name = S;
989 Backrefs.Names[Backrefs.NamesCount++] = N;
990 }
991
992 NamedIdentifierNode *
993 Demangler::demangleBackRefName(std::string_view &MangledName) {
994 assert(startsWithDigit(MangledName));
995
996 size_t I = MangledName[0] - '0';
997 if (I >= Backrefs.NamesCount) {
998 Error = true;
999 return nullptr;
1000 }
1001
1002 MangledName.remove_prefix(1);
1003 return Backrefs.Names[I];
1004 }
1005
1006 void Demangler::memorizeIdentifier(IdentifierNode *Identifier) {
1007 // Render this class template name into a string buffer so that we can
1008 // memorize it for the purpose of back-referencing.
1009 OutputBuffer OB;
1010 Identifier->output(OB, OF_Default);
1011 std::string_view Owned = copyString(OB);
1012 memorizeString(Owned);
1013 std::free(OB.getBuffer());
1014 }
1015
1016 IdentifierNode *
1017 Demangler::demangleTemplateInstantiationName(std::string_view &MangledName,
1018 NameBackrefBehavior NBB) {
1019 assert(llvm::itanium_demangle::starts_with(MangledName, "?$"));
1020 consumeFront(MangledName, "?$");
1021
1022 BackrefContext OuterContext;
1023 std::swap(OuterContext, Backrefs);
1024
1025 IdentifierNode *Identifier =
1026 demangleUnqualifiedSymbolName(MangledName, NBB_Simple);
1027 if (!Error)
1028 Identifier->TemplateParams = demangleTemplateParameterList(MangledName);
1029
1030 std::swap(OuterContext, Backrefs);
1031 if (Error)
1032 return nullptr;
1033
1034 if (NBB & NBB_Template) {
1035 // NBB_Template is only set for types and non-leaf names ("a::" in "a::b").
1036 // Structors and conversion operators only makes sense in a leaf name, so
1037 // reject them in NBB_Template contexts.
1038 if (Identifier->kind() == NodeKind::ConversionOperatorIdentifier ||
1039 Identifier->kind() == NodeKind::StructorIdentifier) {
1040 Error = true;
1041 return nullptr;
1042 }
1043
1044 memorizeIdentifier(Identifier);
1045 }
1046
1047 return Identifier;
1048 }
1049
1050 NamedIdentifierNode *
1051 Demangler::demangleSimpleName(std::string_view &MangledName, bool Memorize) {
1052 std::string_view S = demangleSimpleString(MangledName, Memorize);
1053 if (Error)
1054 return nullptr;
1055
1056 NamedIdentifierNode *Name = Arena.alloc<NamedIdentifierNode>();
1057 Name->Name = S;
1058 return Name;
1059 }
1060
1061 static bool isRebasedHexDigit(char C) { return (C >= 'A' && C <= 'P'); }
1062
1063 static uint8_t rebasedHexDigitToNumber(char C) {
1064 assert(isRebasedHexDigit(C));
1065 return (C <= 'J') ? (C - 'A') : (10 + C - 'K');
1066 }
1067
1068 uint8_t Demangler::demangleCharLiteral(std::string_view &MangledName) {
1069 assert(!MangledName.empty());
1070 if (!llvm::itanium_demangle::starts_with(MangledName, '?')) {
1071 const uint8_t F = MangledName.front();
1072 MangledName.remove_prefix(1);
1073 return F;
1074 }
1075
1076 MangledName.remove_prefix(1);
1077 if (MangledName.empty())
1078 goto CharLiteralError;
1079
1080 if (consumeFront(MangledName, '$')) {
1081 // Two hex digits
1082 if (MangledName.size() < 2)
1083 goto CharLiteralError;
1084 std::string_view Nibbles = MangledName.substr(0, 2);
1085 if (!isRebasedHexDigit(Nibbles[0]) || !isRebasedHexDigit(Nibbles[1]))
1086 goto CharLiteralError;
1087 // Don't append the null terminator.
1088 uint8_t C1 = rebasedHexDigitToNumber(Nibbles[0]);
1089 uint8_t C2 = rebasedHexDigitToNumber(Nibbles[1]);
1090 MangledName.remove_prefix(2);
1091 return (C1 << 4) | C2;
1092 }
1093
1094 if (startsWithDigit(MangledName)) {
1095 const char *Lookup = ",/\\:. \n\t'-";
1096 char C = Lookup[MangledName[0] - '0'];
1097 MangledName.remove_prefix(1);
1098 return C;
1099 }
1100
1101 if (MangledName[0] >= 'a' && MangledName[0] <= 'z') {
1102 char Lookup[26] = {'\xE1', '\xE2', '\xE3', '\xE4', '\xE5', '\xE6', '\xE7',
1103 '\xE8', '\xE9', '\xEA', '\xEB', '\xEC', '\xED', '\xEE',
1104 '\xEF', '\xF0', '\xF1', '\xF2', '\xF3', '\xF4', '\xF5',
1105 '\xF6', '\xF7', '\xF8', '\xF9', '\xFA'};
1106 char C = Lookup[MangledName[0] - 'a'];
1107 MangledName.remove_prefix(1);
1108 return C;
1109 }
1110
1111 if (MangledName[0] >= 'A' && MangledName[0] <= 'Z') {
1112 char Lookup[26] = {'\xC1', '\xC2', '\xC3', '\xC4', '\xC5', '\xC6', '\xC7',
1113 '\xC8', '\xC9', '\xCA', '\xCB', '\xCC', '\xCD', '\xCE',
1114 '\xCF', '\xD0', '\xD1', '\xD2', '\xD3', '\xD4', '\xD5',
1115 '\xD6', '\xD7', '\xD8', '\xD9', '\xDA'};
1116 char C = Lookup[MangledName[0] - 'A'];
1117 MangledName.remove_prefix(1);
1118 return C;
1119 }
1120
1121 CharLiteralError:
1122 Error = true;
1123 return '\0';
1124 }
1125
1126 wchar_t Demangler::demangleWcharLiteral(std::string_view &MangledName) {
1127 uint8_t C1, C2;
1128
1129 C1 = demangleCharLiteral(MangledName);
1130 if (Error || MangledName.empty())
1131 goto WCharLiteralError;
1132 C2 = demangleCharLiteral(MangledName);
1133 if (Error)
1134 goto WCharLiteralError;
1135
1136 return ((wchar_t)C1 << 8) | (wchar_t)C2;
1137
1138 WCharLiteralError:
1139 Error = true;
1140 return L'\0';
1141 }
1142
1143 static void writeHexDigit(char *Buffer, uint8_t Digit) {
1144 assert(Digit <= 15);
1145 *Buffer = (Digit < 10) ? ('0' + Digit) : ('A' + Digit - 10);
1146 }
1147
1148 static void outputHex(OutputBuffer &OB, unsigned C) {
1149 assert (C != 0);
1150
1151 // It's easier to do the math if we can work from right to left, but we need
1152 // to print the numbers from left to right. So render this into a temporary
1153 // buffer first, then output the temporary buffer. Each byte is of the form
1154 // \xAB, which means that each byte needs 4 characters. Since there are at
1155 // most 4 bytes, we need a 4*4+1 = 17 character temporary buffer.
1156 char TempBuffer[17];
1157
1158 ::memset(TempBuffer, 0, sizeof(TempBuffer));
1159 constexpr int MaxPos = sizeof(TempBuffer) - 1;
1160
1161 int Pos = MaxPos - 1; // TempBuffer[MaxPos] is the terminating \0.
1162 while (C != 0) {
1163 for (int I = 0; I < 2; ++I) {
1164 writeHexDigit(&TempBuffer[Pos--], C % 16);
1165 C /= 16;
1166 }
1167 }
1168 TempBuffer[Pos--] = 'x';
1169 assert(Pos >= 0);
1170 TempBuffer[Pos--] = '\\';
1171 OB << std::string_view(&TempBuffer[Pos + 1]);
1172 }
1173
1174 static void outputEscapedChar(OutputBuffer &OB, unsigned C) {
1175 switch (C) {
1176 case '\0': // nul
1177 OB << "\\0";
1178 return;
1179 case '\'': // single quote
1180 OB << "\\\'";
1181 return;
1182 case '\"': // double quote
1183 OB << "\\\"";
1184 return;
1185 case '\\': // backslash
1186 OB << "\\\\";
1187 return;
1188 case '\a': // bell
1189 OB << "\\a";
1190 return;
1191 case '\b': // backspace
1192 OB << "\\b";
1193 return;
1194 case '\f': // form feed
1195 OB << "\\f";
1196 return;
1197 case '\n': // new line
1198 OB << "\\n";
1199 return;
1200 case '\r': // carriage return
1201 OB << "\\r";
1202 return;
1203 case '\t': // tab
1204 OB << "\\t";
1205 return;
1206 case '\v': // vertical tab
1207 OB << "\\v";
1208 return;
1209 default:
1210 break;
1211 }
1212
1213 if (C > 0x1F && C < 0x7F) {
1214 // Standard ascii char.
1215 OB << (char)C;
1216 return;
1217 }
1218
1219 outputHex(OB, C);
1220 }
1221
1222 static unsigned countTrailingNullBytes(const uint8_t *StringBytes, int Length) {
1223 const uint8_t *End = StringBytes + Length - 1;
1224 unsigned Count = 0;
1225 while (Length > 0 && *End == 0) {
1226 --Length;
1227 --End;
1228 ++Count;
1229 }
1230 return Count;
1231 }
1232
1233 static unsigned countEmbeddedNulls(const uint8_t *StringBytes,
1234 unsigned Length) {
1235 unsigned Result = 0;
1236 for (unsigned I = 0; I < Length; ++I) {
1237 if (*StringBytes++ == 0)
1238 ++Result;
1239 }
1240 return Result;
1241 }
1242
1243 // A mangled (non-wide) string literal stores the total length of the string it
1244 // refers to (passed in NumBytes), and it contains up to 32 bytes of actual text
1245 // (passed in StringBytes, NumChars).
1246 static unsigned guessCharByteSize(const uint8_t *StringBytes, unsigned NumChars,
1247 uint64_t NumBytes) {
1248 assert(NumBytes > 0);
1249
1250 // If the number of bytes is odd, this is guaranteed to be a char string.
1251 if (NumBytes % 2 == 1)
1252 return 1;
1253
1254 // All strings can encode at most 32 bytes of data. If it's less than that,
1255 // then we encoded the entire string. In this case we check for a 1-byte,
1256 // 2-byte, or 4-byte null terminator.
1257 if (NumBytes < 32) {
1258 unsigned TrailingNulls = countTrailingNullBytes(StringBytes, NumChars);
1259 if (TrailingNulls >= 4 && NumBytes % 4 == 0)
1260 return 4;
1261 if (TrailingNulls >= 2)
1262 return 2;
1263 return 1;
1264 }
1265
1266 // The whole string was not able to be encoded. Try to look at embedded null
1267 // terminators to guess. The heuristic is that we count all embedded null
1268 // terminators. If more than 2/3 are null, it's a char32. If more than 1/3
1269 // are null, it's a char16. Otherwise it's a char8. This obviously isn't
1270 // perfect and is biased towards languages that have ascii alphabets, but this
1271 // was always going to be best effort since the encoding is lossy.
1272 unsigned Nulls = countEmbeddedNulls(StringBytes, NumChars);
1273 if (Nulls >= 2 * NumChars / 3 && NumBytes % 4 == 0)
1274 return 4;
1275 if (Nulls >= NumChars / 3)
1276 return 2;
1277 return 1;
1278 }
1279
1280 static unsigned decodeMultiByteChar(const uint8_t *StringBytes,
1281 unsigned CharIndex, unsigned CharBytes) {
1282 assert(CharBytes == 1 || CharBytes == 2 || CharBytes == 4);
1283 unsigned Offset = CharIndex * CharBytes;
1284 unsigned Result = 0;
1285 StringBytes = StringBytes + Offset;
1286 for (unsigned I = 0; I < CharBytes; ++I) {
1287 unsigned C = static_cast<unsigned>(StringBytes[I]);
1288 Result |= C << (8 * I);
1289 }
1290 return Result;
1291 }
1292
1293 FunctionSymbolNode *
1294 Demangler::demangleVcallThunkNode(std::string_view &MangledName) {
1295 FunctionSymbolNode *FSN = Arena.alloc<FunctionSymbolNode>();
1296 VcallThunkIdentifierNode *VTIN = Arena.alloc<VcallThunkIdentifierNode>();
1297 FSN->Signature = Arena.alloc<ThunkSignatureNode>();
1298 FSN->Signature->FunctionClass = FC_NoParameterList;
1299
1300 FSN->Name = demangleNameScopeChain(MangledName, VTIN);
1301 if (!Error)
1302 Error = !consumeFront(MangledName, "$B");
1303 if (!Error)
1304 VTIN->OffsetInVTable = demangleUnsigned(MangledName);
1305 if (!Error)
1306 Error = !consumeFront(MangledName, 'A');
1307 if (!Error)
1308 FSN->Signature->CallConvention = demangleCallingConvention(MangledName);
1309 return (Error) ? nullptr : FSN;
1310 }
1311
1312 EncodedStringLiteralNode *
1313 Demangler::demangleStringLiteral(std::string_view &MangledName) {
1314 // This function uses goto, so declare all variables up front.
1315 OutputBuffer OB;
1316 std::string_view CRC;
1317 uint64_t StringByteSize;
1318 bool IsWcharT = false;
1319 bool IsNegative = false;
1320 size_t CrcEndPos = 0;
1321 char F;
1322
1323 EncodedStringLiteralNode *Result = Arena.alloc<EncodedStringLiteralNode>();
1324
1325 // Prefix indicating the beginning of a string literal
1326 if (!consumeFront(MangledName, "@_"))
1327 goto StringLiteralError;
1328 if (MangledName.empty())
1329 goto StringLiteralError;
1330
1331 // Char Type (regular or wchar_t)
1332 F = MangledName.front();
1333 MangledName.remove_prefix(1);
1334 switch (F) {
1335 case '1':
1336 IsWcharT = true;
1337 DEMANGLE_FALLTHROUGH;
1338 case '0':
1339 break;
1340 default:
1341 goto StringLiteralError;
1342 }
1343
1344 // Encoded Length
1345 std::tie(StringByteSize, IsNegative) = demangleNumber(MangledName);
1346 if (Error || IsNegative || StringByteSize < (IsWcharT ? 2 : 1))
1347 goto StringLiteralError;
1348
1349 // CRC 32 (always 8 characters plus a terminator)
1350 CrcEndPos = MangledName.find('@');
1351 if (CrcEndPos == std::string_view::npos)
1352 goto StringLiteralError;
1353 CRC = MangledName.substr(0, CrcEndPos);
1354 MangledName.remove_prefix(CrcEndPos + 1);
1355 if (MangledName.empty())
1356 goto StringLiteralError;
1357
1358 if (IsWcharT) {
1359 Result->Char = CharKind::Wchar;
1360 if (StringByteSize > 64)
1361 Result->IsTruncated = true;
1362
1363 while (!consumeFront(MangledName, '@')) {
1364 if (MangledName.size() < 2)
1365 goto StringLiteralError;
1366 wchar_t W = demangleWcharLiteral(MangledName);
1367 if (StringByteSize != 2 || Result->IsTruncated)
1368 outputEscapedChar(OB, W);
1369 StringByteSize -= 2;
1370 if (Error)
1371 goto StringLiteralError;
1372 }
1373 } else {
1374 // The max byte length is actually 32, but some compilers mangled strings
1375 // incorrectly, so we have to assume it can go higher.
1376 constexpr unsigned MaxStringByteLength = 32 * 4;
1377 uint8_t StringBytes[MaxStringByteLength];
1378
1379 unsigned BytesDecoded = 0;
1380 while (!consumeFront(MangledName, '@')) {
1381 if (MangledName.size() < 1 || BytesDecoded >= MaxStringByteLength)
1382 goto StringLiteralError;
1383 StringBytes[BytesDecoded++] = demangleCharLiteral(MangledName);
1384 }
1385
1386 if (StringByteSize > BytesDecoded)
1387 Result->IsTruncated = true;
1388
1389 unsigned CharBytes =
1390 guessCharByteSize(StringBytes, BytesDecoded, StringByteSize);
1391 assert(StringByteSize % CharBytes == 0);
1392 switch (CharBytes) {
1393 case 1:
1394 Result->Char = CharKind::Char;
1395 break;
1396 case 2:
1397 Result->Char = CharKind::Char16;
1398 break;
1399 case 4:
1400 Result->Char = CharKind::Char32;
1401 break;
1402 default:
1403 DEMANGLE_UNREACHABLE;
1404 }
1405 const unsigned NumChars = BytesDecoded / CharBytes;
1406 for (unsigned CharIndex = 0; CharIndex < NumChars; ++CharIndex) {
1407 unsigned NextChar =
1408 decodeMultiByteChar(StringBytes, CharIndex, CharBytes);
1409 if (CharIndex + 1 < NumChars || Result->IsTruncated)
1410 outputEscapedChar(OB, NextChar);
1411 }
1412 }
1413
1414 Result->DecodedString = copyString(OB);
1415 std::free(OB.getBuffer());
1416 return Result;
1417
1418 StringLiteralError:
1419 Error = true;
1420 std::free(OB.getBuffer());
1421 return nullptr;
1422 }
1423
1424 // Returns MangledName's prefix before the first '@', or an error if
1425 // MangledName contains no '@' or the prefix has length 0.
1426 std::string_view Demangler::demangleSimpleString(std::string_view &MangledName,
1427 bool Memorize) {
1428 std::string_view S;
1429 for (size_t i = 0; i < MangledName.size(); ++i) {
1430 if (MangledName[i] != '@')
1431 continue;
1432 if (i == 0)
1433 break;
1434 S = MangledName.substr(0, i);
1435 MangledName.remove_prefix(i + 1);
1436
1437 if (Memorize)
1438 memorizeString(S);
1439 return S;
1440 }
1441
1442 Error = true;
1443 return {};
1444 }
1445
1446 NamedIdentifierNode *
1447 Demangler::demangleAnonymousNamespaceName(std::string_view &MangledName) {
1448 assert(llvm::itanium_demangle::starts_with(MangledName, "?A"));
1449 consumeFront(MangledName, "?A");
1450
1451 NamedIdentifierNode *Node = Arena.alloc<NamedIdentifierNode>();
1452 Node->Name = "`anonymous namespace'";
1453 size_t EndPos = MangledName.find('@');
1454 if (EndPos == std::string_view::npos) {
1455 Error = true;
1456 return nullptr;
1457 }
1458 std::string_view NamespaceKey = MangledName.substr(0, EndPos);
1459 memorizeString(NamespaceKey);
1460 MangledName = MangledName.substr(EndPos + 1);
1461 return Node;
1462 }
1463
1464 NamedIdentifierNode *
1465 Demangler::demangleLocallyScopedNamePiece(std::string_view &MangledName) {
1466 assert(startsWithLocalScopePattern(MangledName));
1467
1468 NamedIdentifierNode *Identifier = Arena.alloc<NamedIdentifierNode>();
1469 consumeFront(MangledName, '?');
1470 uint64_t Number = 0;
1471 bool IsNegative = false;
1472 std::tie(Number, IsNegative) = demangleNumber(MangledName);
1473 assert(!IsNegative);
1474
1475 // One ? to terminate the number
1476 consumeFront(MangledName, '?');
1477
1478 assert(!Error);
1479 Node *Scope = parse(MangledName);
1480 if (Error)
1481 return nullptr;
1482
1483 // Render the parent symbol's name into a buffer.
1484 OutputBuffer OB;
1485 OB << '`';
1486 Scope->output(OB, OF_Default);
1487 OB << '\'';
1488 OB << "::`" << Number << "'";
1489
1490 Identifier->Name = copyString(OB);
1491 std::free(OB.getBuffer());
1492 return Identifier;
1493 }
1494
1495 // Parses a type name in the form of A@B@C@@ which represents C::B::A.
1496 QualifiedNameNode *
1497 Demangler::demangleFullyQualifiedTypeName(std::string_view &MangledName) {
1498 IdentifierNode *Identifier =
1499 demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true);
1500 if (Error)
1501 return nullptr;
1502 assert(Identifier);
1503
1504 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, Identifier);
1505 if (Error)
1506 return nullptr;
1507 assert(QN);
1508 return QN;
1509 }
1510
1511 // Parses a symbol name in the form of A@B@C@@ which represents C::B::A.
1512 // Symbol names have slightly different rules regarding what can appear
1513 // so we separate out the implementations for flexibility.
1514 QualifiedNameNode *
1515 Demangler::demangleFullyQualifiedSymbolName(std::string_view &MangledName) {
1516 // This is the final component of a symbol name (i.e. the leftmost component
1517 // of a mangled name. Since the only possible template instantiation that
1518 // can appear in this context is a function template, and since those are
1519 // not saved for the purposes of name backreferences, only backref simple
1520 // names.
1521 IdentifierNode *Identifier =
1522 demangleUnqualifiedSymbolName(MangledName, NBB_Simple);
1523 if (Error)
1524 return nullptr;
1525
1526 QualifiedNameNode *QN = demangleNameScopeChain(MangledName, Identifier);
1527 if (Error)
1528 return nullptr;
1529
1530 if (Identifier->kind() == NodeKind::StructorIdentifier) {
1531 if (QN->Components->Count < 2) {
1532 Error = true;
1533 return nullptr;
1534 }
1535 StructorIdentifierNode *SIN =
1536 static_cast<StructorIdentifierNode *>(Identifier);
1537 Node *ClassNode = QN->Components->Nodes[QN->Components->Count - 2];
1538 SIN->Class = static_cast<IdentifierNode *>(ClassNode);
1539 }
1540 assert(QN);
1541 return QN;
1542 }
1543
1544 IdentifierNode *
1545 Demangler::demangleUnqualifiedTypeName(std::string_view &MangledName,
1546 bool Memorize) {
1547 // An inner-most name can be a back-reference, because a fully-qualified name
1548 // (e.g. Scope + Inner) can contain other fully qualified names inside of
1549 // them (for example template parameters), and these nested parameters can
1550 // refer to previously mangled types.
1551 if (startsWithDigit(MangledName))
1552 return demangleBackRefName(MangledName);
1553
1554 if (llvm::itanium_demangle::starts_with(MangledName, "?$"))
1555 return demangleTemplateInstantiationName(MangledName, NBB_Template);
1556
1557 return demangleSimpleName(MangledName, Memorize);
1558 }
1559
1560 IdentifierNode *
1561 Demangler::demangleUnqualifiedSymbolName(std::string_view &MangledName,
1562 NameBackrefBehavior NBB) {
1563 if (startsWithDigit(MangledName))
1564 return demangleBackRefName(MangledName);
1565 if (llvm::itanium_demangle::starts_with(MangledName, "?$"))
1566 return demangleTemplateInstantiationName(MangledName, NBB);
1567 if (llvm::itanium_demangle::starts_with(MangledName, '?'))
1568 return demangleFunctionIdentifierCode(MangledName);
1569 return demangleSimpleName(MangledName, /*Memorize=*/(NBB & NBB_Simple) != 0);
1570 }
1571
1572 IdentifierNode *
1573 Demangler::demangleNameScopePiece(std::string_view &MangledName) {
1574 if (startsWithDigit(MangledName))
1575 return demangleBackRefName(MangledName);
1576
1577 if (llvm::itanium_demangle::starts_with(MangledName, "?$"))
1578 return demangleTemplateInstantiationName(MangledName, NBB_Template);
1579
1580 if (llvm::itanium_demangle::starts_with(MangledName, "?A"))
1581 return demangleAnonymousNamespaceName(MangledName);
1582
1583 if (startsWithLocalScopePattern(MangledName))
1584 return demangleLocallyScopedNamePiece(MangledName);
1585
1586 return demangleSimpleName(MangledName, /*Memorize=*/true);
1587 }
1588
1589 static NodeArrayNode *nodeListToNodeArray(ArenaAllocator &Arena, NodeList *Head,
1590 size_t Count) {
1591 NodeArrayNode *N = Arena.alloc<NodeArrayNode>();
1592 N->Count = Count;
1593 N->Nodes = Arena.allocArray<Node *>(Count);
1594 for (size_t I = 0; I < Count; ++I) {
1595 N->Nodes[I] = Head->N;
1596 Head = Head->Next;
1597 }
1598 return N;
1599 }
1600
1601 QualifiedNameNode *
1602 Demangler::demangleNameScopeChain(std::string_view &MangledName,
1603 IdentifierNode *UnqualifiedName) {
1604 NodeList *Head = Arena.alloc<NodeList>();
1605
1606 Head->N = UnqualifiedName;
1607
1608 size_t Count = 1;
1609 while (!consumeFront(MangledName, "@")) {
1610 ++Count;
1611 NodeList *NewHead = Arena.alloc<NodeList>();
1612 NewHead->Next = Head;
1613 Head = NewHead;
1614
1615 if (MangledName.empty()) {
1616 Error = true;
1617 return nullptr;
1618 }
1619
1620 assert(!Error);
1621 IdentifierNode *Elem = demangleNameScopePiece(MangledName);
1622 if (Error)
1623 return nullptr;
1624
1625 Head->N = Elem;
1626 }
1627
1628 QualifiedNameNode *QN = Arena.alloc<QualifiedNameNode>();
1629 QN->Components = nodeListToNodeArray(Arena, Head, Count);
1630 return QN;
1631 }
1632
1633 FuncClass Demangler::demangleFunctionClass(std::string_view &MangledName) {
1634 const char F = MangledName.front();
1635 MangledName.remove_prefix(1);
1636 switch (F) {
1637 case '9':
1638 return FuncClass(FC_ExternC | FC_NoParameterList);
1639 case 'A':
1640 return FC_Private;
1641 case 'B':
1642 return FuncClass(FC_Private | FC_Far);
1643 case 'C':
1644 return FuncClass(FC_Private | FC_Static);
1645 case 'D':
1646 return FuncClass(FC_Private | FC_Static | FC_Far);
1647 case 'E':
1648 return FuncClass(FC_Private | FC_Virtual);
1649 case 'F':
1650 return FuncClass(FC_Private | FC_Virtual | FC_Far);
1651 case 'G':
1652 return FuncClass(FC_Private | FC_StaticThisAdjust);
1653 case 'H':
1654 return FuncClass(FC_Private | FC_StaticThisAdjust | FC_Far);
1655 case 'I':
1656 return FuncClass(FC_Protected);
1657 case 'J':
1658 return FuncClass(FC_Protected | FC_Far);
1659 case 'K':
1660 return FuncClass(FC_Protected | FC_Static);
1661 case 'L':
1662 return FuncClass(FC_Protected | FC_Static | FC_Far);
1663 case 'M':
1664 return FuncClass(FC_Protected | FC_Virtual);
1665 case 'N':
1666 return FuncClass(FC_Protected | FC_Virtual | FC_Far);
1667 case 'O':
1668 return FuncClass(FC_Protected | FC_Virtual | FC_StaticThisAdjust);
1669 case 'P':
1670 return FuncClass(FC_Protected | FC_Virtual | FC_StaticThisAdjust | FC_Far);
1671 case 'Q':
1672 return FuncClass(FC_Public);
1673 case 'R':
1674 return FuncClass(FC_Public | FC_Far);
1675 case 'S':
1676 return FuncClass(FC_Public | FC_Static);
1677 case 'T':
1678 return FuncClass(FC_Public | FC_Static | FC_Far);
1679 case 'U':
1680 return FuncClass(FC_Public | FC_Virtual);
1681 case 'V':
1682 return FuncClass(FC_Public | FC_Virtual | FC_Far);
1683 case 'W':
1684 return FuncClass(FC_Public | FC_Virtual | FC_StaticThisAdjust);
1685 case 'X':
1686 return FuncClass(FC_Public | FC_Virtual | FC_StaticThisAdjust | FC_Far);
1687 case 'Y':
1688 return FuncClass(FC_Global);
1689 case 'Z':
1690 return FuncClass(FC_Global | FC_Far);
1691 case '$': {
1692 FuncClass VFlag = FC_VirtualThisAdjust;
1693 if (consumeFront(MangledName, 'R'))
1694 VFlag = FuncClass(VFlag | FC_VirtualThisAdjustEx);
1695 if (MangledName.empty())
1696 break;
1697 const char F = MangledName.front();
1698 MangledName.remove_prefix(1);
1699 switch (F) {
1700 case '0':
1701 return FuncClass(FC_Private | FC_Virtual | VFlag);
1702 case '1':
1703 return FuncClass(FC_Private | FC_Virtual | VFlag | FC_Far);
1704 case '2':
1705 return FuncClass(FC_Protected | FC_Virtual | VFlag);
1706 case '3':
1707 return FuncClass(FC_Protected | FC_Virtual | VFlag | FC_Far);
1708 case '4':
1709 return FuncClass(FC_Public | FC_Virtual | VFlag);
1710 case '5':
1711 return FuncClass(FC_Public | FC_Virtual | VFlag | FC_Far);
1712 }
1713 }
1714 }
1715
1716 Error = true;
1717 return FC_Public;
1718 }
1719
1720 CallingConv
1721 Demangler::demangleCallingConvention(std::string_view &MangledName) {
1722 if (MangledName.empty()) {
1723 Error = true;
1724 return CallingConv::None;
1725 }
1726
1727 const char F = MangledName.front();
1728 MangledName.remove_prefix(1);
1729 switch (F) {
1730 case 'A':
1731 case 'B':
1732 return CallingConv::Cdecl;
1733 case 'C':
1734 case 'D':
1735 return CallingConv::Pascal;
1736 case 'E':
1737 case 'F':
1738 return CallingConv::Thiscall;
1739 case 'G':
1740 case 'H':
1741 return CallingConv::Stdcall;
1742 case 'I':
1743 case 'J':
1744 return CallingConv::Fastcall;
1745 case 'M':
1746 case 'N':
1747 return CallingConv::Clrcall;
1748 case 'O':
1749 case 'P':
1750 return CallingConv::Eabi;
1751 case 'Q':
1752 return CallingConv::Vectorcall;
1753 case 'S':
1754 return CallingConv::Swift;
1755 case 'W':
1756 return CallingConv::SwiftAsync;
1757 }
1758
1759 return CallingConv::None;
1760 }
1761
1762 StorageClass
1763 Demangler::demangleVariableStorageClass(std::string_view &MangledName) {
1764 assert(MangledName.front() >= '0' && MangledName.front() <= '4');
1765
1766 const char F = MangledName.front();
1767 MangledName.remove_prefix(1);
1768 switch (F) {
1769 case '0':
1770 return StorageClass::PrivateStatic;
1771 case '1':
1772 return StorageClass::ProtectedStatic;
1773 case '2':
1774 return StorageClass::PublicStatic;
1775 case '3':
1776 return StorageClass::Global;
1777 case '4':
1778 return StorageClass::FunctionLocalStatic;
1779 }
1780 DEMANGLE_UNREACHABLE;
1781 }
1782
1783 std::pair<Qualifiers, bool>
1784 Demangler::demangleQualifiers(std::string_view &MangledName) {
1785 if (MangledName.empty()) {
1786 Error = true;
1787 return std::make_pair(Q_None, false);
1788 }
1789
1790 const char F = MangledName.front();
1791 MangledName.remove_prefix(1);
1792 switch (F) {
1793 // Member qualifiers
1794 case 'Q':
1795 return std::make_pair(Q_None, true);
1796 case 'R':
1797 return std::make_pair(Q_Const, true);
1798 case 'S':
1799 return std::make_pair(Q_Volatile, true);
1800 case 'T':
1801 return std::make_pair(Qualifiers(Q_Const | Q_Volatile), true);
1802 // Non-Member qualifiers
1803 case 'A':
1804 return std::make_pair(Q_None, false);
1805 case 'B':
1806 return std::make_pair(Q_Const, false);
1807 case 'C':
1808 return std::make_pair(Q_Volatile, false);
1809 case 'D':
1810 return std::make_pair(Qualifiers(Q_Const | Q_Volatile), false);
1811 }
1812 Error = true;
1813 return std::make_pair(Q_None, false);
1814 }
1815
1816 // <variable-type> ::= <type> <cvr-qualifiers>
1817 // ::= <type> <pointee-cvr-qualifiers> # pointers, references
1818 TypeNode *Demangler::demangleType(std::string_view &MangledName,
1819 QualifierMangleMode QMM) {
1820 Qualifiers Quals = Q_None;
1821 bool IsMember = false;
1822 if (QMM == QualifierMangleMode::Mangle) {
1823 std::tie(Quals, IsMember) = demangleQualifiers(MangledName);
1824 } else if (QMM == QualifierMangleMode::Result) {
1825 if (consumeFront(MangledName, '?'))
1826 std::tie(Quals, IsMember) = demangleQualifiers(MangledName);
1827 }
1828
1829 if (MangledName.empty()) {
1830 Error = true;
1831 return nullptr;
1832 }
1833
1834 TypeNode *Ty = nullptr;
1835 if (isTagType(MangledName))
1836 Ty = demangleClassType(MangledName);
1837 else if (isPointerType(MangledName)) {
1838 if (isMemberPointer(MangledName, Error))
1839 Ty = demangleMemberPointerType(MangledName);
1840 else if (!Error)
1841 Ty = demanglePointerType(MangledName);
1842 else
1843 return nullptr;
1844 } else if (isArrayType(MangledName))
1845 Ty = demangleArrayType(MangledName);
1846 else if (isFunctionType(MangledName)) {
1847 if (consumeFront(MangledName, "$$A8@@"))
1848 Ty = demangleFunctionType(MangledName, true);
1849 else {
1850 assert(llvm::itanium_demangle::starts_with(MangledName, "$$A6"));
1851 consumeFront(MangledName, "$$A6");
1852 Ty = demangleFunctionType(MangledName, false);
1853 }
1854 } else if (isCustomType(MangledName)) {
1855 Ty = demangleCustomType(MangledName);
1856 } else {
1857 Ty = demanglePrimitiveType(MangledName);
1858 }
1859
1860 if (!Ty || Error)
1861 return Ty;
1862 Ty->Quals = Qualifiers(Ty->Quals | Quals);
1863 return Ty;
1864 }
1865
1866 bool Demangler::demangleThrowSpecification(std::string_view &MangledName) {
1867 if (consumeFront(MangledName, "_E"))
1868 return true;
1869 if (consumeFront(MangledName, 'Z'))
1870 return false;
1871
1872 Error = true;
1873 return false;
1874 }
1875
1876 FunctionSignatureNode *
1877 Demangler::demangleFunctionType(std::string_view &MangledName,
1878 bool HasThisQuals) {
1879 FunctionSignatureNode *FTy = Arena.alloc<FunctionSignatureNode>();
1880
1881 if (HasThisQuals) {
1882 FTy->Quals = demanglePointerExtQualifiers(MangledName);
1883 FTy->RefQualifier = demangleFunctionRefQualifier(MangledName);
1884 FTy->Quals = Qualifiers(FTy->Quals | demangleQualifiers(MangledName).first);
1885 }
1886
1887 // Fields that appear on both member and non-member functions.
1888 FTy->CallConvention = demangleCallingConvention(MangledName);
1889
1890 // <return-type> ::= <type>
1891 // ::= @ # structors (they have no declared return type)
1892 bool IsStructor = consumeFront(MangledName, '@');
1893 if (!IsStructor)
1894 FTy->ReturnType = demangleType(MangledName, QualifierMangleMode::Result);
1895
1896 FTy->Params = demangleFunctionParameterList(MangledName, FTy->IsVariadic);
1897
1898 FTy->IsNoexcept = demangleThrowSpecification(MangledName);
1899
1900 return FTy;
1901 }
1902
1903 FunctionSymbolNode *
1904 Demangler::demangleFunctionEncoding(std::string_view &MangledName) {
1905 FuncClass ExtraFlags = FC_None;
1906 if (consumeFront(MangledName, "$$J0"))
1907 ExtraFlags = FC_ExternC;
1908
1909 if (MangledName.empty()) {
1910 Error = true;
1911 return nullptr;
1912 }
1913
1914 FuncClass FC = demangleFunctionClass(MangledName);
1915 FC = FuncClass(ExtraFlags | FC);
1916
1917 FunctionSignatureNode *FSN = nullptr;
1918 ThunkSignatureNode *TTN = nullptr;
1919 if (FC & FC_StaticThisAdjust) {
1920 TTN = Arena.alloc<ThunkSignatureNode>();
1921 TTN->ThisAdjust.StaticOffset = demangleSigned(MangledName);
1922 } else if (FC & FC_VirtualThisAdjust) {
1923 TTN = Arena.alloc<ThunkSignatureNode>();
1924 if (FC & FC_VirtualThisAdjustEx) {
1925 TTN->ThisAdjust.VBPtrOffset = demangleSigned(MangledName);
1926 TTN->ThisAdjust.VBOffsetOffset = demangleSigned(MangledName);
1927 }
1928 TTN->ThisAdjust.VtordispOffset = demangleSigned(MangledName);
1929 TTN->ThisAdjust.StaticOffset = demangleSigned(MangledName);
1930 }
1931
1932 if (FC & FC_NoParameterList) {
1933 // This is an extern "C" function whose full signature hasn't been mangled.
1934 // This happens when we need to mangle a local symbol inside of an extern
1935 // "C" function.
1936 FSN = Arena.alloc<FunctionSignatureNode>();
1937 } else {
1938 bool HasThisQuals = !(FC & (FC_Global | FC_Static));
1939 FSN = demangleFunctionType(MangledName, HasThisQuals);
1940 }
1941
1942 if (Error)
1943 return nullptr;
1944
1945 if (TTN) {
1946 *static_cast<FunctionSignatureNode *>(TTN) = *FSN;
1947 FSN = TTN;
1948 }
1949 FSN->FunctionClass = FC;
1950
1951 FunctionSymbolNode *Symbol = Arena.alloc<FunctionSymbolNode>();
1952 Symbol->Signature = FSN;
1953 return Symbol;
1954 }
1955
1956 CustomTypeNode *Demangler::demangleCustomType(std::string_view &MangledName) {
1957 assert(llvm::itanium_demangle::starts_with(MangledName, '?'));
1958 MangledName.remove_prefix(1);
1959
1960 CustomTypeNode *CTN = Arena.alloc<CustomTypeNode>();
1961 CTN->Identifier = demangleUnqualifiedTypeName(MangledName, /*Memorize=*/true);
1962 if (!consumeFront(MangledName, '@'))
1963 Error = true;
1964 if (Error)
1965 return nullptr;
1966 return CTN;
1967 }
1968
1969 // Reads a primitive type.
1970 PrimitiveTypeNode *
1971 Demangler::demanglePrimitiveType(std::string_view &MangledName) {
1972 if (consumeFront(MangledName, "$$T"))
1973 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Nullptr);
1974
1975 const char F = MangledName.front();
1976 MangledName.remove_prefix(1);
1977 switch (F) {
1978 case 'X':
1979 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Void);
1980 case 'D':
1981 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char);
1982 case 'C':
1983 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Schar);
1984 case 'E':
1985 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Uchar);
1986 case 'F':
1987 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Short);
1988 case 'G':
1989 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Ushort);
1990 case 'H':
1991 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Int);
1992 case 'I':
1993 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Uint);
1994 case 'J':
1995 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Long);
1996 case 'K':
1997 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Ulong);
1998 case 'M':
1999 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Float);
2000 case 'N':
2001 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Double);
2002 case 'O':
2003 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Ldouble);
2004 case '_': {
2005 if (MangledName.empty()) {
2006 Error = true;
2007 return nullptr;
2008 }
2009 const char F = MangledName.front();
2010 MangledName.remove_prefix(1);
2011 switch (F) {
2012 case 'N':
2013 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Bool);
2014 case 'J':
2015 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Int64);
2016 case 'K':
2017 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Uint64);
2018 case 'W':
2019 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Wchar);
2020 case 'Q':
2021 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char8);
2022 case 'S':
2023 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char16);
2024 case 'U':
2025 return Arena.alloc<PrimitiveTypeNode>(PrimitiveKind::Char32);
2026 }
2027 break;
2028 }
2029 }
2030 Error = true;
2031 return nullptr;
2032 }
2033
2034 TagTypeNode *Demangler::demangleClassType(std::string_view &MangledName) {
2035 TagTypeNode *TT = nullptr;
2036
2037 const char F = MangledName.front();
2038 MangledName.remove_prefix(1);
2039 switch (F) {
2040 case 'T':
2041 TT = Arena.alloc<TagTypeNode>(TagKind::Union);
2042 break;
2043 case 'U':
2044 TT = Arena.alloc<TagTypeNode>(TagKind::Struct);
2045 break;
2046 case 'V':
2047 TT = Arena.alloc<TagTypeNode>(TagKind::Class);
2048 break;
2049 case 'W':
2050 if (!consumeFront(MangledName, '4')) {
2051 Error = true;
2052 return nullptr;
2053 }
2054 TT = Arena.alloc<TagTypeNode>(TagKind::Enum);
2055 break;
2056 default:
2057 assert(false);
2058 }
2059
2060 TT->QualifiedName = demangleFullyQualifiedTypeName(MangledName);
2061 return TT;
2062 }
2063
2064 // <pointer-type> ::= E? <pointer-cvr-qualifiers> <ext-qualifiers> <type>
2065 // # the E is required for 64-bit non-static pointers
2066 PointerTypeNode *Demangler::demanglePointerType(std::string_view &MangledName) {
2067 PointerTypeNode *Pointer = Arena.alloc<PointerTypeNode>();
2068
2069 std::tie(Pointer->Quals, Pointer->Affinity) =
2070 demanglePointerCVQualifiers(MangledName);
2071
2072 if (consumeFront(MangledName, "6")) {
2073 Pointer->Pointee = demangleFunctionType(MangledName, false);
2074 return Pointer;
2075 }
2076
2077 Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName);
2078 Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals);
2079
2080 Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Mangle);
2081 return Pointer;
2082 }
2083
2084 PointerTypeNode *
2085 Demangler::demangleMemberPointerType(std::string_view &MangledName) {
2086 PointerTypeNode *Pointer = Arena.alloc<PointerTypeNode>();
2087
2088 std::tie(Pointer->Quals, Pointer->Affinity) =
2089 demanglePointerCVQualifiers(MangledName);
2090 assert(Pointer->Affinity == PointerAffinity::Pointer);
2091
2092 Qualifiers ExtQuals = demanglePointerExtQualifiers(MangledName);
2093 Pointer->Quals = Qualifiers(Pointer->Quals | ExtQuals);
2094
2095 // isMemberPointer() only returns true if there is at least one character
2096 // after the qualifiers.
2097 if (consumeFront(MangledName, "8")) {
2098 Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName);
2099 Pointer->Pointee = demangleFunctionType(MangledName, true);
2100 } else {
2101 Qualifiers PointeeQuals = Q_None;
2102 bool IsMember = false;
2103 std::tie(PointeeQuals, IsMember) = demangleQualifiers(MangledName);
2104 assert(IsMember || Error);
2105 Pointer->ClassParent = demangleFullyQualifiedTypeName(MangledName);
2106
2107 Pointer->Pointee = demangleType(MangledName, QualifierMangleMode::Drop);
2108 if (Pointer->Pointee)
2109 Pointer->Pointee->Quals = PointeeQuals;
2110 }
2111
2112 return Pointer;
2113 }
2114
2115 Qualifiers
2116 Demangler::demanglePointerExtQualifiers(std::string_view &MangledName) {
2117 Qualifiers Quals = Q_None;
2118 if (consumeFront(MangledName, 'E'))
2119 Quals = Qualifiers(Quals | Q_Pointer64);
2120 if (consumeFront(MangledName, 'I'))
2121 Quals = Qualifiers(Quals | Q_Restrict);
2122 if (consumeFront(MangledName, 'F'))
2123 Quals = Qualifiers(Quals | Q_Unaligned);
2124
2125 return Quals;
2126 }
2127
2128 ArrayTypeNode *Demangler::demangleArrayType(std::string_view &MangledName) {
2129 assert(MangledName.front() == 'Y');
2130 MangledName.remove_prefix(1);
2131
2132 uint64_t Rank = 0;
2133 bool IsNegative = false;
2134 std::tie(Rank, IsNegative) = demangleNumber(MangledName);
2135 if (IsNegative || Rank == 0) {
2136 Error = true;
2137 return nullptr;
2138 }
2139
2140 ArrayTypeNode *ATy = Arena.alloc<ArrayTypeNode>();
2141 NodeList *Head = Arena.alloc<NodeList>();
2142 NodeList *Tail = Head;
2143
2144 for (uint64_t I = 0; I < Rank; ++I) {
2145 uint64_t D = 0;
2146 std::tie(D, IsNegative) = demangleNumber(MangledName);
2147 if (Error || IsNegative) {
2148 Error = true;
2149 return nullptr;
2150 }
2151 Tail->N = Arena.alloc<IntegerLiteralNode>(D, IsNegative);
2152 if (I + 1 < Rank) {
2153 Tail->Next = Arena.alloc<NodeList>();
2154 Tail = Tail->Next;
2155 }
2156 }
2157 ATy->Dimensions = nodeListToNodeArray(Arena, Head, Rank);
2158
2159 if (consumeFront(MangledName, "$$C")) {
2160 bool IsMember = false;
2161 std::tie(ATy->Quals, IsMember) = demangleQualifiers(MangledName);
2162 if (IsMember) {
2163 Error = true;
2164 return nullptr;
2165 }
2166 }
2167
2168 ATy->ElementType = demangleType(MangledName, QualifierMangleMode::Drop);
2169 return ATy;
2170 }
2171
2172 // Reads a function's parameters.
2173 NodeArrayNode *
2174 Demangler::demangleFunctionParameterList(std::string_view &MangledName,
2175 bool &IsVariadic) {
2176 // Empty parameter list.
2177 if (consumeFront(MangledName, 'X'))
2178 return nullptr;
2179
2180 NodeList *Head = Arena.alloc<NodeList>();
2181 NodeList **Current = &Head;
2182 size_t Count = 0;
2183 while (!Error && !llvm::itanium_demangle::starts_with(MangledName, '@') &&
2184 !llvm::itanium_demangle::starts_with(MangledName, 'Z')) {
2185 ++Count;
2186
2187 if (startsWithDigit(MangledName)) {
2188 size_t N = MangledName[0] - '0';
2189 if (N >= Backrefs.FunctionParamCount) {
2190 Error = true;
2191 return nullptr;
2192 }
2193 MangledName.remove_prefix(1);
2194
2195 *Current = Arena.alloc<NodeList>();
2196 (*Current)->N = Backrefs.FunctionParams[N];
2197 Current = &(*Current)->Next;
2198 continue;
2199 }
2200
2201 size_t OldSize = MangledName.size();
2202
2203 *Current = Arena.alloc<NodeList>();
2204 TypeNode *TN = demangleType(MangledName, QualifierMangleMode::Drop);
2205 if (!TN || Error)
2206 return nullptr;
2207
2208 (*Current)->N = TN;
2209
2210 size_t CharsConsumed = OldSize - MangledName.size();
2211 assert(CharsConsumed != 0);
2212
2213 // Single-letter types are ignored for backreferences because memorizing
2214 // them doesn't save anything.
2215 if (Backrefs.FunctionParamCount <= 9 && CharsConsumed > 1)
2216 Backrefs.FunctionParams[Backrefs.FunctionParamCount++] = TN;
2217
2218 Current = &(*Current)->Next;
2219 }
2220
2221 if (Error)
2222 return nullptr;
2223
2224 NodeArrayNode *NA = nodeListToNodeArray(Arena, Head, Count);
2225 // A non-empty parameter list is terminated by either 'Z' (variadic) parameter
2226 // list or '@' (non variadic). Careful not to consume "@Z", as in that case
2227 // the following Z could be a throw specifier.
2228 if (consumeFront(MangledName, '@'))
2229 return NA;
2230
2231 if (consumeFront(MangledName, 'Z')) {
2232 IsVariadic = true;
2233 return NA;
2234 }
2235
2236 DEMANGLE_UNREACHABLE;
2237 }
2238
2239 NodeArrayNode *
2240 Demangler::demangleTemplateParameterList(std::string_view &MangledName) {
2241 NodeList *Head = nullptr;
2242 NodeList **Current = &Head;
2243 size_t Count = 0;
2244
2245 while (!llvm::itanium_demangle::starts_with(MangledName, '@')) {
2246 if (consumeFront(MangledName, "$S") || consumeFront(MangledName, "$$V") ||
2247 consumeFront(MangledName, "$$$V") || consumeFront(MangledName, "$$Z")) {
2248 // parameter pack separator
2249 continue;
2250 }
2251
2252 ++Count;
2253
2254 // Template parameter lists don't participate in back-referencing.
2255 *Current = Arena.alloc<NodeList>();
2256
2257 NodeList &TP = **Current;
2258
2259 TemplateParameterReferenceNode *TPRN = nullptr;
2260 if (consumeFront(MangledName, "$$Y")) {
2261 // Template alias
2262 TP.N = demangleFullyQualifiedTypeName(MangledName);
2263 } else if (consumeFront(MangledName, "$$B")) {
2264 // Array
2265 TP.N = demangleType(MangledName, QualifierMangleMode::Drop);
2266 } else if (consumeFront(MangledName, "$$C")) {
2267 // Type has qualifiers.
2268 TP.N = demangleType(MangledName, QualifierMangleMode::Mangle);
2269 } else if (llvm::itanium_demangle::starts_with(MangledName, "$1") ||
2270 llvm::itanium_demangle::starts_with(MangledName, "$H") ||
2271 llvm::itanium_demangle::starts_with(MangledName, "$I") ||
2272 llvm::itanium_demangle::starts_with(MangledName, "$J")) {
2273 // Pointer to member
2274 TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>();
2275 TPRN->IsMemberPointer = true;
2276
2277 MangledName.remove_prefix(1);
2278 // 1 - single inheritance <name>
2279 // H - multiple inheritance <name> <number>
2280 // I - virtual inheritance <name> <number> <number>
2281 // J - unspecified inheritance <name> <number> <number> <number>
2282 char InheritanceSpecifier = MangledName.front();
2283 MangledName.remove_prefix(1);
2284 SymbolNode *S = nullptr;
2285 if (llvm::itanium_demangle::starts_with(MangledName, '?')) {
2286 S = parse(MangledName);
2287 if (Error || !S->Name) {
2288 Error = true;
2289 return nullptr;
2290 }
2291 memorizeIdentifier(S->Name->getUnqualifiedIdentifier());
2292 }
2293
2294 switch (InheritanceSpecifier) {
2295 case 'J':
2296 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] =
2297 demangleSigned(MangledName);
2298 DEMANGLE_FALLTHROUGH;
2299 case 'I':
2300 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] =
2301 demangleSigned(MangledName);
2302 DEMANGLE_FALLTHROUGH;
2303 case 'H':
2304 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] =
2305 demangleSigned(MangledName);
2306 DEMANGLE_FALLTHROUGH;
2307 case '1':
2308 break;
2309 default:
2310 DEMANGLE_UNREACHABLE;
2311 }
2312 TPRN->Affinity = PointerAffinity::Pointer;
2313 TPRN->Symbol = S;
2314 } else if (llvm::itanium_demangle::starts_with(MangledName, "$E?")) {
2315 consumeFront(MangledName, "$E");
2316 // Reference to symbol
2317 TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>();
2318 TPRN->Symbol = parse(MangledName);
2319 TPRN->Affinity = PointerAffinity::Reference;
2320 } else if (llvm::itanium_demangle::starts_with(MangledName, "$F") ||
2321 llvm::itanium_demangle::starts_with(MangledName, "$G")) {
2322 TP.N = TPRN = Arena.alloc<TemplateParameterReferenceNode>();
2323
2324 // Data member pointer.
2325 MangledName.remove_prefix(1);
2326 char InheritanceSpecifier = MangledName.front();
2327 MangledName.remove_prefix(1);
2328
2329 switch (InheritanceSpecifier) {
2330 case 'G':
2331 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] =
2332 demangleSigned(MangledName);
2333 DEMANGLE_FALLTHROUGH;
2334 case 'F':
2335 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] =
2336 demangleSigned(MangledName);
2337 TPRN->ThunkOffsets[TPRN->ThunkOffsetCount++] =
2338 demangleSigned(MangledName);
2339 break;
2340 default:
2341 DEMANGLE_UNREACHABLE;
2342 }
2343 TPRN->IsMemberPointer = true;
2344
2345 } else if (consumeFront(MangledName, "$0")) {
2346 // Integral non-type template parameter
2347 bool IsNegative = false;
2348 uint64_t Value = 0;
2349 std::tie(Value, IsNegative) = demangleNumber(MangledName);
2350
2351 TP.N = Arena.alloc<IntegerLiteralNode>(Value, IsNegative);
2352 } else {
2353 TP.N = demangleType(MangledName, QualifierMangleMode::Drop);
2354 }
2355 if (Error)
2356 return nullptr;
2357
2358 Current = &TP.Next;
2359 }
2360
2361 // The loop above returns nullptr on Error.
2362 assert(!Error);
2363
2364 // Template parameter lists cannot be variadic, so it can only be terminated
2365 // by @ (as opposed to 'Z' in the function parameter case).
2366 assert(llvm::itanium_demangle::starts_with(
2367 MangledName, '@')); // The above loop exits only on '@'.
2368 consumeFront(MangledName, '@');
2369 return nodeListToNodeArray(Arena, Head, Count);
2370 }
2371
2372 void Demangler::dumpBackReferences() {
2373 std::printf("%d function parameter backreferences\n",
2374 (int)Backrefs.FunctionParamCount);
2375
2376 // Create an output stream so we can render each type.
2377 OutputBuffer OB;
2378 for (size_t I = 0; I < Backrefs.FunctionParamCount; ++I) {
2379 OB.setCurrentPosition(0);
2380
2381 TypeNode *T = Backrefs.FunctionParams[I];
2382 T->output(OB, OF_Default);
2383
2384 std::string_view B = OB;
2385 std::printf(" [%d] - %.*s\n", (int)I, (int)B.size(), B.data());
2386 }
2387 std::free(OB.getBuffer());
2388
2389 if (Backrefs.FunctionParamCount > 0)
2390 std::printf("\n");
2391 std::printf("%d name backreferences\n", (int)Backrefs.NamesCount);
2392 for (size_t I = 0; I < Backrefs.NamesCount; ++I) {
2393 std::printf(" [%d] - %.*s\n", (int)I, (int)Backrefs.Names[I]->Name.size(),
2394 Backrefs.Names[I]->Name.data());
2395 }
2396 if (Backrefs.NamesCount > 0)
2397 std::printf("\n");
2398 }
2399
2400 char *llvm::microsoftDemangle(std::string_view MangledName, size_t *NMangled,
2401 int *Status, MSDemangleFlags Flags) {
2402 Demangler D;
2403
2404 std::string_view Name{MangledName};
2405 SymbolNode *AST = D.parse(Name);
2406 if (!D.Error && NMangled)
2407 *NMangled = MangledName.size() - Name.size();
2408
2409 if (Flags & MSDF_DumpBackrefs)
2410 D.dumpBackReferences();
2411
2412 OutputFlags OF = OF_Default;
2413 if (Flags & MSDF_NoCallingConvention)
2414 OF = OutputFlags(OF | OF_NoCallingConvention);
2415 if (Flags & MSDF_NoAccessSpecifier)
2416 OF = OutputFlags(OF | OF_NoAccessSpecifier);
2417 if (Flags & MSDF_NoReturnType)
2418 OF = OutputFlags(OF | OF_NoReturnType);
2419 if (Flags & MSDF_NoMemberType)
2420 OF = OutputFlags(OF | OF_NoMemberType);
2421 if (Flags & MSDF_NoVariableType)
2422 OF = OutputFlags(OF | OF_NoVariableType);
2423
2424 int InternalStatus = demangle_success;
2425 char *Buf;
2426 if (D.Error)
2427 InternalStatus = demangle_invalid_mangled_name;
2428 else {
2429 OutputBuffer OB;
2430 AST->output(OB, OF);
2431 OB += '\0';
2432 Buf = OB.getBuffer();
2433 }
2434
2435 if (Status)
2436 *Status = InternalStatus;
2437 return InternalStatus == demangle_success ? Buf : nullptr;
2438 }
LLVM monorepo