LLDB  mainline
CompilerType.cpp
Go to the documentation of this file.
1 //===-- CompilerType.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 
10 
11 #include "lldb/Core/Debugger.h"
12 #include "lldb/Core/StreamFile.h"
13 #include "lldb/Symbol/Type.h"
15 #include "lldb/Target/Process.h"
19 #include "lldb/Utility/Scalar.h"
20 #include "lldb/Utility/Stream.h"
22 
23 #include <iterator>
24 #include <mutex>
25 
26 using namespace lldb;
27 using namespace lldb_private;
28 
29 // Tests
30 
31 bool CompilerType::IsAggregateType() const {
32  if (IsValid())
33  return m_type_system->IsAggregateType(m_type);
34  return false;
35 }
36 
37 bool CompilerType::IsAnonymousType() const {
38  if (IsValid())
39  return m_type_system->IsAnonymousType(m_type);
40  return false;
41 }
42 
43 bool CompilerType::IsScopedEnumerationType() const {
44  if (IsValid())
45  return m_type_system->IsScopedEnumerationType(m_type);
46  return false;
47 }
48 
49 bool CompilerType::IsArrayType(CompilerType *element_type_ptr, uint64_t *size,
50  bool *is_incomplete) const {
51  if (IsValid())
52  return m_type_system->IsArrayType(m_type, element_type_ptr, size,
53  is_incomplete);
54 
55  if (element_type_ptr)
56  element_type_ptr->Clear();
57  if (size)
58  *size = 0;
59  if (is_incomplete)
60  *is_incomplete = false;
61  return false;
62 }
63 
64 bool CompilerType::IsVectorType(CompilerType *element_type,
65  uint64_t *size) const {
66  if (IsValid())
67  return m_type_system->IsVectorType(m_type, element_type, size);
68  return false;
69 }
70 
71 bool CompilerType::IsRuntimeGeneratedType() const {
72  if (IsValid())
73  return m_type_system->IsRuntimeGeneratedType(m_type);
74  return false;
75 }
76 
77 bool CompilerType::IsCharType() const {
78  if (IsValid())
79  return m_type_system->IsCharType(m_type);
80  return false;
81 }
82 
83 bool CompilerType::IsCompleteType() const {
84  if (IsValid())
85  return m_type_system->IsCompleteType(m_type);
86  return false;
87 }
88 
89 bool CompilerType::IsConst() const {
90  if (IsValid())
91  return m_type_system->IsConst(m_type);
92  return false;
93 }
94 
95 bool CompilerType::IsCStringType(uint32_t &length) const {
96  if (IsValid())
97  return m_type_system->IsCStringType(m_type, length);
98  return false;
99 }
100 
101 bool CompilerType::IsFunctionType() const {
102  if (IsValid())
103  return m_type_system->IsFunctionType(m_type);
104  return false;
105 }
106 
107 // Used to detect "Homogeneous Floating-point Aggregates"
108 uint32_t
109 CompilerType::IsHomogeneousAggregate(CompilerType *base_type_ptr) const {
110  if (IsValid())
111  return m_type_system->IsHomogeneousAggregate(m_type, base_type_ptr);
112  return 0;
113 }
114 
115 size_t CompilerType::GetNumberOfFunctionArguments() const {
116  if (IsValid())
117  return m_type_system->GetNumberOfFunctionArguments(m_type);
118  return 0;
119 }
120 
122 CompilerType::GetFunctionArgumentAtIndex(const size_t index) const {
123  if (IsValid())
124  return m_type_system->GetFunctionArgumentAtIndex(m_type, index);
125  return CompilerType();
126 }
127 
128 bool CompilerType::IsFunctionPointerType() const {
129  if (IsValid())
130  return m_type_system->IsFunctionPointerType(m_type);
131  return false;
132 }
133 
134 bool CompilerType::IsBlockPointerType(
135  CompilerType *function_pointer_type_ptr) const {
136  if (IsValid())
137  return m_type_system->IsBlockPointerType(m_type, function_pointer_type_ptr);
138  return false;
139 }
140 
141 bool CompilerType::IsIntegerType(bool &is_signed) const {
142  if (IsValid())
143  return m_type_system->IsIntegerType(m_type, is_signed);
144  return false;
145 }
146 
147 bool CompilerType::IsEnumerationType(bool &is_signed) const {
148  if (IsValid())
149  return m_type_system->IsEnumerationType(m_type, is_signed);
150  return false;
151 }
152 
153 bool CompilerType::IsIntegerOrEnumerationType(bool &is_signed) const {
154  return IsIntegerType(is_signed) || IsEnumerationType(is_signed);
155 }
156 
157 bool CompilerType::IsPointerType(CompilerType *pointee_type) const {
158  if (IsValid()) {
159  return m_type_system->IsPointerType(m_type, pointee_type);
160  }
161  if (pointee_type)
162  pointee_type->Clear();
163  return false;
164 }
165 
166 bool CompilerType::IsPointerOrReferenceType(CompilerType *pointee_type) const {
167  if (IsValid()) {
168  return m_type_system->IsPointerOrReferenceType(m_type, pointee_type);
169  }
170  if (pointee_type)
171  pointee_type->Clear();
172  return false;
173 }
174 
175 bool CompilerType::IsReferenceType(CompilerType *pointee_type,
176  bool *is_rvalue) const {
177  if (IsValid()) {
178  return m_type_system->IsReferenceType(m_type, pointee_type, is_rvalue);
179  }
180  if (pointee_type)
181  pointee_type->Clear();
182  return false;
183 }
184 
185 bool CompilerType::ShouldTreatScalarValueAsAddress() const {
186  if (IsValid())
187  return m_type_system->ShouldTreatScalarValueAsAddress(m_type);
188  return false;
189 }
190 
191 bool CompilerType::IsFloatingPointType(uint32_t &count,
192  bool &is_complex) const {
193  if (IsValid()) {
194  return m_type_system->IsFloatingPointType(m_type, count, is_complex);
195  }
196  count = 0;
197  is_complex = false;
198  return false;
199 }
200 
201 bool CompilerType::IsDefined() const {
202  if (IsValid())
203  return m_type_system->IsDefined(m_type);
204  return true;
205 }
206 
207 bool CompilerType::IsPolymorphicClass() const {
208  if (IsValid()) {
209  return m_type_system->IsPolymorphicClass(m_type);
210  }
211  return false;
212 }
213 
214 bool CompilerType::IsPossibleDynamicType(CompilerType *dynamic_pointee_type,
215  bool check_cplusplus,
216  bool check_objc) const {
217  if (IsValid())
218  return m_type_system->IsPossibleDynamicType(m_type, dynamic_pointee_type,
219  check_cplusplus, check_objc);
220  return false;
221 }
222 
223 bool CompilerType::IsScalarType() const {
224  if (!IsValid())
225  return false;
226 
227  return m_type_system->IsScalarType(m_type);
228 }
229 
230 bool CompilerType::IsTypedefType() const {
231  if (!IsValid())
232  return false;
233  return m_type_system->IsTypedefType(m_type);
234 }
235 
236 bool CompilerType::IsVoidType() const {
237  if (!IsValid())
238  return false;
239  return m_type_system->IsVoidType(m_type);
240 }
241 
242 bool CompilerType::IsPointerToScalarType() const {
243  if (!IsValid())
244  return false;
245 
246  return IsPointerType() && GetPointeeType().IsScalarType();
247 }
248 
249 bool CompilerType::IsArrayOfScalarType() const {
250  CompilerType element_type;
251  if (IsArrayType(&element_type))
252  return element_type.IsScalarType();
253  return false;
254 }
255 
256 bool CompilerType::IsBeingDefined() const {
257  if (!IsValid())
258  return false;
259  return m_type_system->IsBeingDefined(m_type);
260 }
261 
262 // Type Completion
263 
264 bool CompilerType::GetCompleteType() const {
265  if (!IsValid())
266  return false;
267  return m_type_system->GetCompleteType(m_type);
268 }
269 
270 // AST related queries
271 size_t CompilerType::GetPointerByteSize() const {
272  if (m_type_system)
273  return m_type_system->GetPointerByteSize();
274  return 0;
275 }
276 
277 ConstString CompilerType::GetTypeName() const {
278  if (IsValid()) {
279  return m_type_system->GetTypeName(m_type);
280  }
281  return ConstString("<invalid>");
282 }
283 
284 ConstString CompilerType::GetDisplayTypeName() const {
285  if (IsValid())
286  return m_type_system->GetDisplayTypeName(m_type);
287  return ConstString("<invalid>");
288 }
289 
290 uint32_t CompilerType::GetTypeInfo(
291  CompilerType *pointee_or_element_compiler_type) const {
292  if (!IsValid())
293  return 0;
294 
295  return m_type_system->GetTypeInfo(m_type, pointee_or_element_compiler_type);
296 }
297 
298 lldb::LanguageType CompilerType::GetMinimumLanguage() {
299  if (!IsValid())
300  return lldb::eLanguageTypeC;
301 
302  return m_type_system->GetMinimumLanguage(m_type);
303 }
304 
305 lldb::TypeClass CompilerType::GetTypeClass() const {
306  if (!IsValid())
307  return lldb::eTypeClassInvalid;
308 
309  return m_type_system->GetTypeClass(m_type);
310 }
311 
312 void CompilerType::SetCompilerType(TypeSystem *type_system,
314  m_type_system = type_system;
315  m_type = type;
316 }
317 
318 unsigned CompilerType::GetTypeQualifiers() const {
319  if (IsValid())
320  return m_type_system->GetTypeQualifiers(m_type);
321  return 0;
322 }
323 
324 // Creating related types
325 
327 CompilerType::GetArrayElementType(ExecutionContextScope *exe_scope) const {
328  if (IsValid()) {
329  return m_type_system->GetArrayElementType(m_type, exe_scope);
330  }
331  return CompilerType();
332 }
333 
334 CompilerType CompilerType::GetArrayType(uint64_t size) const {
335  if (IsValid()) {
336  return m_type_system->GetArrayType(m_type, size);
337  }
338  return CompilerType();
339 }
340 
341 CompilerType CompilerType::GetCanonicalType() const {
342  if (IsValid())
343  return m_type_system->GetCanonicalType(m_type);
344  return CompilerType();
345 }
346 
347 CompilerType CompilerType::GetFullyUnqualifiedType() const {
348  if (IsValid())
349  return m_type_system->GetFullyUnqualifiedType(m_type);
350  return CompilerType();
351 }
352 
353 CompilerType CompilerType::GetEnumerationIntegerType() const {
354  if (IsValid())
355  return m_type_system->GetEnumerationIntegerType(m_type);
356  return CompilerType();
357 }
358 
359 int CompilerType::GetFunctionArgumentCount() const {
360  if (IsValid()) {
361  return m_type_system->GetFunctionArgumentCount(m_type);
362  }
363  return -1;
364 }
365 
366 CompilerType CompilerType::GetFunctionArgumentTypeAtIndex(size_t idx) const {
367  if (IsValid()) {
368  return m_type_system->GetFunctionArgumentTypeAtIndex(m_type, idx);
369  }
370  return CompilerType();
371 }
372 
373 CompilerType CompilerType::GetFunctionReturnType() const {
374  if (IsValid()) {
375  return m_type_system->GetFunctionReturnType(m_type);
376  }
377  return CompilerType();
378 }
379 
380 size_t CompilerType::GetNumMemberFunctions() const {
381  if (IsValid()) {
382  return m_type_system->GetNumMemberFunctions(m_type);
383  }
384  return 0;
385 }
386 
387 TypeMemberFunctionImpl CompilerType::GetMemberFunctionAtIndex(size_t idx) {
388  if (IsValid()) {
389  return m_type_system->GetMemberFunctionAtIndex(m_type, idx);
390  }
391  return TypeMemberFunctionImpl();
392 }
393 
394 CompilerType CompilerType::GetNonReferenceType() const {
395  if (IsValid())
396  return m_type_system->GetNonReferenceType(m_type);
397  return CompilerType();
398 }
399 
400 CompilerType CompilerType::GetPointeeType() const {
401  if (IsValid()) {
402  return m_type_system->GetPointeeType(m_type);
403  }
404  return CompilerType();
405 }
406 
407 CompilerType CompilerType::GetPointerType() const {
408  if (IsValid()) {
409  return m_type_system->GetPointerType(m_type);
410  }
411  return CompilerType();
412 }
413 
414 CompilerType CompilerType::GetLValueReferenceType() const {
415  if (IsValid())
416  return m_type_system->GetLValueReferenceType(m_type);
417  else
418  return CompilerType();
419 }
420 
421 CompilerType CompilerType::GetRValueReferenceType() const {
422  if (IsValid())
423  return m_type_system->GetRValueReferenceType(m_type);
424  else
425  return CompilerType();
426 }
427 
428 CompilerType CompilerType::GetAtomicType() const {
429  if (IsValid())
430  return m_type_system->GetAtomicType(m_type);
431  return CompilerType();
432 }
433 
434 CompilerType CompilerType::AddConstModifier() const {
435  if (IsValid())
436  return m_type_system->AddConstModifier(m_type);
437  else
438  return CompilerType();
439 }
440 
441 CompilerType CompilerType::AddVolatileModifier() const {
442  if (IsValid())
443  return m_type_system->AddVolatileModifier(m_type);
444  else
445  return CompilerType();
446 }
447 
448 CompilerType CompilerType::AddRestrictModifier() const {
449  if (IsValid())
450  return m_type_system->AddRestrictModifier(m_type);
451  else
452  return CompilerType();
453 }
454 
455 CompilerType CompilerType::CreateTypedef(const char *name,
456  const CompilerDeclContext &decl_ctx,
457  uint32_t payload) const {
458  if (IsValid())
459  return m_type_system->CreateTypedef(m_type, name, decl_ctx, payload);
460  else
461  return CompilerType();
462 }
463 
464 CompilerType CompilerType::GetTypedefedType() const {
465  if (IsValid())
466  return m_type_system->GetTypedefedType(m_type);
467  else
468  return CompilerType();
469 }
470 
471 // Create related types using the current type's AST
472 
474 CompilerType::GetBasicTypeFromAST(lldb::BasicType basic_type) const {
475  if (IsValid())
476  return m_type_system->GetBasicTypeFromAST(basic_type);
477  return CompilerType();
478 }
479 // Exploring the type
480 
481 llvm::Optional<uint64_t>
482 CompilerType::GetBitSize(ExecutionContextScope *exe_scope) const {
483  if (IsValid())
484  return m_type_system->GetBitSize(m_type, exe_scope);
485  return {};
486 }
487 
488 llvm::Optional<uint64_t>
489 CompilerType::GetByteSize(ExecutionContextScope *exe_scope) const {
490  if (llvm::Optional<uint64_t> bit_size = GetBitSize(exe_scope))
491  return (*bit_size + 7) / 8;
492  return {};
493 }
494 
495 llvm::Optional<size_t> CompilerType::GetTypeBitAlign(ExecutionContextScope *exe_scope) const {
496  if (IsValid())
497  return m_type_system->GetTypeBitAlign(m_type, exe_scope);
498  return {};
499 }
500 
501 lldb::Encoding CompilerType::GetEncoding(uint64_t &count) const {
502  if (!IsValid())
503  return lldb::eEncodingInvalid;
504 
505  return m_type_system->GetEncoding(m_type, count);
506 }
507 
508 lldb::Format CompilerType::GetFormat() const {
509  if (!IsValid())
510  return lldb::eFormatDefault;
511 
512  return m_type_system->GetFormat(m_type);
513 }
514 
515 uint32_t CompilerType::GetNumChildren(bool omit_empty_base_classes,
516  const ExecutionContext *exe_ctx) const {
517  if (!IsValid())
518  return 0;
519  return m_type_system->GetNumChildren(m_type, omit_empty_base_classes,
520  exe_ctx);
521 }
522 
523 lldb::BasicType CompilerType::GetBasicTypeEnumeration() const {
524  if (IsValid())
525  return m_type_system->GetBasicTypeEnumeration(m_type);
526  return eBasicTypeInvalid;
527 }
528 
529 void CompilerType::ForEachEnumerator(
530  std::function<bool(const CompilerType &integer_type,
531  ConstString name,
532  const llvm::APSInt &value)> const &callback) const {
533  if (IsValid())
534  return m_type_system->ForEachEnumerator(m_type, callback);
535 }
536 
537 uint32_t CompilerType::GetNumFields() const {
538  if (!IsValid())
539  return 0;
540  return m_type_system->GetNumFields(m_type);
541 }
542 
543 CompilerType CompilerType::GetFieldAtIndex(size_t idx, std::string &name,
544  uint64_t *bit_offset_ptr,
545  uint32_t *bitfield_bit_size_ptr,
546  bool *is_bitfield_ptr) const {
547  if (!IsValid())
548  return CompilerType();
549  return m_type_system->GetFieldAtIndex(m_type, idx, name, bit_offset_ptr,
550  bitfield_bit_size_ptr, is_bitfield_ptr);
551 }
552 
553 uint32_t CompilerType::GetNumDirectBaseClasses() const {
554  if (IsValid())
555  return m_type_system->GetNumDirectBaseClasses(m_type);
556  return 0;
557 }
558 
559 uint32_t CompilerType::GetNumVirtualBaseClasses() const {
560  if (IsValid())
561  return m_type_system->GetNumVirtualBaseClasses(m_type);
562  return 0;
563 }
564 
566 CompilerType::GetDirectBaseClassAtIndex(size_t idx,
567  uint32_t *bit_offset_ptr) const {
568  if (IsValid())
569  return m_type_system->GetDirectBaseClassAtIndex(m_type, idx,
570  bit_offset_ptr);
571  return CompilerType();
572 }
573 
575 CompilerType::GetVirtualBaseClassAtIndex(size_t idx,
576  uint32_t *bit_offset_ptr) const {
577  if (IsValid())
578  return m_type_system->GetVirtualBaseClassAtIndex(m_type, idx,
579  bit_offset_ptr);
580  return CompilerType();
581 }
582 
583 uint32_t CompilerType::GetIndexOfFieldWithName(
584  const char *name, CompilerType *field_compiler_type_ptr,
585  uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr,
586  bool *is_bitfield_ptr) const {
587  unsigned count = GetNumFields();
588  std::string field_name;
589  for (unsigned index = 0; index < count; index++) {
590  CompilerType field_compiler_type(
591  GetFieldAtIndex(index, field_name, bit_offset_ptr,
592  bitfield_bit_size_ptr, is_bitfield_ptr));
593  if (strcmp(field_name.c_str(), name) == 0) {
594  if (field_compiler_type_ptr)
595  *field_compiler_type_ptr = field_compiler_type;
596  return index;
597  }
598  }
599  return UINT32_MAX;
600 }
601 
602 CompilerType CompilerType::GetChildCompilerTypeAtIndex(
603  ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers,
604  bool omit_empty_base_classes, bool ignore_array_bounds,
605  std::string &child_name, uint32_t &child_byte_size,
606  int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
607  uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
608  bool &child_is_deref_of_parent, ValueObject *valobj,
609  uint64_t &language_flags) const {
610  if (!IsValid())
611  return CompilerType();
612  return m_type_system->GetChildCompilerTypeAtIndex(
613  m_type, exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
614  ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
615  child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
616  child_is_deref_of_parent, valobj, language_flags);
617 }
618 
619 // Look for a child member (doesn't include base classes, but it does include
620 // their members) in the type hierarchy. Returns an index path into
621 // "clang_type" on how to reach the appropriate member.
622 //
623 // class A
624 // {
625 // public:
626 // int m_a;
627 // int m_b;
628 // };
629 //
630 // class B
631 // {
632 // };
633 //
634 // class C :
635 // public B,
636 // public A
637 // {
638 // };
639 //
640 // If we have a clang type that describes "class C", and we wanted to looked
641 // "m_b" in it:
642 //
643 // With omit_empty_base_classes == false we would get an integer array back
644 // with: { 1, 1 } The first index 1 is the child index for "class A" within
645 // class C The second index 1 is the child index for "m_b" within class A
646 //
647 // With omit_empty_base_classes == true we would get an integer array back
648 // with: { 0, 1 } The first index 0 is the child index for "class A" within
649 // class C (since class B doesn't have any members it doesn't count) The second
650 // index 1 is the child index for "m_b" within class A
651 
652 size_t CompilerType::GetIndexOfChildMemberWithName(
653  const char *name, bool omit_empty_base_classes,
654  std::vector<uint32_t> &child_indexes) const {
655  if (IsValid() && name && name[0]) {
656  return m_type_system->GetIndexOfChildMemberWithName(
657  m_type, name, omit_empty_base_classes, child_indexes);
658  }
659  return 0;
660 }
661 
662 size_t CompilerType::GetNumTemplateArguments() const {
663  if (IsValid()) {
664  return m_type_system->GetNumTemplateArguments(m_type);
665  }
666  return 0;
667 }
668 
669 TemplateArgumentKind CompilerType::GetTemplateArgumentKind(size_t idx) const {
670  if (IsValid())
671  return m_type_system->GetTemplateArgumentKind(m_type, idx);
673 }
674 
675 CompilerType CompilerType::GetTypeTemplateArgument(size_t idx) const {
676  if (IsValid()) {
677  return m_type_system->GetTypeTemplateArgument(m_type, idx);
678  }
679  return CompilerType();
680 }
681 
682 llvm::Optional<CompilerType::IntegralTemplateArgument>
683 CompilerType::GetIntegralTemplateArgument(size_t idx) const {
684  if (IsValid())
685  return m_type_system->GetIntegralTemplateArgument(m_type, idx);
686  return llvm::None;
687 }
688 
689 CompilerType CompilerType::GetTypeForFormatters() const {
690  if (IsValid())
691  return m_type_system->GetTypeForFormatters(m_type);
692  return CompilerType();
693 }
694 
695 LazyBool CompilerType::ShouldPrintAsOneLiner(ValueObject *valobj) const {
696  if (IsValid())
697  return m_type_system->ShouldPrintAsOneLiner(m_type, valobj);
698  return eLazyBoolCalculate;
699 }
700 
701 bool CompilerType::IsMeaninglessWithoutDynamicResolution() const {
702  if (IsValid())
703  return m_type_system->IsMeaninglessWithoutDynamicResolution(m_type);
704  return false;
705 }
706 
707 // Get the index of the child of "clang_type" whose name matches. This function
708 // doesn't descend into the children, but only looks one level deep and name
709 // matches can include base class names.
710 
711 uint32_t
712 CompilerType::GetIndexOfChildWithName(const char *name,
713  bool omit_empty_base_classes) const {
714  if (IsValid() && name && name[0]) {
715  return m_type_system->GetIndexOfChildWithName(m_type, name,
716  omit_empty_base_classes);
717  }
718  return UINT32_MAX;
719 }
720 
721 // Dumping types
722 
724  lldb::Format format, const DataExtractor &data,
725  lldb::offset_t data_byte_offset,
726  size_t data_byte_size, uint32_t bitfield_bit_size,
727  uint32_t bitfield_bit_offset, bool show_types,
728  bool show_summary, bool verbose, uint32_t depth) {
729  if (!IsValid())
730  return;
731  m_type_system->DumpValue(m_type, exe_ctx, s, format, data, data_byte_offset,
732  data_byte_size, bitfield_bit_size,
733  bitfield_bit_offset, show_types, show_summary,
734  verbose, depth);
735 }
736 
737 bool CompilerType::DumpTypeValue(Stream *s, lldb::Format format,
738  const DataExtractor &data,
739  lldb::offset_t byte_offset, size_t byte_size,
740  uint32_t bitfield_bit_size,
741  uint32_t bitfield_bit_offset,
742  ExecutionContextScope *exe_scope) {
743  if (!IsValid())
744  return false;
745  return m_type_system->DumpTypeValue(m_type, s, format, data, byte_offset,
746  byte_size, bitfield_bit_size,
747  bitfield_bit_offset, exe_scope);
748 }
749 
750 void CompilerType::DumpSummary(ExecutionContext *exe_ctx, Stream *s,
751  const DataExtractor &data,
752  lldb::offset_t data_byte_offset,
753  size_t data_byte_size) {
754  if (IsValid())
755  m_type_system->DumpSummary(m_type, exe_ctx, s, data, data_byte_offset,
756  data_byte_size);
757 }
758 
759 void CompilerType::DumpTypeDescription(lldb::DescriptionLevel level) const {
760  if (IsValid())
761  m_type_system->DumpTypeDescription(m_type, level);
762 }
763 
764 void CompilerType::DumpTypeDescription(Stream *s,
765  lldb::DescriptionLevel level) const {
766  if (IsValid()) {
767  m_type_system->DumpTypeDescription(m_type, s, level);
768  }
769 }
770 
771 #ifndef NDEBUG
772 LLVM_DUMP_METHOD void CompilerType::dump() const {
773  if (IsValid())
774  m_type_system->dump(m_type);
775  else
776  llvm::errs() << "<invalid>\n";
777 }
778 #endif
779 
780 bool CompilerType::GetValueAsScalar(const lldb_private::DataExtractor &data,
781  lldb::offset_t data_byte_offset,
782  size_t data_byte_size, Scalar &value,
783  ExecutionContextScope *exe_scope) const {
784  if (!IsValid())
785  return false;
786 
787  if (IsAggregateType()) {
788  return false; // Aggregate types don't have scalar values
789  } else {
790  uint64_t count = 0;
791  lldb::Encoding encoding = GetEncoding(count);
792 
793  if (encoding == lldb::eEncodingInvalid || count != 1)
794  return false;
795 
796  llvm::Optional<uint64_t> byte_size = GetByteSize(exe_scope);
797  if (!byte_size)
798  return false;
799  lldb::offset_t offset = data_byte_offset;
800  switch (encoding) {
802  break;
804  break;
805  case lldb::eEncodingUint:
806  if (*byte_size <= sizeof(unsigned long long)) {
807  uint64_t uval64 = data.GetMaxU64(&offset, *byte_size);
808  if (*byte_size <= sizeof(unsigned int)) {
809  value = (unsigned int)uval64;
810  return true;
811  } else if (*byte_size <= sizeof(unsigned long)) {
812  value = (unsigned long)uval64;
813  return true;
814  } else if (*byte_size <= sizeof(unsigned long long)) {
815  value = (unsigned long long)uval64;
816  return true;
817  } else
818  value.Clear();
819  }
820  break;
821 
822  case lldb::eEncodingSint:
823  if (*byte_size <= sizeof(long long)) {
824  int64_t sval64 = data.GetMaxS64(&offset, *byte_size);
825  if (*byte_size <= sizeof(int)) {
826  value = (int)sval64;
827  return true;
828  } else if (*byte_size <= sizeof(long)) {
829  value = (long)sval64;
830  return true;
831  } else if (*byte_size <= sizeof(long long)) {
832  value = (long long)sval64;
833  return true;
834  } else
835  value.Clear();
836  }
837  break;
838 
840  if (*byte_size <= sizeof(long double)) {
841  uint32_t u32;
842  uint64_t u64;
843  if (*byte_size == sizeof(float)) {
844  if (sizeof(float) == sizeof(uint32_t)) {
845  u32 = data.GetU32(&offset);
846  value = *((float *)&u32);
847  return true;
848  } else if (sizeof(float) == sizeof(uint64_t)) {
849  u64 = data.GetU64(&offset);
850  value = *((float *)&u64);
851  return true;
852  }
853  } else if (*byte_size == sizeof(double)) {
854  if (sizeof(double) == sizeof(uint32_t)) {
855  u32 = data.GetU32(&offset);
856  value = *((double *)&u32);
857  return true;
858  } else if (sizeof(double) == sizeof(uint64_t)) {
859  u64 = data.GetU64(&offset);
860  value = *((double *)&u64);
861  return true;
862  }
863  } else if (*byte_size == sizeof(long double)) {
864  if (sizeof(long double) == sizeof(uint32_t)) {
865  u32 = data.GetU32(&offset);
866  value = *((long double *)&u32);
867  return true;
868  } else if (sizeof(long double) == sizeof(uint64_t)) {
869  u64 = data.GetU64(&offset);
870  value = *((long double *)&u64);
871  return true;
872  }
873  }
874  }
875  break;
876  }
877  }
878  return false;
879 }
880 
881 #ifndef NDEBUG
882 bool CompilerType::Verify() const {
883  return !IsValid() || m_type_system->Verify(m_type);
884 }
885 #endif
886 
888  const lldb_private::CompilerType &rhs) {
889  return lhs.GetTypeSystem() == rhs.GetTypeSystem() &&
890  lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType();
891 }
892 
894  const lldb_private::CompilerType &rhs) {
895  return !(lhs == rhs);
896 }
lldb_private::CompilerType::GetNonReferenceType
CompilerType GetNonReferenceType() const
If this type is a reference to a type (L value or R value reference), return a new type with the refe...
Definition: CompilerType.cpp:394
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::TypeSystem::GetTypeQualifiers
virtual unsigned GetTypeQualifiers(lldb::opaque_compiler_type_t type)=0
Scalar.h
lldb::Format
Format
Display format definitions.
Definition: lldb-enumerations.h:155
lldb::eBasicTypeInvalid
@ eBasicTypeInvalid
Definition: lldb-enumerations.h:742
lldb_private::Scalar
Definition: Scalar.h:34
lldb::eEncodingIEEE754
@ eEncodingIEEE754
float
Definition: lldb-enumerations.h:150
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb_private::CompilerType::GetOpaqueQualType
lldb::opaque_compiler_type_t GetOpaqueQualType() const
Definition: CompilerType.h:173
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
lldb_private::CompilerType::AddVolatileModifier
CompilerType AddVolatileModifier() const
Return a new CompilerType adds a volatile modifier to this type if this type is valid and the type sy...
Definition: CompilerType.cpp:441
lldb_private::Stream
Definition: Stream.h:28
lldb::BasicType
BasicType
Basic types enumeration for the public API SBType::GetBasicType().
Definition: lldb-enumerations.h:741
lldb_private::LazyBool
LazyBool
Definition: lldb-private-enumerations.h:115
lldb_private::CompilerType::GetVirtualBaseClassAtIndex
CompilerType GetVirtualBaseClassAtIndex(size_t idx, uint32_t *bit_offset_ptr) const
Definition: CompilerType.cpp:575
lldb_private::CompilerType::GetFunctionArgumentTypeAtIndex
CompilerType GetFunctionArgumentTypeAtIndex(size_t idx) const
Definition: CompilerType.cpp:366
Debugger.h
lldb_private::DataExtractor::GetU64
uint64_t GetU64(lldb::offset_t *offset_ptr) const
Extract a uint64_t value from *offset_ptr.
Definition: DataExtractor.cpp:476
lldb_private::CompilerType::GetFunctionArgumentAtIndex
CompilerType GetFunctionArgumentAtIndex(const size_t index) const
Definition: CompilerType.cpp:122
Process.h
lldb_private::CompilerType::GetTypeTemplateArgument
CompilerType GetTypeTemplateArgument(size_t idx) const
Definition: CompilerType.cpp:675
lldb_private::operator==
bool operator==(const Address &lhs, const Address &rhs)
Definition: Address.cpp:999
lldb::eEncodingInvalid
@ eEncodingInvalid
Definition: lldb-enumerations.h:147
lldb_private::CompilerType::GetPointeeType
CompilerType GetPointeeType() const
If this type is a pointer type, return the type that the pointer points to, else return an invalid ty...
Definition: CompilerType.cpp:400
lldb::eEncodingSint
@ eEncodingSint
signed integer
Definition: lldb-enumerations.h:149
lldb_private::CompilerType::Clear
void Clear()
Definition: CompilerType.h:395
lldb_private::DataExtractor
Definition: DataExtractor.h:48
lldb_private::ExecutionContextScope
Definition: ExecutionContextScope.h:32
lldb_private::CompilerType::CreateTypedef
CompilerType CreateTypedef(const char *name, const CompilerDeclContext &decl_ctx, uint32_t payload) const
Create a typedef to this type using "name" as the name of the typedef this type is valid and the type...
Definition: CompilerType.cpp:455
lldb_private::CompilerType::GetAtomicType
CompilerType GetAtomicType() const
Return a new CompilerType that is the atomic type of this type.
Definition: CompilerType.cpp:428
lldb_private::DataExtractor::GetMaxS64
int64_t GetMaxS64(lldb::offset_t *offset_ptr, size_t byte_size) const
Extract an signed integer of size byte_size from *offset_ptr.
Definition: DataExtractor.cpp:570
StreamString.h
Type.h
lldb::eEncodingUint
@ eEncodingUint
unsigned integer
Definition: lldb-enumerations.h:148
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::CompilerType::AddConstModifier
CompilerType AddConstModifier() const
Return a new CompilerType adds a const modifier to this type if this type is valid and the type syste...
Definition: CompilerType.cpp:434
lldb_private::Scalar::Clear
void Clear()
Definition: Scalar.h:97
lldb_private::CompilerType::GetArrayElementType
CompilerType GetArrayElementType(ExecutionContextScope *exe_scope) const
Creating related types.
Definition: CompilerType.cpp:327
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:39
lldb_private::CompilerType::GetFunctionReturnType
CompilerType GetFunctionReturnType() const
Definition: CompilerType.cpp:373
lldb::TemplateArgumentKind
TemplateArgumentKind
Definition: lldb-enumerations.h:814
CompilerType.h
lldb_private::CompilerDeclContext
Represents a generic declaration context in a program.
Definition: CompilerDeclContext.h:30
lldb_private::CompilerType::GetLValueReferenceType
CompilerType GetLValueReferenceType() const
Return a new CompilerType that is a L value reference to this type if this type is valid and the type...
Definition: CompilerType.cpp:414
lldb_private::operator!=
bool operator!=(const Address &lhs, const Address &rhs)
Definition: Address.cpp:1005
lldb_private::CompilerType::IsScalarType
bool IsScalarType() const
Definition: CompilerType.cpp:223
StreamFile.h
lldb::eEncodingVector
@ eEncodingVector
vector registers
Definition: lldb-enumerations.h:151
lldb_private::ValueObject
ValueObject:
Definition: ValueObject.h:105
lldb_private::CompilerType::GetPointerType
CompilerType GetPointerType() const
Return a new CompilerType that is a pointer to this type.
Definition: CompilerType.cpp:407
lldb::eTemplateArgumentKindNull
@ eTemplateArgumentKindNull
Definition: lldb-enumerations.h:815
uint32_t
lldb_private::CompilerType::GetDirectBaseClassAtIndex
CompilerType GetDirectBaseClassAtIndex(size_t idx, uint32_t *bit_offset_ptr) const
Definition: CompilerType.cpp:566
lldb_private::DataExtractor::GetMaxU64
uint64_t GetMaxU64(lldb::offset_t *offset_ptr, size_t byte_size) const
Extract an unsigned integer of size byte_size from *offset_ptr.
Definition: DataExtractor.cpp:526
lldb_private::CompilerType::GetTypeSystem
TypeSystem * GetTypeSystem() const
Accessors.
Definition: CompilerType.h:162
lldb_private::CompilerType::GetCanonicalType
CompilerType GetCanonicalType() const
Definition: CompilerType.cpp:341
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb_private::CompilerType::AddRestrictModifier
CompilerType AddRestrictModifier() const
Return a new CompilerType adds a restrict modifier to this type if this type is valid and the type sy...
Definition: CompilerType.cpp:448
lldb_private::DataExtractor::GetU32
uint32_t GetU32(lldb::offset_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
Definition: DataExtractor.cpp:427
lldb::Encoding
Encoding
Register encoding definitions.
Definition: lldb-enumerations.h:146
lldb_private::CompilerType::GetBasicTypeFromAST
CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) const
Create related types using the current type's AST.
Definition: CompilerType.cpp:474
lldb_private::CompilerType::GetTypedefedType
CompilerType GetTypedefedType() const
If the current object represents a typedef type, get the underlying type.
Definition: CompilerType.cpp:464
DataExtractor.h
lldb_private::CompilerType::GetEnumerationIntegerType
CompilerType GetEnumerationIntegerType() const
Definition: CompilerType.cpp:353
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
lldb::eLanguageTypeC
@ eLanguageTypeC
Non-standardized C, such as K&R.
Definition: lldb-enumerations.h:439
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::eLazyBoolCalculate
@ eLazyBoolCalculate
Definition: lldb-private-enumerations.h:115
lldb_private::TypeSystem
Interface for representing a type system.
Definition: TypeSystem.h:71
ConstString.h
Stream.h
lldb_private::TypeMemberFunctionImpl
Definition: Type.h:435
lldb_private::CompilerType::GetTypeForFormatters
CompilerType GetTypeForFormatters() const
Definition: CompilerType.cpp:689
lldb
Definition: SBAddress.h:15
lldb::eFormatDefault
@ eFormatDefault
Definition: lldb-enumerations.h:156
lldb::opaque_compiler_type_t
void * opaque_compiler_type_t
Definition: lldb-types.h:90
ExecutionContext.h
lldb_private::CompilerType::GetRValueReferenceType
CompilerType GetRValueReferenceType() const
Return a new CompilerType that is a R value reference to this type if this type is valid and the type...
Definition: CompilerType.cpp:421
DataBufferHeap.h
lldb_private::CompilerType::GetFullyUnqualifiedType
CompilerType GetFullyUnqualifiedType() const
Definition: CompilerType.cpp:347
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
DumpValue
static bool DumpValue(Stream &s, const SymbolContext *sc, const ExecutionContext *exe_ctx, const FormatEntity::Entry &entry, ValueObject *valobj)
Definition: FormatEntity.cpp:673
lldb_private::CompilerType::GetArrayType
CompilerType GetArrayType(uint64_t size) const
Definition: CompilerType.cpp:334