Bug Summary

File:lib/Demangle/MicrosoftDemangleNodes.cpp
Warning:line 73, column 3
Value stored to 'SpaceBefore' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name MicrosoftDemangleNodes.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-9/lib/clang/9.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/lib/Demangle -I /build/llvm-toolchain-snapshot-9~svn362543/lib/Demangle -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn362543/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/9.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-9/lib/clang/9.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/lib/Demangle -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn362543=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2019-06-05-060531-1271-1 -x c++ /build/llvm-toolchain-snapshot-9~svn362543/lib/Demangle/MicrosoftDemangleNodes.cpp -faddrsig
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
19using namespace llvm;
20using namespace ms_demangle;
21
22#define OUTPUT_ENUM_CLASS_VALUE(Enum, Value, Desc)case Enum::Value: OS << Desc; break; \
23 case Enum::Value: \
24 OS << Desc; \
25 break;
26
27// Writes a space if the last token does not end with a punctuation.
28static 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
37static 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
53static 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
65static 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);
Value stored to 'SpaceBefore' is never read
74 size_t Pos2 = OS.getCurrentPosition();
75 if (SpaceAfter && Pos2 > Pos1)
76 OS << " ";
77}
78
79static 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
115std::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
123void TypeNode::outputQuals(bool SpaceBefore, bool SpaceAfter) const {}
124
125void PrimitiveTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
126 switch (PrimKind) {
127 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Void, "void")case PrimitiveKind::Void: OS << "void"; break;;
128 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Bool, "bool")case PrimitiveKind::Bool: OS << "bool"; break;;
129 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char, "char")case PrimitiveKind::Char: OS << "char"; break;;
130 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Schar, "signed char")case PrimitiveKind::Schar: OS << "signed char"; break;;
131 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uchar, "unsigned char")case PrimitiveKind::Uchar: OS << "unsigned char"; break
;
;
132 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char8, "char8_t")case PrimitiveKind::Char8: OS << "char8_t"; break;;
133 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char16, "char16_t")case PrimitiveKind::Char16: OS << "char16_t"; break;;
134 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char32, "char32_t")case PrimitiveKind::Char32: OS << "char32_t"; break;;
135 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Short, "short")case PrimitiveKind::Short: OS << "short"; break;;
136 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ushort, "unsigned short")case PrimitiveKind::Ushort: OS << "unsigned short"; break
;
;
137 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Int, "int")case PrimitiveKind::Int: OS << "int"; break;;
138 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uint, "unsigned int")case PrimitiveKind::Uint: OS << "unsigned int"; break;;
139 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Long, "long")case PrimitiveKind::Long: OS << "long"; break;;
140 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ulong, "unsigned long")case PrimitiveKind::Ulong: OS << "unsigned long"; break
;
;
141 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Int64, "__int64")case PrimitiveKind::Int64: OS << "__int64"; break;;
142 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uint64, "unsigned __int64")case PrimitiveKind::Uint64: OS << "unsigned __int64"; break
;
;
143 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Wchar, "wchar_t")case PrimitiveKind::Wchar: OS << "wchar_t"; break;;
144 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Float, "float")case PrimitiveKind::Float: OS << "float"; break;;
145 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Double, "double")case PrimitiveKind::Double: OS << "double"; break;;
146 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ldouble, "long double")case PrimitiveKind::Ldouble: OS << "long double"; break
;
;
147 OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Nullptr, "std::nullptr_t")case PrimitiveKind::Nullptr: OS << "std::nullptr_t"; break
;
;
148 }
149 outputQualifiers(OS, Quals, true, false);
150}
151
152void NodeArrayNode::output(OutputStream &OS, OutputFlags Flags) const {
153 output(OS, Flags, ", ");
154}
155
156void NodeArrayNode::output(OutputStream &OS, OutputFlags Flags,
157 StringView Separator) const {
158 if (Count == 0)
159 return;
160 if (Nodes[0])
161 Nodes[0]->output(OS, Flags);
162 for (size_t I = 1; I < Count; ++I) {
163 OS << Separator;
164 Nodes[I]->output(OS, Flags);
165 }
166}
167
168void EncodedStringLiteralNode::output(OutputStream &OS,
169 OutputFlags Flags) const {
170 switch (Char) {
171 case CharKind::Wchar:
172 OS << "L\"";
173 break;
174 case CharKind::Char:
175 OS << "\"";
176 break;
177 case CharKind::Char16:
178 OS << "u\"";
179 break;
180 case CharKind::Char32:
181 OS << "U\"";
182 break;
183 }
184 OS << DecodedString << "\"";
185 if (IsTruncated)
186 OS << "...";
187}
188
189void IntegerLiteralNode::output(OutputStream &OS, OutputFlags Flags) const {
190 if (IsNegative)
191 OS << '-';
192 OS << Value;
193}
194
195void TemplateParameterReferenceNode::output(OutputStream &OS,
196 OutputFlags Flags) const {
197 if (ThunkOffsetCount > 0)
198 OS << "{";
199 else if (Affinity == PointerAffinity::Pointer)
200 OS << "&";
201
202 if (Symbol) {
203 Symbol->output(OS, Flags);
204 if (ThunkOffsetCount > 0)
205 OS << ", ";
206 }
207
208 if (ThunkOffsetCount > 0)
209 OS << ThunkOffsets[0];
210 for (int I = 1; I < ThunkOffsetCount; ++I) {
211 OS << ", " << ThunkOffsets[I];
212 }
213 if (ThunkOffsetCount > 0)
214 OS << "}";
215}
216
217void IdentifierNode::outputTemplateParameters(OutputStream &OS,
218 OutputFlags Flags) const {
219 if (!TemplateParams)
220 return;
221 OS << "<";
222 TemplateParams->output(OS, Flags);
223 OS << ">";
224}
225
226void DynamicStructorIdentifierNode::output(OutputStream &OS,
227 OutputFlags Flags) const {
228 if (IsDestructor)
229 OS << "`dynamic atexit destructor for ";
230 else
231 OS << "`dynamic initializer for ";
232
233 if (Variable) {
234 OS << "`";
235 Variable->output(OS, Flags);
236 OS << "''";
237 } else {
238 OS << "'";
239 Name->output(OS, Flags);
240 OS << "''";
241 }
242}
243
244void NamedIdentifierNode::output(OutputStream &OS, OutputFlags Flags) const {
245 OS << Name;
246 outputTemplateParameters(OS, Flags);
247}
248
249void IntrinsicFunctionIdentifierNode::output(OutputStream &OS,
250 OutputFlags Flags) const {
251 switch (Operator) {
252 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, New, "operator new")case IntrinsicFunctionKind::New: OS << "operator new"; break
;
;
253 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Delete, "operator delete")case IntrinsicFunctionKind::Delete: OS << "operator delete"
; break;
;
254 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Assign, "operator=")case IntrinsicFunctionKind::Assign: OS << "operator="; break
;
;
255 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, RightShift, "operator>>")case IntrinsicFunctionKind::RightShift: OS << "operator>>"
; break;
;
256 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LeftShift, "operator<<")case IntrinsicFunctionKind::LeftShift: OS << "operator<<"
; break;
;
257 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalNot, "operator!")case IntrinsicFunctionKind::LogicalNot: OS << "operator!"
; break;
;
258 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Equals, "operator==")case IntrinsicFunctionKind::Equals: OS << "operator==";
break;
;
259 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, NotEquals, "operator!=")case IntrinsicFunctionKind::NotEquals: OS << "operator!="
; break;
;
260 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArraySubscript,case IntrinsicFunctionKind::ArraySubscript: OS << "operator[]"
; break;
261 "operator[]")case IntrinsicFunctionKind::ArraySubscript: OS << "operator[]"
; break;
;
262 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Pointer, "operator->")case IntrinsicFunctionKind::Pointer: OS << "operator->"
; break;
;
263 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Increment, "operator++")case IntrinsicFunctionKind::Increment: OS << "operator++"
; break;
;
264 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Decrement, "operator--")case IntrinsicFunctionKind::Decrement: OS << "operator--"
; break;
;
265 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Minus, "operator-")case IntrinsicFunctionKind::Minus: OS << "operator-"; break
;
;
266 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Plus, "operator+")case IntrinsicFunctionKind::Plus: OS << "operator+"; break
;
;
267 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Dereference, "operator*")case IntrinsicFunctionKind::Dereference: OS << "operator*"
; break;
;
268 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseAnd, "operator&")case IntrinsicFunctionKind::BitwiseAnd: OS << "operator&"
; break;
;
269 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, MemberPointer,case IntrinsicFunctionKind::MemberPointer: OS << "operator->*"
; break;
270 "operator->*")case IntrinsicFunctionKind::MemberPointer: OS << "operator->*"
; break;
;
271 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Divide, "operator/")case IntrinsicFunctionKind::Divide: OS << "operator/"; break
;
;
272 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Modulus, "operator%")case IntrinsicFunctionKind::Modulus: OS << "operator%";
break;
;
273 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LessThan, "operator<")case IntrinsicFunctionKind::LessThan: OS << "operator<"
; break;
;
274 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LessThanEqual, "operator<=")case IntrinsicFunctionKind::LessThanEqual: OS << "operator<="
; break;
;
275 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, GreaterThan, "operator>")case IntrinsicFunctionKind::GreaterThan: OS << "operator>"
; break;
;
276 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, GreaterThanEqual,case IntrinsicFunctionKind::GreaterThanEqual: OS << "operator>="
; break;
277 "operator>=")case IntrinsicFunctionKind::GreaterThanEqual: OS << "operator>="
; break;
;
278 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Comma, "operator,")case IntrinsicFunctionKind::Comma: OS << "operator,"; break
;
;
279 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Parens, "operator()")case IntrinsicFunctionKind::Parens: OS << "operator()";
break;
;
280 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseNot, "operator~")case IntrinsicFunctionKind::BitwiseNot: OS << "operator~"
; break;
;
281 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseXor, "operator^")case IntrinsicFunctionKind::BitwiseXor: OS << "operator^"
; break;
;
282 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseOr, "operator|")case IntrinsicFunctionKind::BitwiseOr: OS << "operator|"
; break;
;
283 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalAnd, "operator&&")case IntrinsicFunctionKind::LogicalAnd: OS << "operator&&"
; break;
;
284 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalOr, "operator||")case IntrinsicFunctionKind::LogicalOr: OS << "operator||"
; break;
;
285 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, TimesEqual, "operator*=")case IntrinsicFunctionKind::TimesEqual: OS << "operator*="
; break;
;
286 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, PlusEqual, "operator+=")case IntrinsicFunctionKind::PlusEqual: OS << "operator+="
; break;
;
287 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, MinusEqual, "operator-=")case IntrinsicFunctionKind::MinusEqual: OS << "operator-="
; break;
;
288 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, DivEqual, "operator/=")case IntrinsicFunctionKind::DivEqual: OS << "operator/="
; break;
;
289 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ModEqual, "operator%=")case IntrinsicFunctionKind::ModEqual: OS << "operator%="
; break;
;
290 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, RshEqual, "operator>>=")case IntrinsicFunctionKind::RshEqual: OS << "operator>>="
; break;
;
291 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LshEqual, "operator<<=")case IntrinsicFunctionKind::LshEqual: OS << "operator<<="
; break;
;
292 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseAndEqual,case IntrinsicFunctionKind::BitwiseAndEqual: OS << "operator&="
; break;
293 "operator&=")case IntrinsicFunctionKind::BitwiseAndEqual: OS << "operator&="
; break;
;
294 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseOrEqual,case IntrinsicFunctionKind::BitwiseOrEqual: OS << "operator|="
; break;
295 "operator|=")case IntrinsicFunctionKind::BitwiseOrEqual: OS << "operator|="
; break;
;
296 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseXorEqual,case IntrinsicFunctionKind::BitwiseXorEqual: OS << "operator^="
; break;
297 "operator^=")case IntrinsicFunctionKind::BitwiseXorEqual: OS << "operator^="
; break;
;
298 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VbaseDtor, "`vbase dtor'")case IntrinsicFunctionKind::VbaseDtor: OS << "`vbase dtor'"
; break;
;
299 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecDelDtor,case IntrinsicFunctionKind::VecDelDtor: OS << "`vector deleting dtor'"
; break;
300 "`vector deleting dtor'")case IntrinsicFunctionKind::VecDelDtor: OS << "`vector deleting dtor'"
; break;
;
301 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, DefaultCtorClosure,case IntrinsicFunctionKind::DefaultCtorClosure: OS << "`default ctor closure'"
; break;
302 "`default ctor closure'")case IntrinsicFunctionKind::DefaultCtorClosure: OS << "`default ctor closure'"
; break;
;
303 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ScalarDelDtor,case IntrinsicFunctionKind::ScalarDelDtor: OS << "`scalar deleting dtor'"
; break;
304 "`scalar deleting dtor'")case IntrinsicFunctionKind::ScalarDelDtor: OS << "`scalar deleting dtor'"
; break;
;
305 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecCtorIter,case IntrinsicFunctionKind::VecCtorIter: OS << "`vector ctor iterator'"
; break;
306 "`vector ctor iterator'")case IntrinsicFunctionKind::VecCtorIter: OS << "`vector ctor iterator'"
; break;
;
307 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecDtorIter,case IntrinsicFunctionKind::VecDtorIter: OS << "`vector dtor iterator'"
; break;
308 "`vector dtor iterator'")case IntrinsicFunctionKind::VecDtorIter: OS << "`vector dtor iterator'"
; break;
;
309 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecVbaseCtorIter,case IntrinsicFunctionKind::VecVbaseCtorIter: OS << "`vector vbase ctor iterator'"
; break;
310 "`vector vbase ctor iterator'")case IntrinsicFunctionKind::VecVbaseCtorIter: OS << "`vector vbase ctor iterator'"
; break;
;
311 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VdispMap,case IntrinsicFunctionKind::VdispMap: OS << "`virtual displacement map'"
; break;
312 "`virtual displacement map'")case IntrinsicFunctionKind::VdispMap: OS << "`virtual displacement map'"
; break;
;
313 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecCtorIter,case IntrinsicFunctionKind::EHVecCtorIter: OS << "`eh vector ctor iterator'"
; break;
314 "`eh vector ctor iterator'")case IntrinsicFunctionKind::EHVecCtorIter: OS << "`eh vector ctor iterator'"
; break;
;
315 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecDtorIter,case IntrinsicFunctionKind::EHVecDtorIter: OS << "`eh vector dtor iterator'"
; break;
316 "`eh vector dtor iterator'")case IntrinsicFunctionKind::EHVecDtorIter: OS << "`eh vector dtor iterator'"
; break;
;
317 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecVbaseCtorIter,case IntrinsicFunctionKind::EHVecVbaseCtorIter: OS << "`eh vector vbase ctor iterator'"
; break;
318 "`eh vector vbase ctor iterator'")case IntrinsicFunctionKind::EHVecVbaseCtorIter: OS << "`eh vector vbase ctor iterator'"
; break;
;
319 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, CopyCtorClosure,case IntrinsicFunctionKind::CopyCtorClosure: OS << "`copy ctor closure'"
; break;
320 "`copy ctor closure'")case IntrinsicFunctionKind::CopyCtorClosure: OS << "`copy ctor closure'"
; break;
;
321 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LocalVftableCtorClosure,case IntrinsicFunctionKind::LocalVftableCtorClosure: OS <<
"`local vftable ctor closure'"; break;
322 "`local vftable ctor closure'")case IntrinsicFunctionKind::LocalVftableCtorClosure: OS <<
"`local vftable ctor closure'"; break;
;
323 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArrayNew, "operator new[]")case IntrinsicFunctionKind::ArrayNew: OS << "operator new[]"
; break;
;
324 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArrayDelete,case IntrinsicFunctionKind::ArrayDelete: OS << "operator delete[]"
; break;
325 "operator delete[]")case IntrinsicFunctionKind::ArrayDelete: OS << "operator delete[]"
; break;
;
326 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorCtorIter,case IntrinsicFunctionKind::ManVectorCtorIter: OS << "`managed vector ctor iterator'"
; break;
327 "`managed vector ctor iterator'")case IntrinsicFunctionKind::ManVectorCtorIter: OS << "`managed vector ctor iterator'"
; break;
;
328 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorDtorIter,case IntrinsicFunctionKind::ManVectorDtorIter: OS << "`managed vector dtor iterator'"
; break;
329 "`managed vector dtor iterator'")case IntrinsicFunctionKind::ManVectorDtorIter: OS << "`managed vector dtor iterator'"
; break;
;
330 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVectorCopyCtorIter,case IntrinsicFunctionKind::EHVectorCopyCtorIter: OS <<
"`EH vector copy ctor iterator'"; break;
331 "`EH vector copy ctor iterator'")case IntrinsicFunctionKind::EHVectorCopyCtorIter: OS <<
"`EH vector copy ctor iterator'"; break;
;
332 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVectorVbaseCopyCtorIter,case IntrinsicFunctionKind::EHVectorVbaseCopyCtorIter: OS <<
"`EH vector vbase copy ctor iterator'"; break;
333 "`EH vector vbase copy ctor iterator'")case IntrinsicFunctionKind::EHVectorVbaseCopyCtorIter: OS <<
"`EH vector vbase copy ctor iterator'"; break;
;
334 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VectorCopyCtorIter,case IntrinsicFunctionKind::VectorCopyCtorIter: OS << "`vector copy ctor iterator'"
; break;
335 "`vector copy ctor iterator'")case IntrinsicFunctionKind::VectorCopyCtorIter: OS << "`vector copy ctor iterator'"
; break;
;
336 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VectorVbaseCopyCtorIter,case IntrinsicFunctionKind::VectorVbaseCopyCtorIter: OS <<
"`vector vbase copy constructor iterator'"; break;
337 "`vector vbase copy constructor iterator'")case IntrinsicFunctionKind::VectorVbaseCopyCtorIter: OS <<
"`vector vbase copy constructor iterator'"; break;
;
338 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorVbaseCopyCtorIter,case IntrinsicFunctionKind::ManVectorVbaseCopyCtorIter: OS <<
"`managed vector vbase copy constructor iterator'"; break;
339 "`managed vector vbase copy constructor iterator'")case IntrinsicFunctionKind::ManVectorVbaseCopyCtorIter: OS <<
"`managed vector vbase copy constructor iterator'"; break;
;
340 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, CoAwait,case IntrinsicFunctionKind::CoAwait: OS << "operator co_await"
; break;
341 "operator co_await")case IntrinsicFunctionKind::CoAwait: OS << "operator co_await"
; break;
;
342 OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Spaceship, "operator<=>")case IntrinsicFunctionKind::Spaceship: OS << "operator<=>"
; break;
;
343 case IntrinsicFunctionKind::MaxIntrinsic:
344 case IntrinsicFunctionKind::None:
345 break;
346 }
347 outputTemplateParameters(OS, Flags);
348}
349
350void LocalStaticGuardIdentifierNode::output(OutputStream &OS,
351 OutputFlags Flags) const {
352 if (IsThread)
353 OS << "`local static thread guard'";
354 else
355 OS << "`local static guard'";
356 if (ScopeIndex > 0)
357 OS << "{" << ScopeIndex << "}";
358}
359
360void ConversionOperatorIdentifierNode::output(OutputStream &OS,
361 OutputFlags Flags) const {
362 OS << "operator";
363 outputTemplateParameters(OS, Flags);
364 OS << " ";
365 TargetType->output(OS, Flags);
366}
367
368void StructorIdentifierNode::output(OutputStream &OS, OutputFlags Flags) const {
369 if (IsDestructor)
370 OS << "~";
371 Class->output(OS, Flags);
372 outputTemplateParameters(OS, Flags);
373}
374
375void LiteralOperatorIdentifierNode::output(OutputStream &OS,
376 OutputFlags Flags) const {
377 OS << "operator \"\"" << Name;
378 outputTemplateParameters(OS, Flags);
379}
380
381void FunctionSignatureNode::outputPre(OutputStream &OS,
382 OutputFlags Flags) const {
383 if (FunctionClass & FC_Public)
384 OS << "public: ";
385 if (FunctionClass & FC_Protected)
386 OS << "protected: ";
387 if (FunctionClass & FC_Private)
388 OS << "private: ";
389
390 if (!(FunctionClass & FC_Global)) {
391 if (FunctionClass & FC_Static)
392 OS << "static ";
393 }
394 if (FunctionClass & FC_Virtual)
395 OS << "virtual ";
396
397 if (FunctionClass & FC_ExternC)
398 OS << "extern \"C\" ";
399
400 if (ReturnType) {
401 ReturnType->outputPre(OS, Flags);
402 OS << " ";
403 }
404
405 if (!(Flags & OF_NoCallingConvention))
406 outputCallingConvention(OS, CallConvention);
407}
408
409void FunctionSignatureNode::outputPost(OutputStream &OS,
410 OutputFlags Flags) const {
411 if (!(FunctionClass & FC_NoParameterList)) {
412 OS << "(";
413 if (Params)
414 Params->output(OS, Flags);
415 else
416 OS << "void";
417
418 if (IsVariadic) {
419 if (OS.back() != '(')
420 OS << ", ";
421 OS << "...";
422 }
423 OS << ")";
424 }
425
426 if (Quals & Q_Const)
427 OS << " const";
428 if (Quals & Q_Volatile)
429 OS << " volatile";
430 if (Quals & Q_Restrict)
431 OS << " __restrict";
432 if (Quals & Q_Unaligned)
433 OS << " __unaligned";
434
435 if (IsNoexcept)
436 OS << " noexcept";
437
438 if (RefQualifier == FunctionRefQualifier::Reference)
439 OS << " &";
440 else if (RefQualifier == FunctionRefQualifier::RValueReference)
441 OS << " &&";
442
443 if (ReturnType)
444 ReturnType->outputPost(OS, Flags);
445}
446
447void ThunkSignatureNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
448 OS << "[thunk]: ";
449
450 FunctionSignatureNode::outputPre(OS, Flags);
451}
452
453void ThunkSignatureNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
454 if (FunctionClass & FC_StaticThisAdjust) {
455 OS << "`adjustor{" << ThisAdjust.StaticOffset << "}'";
456 } else if (FunctionClass & FC_VirtualThisAdjust) {
457 if (FunctionClass & FC_VirtualThisAdjustEx) {
458 OS << "`vtordispex{" << ThisAdjust.VBPtrOffset << ", "
459 << ThisAdjust.VBOffsetOffset << ", " << ThisAdjust.VtordispOffset
460 << ", " << ThisAdjust.StaticOffset << "}'";
461 } else {
462 OS << "`vtordisp{" << ThisAdjust.VtordispOffset << ", "
463 << ThisAdjust.StaticOffset << "}'";
464 }
465 }
466
467 FunctionSignatureNode::outputPost(OS, Flags);
468}
469
470void PointerTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
471 if (Pointee->kind() == NodeKind::FunctionSignature) {
472 // If this is a pointer to a function, don't output the calling convention.
473 // It needs to go inside the parentheses.
474 const FunctionSignatureNode *Sig =
475 static_cast<const FunctionSignatureNode *>(Pointee);
476 Sig->outputPre(OS, OF_NoCallingConvention);
477 } else
478 Pointee->outputPre(OS, Flags);
479
480 outputSpaceIfNecessary(OS);
481
482 if (Quals & Q_Unaligned)
483 OS << "__unaligned ";
484
485 if (Pointee->kind() == NodeKind::ArrayType) {
486 OS << "(";
487 } else if (Pointee->kind() == NodeKind::FunctionSignature) {
488 OS << "(";
489 const FunctionSignatureNode *Sig =
490 static_cast<const FunctionSignatureNode *>(Pointee);
491 outputCallingConvention(OS, Sig->CallConvention);
492 OS << " ";
493 }
494
495 if (ClassParent) {
496 ClassParent->output(OS, Flags);
497 OS << "::";
498 }
499
500 switch (Affinity) {
501 case PointerAffinity::Pointer:
502 OS << "*";
503 break;
504 case PointerAffinity::Reference:
505 OS << "&";
506 break;
507 case PointerAffinity::RValueReference:
508 OS << "&&";
509 break;
510 default:
511 assert(false)((false) ? static_cast<void> (0) : __assert_fail ("false"
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Demangle/MicrosoftDemangleNodes.cpp"
, 511, __PRETTY_FUNCTION__))
;
512 }
513 outputQualifiers(OS, Quals, false, false);
514}
515
516void PointerTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
517 if (Pointee->kind() == NodeKind::ArrayType ||
518 Pointee->kind() == NodeKind::FunctionSignature)
519 OS << ")";
520
521 Pointee->outputPost(OS, Flags);
522}
523
524void TagTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
525 if (!(Flags & OF_NoTagSpecifier)) {
526 switch (Tag) {
527 OUTPUT_ENUM_CLASS_VALUE(TagKind, Class, "class")case TagKind::Class: OS << "class"; break;;
528 OUTPUT_ENUM_CLASS_VALUE(TagKind, Struct, "struct")case TagKind::Struct: OS << "struct"; break;;
529 OUTPUT_ENUM_CLASS_VALUE(TagKind, Union, "union")case TagKind::Union: OS << "union"; break;;
530 OUTPUT_ENUM_CLASS_VALUE(TagKind, Enum, "enum")case TagKind::Enum: OS << "enum"; break;;
531 }
532 OS << " ";
533 }
534 QualifiedName->output(OS, Flags);
535 outputQualifiers(OS, Quals, true, false);
536}
537
538void TagTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {}
539
540void ArrayTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
541 ElementType->outputPre(OS, Flags);
542 outputQualifiers(OS, Quals, true, false);
543}
544
545void ArrayTypeNode::outputOneDimension(OutputStream &OS, OutputFlags Flags,
546 Node *N) const {
547 assert(N->kind() == NodeKind::IntegerLiteral)((N->kind() == NodeKind::IntegerLiteral) ? static_cast<
void> (0) : __assert_fail ("N->kind() == NodeKind::IntegerLiteral"
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/Demangle/MicrosoftDemangleNodes.cpp"
, 547, __PRETTY_FUNCTION__))
;
548 IntegerLiteralNode *ILN = static_cast<IntegerLiteralNode *>(N);
549 if (ILN->Value != 0)
550 ILN->output(OS, Flags);
551}
552
553void ArrayTypeNode::outputDimensionsImpl(OutputStream &OS,
554 OutputFlags Flags) const {
555 if (Dimensions->Count == 0)
556 return;
557
558 outputOneDimension(OS, Flags, Dimensions->Nodes[0]);
559 for (size_t I = 1; I < Dimensions->Count; ++I) {
560 OS << "][";
561 outputOneDimension(OS, Flags, Dimensions->Nodes[I]);
562 }
563}
564
565void ArrayTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {
566 OS << "[";
567 outputDimensionsImpl(OS, Flags);
568 OS << "]";
569
570 ElementType->outputPost(OS, Flags);
571}
572
573void SymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
574 Name->output(OS, Flags);
575}
576
577void FunctionSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
578 Signature->outputPre(OS, Flags);
579 outputSpaceIfNecessary(OS);
580 Name->output(OS, Flags);
581 Signature->outputPost(OS, Flags);
582}
583
584void VariableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
585 switch (SC) {
586 case StorageClass::PrivateStatic:
587 OS << "private: static ";
588 break;
589 case StorageClass::PublicStatic:
590 OS << "public: static ";
591 break;
592 case StorageClass::ProtectedStatic:
593 OS << "protected: static ";
594 break;
595 default:
596 break;
597 }
598
599 if (Type) {
600 Type->outputPre(OS, Flags);
601 outputSpaceIfNecessary(OS);
602 }
603 Name->output(OS, Flags);
604 if (Type)
605 Type->outputPost(OS, Flags);
606}
607
608void CustomTypeNode::outputPre(OutputStream &OS, OutputFlags Flags) const {
609 Identifier->output(OS, Flags);
610}
611void CustomTypeNode::outputPost(OutputStream &OS, OutputFlags Flags) const {}
612
613void QualifiedNameNode::output(OutputStream &OS, OutputFlags Flags) const {
614 Components->output(OS, Flags, "::");
615}
616
617void RttiBaseClassDescriptorNode::output(OutputStream &OS,
618 OutputFlags Flags) const {
619 OS << "`RTTI Base Class Descriptor at (";
620 OS << NVOffset << ", " << VBPtrOffset << ", " << VBTableOffset << ", "
621 << this->Flags;
622 OS << ")'";
623}
624
625void LocalStaticGuardVariableNode::output(OutputStream &OS,
626 OutputFlags Flags) const {
627 Name->output(OS, Flags);
628}
629
630void VcallThunkIdentifierNode::output(OutputStream &OS,
631 OutputFlags Flags) const {
632 OS << "`vcall'{" << OffsetInVTable << ", {flat}}";
633}
634
635void SpecialTableSymbolNode::output(OutputStream &OS, OutputFlags Flags) const {
636 outputQualifiers(OS, Quals, false, true);
637 Name->output(OS, Flags);
638 if (TargetName) {
639 OS << "{for `";
640 TargetName->output(OS, Flags);
641 OS << "'}";
642 }
643 return;
644}