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