contrib/llvm/tools/lldb/source/Symbol/ClangASTType.cpp

   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
  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
 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
 176 ClangASTType::ClangASTType (clang::ASTContext *ast,
 177                             clang::QualType qual_type) :
 178     m_type (qual_type.getAsOpaquePtr()),
 179     m_ast (ast)
 180 {
 181 }
 182
 183 ClangASTType::~ClangASTType()
 184 {
 185 }
 186
 187 //----------------------------------------------------------------------
 188 // Tests
 189 //----------------------------------------------------------------------
 190
 191 bool
 192 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
 225 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
 293 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
 314 ClangASTType::IsCharType () const
 315 {
 316     if (!IsValid())
 317         return false;
 318     return GetQualType().getUnqualifiedType()->isCharType();
 319 }
 320
 321
 322 bool
 323 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
 332 ClangASTType::IsConst() const
 333 {
 334     return GetQualType().isConstQualified();
 335 }
 336
 337 bool
 338 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
 365 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
 410 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
 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
 439 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
 475 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
 496 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
 547 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
 606 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
 640 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
 682 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
 711 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
 726 ClangASTType::IsObjCObjectOrInterfaceType () const
 727 {
 728     if (IsValid())
 729         return GetCanonicalQualType()->isObjCObjectOrInterfaceType();
 730     return false;
 731 }
 732
 733 bool
 734 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
 764 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
 945 ClangASTType::IsScalarType () const
 946 {
 947     if (!IsValid())
 948         return false;
 949
 950     return (GetTypeInfo (NULL) & eTypeIsScalar) != 0;
 951 }
 952
 953 bool
 954 ClangASTType::IsTypedefType () const
 955 {
 956     if (!IsValid())
 957         return false;
 958     return GetQualType()->getTypeClass() == clang::Type::Typedef;
 959 }
 960
 961 bool
 962 ClangASTType::IsVoidType () const
 963 {
 964     if (!IsValid())
 965         return false;
 966     return GetCanonicalQualType()->isVoidType();
 967 }
 968
 969 bool
 970 ClangASTType::IsPointerToScalarType () const
 971 {
 972     if (!IsValid())
 973         return false;
 974
 975     return IsPointerType() && GetPointeeType().IsScalarType();
 976 }
 977
 978 bool
 979 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
 989 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
1008 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
1020 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
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
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
1087 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
1099 ClangASTType::GetPointerByteSize () const
1100 {
1101     if (m_ast)
1102         return m_ast->getTypeSize(m_ast->VoidPtrTy) / 8;
1103     return 0;
1104 }
1105
1106 ConstString
1107 ClangASTType::GetConstQualifiedTypeName () const
1108 {
1109     return GetConstTypeName ();
1110 }
1111
1112 ConstString
1113 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
1125 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
1150 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
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
1412 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
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
1497 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
1509 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
1521 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
1533 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
1545 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
1563 ClangASTType::GetCanonicalType () const
1564 {
1565     if (IsValid())
1566         return ClangASTType (m_ast, GetCanonicalQualType());
1567     return ClangASTType();
1568 }
1569
1570 static QualType
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
1584 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
1593 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
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
1621 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
1635 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
1645 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
1655 ClangASTType::GetNonReferenceType () const
1656 {
1657     if (IsValid())
1658         return ClangASTType(m_ast, GetQualType().getNonReferenceType());
1659     return ClangASTType();
1660 }
1661
1662 ClangASTType
1663 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
1688 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
1699 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
1720 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
1732 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
1749 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
1760 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
1779 ClangASTType::GetByteSize () const
1780 {
1781     return (GetBitSize () + 7) / 8;
1782 }
1783
1784 size_t
1785 ClangASTType::GetTypeBitAlign () const
1786 {
1787     if (GetCompleteType ())
1788         return m_ast->getTypeAlign(GetQualType());
1789     return 0;
1790 }
1791
1792
1793 lldb::Encoding
1794 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
1930 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
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
2078 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
2247 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
2313 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
2382 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
2420 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
2497 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
2599 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
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
2711 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
2830 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
2857 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
2958 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
3442 BaseSpecifierIsEmpty (const CXXBaseSpecifier *b)
3443 {
3444     return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false;
3445 }
3446
3447 static uint32_t
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
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
3546 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
3810 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
4009 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
4048 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
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
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 *
4360 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 *
4369 ClangASTType::GetAsCXXRecordDecl () const
4370 {
4371     return GetCanonicalQualType()->getAsCXXRecordDecl();
4372 }
4373
4374 ObjCInterfaceDecl *
4375 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 *
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
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 *
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 *
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 *
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
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
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
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
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
5063 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 *
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 *
5192 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
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
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
5347 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
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
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
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
5513 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
5531 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
5543 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
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
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
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
6129 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
6141 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
6238 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
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
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
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
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
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