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 //===----------------------------------------------------------------------===//
12
13 #include "llvm/Demangle/MicrosoftDemangleNodes.h"
14 #include "llvm/Demangle/DemangleConfig.h"
15 #include "llvm/Demangle/Utility.h"
16 #include <cctype>
17 #include <string>
18
19 using namespace llvm;
20 using namespace ms_demangle;
21
22 #define OUTPUT_ENUM_CLASS_VALUE(Enum, Value, Desc) \
23 case Enum::Value: \
24 OS << Desc; \
25 break;
26
27 // Writes a space if the last token does not end with a punctuation.
outputSpaceIfNecessary(OutputStream & OS)28 static void outputSpaceIfNecessary(OutputStream &OS) {
29 if (OS.empty())
30 return;
31
32 char C = OS.back();
33 if (std::isalnum(C) || C == '>')
34 OS << " ";
35 }
36
outputSingleQualifier(OutputStream & OS,Qualifiers Q)37 static void outputSingleQualifier(OutputStream &OS, Qualifiers Q) {
38 switch (Q) {
39 case Q_Const:
40 OS << "const";
41 break;
42 case Q_Volatile:
43 OS << "volatile";
44 break;
45 case Q_Restrict:
46 OS << "__restrict";
47 break;
48 default:
49 break;
50 }
51 }
52
outputQualifierIfPresent(OutputStream & OS,Qualifiers Q,Qualifiers Mask,bool NeedSpace)53 static bool outputQualifierIfPresent(OutputStream &OS, Qualifiers Q,
54 Qualifiers Mask, bool NeedSpace) {
55 if (!(Q & Mask))
56 return NeedSpace;
57
58 if (NeedSpace)
59 OS << " ";
60
61 outputSingleQualifier(OS, Mask);
62 return true;
63 }
64
outputQualifiers(OutputStream & OS,Qualifiers Q,bool SpaceBefore,bool SpaceAfter)65 static void outputQualifiers(OutputStream &OS, Qualifiers Q, bool SpaceBefore,
66 bool SpaceAfter) {
67 if (Q == Q_None)
68 return;
69
70 size_t Pos1 = OS.getCurrentPosition();
71 SpaceBefore = outputQualifierIfPresent(OS, Q, Q_Const, SpaceBefore);
72 SpaceBefore = outputQualifierIfPresent(OS, Q, Q_Volatile, SpaceBefore);
73 SpaceBefore = outputQualifierIfPresent(OS, Q, Q_Restrict, SpaceBefore);
74 size_t Pos2 = OS.getCurrentPosition();
75 if (SpaceAfter && Pos2 > Pos1)
76 OS << " ";
77 }
78
outputCallingConvention(OutputStream & OS,CallingConv CC)79 static void outputCallingConvention(OutputStream &OS, CallingConv CC) {
80 outputSpaceIfNecessary(OS);
81
82 switch (CC) {
83 case CallingConv::Cdecl:
84 OS << "__cdecl";
85 break;
86 case CallingConv::Fastcall:
87 OS << "__fastcall";
88 break;
89 case CallingConv::Pascal:
90 OS << "__pascal";
91 break;
92 case CallingConv::Regcall:
93 OS << "__regcall";
94 break;
95 case CallingConv::Stdcall:
96 OS << "__stdcall";
97 break;
98 case CallingConv::Thiscall:
99 OS << "__thiscall";
100 break;
101 case CallingConv::Eabi:
102 OS << "__eabi";
103 break;
104 case CallingConv::Vectorcall:
105 OS << "__vectorcall";
106 break;
107 case CallingConv::Clrcall:
108 OS << "__clrcall";
109 break;
110 default:
111 break;
112 }
113 }
114
toString(OutputFlags Flags) const115 std::string Node::toString(OutputFlags Flags) const {
116 OutputStream OS;
117 initializeOutputStream(nullptr, nullptr, OS, 1024);
118 this->output(OS, Flags);
119 OS << '\0';
120 return {OS.getBuffer()};
121 }
122
outputPre(OutputStream & OS,OutputFlags Flags) const123 void PrimitiveTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
124 switch (PrimKind) {
125 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Void, "void");
126 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Bool, "bool");
127 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char, "char");
128 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Schar, "signed char");
129 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uchar, "unsigned char");
130 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char8, "char8_t");
131 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char16, "char16_t");
132 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char32, "char32_t");
133 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Short, "short");
134 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ushort, "unsigned short");
135 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Int, "int");
136 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uint, "unsigned int");
137 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Long, "long");
138 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ulong, "unsigned long");
139 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Int64, "__int64");
140 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uint64, "unsigned __int64");
141 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Wchar, "wchar_t");
142 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Float, "float");
143 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Double, "double");
144 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ldouble, "long double");
145 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Nullptr, "std::nullptr_t");
146 }
147 outputQualifiers(OS, Quals, true, false);
148 }
149
output(OutputStream & OS,OutputFlags Flags) const150 void NodeArrayNode::output(OutputStream &OS, OutputFlags Flags) const {
151 output(OS, Flags, ", ");
152 }
153
output(OutputStream & OS,OutputFlags Flags,StringView Separator) const154 void NodeArrayNode::output(OutputStream &OS, OutputFlags Flags,
155 StringView Separator) const {
156 if (Count == 0)
157 return;
158 if (Nodes[0])
159 Nodes[0]->output(OS, Flags);
160 for (size_t I = 1; I < Count; ++I) {
161 OS << Separator;
162 Nodes[I]->output(OS, Flags);
163 }
164 }
165
output(OutputStream & OS,OutputFlags Flags) const166 void EncodedStringLiteralNode::output(OutputStream &OS,
167 OutputFlags Flags) const {
168 switch (Char) {
169 case CharKind::Wchar:
170 OS << "L\"";
171 break;
172 case CharKind::Char:
173 OS << "\"";
174 break;
175 case CharKind::Char16:
176 OS << "u\"";
177 break;
178 case CharKind::Char32:
179 OS << "U\"";
180 break;
181 }
182 OS << DecodedString << "\"";
183 if (IsTruncated)
184 OS << "...";
185 }
186
output(OutputStream & OS,OutputFlags Flags) const187 void IntegerLiteralNode::output(OutputStream &OS, OutputFlags Flags) const {
188 if (IsNegative)
189 OS << '-';
190 OS << Value;
191 }
192
output(OutputStream & OS,OutputFlags Flags) const193 void TemplateParameterReferenceNode::output(OutputStream &OS,
194 OutputFlags Flags) const {
195 if (ThunkOffsetCount > 0)
196 OS << "{";
197 else if (Affinity == PointerAffinity::Pointer)
198 OS << "&";
199
200 if (Symbol) {
201 Symbol->output(OS, Flags);
202 if (ThunkOffsetCount > 0)
203 OS << ", ";
204 }
205
206 if (ThunkOffsetCount > 0)
207 OS << ThunkOffsets[0];
208 for (int I = 1; I < ThunkOffsetCount; ++I) {
209 OS << ", " << ThunkOffsets[I];
210 }
211 if (ThunkOffsetCount > 0)
212 OS << "}";
213 }
214
outputTemplateParameters(OutputStream & OS,OutputFlags Flags) const215 void IdentifierNode::outputTemplateParameters(OutputStream &OS,
216 OutputFlags Flags) const {
217 if (!TemplateParams)
218 return;
219 OS << "<";
220 TemplateParams->output(OS, Flags);
221 OS << ">";
222 }
223
output(OutputStream & OS,OutputFlags Flags) const224 void DynamicStructorIdentifierNode::output(OutputStream &OS,
225 OutputFlags Flags) const {
226 if (IsDestructor)
227 OS << "`dynamic atexit destructor for ";
228 else
229 OS << "`dynamic initializer for ";
230
231 if (Variable) {
232 OS << "`";
233 Variable->output(OS, Flags);
234 OS << "''";
235 } else {
236 OS << "'";
237 Name->output(OS, Flags);
238 OS << "''";
239 }
240 }
241
output(OutputStream & OS,OutputFlags Flags) const242 void NamedIdentifierNode::output(OutputStream &OS, OutputFlags Flags) const {
243 OS << Name;
244 outputTemplateParameters(OS, Flags);
245 }
246
output(OutputStream & OS,OutputFlags Flags) const247 void IntrinsicFunctionIdentifierNode::output(OutputStream &OS,
248 OutputFlags Flags) const {
249 switch (Operator) {
250 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, New, "operator new");
251 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Delete, "operator delete");
252 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Assign, "operator=");
253 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, RightShift, "operator>>");
254 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LeftShift, "operator<<");
255 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalNot, "operator!");
256 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Equals, "operator==");
257 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, NotEquals, "operator!=");
258 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArraySubscript,
259 "operator[]");
260 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Pointer, "operator->");
261 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Increment, "operator++");
262 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Decrement, "operator--");
263 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Minus, "operator-");
264 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Plus, "operator+");
265 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Dereference, "operator*");
266 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseAnd, "operator&");
267 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, MemberPointer,
268 "operator->*");
269 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Divide, "operator/");
270 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Modulus, "operator%");
271 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LessThan, "operator<");
272 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LessThanEqual, "operator<=");
273 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, GreaterThan, "operator>");
274 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, GreaterThanEqual,
275 "operator>=");
276 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Comma, "operator,");
277 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Parens, "operator()");
278 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseNot, "operator~");
279 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseXor, "operator^");
280 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseOr, "operator|");
281 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalAnd, "operator&&");
282 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalOr, "operator||");
283 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, TimesEqual, "operator*=");
284 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, PlusEqual, "operator+=");
285 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, MinusEqual, "operator-=");
286 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, DivEqual, "operator/=");
287 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ModEqual, "operator%=");
288 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, RshEqual, "operator>>=");
289 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LshEqual, "operator<<=");
290 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseAndEqual,
291 "operator&=");
292 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseOrEqual,
293 "operator|=");
294 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseXorEqual,
295 "operator^=");
296 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VbaseDtor, "`vbase dtor'");
297 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecDelDtor,
298 "`vector deleting dtor'");
299 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, DefaultCtorClosure,
300 "`default ctor closure'");
301 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ScalarDelDtor,
302 "`scalar deleting dtor'");
303 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecCtorIter,
304 "`vector ctor iterator'");
305 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecDtorIter,
306 "`vector dtor iterator'");
307 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecVbaseCtorIter,
308 "`vector vbase ctor iterator'");
309 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VdispMap,
310 "`virtual displacement map'");
311 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecCtorIter,
312 "`eh vector ctor iterator'");
313 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecDtorIter,
314 "`eh vector dtor iterator'");
315 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecVbaseCtorIter,
316 "`eh vector vbase ctor iterator'");
317 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, CopyCtorClosure,
318 "`copy ctor closure'");
319 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LocalVftableCtorClosure,
320 "`local vftable ctor closure'");
321 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArrayNew, "operator new[]");
322 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArrayDelete,
323 "operator delete[]");
324 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorCtorIter,
325 "`managed vector ctor iterator'");
326 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorDtorIter,
327 "`managed vector dtor iterator'");
328 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVectorCopyCtorIter,
329 "`EH vector copy ctor iterator'");
330 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVectorVbaseCopyCtorIter,
331 "`EH vector vbase copy ctor iterator'");
332 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VectorCopyCtorIter,
333 "`vector copy ctor iterator'");
334 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VectorVbaseCopyCtorIter,
335 "`vector vbase copy constructor iterator'");
336 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorVbaseCopyCtorIter,
337 "`managed vector vbase copy constructor iterator'");
338 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, CoAwait,
339 "operator co_await");
340 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Spaceship, "operator<=>");
341 case IntrinsicFunctionKind::MaxIntrinsic:
342 case IntrinsicFunctionKind::None:
343 break;
344 }
345 outputTemplateParameters(OS, Flags);
346 }
347
output(OutputStream & OS,OutputFlags Flags) const348 void LocalStaticGuardIdentifierNode::output(OutputStream &OS,
349 OutputFlags Flags) const {
350 if (IsThread)
351 OS << "`local static thread guard'";
352 else
353 OS << "`local static guard'";
354 if (ScopeIndex > 0)
355 OS << "{" << ScopeIndex << "}";
356 }
357
output(OutputStream & OS,OutputFlags Flags) const358 void ConversionOperatorIdentifierNode::output(OutputStream &OS,
359 OutputFlags Flags) const {
360 OS << "operator";
361 outputTemplateParameters(OS, Flags);
362 OS << " ";
363 TargetType->output(OS, Flags);
364 }
365
output(OutputStream & OS,OutputFlags Flags) const366 void StructorIdentifierNode::output(OutputStream &OS, OutputFlags Flags) const {
367 if (IsDestructor)
368 OS << "~";
369 Class->output(OS, Flags);
370 outputTemplateParameters(OS, Flags);
371 }
372
output(OutputStream & OS,OutputFlags Flags) const373 void LiteralOperatorIdentifierNode::output(OutputStream &OS,
374 OutputFlags Flags) const {
375 OS << "operator \"\"" << Name;
376 outputTemplateParameters(OS, Flags);
377 }
378
outputPre(OutputStream & OS,OutputFlags Flags) const379 void FunctionSignatureNode::outputPre(OutputStream &OS,
380 OutputFlags Flags) const {
381 if (!(Flags & OF_NoAccessSpecifier)) {
382 if (FunctionClass & FC_Public)
383 OS << "public: ";
384 if (FunctionClass & FC_Protected)
385 OS << "protected: ";
386 if (FunctionClass & FC_Private)
387 OS << "private: ";
388 }
389
390 if (!(Flags & OF_NoMemberType)) {
391 if (!(FunctionClass & FC_Global)) {
392 if (FunctionClass & FC_Static)
393 OS << "static ";
394 }
395 if (FunctionClass & FC_Virtual)
396 OS << "virtual ";
397
398 if (FunctionClass & FC_ExternC)
399 OS << "extern \"C\" ";
400 }
401
402 if (!(Flags & OF_NoReturnType) && ReturnType) {
403 ReturnType->outputPre(OS, Flags);
404 OS << " ";
405 }
406
407 if (!(Flags & OF_NoCallingConvention))
408 outputCallingConvention(OS, CallConvention);
409 }
410
outputPost(OutputStream & OS,OutputFlags Flags) const411 void FunctionSignatureNode::outputPost(OutputStream &OS,
412 OutputFlags Flags) const {
413 if (!(FunctionClass & FC_NoParameterList)) {
414 OS << "(";
415 if (Params)
416 Params->output(OS, Flags);
417 else
418 OS << "void";
419
420 if (IsVariadic) {
421 if (OS.back() != '(')
422 OS << ", ";
423 OS << "...";
424 }
425 OS << ")";
426 }
427
428 if (Quals & Q_Const)
429 OS << " const";
430 if (Quals & Q_Volatile)
431 OS << " volatile";
432 if (Quals & Q_Restrict)
433 OS << " __restrict";
434 if (Quals & Q_Unaligned)
435 OS << " __unaligned";
436
437 if (IsNoexcept)
438 OS << " noexcept";
439
440 if (RefQualifier == FunctionRefQualifier::Reference)
441 OS << " &";
442 else if (RefQualifier == FunctionRefQualifier::RValueReference)
443 OS << " &&";
444
445 if (!(Flags & OF_NoReturnType) && ReturnType)
446 ReturnType->outputPost(OS, Flags);
447 }
448
outputPre(OutputStream & OS,OutputFlags Flags) const449 void ThunkSignatureNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
450 OS << "[thunk]: ";
451
452 FunctionSignatureNode::outputPre(OS, Flags);
453 }
454
outputPost(OutputStream & OS,OutputFlags Flags) const455 void ThunkSignatureNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
456 if (FunctionClass & FC_StaticThisAdjust) {
457 OS << "`adjustor{" << ThisAdjust.StaticOffset << "}'";
458 } else if (FunctionClass & FC_VirtualThisAdjust) {
459 if (FunctionClass & FC_VirtualThisAdjustEx) {
460 OS << "`vtordispex{" << ThisAdjust.VBPtrOffset << ", "
461 << ThisAdjust.VBOffsetOffset << ", " << ThisAdjust.VtordispOffset
462 << ", " << ThisAdjust.StaticOffset << "}'";
463 } else {
464 OS << "`vtordisp{" << ThisAdjust.VtordispOffset << ", "
465 << ThisAdjust.StaticOffset << "}'";
466 }
467 }
468
469 FunctionSignatureNode::outputPost(OS, Flags);
470 }
471
outputPre(OutputStream & OS,OutputFlags Flags) const472 void PointerTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
473 if (Pointee->kind() == NodeKind::FunctionSignature) {
474 // If this is a pointer to a function, don't output the calling convention.
475 // It needs to go inside the parentheses.
476 const FunctionSignatureNode *Sig =
477 static_cast<const FunctionSignatureNode *>(Pointee);
478 Sig->outputPre(OS, OF_NoCallingConvention);
479 } else
480 Pointee->outputPre(OS, Flags);
481
482 outputSpaceIfNecessary(OS);
483
484 if (Quals & Q_Unaligned)
485 OS << "__unaligned ";
486
487 if (Pointee->kind() == NodeKind::ArrayType) {
488 OS << "(";
489 } else if (Pointee->kind() == NodeKind::FunctionSignature) {
490 OS << "(";
491 const FunctionSignatureNode *Sig =
492 static_cast<const FunctionSignatureNode *>(Pointee);
493 outputCallingConvention(OS, Sig->CallConvention);
494 OS << " ";
495 }
496
497 if (ClassParent) {
498 ClassParent->output(OS, Flags);
499 OS << "::";
500 }
501
502 switch (Affinity) {
503 case PointerAffinity::Pointer:
504 OS << "*";
505 break;
506 case PointerAffinity::Reference:
507 OS << "&";
508 break;
509 case PointerAffinity::RValueReference:
510 OS << "&&";
511 break;
512 default:
513 assert(false);
514 }
515 outputQualifiers(OS, Quals, false, false);
516 }
517
outputPost(OutputStream & OS,OutputFlags Flags) const518 void PointerTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
519 if (Pointee->kind() == NodeKind::ArrayType ||
520 Pointee->kind() == NodeKind::FunctionSignature)
521 OS << ")";
522
523 Pointee->outputPost(OS, Flags);
524 }
525
outputPre(OutputStream & OS,OutputFlags Flags) const526 void TagTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
527 if (!(Flags & OF_NoTagSpecifier)) {
528 switch (Tag) {
529 OUTPUT_ENUM_CLASS_VALUE(TagKind, Class, "class");
530 OUTPUT_ENUM_CLASS_VALUE(TagKind, Struct, "struct");
531 OUTPUT_ENUM_CLASS_VALUE(TagKind, Union, "union");
532 OUTPUT_ENUM_CLASS_VALUE(TagKind, Enum, "enum");
533 }
534 OS << " ";
535 }
536 QualifiedName->output(OS, Flags);
537 outputQualifiers(OS, Quals, true, false);
538 }
539
outputPost(OutputStream & OS,OutputFlags Flags) const540 void TagTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {}
541
outputPre(OutputStream & OS,OutputFlags Flags) const542 void ArrayTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
543 ElementType->outputPre(OS, Flags);
544 outputQualifiers(OS, Quals, true, false);
545 }
546
outputOneDimension(OutputStream & OS,OutputFlags Flags,Node * N) const547 void ArrayTypeNode::outputOneDimension(OutputStream &OS, OutputFlags Flags,
548 Node *N) const {
549 assert(N->kind() == NodeKind::IntegerLiteral);
550 IntegerLiteralNode *ILN = static_cast<IntegerLiteralNode *>(N);
551 if (ILN->Value != 0)
552 ILN->output(OS, Flags);
553 }
554
outputDimensionsImpl(OutputStream & OS,OutputFlags Flags) const555 void ArrayTypeNode::outputDimensionsImpl(OutputStream &OS,
556 OutputFlags Flags) const {
557 if (Dimensions->Count == 0)
558 return;
559
560 outputOneDimension(OS, Flags, Dimensions->Nodes[0]);
561 for (size_t I = 1; I < Dimensions->Count; ++I) {
562 OS << "][";
563 outputOneDimension(OS, Flags, Dimensions->Nodes[I]);
564 }
565 }
566
outputPost(OutputStream & OS,OutputFlags Flags) const567 void ArrayTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
568 OS << "[";
569 outputDimensionsImpl(OS, Flags);
570 OS << "]";
571
572 ElementType->outputPost(OS, Flags);
573 }
574
output(OutputStream & OS,OutputFlags Flags) const575 void SymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
576 Name->output(OS, Flags);
577 }
578
output(OutputStream & OS,OutputFlags Flags) const579 void FunctionSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
580 Signature->outputPre(OS, Flags);
581 outputSpaceIfNecessary(OS);
582 Name->output(OS, Flags);
583 Signature->outputPost(OS, Flags);
584 }
585
output(OutputStream & OS,OutputFlags Flags) const586 void VariableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
587 const char *AccessSpec = nullptr;
588 bool IsStatic = true;
589 switch (SC) {
590 case StorageClass::PrivateStatic:
591 AccessSpec = "private";
592 break;
593 case StorageClass::PublicStatic:
594 AccessSpec = "public";
595 break;
596 case StorageClass::ProtectedStatic:
597 AccessSpec = "protected";
598 break;
599 default:
600 IsStatic = false;
601 break;
602 }
603 if (!(Flags & OF_NoAccessSpecifier) && AccessSpec)
604 OS << AccessSpec << ": ";
605 if (!(Flags & OF_NoMemberType) && IsStatic)
606 OS << "static ";
607
608 if (Type) {
609 Type->outputPre(OS, Flags);
610 outputSpaceIfNecessary(OS);
611 }
612 Name->output(OS, Flags);
613 if (Type)
614 Type->outputPost(OS, Flags);
615 }
616
outputPre(OutputStream & OS,OutputFlags Flags) const617 void CustomTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
618 Identifier->output(OS, Flags);
619 }
outputPost(OutputStream & OS,OutputFlags Flags) const620 void CustomTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {}
621
output(OutputStream & OS,OutputFlags Flags) const622 void QualifiedNameNode::output(OutputStream &OS, OutputFlags Flags) const {
623 Components->output(OS, Flags, "::");
624 }
625
output(OutputStream & OS,OutputFlags Flags) const626 void RttiBaseClassDescriptorNode::output(OutputStream &OS,
627 OutputFlags Flags) const {
628 OS << "`RTTI Base Class Descriptor at (";
629 OS << NVOffset << ", " << VBPtrOffset << ", " << VBTableOffset << ", "
630 << this->Flags;
631 OS << ")'";
632 }
633
output(OutputStream & OS,OutputFlags Flags) const634 void LocalStaticGuardVariableNode::output(OutputStream &OS,
635 OutputFlags Flags) const {
636 Name->output(OS, Flags);
637 }
638
output(OutputStream & OS,OutputFlags Flags) const639 void VcallThunkIdentifierNode::output(OutputStream &OS,
640 OutputFlags Flags) const {
641 OS << "`vcall'{" << OffsetInVTable << ", {flat}}";
642 }
643
output(OutputStream & OS,OutputFlags Flags) const644 void SpecialTableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
645 outputQualifiers(OS, Quals, false, true);
646 Name->output(OS, Flags);
647 if (TargetName) {
648 OS << "{for `";
649 TargetName->output(OS, Flags);
650 OS << "'}";
651 }
652 return;
653 }
654