Bug Summary

File:tools/lldb/source/Symbol/ClangASTType.cpp
Location:line 5373, column 21
Description:Called C++ object pointer is null

Annotated Source Code

1//===-- ClangASTType.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#include "lldb/lldb-python.h"
11
12#include "lldb/Symbol/ClangASTType.h"
13
14#include "clang/AST/ASTConsumer.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/Attr.h"
17#include "clang/AST/CXXInheritance.h"
18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclCXX.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/AST/DeclGroup.h"
22#include "clang/AST/DeclTemplate.h"
23#include "clang/AST/RecordLayout.h"
24#include "clang/AST/Type.h"
25#include "clang/AST/VTableBuilder.h"
26
27#include "clang/Basic/Builtins.h"
28#include "clang/Basic/IdentifierTable.h"
29#include "clang/Basic/LangOptions.h"
30#include "clang/Basic/SourceManager.h"
31#include "clang/Basic/TargetInfo.h"
32
33#include "llvm/Support/FormattedStream.h"
34#include "llvm/Support/raw_ostream.h"
35
36#include "lldb/Core/ConstString.h"
37#include "lldb/Core/DataBufferHeap.h"
38#include "lldb/Core/DataExtractor.h"
39#include "lldb/Core/Debugger.h"
40#include "lldb/Core/Scalar.h"
41#include "lldb/Core/Stream.h"
42#include "lldb/Core/StreamFile.h"
43#include "lldb/Core/StreamString.h"
44#include "lldb/Symbol/ClangASTContext.h"
45#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
46#include "lldb/Symbol/VerifyDecl.h"
47#include "lldb/Target/ExecutionContext.h"
48#include "lldb/Target/Process.h"
49
50#include <iterator>
51#include <mutex>
52
53using namespace lldb;
54using namespace lldb_private;
55
56static bool
57GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type, bool allow_completion = true)
58{
59 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
60 switch (type_class)
61 {
62 case clang::Type::ConstantArray:
63 case clang::Type::IncompleteArray:
64 case clang::Type::VariableArray:
65 {
66 const clang::ArrayType *array_type = llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr());
67
68 if (array_type)
69 return GetCompleteQualType (ast, array_type->getElementType(), allow_completion);
70 }
71 break;
72
73 case clang::Type::Record:
74 case clang::Type::Enum:
75 {
76 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
77 if (tag_type)
78 {
79 clang::TagDecl *tag_decl = tag_type->getDecl();
80 if (tag_decl)
81 {
82 if (tag_decl->isCompleteDefinition())
83 return true;
84
85 if (!allow_completion)
86 return false;
87
88 if (tag_decl->hasExternalLexicalStorage())
89 {
90 if (ast)
91 {
92 clang::ExternalASTSource *external_ast_source = ast->getExternalSource();
93 if (external_ast_source)
94 {
95 external_ast_source->CompleteType(tag_decl);
96 return !tag_type->isIncompleteType();
97 }
98 }
99 }
100 return false;
101 }
102 }
103
104 }
105 break;
106
107 case clang::Type::ObjCObject:
108 case clang::Type::ObjCInterface:
109 {
110 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
111 if (objc_class_type)
112 {
113 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
114 // We currently can't complete objective C types through the newly added ASTContext
115 // because it only supports TagDecl objects right now...
116 if (class_interface_decl)
117 {
118 if (class_interface_decl->getDefinition())
119 return true;
120
121 if (!allow_completion)
122 return false;
123
124 if (class_interface_decl->hasExternalLexicalStorage())
125 {
126 if (ast)
127 {
128 clang::ExternalASTSource *external_ast_source = ast->getExternalSource();
129 if (external_ast_source)
130 {
131 external_ast_source->CompleteType (class_interface_decl);
132 return !objc_class_type->isIncompleteType();
133 }
134 }
135 }
136 return false;
137 }
138 }
139 }
140 break;
141
142 case clang::Type::Typedef:
143 return GetCompleteQualType (ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType(), allow_completion);
144
145 case clang::Type::Elaborated:
146 return GetCompleteQualType (ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType(), allow_completion);
147
148 case clang::Type::Paren:
149 return GetCompleteQualType (ast, llvm::cast<clang::ParenType>(qual_type)->desugar(), allow_completion);
150
151 default:
152 break;
153 }
154
155 return true;
156}
157
158static clang::ObjCIvarDecl::AccessControl
159ConvertAccessTypeToObjCIvarAccessControl (AccessType access)
160{
161 switch (access)
162 {
163 case eAccessNone: return clang::ObjCIvarDecl::None;
164 case eAccessPublic: return clang::ObjCIvarDecl::Public;
165 case eAccessPrivate: return clang::ObjCIvarDecl::Private;
166 case eAccessProtected: return clang::ObjCIvarDecl::Protected;
167 case eAccessPackage: return clang::ObjCIvarDecl::Package;
168 }
169 return clang::ObjCIvarDecl::None;
170}
171
172//----------------------------------------------------------------------
173// Tests
174//----------------------------------------------------------------------
175
176ClangASTType::ClangASTType (clang::ASTContext *ast,
177 clang::QualType qual_type) :
178 m_type (qual_type.getAsOpaquePtr()),
179 m_ast (ast)
180{
181}
182
183ClangASTType::~ClangASTType()
184{
185}
186
187//----------------------------------------------------------------------
188// Tests
189//----------------------------------------------------------------------
190
191bool
192ClangASTType::IsAggregateType () const
193{
194 if (!IsValid())
195 return false;
196
197 clang::QualType qual_type (GetCanonicalQualType());
198
199 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
200 switch (type_class)
201 {
202 case clang::Type::IncompleteArray:
203 case clang::Type::VariableArray:
204 case clang::Type::ConstantArray:
205 case clang::Type::ExtVector:
206 case clang::Type::Vector:
207 case clang::Type::Record:
208 case clang::Type::ObjCObject:
209 case clang::Type::ObjCInterface:
210 return true;
211 case clang::Type::Elaborated:
212 return ClangASTType(m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsAggregateType();
213 case clang::Type::Typedef:
214 return ClangASTType(m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsAggregateType();
215 case clang::Type::Paren:
216 return ClangASTType(m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsAggregateType();
217 default:
218 break;
219 }
220 // The clang type does have a value
221 return false;
222}
223
224bool
225ClangASTType::IsArrayType (ClangASTType *element_type_ptr,
226 uint64_t *size,
227 bool *is_incomplete) const
228{
229 if (IsValid())
230 {
231 clang::QualType qual_type (GetCanonicalQualType());
232
233 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
234 switch (type_class)
235 {
236 default:
237 break;
238
239 case clang::Type::ConstantArray:
240 if (element_type_ptr)
241 element_type_ptr->SetClangType (m_ast, llvm::cast<clang::ConstantArrayType>(qual_type)->getElementType());
242 if (size)
243 *size = llvm::cast<clang::ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULLONG_MAX(9223372036854775807LL*2ULL+1ULL));
244 return true;
245
246 case clang::Type::IncompleteArray:
247 if (element_type_ptr)
248 element_type_ptr->SetClangType (m_ast, llvm::cast<clang::IncompleteArrayType>(qual_type)->getElementType());
249 if (size)
250 *size = 0;
251 if (is_incomplete)
252 *is_incomplete = true;
253 return true;
254
255 case clang::Type::VariableArray:
256 if (element_type_ptr)
257 element_type_ptr->SetClangType (m_ast, llvm::cast<clang::VariableArrayType>(qual_type)->getElementType());
258 if (size)
259 *size = 0;
260 return true;
261
262 case clang::Type::DependentSizedArray:
263 if (element_type_ptr)
264 element_type_ptr->SetClangType (m_ast, llvm::cast<clang::DependentSizedArrayType>(qual_type)->getElementType());
265 if (size)
266 *size = 0;
267 return true;
268
269 case clang::Type::Typedef:
270 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsArrayType (element_type_ptr,
271 size,
272 is_incomplete);
273 case clang::Type::Elaborated:
274 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsArrayType (element_type_ptr,
275 size,
276 is_incomplete);
277 case clang::Type::Paren:
278 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsArrayType (element_type_ptr,
279 size,
280 is_incomplete);
281 }
282 }
283 if (element_type_ptr)
284 element_type_ptr->Clear();
285 if (size)
286 *size = 0;
287 if (is_incomplete)
288 *is_incomplete = false;
289 return 0;
290}
291
292bool
293ClangASTType::IsRuntimeGeneratedType () const
294{
295 if (!IsValid())
296 return false;
297
298 clang::DeclContext* decl_ctx = GetDeclContextForType();
299 if (!decl_ctx)
300 return false;
301
302 if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx))
303 return false;
304
305 clang::ObjCInterfaceDecl *result_iface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
306
307 ClangASTMetadata* ast_metadata = ClangASTContext::GetMetadata(m_ast, result_iface_decl);
308 if (!ast_metadata)
309 return false;
310 return (ast_metadata->GetISAPtr() != 0);
311}
312
313bool
314ClangASTType::IsCharType () const
315{
316 if (!IsValid())
317 return false;
318 return GetQualType().getUnqualifiedType()->isCharType();
319}
320
321
322bool
323ClangASTType::IsCompleteType () const
324{
325 if (!IsValid())
326 return false;
327 const bool allow_completion = false;
328 return GetCompleteQualType (m_ast, GetQualType(), allow_completion);
329}
330
331bool
332ClangASTType::IsConst() const
333{
334 return GetQualType().isConstQualified();
335}
336
337bool
338ClangASTType::IsCStringType (uint32_t &length) const
339{
340 ClangASTType pointee_or_element_clang_type;
341 length = 0;
342 Flags type_flags (GetTypeInfo (&pointee_or_element_clang_type));
343
344 if (!pointee_or_element_clang_type.IsValid())
345 return false;
346
347 if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer))
348 {
349 if (pointee_or_element_clang_type.IsCharType())
350 {
351 if (type_flags.Test (eTypeIsArray))
352 {
353 // We know the size of the array and it could be a C string
354 // since it is an array of characters
355 length = llvm::cast<clang::ConstantArrayType>(GetCanonicalQualType().getTypePtr())->getSize().getLimitedValue();
356 }
357 return true;
358
359 }
360 }
361 return false;
362}
363
364bool
365ClangASTType::IsFunctionType (bool *is_variadic_ptr) const
366{
367 if (IsValid())
368 {
369 clang::QualType qual_type (GetCanonicalQualType());
370
371 if (qual_type->isFunctionType())
372 {
373 if (is_variadic_ptr)
374 {
375 const clang::FunctionProtoType *function_proto_type = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
376 if (function_proto_type)
377 *is_variadic_ptr = function_proto_type->isVariadic();
378 else
379 *is_variadic_ptr = false;
380 }
381 return true;
382 }
383
384 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
385 switch (type_class)
386 {
387 default:
388 break;
389 case clang::Type::Typedef:
390 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionType();
391 case clang::Type::Elaborated:
392 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsFunctionType();
393 case clang::Type::Paren:
394 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsFunctionType();
395
396 case clang::Type::LValueReference:
397 case clang::Type::RValueReference:
398 {
399 const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
400 if (reference_type)
401 return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionType();
402 }
403 break;
404 }
405 }
406 return false;
407}
408
409// Used to detect "Homogeneous Floating-point Aggregates"
410uint32_t
411ClangASTType::IsHomogeneousAggregate (ClangASTType* base_type_ptr) const
412{
413 if (!IsValid())
414 return 0;
415
416 clang::QualType qual_type(GetCanonicalQualType());
417 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
418 switch (type_class)
419 {
420 case clang::Type::Record:
421 if (GetCompleteType ())
422 {
423 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
424 if (cxx_record_decl)
425 {
426 if (cxx_record_decl->getNumBases() ||
427 cxx_record_decl->isDynamicClass())
428 return 0;
429 }
430 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
431 if (record_type)
432 {
433 const clang::RecordDecl *record_decl = record_type->getDecl();
434 if (record_decl)
435 {
436 // We are looking for a structure that contains only floating point types
437 clang::RecordDecl::field_iterator field_pos, field_end = record_decl->field_end();
438 uint32_t num_fields = 0;
439 bool is_hva = false;
440 bool is_hfa = false;
441 clang::QualType base_qual_type;
442 for (field_pos = record_decl->field_begin(); field_pos != field_end; ++field_pos)
443 {
444 clang::QualType field_qual_type = field_pos->getType();
445 if (field_qual_type->isFloatingType())
446 {
447 if (field_qual_type->isComplexType())
448 return 0;
449 else
450 {
451 if (num_fields == 0)
452 base_qual_type = field_qual_type;
453 else
454 {
455 if (is_hva)
456 return 0;
457 is_hfa = true;
458 if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
459 return 0;
460 }
461 }
462 }
463 else if (field_qual_type->isVectorType() || field_qual_type->isExtVectorType())
464 {
465 const clang::VectorType *array = llvm::cast<clang::VectorType>(field_qual_type.getTypePtr());
466 if (array && array->getNumElements() <= 4)
467 {
468 if (num_fields == 0)
469 base_qual_type = array->getElementType();
470 else
471 {
472 if (is_hfa)
473 return 0;
474 is_hva = true;
475 if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
476 return 0;
477 }
478 }
479 else
480 return 0;
481 }
482 else
483 return 0;
484 ++num_fields;
485 }
486 if (base_type_ptr)
487 *base_type_ptr = ClangASTType (m_ast, base_qual_type);
488 return num_fields;
489 }
490 }
491 }
492 break;
493
494 case clang::Type::Typedef:
495 return ClangASTType(m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsHomogeneousAggregate (base_type_ptr);
496
497 case clang::Type::Elaborated:
498 return ClangASTType(m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsHomogeneousAggregate (base_type_ptr);
499 default:
500 break;
501 }
502 return 0;
503}
504
505size_t
506ClangASTType::GetNumberOfFunctionArguments () const
507{
508 if (IsValid())
509 {
510 clang::QualType qual_type (GetCanonicalQualType());
511 const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
512 if (func)
513 return func->getNumParams();
514 }
515 return 0;
516}
517
518ClangASTType
519ClangASTType::GetFunctionArgumentAtIndex (const size_t index) const
520{
521 if (IsValid())
522 {
523 clang::QualType qual_type (GetCanonicalQualType());
524 const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
525 if (func)
526 {
527 if (index < func->getNumParams())
528 return ClangASTType(m_ast, func->getParamType(index).getAsOpaquePtr());
529 }
530 }
531 return ClangASTType();
532}
533
534bool
535ClangASTType::IsFunctionPointerType () const
536{
537 if (IsValid())
538 {
539 clang::QualType qual_type (GetCanonicalQualType());
540
541 if (qual_type->isFunctionPointerType())
542 return true;
543
544 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
545 switch (type_class)
546 {
547 default:
548 break;
549 case clang::Type::Typedef:
550 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionPointerType();
551 case clang::Type::Elaborated:
552 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsFunctionPointerType();
553 case clang::Type::Paren:
554 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsFunctionPointerType();
555
556 case clang::Type::LValueReference:
557 case clang::Type::RValueReference:
558 {
559 const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
560 if (reference_type)
561 return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionPointerType();
562 }
563 break;
564 }
565 }
566 return false;
567
568}
569
570bool
571ClangASTType::IsIntegerType (bool &is_signed) const
572{
573 if (!IsValid())
574 return false;
575
576 clang::QualType qual_type (GetCanonicalQualType());
577 const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
578
579 if (builtin_type)
580 {
581 if (builtin_type->isInteger())
582 {
583 is_signed = builtin_type->isSignedInteger();
584 return true;
585 }
586 }
587
588 return false;
589}
590
591bool
592ClangASTType::IsPointerType (ClangASTType *pointee_type) const
593{
594 if (IsValid())
595 {
596 clang::QualType qual_type (GetCanonicalQualType());
597 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
598 switch (type_class)
599 {
600 case clang::Type::Builtin:
601 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
602 {
603 default:
604 break;
605 case clang::BuiltinType::ObjCId:
606 case clang::BuiltinType::ObjCClass:
607 return true;
608 }
609 return false;
610 case clang::Type::ObjCObjectPointer:
611 if (pointee_type)
612 pointee_type->SetClangType (m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType());
613 return true;
614 case clang::Type::BlockPointer:
615 if (pointee_type)
616 pointee_type->SetClangType (m_ast, llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType());
617 return true;
618 case clang::Type::Pointer:
619 if (pointee_type)
620 pointee_type->SetClangType (m_ast, llvm::cast<clang::PointerType>(qual_type)->getPointeeType());
621 return true;
622 case clang::Type::MemberPointer:
623 if (pointee_type)
624 pointee_type->SetClangType (m_ast, llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType());
625 return true;
626 case clang::Type::Typedef:
627 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerType(pointee_type);
628 case clang::Type::Elaborated:
629 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsPointerType(pointee_type);
630 case clang::Type::Paren:
631 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsPointerType(pointee_type);
632 default:
633 break;
634 }
635 }
636 if (pointee_type)
637 pointee_type->Clear();
638 return false;
639}
640
641
642bool
643ClangASTType::IsPointerOrReferenceType (ClangASTType *pointee_type) const
644{
645 if (IsValid())
646 {
647 clang::QualType qual_type (GetCanonicalQualType());
648 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
649 switch (type_class)
650 {
651 case clang::Type::Builtin:
652 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
653 {
654 default:
655 break;
656 case clang::BuiltinType::ObjCId:
657 case clang::BuiltinType::ObjCClass:
658 return true;
659 }
660 return false;
661 case clang::Type::ObjCObjectPointer:
662 if (pointee_type)
663 pointee_type->SetClangType(m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType());
664 return true;
665 case clang::Type::BlockPointer:
666 if (pointee_type)
667 pointee_type->SetClangType(m_ast, llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType());
668 return true;
669 case clang::Type::Pointer:
670 if (pointee_type)
671 pointee_type->SetClangType(m_ast, llvm::cast<clang::PointerType>(qual_type)->getPointeeType());
672 return true;
673 case clang::Type::MemberPointer:
674 if (pointee_type)
675 pointee_type->SetClangType(m_ast, llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType());
676 return true;
677 case clang::Type::LValueReference:
678 if (pointee_type)
679 pointee_type->SetClangType(m_ast, llvm::cast<clang::LValueReferenceType>(qual_type)->desugar());
680 return true;
681 case clang::Type::RValueReference:
682 if (pointee_type)
683 pointee_type->SetClangType(m_ast, llvm::cast<clang::RValueReferenceType>(qual_type)->desugar());
684 return true;
685 case clang::Type::Typedef:
686 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerOrReferenceType(pointee_type);
687 case clang::Type::Elaborated:
688 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsPointerOrReferenceType(pointee_type);
689 case clang::Type::Paren:
690 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsPointerOrReferenceType(pointee_type);
691 default:
692 break;
693 }
694 }
695 if (pointee_type)
696 pointee_type->Clear();
697 return false;
698}
699
700
701bool
702ClangASTType::IsReferenceType (ClangASTType *pointee_type, bool* is_rvalue) const
703{
704 if (IsValid())
705 {
706 clang::QualType qual_type (GetCanonicalQualType());
707 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
708
709 switch (type_class)
710 {
711 case clang::Type::LValueReference:
712 if (pointee_type)
713 pointee_type->SetClangType(m_ast, llvm::cast<clang::LValueReferenceType>(qual_type)->desugar());
714 if (is_rvalue)
715 *is_rvalue = false;
716 return true;
717 case clang::Type::RValueReference:
718 if (pointee_type)
719 pointee_type->SetClangType(m_ast, llvm::cast<clang::RValueReferenceType>(qual_type)->desugar());
720 if (is_rvalue)
721 *is_rvalue = true;
722 return true;
723 case clang::Type::Typedef:
724 return ClangASTType(m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsReferenceType(pointee_type, is_rvalue);
725 case clang::Type::Elaborated:
726 return ClangASTType(m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsReferenceType(pointee_type, is_rvalue);
727 case clang::Type::Paren:
728 return ClangASTType(m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).IsReferenceType(pointee_type, is_rvalue);
729
730 default:
731 break;
732 }
733 }
734 if (pointee_type)
735 pointee_type->Clear();
736 return false;
737}
738
739bool
740ClangASTType::IsFloatingPointType (uint32_t &count, bool &is_complex) const
741{
742 if (IsValid())
743 {
744 clang::QualType qual_type (GetCanonicalQualType());
745
746 if (const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal()))
747 {
748 clang::BuiltinType::Kind kind = BT->getKind();
749 if (kind >= clang::BuiltinType::Float && kind <= clang::BuiltinType::LongDouble)
750 {
751 count = 1;
752 is_complex = false;
753 return true;
754 }
755 }
756 else if (const clang::ComplexType *CT = llvm::dyn_cast<clang::ComplexType>(qual_type->getCanonicalTypeInternal()))
757 {
758 if (ClangASTType (m_ast, CT->getElementType()).IsFloatingPointType (count, is_complex))
759 {
760 count = 2;
761 is_complex = true;
762 return true;
763 }
764 }
765 else if (const clang::VectorType *VT = llvm::dyn_cast<clang::VectorType>(qual_type->getCanonicalTypeInternal()))
766 {
767 if (ClangASTType (m_ast, VT->getElementType()).IsFloatingPointType (count, is_complex))
768 {
769 count = VT->getNumElements();
770 is_complex = false;
771 return true;
772 }
773 }
774 }
775 count = 0;
776 is_complex = false;
777 return false;
778}
779
780
781bool
782ClangASTType::IsDefined() const
783{
784 if (!IsValid())
785 return false;
786
787 clang::QualType qual_type(GetQualType());
788 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
789 if (tag_type)
790 {
791 clang::TagDecl *tag_decl = tag_type->getDecl();
792 if (tag_decl)
793 return tag_decl->isCompleteDefinition();
794 return false;
795 }
796 else
797 {
798 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
799 if (objc_class_type)
800 {
801 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
802 if (class_interface_decl)
803 return class_interface_decl->getDefinition() != nullptr;
804 return false;
805 }
806 }
807 return true;
808}
809
810bool
811ClangASTType::IsObjCClassType () const
812{
813 if (IsValid())
814 {
815 clang::QualType qual_type (GetCanonicalQualType());
816
817 const clang::ObjCObjectPointerType *obj_pointer_type = llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
818
819 if (obj_pointer_type)
820 return obj_pointer_type->isObjCClassType();
821 }
822 return false;
823}
824
825bool
826ClangASTType::IsObjCObjectOrInterfaceType () const
827{
828 if (IsValid())
829 return GetCanonicalQualType()->isObjCObjectOrInterfaceType();
830 return false;
831}
832
833bool
834ClangASTType::IsPolymorphicClass () const
835{
836 if (IsValid())
837 {
838 clang::QualType qual_type(GetCanonicalQualType());
839 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
840 switch (type_class)
841 {
842 case clang::Type::Record:
843 if (GetCompleteType())
844 {
845 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
846 const clang::RecordDecl *record_decl = record_type->getDecl();
847 if (record_decl)
848 {
849 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
850 if (cxx_record_decl)
851 return cxx_record_decl->isPolymorphic();
852 }
853 }
854 break;
855
856 default:
857 break;
858 }
859 }
860 return false;
861}
862
863bool
864ClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type,
865 bool check_cplusplus,
866 bool check_objc) const
867{
868 clang::QualType pointee_qual_type;
869 if (m_type)
870 {
871 clang::QualType qual_type (GetCanonicalQualType());
872 bool success = false;
873 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
874 switch (type_class)
875 {
876 case clang::Type::Builtin:
877 if (check_objc && llvm::cast<clang::BuiltinType>(qual_type)->getKind() == clang::BuiltinType::ObjCId)
878 {
879 if (dynamic_pointee_type)
880 dynamic_pointee_type->SetClangType(m_ast, m_type);
881 return true;
882 }
883 break;
884
885 case clang::Type::ObjCObjectPointer:
886 if (check_objc)
887 {
888 if (dynamic_pointee_type)
889 dynamic_pointee_type->SetClangType(m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType());
890 return true;
891 }
892 break;
893
894 case clang::Type::Pointer:
895 pointee_qual_type = llvm::cast<clang::PointerType>(qual_type)->getPointeeType();
896 success = true;
897 break;
898
899 case clang::Type::LValueReference:
900 case clang::Type::RValueReference:
901 pointee_qual_type = llvm::cast<clang::ReferenceType>(qual_type)->getPointeeType();
902 success = true;
903 break;
904
905 case clang::Type::Typedef:
906 return ClangASTType (m_ast,
907 llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPossibleDynamicType (dynamic_pointee_type,
908 check_cplusplus,
909 check_objc);
910
911 case clang::Type::Elaborated:
912 return ClangASTType (m_ast,
913 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).IsPossibleDynamicType (dynamic_pointee_type,
914 check_cplusplus,
915 check_objc);
916
917 case clang::Type::Paren:
918 return ClangASTType (m_ast,
919 llvm::cast<clang::ParenType>(qual_type)->desugar()).IsPossibleDynamicType (dynamic_pointee_type,
920 check_cplusplus,
921 check_objc);
922 default:
923 break;
924 }
925
926 if (success)
927 {
928 // Check to make sure what we are pointing too is a possible dynamic C++ type
929 // We currently accept any "void *" (in case we have a class that has been
930 // watered down to an opaque pointer) and virtual C++ classes.
931 const clang::Type::TypeClass pointee_type_class = pointee_qual_type.getCanonicalType()->getTypeClass();
932 switch (pointee_type_class)
933 {
934 case clang::Type::Builtin:
935 switch (llvm::cast<clang::BuiltinType>(pointee_qual_type)->getKind())
936 {
937 case clang::BuiltinType::UnknownAny:
938 case clang::BuiltinType::Void:
939 if (dynamic_pointee_type)
940 dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type);
941 return true;
942
943 case clang::BuiltinType::NullPtr:
944 case clang::BuiltinType::Bool:
945 case clang::BuiltinType::Char_U:
946 case clang::BuiltinType::UChar:
947 case clang::BuiltinType::WChar_U:
948 case clang::BuiltinType::Char16:
949 case clang::BuiltinType::Char32:
950 case clang::BuiltinType::UShort:
951 case clang::BuiltinType::UInt:
952 case clang::BuiltinType::ULong:
953 case clang::BuiltinType::ULongLong:
954 case clang::BuiltinType::UInt128:
955 case clang::BuiltinType::Char_S:
956 case clang::BuiltinType::SChar:
957 case clang::BuiltinType::WChar_S:
958 case clang::BuiltinType::Short:
959 case clang::BuiltinType::Int:
960 case clang::BuiltinType::Long:
961 case clang::BuiltinType::LongLong:
962 case clang::BuiltinType::Int128:
963 case clang::BuiltinType::Float:
964 case clang::BuiltinType::Double:
965 case clang::BuiltinType::LongDouble:
966 case clang::BuiltinType::Dependent:
967 case clang::BuiltinType::Overload:
968 case clang::BuiltinType::ObjCId:
969 case clang::BuiltinType::ObjCClass:
970 case clang::BuiltinType::ObjCSel:
971 case clang::BuiltinType::BoundMember:
972 case clang::BuiltinType::Half:
973 case clang::BuiltinType::ARCUnbridgedCast:
974 case clang::BuiltinType::PseudoObject:
975 case clang::BuiltinType::BuiltinFn:
976 case clang::BuiltinType::OCLEvent:
977 case clang::BuiltinType::OCLImage1d:
978 case clang::BuiltinType::OCLImage1dArray:
979 case clang::BuiltinType::OCLImage1dBuffer:
980 case clang::BuiltinType::OCLImage2d:
981 case clang::BuiltinType::OCLImage2dArray:
982 case clang::BuiltinType::OCLImage3d:
983 case clang::BuiltinType::OCLSampler:
984 break;
985 }
986 break;
987
988 case clang::Type::Record:
989 if (check_cplusplus)
990 {
991 clang::CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl();
992 if (cxx_record_decl)
993 {
994 bool is_complete = cxx_record_decl->isCompleteDefinition();
995
996 if (is_complete)
997 success = cxx_record_decl->isDynamicClass();
998 else
999 {
1000 ClangASTMetadata *metadata = ClangASTContext::GetMetadata (m_ast, cxx_record_decl);
1001 if (metadata)
1002 success = metadata->GetIsDynamicCXXType();
1003 else
1004 {
1005 is_complete = ClangASTType(m_ast, pointee_qual_type).GetCompleteType();
1006 if (is_complete)
1007 success = cxx_record_decl->isDynamicClass();
1008 else
1009 success = false;
1010 }
1011 }
1012
1013 if (success)
1014 {
1015 if (dynamic_pointee_type)
1016 dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type);
1017 return true;
1018 }
1019 }
1020 }
1021 break;
1022
1023 case clang::Type::ObjCObject:
1024 case clang::Type::ObjCInterface:
1025 if (check_objc)
1026 {
1027 if (dynamic_pointee_type)
1028 dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type);
1029 return true;
1030 }
1031 break;
1032
1033 default:
1034 break;
1035 }
1036 }
1037 }
1038 if (dynamic_pointee_type)
1039 dynamic_pointee_type->Clear();
1040 return false;
1041}
1042
1043
1044bool
1045ClangASTType::IsScalarType () const
1046{
1047 if (!IsValid())
1048 return false;
1049
1050 return (GetTypeInfo (nullptr) & eTypeIsScalar) != 0;
1051}
1052
1053bool
1054ClangASTType::IsTypedefType () const
1055{
1056 if (!IsValid())
1057 return false;
1058 return GetQualType()->getTypeClass() == clang::Type::Typedef;
1059}
1060
1061bool
1062ClangASTType::IsVoidType () const
1063{
1064 if (!IsValid())
1065 return false;
1066 return GetCanonicalQualType()->isVoidType();
1067}
1068
1069bool
1070ClangASTType::IsPointerToScalarType () const
1071{
1072 if (!IsValid())
1073 return false;
1074
1075 return IsPointerType() && GetPointeeType().IsScalarType();
1076}
1077
1078bool
1079ClangASTType::IsArrayOfScalarType () const
1080{
1081 ClangASTType element_type;
1082 if (IsArrayType(&element_type, nullptr, nullptr))
1083 return element_type.IsScalarType();
1084 return false;
1085}
1086
1087
1088bool
1089ClangASTType::GetCXXClassName (std::string &class_name) const
1090{
1091 if (IsValid())
1092 {
1093 clang::QualType qual_type (GetCanonicalQualType());
1094
1095 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
1096 if (cxx_record_decl)
1097 {
1098 class_name.assign (cxx_record_decl->getIdentifier()->getNameStart());
1099 return true;
1100 }
1101 }
1102 class_name.clear();
1103 return false;
1104}
1105
1106
1107bool
1108ClangASTType::IsCXXClassType () const
1109{
1110 if (!IsValid())
1111 return false;
1112
1113 clang::QualType qual_type (GetCanonicalQualType());
1114 if (qual_type->getAsCXXRecordDecl() != nullptr)
1115 return true;
1116 return false;
1117}
1118
1119bool
1120ClangASTType::IsBeingDefined () const
1121{
1122 if (!IsValid())
1123 return false;
1124 clang::QualType qual_type (GetCanonicalQualType());
1125 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type);
1126 if (tag_type)
1127 return tag_type->isBeingDefined();
1128 return false;
1129}
1130
1131bool
1132ClangASTType::IsObjCObjectPointerType (ClangASTType *class_type_ptr)
1133{
1134 if (!IsValid())
1135 return false;
1136
1137 clang::QualType qual_type (GetCanonicalQualType());
1138
1139 if (qual_type->isObjCObjectPointerType())
1140 {
1141 if (class_type_ptr)
1142 {
1143 if (!qual_type->isObjCClassType() &&
1144 !qual_type->isObjCIdType())
1145 {
1146 const clang::ObjCObjectPointerType *obj_pointer_type = llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
1147 if (obj_pointer_type == nullptr)
1148 class_type_ptr->Clear();
1149 else
1150 class_type_ptr->SetClangType (m_ast, clang::QualType(obj_pointer_type->getInterfaceType(), 0));
1151 }
1152 }
1153 return true;
1154 }
1155 if (class_type_ptr)
1156 class_type_ptr->Clear();
1157 return false;
1158}
1159
1160bool
1161ClangASTType::GetObjCClassName (std::string &class_name)
1162{
1163 if (!IsValid())
1164 return false;
1165
1166 clang::QualType qual_type (GetCanonicalQualType());
1167
1168 const clang::ObjCObjectType *object_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
1169 if (object_type)
1170 {
1171 const clang::ObjCInterfaceDecl *interface = object_type->getInterface();
1172 if (interface)
1173 {
1174 class_name = interface->getNameAsString();
1175 return true;
1176 }
1177 }
1178 return false;
1179}
1180
1181
1182//----------------------------------------------------------------------
1183// Type Completion
1184//----------------------------------------------------------------------
1185
1186bool
1187ClangASTType::GetCompleteType () const
1188{
1189 if (!IsValid())
1190 return false;
1191 const bool allow_completion = true;
1192 return GetCompleteQualType (m_ast, GetQualType(), allow_completion);
1193}
1194
1195//----------------------------------------------------------------------
1196// AST related queries
1197//----------------------------------------------------------------------
1198size_t
1199ClangASTType::GetPointerByteSize () const
1200{
1201 if (m_ast)
1202 return m_ast->getTypeSize(m_ast->VoidPtrTy) / 8;
1203 return 0;
1204}
1205
1206ConstString
1207ClangASTType::GetConstQualifiedTypeName () const
1208{
1209 return GetConstTypeName ();
1210}
1211
1212ConstString
1213ClangASTType::GetConstTypeName () const
1214{
1215 if (IsValid())
1216 {
1217 ConstString type_name (GetTypeName());
1218 if (type_name)
1219 return type_name;
1220 }
1221 return ConstString("<invalid>");
1222}
1223
1224ConstString
1225ClangASTType::GetTypeName () const
1226{
1227 std::string type_name;
1228 if (IsValid())
1229 {
1230 clang::PrintingPolicy printing_policy (m_ast->getPrintingPolicy());
1231 clang::QualType qual_type(GetQualType());
1232 printing_policy.SuppressTagKeyword = true;
1233 printing_policy.LangOpts.WChar = true;
1234 const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>();
1235 if (typedef_type)
1236 {
1237 const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
1238 type_name = typedef_decl->getQualifiedNameAsString();
1239 }
1240 else
1241 {
1242 type_name = qual_type.getAsString(printing_policy);
1243 }
1244 }
1245 return ConstString(type_name);
1246}
1247
1248ConstString
1249ClangASTType::GetDisplayTypeName () const
1250{
1251 return GetTypeName();
1252}
1253
1254uint32_t
1255ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const
1256{
1257 if (!IsValid())
1258 return 0;
1259
1260 if (pointee_or_element_clang_type)
1261 pointee_or_element_clang_type->Clear();
1262
1263 clang::QualType qual_type (GetQualType());
1264
1265 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
1266 switch (type_class)
1267 {
1268 case clang::Type::Builtin:
1269 {
1270 const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
1271
1272 uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
1273 switch (builtin_type->getKind())
1274 {
1275 case clang::BuiltinType::ObjCId:
1276 case clang::BuiltinType::ObjCClass:
1277 if (pointee_or_element_clang_type)
1278 pointee_or_element_clang_type->SetClangType(m_ast, m_ast->ObjCBuiltinClassTy);
1279 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
1280 break;
1281
1282 case clang::BuiltinType::ObjCSel:
1283 if (pointee_or_element_clang_type)
1284 pointee_or_element_clang_type->SetClangType(m_ast, m_ast->CharTy);
1285 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
1286 break;
1287
1288 case clang::BuiltinType::Bool:
1289 case clang::BuiltinType::Char_U:
1290 case clang::BuiltinType::UChar:
1291 case clang::BuiltinType::WChar_U:
1292 case clang::BuiltinType::Char16:
1293 case clang::BuiltinType::Char32:
1294 case clang::BuiltinType::UShort:
1295 case clang::BuiltinType::UInt:
1296 case clang::BuiltinType::ULong:
1297 case clang::BuiltinType::ULongLong:
1298 case clang::BuiltinType::UInt128:
1299 case clang::BuiltinType::Char_S:
1300 case clang::BuiltinType::SChar:
1301 case clang::BuiltinType::WChar_S:
1302 case clang::BuiltinType::Short:
1303 case clang::BuiltinType::Int:
1304 case clang::BuiltinType::Long:
1305 case clang::BuiltinType::LongLong:
1306 case clang::BuiltinType::Int128:
1307 case clang::BuiltinType::Float:
1308 case clang::BuiltinType::Double:
1309 case clang::BuiltinType::LongDouble:
1310 builtin_type_flags |= eTypeIsScalar;
1311 if (builtin_type->isInteger())
1312 {
1313 builtin_type_flags |= eTypeIsInteger;
1314 if (builtin_type->isSignedInteger())
1315 builtin_type_flags |= eTypeIsSigned;
1316 }
1317 else if (builtin_type->isFloatingPoint())
1318 builtin_type_flags |= eTypeIsFloat;
1319 break;
1320 default:
1321 break;
1322 }
1323 return builtin_type_flags;
1324 }
1325
1326 case clang::Type::BlockPointer:
1327 if (pointee_or_element_clang_type)
1328 pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType());
1329 return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
1330
1331 case clang::Type::Complex:
1332 {
1333 uint32_t complex_type_flags = eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex;
1334 const clang::ComplexType *complex_type = llvm::dyn_cast<clang::ComplexType>(qual_type->getCanonicalTypeInternal());
1335 if (complex_type)
1336 {
1337 clang::QualType complex_element_type (complex_type->getElementType());
1338 if (complex_element_type->isIntegerType())
1339 complex_type_flags |= eTypeIsFloat;
1340 else if (complex_element_type->isFloatingType())
1341 complex_type_flags |= eTypeIsInteger;
1342 }
1343 return complex_type_flags;
1344 }
1345 break;
1346
1347 case clang::Type::ConstantArray:
1348 case clang::Type::DependentSizedArray:
1349 case clang::Type::IncompleteArray:
1350 case clang::Type::VariableArray:
1351 if (pointee_or_element_clang_type)
1352 pointee_or_element_clang_type->SetClangType(m_ast, llvm::cast<clang::ArrayType>(qual_type.getTypePtr())->getElementType());
1353 return eTypeHasChildren | eTypeIsArray;
1354
1355 case clang::Type::DependentName: return 0;
1356 case clang::Type::DependentSizedExtVector: return eTypeHasChildren | eTypeIsVector;
1357 case clang::Type::DependentTemplateSpecialization: return eTypeIsTemplate;
1358 case clang::Type::Decltype: return 0;
1359
1360 case clang::Type::Enum:
1361 if (pointee_or_element_clang_type)
1362 pointee_or_element_clang_type->SetClangType(m_ast, llvm::cast<clang::EnumType>(qual_type)->getDecl()->getIntegerType());
1363 return eTypeIsEnumeration | eTypeHasValue;
1364
1365 case clang::Type::Elaborated:
1366 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetTypeInfo (pointee_or_element_clang_type);
1367 case clang::Type::Paren:
1368 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetTypeInfo (pointee_or_element_clang_type);
1369
1370 case clang::Type::FunctionProto: return eTypeIsFuncPrototype | eTypeHasValue;
1371 case clang::Type::FunctionNoProto: return eTypeIsFuncPrototype | eTypeHasValue;
1372 case clang::Type::InjectedClassName: return 0;
1373
1374 case clang::Type::LValueReference:
1375 case clang::Type::RValueReference:
1376 if (pointee_or_element_clang_type)
1377 pointee_or_element_clang_type->SetClangType(m_ast, llvm::cast<clang::ReferenceType>(qual_type.getTypePtr())->getPointeeType());
1378 return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
1379
1380 case clang::Type::MemberPointer: return eTypeIsPointer | eTypeIsMember | eTypeHasValue;
1381
1382 case clang::Type::ObjCObjectPointer:
1383 if (pointee_or_element_clang_type)
1384 pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType());
1385 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | eTypeHasValue;
1386
1387 case clang::Type::ObjCObject: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
1388 case clang::Type::ObjCInterface: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
1389
1390 case clang::Type::Pointer:
1391 if (pointee_or_element_clang_type)
1392 pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType());
1393 return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
1394
1395 case clang::Type::Record:
1396 if (qual_type->getAsCXXRecordDecl())
1397 return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
1398 else
1399 return eTypeHasChildren | eTypeIsStructUnion;
1400 break;
1401 case clang::Type::SubstTemplateTypeParm: return eTypeIsTemplate;
1402 case clang::Type::TemplateTypeParm: return eTypeIsTemplate;
1403 case clang::Type::TemplateSpecialization: return eTypeIsTemplate;
1404
1405 case clang::Type::Typedef:
1406 return eTypeIsTypedef | ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTypeInfo (pointee_or_element_clang_type);
1407 case clang::Type::TypeOfExpr: return 0;
1408 case clang::Type::TypeOf: return 0;
1409 case clang::Type::UnresolvedUsing: return 0;
1410
1411 case clang::Type::ExtVector:
1412 case clang::Type::Vector:
1413 {
1414 uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector;
1415 const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>(qual_type->getCanonicalTypeInternal());
1416 if (vector_type)
1417 {
1418 if (vector_type->isIntegerType())
1419 vector_type_flags |= eTypeIsFloat;
1420 else if (vector_type->isFloatingType())
1421 vector_type_flags |= eTypeIsInteger;
1422 }
1423 return vector_type_flags;
1424 }
1425 default: return 0;
1426 }
1427 return 0;
1428}
1429
1430
1431
1432lldb::LanguageType
1433ClangASTType::GetMinimumLanguage ()
1434{
1435 if (!IsValid())
1436 return lldb::eLanguageTypeC;
1437
1438 // If the type is a reference, then resolve it to what it refers to first:
1439 clang::QualType qual_type (GetCanonicalQualType().getNonReferenceType());
1440 if (qual_type->isAnyPointerType())
1441 {
1442 if (qual_type->isObjCObjectPointerType())
1443 return lldb::eLanguageTypeObjC;
1444
1445 clang::QualType pointee_type (qual_type->getPointeeType());
1446 if (pointee_type->getPointeeCXXRecordDecl() != nullptr)
1447 return lldb::eLanguageTypeC_plus_plus;
1448 if (pointee_type->isObjCObjectOrInterfaceType())
1449 return lldb::eLanguageTypeObjC;
1450 if (pointee_type->isObjCClassType())
1451 return lldb::eLanguageTypeObjC;
1452 if (pointee_type.getTypePtr() == m_ast->ObjCBuiltinIdTy.getTypePtr())
1453 return lldb::eLanguageTypeObjC;
1454 }
1455 else
1456 {
1457 if (qual_type->isObjCObjectOrInterfaceType())
1458 return lldb::eLanguageTypeObjC;
1459 if (qual_type->getAsCXXRecordDecl())
1460 return lldb::eLanguageTypeC_plus_plus;
1461 switch (qual_type->getTypeClass())
1462 {
1463 default:
1464 break;
1465 case clang::Type::Builtin:
1466 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
1467 {
1468 default:
1469 case clang::BuiltinType::Void:
1470 case clang::BuiltinType::Bool:
1471 case clang::BuiltinType::Char_U:
1472 case clang::BuiltinType::UChar:
1473 case clang::BuiltinType::WChar_U:
1474 case clang::BuiltinType::Char16:
1475 case clang::BuiltinType::Char32:
1476 case clang::BuiltinType::UShort:
1477 case clang::BuiltinType::UInt:
1478 case clang::BuiltinType::ULong:
1479 case clang::BuiltinType::ULongLong:
1480 case clang::BuiltinType::UInt128:
1481 case clang::BuiltinType::Char_S:
1482 case clang::BuiltinType::SChar:
1483 case clang::BuiltinType::WChar_S:
1484 case clang::BuiltinType::Short:
1485 case clang::BuiltinType::Int:
1486 case clang::BuiltinType::Long:
1487 case clang::BuiltinType::LongLong:
1488 case clang::BuiltinType::Int128:
1489 case clang::BuiltinType::Float:
1490 case clang::BuiltinType::Double:
1491 case clang::BuiltinType::LongDouble:
1492 break;
1493
1494 case clang::BuiltinType::NullPtr:
1495 return eLanguageTypeC_plus_plus;
1496
1497 case clang::BuiltinType::ObjCId:
1498 case clang::BuiltinType::ObjCClass:
1499 case clang::BuiltinType::ObjCSel:
1500 return eLanguageTypeObjC;
1501
1502 case clang::BuiltinType::Dependent:
1503 case clang::BuiltinType::Overload:
1504 case clang::BuiltinType::BoundMember:
1505 case clang::BuiltinType::UnknownAny:
1506 break;
1507 }
1508 break;
1509 case clang::Type::Typedef:
1510 return ClangASTType(m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetMinimumLanguage();
1511 }
1512 }
1513 return lldb::eLanguageTypeC;
1514}
1515
1516lldb::TypeClass
1517ClangASTType::GetTypeClass () const
1518{
1519 if (!IsValid())
1520 return lldb::eTypeClassInvalid;
1521
1522 clang::QualType qual_type(GetQualType());
1523
1524 switch (qual_type->getTypeClass())
1525 {
1526 case clang::Type::UnaryTransform: break;
1527 case clang::Type::FunctionNoProto: return lldb::eTypeClassFunction;
1528 case clang::Type::FunctionProto: return lldb::eTypeClassFunction;
1529 case clang::Type::IncompleteArray: return lldb::eTypeClassArray;
1530 case clang::Type::VariableArray: return lldb::eTypeClassArray;
1531 case clang::Type::ConstantArray: return lldb::eTypeClassArray;
1532 case clang::Type::DependentSizedArray: return lldb::eTypeClassArray;
1533 case clang::Type::DependentSizedExtVector: return lldb::eTypeClassVector;
1534 case clang::Type::ExtVector: return lldb::eTypeClassVector;
1535 case clang::Type::Vector: return lldb::eTypeClassVector;
1536 case clang::Type::Builtin: return lldb::eTypeClassBuiltin;
1537 case clang::Type::ObjCObjectPointer: return lldb::eTypeClassObjCObjectPointer;
1538 case clang::Type::BlockPointer: return lldb::eTypeClassBlockPointer;
1539 case clang::Type::Pointer: return lldb::eTypeClassPointer;
1540 case clang::Type::LValueReference: return lldb::eTypeClassReference;
1541 case clang::Type::RValueReference: return lldb::eTypeClassReference;
1542 case clang::Type::MemberPointer: return lldb::eTypeClassMemberPointer;
1543 case clang::Type::Complex:
1544 if (qual_type->isComplexType())
1545 return lldb::eTypeClassComplexFloat;
1546 else
1547 return lldb::eTypeClassComplexInteger;
1548 case clang::Type::ObjCObject: return lldb::eTypeClassObjCObject;
1549 case clang::Type::ObjCInterface: return lldb::eTypeClassObjCInterface;
1550 case clang::Type::Record:
1551 {
1552 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
1553 const clang::RecordDecl *record_decl = record_type->getDecl();
1554 if (record_decl->isUnion())
1555 return lldb::eTypeClassUnion;
1556 else if (record_decl->isStruct())
1557 return lldb::eTypeClassStruct;
1558 else
1559 return lldb::eTypeClassClass;
1560 }
1561 break;
1562 case clang::Type::Enum: return lldb::eTypeClassEnumeration;
1563 case clang::Type::Typedef: return lldb::eTypeClassTypedef;
1564 case clang::Type::UnresolvedUsing: break;
1565 case clang::Type::Paren:
1566 return ClangASTType(m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetTypeClass();
1567 case clang::Type::Elaborated:
1568 return ClangASTType(m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetTypeClass();
1569
1570 case clang::Type::Attributed: break;
1571 case clang::Type::TemplateTypeParm: break;
1572 case clang::Type::SubstTemplateTypeParm: break;
1573 case clang::Type::SubstTemplateTypeParmPack:break;
1574 case clang::Type::Auto: break;
1575 case clang::Type::InjectedClassName: break;
1576 case clang::Type::DependentName: break;
1577 case clang::Type::DependentTemplateSpecialization: break;
1578 case clang::Type::PackExpansion: break;
1579
1580 case clang::Type::TypeOfExpr: break;
1581 case clang::Type::TypeOf: break;
1582 case clang::Type::Decltype: break;
1583 case clang::Type::TemplateSpecialization: break;
1584 case clang::Type::Atomic: break;
1585
1586 // pointer type decayed from an array or function type.
1587 case clang::Type::Decayed: break;
1588 case clang::Type::Adjusted: break;
1589 }
1590 // We don't know hot to display this type...
1591 return lldb::eTypeClassOther;
1592
1593}
1594
1595void
1596ClangASTType::SetClangType (clang::ASTContext *ast, clang::QualType qual_type)
1597{
1598 m_ast = ast;
1599 m_type = qual_type.getAsOpaquePtr();
1600}
1601
1602unsigned
1603ClangASTType::GetTypeQualifiers() const
1604{
1605 if (IsValid())
1606 return GetQualType().getQualifiers().getCVRQualifiers();
1607 return 0;
1608}
1609
1610//----------------------------------------------------------------------
1611// Creating related types
1612//----------------------------------------------------------------------
1613
1614ClangASTType
1615ClangASTType::AddConstModifier () const
1616{
1617 if (m_type)
1618 {
1619 clang::QualType result(GetQualType());
1620 result.addConst();
1621 return ClangASTType (m_ast, result);
1622 }
1623 return ClangASTType();
1624}
1625
1626ClangASTType
1627ClangASTType::AddRestrictModifier () const
1628{
1629 if (m_type)
1630 {
1631 clang::QualType result(GetQualType());
1632 result.getQualifiers().setRestrict (true);
1633 return ClangASTType (m_ast, result);
1634 }
1635 return ClangASTType();
1636}
1637
1638ClangASTType
1639ClangASTType::AddVolatileModifier () const
1640{
1641 if (m_type)
1642 {
1643 clang::QualType result(GetQualType());
1644 result.getQualifiers().setVolatile (true);
1645 return ClangASTType (m_ast, result);
1646 }
1647 return ClangASTType();
1648}
1649
1650ClangASTType
1651ClangASTType::GetArrayElementType (uint64_t *stride) const
1652{
1653 if (IsValid())
1654 {
1655 clang::QualType qual_type(GetCanonicalQualType());
1656
1657 const clang::Type *array_elem_type = qual_type.getTypePtr()->getArrayElementTypeNoTypeQual();
1658
1659 if (!array_elem_type)
1660 return ClangASTType();
1661
1662 ClangASTType element_type (m_ast, array_elem_type->getCanonicalTypeUnqualified());
1663
1664 // TODO: the real stride will be >= this value.. find the real one!
1665 if (stride)
1666 *stride = element_type.GetByteSize();
1667
1668 return element_type;
1669
1670 }
1671 return ClangASTType();
1672}
1673
1674ClangASTType
1675ClangASTType::GetCanonicalType () const
1676{
1677 if (IsValid())
1678 return ClangASTType (m_ast, GetCanonicalQualType());
1679 return ClangASTType();
1680}
1681
1682static clang::QualType
1683GetFullyUnqualifiedType_Impl (clang::ASTContext *ast, clang::QualType qual_type)
1684{
1685 if (qual_type->isPointerType())
1686 qual_type = ast->getPointerType(GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType()));
1687 else
1688 qual_type = qual_type.getUnqualifiedType();
1689 qual_type.removeLocalConst();
1690 qual_type.removeLocalRestrict();
1691 qual_type.removeLocalVolatile();
1692 return qual_type;
1693}
1694
1695ClangASTType
1696ClangASTType::GetFullyUnqualifiedType () const
1697{
1698 if (IsValid())
1699 return ClangASTType(m_ast, GetFullyUnqualifiedType_Impl(m_ast, GetQualType()));
1700 return ClangASTType();
1701}
1702
1703
1704int
1705ClangASTType::GetFunctionArgumentCount () const
1706{
1707 if (IsValid())
1708 {
1709 const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType());
1710 if (func)
1711 return func->getNumParams();
1712 }
1713 return -1;
1714}
1715
1716ClangASTType
1717ClangASTType::GetFunctionArgumentTypeAtIndex (size_t idx) const
1718{
1719 if (IsValid())
1720 {
1721 const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType());
1722 if (func)
1723 {
1724 const uint32_t num_args = func->getNumParams();
1725 if (idx < num_args)
1726 return ClangASTType(m_ast, func->getParamType(idx));
1727 }
1728 }
1729 return ClangASTType();
1730}
1731
1732ClangASTType
1733ClangASTType::GetFunctionReturnType () const
1734{
1735 if (IsValid())
1736 {
1737 clang::QualType qual_type(GetCanonicalQualType());
1738 const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
1739 if (func)
1740 return ClangASTType(m_ast, func->getReturnType());
1741 }
1742 return ClangASTType();
1743}
1744
1745size_t
1746ClangASTType::GetNumMemberFunctions () const
1747{
1748 size_t num_functions = 0;
1749 if (IsValid())
1750 {
1751 clang::QualType qual_type(GetCanonicalQualType());
1752 switch (qual_type->getTypeClass()) {
1753 case clang::Type::Record:
1754 if (GetCompleteQualType (m_ast, qual_type))
1755 {
1756 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
1757 const clang::RecordDecl *record_decl = record_type->getDecl();
1758 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 1758, __PRETTY_FUNCTION__))
;
1759 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
1760 if (cxx_record_decl)
1761 num_functions = std::distance(cxx_record_decl->method_begin(), cxx_record_decl->method_end());
1762 }
1763 break;
1764
1765 case clang::Type::ObjCObjectPointer:
1766 if (GetCompleteType())
1767 {
1768 const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
1769 if (objc_class_type)
1770 {
1771 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
1772 if (class_interface_decl)
1773 num_functions = std::distance(class_interface_decl->meth_begin(), class_interface_decl->meth_end());
1774 }
1775 }
1776 break;
1777
1778 case clang::Type::ObjCObject:
1779 case clang::Type::ObjCInterface:
1780 if (GetCompleteType())
1781 {
1782 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
1783 if (objc_class_type)
1784 {
1785 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1786 if (class_interface_decl)
1787 num_functions = std::distance(class_interface_decl->meth_begin(), class_interface_decl->meth_end());
1788 }
1789 }
1790 break;
1791
1792
1793 case clang::Type::Typedef:
1794 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumMemberFunctions();
1795
1796 case clang::Type::Elaborated:
1797 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumMemberFunctions();
1798
1799 case clang::Type::Paren:
1800 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumMemberFunctions();
1801
1802 default:
1803 break;
1804 }
1805 }
1806 return num_functions;
1807}
1808
1809TypeMemberFunctionImpl
1810ClangASTType::GetMemberFunctionAtIndex (size_t idx)
1811{
1812 std::string name("");
1813 MemberFunctionKind kind(MemberFunctionKind::eMemberFunctionKindUnknown);
1814 ClangASTType type{};
1815 clang::ObjCMethodDecl *method_decl(nullptr);
1816 if (IsValid())
1817 {
1818 clang::QualType qual_type(GetCanonicalQualType());
1819 switch (qual_type->getTypeClass()) {
1820 case clang::Type::Record:
1821 if (GetCompleteQualType (m_ast, qual_type))
1822 {
1823 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
1824 const clang::RecordDecl *record_decl = record_type->getDecl();
1825 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 1825, __PRETTY_FUNCTION__))
;
1826 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
1827 if (cxx_record_decl)
1828 {
1829 auto method_iter = cxx_record_decl->method_begin();
1830 auto method_end = cxx_record_decl->method_end();
1831 if (idx < static_cast<size_t>(std::distance(method_iter, method_end)))
1832 {
1833 std::advance(method_iter, idx);
1834 auto method_decl = method_iter->getCanonicalDecl();
1835 if (method_decl)
1836 {
1837 if (!method_decl->getName().empty())
1838 name.assign(method_decl->getName().data());
1839 else
1840 name.clear();
1841 if (method_decl->isStatic())
1842 kind = lldb::eMemberFunctionKindStaticMethod;
1843 else if (llvm::isa<clang::CXXConstructorDecl>(method_decl))
1844 kind = lldb::eMemberFunctionKindConstructor;
1845 else if (llvm::isa<clang::CXXDestructorDecl>(method_decl))
1846 kind = lldb::eMemberFunctionKindDestructor;
1847 else
1848 kind = lldb::eMemberFunctionKindInstanceMethod;
1849 type = ClangASTType(m_ast,method_decl->getType().getAsOpaquePtr());
1850 }
1851 }
1852 }
1853 }
1854 break;
1855
1856 case clang::Type::ObjCObjectPointer:
1857 if (GetCompleteType())
1858 {
1859 const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
1860 if (objc_class_type)
1861 {
1862 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
1863 if (class_interface_decl)
1864 {
1865 auto method_iter = class_interface_decl->meth_begin();
1866 auto method_end = class_interface_decl->meth_end();
1867 if (idx < static_cast<size_t>(std::distance(method_iter, method_end)))
1868 {
1869 std::advance(method_iter, idx);
1870 method_decl = method_iter->getCanonicalDecl();
1871 if (method_decl)
1872 {
1873 name = method_decl->getSelector().getAsString();
1874 if (method_decl->isClassMethod())
1875 kind = lldb::eMemberFunctionKindStaticMethod;
1876 else
1877 kind = lldb::eMemberFunctionKindInstanceMethod;
1878 }
1879 }
1880 }
1881 }
1882 }
1883 break;
1884
1885 case clang::Type::ObjCObject:
1886 case clang::Type::ObjCInterface:
1887 if (GetCompleteType())
1888 {
1889 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
1890 if (objc_class_type)
1891 {
1892 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1893 if (class_interface_decl)
1894 {
1895 auto method_iter = class_interface_decl->meth_begin();
1896 auto method_end = class_interface_decl->meth_end();
1897 if (idx < static_cast<size_t>(std::distance(method_iter, method_end)))
1898 {
1899 std::advance(method_iter, idx);
1900 method_decl = method_iter->getCanonicalDecl();
1901 if (method_decl)
1902 {
1903 name = method_decl->getSelector().getAsString();
1904 if (method_decl->isClassMethod())
1905 kind = lldb::eMemberFunctionKindStaticMethod;
1906 else
1907 kind = lldb::eMemberFunctionKindInstanceMethod;
1908 }
1909 }
1910 }
1911 }
1912 }
1913 break;
1914
1915 case clang::Type::Typedef:
1916 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetMemberFunctionAtIndex(idx);
1917
1918 case clang::Type::Elaborated:
1919 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetMemberFunctionAtIndex(idx);
1920
1921 case clang::Type::Paren:
1922 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetMemberFunctionAtIndex(idx);
1923
1924 default:
1925 break;
1926 }
1927 }
1928
1929 if (kind == eMemberFunctionKindUnknown)
1930 return TypeMemberFunctionImpl();
1931 if (method_decl)
1932 return TypeMemberFunctionImpl(method_decl, name, kind);
1933 if (type)
1934 return TypeMemberFunctionImpl(type, name, kind);
1935
1936 return TypeMemberFunctionImpl();
1937}
1938
1939ClangASTType
1940ClangASTType::GetLValueReferenceType () const
1941{
1942 if (IsValid())
1943 {
1944 return ClangASTType(m_ast, m_ast->getLValueReferenceType(GetQualType()));
1945 }
1946 return ClangASTType();
1947}
1948
1949ClangASTType
1950ClangASTType::GetRValueReferenceType () const
1951{
1952 if (IsValid())
1953 {
1954 return ClangASTType(m_ast, m_ast->getRValueReferenceType(GetQualType()));
1955 }
1956 return ClangASTType();
1957}
1958
1959ClangASTType
1960ClangASTType::GetNonReferenceType () const
1961{
1962 if (IsValid())
1963 return ClangASTType(m_ast, GetQualType().getNonReferenceType());
1964 return ClangASTType();
1965}
1966
1967ClangASTType
1968ClangASTType::CreateTypedefType (const char *typedef_name,
1969 clang::DeclContext *decl_ctx) const
1970{
1971 if (IsValid() && typedef_name && typedef_name[0])
1972 {
1973 clang::QualType qual_type (GetQualType());
1974 if (decl_ctx == nullptr)
1975 decl_ctx = m_ast->getTranslationUnitDecl();
1976 clang::TypedefDecl *decl = clang::TypedefDecl::Create (*m_ast,
1977 decl_ctx,
1978 clang::SourceLocation(),
1979 clang::SourceLocation(),
1980 &m_ast->Idents.get(typedef_name),
1981 m_ast->getTrivialTypeSourceInfo(qual_type));
1982
1983 decl->setAccess(clang::AS_public); // TODO respect proper access specifier
1984
1985 // Get a uniqued clang::QualType for the typedef decl type
1986 return ClangASTType (m_ast, m_ast->getTypedefType (decl));
1987 }
1988 return ClangASTType();
1989
1990}
1991
1992ClangASTType
1993ClangASTType::GetPointeeType () const
1994{
1995 if (m_type)
1996 {
1997 clang::QualType qual_type(GetQualType());
1998 return ClangASTType (m_ast, qual_type.getTypePtr()->getPointeeType());
1999 }
2000 return ClangASTType();
2001}
2002
2003ClangASTType
2004ClangASTType::GetPointerType () const
2005{
2006 if (IsValid())
2007 {
2008 clang::QualType qual_type (GetQualType());
2009
2010 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2011 switch (type_class)
2012 {
2013 case clang::Type::ObjCObject:
2014 case clang::Type::ObjCInterface:
2015 return ClangASTType(m_ast, m_ast->getObjCObjectPointerType(qual_type).getAsOpaquePtr());
2016
2017 default:
2018 return ClangASTType(m_ast, m_ast->getPointerType(qual_type).getAsOpaquePtr());
2019 }
2020 }
2021 return ClangASTType();
2022}
2023
2024ClangASTType
2025ClangASTType::GetTypedefedType () const
2026{
2027 if (IsValid())
2028 {
2029 const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(GetQualType());
2030 if (typedef_type)
2031 return ClangASTType (m_ast, typedef_type->getDecl()->getUnderlyingType());
2032 }
2033 return ClangASTType();
2034}
2035
2036ClangASTType
2037ClangASTType::RemoveFastQualifiers () const
2038{
2039 if (m_type)
2040 {
2041 clang::QualType qual_type(GetQualType());
2042 qual_type.getQualifiers().removeFastQualifiers();
2043 return ClangASTType (m_ast, qual_type);
2044 }
2045 return ClangASTType();
2046}
2047
2048
2049//----------------------------------------------------------------------
2050// Create related types using the current type's AST
2051//----------------------------------------------------------------------
2052
2053ClangASTType
2054ClangASTType::GetBasicTypeFromAST (lldb::BasicType basic_type) const
2055{
2056 if (IsValid())
2057 return ClangASTContext::GetBasicType(m_ast, basic_type);
2058 return ClangASTType();
2059}
2060//----------------------------------------------------------------------
2061// Exploring the type
2062//----------------------------------------------------------------------
2063
2064uint64_t
2065ClangASTType::GetBitSize () const
2066{
2067 if (GetCompleteType ())
2068 {
2069 clang::QualType qual_type(GetCanonicalQualType());
2070 const uint32_t bit_size = m_ast->getTypeSize (qual_type);
2071 if (bit_size == 0)
2072 {
2073 if (qual_type->isIncompleteArrayType())
2074 return m_ast->getTypeSize (qual_type->getArrayElementTypeNoTypeQual()->getCanonicalTypeUnqualified());
2075 }
2076 if (qual_type->isObjCObjectOrInterfaceType())
2077 return bit_size + m_ast->getTypeSize(m_ast->ObjCBuiltinClassTy);
2078 return bit_size;
2079 }
2080 return 0;
2081}
2082
2083uint64_t
2084ClangASTType::GetByteSize () const
2085{
2086 return (GetBitSize () + 7) / 8;
2087}
2088
2089size_t
2090ClangASTType::GetTypeBitAlign () const
2091{
2092 if (GetCompleteType ())
2093 return m_ast->getTypeAlign(GetQualType());
2094 return 0;
2095}
2096
2097
2098lldb::Encoding
2099ClangASTType::GetEncoding (uint64_t &count) const
2100{
2101 if (!IsValid())
2102 return lldb::eEncodingInvalid;
2103
2104 count = 1;
2105 clang::QualType qual_type(GetCanonicalQualType());
2106
2107 switch (qual_type->getTypeClass())
2108 {
2109 case clang::Type::UnaryTransform:
2110 break;
2111
2112 case clang::Type::FunctionNoProto:
2113 case clang::Type::FunctionProto:
2114 break;
2115
2116 case clang::Type::IncompleteArray:
2117 case clang::Type::VariableArray:
2118 break;
2119
2120 case clang::Type::ConstantArray:
2121 break;
2122
2123 case clang::Type::ExtVector:
2124 case clang::Type::Vector:
2125 // TODO: Set this to more than one???
2126 break;
2127
2128 case clang::Type::Builtin:
2129 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
2130 {
2131 default: assert(0 && "Unknown builtin type!")((0 && "Unknown builtin type!") ? static_cast<void
> (0) : __assert_fail ("0 && \"Unknown builtin type!\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 2131, __PRETTY_FUNCTION__))
;
2132 case clang::BuiltinType::Void:
2133 break;
2134
2135 case clang::BuiltinType::Bool:
2136 case clang::BuiltinType::Char_S:
2137 case clang::BuiltinType::SChar:
2138 case clang::BuiltinType::WChar_S:
2139 case clang::BuiltinType::Char16:
2140 case clang::BuiltinType::Char32:
2141 case clang::BuiltinType::Short:
2142 case clang::BuiltinType::Int:
2143 case clang::BuiltinType::Long:
2144 case clang::BuiltinType::LongLong:
2145 case clang::BuiltinType::Int128: return lldb::eEncodingSint;
2146
2147 case clang::BuiltinType::Char_U:
2148 case clang::BuiltinType::UChar:
2149 case clang::BuiltinType::WChar_U:
2150 case clang::BuiltinType::UShort:
2151 case clang::BuiltinType::UInt:
2152 case clang::BuiltinType::ULong:
2153 case clang::BuiltinType::ULongLong:
2154 case clang::BuiltinType::UInt128: return lldb::eEncodingUint;
2155
2156 case clang::BuiltinType::Float:
2157 case clang::BuiltinType::Double:
2158 case clang::BuiltinType::LongDouble: return lldb::eEncodingIEEE754;
2159
2160 case clang::BuiltinType::ObjCClass:
2161 case clang::BuiltinType::ObjCId:
2162 case clang::BuiltinType::ObjCSel: return lldb::eEncodingUint;
2163
2164 case clang::BuiltinType::NullPtr: return lldb::eEncodingUint;
2165 }
2166 break;
2167 // All pointer types are represented as unsigned integer encodings.
2168 // We may nee to add a eEncodingPointer if we ever need to know the
2169 // difference
2170 case clang::Type::ObjCObjectPointer:
2171 case clang::Type::BlockPointer:
2172 case clang::Type::Pointer:
2173 case clang::Type::LValueReference:
2174 case clang::Type::RValueReference:
2175 case clang::Type::MemberPointer: return lldb::eEncodingUint;
2176 case clang::Type::Complex:
2177 {
2178 lldb::Encoding encoding = lldb::eEncodingIEEE754;
2179 if (qual_type->isComplexType())
2180 encoding = lldb::eEncodingIEEE754;
2181 else
2182 {
2183 const clang::ComplexType *complex_type = qual_type->getAsComplexIntegerType();
2184 if (complex_type)
2185 encoding = ClangASTType(m_ast, complex_type->getElementType()).GetEncoding(count);
2186 else
2187 encoding = lldb::eEncodingSint;
2188 }
2189 count = 2;
2190 return encoding;
2191 }
2192
2193 case clang::Type::ObjCInterface: break;
2194 case clang::Type::Record: break;
2195 case clang::Type::Enum: return lldb::eEncodingSint;
2196 case clang::Type::Typedef:
2197 return ClangASTType(m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetEncoding(count);
2198
2199 case clang::Type::Elaborated:
2200 return ClangASTType(m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetEncoding(count);
2201
2202 case clang::Type::Paren:
2203 return ClangASTType(m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetEncoding(count);
2204
2205 case clang::Type::DependentSizedArray:
2206 case clang::Type::DependentSizedExtVector:
2207 case clang::Type::UnresolvedUsing:
2208 case clang::Type::Attributed:
2209 case clang::Type::TemplateTypeParm:
2210 case clang::Type::SubstTemplateTypeParm:
2211 case clang::Type::SubstTemplateTypeParmPack:
2212 case clang::Type::Auto:
2213 case clang::Type::InjectedClassName:
2214 case clang::Type::DependentName:
2215 case clang::Type::DependentTemplateSpecialization:
2216 case clang::Type::PackExpansion:
2217 case clang::Type::ObjCObject:
2218
2219 case clang::Type::TypeOfExpr:
2220 case clang::Type::TypeOf:
2221 case clang::Type::Decltype:
2222 case clang::Type::TemplateSpecialization:
2223 case clang::Type::Atomic:
2224 case clang::Type::Adjusted:
2225 break;
2226
2227 // pointer type decayed from an array or function type.
2228 case clang::Type::Decayed:
2229 break;
2230 }
2231 count = 0;
2232 return lldb::eEncodingInvalid;
2233}
2234
2235lldb::Format
2236ClangASTType::GetFormat () const
2237{
2238 if (!IsValid())
2239 return lldb::eFormatDefault;
2240
2241 clang::QualType qual_type(GetCanonicalQualType());
2242
2243 switch (qual_type->getTypeClass())
2244 {
2245 case clang::Type::UnaryTransform:
2246 break;
2247
2248 case clang::Type::FunctionNoProto:
2249 case clang::Type::FunctionProto:
2250 break;
2251
2252 case clang::Type::IncompleteArray:
2253 case clang::Type::VariableArray:
2254 break;
2255
2256 case clang::Type::ConstantArray:
2257 return lldb::eFormatVoid; // no value
2258
2259 case clang::Type::ExtVector:
2260 case clang::Type::Vector:
2261 break;
2262
2263 case clang::Type::Builtin:
2264 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
2265 {
2266 //default: assert(0 && "Unknown builtin type!");
2267 case clang::BuiltinType::UnknownAny:
2268 case clang::BuiltinType::Void:
2269 case clang::BuiltinType::BoundMember:
2270 break;
2271
2272 case clang::BuiltinType::Bool: return lldb::eFormatBoolean;
2273 case clang::BuiltinType::Char_S:
2274 case clang::BuiltinType::SChar:
2275 case clang::BuiltinType::WChar_S:
2276 case clang::BuiltinType::Char_U:
2277 case clang::BuiltinType::UChar:
2278 case clang::BuiltinType::WChar_U: return lldb::eFormatChar;
2279 case clang::BuiltinType::Char16: return lldb::eFormatUnicode16;
2280 case clang::BuiltinType::Char32: return lldb::eFormatUnicode32;
2281 case clang::BuiltinType::UShort: return lldb::eFormatUnsigned;
2282 case clang::BuiltinType::Short: return lldb::eFormatDecimal;
2283 case clang::BuiltinType::UInt: return lldb::eFormatUnsigned;
2284 case clang::BuiltinType::Int: return lldb::eFormatDecimal;
2285 case clang::BuiltinType::ULong: return lldb::eFormatUnsigned;
2286 case clang::BuiltinType::Long: return lldb::eFormatDecimal;
2287 case clang::BuiltinType::ULongLong: return lldb::eFormatUnsigned;
2288 case clang::BuiltinType::LongLong: return lldb::eFormatDecimal;
2289 case clang::BuiltinType::UInt128: return lldb::eFormatUnsigned;
2290 case clang::BuiltinType::Int128: return lldb::eFormatDecimal;
2291 case clang::BuiltinType::Float: return lldb::eFormatFloat;
2292 case clang::BuiltinType::Double: return lldb::eFormatFloat;
2293 case clang::BuiltinType::LongDouble: return lldb::eFormatFloat;
2294 case clang::BuiltinType::NullPtr:
2295 case clang::BuiltinType::Overload:
2296 case clang::BuiltinType::Dependent:
2297 case clang::BuiltinType::ObjCId:
2298 case clang::BuiltinType::ObjCClass:
2299 case clang::BuiltinType::ObjCSel:
2300 case clang::BuiltinType::Half:
2301 case clang::BuiltinType::ARCUnbridgedCast:
2302 case clang::BuiltinType::PseudoObject:
2303 case clang::BuiltinType::BuiltinFn:
2304 case clang::BuiltinType::OCLEvent:
2305 case clang::BuiltinType::OCLImage1d:
2306 case clang::BuiltinType::OCLImage1dArray:
2307 case clang::BuiltinType::OCLImage1dBuffer:
2308 case clang::BuiltinType::OCLImage2d:
2309 case clang::BuiltinType::OCLImage2dArray:
2310 case clang::BuiltinType::OCLImage3d:
2311 case clang::BuiltinType::OCLSampler:
2312 return lldb::eFormatHex;
2313 }
2314 break;
2315 case clang::Type::ObjCObjectPointer: return lldb::eFormatHex;
2316 case clang::Type::BlockPointer: return lldb::eFormatHex;
2317 case clang::Type::Pointer: return lldb::eFormatHex;
2318 case clang::Type::LValueReference:
2319 case clang::Type::RValueReference: return lldb::eFormatHex;
2320 case clang::Type::MemberPointer: break;
2321 case clang::Type::Complex:
2322 {
2323 if (qual_type->isComplexType())
2324 return lldb::eFormatComplex;
2325 else
2326 return lldb::eFormatComplexInteger;
2327 }
2328 case clang::Type::ObjCInterface: break;
2329 case clang::Type::Record: break;
2330 case clang::Type::Enum: return lldb::eFormatEnum;
2331 case clang::Type::Typedef:
2332 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetFormat();
2333 case clang::Type::Auto:
2334 return ClangASTType (m_ast, llvm::cast<clang::AutoType>(qual_type)->desugar()).GetFormat();
2335 case clang::Type::Paren:
2336 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetFormat();
2337 case clang::Type::Elaborated:
2338 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetFormat();
2339 case clang::Type::DependentSizedArray:
2340 case clang::Type::DependentSizedExtVector:
2341 case clang::Type::UnresolvedUsing:
2342 case clang::Type::Attributed:
2343 case clang::Type::TemplateTypeParm:
2344 case clang::Type::SubstTemplateTypeParm:
2345 case clang::Type::SubstTemplateTypeParmPack:
2346 case clang::Type::InjectedClassName:
2347 case clang::Type::DependentName:
2348 case clang::Type::DependentTemplateSpecialization:
2349 case clang::Type::PackExpansion:
2350 case clang::Type::ObjCObject:
2351
2352 case clang::Type::TypeOfExpr:
2353 case clang::Type::TypeOf:
2354 case clang::Type::Decltype:
2355 case clang::Type::TemplateSpecialization:
2356 case clang::Type::Atomic:
2357 case clang::Type::Adjusted:
2358 break;
2359
2360 // pointer type decayed from an array or function type.
2361 case clang::Type::Decayed:
2362 break;
2363 }
2364 // We don't know hot to display this type...
2365 return lldb::eFormatBytes;
2366}
2367
2368static bool
2369ObjCDeclHasIVars (clang::ObjCInterfaceDecl *class_interface_decl, bool check_superclass)
2370{
2371 while (class_interface_decl)
2372 {
2373 if (class_interface_decl->ivar_size() > 0)
2374 return true;
2375
2376 if (check_superclass)
2377 class_interface_decl = class_interface_decl->getSuperClass();
2378 else
2379 break;
2380 }
2381 return false;
2382}
2383
2384uint32_t
2385ClangASTType::GetNumChildren (bool omit_empty_base_classes) const
2386{
2387 if (!IsValid())
2388 return 0;
2389
2390 uint32_t num_children = 0;
2391 clang::QualType qual_type(GetQualType());
2392 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2393 switch (type_class)
2394 {
2395 case clang::Type::Builtin:
2396 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
2397 {
2398 case clang::BuiltinType::ObjCId: // child is Class
2399 case clang::BuiltinType::ObjCClass: // child is Class
2400 num_children = 1;
2401 break;
2402
2403 default:
2404 break;
2405 }
2406 break;
2407
2408 case clang::Type::Complex: return 0;
2409
2410 case clang::Type::Record:
2411 if (GetCompleteQualType (m_ast, qual_type))
2412 {
2413 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
2414 const clang::RecordDecl *record_decl = record_type->getDecl();
2415 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 2415, __PRETTY_FUNCTION__))
;
2416 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
2417 if (cxx_record_decl)
2418 {
2419 if (omit_empty_base_classes)
2420 {
2421 // Check each base classes to see if it or any of its
2422 // base classes contain any fields. This can help
2423 // limit the noise in variable views by not having to
2424 // show base classes that contain no members.
2425 clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2426 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2427 base_class != base_class_end;
2428 ++base_class)
2429 {
2430 const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
2431
2432 // Skip empty base classes
2433 if (ClangASTContext::RecordHasFields(base_class_decl) == false)
2434 continue;
2435
2436 num_children++;
2437 }
2438 }
2439 else
2440 {
2441 // Include all base classes
2442 num_children += cxx_record_decl->getNumBases();
2443 }
2444
2445 }
2446 clang::RecordDecl::field_iterator field, field_end;
2447 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
2448 ++num_children;
2449 }
2450 break;
2451
2452 case clang::Type::ObjCObject:
2453 case clang::Type::ObjCInterface:
2454 if (GetCompleteQualType (m_ast, qual_type))
2455 {
2456 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
2457 assert (objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 2457, __PRETTY_FUNCTION__))
;
2458 if (objc_class_type)
2459 {
2460 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2461
2462 if (class_interface_decl)
2463 {
2464
2465 clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2466 if (superclass_interface_decl)
2467 {
2468 if (omit_empty_base_classes)
2469 {
2470 if (ObjCDeclHasIVars (superclass_interface_decl, true))
2471 ++num_children;
2472 }
2473 else
2474 ++num_children;
2475 }
2476
2477 num_children += class_interface_decl->ivar_size();
2478 }
2479 }
2480 }
2481 break;
2482
2483 case clang::Type::ObjCObjectPointer:
2484 {
2485 const clang::ObjCObjectPointerType *pointer_type = llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr());
2486 clang::QualType pointee_type = pointer_type->getPointeeType();
2487 uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes);
2488 // If this type points to a simple type, then it has 1 child
2489 if (num_pointee_children == 0)
2490 num_children = 1;
2491 else
2492 num_children = num_pointee_children;
2493 }
2494 break;
2495
2496 case clang::Type::Vector:
2497 case clang::Type::ExtVector:
2498 num_children = llvm::cast<clang::VectorType>(qual_type.getTypePtr())->getNumElements();
2499 break;
2500
2501 case clang::Type::ConstantArray:
2502 num_children = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
2503 break;
2504
2505 case clang::Type::Pointer:
2506 {
2507 const clang::PointerType *pointer_type = llvm::cast<clang::PointerType>(qual_type.getTypePtr());
2508 clang::QualType pointee_type (pointer_type->getPointeeType());
2509 uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes);
2510 if (num_pointee_children == 0)
2511 {
2512 // We have a pointer to a pointee type that claims it has no children.
2513 // We will want to look at
2514 num_children = ClangASTType (m_ast, pointee_type).GetNumPointeeChildren();
2515 }
2516 else
2517 num_children = num_pointee_children;
2518 }
2519 break;
2520
2521 case clang::Type::LValueReference:
2522 case clang::Type::RValueReference:
2523 {
2524 const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
2525 clang::QualType pointee_type = reference_type->getPointeeType();
2526 uint32_t num_pointee_children = ClangASTType (m_ast, pointee_type).GetNumChildren (omit_empty_base_classes);
2527 // If this type points to a simple type, then it has 1 child
2528 if (num_pointee_children == 0)
2529 num_children = 1;
2530 else
2531 num_children = num_pointee_children;
2532 }
2533 break;
2534
2535
2536 case clang::Type::Typedef:
2537 num_children = ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumChildren (omit_empty_base_classes);
2538 break;
2539
2540 case clang::Type::Elaborated:
2541 num_children = ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumChildren (omit_empty_base_classes);
2542 break;
2543
2544 case clang::Type::Paren:
2545 num_children = ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumChildren (omit_empty_base_classes);
2546 break;
2547 default:
2548 break;
2549 }
2550 return num_children;
2551}
2552
2553lldb::BasicType
2554ClangASTType::GetBasicTypeEnumeration () const
2555{
2556 if (IsValid())
2557 {
2558 clang::QualType qual_type(GetQualType());
2559 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2560 if (type_class == clang::Type::Builtin)
2561 {
2562 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
2563 {
2564 case clang::BuiltinType::Void: return eBasicTypeVoid;
2565 case clang::BuiltinType::Bool: return eBasicTypeBool;
2566 case clang::BuiltinType::Char_S: return eBasicTypeSignedChar;
2567 case clang::BuiltinType::Char_U: return eBasicTypeUnsignedChar;
2568 case clang::BuiltinType::Char16: return eBasicTypeChar16;
2569 case clang::BuiltinType::Char32: return eBasicTypeChar32;
2570 case clang::BuiltinType::UChar: return eBasicTypeUnsignedChar;
2571 case clang::BuiltinType::SChar: return eBasicTypeSignedChar;
2572 case clang::BuiltinType::WChar_S: return eBasicTypeSignedWChar;
2573 case clang::BuiltinType::WChar_U: return eBasicTypeUnsignedWChar;
2574 case clang::BuiltinType::Short: return eBasicTypeShort;
2575 case clang::BuiltinType::UShort: return eBasicTypeUnsignedShort;
2576 case clang::BuiltinType::Int: return eBasicTypeInt;
2577 case clang::BuiltinType::UInt: return eBasicTypeUnsignedInt;
2578 case clang::BuiltinType::Long: return eBasicTypeLong;
2579 case clang::BuiltinType::ULong: return eBasicTypeUnsignedLong;
2580 case clang::BuiltinType::LongLong: return eBasicTypeLongLong;
2581 case clang::BuiltinType::ULongLong: return eBasicTypeUnsignedLongLong;
2582 case clang::BuiltinType::Int128: return eBasicTypeInt128;
2583 case clang::BuiltinType::UInt128: return eBasicTypeUnsignedInt128;
2584
2585 case clang::BuiltinType::Half: return eBasicTypeHalf;
2586 case clang::BuiltinType::Float: return eBasicTypeFloat;
2587 case clang::BuiltinType::Double: return eBasicTypeDouble;
2588 case clang::BuiltinType::LongDouble:return eBasicTypeLongDouble;
2589
2590 case clang::BuiltinType::NullPtr: return eBasicTypeNullPtr;
2591 case clang::BuiltinType::ObjCId: return eBasicTypeObjCID;
2592 case clang::BuiltinType::ObjCClass: return eBasicTypeObjCClass;
2593 case clang::BuiltinType::ObjCSel: return eBasicTypeObjCSel;
2594 case clang::BuiltinType::Dependent:
2595 case clang::BuiltinType::Overload:
2596 case clang::BuiltinType::BoundMember:
2597 case clang::BuiltinType::PseudoObject:
2598 case clang::BuiltinType::UnknownAny:
2599 case clang::BuiltinType::BuiltinFn:
2600 case clang::BuiltinType::ARCUnbridgedCast:
2601 case clang::BuiltinType::OCLEvent:
2602 case clang::BuiltinType::OCLImage1d:
2603 case clang::BuiltinType::OCLImage1dArray:
2604 case clang::BuiltinType::OCLImage1dBuffer:
2605 case clang::BuiltinType::OCLImage2d:
2606 case clang::BuiltinType::OCLImage2dArray:
2607 case clang::BuiltinType::OCLImage3d:
2608 case clang::BuiltinType::OCLSampler:
2609 return eBasicTypeOther;
2610 }
2611 }
2612 }
2613 return eBasicTypeInvalid;
2614}
2615
2616
2617#pragma mark Aggregate Types
2618
2619uint32_t
2620ClangASTType::GetNumDirectBaseClasses () const
2621{
2622 if (!IsValid())
2623 return 0;
2624
2625 uint32_t count = 0;
2626 clang::QualType qual_type(GetCanonicalQualType());
2627 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2628 switch (type_class)
2629 {
2630 case clang::Type::Record:
2631 if (GetCompleteType())
2632 {
2633 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2634 if (cxx_record_decl)
2635 count = cxx_record_decl->getNumBases();
2636 }
2637 break;
2638
2639 case clang::Type::ObjCObjectPointer:
2640 count = GetPointeeType().GetNumDirectBaseClasses();
2641 break;
2642
2643 case clang::Type::ObjCObject:
2644 if (GetCompleteType())
2645 {
2646 const clang::ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
2647 if (objc_class_type)
2648 {
2649 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2650
2651 if (class_interface_decl && class_interface_decl->getSuperClass())
2652 count = 1;
2653 }
2654 }
2655 break;
2656 case clang::Type::ObjCInterface:
2657 if (GetCompleteType())
2658 {
2659 const clang::ObjCInterfaceType *objc_interface_type = qual_type->getAs<clang::ObjCInterfaceType>();
2660 if (objc_interface_type)
2661 {
2662 clang::ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface();
2663
2664 if (class_interface_decl && class_interface_decl->getSuperClass())
2665 count = 1;
2666 }
2667 }
2668 break;
2669
2670
2671 case clang::Type::Typedef:
2672 count = ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumDirectBaseClasses ();
2673 break;
2674
2675 case clang::Type::Elaborated:
2676 count = ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumDirectBaseClasses ();
2677 break;
2678
2679 case clang::Type::Paren:
2680 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumDirectBaseClasses ();
2681
2682 default:
2683 break;
2684 }
2685 return count;
2686}
2687
2688uint32_t
2689ClangASTType::GetNumVirtualBaseClasses () const
2690{
2691 if (!IsValid())
2692 return 0;
2693
2694 uint32_t count = 0;
2695 clang::QualType qual_type(GetCanonicalQualType());
2696 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2697 switch (type_class)
2698 {
2699 case clang::Type::Record:
2700 if (GetCompleteType())
2701 {
2702 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2703 if (cxx_record_decl)
2704 count = cxx_record_decl->getNumVBases();
2705 }
2706 break;
2707
2708 case clang::Type::Typedef:
2709 count = ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumVirtualBaseClasses();
2710 break;
2711
2712 case clang::Type::Elaborated:
2713 count = ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumVirtualBaseClasses();
2714 break;
2715
2716 case clang::Type::Paren:
2717 count = ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumVirtualBaseClasses();
2718 break;
2719
2720 default:
2721 break;
2722 }
2723 return count;
2724}
2725
2726uint32_t
2727ClangASTType::GetNumFields () const
2728{
2729 if (!IsValid())
2730 return 0;
2731
2732 uint32_t count = 0;
2733 clang::QualType qual_type(GetCanonicalQualType());
2734 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2735 switch (type_class)
2736 {
2737 case clang::Type::Record:
2738 if (GetCompleteType())
2739 {
2740 const clang::RecordType *record_type = llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr());
2741 if (record_type)
2742 {
2743 clang::RecordDecl *record_decl = record_type->getDecl();
2744 if (record_decl)
2745 {
2746 uint32_t field_idx = 0;
2747 clang::RecordDecl::field_iterator field, field_end;
2748 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
2749 ++field_idx;
2750 count = field_idx;
2751 }
2752 }
2753 }
2754 break;
2755
2756 case clang::Type::Typedef:
2757 count = ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumFields();
2758 break;
2759
2760 case clang::Type::Elaborated:
2761 count = ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumFields();
2762 break;
2763
2764 case clang::Type::Paren:
2765 count = ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumFields();
2766 break;
2767
2768 case clang::Type::ObjCObjectPointer:
2769 if (GetCompleteType())
2770 {
2771 const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
2772 if (objc_class_type)
2773 {
2774 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
2775
2776 if (class_interface_decl)
2777 count = class_interface_decl->ivar_size();
2778 }
2779 }
2780 break;
2781
2782 case clang::Type::ObjCObject:
2783 case clang::Type::ObjCInterface:
2784 if (GetCompleteType())
2785 {
2786 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
2787 if (objc_class_type)
2788 {
2789 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2790
2791 if (class_interface_decl)
2792 count = class_interface_decl->ivar_size();
2793 }
2794 }
2795 break;
2796
2797 default:
2798 break;
2799 }
2800 return count;
2801}
2802
2803ClangASTType
2804ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const
2805{
2806 if (!IsValid())
2807 return ClangASTType();
2808
2809 clang::QualType qual_type(GetCanonicalQualType());
2810 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2811 switch (type_class)
2812 {
2813 case clang::Type::Record:
2814 if (GetCompleteType())
2815 {
2816 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2817 if (cxx_record_decl)
2818 {
2819 uint32_t curr_idx = 0;
2820 clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2821 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2822 base_class != base_class_end;
2823 ++base_class, ++curr_idx)
2824 {
2825 if (curr_idx == idx)
2826 {
2827 if (bit_offset_ptr)
2828 {
2829 const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl);
2830 const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
2831 if (base_class->isVirtual())
2832 *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
2833 else
2834 *bit_offset_ptr = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
2835 }
2836 return ClangASTType (m_ast, base_class->getType());
2837 }
2838 }
2839 }
2840 }
2841 break;
2842
2843 case clang::Type::ObjCObjectPointer:
2844 return GetPointeeType().GetDirectBaseClassAtIndex(idx,bit_offset_ptr);
2845
2846 case clang::Type::ObjCObject:
2847 if (idx == 0 && GetCompleteType())
2848 {
2849 const clang::ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
2850 if (objc_class_type)
2851 {
2852 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2853
2854 if (class_interface_decl)
2855 {
2856 clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2857 if (superclass_interface_decl)
2858 {
2859 if (bit_offset_ptr)
2860 *bit_offset_ptr = 0;
2861 return ClangASTType (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl));
2862 }
2863 }
2864 }
2865 }
2866 break;
2867 case clang::Type::ObjCInterface:
2868 if (idx == 0 && GetCompleteType())
2869 {
2870 const clang::ObjCObjectType *objc_interface_type = qual_type->getAs<clang::ObjCInterfaceType>();
2871 if (objc_interface_type)
2872 {
2873 clang::ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface();
2874
2875 if (class_interface_decl)
2876 {
2877 clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2878 if (superclass_interface_decl)
2879 {
2880 if (bit_offset_ptr)
2881 *bit_offset_ptr = 0;
2882 return ClangASTType (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl));
2883 }
2884 }
2885 }
2886 }
2887 break;
2888
2889
2890 case clang::Type::Typedef:
2891 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
2892
2893 case clang::Type::Elaborated:
2894 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
2895
2896 case clang::Type::Paren:
2897 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
2898
2899 default:
2900 break;
2901 }
2902 return ClangASTType();
2903}
2904
2905ClangASTType
2906ClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const
2907{
2908 if (!IsValid())
2909 return ClangASTType();
2910
2911 clang::QualType qual_type(GetCanonicalQualType());
2912 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2913 switch (type_class)
2914 {
2915 case clang::Type::Record:
2916 if (GetCompleteType())
2917 {
2918 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2919 if (cxx_record_decl)
2920 {
2921 uint32_t curr_idx = 0;
2922 clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2923 for (base_class = cxx_record_decl->vbases_begin(), base_class_end = cxx_record_decl->vbases_end();
2924 base_class != base_class_end;
2925 ++base_class, ++curr_idx)
2926 {
2927 if (curr_idx == idx)
2928 {
2929 if (bit_offset_ptr)
2930 {
2931 const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl);
2932 const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
2933 *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
2934
2935 }
2936 return ClangASTType (m_ast, base_class->getType());
2937 }
2938 }
2939 }
2940 }
2941 break;
2942
2943 case clang::Type::Typedef:
2944 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
2945
2946 case clang::Type::Elaborated:
2947 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
2948
2949 case clang::Type::Paren:
2950 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
2951
2952 default:
2953 break;
2954 }
2955 return ClangASTType();
2956}
2957
2958static clang_type_t
2959GetObjCFieldAtIndex (clang::ASTContext *ast,
2960 clang::ObjCInterfaceDecl *class_interface_decl,
2961 size_t idx,
2962 std::string& name,
2963 uint64_t *bit_offset_ptr,
2964 uint32_t *bitfield_bit_size_ptr,
2965 bool *is_bitfield_ptr)
2966{
2967 if (class_interface_decl)
2968 {
2969 if (idx < (class_interface_decl->ivar_size()))
2970 {
2971 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
2972 uint32_t ivar_idx = 0;
2973
2974 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++ivar_idx)
2975 {
2976 if (ivar_idx == idx)
2977 {
2978 const clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
2979
2980 clang::QualType ivar_qual_type(ivar_decl->getType());
2981
2982 name.assign(ivar_decl->getNameAsString());
2983
2984 if (bit_offset_ptr)
2985 {
2986 const clang::ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl);
2987 *bit_offset_ptr = interface_layout.getFieldOffset (ivar_idx);
2988 }
2989
2990 const bool is_bitfield = ivar_pos->isBitField();
2991
2992 if (bitfield_bit_size_ptr)
2993 {
2994 *bitfield_bit_size_ptr = 0;
2995
2996 if (is_bitfield && ast)
2997 {
2998 clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth();
2999 llvm::APSInt bitfield_apsint;
3000 if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *ast))
3001 {
3002 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
3003 }
3004 }
3005 }
3006 if (is_bitfield_ptr)
3007 *is_bitfield_ptr = is_bitfield;
3008
3009 return ivar_qual_type.getAsOpaquePtr();
3010 }
3011 }
3012 }
3013 }
3014 return nullptr;
3015}
3016
3017ClangASTType
3018ClangASTType::GetFieldAtIndex (size_t idx,
3019 std::string& name,
3020 uint64_t *bit_offset_ptr,
3021 uint32_t *bitfield_bit_size_ptr,
3022 bool *is_bitfield_ptr) const
3023{
3024 if (!IsValid())
3025 return ClangASTType();
3026
3027 clang::QualType qual_type(GetCanonicalQualType());
3028 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3029 switch (type_class)
3030 {
3031 case clang::Type::Record:
3032 if (GetCompleteType())
3033 {
3034 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3035 const clang::RecordDecl *record_decl = record_type->getDecl();
3036 uint32_t field_idx = 0;
3037 clang::RecordDecl::field_iterator field, field_end;
3038 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx)
3039 {
3040 if (idx == field_idx)
3041 {
3042 // Print the member type if requested
3043 // Print the member name and equal sign
3044 name.assign(field->getNameAsString());
3045
3046 // Figure out the type byte size (field_type_info.first) and
3047 // alignment (field_type_info.second) from the AST context.
3048 if (bit_offset_ptr)
3049 {
3050 const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
3051 *bit_offset_ptr = record_layout.getFieldOffset (field_idx);
3052 }
3053
3054 const bool is_bitfield = field->isBitField();
3055
3056 if (bitfield_bit_size_ptr)
3057 {
3058 *bitfield_bit_size_ptr = 0;
3059
3060 if (is_bitfield)
3061 {
3062 clang::Expr *bitfield_bit_size_expr = field->getBitWidth();
3063 llvm::APSInt bitfield_apsint;
3064 if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *m_ast))
3065 {
3066 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
3067 }
3068 }
3069 }
3070 if (is_bitfield_ptr)
3071 *is_bitfield_ptr = is_bitfield;
3072
3073 return ClangASTType (m_ast, field->getType());
3074 }
3075 }
3076 }
3077 break;
3078
3079 case clang::Type::ObjCObjectPointer:
3080 if (GetCompleteType())
3081 {
3082 const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
3083 if (objc_class_type)
3084 {
3085 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
3086 return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
3087 }
3088 }
3089 break;
3090
3091 case clang::Type::ObjCObject:
3092 case clang::Type::ObjCInterface:
3093 if (GetCompleteType())
3094 {
3095 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
3096 assert (objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 3096, __PRETTY_FUNCTION__))
;
3097 if (objc_class_type)
3098 {
3099 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3100 return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
3101 }
3102 }
3103 break;
3104
3105
3106 case clang::Type::Typedef:
3107 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).
3108 GetFieldAtIndex (idx,
3109 name,
3110 bit_offset_ptr,
3111 bitfield_bit_size_ptr,
3112 is_bitfield_ptr);
3113
3114 case clang::Type::Elaborated:
3115 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).
3116 GetFieldAtIndex (idx,
3117 name,
3118 bit_offset_ptr,
3119 bitfield_bit_size_ptr,
3120 is_bitfield_ptr);
3121
3122 case clang::Type::Paren:
3123 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).
3124 GetFieldAtIndex (idx,
3125 name,
3126 bit_offset_ptr,
3127 bitfield_bit_size_ptr,
3128 is_bitfield_ptr);
3129
3130 default:
3131 break;
3132 }
3133 return ClangASTType();
3134}
3135
3136uint32_t
3137ClangASTType::GetIndexOfFieldWithName (const char* name,
3138 ClangASTType* field_clang_type_ptr,
3139 uint64_t *bit_offset_ptr,
3140 uint32_t *bitfield_bit_size_ptr,
3141 bool *is_bitfield_ptr) const
3142{
3143 unsigned count = GetNumFields();
3144 std::string field_name;
3145 for (unsigned index = 0; index < count; index++)
3146 {
3147 ClangASTType field_clang_type (GetFieldAtIndex(index, field_name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
3148 if (strcmp(field_name.c_str(), name) == 0)
3149 {
3150 if (field_clang_type_ptr)
3151 *field_clang_type_ptr = field_clang_type;
3152 return index;
3153 }
3154 }
3155 return UINT32_MAX(4294967295U);
3156}
3157
3158// If a pointer to a pointee type (the clang_type arg) says that it has no
3159// children, then we either need to trust it, or override it and return a
3160// different result. For example, an "int *" has one child that is an integer,
3161// but a function pointer doesn't have any children. Likewise if a Record type
3162// claims it has no children, then there really is nothing to show.
3163uint32_t
3164ClangASTType::GetNumPointeeChildren () const
3165{
3166 if (!IsValid())
3167 return 0;
3168
3169 clang::QualType qual_type(GetCanonicalQualType());
3170 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3171 switch (type_class)
3172 {
3173 case clang::Type::Builtin:
3174 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
3175 {
3176 case clang::BuiltinType::UnknownAny:
3177 case clang::BuiltinType::Void:
3178 case clang::BuiltinType::NullPtr:
3179 case clang::BuiltinType::OCLEvent:
3180 case clang::BuiltinType::OCLImage1d:
3181 case clang::BuiltinType::OCLImage1dArray:
3182 case clang::BuiltinType::OCLImage1dBuffer:
3183 case clang::BuiltinType::OCLImage2d:
3184 case clang::BuiltinType::OCLImage2dArray:
3185 case clang::BuiltinType::OCLImage3d:
3186 case clang::BuiltinType::OCLSampler:
3187 return 0;
3188 case clang::BuiltinType::Bool:
3189 case clang::BuiltinType::Char_U:
3190 case clang::BuiltinType::UChar:
3191 case clang::BuiltinType::WChar_U:
3192 case clang::BuiltinType::Char16:
3193 case clang::BuiltinType::Char32:
3194 case clang::BuiltinType::UShort:
3195 case clang::BuiltinType::UInt:
3196 case clang::BuiltinType::ULong:
3197 case clang::BuiltinType::ULongLong:
3198 case clang::BuiltinType::UInt128:
3199 case clang::BuiltinType::Char_S:
3200 case clang::BuiltinType::SChar:
3201 case clang::BuiltinType::WChar_S:
3202 case clang::BuiltinType::Short:
3203 case clang::BuiltinType::Int:
3204 case clang::BuiltinType::Long:
3205 case clang::BuiltinType::LongLong:
3206 case clang::BuiltinType::Int128:
3207 case clang::BuiltinType::Float:
3208 case clang::BuiltinType::Double:
3209 case clang::BuiltinType::LongDouble:
3210 case clang::BuiltinType::Dependent:
3211 case clang::BuiltinType::Overload:
3212 case clang::BuiltinType::ObjCId:
3213 case clang::BuiltinType::ObjCClass:
3214 case clang::BuiltinType::ObjCSel:
3215 case clang::BuiltinType::BoundMember:
3216 case clang::BuiltinType::Half:
3217 case clang::BuiltinType::ARCUnbridgedCast:
3218 case clang::BuiltinType::PseudoObject:
3219 case clang::BuiltinType::BuiltinFn:
3220 return 1;
3221 }
3222 break;
3223
3224 case clang::Type::Complex: return 1;
3225 case clang::Type::Pointer: return 1;
3226 case clang::Type::BlockPointer: return 0; // If block pointers don't have debug info, then no children for them
3227 case clang::Type::LValueReference: return 1;
3228 case clang::Type::RValueReference: return 1;
3229 case clang::Type::MemberPointer: return 0;
3230 case clang::Type::ConstantArray: return 0;
3231 case clang::Type::IncompleteArray: return 0;
3232 case clang::Type::VariableArray: return 0;
3233 case clang::Type::DependentSizedArray: return 0;
3234 case clang::Type::DependentSizedExtVector: return 0;
3235 case clang::Type::Vector: return 0;
3236 case clang::Type::ExtVector: return 0;
3237 case clang::Type::FunctionProto: return 0; // When we function pointers, they have no children...
3238 case clang::Type::FunctionNoProto: return 0; // When we function pointers, they have no children...
3239 case clang::Type::UnresolvedUsing: return 0;
3240 case clang::Type::Paren: return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumPointeeChildren ();
3241 case clang::Type::Typedef: return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumPointeeChildren ();
3242 case clang::Type::Elaborated: return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumPointeeChildren ();
3243 case clang::Type::TypeOfExpr: return 0;
3244 case clang::Type::TypeOf: return 0;
3245 case clang::Type::Decltype: return 0;
3246 case clang::Type::Record: return 0;
3247 case clang::Type::Enum: return 1;
3248 case clang::Type::TemplateTypeParm: return 1;
3249 case clang::Type::SubstTemplateTypeParm: return 1;
3250 case clang::Type::TemplateSpecialization: return 1;
3251 case clang::Type::InjectedClassName: return 0;
3252 case clang::Type::DependentName: return 1;
3253 case clang::Type::DependentTemplateSpecialization: return 1;
3254 case clang::Type::ObjCObject: return 0;
3255 case clang::Type::ObjCInterface: return 0;
3256 case clang::Type::ObjCObjectPointer: return 1;
3257 default:
3258 break;
3259 }
3260 return 0;
3261}
3262
3263
3264ClangASTType
3265ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
3266 size_t idx,
3267 bool transparent_pointers,
3268 bool omit_empty_base_classes,
3269 bool ignore_array_bounds,
3270 std::string& child_name,
3271 uint32_t &child_byte_size,
3272 int32_t &child_byte_offset,
3273 uint32_t &child_bitfield_bit_size,
3274 uint32_t &child_bitfield_bit_offset,
3275 bool &child_is_base_class,
3276 bool &child_is_deref_of_parent,
3277 ValueObject *valobj) const
3278{
3279 if (!IsValid())
3280 return ClangASTType();
3281
3282 clang::QualType parent_qual_type(GetCanonicalQualType());
3283 const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass();
3284 child_bitfield_bit_size = 0;
3285 child_bitfield_bit_offset = 0;
3286 child_is_base_class = false;
3287
3288 const bool idx_is_valid = idx < GetNumChildren (omit_empty_base_classes);
3289 uint32_t bit_offset;
3290 switch (parent_type_class)
3291 {
3292 case clang::Type::Builtin:
3293 if (idx_is_valid)
3294 {
3295 switch (llvm::cast<clang::BuiltinType>(parent_qual_type)->getKind())
3296 {
3297 case clang::BuiltinType::ObjCId:
3298 case clang::BuiltinType::ObjCClass:
3299 child_name = "isa";
3300 child_byte_size = m_ast->getTypeSize(m_ast->ObjCBuiltinClassTy) / CHAR_BIT8;
3301 return ClangASTType (m_ast, m_ast->ObjCBuiltinClassTy);
3302
3303 default:
3304 break;
3305 }
3306 }
3307 break;
3308
3309 case clang::Type::Record:
3310 if (idx_is_valid && GetCompleteType())
3311 {
3312 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(parent_qual_type.getTypePtr());
3313 const clang::RecordDecl *record_decl = record_type->getDecl();
3314 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 3314, __PRETTY_FUNCTION__))
;
3315 const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
3316 uint32_t child_idx = 0;
3317
3318 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
3319 if (cxx_record_decl)
3320 {
3321 // We might have base classes to print out first
3322 clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3323 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3324 base_class != base_class_end;
3325 ++base_class)
3326 {
3327 const clang::CXXRecordDecl *base_class_decl = nullptr;
3328
3329 // Skip empty base classes
3330 if (omit_empty_base_classes)
3331 {
3332 base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
3333 if (ClangASTContext::RecordHasFields(base_class_decl) == false)
3334 continue;
3335 }
3336
3337 if (idx == child_idx)
3338 {
3339 if (base_class_decl == nullptr)
3340 base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
3341
3342
3343 if (base_class->isVirtual())
3344 {
3345 bool handled = false;
3346 if (valobj)
3347 {
3348 Error err;
3349 AddressType addr_type = eAddressTypeInvalid;
3350 lldb::addr_t vtable_ptr_addr = valobj->GetCPPVTableAddress(addr_type);
3351
3352 if (vtable_ptr_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL) && addr_type == eAddressTypeLoad)
3353 {
3354
3355 ExecutionContext exe_ctx (valobj->GetExecutionContextRef());
3356 Process *process = exe_ctx.GetProcessPtr();
3357 if (process)
3358 {
3359 clang::VTableContextBase *vtable_ctx = m_ast->getVTableContext();
3360 if (vtable_ctx)
3361 {
3362 if (vtable_ctx->isMicrosoft())
3363 {
3364 clang::MicrosoftVTableContext *msoft_vtable_ctx = static_cast<clang::MicrosoftVTableContext *>(vtable_ctx);
3365
3366 if (vtable_ptr_addr)
3367 {
3368 const lldb::addr_t vbtable_ptr_addr = vtable_ptr_addr + record_layout.getVBPtrOffset().getQuantity();
3369
3370 const lldb::addr_t vbtable_ptr = process->ReadPointerFromMemory(vbtable_ptr_addr, err);
3371 if (vbtable_ptr != LLDB_INVALID_ADDRESS(18446744073709551615UL))
3372 {
3373 // Get the index into the virtual base table. The index is the index in uint32_t from vbtable_ptr
3374 const unsigned vbtable_index = msoft_vtable_ctx->getVBTableIndex(cxx_record_decl, base_class_decl);
3375 const lldb::addr_t base_offset_addr = vbtable_ptr + vbtable_index * 4;
3376 const uint32_t base_offset = process->ReadUnsignedIntegerFromMemory(base_offset_addr, 4, UINT32_MAX(4294967295U), err);
3377 if (base_offset != UINT32_MAX(4294967295U))
3378 {
3379 handled = true;
3380 bit_offset = base_offset * 8;
3381 }
3382 }
3383 }
3384 }
3385 else
3386 {
3387 clang::ItaniumVTableContext *itanium_vtable_ctx = static_cast<clang::ItaniumVTableContext *>(vtable_ctx);
3388 if (vtable_ptr_addr)
3389 {
3390 const lldb::addr_t vtable_ptr = process->ReadPointerFromMemory(vtable_ptr_addr, err);
3391 if (vtable_ptr != LLDB_INVALID_ADDRESS(18446744073709551615UL))
3392 {
3393 clang::CharUnits base_offset_offset = itanium_vtable_ctx->getVirtualBaseOffsetOffset(cxx_record_decl, base_class_decl);
3394 const lldb::addr_t base_offset_addr = vtable_ptr + base_offset_offset.getQuantity();
3395 const uint32_t base_offset = process->ReadUnsignedIntegerFromMemory(base_offset_addr, 4, UINT32_MAX(4294967295U), err);
3396 if (base_offset != UINT32_MAX(4294967295U))
3397 {
3398 handled = true;
3399 bit_offset = base_offset * 8;
3400 }
3401 }
3402 }
3403 }
3404 }
3405 }
3406 }
3407
3408 }
3409 if (!handled)
3410 bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
3411 }
3412 else
3413 bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
3414
3415 // Base classes should be a multiple of 8 bits in size
3416 child_byte_offset = bit_offset/8;
3417 ClangASTType base_class_clang_type(m_ast, base_class->getType());
3418 child_name = base_class_clang_type.GetTypeName().AsCString("");
3419 uint64_t base_class_clang_type_bit_size = base_class_clang_type.GetBitSize();
3420
3421 // Base classes bit sizes should be a multiple of 8 bits in size
3422 assert (base_class_clang_type_bit_size % 8 == 0)((base_class_clang_type_bit_size % 8 == 0) ? static_cast<void
> (0) : __assert_fail ("base_class_clang_type_bit_size % 8 == 0"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 3422, __PRETTY_FUNCTION__))
;
3423 child_byte_size = base_class_clang_type_bit_size / 8;
3424 child_is_base_class = true;
3425 return base_class_clang_type;
3426 }
3427 // We don't increment the child index in the for loop since we might
3428 // be skipping empty base classes
3429 ++child_idx;
3430 }
3431 }
3432 // Make sure index is in range...
3433 uint32_t field_idx = 0;
3434 clang::RecordDecl::field_iterator field, field_end;
3435 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx)
3436 {
3437 if (idx == child_idx)
3438 {
3439 // Print the member type if requested
3440 // Print the member name and equal sign
3441 child_name.assign(field->getNameAsString().c_str());
3442
3443 // Figure out the type byte size (field_type_info.first) and
3444 // alignment (field_type_info.second) from the AST context.
3445 ClangASTType field_clang_type (m_ast, field->getType());
3446 assert(field_idx < record_layout.getFieldCount())((field_idx < record_layout.getFieldCount()) ? static_cast
<void> (0) : __assert_fail ("field_idx < record_layout.getFieldCount()"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 3446, __PRETTY_FUNCTION__))
;
3447 child_byte_size = field_clang_type.GetByteSize();
3448
3449 // Figure out the field offset within the current struct/union/class type
3450 bit_offset = record_layout.getFieldOffset (field_idx);
3451 child_byte_offset = bit_offset / 8;
3452 if (ClangASTContext::FieldIsBitfield (m_ast, *field, child_bitfield_bit_size))
3453 child_bitfield_bit_offset = bit_offset % 8;
3454
3455 return field_clang_type;
3456 }
3457 }
3458 }
3459 break;
3460
3461 case clang::Type::ObjCObject:
3462 case clang::Type::ObjCInterface:
3463 if (idx_is_valid && GetCompleteType())
3464 {
3465 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(parent_qual_type.getTypePtr());
3466 assert (objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 3466, __PRETTY_FUNCTION__))
;
3467 if (objc_class_type)
3468 {
3469 uint32_t child_idx = 0;
3470 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3471
3472 if (class_interface_decl)
3473 {
3474
3475 const clang::ASTRecordLayout &interface_layout = m_ast->getASTObjCInterfaceLayout(class_interface_decl);
3476 clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3477 if (superclass_interface_decl)
3478 {
3479 if (omit_empty_base_classes)
3480 {
3481 ClangASTType base_class_clang_type (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl));
3482 if (base_class_clang_type.GetNumChildren(omit_empty_base_classes) > 0)
3483 {
3484 if (idx == 0)
3485 {
3486 clang::QualType ivar_qual_type(m_ast->getObjCInterfaceType(superclass_interface_decl));
3487
3488
3489 child_name.assign(superclass_interface_decl->getNameAsString().c_str());
3490
3491 clang::TypeInfo ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr());
3492
3493 child_byte_size = ivar_type_info.Width / 8;
3494 child_byte_offset = 0;
3495 child_is_base_class = true;
3496
3497 return ClangASTType (m_ast, ivar_qual_type);
3498 }
3499
3500 ++child_idx;
3501 }
3502 }
3503 else
3504 ++child_idx;
3505 }
3506
3507 const uint32_t superclass_idx = child_idx;
3508
3509 if (idx < (child_idx + class_interface_decl->ivar_size()))
3510 {
3511 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
3512
3513 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
3514 {
3515 if (child_idx == idx)
3516 {
3517 clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
3518
3519 clang::QualType ivar_qual_type(ivar_decl->getType());
3520
3521 child_name.assign(ivar_decl->getNameAsString().c_str());
3522
3523 clang::TypeInfo ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr());
3524
3525 child_byte_size = ivar_type_info.Width / 8;
3526
3527 // Figure out the field offset within the current struct/union/class type
3528 // For ObjC objects, we can't trust the bit offset we get from the Clang AST, since
3529 // that doesn't account for the space taken up by unbacked properties, or from
3530 // the changing size of base classes that are newer than this class.
3531 // So if we have a process around that we can ask about this object, do so.
3532 child_byte_offset = LLDB_INVALID_IVAR_OFFSET(4294967295U);
3533 Process *process = nullptr;
3534 if (exe_ctx)
3535 process = exe_ctx->GetProcessPtr();
3536 if (process)
3537 {
3538 ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
3539 if (objc_runtime != nullptr)
3540 {
3541 ClangASTType parent_ast_type (m_ast, parent_qual_type);
3542 child_byte_offset = objc_runtime->GetByteOffsetForIvar (parent_ast_type, ivar_decl->getNameAsString().c_str());
3543 }
3544 }
3545
3546 // Setting this to UINT32_MAX to make sure we don't compute it twice...
3547 bit_offset = UINT32_MAX(4294967295U);
3548
3549 if (child_byte_offset == static_cast<int32_t>(LLDB_INVALID_IVAR_OFFSET(4294967295U)))
3550 {
3551 bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
3552 child_byte_offset = bit_offset / 8;
3553 }
3554
3555 // Note, the ObjC Ivar Byte offset is just that, it doesn't account for the bit offset
3556 // of a bitfield within its containing object. So regardless of where we get the byte
3557 // offset from, we still need to get the bit offset for bitfields from the layout.
3558
3559 if (ClangASTContext::FieldIsBitfield (m_ast, ivar_decl, child_bitfield_bit_size))
3560 {
3561 if (bit_offset == UINT32_MAX(4294967295U))
3562 bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
3563
3564 child_bitfield_bit_offset = bit_offset % 8;
3565 }
3566 return ClangASTType (m_ast, ivar_qual_type);
3567 }
3568 ++child_idx;
3569 }
3570 }
3571 }
3572 }
3573 }
3574 break;
3575
3576 case clang::Type::ObjCObjectPointer:
3577 if (idx_is_valid)
3578 {
3579 ClangASTType pointee_clang_type (GetPointeeType());
3580
3581 if (transparent_pointers && pointee_clang_type.IsAggregateType())
3582 {
3583 child_is_deref_of_parent = false;
3584 bool tmp_child_is_deref_of_parent = false;
3585 return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3586 idx,
3587 transparent_pointers,
3588 omit_empty_base_classes,
3589 ignore_array_bounds,
3590 child_name,
3591 child_byte_size,
3592 child_byte_offset,
3593 child_bitfield_bit_size,
3594 child_bitfield_bit_offset,
3595 child_is_base_class,
3596 tmp_child_is_deref_of_parent,
3597 valobj);
3598 }
3599 else
3600 {
3601 child_is_deref_of_parent = true;
3602 const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL__null;
3603 if (parent_name)
3604 {
3605 child_name.assign(1, '*');
3606 child_name += parent_name;
3607 }
3608
3609 // We have a pointer to an simple type
3610 if (idx == 0 && pointee_clang_type.GetCompleteType())
3611 {
3612 child_byte_size = pointee_clang_type.GetByteSize();
3613 child_byte_offset = 0;
3614 return pointee_clang_type;
3615 }
3616 }
3617 }
3618 break;
3619
3620 case clang::Type::Vector:
3621 case clang::Type::ExtVector:
3622 if (idx_is_valid)
3623 {
3624 const clang::VectorType *array = llvm::cast<clang::VectorType>(parent_qual_type.getTypePtr());
3625 if (array)
3626 {
3627 ClangASTType element_type (m_ast, array->getElementType());
3628 if (element_type.GetCompleteType())
3629 {
3630 char element_name[64];
3631 ::snprintf (element_name, sizeof (element_name), "[%zu]", idx);
3632 child_name.assign(element_name);
3633 child_byte_size = element_type.GetByteSize();
3634 child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
3635 return element_type;
3636 }
3637 }
3638 }
3639 break;
3640
3641 case clang::Type::ConstantArray:
3642 case clang::Type::IncompleteArray:
3643 if (ignore_array_bounds || idx_is_valid)
3644 {
3645 const clang::ArrayType *array = llvm::cast<clang::ArrayType>(parent_qual_type.getTypePtr());
3646 if (array)
3647 {
3648 ClangASTType element_type (m_ast, array->getElementType());
3649 if (element_type.GetCompleteType())
3650 {
3651 char element_name[64];
3652 ::snprintf (element_name, sizeof (element_name), "[%zu]", idx);
3653 child_name.assign(element_name);
3654 child_byte_size = element_type.GetByteSize();
3655 child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
3656 return element_type;
3657 }
3658 }
3659 }
3660 break;
3661
3662
3663 case clang::Type::Pointer:
3664 if (idx_is_valid)
3665 {
3666 ClangASTType pointee_clang_type (GetPointeeType());
3667
3668 // Don't dereference "void *" pointers
3669 if (pointee_clang_type.IsVoidType())
3670 return ClangASTType();
3671
3672 if (transparent_pointers && pointee_clang_type.IsAggregateType ())
3673 {
3674 child_is_deref_of_parent = false;
3675 bool tmp_child_is_deref_of_parent = false;
3676 return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3677 idx,
3678 transparent_pointers,
3679 omit_empty_base_classes,
3680 ignore_array_bounds,
3681 child_name,
3682 child_byte_size,
3683 child_byte_offset,
3684 child_bitfield_bit_size,
3685 child_bitfield_bit_offset,
3686 child_is_base_class,
3687 tmp_child_is_deref_of_parent,
3688 valobj);
3689 }
3690 else
3691 {
3692 child_is_deref_of_parent = true;
3693
3694 const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL__null;
3695 if (parent_name)
3696 {
3697 child_name.assign(1, '*');
3698 child_name += parent_name;
3699 }
3700
3701 // We have a pointer to an simple type
3702 if (idx == 0)
3703 {
3704 child_byte_size = pointee_clang_type.GetByteSize();
3705 child_byte_offset = 0;
3706 return pointee_clang_type;
3707 }
3708 }
3709 }
3710 break;
3711
3712 case clang::Type::LValueReference:
3713 case clang::Type::RValueReference:
3714 if (idx_is_valid)
3715 {
3716 const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(parent_qual_type.getTypePtr());
3717 ClangASTType pointee_clang_type (m_ast, reference_type->getPointeeType());
3718 if (transparent_pointers && pointee_clang_type.IsAggregateType ())
3719 {
3720 child_is_deref_of_parent = false;
3721 bool tmp_child_is_deref_of_parent = false;
3722 return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3723 idx,
3724 transparent_pointers,
3725 omit_empty_base_classes,
3726 ignore_array_bounds,
3727 child_name,
3728 child_byte_size,
3729 child_byte_offset,
3730 child_bitfield_bit_size,
3731 child_bitfield_bit_offset,
3732 child_is_base_class,
3733 tmp_child_is_deref_of_parent,
3734 valobj);
3735 }
3736 else
3737 {
3738 const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL__null;
3739 if (parent_name)
3740 {
3741 child_name.assign(1, '&');
3742 child_name += parent_name;
3743 }
3744
3745 // We have a pointer to an simple type
3746 if (idx == 0)
3747 {
3748 child_byte_size = pointee_clang_type.GetByteSize();
3749 child_byte_offset = 0;
3750 return pointee_clang_type;
3751 }
3752 }
3753 }
3754 break;
3755
3756 case clang::Type::Typedef:
3757 {
3758 ClangASTType typedefed_clang_type (m_ast, llvm::cast<clang::TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType());
3759 return typedefed_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3760 idx,
3761 transparent_pointers,
3762 omit_empty_base_classes,
3763 ignore_array_bounds,
3764 child_name,
3765 child_byte_size,
3766 child_byte_offset,
3767 child_bitfield_bit_size,
3768 child_bitfield_bit_offset,
3769 child_is_base_class,
3770 child_is_deref_of_parent,
3771 valobj);
3772 }
3773 break;
3774
3775 case clang::Type::Elaborated:
3776 {
3777 ClangASTType elaborated_clang_type (m_ast, llvm::cast<clang::ElaboratedType>(parent_qual_type)->getNamedType());
3778 return elaborated_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3779 idx,
3780 transparent_pointers,
3781 omit_empty_base_classes,
3782 ignore_array_bounds,
3783 child_name,
3784 child_byte_size,
3785 child_byte_offset,
3786 child_bitfield_bit_size,
3787 child_bitfield_bit_offset,
3788 child_is_base_class,
3789 child_is_deref_of_parent,
3790 valobj);
3791 }
3792
3793 case clang::Type::Paren:
3794 {
3795 ClangASTType paren_clang_type (m_ast, llvm::cast<clang::ParenType>(parent_qual_type)->desugar());
3796 return paren_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3797 idx,
3798 transparent_pointers,
3799 omit_empty_base_classes,
3800 ignore_array_bounds,
3801 child_name,
3802 child_byte_size,
3803 child_byte_offset,
3804 child_bitfield_bit_size,
3805 child_bitfield_bit_offset,
3806 child_is_base_class,
3807 child_is_deref_of_parent,
3808 valobj);
3809 }
3810
3811
3812 default:
3813 break;
3814 }
3815 return ClangASTType();
3816}
3817
3818static inline bool
3819BaseSpecifierIsEmpty (const clang::CXXBaseSpecifier *b)
3820{
3821 return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false;
3822}
3823
3824static uint32_t
3825GetIndexForRecordBase
3826(
3827 const clang::RecordDecl *record_decl,
3828 const clang::CXXBaseSpecifier *base_spec,
3829 bool omit_empty_base_classes
3830 )
3831{
3832 uint32_t child_idx = 0;
3833
3834 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
3835
3836 // const char *super_name = record_decl->getNameAsCString();
3837 // const char *base_name = base_spec->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString();
3838 // printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name);
3839 //
3840 if (cxx_record_decl)
3841 {
3842 clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3843 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3844 base_class != base_class_end;
3845 ++base_class)
3846 {
3847 if (omit_empty_base_classes)
3848 {
3849 if (BaseSpecifierIsEmpty (base_class))
3850 continue;
3851 }
3852
3853 // printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name,
3854 // child_idx,
3855 // base_class->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString());
3856 //
3857 //
3858 if (base_class == base_spec)
3859 return child_idx;
3860 ++child_idx;
3861 }
3862 }
3863
3864 return UINT32_MAX(4294967295U);
3865}
3866
3867
3868static uint32_t
3869GetIndexForRecordChild (const clang::RecordDecl *record_decl,
3870 clang::NamedDecl *canonical_decl,
3871 bool omit_empty_base_classes)
3872{
3873 uint32_t child_idx = ClangASTContext::GetNumBaseClasses (llvm::dyn_cast<clang::CXXRecordDecl>(record_decl),
3874 omit_empty_base_classes);
3875
3876 clang::RecordDecl::field_iterator field, field_end;
3877 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
3878 field != field_end;
3879 ++field, ++child_idx)
3880 {
3881 if (field->getCanonicalDecl() == canonical_decl)
3882 return child_idx;
3883 }
3884
3885 return UINT32_MAX(4294967295U);
3886}
3887
3888// Look for a child member (doesn't include base classes, but it does include
3889// their members) in the type hierarchy. Returns an index path into "clang_type"
3890// on how to reach the appropriate member.
3891//
3892// class A
3893// {
3894// public:
3895// int m_a;
3896// int m_b;
3897// };
3898//
3899// class B
3900// {
3901// };
3902//
3903// class C :
3904// public B,
3905// public A
3906// {
3907// };
3908//
3909// If we have a clang type that describes "class C", and we wanted to looked
3910// "m_b" in it:
3911//
3912// With omit_empty_base_classes == false we would get an integer array back with:
3913// { 1, 1 }
3914// The first index 1 is the child index for "class A" within class C
3915// The second index 1 is the child index for "m_b" within class A
3916//
3917// With omit_empty_base_classes == true we would get an integer array back with:
3918// { 0, 1 }
3919// The first index 0 is the child index for "class A" within class C (since class B doesn't have any members it doesn't count)
3920// The second index 1 is the child index for "m_b" within class A
3921
3922size_t
3923ClangASTType::GetIndexOfChildMemberWithName (const char *name,
3924 bool omit_empty_base_classes,
3925 std::vector<uint32_t>& child_indexes) const
3926{
3927 if (IsValid() && name && name[0])
3928 {
3929 clang::QualType qual_type(GetCanonicalQualType());
3930 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3931 switch (type_class)
3932 {
3933 case clang::Type::Record:
3934 if (GetCompleteType ())
3935 {
3936 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3937 const clang::RecordDecl *record_decl = record_type->getDecl();
3938
3939 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 3939, __PRETTY_FUNCTION__))
;
3940 uint32_t child_idx = 0;
3941
3942 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
3943
3944 // Try and find a field that matches NAME
3945 clang::RecordDecl::field_iterator field, field_end;
3946 llvm::StringRef name_sref(name);
3947 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
3948 field != field_end;
3949 ++field, ++child_idx)
3950 {
3951 llvm::StringRef field_name = field->getName();
3952 if (field_name.empty())
3953 {
3954 ClangASTType field_type(m_ast,field->getType());
3955 child_indexes.push_back(child_idx);
3956 if (field_type.GetIndexOfChildMemberWithName(name, omit_empty_base_classes, child_indexes))
3957 return child_indexes.size();
3958 child_indexes.pop_back();
3959
3960 }
3961 else if (field_name.equals (name_sref))
3962 {
3963 // We have to add on the number of base classes to this index!
3964 child_indexes.push_back (child_idx + ClangASTContext::GetNumBaseClasses (cxx_record_decl, omit_empty_base_classes));
3965 return child_indexes.size();
3966 }
3967 }
3968
3969 if (cxx_record_decl)
3970 {
3971 const clang::RecordDecl *parent_record_decl = cxx_record_decl;
3972
3973 //printf ("parent = %s\n", parent_record_decl->getNameAsCString());
3974
3975 //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl();
3976 // Didn't find things easily, lets let clang do its thang...
3977 clang::IdentifierInfo & ident_ref = m_ast->Idents.get(name_sref);
3978 clang::DeclarationName decl_name(&ident_ref);
3979
3980 clang::CXXBasePaths paths;
3981 if (cxx_record_decl->lookupInBases(clang::CXXRecordDecl::FindOrdinaryMember,
3982 decl_name.getAsOpaquePtr(),
3983 paths))
3984 {
3985 clang::CXXBasePaths::const_paths_iterator path, path_end = paths.end();
3986 for (path = paths.begin(); path != path_end; ++path)
3987 {
3988 const size_t num_path_elements = path->size();
3989 for (size_t e=0; e<num_path_elements; ++e)
3990 {
3991 clang::CXXBasePathElement elem = (*path)[e];
3992
3993 child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes);
3994 if (child_idx == UINT32_MAX(4294967295U))
3995 {
3996 child_indexes.clear();
3997 return 0;
3998 }
3999 else
4000 {
4001 child_indexes.push_back (child_idx);
4002 parent_record_decl = llvm::cast<clang::RecordDecl>(elem.Base->getType()->getAs<clang::RecordType>()->getDecl());
4003 }
4004 }
4005 for (clang::NamedDecl *path_decl : path->Decls)
4006 {
4007 child_idx = GetIndexForRecordChild (parent_record_decl, path_decl, omit_empty_base_classes);
4008 if (child_idx == UINT32_MAX(4294967295U))
4009 {
4010 child_indexes.clear();
4011 return 0;
4012 }
4013 else
4014 {
4015 child_indexes.push_back (child_idx);
4016 }
4017 }
4018 }
4019 return child_indexes.size();
4020 }
4021 }
4022
4023 }
4024 break;
4025
4026 case clang::Type::ObjCObject:
4027 case clang::Type::ObjCInterface:
4028 if (GetCompleteType ())
4029 {
4030 llvm::StringRef name_sref(name);
4031 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4032 assert (objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 4032, __PRETTY_FUNCTION__))
;
4033 if (objc_class_type)
4034 {
4035 uint32_t child_idx = 0;
4036 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
4037
4038 if (class_interface_decl)
4039 {
4040 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
4041 clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
4042
4043 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
4044 {
4045 const clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
4046
4047 if (ivar_decl->getName().equals (name_sref))
4048 {
4049 if ((!omit_empty_base_classes && superclass_interface_decl) ||
4050 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
4051 ++child_idx;
4052
4053 child_indexes.push_back (child_idx);
4054 return child_indexes.size();
4055 }
4056 }
4057
4058 if (superclass_interface_decl)
4059 {
4060 // The super class index is always zero for ObjC classes,
4061 // so we push it onto the child indexes in case we find
4062 // an ivar in our superclass...
4063 child_indexes.push_back (0);
4064
4065 ClangASTType superclass_clang_type (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl));
4066 if (superclass_clang_type.GetIndexOfChildMemberWithName (name,
4067 omit_empty_base_classes,
4068 child_indexes))
4069 {
4070 // We did find an ivar in a superclass so just
4071 // return the results!
4072 return child_indexes.size();
4073 }
4074
4075 // We didn't find an ivar matching "name" in our
4076 // superclass, pop the superclass zero index that
4077 // we pushed on above.
4078 child_indexes.pop_back();
4079 }
4080 }
4081 }
4082 }
4083 break;
4084
4085 case clang::Type::ObjCObjectPointer:
4086 {
4087 ClangASTType objc_object_clang_type (m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType());
4088 return objc_object_clang_type.GetIndexOfChildMemberWithName (name,
4089 omit_empty_base_classes,
4090 child_indexes);
4091 }
4092 break;
4093
4094
4095 case clang::Type::ConstantArray:
4096 {
4097 // const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr());
4098 // const uint64_t element_count = array->getSize().getLimitedValue();
4099 //
4100 // if (idx < element_count)
4101 // {
4102 // std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
4103 //
4104 // char element_name[32];
4105 // ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
4106 //
4107 // child_name.assign(element_name);
4108 // assert(field_type_info.first % 8 == 0);
4109 // child_byte_size = field_type_info.first / 8;
4110 // child_byte_offset = idx * child_byte_size;
4111 // return array->getElementType().getAsOpaquePtr();
4112 // }
4113 }
4114 break;
4115
4116 // case clang::Type::MemberPointerType:
4117 // {
4118 // MemberPointerType *mem_ptr_type = llvm::cast<MemberPointerType>(qual_type.getTypePtr());
4119 // clang::QualType pointee_type = mem_ptr_type->getPointeeType();
4120 //
4121 // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
4122 // {
4123 // return GetIndexOfChildWithName (ast,
4124 // mem_ptr_type->getPointeeType().getAsOpaquePtr(),
4125 // name);
4126 // }
4127 // }
4128 // break;
4129 //
4130 case clang::Type::LValueReference:
4131 case clang::Type::RValueReference:
4132 {
4133 const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
4134 clang::QualType pointee_type(reference_type->getPointeeType());
4135 ClangASTType pointee_clang_type (m_ast, pointee_type);
4136
4137 if (pointee_clang_type.IsAggregateType ())
4138 {
4139 return pointee_clang_type.GetIndexOfChildMemberWithName (name,
4140 omit_empty_base_classes,
4141 child_indexes);
4142 }
4143 }
4144 break;
4145
4146 case clang::Type::Pointer:
4147 {
4148 ClangASTType pointee_clang_type (GetPointeeType());
4149
4150 if (pointee_clang_type.IsAggregateType ())
4151 {
4152 return pointee_clang_type.GetIndexOfChildMemberWithName (name,
4153 omit_empty_base_classes,
4154 child_indexes);
4155 }
4156 }
4157 break;
4158
4159 case clang::Type::Typedef:
4160 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildMemberWithName (name,
4161 omit_empty_base_classes,
4162 child_indexes);
4163
4164 case clang::Type::Elaborated:
4165 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildMemberWithName (name,
4166 omit_empty_base_classes,
4167 child_indexes);
4168
4169 case clang::Type::Paren:
4170 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildMemberWithName (name,
4171 omit_empty_base_classes,
4172 child_indexes);
4173
4174 default:
4175 break;
4176 }
4177 }
4178 return 0;
4179}
4180
4181
4182// Get the index of the child of "clang_type" whose name matches. This function
4183// doesn't descend into the children, but only looks one level deep and name
4184// matches can include base class names.
4185
4186uint32_t
4187ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_classes) const
4188{
4189 if (IsValid() && name && name[0])
4190 {
4191 clang::QualType qual_type(GetCanonicalQualType());
4192
4193 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4194
4195 switch (type_class)
4196 {
4197 case clang::Type::Record:
4198 if (GetCompleteType ())
4199 {
4200 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4201 const clang::RecordDecl *record_decl = record_type->getDecl();
4202
4203 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 4203, __PRETTY_FUNCTION__))
;
4204 uint32_t child_idx = 0;
4205
4206 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4207
4208 if (cxx_record_decl)
4209 {
4210 clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
4211 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
4212 base_class != base_class_end;
4213 ++base_class)
4214 {
4215 // Skip empty base classes
4216 clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
4217 if (omit_empty_base_classes && ClangASTContext::RecordHasFields(base_class_decl) == false)
4218 continue;
4219
4220 ClangASTType base_class_clang_type (m_ast, base_class->getType());
4221 std::string base_class_type_name (base_class_clang_type.GetTypeName().AsCString(""));
4222 if (base_class_type_name.compare (name) == 0)
4223 return child_idx;
4224 ++child_idx;
4225 }
4226 }
4227
4228 // Try and find a field that matches NAME
4229 clang::RecordDecl::field_iterator field, field_end;
4230 llvm::StringRef name_sref(name);
4231 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
4232 field != field_end;
4233 ++field, ++child_idx)
4234 {
4235 if (field->getName().equals (name_sref))
4236 return child_idx;
4237 }
4238
4239 }
4240 break;
4241
4242 case clang::Type::ObjCObject:
4243 case clang::Type::ObjCInterface:
4244 if (GetCompleteType())
4245 {
4246 llvm::StringRef name_sref(name);
4247 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4248 assert (objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 4248, __PRETTY_FUNCTION__))
;
4249 if (objc_class_type)
4250 {
4251 uint32_t child_idx = 0;
4252 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
4253
4254 if (class_interface_decl)
4255 {
4256 clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
4257 clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
4258
4259 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
4260 {
4261 const clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
4262
4263 if (ivar_decl->getName().equals (name_sref))
4264 {
4265 if ((!omit_empty_base_classes && superclass_interface_decl) ||
4266 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
4267 ++child_idx;
4268
4269 return child_idx;
4270 }
4271 }
4272
4273 if (superclass_interface_decl)
4274 {
4275 if (superclass_interface_decl->getName().equals (name_sref))
4276 return 0;
4277 }
4278 }
4279 }
4280 }
4281 break;
4282
4283 case clang::Type::ObjCObjectPointer:
4284 {
4285 ClangASTType pointee_clang_type (m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType());
4286 return pointee_clang_type.GetIndexOfChildWithName (name, omit_empty_base_classes);
4287 }
4288 break;
4289
4290 case clang::Type::ConstantArray:
4291 {
4292 // const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr());
4293 // const uint64_t element_count = array->getSize().getLimitedValue();
4294 //
4295 // if (idx < element_count)
4296 // {
4297 // std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
4298 //
4299 // char element_name[32];
4300 // ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
4301 //
4302 // child_name.assign(element_name);
4303 // assert(field_type_info.first % 8 == 0);
4304 // child_byte_size = field_type_info.first / 8;
4305 // child_byte_offset = idx * child_byte_size;
4306 // return array->getElementType().getAsOpaquePtr();
4307 // }
4308 }
4309 break;
4310
4311 // case clang::Type::MemberPointerType:
4312 // {
4313 // MemberPointerType *mem_ptr_type = llvm::cast<MemberPointerType>(qual_type.getTypePtr());
4314 // clang::QualType pointee_type = mem_ptr_type->getPointeeType();
4315 //
4316 // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
4317 // {
4318 // return GetIndexOfChildWithName (ast,
4319 // mem_ptr_type->getPointeeType().getAsOpaquePtr(),
4320 // name);
4321 // }
4322 // }
4323 // break;
4324 //
4325 case clang::Type::LValueReference:
4326 case clang::Type::RValueReference:
4327 {
4328 const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
4329 ClangASTType pointee_type (m_ast, reference_type->getPointeeType());
4330
4331 if (pointee_type.IsAggregateType ())
4332 {
4333 return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes);
4334 }
4335 }
4336 break;
4337
4338 case clang::Type::Pointer:
4339 {
4340 const clang::PointerType *pointer_type = llvm::cast<clang::PointerType>(qual_type.getTypePtr());
4341 ClangASTType pointee_type (m_ast, pointer_type->getPointeeType());
4342
4343 if (pointee_type.IsAggregateType ())
4344 {
4345 return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes);
4346 }
4347 else
4348 {
4349 // if (parent_name)
4350 // {
4351 // child_name.assign(1, '*');
4352 // child_name += parent_name;
4353 // }
4354 //
4355 // // We have a pointer to an simple type
4356 // if (idx == 0)
4357 // {
4358 // std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
4359 // assert(clang_type_info.first % 8 == 0);
4360 // child_byte_size = clang_type_info.first / 8;
4361 // child_byte_offset = 0;
4362 // return pointee_type.getAsOpaquePtr();
4363 // }
4364 }
4365 }
4366 break;
4367
4368 case clang::Type::Elaborated:
4369 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildWithName (name, omit_empty_base_classes);
4370
4371 case clang::Type::Paren:
4372 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildWithName (name, omit_empty_base_classes);
4373
4374 case clang::Type::Typedef:
4375 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildWithName (name, omit_empty_base_classes);
4376
4377 default:
4378 break;
4379 }
4380 }
4381 return UINT32_MAX(4294967295U);
4382}
4383
4384
4385size_t
4386ClangASTType::GetNumTemplateArguments () const
4387{
4388 if (IsValid())
4389 {
4390 clang::QualType qual_type (GetCanonicalQualType());
4391
4392 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4393 switch (type_class)
4394 {
4395 case clang::Type::Record:
4396 if (GetCompleteType ())
4397 {
4398 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
4399 if (cxx_record_decl)
4400 {
4401 const clang::ClassTemplateSpecializationDecl *template_decl = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(cxx_record_decl);
4402 if (template_decl)
4403 return template_decl->getTemplateArgs().size();
4404 }
4405 }
4406 break;
4407
4408 case clang::Type::Typedef:
4409 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumTemplateArguments();
4410
4411 case clang::Type::Elaborated:
4412 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumTemplateArguments();
4413
4414 case clang::Type::Paren:
4415 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumTemplateArguments();
4416
4417 default:
4418 break;
4419 }
4420 }
4421 return 0;
4422}
4423
4424ClangASTType
4425ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &kind) const
4426{
4427 if (IsValid())
4428 {
4429 clang::QualType qual_type (GetCanonicalQualType());
4430
4431 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4432 switch (type_class)
4433 {
4434 case clang::Type::Record:
4435 if (GetCompleteType ())
4436 {
4437 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
4438 if (cxx_record_decl)
4439 {
4440 const clang::ClassTemplateSpecializationDecl *template_decl = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(cxx_record_decl);
4441 if (template_decl && arg_idx < template_decl->getTemplateArgs().size())
4442 {
4443 const clang::TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx];
4444 switch (template_arg.getKind())
4445 {
4446 case clang::TemplateArgument::Null:
4447 kind = eTemplateArgumentKindNull;
4448 return ClangASTType();
4449
4450 case clang::TemplateArgument::Type:
4451 kind = eTemplateArgumentKindType;
4452 return ClangASTType(m_ast, template_arg.getAsType());
4453
4454 case clang::TemplateArgument::Declaration:
4455 kind = eTemplateArgumentKindDeclaration;
4456 return ClangASTType();
4457
4458 case clang::TemplateArgument::Integral:
4459 kind = eTemplateArgumentKindIntegral;
4460 return ClangASTType(m_ast, template_arg.getIntegralType());
4461
4462 case clang::TemplateArgument::Template:
4463 kind = eTemplateArgumentKindTemplate;
4464 return ClangASTType();
4465
4466 case clang::TemplateArgument::TemplateExpansion:
4467 kind = eTemplateArgumentKindTemplateExpansion;
4468 return ClangASTType();
4469
4470 case clang::TemplateArgument::Expression:
4471 kind = eTemplateArgumentKindExpression;
4472 return ClangASTType();
4473
4474 case clang::TemplateArgument::Pack:
4475 kind = eTemplateArgumentKindPack;
4476 return ClangASTType();
4477
4478 default:
4479 assert (!"Unhandled clang::TemplateArgument::ArgKind")((!"Unhandled clang::TemplateArgument::ArgKind") ? static_cast
<void> (0) : __assert_fail ("!\"Unhandled clang::TemplateArgument::ArgKind\""
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 4479, __PRETTY_FUNCTION__))
;
4480 break;
4481 }
4482 }
4483 }
4484 }
4485 break;
4486
4487 case clang::Type::Typedef:
4488 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTemplateArgument (arg_idx, kind);
4489
4490 case clang::Type::Elaborated:
4491 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetTemplateArgument (arg_idx, kind);
4492
4493 case clang::Type::Paren:
4494 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetTemplateArgument (arg_idx, kind);
4495
4496 default:
4497 break;
4498 }
4499 }
4500 kind = eTemplateArgumentKindNull;
4501 return ClangASTType ();
4502}
4503
4504static bool
4505IsOperator (const char *name, clang::OverloadedOperatorKind &op_kind)
4506{
4507 if (name == nullptr || name[0] == '\0')
4508 return false;
4509
4510#define OPERATOR_PREFIX "operator"
4511#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1)
4512
4513 const char *post_op_name = nullptr;
4514
4515 bool no_space = true;
4516
4517 if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH))
4518 return false;
4519
4520 post_op_name = name + OPERATOR_PREFIX_LENGTH;
4521
4522 if (post_op_name[0] == ' ')
4523 {
4524 post_op_name++;
4525 no_space = false;
4526 }
4527
4528#undef OPERATOR_PREFIX
4529#undef OPERATOR_PREFIX_LENGTH
4530
4531 // This is an operator, set the overloaded operator kind to invalid
4532 // in case this is a conversion operator...
4533 op_kind = clang::NUM_OVERLOADED_OPERATORS;
4534
4535 switch (post_op_name[0])
4536 {
4537 default:
4538 if (no_space)
4539 return false;
4540 break;
4541 case 'n':
4542 if (no_space)
4543 return false;
4544 if (strcmp (post_op_name, "new") == 0)
4545 op_kind = clang::OO_New;
4546 else if (strcmp (post_op_name, "new[]") == 0)
4547 op_kind = clang::OO_Array_New;
4548 break;
4549
4550 case 'd':
4551 if (no_space)
4552 return false;
4553 if (strcmp (post_op_name, "delete") == 0)
4554 op_kind = clang::OO_Delete;
4555 else if (strcmp (post_op_name, "delete[]") == 0)
4556 op_kind = clang::OO_Array_Delete;
4557 break;
4558
4559 case '+':
4560 if (post_op_name[1] == '\0')
4561 op_kind = clang::OO_Plus;
4562 else if (post_op_name[2] == '\0')
4563 {
4564 if (post_op_name[1] == '=')
4565 op_kind = clang::OO_PlusEqual;
4566 else if (post_op_name[1] == '+')
4567 op_kind = clang::OO_PlusPlus;
4568 }
4569 break;
4570
4571 case '-':
4572 if (post_op_name[1] == '\0')
4573 op_kind = clang::OO_Minus;
4574 else if (post_op_name[2] == '\0')
4575 {
4576 switch (post_op_name[1])
4577 {
4578 case '=': op_kind = clang::OO_MinusEqual; break;
4579 case '-': op_kind = clang::OO_MinusMinus; break;
4580 case '>': op_kind = clang::OO_Arrow; break;
4581 }
4582 }
4583 else if (post_op_name[3] == '\0')
4584 {
4585 if (post_op_name[2] == '*')
4586 op_kind = clang::OO_ArrowStar; break;
4587 }
4588 break;
4589
4590 case '*':
4591 if (post_op_name[1] == '\0')
4592 op_kind = clang::OO_Star;
4593 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4594 op_kind = clang::OO_StarEqual;
4595 break;
4596
4597 case '/':
4598 if (post_op_name[1] == '\0')
4599 op_kind = clang::OO_Slash;
4600 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4601 op_kind = clang::OO_SlashEqual;
4602 break;
4603
4604 case '%':
4605 if (post_op_name[1] == '\0')
4606 op_kind = clang::OO_Percent;
4607 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4608 op_kind = clang::OO_PercentEqual;
4609 break;
4610
4611
4612 case '^':
4613 if (post_op_name[1] == '\0')
4614 op_kind = clang::OO_Caret;
4615 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4616 op_kind = clang::OO_CaretEqual;
4617 break;
4618
4619 case '&':
4620 if (post_op_name[1] == '\0')
4621 op_kind = clang::OO_Amp;
4622 else if (post_op_name[2] == '\0')
4623 {
4624 switch (post_op_name[1])
4625 {
4626 case '=': op_kind = clang::OO_AmpEqual; break;
4627 case '&': op_kind = clang::OO_AmpAmp; break;
4628 }
4629 }
4630 break;
4631
4632 case '|':
4633 if (post_op_name[1] == '\0')
4634 op_kind = clang::OO_Pipe;
4635 else if (post_op_name[2] == '\0')
4636 {
4637 switch (post_op_name[1])
4638 {
4639 case '=': op_kind = clang::OO_PipeEqual; break;
4640 case '|': op_kind = clang::OO_PipePipe; break;
4641 }
4642 }
4643 break;
4644
4645 case '~':
4646 if (post_op_name[1] == '\0')
4647 op_kind = clang::OO_Tilde;
4648 break;
4649
4650 case '!':
4651 if (post_op_name[1] == '\0')
4652 op_kind = clang::OO_Exclaim;
4653 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4654 op_kind = clang::OO_ExclaimEqual;
4655 break;
4656
4657 case '=':
4658 if (post_op_name[1] == '\0')
4659 op_kind = clang::OO_Equal;
4660 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4661 op_kind = clang::OO_EqualEqual;
4662 break;
4663
4664 case '<':
4665 if (post_op_name[1] == '\0')
4666 op_kind = clang::OO_Less;
4667 else if (post_op_name[2] == '\0')
4668 {
4669 switch (post_op_name[1])
4670 {
4671 case '<': op_kind = clang::OO_LessLess; break;
4672 case '=': op_kind = clang::OO_LessEqual; break;
4673 }
4674 }
4675 else if (post_op_name[3] == '\0')
4676 {
4677 if (post_op_name[2] == '=')
4678 op_kind = clang::OO_LessLessEqual;
4679 }
4680 break;
4681
4682 case '>':
4683 if (post_op_name[1] == '\0')
4684 op_kind = clang::OO_Greater;
4685 else if (post_op_name[2] == '\0')
4686 {
4687 switch (post_op_name[1])
4688 {
4689 case '>': op_kind = clang::OO_GreaterGreater; break;
4690 case '=': op_kind = clang::OO_GreaterEqual; break;
4691 }
4692 }
4693 else if (post_op_name[1] == '>' &&
4694 post_op_name[2] == '=' &&
4695 post_op_name[3] == '\0')
4696 {
4697 op_kind = clang::OO_GreaterGreaterEqual;
4698 }
4699 break;
4700
4701 case ',':
4702 if (post_op_name[1] == '\0')
4703 op_kind = clang::OO_Comma;
4704 break;
4705
4706 case '(':
4707 if (post_op_name[1] == ')' && post_op_name[2] == '\0')
4708 op_kind = clang::OO_Call;
4709 break;
4710
4711 case '[':
4712 if (post_op_name[1] == ']' && post_op_name[2] == '\0')
4713 op_kind = clang::OO_Subscript;
4714 break;
4715 }
4716
4717 return true;
4718}
4719
4720clang::EnumDecl *
4721ClangASTType::GetAsEnumDecl () const
4722{
4723 const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType());
4724 if (enum_type)
4725 return enum_type->getDecl();
4726 return NULL__null;
4727}
4728
4729clang::RecordDecl *
4730ClangASTType::GetAsRecordDecl () const
4731{
4732 const clang::RecordType *record_type = llvm::dyn_cast<clang::RecordType>(GetCanonicalQualType());
4733 if (record_type)
4734 return record_type->getDecl();
4735 return nullptr;
4736}
4737
4738clang::CXXRecordDecl *
4739ClangASTType::GetAsCXXRecordDecl () const
4740{
4741 return GetCanonicalQualType()->getAsCXXRecordDecl();
4742}
4743
4744clang::ObjCInterfaceDecl *
4745ClangASTType::GetAsObjCInterfaceDecl () const
4746{
4747 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(GetCanonicalQualType());
4748 if (objc_class_type)
4749 return objc_class_type->getInterface();
4750 return nullptr;
4751}
4752
4753clang::FieldDecl *
4754ClangASTType::AddFieldToRecordType (const char *name,
4755 const ClangASTType &field_clang_type,
4756 AccessType access,
4757 uint32_t bitfield_bit_size)
4758{
4759 if (!IsValid() || !field_clang_type.IsValid())
4760 return nullptr;
4761
4762 clang::FieldDecl *field = nullptr;
4763
4764 clang::Expr *bit_width = nullptr;
4765 if (bitfield_bit_size != 0)
4766 {
4767 llvm::APInt bitfield_bit_size_apint(m_ast->getTypeSize(m_ast->IntTy), bitfield_bit_size);
4768 bit_width = new (*m_ast)clang::IntegerLiteral (*m_ast, bitfield_bit_size_apint, m_ast->IntTy, clang::SourceLocation());
4769 }
4770
4771 clang::RecordDecl *record_decl = GetAsRecordDecl ();
4772 if (record_decl)
4773 {
4774 field = clang::FieldDecl::Create (*m_ast,
4775 record_decl,
4776 clang::SourceLocation(),
4777 clang::SourceLocation(),
4778 name ? &m_ast->Idents.get(name) : nullptr, // Identifier
4779 field_clang_type.GetQualType(), // Field type
4780 nullptr, // TInfo *
4781 bit_width, // BitWidth
4782 false, // Mutable
4783 clang::ICIS_NoInit); // HasInit
4784
4785 if (!name)
4786 {
4787 // Determine whether this field corresponds to an anonymous
4788 // struct or union.
4789 if (const clang::TagType *TagT = field->getType()->getAs<clang::TagType>()) {
4790 if (clang::RecordDecl *Rec = llvm::dyn_cast<clang::RecordDecl>(TagT->getDecl()))
4791 if (!Rec->getDeclName()) {
4792 Rec->setAnonymousStructOrUnion(true);
4793 field->setImplicit();
4794
4795 }
4796 }
4797 }
4798
4799 if (field)
4800 {
4801 field->setAccess (ClangASTContext::ConvertAccessTypeToAccessSpecifier (access));
4802
4803 record_decl->addDecl(field);
4804
4805#ifdef LLDB_CONFIGURATION_DEBUG
4806 VerifyDecl(field);
4807#endif
4808 }
4809 }
4810 else
4811 {
4812 clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
4813
4814 if (class_interface_decl)
4815 {
4816 const bool is_synthesized = false;
4817
4818 field_clang_type.GetCompleteType();
4819
4820 field = clang::ObjCIvarDecl::Create (*m_ast,
4821 class_interface_decl,
4822 clang::SourceLocation(),
4823 clang::SourceLocation(),
4824 name ? &m_ast->Idents.get(name) : nullptr, // Identifier
4825 field_clang_type.GetQualType(), // Field type
4826 nullptr, // TypeSourceInfo *
4827 ConvertAccessTypeToObjCIvarAccessControl (access),
4828 bit_width,
4829 is_synthesized);
4830
4831 if (field)
4832 {
4833 class_interface_decl->addDecl(field);
4834
4835#ifdef LLDB_CONFIGURATION_DEBUG
4836 VerifyDecl(field);
4837#endif
4838 }
4839 }
4840 }
4841 return field;
4842}
4843
4844void
4845ClangASTType::BuildIndirectFields ()
4846{
4847 clang::RecordDecl *record_decl = GetAsRecordDecl();
4848
4849 if (!record_decl)
4850 return;
4851
4852 typedef llvm::SmallVector <clang::IndirectFieldDecl *, 1> IndirectFieldVector;
4853
4854 IndirectFieldVector indirect_fields;
4855 clang::RecordDecl::field_iterator field_pos;
4856 clang::RecordDecl::field_iterator field_end_pos = record_decl->field_end();
4857 clang::RecordDecl::field_iterator last_field_pos = field_end_pos;
4858 for (field_pos = record_decl->field_begin(); field_pos != field_end_pos; last_field_pos = field_pos++)
4859 {
4860 if (field_pos->isAnonymousStructOrUnion())
4861 {
4862 clang::QualType field_qual_type = field_pos->getType();
4863
4864 const clang::RecordType *field_record_type = field_qual_type->getAs<clang::RecordType>();
4865
4866 if (!field_record_type)
4867 continue;
4868
4869 clang::RecordDecl *field_record_decl = field_record_type->getDecl();
4870
4871 if (!field_record_decl)
4872 continue;
4873
4874 for (clang::RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end();
4875 di != de;
4876 ++di)
4877 {
4878 if (clang::FieldDecl *nested_field_decl = llvm::dyn_cast<clang::FieldDecl>(*di))
4879 {
4880 clang::NamedDecl **chain = new (*m_ast) clang::NamedDecl*[2];
4881 chain[0] = *field_pos;
4882 chain[1] = nested_field_decl;
4883 clang::IndirectFieldDecl *indirect_field = clang::IndirectFieldDecl::Create(*m_ast,
4884 record_decl,
4885 clang::SourceLocation(),
4886 nested_field_decl->getIdentifier(),
4887 nested_field_decl->getType(),
4888 chain,
4889 2);
4890
4891 indirect_field->setImplicit();
4892
4893 indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(),
4894 nested_field_decl->getAccess()));
4895
4896 indirect_fields.push_back(indirect_field);
4897 }
4898 else if (clang::IndirectFieldDecl *nested_indirect_field_decl = llvm::dyn_cast<clang::IndirectFieldDecl>(*di))
4899 {
4900 int nested_chain_size = nested_indirect_field_decl->getChainingSize();
4901 clang::NamedDecl **chain = new (*m_ast) clang::NamedDecl*[nested_chain_size + 1];
4902 chain[0] = *field_pos;
4903
4904 int chain_index = 1;
4905 for (clang::IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(),
4906 nce = nested_indirect_field_decl->chain_end();
4907 nci < nce;
4908 ++nci)
4909 {
4910 chain[chain_index] = *nci;
4911 chain_index++;
4912 }
4913
4914 clang::IndirectFieldDecl *indirect_field = clang::IndirectFieldDecl::Create(*m_ast,
4915 record_decl,
4916 clang::SourceLocation(),
4917 nested_indirect_field_decl->getIdentifier(),
4918 nested_indirect_field_decl->getType(),
4919 chain,
4920 nested_chain_size + 1);
4921
4922 indirect_field->setImplicit();
4923
4924 indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(),
4925 nested_indirect_field_decl->getAccess()));
4926
4927 indirect_fields.push_back(indirect_field);
4928 }
4929 }
4930 }
4931 }
4932
4933 // Check the last field to see if it has an incomplete array type as its
4934 // last member and if it does, the tell the record decl about it
4935 if (last_field_pos != field_end_pos)
4936 {
4937 if (last_field_pos->getType()->isIncompleteArrayType())
4938 record_decl->hasFlexibleArrayMember();
4939 }
4940
4941 for (IndirectFieldVector::iterator ifi = indirect_fields.begin(), ife = indirect_fields.end();
4942 ifi < ife;
4943 ++ifi)
4944 {
4945 record_decl->addDecl(*ifi);
4946 }
4947}
4948
4949clang::VarDecl *
4950ClangASTType::AddVariableToRecordType (const char *name,
4951 const ClangASTType &var_type,
4952 AccessType access)
4953{
4954 clang::VarDecl *var_decl = nullptr;
4955
4956 if (!IsValid() || !var_type.IsValid())
4957 return nullptr;
4958
4959 clang::RecordDecl *record_decl = GetAsRecordDecl ();
4960 if (record_decl)
4961 {
4962 var_decl = clang::VarDecl::Create (*m_ast, // ASTContext &
4963 record_decl, // DeclContext *
4964 clang::SourceLocation(), // clang::SourceLocation StartLoc
4965 clang::SourceLocation(), // clang::SourceLocation IdLoc
4966 name ? &m_ast->Idents.get(name) : nullptr, // clang::IdentifierInfo *
4967 var_type.GetQualType(), // Variable clang::QualType
4968 nullptr, // TypeSourceInfo *
4969 clang::SC_Static); // StorageClass
4970 if (var_decl)
4971 {
4972 var_decl->setAccess(ClangASTContext::ConvertAccessTypeToAccessSpecifier (access));
4973 record_decl->addDecl(var_decl);
4974
4975#ifdef LLDB_CONFIGURATION_DEBUG
4976 VerifyDecl(var_decl);
4977#endif
4978 }
4979 }
4980 return var_decl;
4981}
4982
4983
4984clang::CXXMethodDecl *
4985ClangASTType::AddMethodToCXXRecordType (const char *name,
4986 const ClangASTType &method_clang_type,
4987 lldb::AccessType access,
4988 bool is_virtual,
4989 bool is_static,
4990 bool is_inline,
4991 bool is_explicit,
4992 bool is_attr_used,
4993 bool is_artificial)
4994{
4995 if (!IsValid() || !method_clang_type.IsValid() || name == nullptr || name[0] == '\0')
4996 return nullptr;
4997
4998 clang::QualType record_qual_type(GetCanonicalQualType());
4999
5000 clang::CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl();
5001
5002 if (cxx_record_decl == nullptr)
5003 return nullptr;
5004
5005 clang::QualType method_qual_type (method_clang_type.GetQualType());
5006
5007 clang::CXXMethodDecl *cxx_method_decl = nullptr;
5008
5009 clang::DeclarationName decl_name (&m_ast->Idents.get(name));
5010
5011 const clang::FunctionType *function_type = llvm::dyn_cast<clang::FunctionType>(method_qual_type.getTypePtr());
5012
5013 if (function_type == nullptr)
5014 return nullptr;
5015
5016 const clang::FunctionProtoType *method_function_prototype (llvm::dyn_cast<clang::FunctionProtoType>(function_type));
5017
5018 if (!method_function_prototype)
5019 return nullptr;
5020
5021 unsigned int num_params = method_function_prototype->getNumParams();
5022
5023 clang::CXXDestructorDecl *cxx_dtor_decl(nullptr);
5024 clang::CXXConstructorDecl *cxx_ctor_decl(nullptr);
5025
5026 if (is_artificial)
5027 return nullptr; // skip everything artificial
5028
5029 if (name[0] == '~')
5030 {
5031 cxx_dtor_decl = clang::CXXDestructorDecl::Create (*m_ast,
5032 cxx_record_decl,
5033 clang::SourceLocation(),
5034 clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXDestructorName (m_ast->getCanonicalType (record_qual_type)), clang::SourceLocation()),
5035 method_qual_type,
5036 nullptr,
5037 is_inline,
5038 is_artificial);
5039 cxx_method_decl = cxx_dtor_decl;
5040 }
5041 else if (decl_name == cxx_record_decl->getDeclName())
5042 {
5043 cxx_ctor_decl = clang::CXXConstructorDecl::Create (*m_ast,
5044 cxx_record_decl,
5045 clang::SourceLocation(),
5046 clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXConstructorName (m_ast->getCanonicalType (record_qual_type)), clang::SourceLocation()),
5047 method_qual_type,
5048 nullptr, // TypeSourceInfo *
5049 is_explicit,
5050 is_inline,
5051 is_artificial,
5052 false /*is_constexpr*/);
5053 cxx_method_decl = cxx_ctor_decl;
5054 }
5055 else
5056 {
5057 clang::StorageClass SC = is_static ? clang::SC_Static : clang::SC_None;
5058 clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
5059
5060 if (IsOperator (name, op_kind))
5061 {
5062 if (op_kind != clang::NUM_OVERLOADED_OPERATORS)
5063 {
5064 // Check the number of operator parameters. Sometimes we have
5065 // seen bad DWARF that doesn't correctly describe operators and
5066 // if we try to create a methed and add it to the class, clang
5067 // will assert and crash, so we need to make sure things are
5068 // acceptable.
5069 if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount (op_kind, num_params))
5070 return nullptr;
5071 cxx_method_decl = clang::CXXMethodDecl::Create (*m_ast,
5072 cxx_record_decl,
5073 clang::SourceLocation(),
5074 clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXOperatorName (op_kind), clang::SourceLocation()),
5075 method_qual_type,
5076 nullptr, // TypeSourceInfo *
5077 SC,
5078 is_inline,
5079 false /*is_constexpr*/,
5080 clang::SourceLocation());
5081 }
5082 else if (num_params == 0)
5083 {
5084 // Conversion operators don't take params...
5085 cxx_method_decl = clang::CXXConversionDecl::Create (*m_ast,
5086 cxx_record_decl,
5087 clang::SourceLocation(),
5088 clang::DeclarationNameInfo (m_ast->DeclarationNames.getCXXConversionFunctionName (m_ast->getCanonicalType (function_type->getReturnType())), clang::SourceLocation()),
5089 method_qual_type,
5090 nullptr, // TypeSourceInfo *
5091 is_inline,
5092 is_explicit,
5093 false /*is_constexpr*/,
5094 clang::SourceLocation());
5095 }
5096 }
5097
5098 if (cxx_method_decl == nullptr)
5099 {
5100 cxx_method_decl = clang::CXXMethodDecl::Create (*m_ast,
5101 cxx_record_decl,
5102 clang::SourceLocation(),
5103 clang::DeclarationNameInfo (decl_name, clang::SourceLocation()),
5104 method_qual_type,
5105 nullptr, // TypeSourceInfo *
5106 SC,
5107 is_inline,
5108 false /*is_constexpr*/,
5109 clang::SourceLocation());
5110 }
5111 }
5112
5113 clang::AccessSpecifier access_specifier = ClangASTContext::ConvertAccessTypeToAccessSpecifier (access);
5114
5115 cxx_method_decl->setAccess (access_specifier);
5116 cxx_method_decl->setVirtualAsWritten (is_virtual);
5117
5118 if (is_attr_used)
5119 cxx_method_decl->addAttr(clang::UsedAttr::CreateImplicit(*m_ast));
5120
5121 // Populate the method decl with parameter decls
5122
5123 llvm::SmallVector<clang::ParmVarDecl *, 12> params;
5124
5125 for (unsigned param_index = 0;
5126 param_index < num_params;
5127 ++param_index)
5128 {
5129 params.push_back (clang::ParmVarDecl::Create (*m_ast,
5130 cxx_method_decl,
5131 clang::SourceLocation(),
5132 clang::SourceLocation(),
5133 nullptr, // anonymous
5134 method_function_prototype->getParamType(param_index),
5135 nullptr,
5136 clang::SC_None,
5137 nullptr));
5138 }
5139
5140 cxx_method_decl->setParams (llvm::ArrayRef<clang::ParmVarDecl*>(params));
5141
5142 cxx_record_decl->addDecl (cxx_method_decl);
5143
5144 // Sometimes the debug info will mention a constructor (default/copy/move),
5145 // destructor, or assignment operator (copy/move) but there won't be any
5146 // version of this in the code. So we check if the function was artificially
5147 // generated and if it is trivial and this lets the compiler/backend know
5148 // that it can inline the IR for these when it needs to and we can avoid a
5149 // "missing function" error when running expressions.
5150
5151 if (is_artificial)
5152 {
5153 if (cxx_ctor_decl &&
5154 ((cxx_ctor_decl->isDefaultConstructor() && cxx_record_decl->hasTrivialDefaultConstructor ()) ||
5155 (cxx_ctor_decl->isCopyConstructor() && cxx_record_decl->hasTrivialCopyConstructor ()) ||
5156 (cxx_ctor_decl->isMoveConstructor() && cxx_record_decl->hasTrivialMoveConstructor ()) ))
5157 {
5158 cxx_ctor_decl->setDefaulted();
5159 cxx_ctor_decl->setTrivial(true);
5160 }
5161 else if (cxx_dtor_decl)
5162 {
5163 if (cxx_record_decl->hasTrivialDestructor())
5164 {
5165 cxx_dtor_decl->setDefaulted();
5166 cxx_dtor_decl->setTrivial(true);
5167 }
5168 }
5169 else if ((cxx_method_decl->isCopyAssignmentOperator() && cxx_record_decl->hasTrivialCopyAssignment()) ||
5170 (cxx_method_decl->isMoveAssignmentOperator() && cxx_record_decl->hasTrivialMoveAssignment()))
5171 {
5172 cxx_method_decl->setDefaulted();
5173 cxx_method_decl->setTrivial(true);
5174 }
5175 }
5176
5177#ifdef LLDB_CONFIGURATION_DEBUG
5178 VerifyDecl(cxx_method_decl);
5179#endif
5180
5181 // printf ("decl->isPolymorphic() = %i\n", cxx_record_decl->isPolymorphic());
5182 // printf ("decl->isAggregate() = %i\n", cxx_record_decl->isAggregate());
5183 // printf ("decl->isPOD() = %i\n", cxx_record_decl->isPOD());
5184 // printf ("decl->isEmpty() = %i\n", cxx_record_decl->isEmpty());
5185 // printf ("decl->isAbstract() = %i\n", cxx_record_decl->isAbstract());
5186 // printf ("decl->hasTrivialConstructor() = %i\n", cxx_record_decl->hasTrivialConstructor());
5187 // printf ("decl->hasTrivialCopyConstructor() = %i\n", cxx_record_decl->hasTrivialCopyConstructor());
5188 // printf ("decl->hasTrivialCopyAssignment() = %i\n", cxx_record_decl->hasTrivialCopyAssignment());
5189 // printf ("decl->hasTrivialDestructor() = %i\n", cxx_record_decl->hasTrivialDestructor());
5190 return cxx_method_decl;
5191}
5192
5193
5194#pragma mark C++ Base Classes
5195
5196clang::CXXBaseSpecifier *
5197ClangASTType::CreateBaseClassSpecifier (AccessType access, bool is_virtual, bool base_of_class)
5198{
5199 if (IsValid())
5200 return new clang::CXXBaseSpecifier (clang::SourceRange(),
5201 is_virtual,
5202 base_of_class,
5203 ClangASTContext::ConvertAccessTypeToAccessSpecifier (access),
5204 m_ast->getTrivialTypeSourceInfo (GetQualType()),
5205 clang::SourceLocation());
5206 return nullptr;
5207}
5208
5209void
5210ClangASTType::DeleteBaseClassSpecifiers (clang::CXXBaseSpecifier **base_classes, unsigned num_base_classes)
5211{
5212 for (unsigned i=0; i<num_base_classes; ++i)
5213 {
5214 delete base_classes[i];
5215 base_classes[i] = nullptr;
5216 }
5217}
5218
5219bool
5220ClangASTType::SetBaseClassesForClassType (clang::CXXBaseSpecifier const * const *base_classes,
5221 unsigned num_base_classes)
5222{
5223 if (IsValid())
5224 {
5225 clang::CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl();
5226 if (cxx_record_decl)
5227 {
5228 cxx_record_decl->setBases(base_classes, num_base_classes);
5229 return true;
5230 }
5231 }
5232 return false;
5233}
5234
5235bool
5236ClangASTType::SetObjCSuperClass (const ClangASTType &superclass_clang_type)
5237{
5238 if (IsValid() && superclass_clang_type.IsValid())
5239 {
5240 clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
5241 clang::ObjCInterfaceDecl *super_interface_decl = superclass_clang_type.GetAsObjCInterfaceDecl ();
5242 if (class_interface_decl && super_interface_decl)
5243 {
5244 class_interface_decl->setSuperClass(super_interface_decl);
5245 return true;
5246 }
5247 }
5248 return false;
5249}
5250
5251bool
5252ClangASTType::AddObjCClassProperty (const char *property_name,
5253 const ClangASTType &property_clang_type,
5254 clang::ObjCIvarDecl *ivar_decl,
5255 const char *property_setter_name,
5256 const char *property_getter_name,
5257 uint32_t property_attributes,
5258 ClangASTMetadata *metadata)
5259{
5260 if (!IsValid() || !property_clang_type.IsValid() || property_name == nullptr || property_name[0] == '\0')
1
Taking false branch
5261 return false;
5262
5263 clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
5264
5265 if (class_interface_decl)
2
Assuming 'class_interface_decl' is non-null
3
Taking true branch
5266 {
5267 ClangASTType property_clang_type_to_access;
5268
5269 if (property_clang_type.IsValid())
4
Taking true branch
5270 property_clang_type_to_access = property_clang_type;
5271 else if (ivar_decl)
5272 property_clang_type_to_access = ClangASTType (m_ast, ivar_decl->getType());
5273
5274 if (class_interface_decl && property_clang_type_to_access.IsValid())
5
Taking true branch
5275 {
5276 clang::TypeSourceInfo *prop_type_source;
5277 if (ivar_decl)
6
Assuming 'ivar_decl' is non-null
7
Taking true branch
5278 prop_type_source = m_ast->getTrivialTypeSourceInfo (ivar_decl->getType());
5279 else
5280 prop_type_source = m_ast->getTrivialTypeSourceInfo (property_clang_type.GetQualType());
5281
5282 clang::ObjCPropertyDecl *property_decl = clang::ObjCPropertyDecl::Create (*m_ast,
5283 class_interface_decl,
5284 clang::SourceLocation(), // Source Location
5285 &m_ast->Idents.get(property_name),
5286 clang::SourceLocation(), //Source Location for AT
5287 clang::SourceLocation(), //Source location for (
5288 prop_type_source);
5289
5290 if (property_decl)
8
Assuming 'property_decl' is non-null
9
Taking true branch
5291 {
5292 if (metadata)
10
Assuming 'metadata' is null
11
Taking false branch
5293 ClangASTContext::SetMetadata(m_ast, property_decl, *metadata);
5294
5295 class_interface_decl->addDecl (property_decl);
5296
5297 clang::Selector setter_sel, getter_sel;
5298
5299 if (property_setter_name != nullptr)
12
Taking false branch
5300 {
5301 std::string property_setter_no_colon(property_setter_name, strlen(property_setter_name) - 1);
5302 clang::IdentifierInfo *setter_ident = &m_ast->Idents.get(property_setter_no_colon.c_str());
5303 setter_sel = m_ast->Selectors.getSelector(1, &setter_ident);
5304 }
5305 else if (!(property_attributes & DW_APPLE_PROPERTY_readonly))
13
Taking false branch
5306 {
5307 std::string setter_sel_string("set");
5308 setter_sel_string.push_back(::toupper(property_name[0]));
5309 setter_sel_string.append(&property_name[1]);
5310 clang::IdentifierInfo *setter_ident = &m_ast->Idents.get(setter_sel_string.c_str());
5311 setter_sel = m_ast->Selectors.getSelector(1, &setter_ident);
5312 }
5313 property_decl->setSetterName(setter_sel);
5314 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_setter);
5315
5316 if (property_getter_name != nullptr)
14
Taking false branch
5317 {
5318 clang::IdentifierInfo *getter_ident = &m_ast->Idents.get(property_getter_name);
5319 getter_sel = m_ast->Selectors.getSelector(0, &getter_ident);
5320 }
5321 else
5322 {
5323 clang::IdentifierInfo *getter_ident = &m_ast->Idents.get(property_name);
5324 getter_sel = m_ast->Selectors.getSelector(0, &getter_ident);
5325 }
5326 property_decl->setGetterName(getter_sel);
5327 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_getter);
5328
5329 if (ivar_decl)
15
Taking true branch
5330 property_decl->setPropertyIvarDecl (ivar_decl);
5331
5332 if (property_attributes & DW_APPLE_PROPERTY_readonly)
16
Taking true branch
5333 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readonly);
5334 if (property_attributes & DW_APPLE_PROPERTY_readwrite)
17
Taking false branch
5335 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readwrite);
5336 if (property_attributes & DW_APPLE_PROPERTY_assign)
18
Taking false branch
5337 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_assign);
5338 if (property_attributes & DW_APPLE_PROPERTY_retain)
19
Taking false branch
5339 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_retain);
5340 if (property_attributes & DW_APPLE_PROPERTY_copy)
20
Taking false branch
5341 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_copy);
5342 if (property_attributes & DW_APPLE_PROPERTY_nonatomic)
21
Taking false branch
5343 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_nonatomic);
5344
5345 if (!getter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(getter_sel))
22
Taking true branch
5346 {
5347 const bool isInstance = true;
5348 const bool isVariadic = false;
5349 const bool isSynthesized = false;
5350 const bool isImplicitlyDeclared = true;
5351 const bool isDefined = false;
5352 const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None;
5353 const bool HasRelatedResultType = false;
5354
5355 clang::ObjCMethodDecl *getter = clang::ObjCMethodDecl::Create (*m_ast,
23
'getter' initialized here
5356 clang::SourceLocation(),
5357 clang::SourceLocation(),
5358 getter_sel,
5359 property_clang_type_to_access.GetQualType(),
5360 nullptr,
5361 class_interface_decl,
5362 isInstance,
5363 isVariadic,
5364 isSynthesized,
5365 isImplicitlyDeclared,
5366 isDefined,
5367 impControl,
5368 HasRelatedResultType);
5369
5370 if (getter && metadata)
24
Assuming pointer value is null
5371 ClangASTContext::SetMetadata(m_ast, getter, *metadata);
5372
5373 getter->setMethodParams(*m_ast, llvm::ArrayRef<clang::ParmVarDecl*>(), llvm::ArrayRef<clang::SourceLocation>());
25
Called C++ object pointer is null
5374
5375 class_interface_decl->addDecl(getter);
5376 }
5377
5378 if (!setter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(setter_sel))
5379 {
5380 clang::QualType result_type = m_ast->VoidTy;
5381
5382 const bool isInstance = true;
5383 const bool isVariadic = false;
5384 const bool isSynthesized = false;
5385 const bool isImplicitlyDeclared = true;
5386 const bool isDefined = false;
5387 const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None;
5388 const bool HasRelatedResultType = false;
5389
5390 clang::ObjCMethodDecl *setter = clang::ObjCMethodDecl::Create (*m_ast,
5391 clang::SourceLocation(),
5392 clang::SourceLocation(),
5393 setter_sel,
5394 result_type,
5395 nullptr,
5396 class_interface_decl,
5397 isInstance,
5398 isVariadic,
5399 isSynthesized,
5400 isImplicitlyDeclared,
5401 isDefined,
5402 impControl,
5403 HasRelatedResultType);
5404
5405 if (setter && metadata)
5406 ClangASTContext::SetMetadata(m_ast, setter, *metadata);
5407
5408 llvm::SmallVector<clang::ParmVarDecl *, 1> params;
5409
5410 params.push_back (clang::ParmVarDecl::Create (*m_ast,
5411 setter,
5412 clang::SourceLocation(),
5413 clang::SourceLocation(),
5414 nullptr, // anonymous
5415 property_clang_type_to_access.GetQualType(),
5416 nullptr,
5417 clang::SC_Auto,
5418 nullptr));
5419
5420 setter->setMethodParams(*m_ast, llvm::ArrayRef<clang::ParmVarDecl*>(params), llvm::ArrayRef<clang::SourceLocation>());
5421
5422 class_interface_decl->addDecl(setter);
5423 }
5424
5425 return true;
5426 }
5427 }
5428 }
5429 return false;
5430}
5431
5432bool
5433ClangASTType::IsObjCClassTypeAndHasIVars (bool check_superclass) const
5434{
5435 clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
5436 if (class_interface_decl)
5437 return ObjCDeclHasIVars (class_interface_decl, check_superclass);
5438 return false;
5439}
5440
5441
5442clang::ObjCMethodDecl *
5443ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol name as seen in the symbol table ("-[NString stringWithCString:]")
5444 const ClangASTType &method_clang_type,
5445 lldb::AccessType access,
5446 bool is_artificial)
5447{
5448 if (!IsValid() || !method_clang_type.IsValid())
5449 return nullptr;
5450
5451 clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl();
5452
5453 if (class_interface_decl == nullptr)
5454 return nullptr;
5455
5456 const char *selector_start = ::strchr (name, ' ');
5457 if (selector_start == nullptr)
5458 return nullptr;
5459
5460 selector_start++;
5461 llvm::SmallVector<clang::IdentifierInfo *, 12> selector_idents;
5462
5463 size_t len = 0;
5464 const char *start;
5465 //printf ("name = '%s'\n", name);
5466
5467 unsigned num_selectors_with_args = 0;
5468 for (start = selector_start;
5469 start && *start != '\0' && *start != ']';
5470 start += len)
5471 {
5472 len = ::strcspn(start, ":]");
5473 bool has_arg = (start[len] == ':');
5474 if (has_arg)
5475 ++num_selectors_with_args;
5476 selector_idents.push_back (&m_ast->Idents.get (llvm::StringRef (start, len)));
5477 if (has_arg)
5478 len += 1;
5479 }
5480
5481
5482 if (selector_idents.size() == 0)
5483 return nullptr;
5484
5485 clang::Selector method_selector = m_ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0,
5486 selector_idents.data());
5487
5488 clang::QualType method_qual_type (method_clang_type.GetQualType());
5489
5490 // Populate the method decl with parameter decls
5491 const clang::Type *method_type(method_qual_type.getTypePtr());
5492
5493 if (method_type == nullptr)
5494 return nullptr;
5495
5496 const clang::FunctionProtoType *method_function_prototype (llvm::dyn_cast<clang::FunctionProtoType>(method_type));
5497
5498 if (!method_function_prototype)
5499 return nullptr;
5500
5501
5502 bool is_variadic = false;
5503 bool is_synthesized = false;
5504 bool is_defined = false;
5505 clang::ObjCMethodDecl::ImplementationControl imp_control = clang::ObjCMethodDecl::None;
5506
5507 const unsigned num_args = method_function_prototype->getNumParams();
5508
5509 if (num_args != num_selectors_with_args)
5510 return nullptr; // some debug information is corrupt. We are not going to deal with it.
5511
5512 clang::ObjCMethodDecl *objc_method_decl = clang::ObjCMethodDecl::Create (*m_ast,
5513 clang::SourceLocation(), // beginLoc,
5514 clang::SourceLocation(), // endLoc,
5515 method_selector,
5516 method_function_prototype->getReturnType(),
5517 nullptr, // TypeSourceInfo *ResultTInfo,
5518 GetDeclContextForType (),
5519 name[0] == '-',
5520 is_variadic,
5521 is_synthesized,
5522 true, // is_implicitly_declared; we force this to true because we don't have source locations
5523 is_defined,
5524 imp_control,
5525 false /*has_related_result_type*/);
5526
5527
5528 if (objc_method_decl == nullptr)
5529 return nullptr;
5530
5531 if (num_args > 0)
5532 {
5533 llvm::SmallVector<clang::ParmVarDecl *, 12> params;
5534
5535 for (unsigned param_index = 0; param_index < num_args; ++param_index)
5536 {
5537 params.push_back (clang::ParmVarDecl::Create (*m_ast,
5538 objc_method_decl,
5539 clang::SourceLocation(),
5540 clang::SourceLocation(),
5541 nullptr, // anonymous
5542 method_function_prototype->getParamType(param_index),
5543 nullptr,
5544 clang::SC_Auto,
5545 nullptr));
5546 }
5547
5548 objc_method_decl->setMethodParams(*m_ast, llvm::ArrayRef<clang::ParmVarDecl*>(params), llvm::ArrayRef<clang::SourceLocation>());
5549 }
5550
5551 class_interface_decl->addDecl (objc_method_decl);
5552
5553#ifdef LLDB_CONFIGURATION_DEBUG
5554 VerifyDecl(objc_method_decl);
5555#endif
5556
5557 return objc_method_decl;
5558}
5559
5560
5561clang::DeclContext *
5562ClangASTType::GetDeclContextForType () const
5563{
5564 if (!IsValid())
5565 return nullptr;
5566
5567 clang::QualType qual_type(GetCanonicalQualType());
5568 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5569 switch (type_class)
5570 {
5571 case clang::Type::UnaryTransform: break;
5572 case clang::Type::FunctionNoProto: break;
5573 case clang::Type::FunctionProto: break;
5574 case clang::Type::IncompleteArray: break;
5575 case clang::Type::VariableArray: break;
5576 case clang::Type::ConstantArray: break;
5577 case clang::Type::DependentSizedArray: break;
5578 case clang::Type::ExtVector: break;
5579 case clang::Type::DependentSizedExtVector: break;
5580 case clang::Type::Vector: break;
5581 case clang::Type::Builtin: break;
5582 case clang::Type::BlockPointer: break;
5583 case clang::Type::Pointer: break;
5584 case clang::Type::LValueReference: break;
5585 case clang::Type::RValueReference: break;
5586 case clang::Type::MemberPointer: break;
5587 case clang::Type::Complex: break;
5588 case clang::Type::ObjCObject: break;
5589 case clang::Type::ObjCInterface: return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr())->getInterface();
5590 case clang::Type::ObjCObjectPointer: return ClangASTType (m_ast, llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()).GetDeclContextForType();
5591 case clang::Type::Record: return llvm::cast<clang::RecordType>(qual_type)->getDecl();
5592 case clang::Type::Enum: return llvm::cast<clang::EnumType>(qual_type)->getDecl();
5593 case clang::Type::Typedef: return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDeclContextForType();
5594 case clang::Type::Elaborated: return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetDeclContextForType();
5595 case clang::Type::Paren: return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).GetDeclContextForType();
5596 case clang::Type::TypeOfExpr: break;
5597 case clang::Type::TypeOf: break;
5598 case clang::Type::Decltype: break;
5599 //case clang::Type::QualifiedName: break;
5600 case clang::Type::TemplateSpecialization: break;
5601 case clang::Type::DependentTemplateSpecialization: break;
5602 case clang::Type::TemplateTypeParm: break;
5603 case clang::Type::SubstTemplateTypeParm: break;
5604 case clang::Type::SubstTemplateTypeParmPack:break;
5605 case clang::Type::PackExpansion: break;
5606 case clang::Type::UnresolvedUsing: break;
5607 case clang::Type::Attributed: break;
5608 case clang::Type::Auto: break;
5609 case clang::Type::InjectedClassName: break;
5610 case clang::Type::DependentName: break;
5611 case clang::Type::Atomic: break;
5612 case clang::Type::Adjusted: break;
5613
5614 // pointer type decayed from an array or function type.
5615 case clang::Type::Decayed: break;
5616 }
5617 // No DeclContext in this type...
5618 return nullptr;
5619}
5620
5621bool
5622ClangASTType::SetDefaultAccessForRecordFields (int default_accessibility,
5623 int *assigned_accessibilities,
5624 size_t num_assigned_accessibilities)
5625{
5626 if (IsValid())
5627 {
5628 clang::RecordDecl *record_decl = GetAsRecordDecl();
5629 if (record_decl)
5630 {
5631 uint32_t field_idx;
5632 clang::RecordDecl::field_iterator field, field_end;
5633 for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0;
5634 field != field_end;
5635 ++field, ++field_idx)
5636 {
5637 // If no accessibility was assigned, assign the correct one
5638 if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none)
5639 field->setAccess ((clang::AccessSpecifier)default_accessibility);
5640 }
5641 return true;
5642 }
5643 }
5644 return false;
5645}
5646
5647
5648bool
5649ClangASTType::SetHasExternalStorage (bool has_extern)
5650{
5651 if (!IsValid())
5652 return false;
5653
5654 clang::QualType qual_type (GetCanonicalQualType());
5655
5656 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5657 switch (type_class)
5658 {
5659 case clang::Type::Record:
5660 {
5661 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
5662 if (cxx_record_decl)
5663 {
5664 cxx_record_decl->setHasExternalLexicalStorage (has_extern);
5665 cxx_record_decl->setHasExternalVisibleStorage (has_extern);
5666 return true;
5667 }
5668 }
5669 break;
5670
5671 case clang::Type::Enum:
5672 {
5673 clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl();
5674 if (enum_decl)
5675 {
5676 enum_decl->setHasExternalLexicalStorage (has_extern);
5677 enum_decl->setHasExternalVisibleStorage (has_extern);
5678 return true;
5679 }
5680 }
5681 break;
5682
5683 case clang::Type::ObjCObject:
5684 case clang::Type::ObjCInterface:
5685 {
5686 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5687 assert (objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 5687, __PRETTY_FUNCTION__))
;
5688 if (objc_class_type)
5689 {
5690 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
5691
5692 if (class_interface_decl)
5693 {
5694 class_interface_decl->setHasExternalLexicalStorage (has_extern);
5695 class_interface_decl->setHasExternalVisibleStorage (has_extern);
5696 return true;
5697 }
5698 }
5699 }
5700 break;
5701
5702 case clang::Type::Typedef:
5703 return ClangASTType (m_ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).SetHasExternalStorage (has_extern);
5704
5705 case clang::Type::Elaborated:
5706 return ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).SetHasExternalStorage (has_extern);
5707
5708 case clang::Type::Paren:
5709 return ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).SetHasExternalStorage (has_extern);
5710
5711 default:
5712 break;
5713 }
5714 return false;
5715}
5716
5717bool
5718ClangASTType::SetTagTypeKind (int kind) const
5719{
5720 if (IsValid())
5721 {
5722 clang::QualType tag_qual_type(GetQualType());
5723 const clang::Type *clang_type = tag_qual_type.getTypePtr();
5724 if (clang_type)
5725 {
5726 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(clang_type);
5727 if (tag_type)
5728 {
5729 clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(tag_type->getDecl());
5730 if (tag_decl)
5731 {
5732 tag_decl->setTagKind ((clang::TagDecl::TagKind)kind);
5733 return true;
5734 }
5735 }
5736 }
5737 }
5738 return false;
5739}
5740
5741
5742#pragma mark TagDecl
5743
5744bool
5745ClangASTType::StartTagDeclarationDefinition ()
5746{
5747 if (IsValid())
5748 {
5749 clang::QualType qual_type (GetQualType());
5750 const clang::Type *t = qual_type.getTypePtr();
5751 if (t)
5752 {
5753 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(t);
5754 if (tag_type)
5755 {
5756 clang::TagDecl *tag_decl = tag_type->getDecl();
5757 if (tag_decl)
5758 {
5759 tag_decl->startDefinition();
5760 return true;
5761 }
5762 }
5763
5764 const clang::ObjCObjectType *object_type = llvm::dyn_cast<clang::ObjCObjectType>(t);
5765 if (object_type)
5766 {
5767 clang::ObjCInterfaceDecl *interface_decl = object_type->getInterface();
5768 if (interface_decl)
5769 {
5770 interface_decl->startDefinition();
5771 return true;
5772 }
5773 }
5774 }
5775 }
5776 return false;
5777}
5778
5779bool
5780ClangASTType::CompleteTagDeclarationDefinition ()
5781{
5782 if (IsValid())
5783 {
5784 clang::QualType qual_type (GetQualType());
5785
5786 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
5787
5788 if (cxx_record_decl)
5789 {
5790 cxx_record_decl->completeDefinition();
5791
5792 return true;
5793 }
5794
5795 const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(qual_type.getTypePtr());
5796
5797 if (enum_type)
5798 {
5799 clang::EnumDecl *enum_decl = enum_type->getDecl();
5800
5801 if (enum_decl)
5802 {
5803 /// TODO This really needs to be fixed.
5804
5805 unsigned NumPositiveBits = 1;
5806 unsigned NumNegativeBits = 0;
5807
5808 clang::QualType promotion_qual_type;
5809 // If the enum integer type is less than an integer in bit width,
5810 // then we must promote it to an integer size.
5811 if (m_ast->getTypeSize(enum_decl->getIntegerType()) < m_ast->getTypeSize(m_ast->IntTy))
5812 {
5813 if (enum_decl->getIntegerType()->isSignedIntegerType())
5814 promotion_qual_type = m_ast->IntTy;
5815 else
5816 promotion_qual_type = m_ast->UnsignedIntTy;
5817 }
5818 else
5819 promotion_qual_type = enum_decl->getIntegerType();
5820
5821 enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits);
5822 return true;
5823 }
5824 }
5825 }
5826 return false;
5827}
5828
5829
5830
5831
5832
5833
5834
5835bool
5836ClangASTType::AddEnumerationValueToEnumerationType (const ClangASTType &enumerator_clang_type,
5837 const Declaration &decl,
5838 const char *name,
5839 int64_t enum_value,
5840 uint32_t enum_value_bit_size)
5841{
5842 if (IsValid() && enumerator_clang_type.IsValid() && name && name[0])
5843 {
5844 clang::QualType enum_qual_type (GetCanonicalQualType());
5845
5846 bool is_signed = false;
5847 enumerator_clang_type.IsIntegerType (is_signed);
5848 const clang::Type *clang_type = enum_qual_type.getTypePtr();
5849 if (clang_type)
5850 {
5851 const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(clang_type);
5852
5853 if (enum_type)
5854 {
5855 llvm::APSInt enum_llvm_apsint(enum_value_bit_size, is_signed);
5856 enum_llvm_apsint = enum_value;
5857 clang::EnumConstantDecl *enumerator_decl =
5858 clang::EnumConstantDecl::Create (*m_ast,
5859 enum_type->getDecl(),
5860 clang::SourceLocation(),
5861 name ? &m_ast->Idents.get(name) : nullptr, // Identifier
5862 enumerator_clang_type.GetQualType(),
5863 nullptr,
5864 enum_llvm_apsint);
5865
5866 if (enumerator_decl)
5867 {
5868 enum_type->getDecl()->addDecl(enumerator_decl);
5869
5870#ifdef LLDB_CONFIGURATION_DEBUG
5871 VerifyDecl(enumerator_decl);
5872#endif
5873
5874 return true;
5875 }
5876 }
5877 }
5878 }
5879 return false;
5880}
5881
5882
5883ClangASTType
5884ClangASTType::GetEnumerationIntegerType () const
5885{
5886 clang::QualType enum_qual_type (GetCanonicalQualType());
5887 const clang::Type *clang_type = enum_qual_type.getTypePtr();
5888 if (clang_type)
5889 {
5890 const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(clang_type);
5891 if (enum_type)
5892 {
5893 clang::EnumDecl *enum_decl = enum_type->getDecl();
5894 if (enum_decl)
5895 return ClangASTType (m_ast, enum_decl->getIntegerType());
5896 }
5897 }
5898 return ClangASTType();
5899}
5900
5901ClangASTType
5902ClangASTType::CreateMemberPointerType (const ClangASTType &pointee_type) const
5903{
5904 if (IsValid() && pointee_type.IsValid())
5905 {
5906 return ClangASTType (m_ast, m_ast->getMemberPointerType (pointee_type.GetQualType(),
5907 GetQualType().getTypePtr()));
5908 }
5909 return ClangASTType();
5910}
5911
5912
5913size_t
5914ClangASTType::ConvertStringToFloatValue (const char *s, uint8_t *dst, size_t dst_size) const
5915{
5916 if (IsValid())
5917 {
5918 clang::QualType qual_type (GetCanonicalQualType());
5919 uint32_t count = 0;
5920 bool is_complex = false;
5921 if (IsFloatingPointType (count, is_complex))
5922 {
5923 // TODO: handle complex and vector types
5924 if (count != 1)
5925 return false;
5926
5927 llvm::StringRef s_sref(s);
5928 llvm::APFloat ap_float(m_ast->getFloatTypeSemantics(qual_type), s_sref);
5929
5930 const uint64_t bit_size = m_ast->getTypeSize (qual_type);
5931 const uint64_t byte_size = bit_size / 8;
5932 if (dst_size >= byte_size)
5933 {
5934 if (bit_size == sizeof(float)*8)
5935 {
5936 float float32 = ap_float.convertToFloat();
5937 ::memcpy (dst, &float32, byte_size);
5938 return byte_size;
5939 }
5940 else if (bit_size >= 64)
5941 {
5942 llvm::APInt ap_int(ap_float.bitcastToAPInt());
5943 ::memcpy (dst, ap_int.getRawData(), byte_size);
5944 return byte_size;
5945 }
5946 }
5947 }
5948 }
5949 return 0;
5950}
5951
5952
5953
5954//----------------------------------------------------------------------
5955// Dumping types
5956//----------------------------------------------------------------------
5957#define DEPTH_INCREMENT2 2
5958
5959void
5960ClangASTType::DumpValue (ExecutionContext *exe_ctx,
5961 Stream *s,
5962 lldb::Format format,
5963 const lldb_private::DataExtractor &data,
5964 lldb::offset_t data_byte_offset,
5965 size_t data_byte_size,
5966 uint32_t bitfield_bit_size,
5967 uint32_t bitfield_bit_offset,
5968 bool show_types,
5969 bool show_summary,
5970 bool verbose,
5971 uint32_t depth)
5972{
5973 if (!IsValid())
5974 return;
5975
5976 clang::QualType qual_type(GetQualType());
5977 switch (qual_type->getTypeClass())
5978 {
5979 case clang::Type::Record:
5980 if (GetCompleteType ())
5981 {
5982 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5983 const clang::RecordDecl *record_decl = record_type->getDecl();
5984 assert(record_decl)((record_decl) ? static_cast<void> (0) : __assert_fail (
"record_decl", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 5984, __PRETTY_FUNCTION__))
;
5985 uint32_t field_bit_offset = 0;
5986 uint32_t field_byte_offset = 0;
5987 const clang::ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
5988 uint32_t child_idx = 0;
5989
5990 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
5991 if (cxx_record_decl)
5992 {
5993 // We might have base classes to print out first
5994 clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
5995 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
5996 base_class != base_class_end;
5997 ++base_class)
5998 {
5999 const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
6000
6001 // Skip empty base classes
6002 if (verbose == false && ClangASTContext::RecordHasFields(base_class_decl) == false)
6003 continue;
6004
6005 if (base_class->isVirtual())
6006 field_bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
6007 else
6008 field_bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
6009 field_byte_offset = field_bit_offset / 8;
6010 assert (field_bit_offset % 8 == 0)((field_bit_offset % 8 == 0) ? static_cast<void> (0) : __assert_fail
("field_bit_offset % 8 == 0", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 6010, __PRETTY_FUNCTION__))
;
6011 if (child_idx == 0)
6012 s->PutChar('{');
6013 else
6014 s->PutChar(',');
6015
6016 clang::QualType base_class_qual_type = base_class->getType();
6017 std::string base_class_type_name(base_class_qual_type.getAsString());
6018
6019 // Indent and print the base class type name
6020 s->Printf("\n%*s%s ", depth + DEPTH_INCREMENT2, "", base_class_type_name.c_str());
6021
6022 clang::TypeInfo base_class_type_info = m_ast->getTypeInfo(base_class_qual_type);
6023
6024 // Dump the value of the member
6025 ClangASTType base_clang_type(m_ast, base_class_qual_type);
6026 base_clang_type.DumpValue (exe_ctx,
6027 s, // Stream to dump to
6028 base_clang_type.GetFormat(), // The format with which to display the member
6029 data, // Data buffer containing all bytes for this type
6030 data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from
6031 base_class_type_info.Width / 8, // Size of this type in bytes
6032 0, // Bitfield bit size
6033 0, // Bitfield bit offset
6034 show_types, // Boolean indicating if we should show the variable types
6035 show_summary, // Boolean indicating if we should show a summary for the current type
6036 verbose, // Verbose output?
6037 depth + DEPTH_INCREMENT2); // Scope depth for any types that have children
6038
6039 ++child_idx;
6040 }
6041 }
6042 uint32_t field_idx = 0;
6043 clang::RecordDecl::field_iterator field, field_end;
6044 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx)
6045 {
6046 // Print the starting squiggly bracket (if this is the
6047 // first member) or comman (for member 2 and beyong) for
6048 // the struct/union/class member.
6049 if (child_idx == 0)
6050 s->PutChar('{');
6051 else
6052 s->PutChar(',');
6053
6054 // Indent
6055 s->Printf("\n%*s", depth + DEPTH_INCREMENT2, "");
6056
6057 clang::QualType field_type = field->getType();
6058 // Print the member type if requested
6059 // Figure out the type byte size (field_type_info.first) and
6060 // alignment (field_type_info.second) from the AST context.
6061 clang::TypeInfo field_type_info = m_ast->getTypeInfo(field_type);
6062 assert(field_idx < record_layout.getFieldCount())((field_idx < record_layout.getFieldCount()) ? static_cast
<void> (0) : __assert_fail ("field_idx < record_layout.getFieldCount()"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 6062, __PRETTY_FUNCTION__))
;
6063 // Figure out the field offset within the current struct/union/class type
6064 field_bit_offset = record_layout.getFieldOffset (field_idx);
6065 field_byte_offset = field_bit_offset / 8;
6066 uint32_t field_bitfield_bit_size = 0;
6067 uint32_t field_bitfield_bit_offset = 0;
6068 if (ClangASTContext::FieldIsBitfield (m_ast, *field, field_bitfield_bit_size))
6069 field_bitfield_bit_offset = field_bit_offset % 8;
6070
6071 if (show_types)
6072 {
6073 std::string field_type_name(field_type.getAsString());
6074 if (field_bitfield_bit_size > 0)
6075 s->Printf("(%s:%u) ", field_type_name.c_str(), field_bitfield_bit_size);
6076 else
6077 s->Printf("(%s) ", field_type_name.c_str());
6078 }
6079 // Print the member name and equal sign
6080 s->Printf("%s = ", field->getNameAsString().c_str());
6081
6082
6083 // Dump the value of the member
6084 ClangASTType field_clang_type (m_ast, field_type);
6085 field_clang_type.DumpValue (exe_ctx,
6086 s, // Stream to dump to
6087 field_clang_type.GetFormat(), // The format with which to display the member
6088 data, // Data buffer containing all bytes for this type
6089 data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from
6090 field_type_info.Width / 8, // Size of this type in bytes
6091 field_bitfield_bit_size, // Bitfield bit size
6092 field_bitfield_bit_offset, // Bitfield bit offset
6093 show_types, // Boolean indicating if we should show the variable types
6094 show_summary, // Boolean indicating if we should show a summary for the current type
6095 verbose, // Verbose output?
6096 depth + DEPTH_INCREMENT2); // Scope depth for any types that have children
6097 }
6098
6099 // Indent the trailing squiggly bracket
6100 if (child_idx > 0)
6101 s->Printf("\n%*s}", depth, "");
6102 }
6103 return;
6104
6105 case clang::Type::Enum:
6106 if (GetCompleteType ())
6107 {
6108 const clang::EnumType *enum_type = llvm::cast<clang::EnumType>(qual_type.getTypePtr());
6109 const clang::EnumDecl *enum_decl = enum_type->getDecl();
6110 assert(enum_decl)((enum_decl) ? static_cast<void> (0) : __assert_fail ("enum_decl"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 6110, __PRETTY_FUNCTION__))
;
6111 clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
6112 lldb::offset_t offset = data_byte_offset;
6113 const int64_t enum_value = data.GetMaxU64Bitfield(&offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset);
6114 for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos)
6115 {
6116 if (enum_pos->getInitVal() == enum_value)
6117 {
6118 s->Printf("%s", enum_pos->getNameAsString().c_str());
6119 return;
6120 }
6121 }
6122 // If we have gotten here we didn't get find the enumerator in the
6123 // enum decl, so just print the integer.
6124 s->Printf("%" PRIi64"l" "i", enum_value);
6125 }
6126 return;
6127
6128 case clang::Type::ConstantArray:
6129 {
6130 const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr());
6131 bool is_array_of_characters = false;
6132 clang::QualType element_qual_type = array->getElementType();
6133
6134 const clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr();
6135 if (canonical_type)
6136 is_array_of_characters = canonical_type->isCharType();
6137
6138 const uint64_t element_count = array->getSize().getLimitedValue();
6139
6140 clang::TypeInfo field_type_info = m_ast->getTypeInfo(element_qual_type);
6141
6142 uint32_t element_idx = 0;
6143 uint32_t element_offset = 0;
6144 uint64_t element_byte_size = field_type_info.Width / 8;
6145 uint32_t element_stride = element_byte_size;
6146
6147 if (is_array_of_characters)
6148 {
6149 s->PutChar('"');
6150 data.Dump(s, data_byte_offset, lldb::eFormatChar, element_byte_size, element_count, UINT32_MAX(4294967295U), LLDB_INVALID_ADDRESS(18446744073709551615UL), 0, 0);
6151 s->PutChar('"');
6152 return;
6153 }
6154 else
6155 {
6156 ClangASTType element_clang_type(m_ast, element_qual_type);
6157 lldb::Format element_format = element_clang_type.GetFormat();
6158
6159 for (element_idx = 0; element_idx < element_count; ++element_idx)
6160 {
6161 // Print the starting squiggly bracket (if this is the
6162 // first member) or comman (for member 2 and beyong) for
6163 // the struct/union/class member.
6164 if (element_idx == 0)
6165 s->PutChar('{');
6166 else
6167 s->PutChar(',');
6168
6169 // Indent and print the index
6170 s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT2, "", element_idx);
6171
6172 // Figure out the field offset within the current struct/union/class type
6173 element_offset = element_idx * element_stride;
6174
6175 // Dump the value of the member
6176 element_clang_type.DumpValue (exe_ctx,
6177 s, // Stream to dump to
6178 element_format, // The format with which to display the element
6179 data, // Data buffer containing all bytes for this type
6180 data_byte_offset + element_offset,// Offset into "data" where to grab value from
6181 element_byte_size, // Size of this type in bytes
6182 0, // Bitfield bit size
6183 0, // Bitfield bit offset
6184 show_types, // Boolean indicating if we should show the variable types
6185 show_summary, // Boolean indicating if we should show a summary for the current type
6186 verbose, // Verbose output?
6187 depth + DEPTH_INCREMENT2); // Scope depth for any types that have children
6188 }
6189
6190 // Indent the trailing squiggly bracket
6191 if (element_idx > 0)
6192 s->Printf("\n%*s}", depth, "");
6193 }
6194 }
6195 return;
6196
6197 case clang::Type::Typedef:
6198 {
6199 clang::QualType typedef_qual_type = llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType();
6200
6201 ClangASTType typedef_clang_type (m_ast, typedef_qual_type);
6202 lldb::Format typedef_format = typedef_clang_type.GetFormat();
6203 clang::TypeInfo typedef_type_info = m_ast->getTypeInfo(typedef_qual_type);
6204 uint64_t typedef_byte_size = typedef_type_info.Width / 8;
6205
6206 return typedef_clang_type.DumpValue (exe_ctx,
6207 s, // Stream to dump to
6208 typedef_format, // The format with which to display the element
6209 data, // Data buffer containing all bytes for this type
6210 data_byte_offset, // Offset into "data" where to grab value from
6211 typedef_byte_size, // Size of this type in bytes
6212 bitfield_bit_size, // Bitfield bit size
6213 bitfield_bit_offset,// Bitfield bit offset
6214 show_types, // Boolean indicating if we should show the variable types
6215 show_summary, // Boolean indicating if we should show a summary for the current type
6216 verbose, // Verbose output?
6217 depth); // Scope depth for any types that have children
6218 }
6219 break;
6220
6221 case clang::Type::Elaborated:
6222 {
6223 clang::QualType elaborated_qual_type = llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType();
6224 ClangASTType elaborated_clang_type (m_ast, elaborated_qual_type);
6225 lldb::Format elaborated_format = elaborated_clang_type.GetFormat();
6226 clang::TypeInfo elaborated_type_info = m_ast->getTypeInfo(elaborated_qual_type);
6227 uint64_t elaborated_byte_size = elaborated_type_info.Width / 8;
6228
6229 return elaborated_clang_type.DumpValue (exe_ctx,
6230 s, // Stream to dump to
6231 elaborated_format, // The format with which to display the element
6232 data, // Data buffer containing all bytes for this type
6233 data_byte_offset, // Offset into "data" where to grab value from
6234 elaborated_byte_size, // Size of this type in bytes
6235 bitfield_bit_size, // Bitfield bit size
6236 bitfield_bit_offset,// Bitfield bit offset
6237 show_types, // Boolean indicating if we should show the variable types
6238 show_summary, // Boolean indicating if we should show a summary for the current type
6239 verbose, // Verbose output?
6240 depth); // Scope depth for any types that have children
6241 }
6242 break;
6243
6244 case clang::Type::Paren:
6245 {
6246 clang::QualType desugar_qual_type = llvm::cast<clang::ParenType>(qual_type)->desugar();
6247 ClangASTType desugar_clang_type (m_ast, desugar_qual_type);
6248
6249 lldb::Format desugar_format = desugar_clang_type.GetFormat();
6250 clang::TypeInfo desugar_type_info = m_ast->getTypeInfo(desugar_qual_type);
6251 uint64_t desugar_byte_size = desugar_type_info.Width / 8;
6252
6253 return desugar_clang_type.DumpValue (exe_ctx,
6254 s, // Stream to dump to
6255 desugar_format, // The format with which to display the element
6256 data, // Data buffer containing all bytes for this type
6257 data_byte_offset, // Offset into "data" where to grab value from
6258 desugar_byte_size, // Size of this type in bytes
6259 bitfield_bit_size, // Bitfield bit size
6260 bitfield_bit_offset,// Bitfield bit offset
6261 show_types, // Boolean indicating if we should show the variable types
6262 show_summary, // Boolean indicating if we should show a summary for the current type
6263 verbose, // Verbose output?
6264 depth); // Scope depth for any types that have children
6265 }
6266 break;
6267
6268 default:
6269 // We are down the a scalar type that we just need to display.
6270 data.Dump(s,
6271 data_byte_offset,
6272 format,
6273 data_byte_size,
6274 1,
6275 UINT32_MAX(4294967295U),
6276 LLDB_INVALID_ADDRESS(18446744073709551615UL),
6277 bitfield_bit_size,
6278 bitfield_bit_offset);
6279
6280 if (show_summary)
6281 DumpSummary (exe_ctx, s, data, data_byte_offset, data_byte_size);
6282 break;
6283 }
6284}
6285
6286
6287
6288
6289bool
6290ClangASTType::DumpTypeValue (Stream *s,
6291 lldb::Format format,
6292 const lldb_private::DataExtractor &data,
6293 lldb::offset_t byte_offset,
6294 size_t byte_size,
6295 uint32_t bitfield_bit_size,
6296 uint32_t bitfield_bit_offset,
6297 ExecutionContextScope *exe_scope)
6298{
6299 if (!IsValid())
6300 return false;
6301 if (IsAggregateType())
6302 {
6303 return false;
6304 }
6305 else
6306 {
6307 clang::QualType qual_type(GetQualType());
6308
6309 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6310 switch (type_class)
6311 {
6312 case clang::Type::Typedef:
6313 {
6314 clang::QualType typedef_qual_type = llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType();
6315 ClangASTType typedef_clang_type (m_ast, typedef_qual_type);
6316 if (format == eFormatDefault)
6317 format = typedef_clang_type.GetFormat();
6318 clang::TypeInfo typedef_type_info = m_ast->getTypeInfo(typedef_qual_type);
6319 uint64_t typedef_byte_size = typedef_type_info.Width / 8;
6320
6321 return typedef_clang_type.DumpTypeValue (s,
6322 format, // The format with which to display the element
6323 data, // Data buffer containing all bytes for this type
6324 byte_offset, // Offset into "data" where to grab value from
6325 typedef_byte_size, // Size of this type in bytes
6326 bitfield_bit_size, // Size in bits of a bitfield value, if zero don't treat as a bitfield
6327 bitfield_bit_offset, // Offset in bits of a bitfield value if bitfield_bit_size != 0
6328 exe_scope);
6329 }
6330 break;
6331
6332 case clang::Type::Enum:
6333 // If our format is enum or default, show the enumeration value as
6334 // its enumeration string value, else just display it as requested.
6335 if ((format == eFormatEnum || format == eFormatDefault) && GetCompleteType ())
6336 {
6337 const clang::EnumType *enum_type = llvm::cast<clang::EnumType>(qual_type.getTypePtr());
6338 const clang::EnumDecl *enum_decl = enum_type->getDecl();
6339 assert(enum_decl)((enum_decl) ? static_cast<void> (0) : __assert_fail ("enum_decl"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 6339, __PRETTY_FUNCTION__))
;
6340 clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
6341 const bool is_signed = qual_type->isSignedIntegerOrEnumerationType();
6342 lldb::offset_t offset = byte_offset;
6343 if (is_signed)
6344 {
6345 const int64_t enum_svalue = data.GetMaxS64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
6346 for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos)
6347 {
6348 if (enum_pos->getInitVal().getSExtValue() == enum_svalue)
6349 {
6350 s->PutCString (enum_pos->getNameAsString().c_str());
6351 return true;
6352 }
6353 }
6354 // If we have gotten here we didn't get find the enumerator in the
6355 // enum decl, so just print the integer.
6356 s->Printf("%" PRIi64"l" "i", enum_svalue);
6357 }
6358 else
6359 {
6360 const uint64_t enum_uvalue = data.GetMaxU64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
6361 for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos)
6362 {
6363 if (enum_pos->getInitVal().getZExtValue() == enum_uvalue)
6364 {
6365 s->PutCString (enum_pos->getNameAsString().c_str());
6366 return true;
6367 }
6368 }
6369 // If we have gotten here we didn't get find the enumerator in the
6370 // enum decl, so just print the integer.
6371 s->Printf("%" PRIu64"l" "u", enum_uvalue);
6372 }
6373 return true;
6374 }
6375 // format was not enum, just fall through and dump the value as requested....
6376
6377 default:
6378 // We are down the a scalar type that we just need to display.
6379 {
6380 uint32_t item_count = 1;
6381 // A few formats, we might need to modify our size and count for depending
6382 // on how we are trying to display the value...
6383 switch (format)
6384 {
6385 default:
6386 case eFormatBoolean:
6387 case eFormatBinary:
6388 case eFormatComplex:
6389 case eFormatCString: // NULL terminated C strings
6390 case eFormatDecimal:
6391 case eFormatEnum:
6392 case eFormatHex:
6393 case eFormatHexUppercase:
6394 case eFormatFloat:
6395 case eFormatOctal:
6396 case eFormatOSType:
6397 case eFormatUnsigned:
6398 case eFormatPointer:
6399 case eFormatVectorOfChar:
6400 case eFormatVectorOfSInt8:
6401 case eFormatVectorOfUInt8:
6402 case eFormatVectorOfSInt16:
6403 case eFormatVectorOfUInt16:
6404 case eFormatVectorOfSInt32:
6405 case eFormatVectorOfUInt32:
6406 case eFormatVectorOfSInt64:
6407 case eFormatVectorOfUInt64:
6408 case eFormatVectorOfFloat32:
6409 case eFormatVectorOfFloat64:
6410 case eFormatVectorOfUInt128:
6411 break;
6412
6413 case eFormatChar:
6414 case eFormatCharPrintable:
6415 case eFormatCharArray:
6416 case eFormatBytes:
6417 case eFormatBytesWithASCII:
6418 item_count = byte_size;
6419 byte_size = 1;
6420 break;
6421
6422 case eFormatUnicode16:
6423 item_count = byte_size / 2;
6424 byte_size = 2;
6425 break;
6426
6427 case eFormatUnicode32:
6428 item_count = byte_size / 4;
6429 byte_size = 4;
6430 break;
6431 }
6432 return data.Dump (s,
6433 byte_offset,
6434 format,
6435 byte_size,
6436 item_count,
6437 UINT32_MAX(4294967295U),
6438 LLDB_INVALID_ADDRESS(18446744073709551615UL),
6439 bitfield_bit_size,
6440 bitfield_bit_offset,
6441 exe_scope);
6442 }
6443 break;
6444 }
6445 }
6446 return 0;
6447}
6448
6449
6450
6451void
6452ClangASTType::DumpSummary (ExecutionContext *exe_ctx,
6453 Stream *s,
6454 const lldb_private::DataExtractor &data,
6455 lldb::offset_t data_byte_offset,
6456 size_t data_byte_size)
6457{
6458 uint32_t length = 0;
6459 if (IsCStringType (length))
6460 {
6461 if (exe_ctx)
6462 {
6463 Process *process = exe_ctx->GetProcessPtr();
6464 if (process)
6465 {
6466 lldb::offset_t offset = data_byte_offset;
6467 lldb::addr_t pointer_address = data.GetMaxU64(&offset, data_byte_size);
6468 std::vector<uint8_t> buf;
6469 if (length > 0)
6470 buf.resize (length);
6471 else
6472 buf.resize (256);
6473
6474 lldb_private::DataExtractor cstr_data(&buf.front(), buf.size(), process->GetByteOrder(), 4);
6475 buf.back() = '\0';
6476 size_t bytes_read;
6477 size_t total_cstr_len = 0;
6478 Error error;
6479 while ((bytes_read = process->ReadMemory (pointer_address, &buf.front(), buf.size(), error)) > 0)
6480 {
6481 const size_t len = strlen((const char *)&buf.front());
6482 if (len == 0)
6483 break;
6484 if (total_cstr_len == 0)
6485 s->PutCString (" \"");
6486 cstr_data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX(4294967295U), LLDB_INVALID_ADDRESS(18446744073709551615UL), 0, 0);
6487 total_cstr_len += len;
6488 if (len < buf.size())
6489 break;
6490 pointer_address += total_cstr_len;
6491 }
6492 if (total_cstr_len > 0)
6493 s->PutChar ('"');
6494 }
6495 }
6496 }
6497}
6498
6499void
6500ClangASTType::DumpTypeDescription () const
6501{
6502 StreamFile s (stdoutstdout, false);
6503 DumpTypeDescription (&s);
6504 ClangASTMetadata *metadata = ClangASTContext::GetMetadata (m_ast, m_type);
6505 if (metadata)
6506 {
6507 metadata->Dump (&s);
6508 }
6509}
6510
6511void
6512ClangASTType::DumpTypeDescription (Stream *s) const
6513{
6514 if (IsValid())
6515 {
6516 clang::QualType qual_type(GetQualType());
6517
6518 llvm::SmallVector<char, 1024> buf;
6519 llvm::raw_svector_ostream llvm_ostrm (buf);
6520
6521 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6522 switch (type_class)
6523 {
6524 case clang::Type::ObjCObject:
6525 case clang::Type::ObjCInterface:
6526 {
6527 GetCompleteType ();
6528
6529 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
6530 assert (objc_class_type)((objc_class_type) ? static_cast<void> (0) : __assert_fail
("objc_class_type", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn219601/tools/lldb/source/Symbol/ClangASTType.cpp"
, 6530, __PRETTY_FUNCTION__))
;
6531 if (objc_class_type)
6532 {
6533 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
6534 if (class_interface_decl)
6535 {
6536 clang::PrintingPolicy policy = m_ast->getPrintingPolicy();
6537 class_interface_decl->print(llvm_ostrm, policy, s->GetIndentLevel());
6538 }
6539 }
6540 }
6541 break;
6542
6543 case clang::Type::Typedef:
6544 {
6545 const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>();
6546 if (typedef_type)
6547 {
6548 const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
6549 std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString());
6550 if (!clang_typedef_name.empty())
6551 {
6552 s->PutCString ("typedef ");
6553 s->PutCString (clang_typedef_name.c_str());
6554 }
6555 }
6556 }
6557 break;
6558
6559 case clang::Type::Elaborated:
6560 ClangASTType (m_ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).DumpTypeDescription(s);
6561 return;
6562
6563 case clang::Type::Paren:
6564 ClangASTType (m_ast, llvm::cast<clang::ParenType>(qual_type)->desugar()).DumpTypeDescription(s);
6565 return;
6566
6567 case clang::Type::Record:
6568 {
6569 GetCompleteType ();
6570
6571 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
6572 const clang::RecordDecl *record_decl = record_type->getDecl();
6573 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
6574
6575 if (cxx_record_decl)
6576 cxx_record_decl->print(llvm_ostrm, m_ast->getPrintingPolicy(), s->GetIndentLevel());
6577 else
6578 record_decl->print(llvm_ostrm, m_ast->getPrintingPolicy(), s->GetIndentLevel());
6579 }
6580 break;
6581
6582 default:
6583 {
6584 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
6585 if (tag_type)
6586 {
6587 clang::TagDecl *tag_decl = tag_type->getDecl();
6588 if (tag_decl)
6589 tag_decl->print(llvm_ostrm, 0);
6590 }
6591 else
6592 {
6593 std::string clang_type_name(qual_type.getAsString());
6594 if (!clang_type_name.empty())
6595 s->PutCString (clang_type_name.c_str());
6596 }
6597 }
6598 }
6599
6600 llvm_ostrm.flush();
6601 if (buf.size() > 0)
6602 {
6603 s->Write (buf.data(), buf.size());
6604 }
6605 }
6606}
6607
6608bool
6609ClangASTType::GetValueAsScalar (const lldb_private::DataExtractor &data,
6610 lldb::offset_t data_byte_offset,
6611 size_t data_byte_size,
6612 Scalar &value) const
6613{
6614 if (!IsValid())
6615 return false;
6616
6617 if (IsAggregateType ())
6618 {
6619 return false; // Aggregate types don't have scalar values
6620 }
6621 else
6622 {
6623 uint64_t count = 0;
6624 lldb::Encoding encoding = GetEncoding (count);
6625
6626 if (encoding == lldb::eEncodingInvalid || count != 1)
6627 return false;
6628
6629 const uint64_t byte_size = GetByteSize();
6630 lldb::offset_t offset = data_byte_offset;
6631 switch (encoding)
6632 {
6633 case lldb::eEncodingInvalid:
6634 break;
6635 case lldb::eEncodingVector:
6636 break;
6637 case lldb::eEncodingUint:
6638 if (byte_size <= sizeof(unsigned long long))
6639 {
6640 uint64_t uval64 = data.GetMaxU64 (&offset, byte_size);
6641 if (byte_size <= sizeof(unsigned int))
6642 {
6643 value = (unsigned int)uval64;
6644 return true;
6645 }
6646 else if (byte_size <= sizeof(unsigned long))
6647 {
6648 value = (unsigned long)uval64;
6649 return true;
6650 }
6651 else if (byte_size <= sizeof(unsigned long long))
6652 {
6653 value = (unsigned long long )uval64;
6654 return true;
6655 }
6656 else
6657 value.Clear();
6658 }
6659 break;
6660
6661 case lldb::eEncodingSint:
6662 if (byte_size <= sizeof(long long))
6663 {
6664 int64_t sval64 = data.GetMaxS64 (&offset, byte_size);
6665 if (byte_size <= sizeof(int))
6666 {
6667 value = (int)sval64;
6668 return true;
6669 }
6670 else if (byte_size <= sizeof(long))
6671 {
6672 value = (long)sval64;
6673 return true;
6674 }
6675 else if (byte_size <= sizeof(long long))
6676 {
6677 value = (long long )sval64;
6678 return true;
6679 }
6680 else
6681 value.Clear();
6682 }
6683 break;
6684
6685 case lldb::eEncodingIEEE754:
6686 if (byte_size <= sizeof(long double))
6687 {
6688 uint32_t u32;
6689 uint64_t u64;
6690 if (byte_size == sizeof(float))
6691 {
6692 if (sizeof(float) == sizeof(uint32_t))
6693 {
6694 u32 = data.GetU32(&offset);
6695 value = *((float *)&u32);
6696 return true;
6697 }
6698 else if (sizeof(float) == sizeof(uint64_t))
6699 {
6700 u64 = data.GetU64(&offset);
6701 value = *((float *)&u64);
6702 return true;
6703 }
6704 }
6705 else
6706 if (byte_size == sizeof(double))
6707 {
6708 if (sizeof(double) == sizeof(uint32_t))
6709 {
6710 u32 = data.GetU32(&offset);
6711 value = *((double *)&u32);
6712 return true;
6713 }
6714 else if (sizeof(double) == sizeof(uint64_t))
6715 {
6716 u64 = data.GetU64(&offset);
6717 value = *((double *)&u64);
6718 return true;
6719 }
6720 }
6721 else
6722 if (byte_size == sizeof(long double))
6723 {
6724 if (sizeof(long double) == sizeof(uint32_t))
6725 {
6726 u32 = data.GetU32(&offset);
6727 value = *((long double *)&u32);
6728 return true;
6729 }
6730 else if (sizeof(long double) == sizeof(uint64_t))
6731 {
6732 u64 = data.GetU64(&offset);
6733 value = *((long double *)&u64);
6734 return true;
6735 }
6736 }
6737 }
6738 break;
6739 }
6740 }
6741 return false;
6742}
6743
6744bool
6745ClangASTType::SetValueFromScalar (const Scalar &value, Stream &strm)
6746{
6747 // Aggregate types don't have scalar values
6748 if (!IsAggregateType ())
6749 {
6750 strm.GetFlags().Set(Stream::eBinary);
6751 uint64_t count = 0;
6752 lldb::Encoding encoding = GetEncoding (count);
6753
6754 if (encoding == lldb::eEncodingInvalid || count != 1)
6755 return false;
6756
6757 const uint64_t bit_width = GetBitSize();
6758 // This function doesn't currently handle non-byte aligned assignments
6759 if ((bit_width % 8) != 0)
6760 return false;
6761
6762 const uint64_t byte_size = (bit_width + 7 ) / 8;
6763 switch (encoding)
6764 {
6765 case lldb::eEncodingInvalid:
6766 break;
6767 case lldb::eEncodingVector:
6768 break;
6769 case lldb::eEncodingUint:
6770 switch (byte_size)
6771 {
6772 case 1: strm.PutHex8(value.UInt()); return true;
6773 case 2: strm.PutHex16(value.UInt()); return true;
6774 case 4: strm.PutHex32(value.UInt()); return true;
6775 case 8: strm.PutHex64(value.ULongLong()); return true;
6776 default:
6777 break;
6778 }
6779 break;
6780
6781 case lldb::eEncodingSint:
6782 switch (byte_size)
6783 {
6784 case 1: strm.PutHex8(value.SInt()); return true;
6785 case 2: strm.PutHex16(value.SInt()); return true;
6786 case 4: strm.PutHex32(value.SInt()); return true;
6787 case 8: strm.PutHex64(value.SLongLong()); return true;
6788 default:
6789 break;
6790 }
6791 break;
6792
6793 case lldb::eEncodingIEEE754:
6794 if (byte_size <= sizeof(long double))
6795 {
6796 if (byte_size == sizeof(float))
6797 {
6798 strm.PutFloat(value.Float());
6799 return true;
6800 }
6801 else
6802 if (byte_size == sizeof(double))
6803 {
6804 strm.PutDouble(value.Double());
6805 return true;
6806 }
6807 else
6808 if (byte_size == sizeof(long double))
6809 {
6810 strm.PutDouble(value.LongDouble());
6811 return true;
6812 }
6813 }
6814 break;
6815 }
6816 }
6817 return false;
6818}
6819
6820bool
6821ClangASTType::ReadFromMemory (lldb_private::ExecutionContext *exe_ctx,
6822 lldb::addr_t addr,
6823 AddressType address_type,
6824 lldb_private::DataExtractor &data)
6825{
6826 if (!IsValid())
6827 return false;
6828
6829 // Can't convert a file address to anything valid without more
6830 // context (which Module it came from)
6831 if (address_type == eAddressTypeFile)
6832 return false;
6833
6834 if (!GetCompleteType())
6835 return false;
6836
6837 const uint64_t byte_size = GetByteSize();
6838 if (data.GetByteSize() < byte_size)
6839 {
6840 lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0'));
6841 data.SetData(data_sp);
6842 }
6843
6844 uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size);
6845 if (dst != nullptr)
6846 {
6847 if (address_type == eAddressTypeHost)
6848 {
6849 if (addr == 0)
6850 return false;
6851 // The address is an address in this process, so just copy it
6852 memcpy (dst, (uint8_t*)nullptr + addr, byte_size);
6853 return true;
6854 }
6855 else
6856 {
6857 Process *process = nullptr;
6858 if (exe_ctx)
6859 process = exe_ctx->GetProcessPtr();
6860 if (process)
6861 {
6862 Error error;
6863 return process->ReadMemory(addr, dst, byte_size, error) == byte_size;
6864 }
6865 }
6866 }
6867 return false;
6868}
6869
6870bool
6871ClangASTType::WriteToMemory (lldb_private::ExecutionContext *exe_ctx,
6872 lldb::addr_t addr,
6873 AddressType address_type,
6874 StreamString &new_value)
6875{
6876 if (!IsValid())
6877 return false;
6878
6879 // Can't convert a file address to anything valid without more
6880 // context (which Module it came from)
6881 if (address_type == eAddressTypeFile)
6882 return false;
6883
6884 if (!GetCompleteType())
6885 return false;
6886
6887 const uint64_t byte_size = GetByteSize();
6888
6889 if (byte_size > 0)
6890 {
6891 if (address_type == eAddressTypeHost)
6892 {
6893 // The address is an address in this process, so just copy it
6894 memcpy ((void *)addr, new_value.GetData(), byte_size);
6895 return true;
6896 }
6897 else
6898 {
6899 Process *process = nullptr;
6900 if (exe_ctx)
6901 process = exe_ctx->GetProcessPtr();
6902 if (process)
6903 {
6904 Error error;
6905 return process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size;
6906 }
6907 }
6908 }
6909 return false;
6910}
6911
6912
6913//clang::CXXRecordDecl *
6914//ClangASTType::GetAsCXXRecordDecl (lldb::clang_type_t opaque_clang_qual_type)
6915//{
6916// if (opaque_clang_qual_type)
6917// return clang::QualType::getFromOpaquePtr(opaque_clang_qual_type)->getAsCXXRecordDecl();
6918// return NULL;
6919//}
6920
6921bool
6922lldb_private::operator == (const lldb_private::ClangASTType &lhs, const lldb_private::ClangASTType &rhs)
6923{
6924 return lhs.GetASTContext() == rhs.GetASTContext() && lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType();
6925}
6926
6927
6928bool
6929lldb_private::operator != (const lldb_private::ClangASTType &lhs, const lldb_private::ClangASTType &rhs)
6930{
6931 return lhs.GetASTContext() != rhs.GetASTContext() || lhs.GetOpaqueQualType() != rhs.GetOpaqueQualType();
6932}
6933
6934
6935