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