File: | tools/lldb/source/DataFormatters/VectorType.cpp |
Warning: | line 109, column 12 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===-- VectorType.cpp ------------------------------------------*- C++ -*-===// | |||
2 | // | |||
3 | // The LLVM Compiler Infrastructure | |||
4 | // | |||
5 | // This file is distributed under the University of Illinois Open Source | |||
6 | // License. See LICENSE.TXT for details. | |||
7 | // | |||
8 | //===----------------------------------------------------------------------===// | |||
9 | ||||
10 | // C Includes | |||
11 | // C++ Includes | |||
12 | // Other libraries and framework includes | |||
13 | // Project includes | |||
14 | #include "lldb/DataFormatters/VectorType.h" | |||
15 | ||||
16 | #include "lldb/Core/ValueObject.h" | |||
17 | #include "lldb/DataFormatters/FormattersHelpers.h" | |||
18 | #include "lldb/Symbol/CompilerType.h" | |||
19 | #include "lldb/Symbol/TypeSystem.h" | |||
20 | #include "lldb/Target/Target.h" | |||
21 | ||||
22 | #include "lldb/Utility/LLDBAssert.h" | |||
23 | ||||
24 | using namespace lldb; | |||
25 | using namespace lldb_private; | |||
26 | using namespace lldb_private::formatters; | |||
27 | ||||
28 | static CompilerType GetCompilerTypeForFormat(lldb::Format format, | |||
29 | CompilerType element_type, | |||
30 | TypeSystem *type_system) { | |||
31 | lldbassert(type_system && "type_system needs to be not NULL")lldb_private::lldb_assert(static_cast<bool>(type_system && "type_system needs to be not NULL"), "type_system && \"type_system needs to be not NULL\"" , __FUNCTION__, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/DataFormatters/VectorType.cpp" , 31); | |||
32 | ||||
33 | switch (format) { | |||
34 | case lldb::eFormatAddressInfo: | |||
35 | case lldb::eFormatPointer: | |||
36 | return type_system->GetBuiltinTypeForEncodingAndBitSize( | |||
37 | eEncodingUint, 8 * type_system->GetPointerByteSize()); | |||
38 | ||||
39 | case lldb::eFormatBoolean: | |||
40 | return type_system->GetBasicTypeFromAST(lldb::eBasicTypeBool); | |||
41 | ||||
42 | case lldb::eFormatBytes: | |||
43 | case lldb::eFormatBytesWithASCII: | |||
44 | case lldb::eFormatChar: | |||
45 | case lldb::eFormatCharArray: | |||
46 | case lldb::eFormatCharPrintable: | |||
47 | return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar); | |||
48 | ||||
49 | case lldb::eFormatComplex /* lldb::eFormatComplexFloat */: | |||
50 | return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloatComplex); | |||
51 | ||||
52 | case lldb::eFormatCString: | |||
53 | return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar) | |||
54 | .GetPointerType(); | |||
55 | ||||
56 | case lldb::eFormatFloat: | |||
57 | return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloat); | |||
58 | ||||
59 | case lldb::eFormatHex: | |||
60 | case lldb::eFormatHexUppercase: | |||
61 | case lldb::eFormatOctal: | |||
62 | return type_system->GetBasicTypeFromAST(lldb::eBasicTypeInt); | |||
63 | ||||
64 | case lldb::eFormatHexFloat: | |||
65 | return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloat); | |||
66 | ||||
67 | case lldb::eFormatUnicode16: | |||
68 | case lldb::eFormatUnicode32: | |||
69 | ||||
70 | case lldb::eFormatUnsigned: | |||
71 | return type_system->GetBasicTypeFromAST(lldb::eBasicTypeUnsignedInt); | |||
72 | ||||
73 | case lldb::eFormatVectorOfChar: | |||
74 | return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar); | |||
75 | ||||
76 | case lldb::eFormatVectorOfFloat32: | |||
77 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingIEEE754, | |||
78 | 32); | |||
79 | ||||
80 | case lldb::eFormatVectorOfFloat64: | |||
81 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingIEEE754, | |||
82 | 64); | |||
83 | ||||
84 | case lldb::eFormatVectorOfSInt16: | |||
85 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 16); | |||
86 | ||||
87 | case lldb::eFormatVectorOfSInt32: | |||
88 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 32); | |||
89 | ||||
90 | case lldb::eFormatVectorOfSInt64: | |||
91 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 64); | |||
92 | ||||
93 | case lldb::eFormatVectorOfSInt8: | |||
94 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 8); | |||
95 | ||||
96 | case lldb::eFormatVectorOfUInt128: | |||
97 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 128); | |||
98 | ||||
99 | case lldb::eFormatVectorOfUInt16: | |||
100 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 16); | |||
101 | ||||
102 | case lldb::eFormatVectorOfUInt32: | |||
103 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32); | |||
104 | ||||
105 | case lldb::eFormatVectorOfUInt64: | |||
106 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 64); | |||
107 | ||||
108 | case lldb::eFormatVectorOfUInt8: | |||
109 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8); | |||
| ||||
110 | ||||
111 | case lldb::eFormatDefault: | |||
112 | return element_type; | |||
113 | ||||
114 | case lldb::eFormatBinary: | |||
115 | case lldb::eFormatComplexInteger: | |||
116 | case lldb::eFormatDecimal: | |||
117 | case lldb::eFormatEnum: | |||
118 | case lldb::eFormatInstruction: | |||
119 | case lldb::eFormatOSType: | |||
120 | case lldb::eFormatVoid: | |||
121 | default: | |||
122 | return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8); | |||
123 | } | |||
124 | } | |||
125 | ||||
126 | static lldb::Format GetItemFormatForFormat(lldb::Format format, | |||
127 | CompilerType element_type) { | |||
128 | switch (format) { | |||
129 | case lldb::eFormatVectorOfChar: | |||
130 | return lldb::eFormatChar; | |||
131 | ||||
132 | case lldb::eFormatVectorOfFloat32: | |||
133 | case lldb::eFormatVectorOfFloat64: | |||
134 | return lldb::eFormatFloat; | |||
135 | ||||
136 | case lldb::eFormatVectorOfSInt16: | |||
137 | case lldb::eFormatVectorOfSInt32: | |||
138 | case lldb::eFormatVectorOfSInt64: | |||
139 | case lldb::eFormatVectorOfSInt8: | |||
140 | return lldb::eFormatDecimal; | |||
141 | ||||
142 | case lldb::eFormatVectorOfUInt128: | |||
143 | case lldb::eFormatVectorOfUInt16: | |||
144 | case lldb::eFormatVectorOfUInt32: | |||
145 | case lldb::eFormatVectorOfUInt64: | |||
146 | case lldb::eFormatVectorOfUInt8: | |||
147 | return lldb::eFormatUnsigned; | |||
148 | ||||
149 | case lldb::eFormatBinary: | |||
150 | case lldb::eFormatComplexInteger: | |||
151 | case lldb::eFormatDecimal: | |||
152 | case lldb::eFormatEnum: | |||
153 | case lldb::eFormatInstruction: | |||
154 | case lldb::eFormatOSType: | |||
155 | case lldb::eFormatVoid: | |||
156 | return eFormatHex; | |||
157 | ||||
158 | case lldb::eFormatDefault: { | |||
159 | // special case the (default, char) combination to actually display as an | |||
160 | // integer value most often, you won't want to see the ASCII characters... | |||
161 | // (and if you do, eFormatChar is a keystroke away) | |||
162 | bool is_char = element_type.IsCharType(); | |||
163 | bool is_signed = false; | |||
164 | element_type.IsIntegerType(is_signed); | |||
165 | return is_char ? (is_signed ? lldb::eFormatDecimal : eFormatHex) : format; | |||
166 | } break; | |||
167 | ||||
168 | default: | |||
169 | return format; | |||
170 | } | |||
171 | } | |||
172 | ||||
173 | static size_t CalculateNumChildren( | |||
174 | CompilerType container_type, CompilerType element_type, | |||
175 | lldb_private::ExecutionContextScope *exe_scope = | |||
176 | nullptr // does not matter here because all we trade in are basic types | |||
177 | ) { | |||
178 | auto container_size = container_type.GetByteSize(exe_scope); | |||
179 | auto element_size = element_type.GetByteSize(exe_scope); | |||
180 | ||||
181 | if (element_size) { | |||
182 | if (container_size % element_size) | |||
183 | return 0; | |||
184 | return container_size / element_size; | |||
185 | } | |||
186 | return 0; | |||
187 | } | |||
188 | ||||
189 | namespace lldb_private { | |||
190 | namespace formatters { | |||
191 | ||||
192 | class VectorTypeSyntheticFrontEnd : public SyntheticChildrenFrontEnd { | |||
193 | public: | |||
194 | VectorTypeSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) | |||
195 | : SyntheticChildrenFrontEnd(*valobj_sp), m_parent_format(eFormatInvalid), | |||
196 | m_item_format(eFormatInvalid), m_child_type(), m_num_children(0) {} | |||
197 | ||||
198 | ~VectorTypeSyntheticFrontEnd() override = default; | |||
199 | ||||
200 | size_t CalculateNumChildren() override { return m_num_children; } | |||
201 | ||||
202 | lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { | |||
203 | if (idx >= CalculateNumChildren()) | |||
204 | return lldb::ValueObjectSP(); | |||
205 | auto offset = idx * m_child_type.GetByteSize(nullptr); | |||
206 | StreamString idx_name; | |||
207 | idx_name.Printf("[%" PRIu64"l" "u" "]", (uint64_t)idx); | |||
208 | ValueObjectSP child_sp(m_backend.GetSyntheticChildAtOffset( | |||
209 | offset, m_child_type, true, ConstString(idx_name.GetString()))); | |||
210 | if (!child_sp) | |||
211 | return child_sp; | |||
212 | ||||
213 | child_sp->SetFormat(m_item_format); | |||
214 | ||||
215 | return child_sp; | |||
216 | } | |||
217 | ||||
218 | bool Update() override { | |||
219 | m_parent_format = m_backend.GetFormat(); | |||
220 | CompilerType parent_type(m_backend.GetCompilerType()); | |||
221 | CompilerType element_type; | |||
222 | parent_type.IsVectorType(&element_type, nullptr); | |||
223 | TargetSP target_sp(m_backend.GetTargetSP()); | |||
224 | m_child_type = ::GetCompilerTypeForFormat( | |||
225 | m_parent_format, element_type, | |||
226 | target_sp | |||
227 | ? target_sp->GetScratchTypeSystemForLanguage(nullptr, | |||
228 | lldb::eLanguageTypeC) | |||
229 | : nullptr); | |||
230 | m_num_children = ::CalculateNumChildren(parent_type, m_child_type); | |||
231 | m_item_format = GetItemFormatForFormat(m_parent_format, m_child_type); | |||
232 | return false; | |||
233 | } | |||
234 | ||||
235 | bool MightHaveChildren() override { return true; } | |||
236 | ||||
237 | size_t GetIndexOfChildWithName(const ConstString &name) override { | |||
238 | const char *item_name = name.GetCString(); | |||
239 | uint32_t idx = ExtractIndexFromString(item_name); | |||
240 | if (idx < UINT32_MAX(4294967295U) && idx >= CalculateNumChildren()) | |||
241 | return UINT32_MAX(4294967295U); | |||
242 | return idx; | |||
243 | } | |||
244 | ||||
245 | private: | |||
246 | lldb::Format m_parent_format; | |||
247 | lldb::Format m_item_format; | |||
248 | CompilerType m_child_type; | |||
249 | size_t m_num_children; | |||
250 | }; | |||
251 | ||||
252 | } // namespace formatters | |||
253 | } // namespace lldb_private | |||
254 | ||||
255 | bool lldb_private::formatters::VectorTypeSummaryProvider( | |||
256 | ValueObject &valobj, Stream &s, const TypeSummaryOptions &) { | |||
257 | auto synthetic_children = | |||
258 | VectorTypeSyntheticFrontEndCreator(nullptr, valobj.GetSP()); | |||
259 | if (!synthetic_children) | |||
| ||||
260 | return false; | |||
261 | ||||
262 | synthetic_children->Update(); | |||
263 | ||||
264 | s.PutChar('('); | |||
265 | bool first = true; | |||
266 | ||||
267 | size_t idx = 0, len = synthetic_children->CalculateNumChildren(); | |||
268 | ||||
269 | for (; idx < len; idx++) { | |||
270 | auto child_sp = synthetic_children->GetChildAtIndex(idx); | |||
271 | if (!child_sp) | |||
272 | continue; | |||
273 | child_sp = child_sp->GetQualifiedRepresentationIfAvailable( | |||
274 | lldb::eDynamicDontRunTarget, true); | |||
275 | ||||
276 | const char *child_value = child_sp->GetValueAsCString(); | |||
277 | if (child_value && *child_value) { | |||
278 | if (first) { | |||
279 | s.Printf("%s", child_value); | |||
280 | first = false; | |||
281 | } else { | |||
282 | s.Printf(", %s", child_value); | |||
283 | } | |||
284 | } | |||
285 | } | |||
286 | ||||
287 | s.PutChar(')'); | |||
288 | ||||
289 | return true; | |||
290 | } | |||
291 | ||||
292 | lldb_private::SyntheticChildrenFrontEnd * | |||
293 | lldb_private::formatters::VectorTypeSyntheticFrontEndCreator( | |||
294 | CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { | |||
295 | if (!valobj_sp) | |||
296 | return nullptr; | |||
297 | return new VectorTypeSyntheticFrontEnd(valobj_sp); | |||
298 | } |