1//===-- CompilerType.h ------------------------------------------*- C++ -*-===//
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#ifndef LLDB_SYMBOL_COMPILERTYPE_H
10#define LLDB_SYMBOL_COMPILERTYPE_H
11
12#include <functional>
13#include <string>
14#include <vector>
15
16#include "lldb/lldb-private.h"
17#include "llvm/ADT/APSInt.h"
18
19namespace lldb_private {
20
21class DataExtractor;
22
23/// Generic representation of a type in a programming language.
24///
25/// This class serves as an abstraction for a type inside one of the TypeSystems
26/// implemented by the language plugins. It does not have any actual logic in it
27/// but only stores an opaque pointer and a pointer to the TypeSystem that
28/// gives meaning to this opaque pointer. All methods of this class should call
29/// their respective method in the TypeSystem interface and pass the opaque
30/// pointer along.
31///
32/// \see lldb_private::TypeSystem
33class CompilerType {
34public:
35 /// Creates a CompilerType with the given TypeSystem and opaque compiler type.
36 ///
37 /// This constructor should only be called from the respective TypeSystem
38 /// implementation.
39 ///
40 /// \see lldb_private::TypeSystemClang::GetType(clang::QualType)
41 CompilerType(TypeSystem *type_system, lldb::opaque_compiler_type_t type)
42 : m_type(type), m_type_system(type_system) {
43 assert(Verify() && "verification failed");
44 }
45
46 CompilerType(const CompilerType &rhs)
47 : m_type(rhs.m_type), m_type_system(rhs.m_type_system) {}
48
49 CompilerType() = default;
50
51 /// Operators.
52 /// \{
53 const CompilerType &operator=(const CompilerType &rhs) {
54 m_type = rhs.m_type;
55 m_type_system = rhs.m_type_system;
56 return *this;
57 }
58
59 bool operator<(const CompilerType &rhs) const {
60 if (m_type_system == rhs.m_type_system)
61 return m_type < rhs.m_type;
62 return m_type_system < rhs.m_type_system;
63 }
64 /// \}
65
66 /// Tests.
67 /// \{
68 explicit operator bool() const {
69 return m_type != nullptr && m_type_system != nullptr;
70 }
71
72 bool IsValid() const { return m_type != nullptr && m_type_system != nullptr; }
73
74 bool IsArrayType(CompilerType *element_type = nullptr,
75 uint64_t *size = nullptr,
76 bool *is_incomplete = nullptr) const;
77
78 bool IsVectorType(CompilerType *element_type = nullptr,
79 uint64_t *size = nullptr) const;
80
81 bool IsArrayOfScalarType() const;
82
83 bool IsAggregateType() const;
84
85 bool IsAnonymousType() const;
86
87 bool IsScopedEnumerationType() const;
88
89 bool IsBeingDefined() const;
90
91 bool IsCharType() const;
92
93 bool IsCompleteType() const;
94
95 bool IsConst() const;
96
97 bool IsCStringType(uint32_t &length) const;
98
99 bool IsDefined() const;
100
101 bool IsFloatingPointType(uint32_t &count, bool &is_complex) const;
102
103 bool IsFunctionType() const;
104
105 uint32_t IsHomogeneousAggregate(CompilerType *base_type_ptr) const;
106
107 size_t GetNumberOfFunctionArguments() const;
108
109 CompilerType GetFunctionArgumentAtIndex(const size_t index) const;
110
111 bool IsVariadicFunctionType() const;
112
113 bool IsFunctionPointerType() const;
114
115 bool
116 IsBlockPointerType(CompilerType *function_pointer_type_ptr = nullptr) const;
117
118 bool IsIntegerType(bool &is_signed) const;
119
120 bool IsEnumerationType(bool &is_signed) const;
121
122 bool IsIntegerOrEnumerationType(bool &is_signed) const;
123
124 bool IsPolymorphicClass() const;
125
126 /// \param target_type Can pass nullptr.
127 bool IsPossibleDynamicType(CompilerType *target_type, bool check_cplusplus,
128 bool check_objc) const;
129
130 bool IsPointerToScalarType() const;
131
132 bool IsRuntimeGeneratedType() const;
133
134 bool IsPointerType(CompilerType *pointee_type = nullptr) const;
135
136 bool IsPointerOrReferenceType(CompilerType *pointee_type = nullptr) const;
137
138 bool IsReferenceType(CompilerType *pointee_type = nullptr,
139 bool *is_rvalue = nullptr) const;
140
141 bool ShouldTreatScalarValueAsAddress() const;
142
143 bool IsScalarType() const;
144
145 bool IsTypedefType() const;
146
147 bool IsVoidType() const;
148 /// \}
149
150 /// Type Completion.
151 /// \{
152 bool GetCompleteType() const;
153 /// \}
154
155 /// AST related queries.
156 /// \{
157 size_t GetPointerByteSize() const;
158 /// \}
159
160 /// Accessors.
161 /// \{
162 TypeSystem *GetTypeSystem() const { return m_type_system; }
163
164 ConstString GetTypeName() const;
165
166 ConstString GetDisplayTypeName() const;
167
168 uint32_t
169 GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr) const;
170
171 lldb::LanguageType GetMinimumLanguage();
172
173 lldb::opaque_compiler_type_t GetOpaqueQualType() const { return m_type; }
174
175 lldb::TypeClass GetTypeClass() const;
176
177 void SetCompilerType(TypeSystem *type_system,
178 lldb::opaque_compiler_type_t type);
179
180 unsigned GetTypeQualifiers() const;
181 /// \}
182
183 /// Creating related types.
184 /// \{
185 CompilerType GetArrayElementType(ExecutionContextScope *exe_scope) const;
186
187 CompilerType GetArrayType(uint64_t size) const;
188
189 CompilerType GetCanonicalType() const;
190
191 CompilerType GetFullyUnqualifiedType() const;
192
193 CompilerType GetEnumerationIntegerType() const;
194
195 /// Returns -1 if this isn't a function of if the function doesn't
196 /// have a prototype Returns a value >= 0 if there is a prototype.
197 int GetFunctionArgumentCount() const;
198
199 CompilerType GetFunctionArgumentTypeAtIndex(size_t idx) const;
200
201 CompilerType GetFunctionReturnType() const;
202
203 size_t GetNumMemberFunctions() const;
204
205 TypeMemberFunctionImpl GetMemberFunctionAtIndex(size_t idx);
206
207 /// If this type is a reference to a type (L value or R value reference),
208 /// return a new type with the reference removed, else return the current type
209 /// itself.
210 CompilerType GetNonReferenceType() const;
211
212 /// If this type is a pointer type, return the type that the pointer points
213 /// to, else return an invalid type.
214 CompilerType GetPointeeType() const;
215
216 /// Return a new CompilerType that is a pointer to this type
217 CompilerType GetPointerType() const;
218
219 /// Return a new CompilerType that is a L value reference to this type if this
220 /// type is valid and the type system supports L value references, else return
221 /// an invalid type.
222 CompilerType GetLValueReferenceType() const;
223
224 /// Return a new CompilerType that is a R value reference to this type if this
225 /// type is valid and the type system supports R value references, else return
226 /// an invalid type.
227 CompilerType GetRValueReferenceType() const;
228
229 /// Return a new CompilerType adds a const modifier to this type if this type
230 /// is valid and the type system supports const modifiers, else return an
231 /// invalid type.
232 CompilerType AddConstModifier() const;
233
234 /// Return a new CompilerType adds a volatile modifier to this type if this
235 /// type is valid and the type system supports volatile modifiers, else return
236 /// an invalid type.
237 CompilerType AddVolatileModifier() const;
238
239 /// Return a new CompilerType that is the atomic type of this type. If this
240 /// type is not valid or the type system doesn't support atomic types, this
241 /// returns an invalid type.
242 CompilerType GetAtomicType() const;
243
244 /// Return a new CompilerType adds a restrict modifier to this type if this
245 /// type is valid and the type system supports restrict modifiers, else return
246 /// an invalid type.
247 CompilerType AddRestrictModifier() const;
248
249 /// Create a typedef to this type using "name" as the name of the typedef this
250 /// type is valid and the type system supports typedefs, else return an
251 /// invalid type.
252 /// \param payload The typesystem-specific \p lldb::Type payload.
253 CompilerType CreateTypedef(const char *name,
254 const CompilerDeclContext &decl_ctx,
255 uint32_t payload) const;
256
257 /// If the current object represents a typedef type, get the underlying type
258 CompilerType GetTypedefedType() const;
259
260 /// Create related types using the current type's AST
261 CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) const;
262 /// \}
263
264 /// Exploring the type.
265 /// \{
266 struct IntegralTemplateArgument;
267
268 /// Return the size of the type in bytes.
269 llvm::Optional<uint64_t> GetByteSize(ExecutionContextScope *exe_scope) const;
270 /// Return the size of the type in bits.
271 llvm::Optional<uint64_t> GetBitSize(ExecutionContextScope *exe_scope) const;
272
273 lldb::Encoding GetEncoding(uint64_t &count) const;
274
275 lldb::Format GetFormat() const;
276
277 llvm::Optional<size_t>
278 GetTypeBitAlign(ExecutionContextScope *exe_scope) const;
279
280 uint32_t GetNumChildren(bool omit_empty_base_classes,
281 const ExecutionContext *exe_ctx) const;
282
283 lldb::BasicType GetBasicTypeEnumeration() const;
284
285 static lldb::BasicType GetBasicTypeEnumeration(ConstString name);
286
287 /// If this type is an enumeration, iterate through all of its enumerators
288 /// using a callback. If the callback returns true, keep iterating, else abort
289 /// the iteration.
290 void ForEachEnumerator(
291 std::function<bool(const CompilerType &integer_type, ConstString name,
292 const llvm::APSInt &value)> const &callback) const;
293
294 uint32_t GetNumFields() const;
295
296 CompilerType GetFieldAtIndex(size_t idx, std::string &name,
297 uint64_t *bit_offset_ptr,
298 uint32_t *bitfield_bit_size_ptr,
299 bool *is_bitfield_ptr) const;
300
301 uint32_t GetNumDirectBaseClasses() const;
302
303 uint32_t GetNumVirtualBaseClasses() const;
304
305 CompilerType GetDirectBaseClassAtIndex(size_t idx,
306 uint32_t *bit_offset_ptr) const;
307
308 CompilerType GetVirtualBaseClassAtIndex(size_t idx,
309 uint32_t *bit_offset_ptr) const;
310
311 uint32_t GetIndexOfFieldWithName(const char *name,
312 CompilerType *field_compiler_type = nullptr,
313 uint64_t *bit_offset_ptr = nullptr,
314 uint32_t *bitfield_bit_size_ptr = nullptr,
315 bool *is_bitfield_ptr = nullptr) const;
316
317 CompilerType GetChildCompilerTypeAtIndex(
318 ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers,
319 bool omit_empty_base_classes, bool ignore_array_bounds,
320 std::string &child_name, uint32_t &child_byte_size,
321 int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
322 uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
323 bool &child_is_deref_of_parent, ValueObject *valobj,
324 uint64_t &language_flags) const;
325
326 /// Lookup a child given a name. This function will match base class names and
327 /// member member names in "clang_type" only, not descendants.
328 uint32_t GetIndexOfChildWithName(const char *name,
329 bool omit_empty_base_classes) const;
330
331 /// Lookup a child member given a name. This function will match member names
332 /// only and will descend into "clang_type" children in search for the first
333 /// member in this class, or any base class that matches "name".
334 /// TODO: Return all matches for a given name by returning a
335 /// vector<vector<uint32_t>>
336 /// so we catch all names that match a given child name, not just the first.
337 size_t
338 GetIndexOfChildMemberWithName(const char *name, bool omit_empty_base_classes,
339 std::vector<uint32_t> &child_indexes) const;
340
341 size_t GetNumTemplateArguments() const;
342
343 lldb::TemplateArgumentKind GetTemplateArgumentKind(size_t idx) const;
344 CompilerType GetTypeTemplateArgument(size_t idx) const;
345
346 /// Returns the value of the template argument and its type.
347 llvm::Optional<IntegralTemplateArgument>
348 GetIntegralTemplateArgument(size_t idx) const;
349
350 CompilerType GetTypeForFormatters() const;
351
352 LazyBool ShouldPrintAsOneLiner(ValueObject *valobj) const;
353
354 bool IsMeaninglessWithoutDynamicResolution() const;
355 /// \}
356
357 /// Dumping types.
358 /// \{
359#ifndef NDEBUG
360 /// Convenience LLVM-style dump method for use in the debugger only.
361 /// Don't call this function from actual code.
362 LLVM_DUMP_METHOD void dump() const;
363#endif
364
365 void DumpValue(ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
366 const DataExtractor &data, lldb::offset_t data_offset,
367 size_t data_byte_size, uint32_t bitfield_bit_size,
368 uint32_t bitfield_bit_offset, bool show_types,
369 bool show_summary, bool verbose, uint32_t depth);
370
371 bool DumpTypeValue(Stream *s, lldb::Format format, const DataExtractor &data,
372 lldb::offset_t data_offset, size_t data_byte_size,
373 uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
374 ExecutionContextScope *exe_scope);
375
376 void DumpSummary(ExecutionContext *exe_ctx, Stream *s,
377 const DataExtractor &data, lldb::offset_t data_offset,
378 size_t data_byte_size);
379
380 /// Dump to stdout.
381 void DumpTypeDescription(lldb::DescriptionLevel level =
382 lldb::eDescriptionLevelFull) const;
383
384 /// Print a description of the type to a stream. The exact implementation
385 /// varies, but the expectation is that eDescriptionLevelFull returns a
386 /// source-like representation of the type, whereas eDescriptionLevelVerbose
387 /// does a dump of the underlying AST if applicable.
388 void DumpTypeDescription(Stream *s, lldb::DescriptionLevel level =
389 lldb::eDescriptionLevelFull) const;
390 /// \}
391
392 bool GetValueAsScalar(const DataExtractor &data, lldb::offset_t data_offset,
393 size_t data_byte_size, Scalar &value,
394 ExecutionContextScope *exe_scope) const;
395 void Clear() {
396 m_type = nullptr;
397 m_type_system = nullptr;
398 }
399
400private:
401#ifndef NDEBUG
402 /// If the type is valid, ask the TypeSystem to verify the integrity
403 /// of the type to catch CompilerTypes that mix and match invalid
404 /// TypeSystem/Opaque type pairs.
405 bool Verify() const;
406#endif
407
408 lldb::opaque_compiler_type_t m_type = nullptr;
409 TypeSystem *m_type_system = nullptr;
410};
411
412bool operator==(const CompilerType &lhs, const CompilerType &rhs);
413bool operator!=(const CompilerType &lhs, const CompilerType &rhs);
414
415struct CompilerType::IntegralTemplateArgument {
416 llvm::APSInt value;
417 CompilerType type;
418};
419
420} // namespace lldb_private
421
422#endif // LLDB_SYMBOL_COMPILERTYPE_H
423