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

   1 //===-- ClangASTContext.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/Symbol/ClangASTContext.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 #include <mutex> // std::once
  15 #include <string>
  16 #include <vector>
  17
  18 // Other libraries and framework includes
  19
  20 // Clang headers like to use NDEBUG inside of them to enable/disable debug
  21 // related features using "#ifndef NDEBUG" preprocessor blocks to do one thing
  22 // or another. This is bad because it means that if clang was built in release
  23 // mode, it assumes that you are building in release mode which is not always
  24 // the case. You can end up with functions that are defined as empty in header
  25 // files when NDEBUG is not defined, and this can cause link errors with the
  26 // clang .a files that you have since you might be missing functions in the .a
  27 // file. So we have to define NDEBUG when including clang headers to avoid any
  28 // mismatches. This is covered by rdar://problem/8691220
  29
  30 #if !defined(NDEBUG) && !defined(LLVM_NDEBUG_OFF)
  31 #define LLDB_DEFINED_NDEBUG_FOR_CLANG
  32 #define NDEBUG
  33 // Need to include assert.h so it is as clang would expect it to be (disabled)
  34 #include <assert.h>
  35 #endif
  36
  37 #include "clang/AST/ASTContext.h"
  38 #include "clang/AST/ASTImporter.h"
  39 #include "clang/AST/Attr.h"
  40 #include "clang/AST/CXXInheritance.h"
  41 #include "clang/AST/DeclObjC.h"
  42 #include "clang/AST/DeclTemplate.h"
  43 #include "clang/AST/Mangle.h"
  44 #include "clang/AST/RecordLayout.h"
  45 #include "clang/AST/Type.h"
  46 #include "clang/AST/VTableBuilder.h"
  47 #include "clang/Basic/Builtins.h"
  48 #include "clang/Basic/Diagnostic.h"
  49 #include "clang/Basic/FileManager.h"
  50 #include "clang/Basic/FileSystemOptions.h"
  51 #include "clang/Basic/SourceManager.h"
  52 #include "clang/Basic/TargetInfo.h"
  53 #include "clang/Basic/TargetOptions.h"
  54 #include "clang/Frontend/FrontendOptions.h"
  55 #include "clang/Frontend/LangStandard.h"
  56
  57 #ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
  58 #undef NDEBUG
  59 #undef LLDB_DEFINED_NDEBUG_FOR_CLANG
  60 // Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
  61 #include <assert.h>
  62 #endif
  63
  64 #include "llvm/Support/Signals.h"
  65
  66 #include "lldb/Core/ArchSpec.h"
  67 #include "lldb/Core/Flags.h"
  68 #include "lldb/Core/Log.h"
  69 #include "lldb/Core/Module.h"
  70 #include "lldb/Core/PluginManager.h"
  71 #include "lldb/Core/RegularExpression.h"
  72 #include "lldb/Core/StreamFile.h"
  73 #include "lldb/Core/ThreadSafeDenseMap.h"
  74 #include "lldb/Core/UniqueCStringMap.h"
  75 #include "Plugins/ExpressionParser/Clang/ClangUserExpression.h"
  76 #include "Plugins/ExpressionParser/Clang/ClangFunctionCaller.h"
  77 #include "Plugins/ExpressionParser/Clang/ClangUtilityFunction.h"
  78 #include "lldb/Symbol/ClangASTContext.h"
  79 #include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
  80 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
  81 #include "lldb/Symbol/ObjectFile.h"
  82 #include "lldb/Symbol/SymbolFile.h"
  83 #include "lldb/Symbol/VerifyDecl.h"
  84 #include "lldb/Target/ExecutionContext.h"
  85 #include "lldb/Target/Language.h"
  86 #include "lldb/Target/ObjCLanguageRuntime.h"
  87 #include "lldb/Target/Process.h"
  88 #include "lldb/Target/Target.h"
  89
  90 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
  91
  92 #include <stdio.h>
  93
  94 #include <mutex>
  95
  96 using namespace lldb;
  97 using namespace lldb_private;
  98 using namespace llvm;
  99 using namespace clang;
 100
 101 namespace
 102 {
 103     static inline bool ClangASTContextSupportsLanguage (lldb::LanguageType language)
 104     {
 105         return language == eLanguageTypeUnknown || // Clang is the default type system
 106                Language::LanguageIsC (language) ||
 107                Language::LanguageIsCPlusPlus (language) ||
 108                Language::LanguageIsObjC (language);
 109     }
 110 }
 111
 112 typedef lldb_private::ThreadSafeDenseMap<clang::ASTContext *, ClangASTContext*> ClangASTMap;
 113
 114 static ClangASTMap &
 115 GetASTMap()
 116 {
 117     static ClangASTMap *g_map_ptr = nullptr;
 118     static std::once_flag g_once_flag;
 119     std::call_once(g_once_flag,  []() {
 120         g_map_ptr = new ClangASTMap(); // leaked on purpose to avoid spins
 121     });
 122     return *g_map_ptr;
 123 }
 124
 125
 126 clang::AccessSpecifier
 127 ClangASTContext::ConvertAccessTypeToAccessSpecifier (AccessType access)
 128 {
 129     switch (access)
 130     {
 131     default:               break;
 132     case eAccessNone:      return AS_none;
 133     case eAccessPublic:    return AS_public;
 134     case eAccessPrivate:   return AS_private;
 135     case eAccessProtected: return AS_protected;
 136     }
 137     return AS_none;
 138 }
 139
 140 static void
 141 ParseLangArgs (LangOptions &Opts, InputKind IK, const char* triple)
 142 {
 143     // FIXME: Cleanup per-file based stuff.
 144
 145     // Set some properties which depend solely on the input kind; it would be nice
 146     // to move these to the language standard, and have the driver resolve the
 147     // input kind + language standard.
 148     if (IK == IK_Asm) {
 149         Opts.AsmPreprocessor = 1;
 150     } else if (IK == IK_ObjC ||
 151                IK == IK_ObjCXX ||
 152                IK == IK_PreprocessedObjC ||
 153                IK == IK_PreprocessedObjCXX) {
 154         Opts.ObjC1 = Opts.ObjC2 = 1;
 155     }
 156
 157     LangStandard::Kind LangStd = LangStandard::lang_unspecified;
 158
 159     if (LangStd == LangStandard::lang_unspecified) {
 160         // Based on the base language, pick one.
 161         switch (IK) {
 162             case IK_None:
 163             case IK_AST:
 164             case IK_LLVM_IR:
 165                 assert (!"Invalid input kind!");
 166             case IK_OpenCL:
 167                 LangStd = LangStandard::lang_opencl;
 168                 break;
 169             case IK_CUDA:
 170             case IK_PreprocessedCuda:
 171                 LangStd = LangStandard::lang_cuda;
 172                 break;
 173             case IK_Asm:
 174             case IK_C:
 175             case IK_PreprocessedC:
 176             case IK_ObjC:
 177             case IK_PreprocessedObjC:
 178                 LangStd = LangStandard::lang_gnu99;
 179                 break;
 180             case IK_CXX:
 181             case IK_PreprocessedCXX:
 182             case IK_ObjCXX:
 183             case IK_PreprocessedObjCXX:
 184                 LangStd = LangStandard::lang_gnucxx98;
 185                 break;
 186         }
 187     }
 188
 189     const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
 190     Opts.LineComment = Std.hasLineComments();
 191     Opts.C99 = Std.isC99();
 192     Opts.CPlusPlus = Std.isCPlusPlus();
 193     Opts.CPlusPlus11 = Std.isCPlusPlus11();
 194     Opts.Digraphs = Std.hasDigraphs();
 195     Opts.GNUMode = Std.isGNUMode();
 196     Opts.GNUInline = !Std.isC99();
 197     Opts.HexFloats = Std.hasHexFloats();
 198     Opts.ImplicitInt = Std.hasImplicitInt();
 199
 200     Opts.WChar = true;
 201
 202     // OpenCL has some additional defaults.
 203     if (LangStd == LangStandard::lang_opencl) {
 204         Opts.OpenCL = 1;
 205         Opts.AltiVec = 1;
 206         Opts.CXXOperatorNames = 1;
 207         Opts.LaxVectorConversions = 1;
 208     }
 209
 210     // OpenCL and C++ both have bool, true, false keywords.
 211     Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
 212
 213 //    if (Opts.CPlusPlus)
 214 //        Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names);
 215 //
 216 //    if (Args.hasArg(OPT_fobjc_gc_only))
 217 //        Opts.setGCMode(LangOptions::GCOnly);
 218 //    else if (Args.hasArg(OPT_fobjc_gc))
 219 //        Opts.setGCMode(LangOptions::HybridGC);
 220 //
 221 //    if (Args.hasArg(OPT_print_ivar_layout))
 222 //        Opts.ObjCGCBitmapPrint = 1;
 223 //
 224 //    if (Args.hasArg(OPT_faltivec))
 225 //        Opts.AltiVec = 1;
 226 //
 227 //    if (Args.hasArg(OPT_pthread))
 228 //        Opts.POSIXThreads = 1;
 229 //
 230 //    llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility,
 231 //                                          "default");
 232 //    if (Vis == "default")
 233         Opts.setValueVisibilityMode(DefaultVisibility);
 234 //    else if (Vis == "hidden")
 235 //        Opts.setVisibilityMode(LangOptions::Hidden);
 236 //    else if (Vis == "protected")
 237 //        Opts.setVisibilityMode(LangOptions::Protected);
 238 //    else
 239 //        Diags.Report(diag::err_drv_invalid_value)
 240 //        << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
 241
 242 //    Opts.OverflowChecking = Args.hasArg(OPT_ftrapv);
 243
 244     // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
 245     // is specified, or -std is set to a conforming mode.
 246     Opts.Trigraphs = !Opts.GNUMode;
 247 //    if (Args.hasArg(OPT_trigraphs))
 248 //        Opts.Trigraphs = 1;
 249 //
 250 //    Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
 251 //                                     OPT_fno_dollars_in_identifiers,
 252 //                                     !Opts.AsmPreprocessor);
 253 //    Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
 254 //    Opts.Microsoft = Args.hasArg(OPT_fms_extensions);
 255 //    Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
 256 //    if (Args.hasArg(OPT_fno_lax_vector_conversions))
 257 //        Opts.LaxVectorConversions = 0;
 258 //    Opts.Exceptions = Args.hasArg(OPT_fexceptions);
 259 //    Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
 260 //    Opts.Blocks = Args.hasArg(OPT_fblocks);
 261       Opts.CharIsSigned = ArchSpec(triple).CharIsSignedByDefault();
 262 //    Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
 263 //    Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
 264 //    Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
 265 //    Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
 266 //    Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
 267 //    Opts.AccessControl = Args.hasArg(OPT_faccess_control);
 268 //    Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
 269 //    Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno);
 270 //    Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99,
 271 //                                                 Diags);
 272 //    Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
 273 //    Opts.ObjCConstantStringClass = getLastArgValue(Args,
 274 //                                                   OPT_fconstant_string_class);
 275 //    Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi);
 276 //    Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
 277 //    Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
 278 //    Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
 279 //    Opts.Static = Args.hasArg(OPT_static_define);
 280     Opts.OptimizeSize = 0;
 281
 282     // FIXME: Eliminate this dependency.
 283 //    unsigned Opt =
 284 //    Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
 285 //    Opts.Optimize = Opt != 0;
 286     unsigned Opt = 0;
 287
 288     // This is the __NO_INLINE__ define, which just depends on things like the
 289     // optimization level and -fno-inline, not actually whether the backend has
 290     // inlining enabled.
 291     //
 292     // FIXME: This is affected by other options (-fno-inline).
 293     Opts.NoInlineDefine = !Opt;
 294
 295 //    unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
 296 //    switch (SSP) {
 297 //        default:
 298 //            Diags.Report(diag::err_drv_invalid_value)
 299 //            << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
 300 //            break;
 301 //        case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break;
 302 //        case 1: Opts.setStackProtectorMode(LangOptions::SSPOn);  break;
 303 //        case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break;
 304 //    }
 305 }
 306
 307
 308 ClangASTContext::ClangASTContext (const char *target_triple) :
 309     TypeSystem (TypeSystem::eKindClang),
 310     m_target_triple (),
 311     m_ast_ap (),
 312     m_language_options_ap (),
 313     m_source_manager_ap (),
 314     m_diagnostics_engine_ap (),
 315     m_target_options_rp (),
 316     m_target_info_ap (),
 317     m_identifier_table_ap (),
 318     m_selector_table_ap (),
 319     m_builtins_ap (),
 320     m_callback_tag_decl (nullptr),
 321     m_callback_objc_decl (nullptr),
 322     m_callback_baton (nullptr),
 323     m_pointer_byte_size (0),
 324     m_ast_owned (false)
 325 {
 326     if (target_triple && target_triple[0])
 327         SetTargetTriple (target_triple);
 328 }
 329
 330 //----------------------------------------------------------------------
 331 // Destructor
 332 //----------------------------------------------------------------------
 333 ClangASTContext::~ClangASTContext()
 334 {
 335     if (m_ast_ap.get())
 336     {
 337         GetASTMap().Erase(m_ast_ap.get());
 338         if (!m_ast_owned)
 339             m_ast_ap.release();
 340     }
 341
 342     m_builtins_ap.reset();
 343     m_selector_table_ap.reset();
 344     m_identifier_table_ap.reset();
 345     m_target_info_ap.reset();
 346     m_target_options_rp.reset();
 347     m_diagnostics_engine_ap.reset();
 348     m_source_manager_ap.reset();
 349     m_language_options_ap.reset();
 350     m_ast_ap.reset();
 351 }
 352
 353 ConstString
 354 ClangASTContext::GetPluginNameStatic()
 355 {
 356     return ConstString("clang");
 357 }
 358
 359 ConstString
 360 ClangASTContext::GetPluginName()
 361 {
 362     return ClangASTContext::GetPluginNameStatic();
 363 }
 364
 365 uint32_t
 366 ClangASTContext::GetPluginVersion()
 367 {
 368     return 1;
 369 }
 370
 371 lldb::TypeSystemSP
 372 ClangASTContext::CreateInstance (lldb::LanguageType language,
 373                                  lldb_private::Module *module,
 374                                  Target *target)
 375 {
 376     if (ClangASTContextSupportsLanguage(language))
 377     {
 378         ArchSpec arch;
 379         if (module)
 380             arch = module->GetArchitecture();
 381         else if (target)
 382             arch = target->GetArchitecture();
 383
 384         if (arch.IsValid())
 385         {
 386             ArchSpec fixed_arch = arch;
 387             // LLVM wants this to be set to iOS or MacOSX; if we're working on
 388             // a bare-boards type image, change the triple for llvm's benefit.
 389             if (fixed_arch.GetTriple().getVendor() == llvm::Triple::Apple &&
 390                 fixed_arch.GetTriple().getOS() == llvm::Triple::UnknownOS)
 391             {
 392                 if (fixed_arch.GetTriple().getArch() == llvm::Triple::arm ||
 393                     fixed_arch.GetTriple().getArch() == llvm::Triple::aarch64 ||
 394                     fixed_arch.GetTriple().getArch() == llvm::Triple::thumb)
 395                 {
 396                     fixed_arch.GetTriple().setOS(llvm::Triple::IOS);
 397                 }
 398                 else
 399                 {
 400                     fixed_arch.GetTriple().setOS(llvm::Triple::MacOSX);
 401                 }
 402             }
 403
 404             if (module)
 405             {
 406                 std::shared_ptr<ClangASTContext> ast_sp(new ClangASTContext);
 407                 if (ast_sp)
 408                 {
 409                     ast_sp->SetArchitecture (fixed_arch);
 410                 }
 411                 return ast_sp;
 412             }
 413             else if (target && target->IsValid())
 414             {
 415                 std::shared_ptr<ClangASTContextForExpressions> ast_sp(new ClangASTContextForExpressions(*target));
 416                 if (ast_sp)
 417                 {
 418                     ast_sp->SetArchitecture(fixed_arch);
 419                     ast_sp->m_scratch_ast_source_ap.reset (new ClangASTSource(target->shared_from_this()));
 420                     ast_sp->m_scratch_ast_source_ap->InstallASTContext(ast_sp->getASTContext());
 421                     llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> proxy_ast_source(ast_sp->m_scratch_ast_source_ap->CreateProxy());
 422                     ast_sp->SetExternalSource(proxy_ast_source);
 423                     return ast_sp;
 424                 }
 425             }
 426         }
 427     }
 428     return lldb::TypeSystemSP();
 429 }
 430
 431 void
 432 ClangASTContext::EnumerateSupportedLanguages(std::set<lldb::LanguageType> &languages_for_types, std::set<lldb::LanguageType> &languages_for_expressions)
 433 {
 434     static std::vector<lldb::LanguageType> s_supported_languages_for_types({
 435         lldb::eLanguageTypeC89,
 436         lldb::eLanguageTypeC,
 437         lldb::eLanguageTypeC11,
 438         lldb::eLanguageTypeC_plus_plus,
 439         lldb::eLanguageTypeC99,
 440         lldb::eLanguageTypeObjC,
 441         lldb::eLanguageTypeObjC_plus_plus,
 442         lldb::eLanguageTypeC_plus_plus_03,
 443         lldb::eLanguageTypeC_plus_plus_11,
 444         lldb::eLanguageTypeC11,
 445         lldb::eLanguageTypeC_plus_plus_14});
 446
 447     static std::vector<lldb::LanguageType> s_supported_languages_for_expressions({
 448         lldb::eLanguageTypeC_plus_plus,
 449         lldb::eLanguageTypeObjC_plus_plus,
 450         lldb::eLanguageTypeC_plus_plus_03,
 451         lldb::eLanguageTypeC_plus_plus_11,
 452         lldb::eLanguageTypeC_plus_plus_14});
 453
 454     languages_for_types.insert(s_supported_languages_for_types.begin(), s_supported_languages_for_types.end());
 455     languages_for_expressions.insert(s_supported_languages_for_expressions.begin(), s_supported_languages_for_expressions.end());
 456 }
 457
 458
 459 void
 460 ClangASTContext::Initialize()
 461 {
 462     PluginManager::RegisterPlugin (GetPluginNameStatic(),
 463                                    "clang base AST context plug-in",
 464                                    CreateInstance,
 465                                    EnumerateSupportedLanguages);
 466 }
 467
 468 void
 469 ClangASTContext::Terminate()
 470 {
 471     PluginManager::UnregisterPlugin (CreateInstance);
 472 }
 473
 474
 475 void
 476 ClangASTContext::Clear()
 477 {
 478     m_ast_ap.reset();
 479     m_language_options_ap.reset();
 480     m_source_manager_ap.reset();
 481     m_diagnostics_engine_ap.reset();
 482     m_target_options_rp.reset();
 483     m_target_info_ap.reset();
 484     m_identifier_table_ap.reset();
 485     m_selector_table_ap.reset();
 486     m_builtins_ap.reset();
 487     m_pointer_byte_size = 0;
 488 }
 489
 490 const char *
 491 ClangASTContext::GetTargetTriple ()
 492 {
 493     return m_target_triple.c_str();
 494 }
 495
 496 void
 497 ClangASTContext::SetTargetTriple (const char *target_triple)
 498 {
 499     Clear();
 500     m_target_triple.assign(target_triple);
 501 }
 502
 503 void
 504 ClangASTContext::SetArchitecture (const ArchSpec &arch)
 505 {
 506     SetTargetTriple(arch.GetTriple().str().c_str());
 507 }
 508
 509 bool
 510 ClangASTContext::HasExternalSource ()
 511 {
 512     ASTContext *ast = getASTContext();
 513     if (ast)
 514         return ast->getExternalSource () != nullptr;
 515     return false;
 516 }
 517
 518 void
 519 ClangASTContext::SetExternalSource (llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_ap)
 520 {
 521     ASTContext *ast = getASTContext();
 522     if (ast)
 523     {
 524         ast->setExternalSource (ast_source_ap);
 525         ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true);
 526         //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true);
 527     }
 528 }
 529
 530 void
 531 ClangASTContext::RemoveExternalSource ()
 532 {
 533     ASTContext *ast = getASTContext();
 534
 535     if (ast)
 536     {
 537         llvm::IntrusiveRefCntPtr<ExternalASTSource> empty_ast_source_ap;
 538         ast->setExternalSource (empty_ast_source_ap);
 539         ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false);
 540         //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false);
 541     }
 542 }
 543
 544 void
 545 ClangASTContext::setASTContext(clang::ASTContext *ast_ctx)
 546 {
 547     if (!m_ast_owned) {
 548         m_ast_ap.release();
 549     }
 550     m_ast_owned = false;
 551     m_ast_ap.reset(ast_ctx);
 552     GetASTMap().Insert(ast_ctx, this);
 553 }
 554
 555 ASTContext *
 556 ClangASTContext::getASTContext()
 557 {
 558     if (m_ast_ap.get() == nullptr)
 559     {
 560         m_ast_owned = true;
 561         m_ast_ap.reset(new ASTContext (*getLanguageOptions(),
 562                                        *getSourceManager(),
 563                                        *getIdentifierTable(),
 564                                        *getSelectorTable(),
 565                                        *getBuiltinContext()));
 566
 567         m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false);
 568
 569         // This can be NULL if we don't know anything about the architecture or if the
 570         // target for an architecture isn't enabled in the llvm/clang that we built
 571         TargetInfo *target_info = getTargetInfo();
 572         if (target_info)
 573             m_ast_ap->InitBuiltinTypes(*target_info);
 574
 575         if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton)
 576         {
 577             m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage();
 578             //m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage();
 579         }
 580
 581         GetASTMap().Insert(m_ast_ap.get(), this);
 582
 583         llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_ap (new ClangExternalASTSourceCallbacks (ClangASTContext::CompleteTagDecl,
 584                                                                                                                ClangASTContext::CompleteObjCInterfaceDecl,
 585                                                                                                                nullptr,
 586                                                                                                                ClangASTContext::LayoutRecordType,
 587                                                                                                                this));
 588         SetExternalSource (ast_source_ap);
 589     }
 590     return m_ast_ap.get();
 591 }
 592
 593 ClangASTContext*
 594 ClangASTContext::GetASTContext (clang::ASTContext* ast)
 595 {
 596     ClangASTContext *clang_ast = GetASTMap().Lookup(ast);
 597     return clang_ast;
 598 }
 599
 600 Builtin::Context *
 601 ClangASTContext::getBuiltinContext()
 602 {
 603     if (m_builtins_ap.get() == nullptr)
 604         m_builtins_ap.reset (new Builtin::Context());
 605     return m_builtins_ap.get();
 606 }
 607
 608 IdentifierTable *
 609 ClangASTContext::getIdentifierTable()
 610 {
 611     if (m_identifier_table_ap.get() == nullptr)
 612         m_identifier_table_ap.reset(new IdentifierTable (*ClangASTContext::getLanguageOptions(), nullptr));
 613     return m_identifier_table_ap.get();
 614 }
 615
 616 LangOptions *
 617 ClangASTContext::getLanguageOptions()
 618 {
 619     if (m_language_options_ap.get() == nullptr)
 620     {
 621         m_language_options_ap.reset(new LangOptions());
 622         ParseLangArgs(*m_language_options_ap, IK_ObjCXX, GetTargetTriple());
 623 //        InitializeLangOptions(*m_language_options_ap, IK_ObjCXX);
 624     }
 625     return m_language_options_ap.get();
 626 }
 627
 628 SelectorTable *
 629 ClangASTContext::getSelectorTable()
 630 {
 631     if (m_selector_table_ap.get() == nullptr)
 632         m_selector_table_ap.reset (new SelectorTable());
 633     return m_selector_table_ap.get();
 634 }
 635
 636 clang::FileManager *
 637 ClangASTContext::getFileManager()
 638 {
 639     if (m_file_manager_ap.get() == nullptr)
 640     {
 641         clang::FileSystemOptions file_system_options;
 642         m_file_manager_ap.reset(new clang::FileManager(file_system_options));
 643     }
 644     return m_file_manager_ap.get();
 645 }
 646
 647 clang::SourceManager *
 648 ClangASTContext::getSourceManager()
 649 {
 650     if (m_source_manager_ap.get() == nullptr)
 651         m_source_manager_ap.reset(new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager()));
 652     return m_source_manager_ap.get();
 653 }
 654
 655 clang::DiagnosticsEngine *
 656 ClangASTContext::getDiagnosticsEngine()
 657 {
 658     if (m_diagnostics_engine_ap.get() == nullptr)
 659     {
 660         llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs());
 661         m_diagnostics_engine_ap.reset(new DiagnosticsEngine(diag_id_sp, new DiagnosticOptions()));
 662     }
 663     return m_diagnostics_engine_ap.get();
 664 }
 665
 666 clang::MangleContext *
 667 ClangASTContext::getMangleContext()
 668 {
 669     if (m_mangle_ctx_ap.get() == nullptr)
 670         m_mangle_ctx_ap.reset (getASTContext()->createMangleContext());
 671     return m_mangle_ctx_ap.get();
 672 }
 673
 674 class NullDiagnosticConsumer : public DiagnosticConsumer
 675 {
 676 public:
 677     NullDiagnosticConsumer ()
 678     {
 679         m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS);
 680     }
 681
 682     void HandleDiagnostic (DiagnosticsEngine::Level DiagLevel, const Diagnostic &info)
 683     {
 684         if (m_log)
 685         {
 686             llvm::SmallVector<char, 32> diag_str(10);
 687             info.FormatDiagnostic(diag_str);
 688             diag_str.push_back('\0');
 689             m_log->Printf("Compiler diagnostic: %s\n", diag_str.data());
 690         }
 691     }
 692
 693     DiagnosticConsumer *clone (DiagnosticsEngine &Diags) const
 694     {
 695         return new NullDiagnosticConsumer ();
 696     }
 697 private:
 698     Log * m_log;
 699 };
 700
 701 DiagnosticConsumer *
 702 ClangASTContext::getDiagnosticConsumer()
 703 {
 704     if (m_diagnostic_consumer_ap.get() == nullptr)
 705         m_diagnostic_consumer_ap.reset(new NullDiagnosticConsumer);
 706
 707     return m_diagnostic_consumer_ap.get();
 708 }
 709
 710 std::shared_ptr<TargetOptions> &
 711 ClangASTContext::getTargetOptions() {
 712     if (m_target_options_rp.get() == nullptr && !m_target_triple.empty())
 713     {
 714         m_target_options_rp = std::make_shared<TargetOptions>();
 715         if (m_target_options_rp.get() != nullptr)
 716             m_target_options_rp->Triple = m_target_triple;
 717     }
 718     return m_target_options_rp;
 719 }
 720
 721
 722 TargetInfo *
 723 ClangASTContext::getTargetInfo()
 724 {
 725     // target_triple should be something like "x86_64-apple-macosx"
 726     if (m_target_info_ap.get() == nullptr && !m_target_triple.empty())
 727         m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), getTargetOptions()));
 728     return m_target_info_ap.get();
 729 }
 730
 731 #pragma mark Basic Types
 732
 733 static inline bool
 734 QualTypeMatchesBitSize(const uint64_t bit_size, ASTContext *ast, QualType qual_type)
 735 {
 736     uint64_t qual_type_bit_size = ast->getTypeSize(qual_type);
 737     if (qual_type_bit_size == bit_size)
 738         return true;
 739     return false;
 740 }
 741
 742 CompilerType
 743 ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, size_t bit_size)
 744 {
 745     return ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (getASTContext(), encoding, bit_size);
 746 }
 747
 748 CompilerType
 749 ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast, Encoding encoding, uint32_t bit_size)
 750 {
 751     if (!ast)
 752         return CompilerType();
 753     switch (encoding)
 754     {
 755     case eEncodingInvalid:
 756         if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
 757             return CompilerType (ast, ast->VoidPtrTy);
 758         break;
 759
 760     case eEncodingUint:
 761         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
 762             return CompilerType (ast, ast->UnsignedCharTy);
 763         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
 764             return CompilerType (ast, ast->UnsignedShortTy);
 765         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
 766             return CompilerType (ast, ast->UnsignedIntTy);
 767         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
 768             return CompilerType (ast, ast->UnsignedLongTy);
 769         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
 770             return CompilerType (ast, ast->UnsignedLongLongTy);
 771         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
 772             return CompilerType (ast, ast->UnsignedInt128Ty);
 773         break;
 774
 775     case eEncodingSint:
 776         if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
 777             return CompilerType (ast, ast->CharTy);
 778         if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
 779             return CompilerType (ast, ast->ShortTy);
 780         if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
 781             return CompilerType (ast, ast->IntTy);
 782         if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
 783             return CompilerType (ast, ast->LongTy);
 784         if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
 785             return CompilerType (ast, ast->LongLongTy);
 786         if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
 787             return CompilerType (ast, ast->Int128Ty);
 788         break;
 789
 790     case eEncodingIEEE754:
 791         if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
 792             return CompilerType (ast, ast->FloatTy);
 793         if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
 794             return CompilerType (ast, ast->DoubleTy);
 795         if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
 796             return CompilerType (ast, ast->LongDoubleTy);
 797         if (QualTypeMatchesBitSize (bit_size, ast, ast->HalfTy))
 798             return CompilerType (ast, ast->HalfTy);
 799         break;
 800
 801     case eEncodingVector:
 802         // Sanity check that bit_size is a multiple of 8's.
 803         if (bit_size && !(bit_size & 0x7u))
 804             return CompilerType (ast, ast->getExtVectorType (ast->UnsignedCharTy, bit_size/8));
 805         break;
 806     }
 807
 808     return CompilerType();
 809 }
 810
 811
 812
 813 lldb::BasicType
 814 ClangASTContext::GetBasicTypeEnumeration (const ConstString &name)
 815 {
 816     if (name)
 817     {
 818         typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
 819         static TypeNameToBasicTypeMap g_type_map;
 820         static std::once_flag g_once_flag;
 821         std::call_once(g_once_flag, [](){
 822             // "void"
 823             g_type_map.Append(ConstString("void").GetCString(), eBasicTypeVoid);
 824
 825             // "char"
 826             g_type_map.Append(ConstString("char").GetCString(), eBasicTypeChar);
 827             g_type_map.Append(ConstString("signed char").GetCString(), eBasicTypeSignedChar);
 828             g_type_map.Append(ConstString("unsigned char").GetCString(), eBasicTypeUnsignedChar);
 829             g_type_map.Append(ConstString("wchar_t").GetCString(), eBasicTypeWChar);
 830             g_type_map.Append(ConstString("signed wchar_t").GetCString(), eBasicTypeSignedWChar);
 831             g_type_map.Append(ConstString("unsigned wchar_t").GetCString(), eBasicTypeUnsignedWChar);
 832             // "short"
 833             g_type_map.Append(ConstString("short").GetCString(), eBasicTypeShort);
 834             g_type_map.Append(ConstString("short int").GetCString(), eBasicTypeShort);
 835             g_type_map.Append(ConstString("unsigned short").GetCString(), eBasicTypeUnsignedShort);
 836             g_type_map.Append(ConstString("unsigned short int").GetCString(), eBasicTypeUnsignedShort);
 837
 838             // "int"
 839             g_type_map.Append(ConstString("int").GetCString(), eBasicTypeInt);
 840             g_type_map.Append(ConstString("signed int").GetCString(), eBasicTypeInt);
 841             g_type_map.Append(ConstString("unsigned int").GetCString(), eBasicTypeUnsignedInt);
 842             g_type_map.Append(ConstString("unsigned").GetCString(), eBasicTypeUnsignedInt);
 843
 844             // "long"
 845             g_type_map.Append(ConstString("long").GetCString(), eBasicTypeLong);
 846             g_type_map.Append(ConstString("long int").GetCString(), eBasicTypeLong);
 847             g_type_map.Append(ConstString("unsigned long").GetCString(), eBasicTypeUnsignedLong);
 848             g_type_map.Append(ConstString("unsigned long int").GetCString(), eBasicTypeUnsignedLong);
 849
 850             // "long long"
 851             g_type_map.Append(ConstString("long long").GetCString(), eBasicTypeLongLong);
 852             g_type_map.Append(ConstString("long long int").GetCString(), eBasicTypeLongLong);
 853             g_type_map.Append(ConstString("unsigned long long").GetCString(), eBasicTypeUnsignedLongLong);
 854             g_type_map.Append(ConstString("unsigned long long int").GetCString(), eBasicTypeUnsignedLongLong);
 855
 856             // "int128"
 857             g_type_map.Append(ConstString("__int128_t").GetCString(), eBasicTypeInt128);
 858             g_type_map.Append(ConstString("__uint128_t").GetCString(), eBasicTypeUnsignedInt128);
 859
 860             // Miscellaneous
 861             g_type_map.Append(ConstString("bool").GetCString(), eBasicTypeBool);
 862             g_type_map.Append(ConstString("float").GetCString(), eBasicTypeFloat);
 863             g_type_map.Append(ConstString("double").GetCString(), eBasicTypeDouble);
 864             g_type_map.Append(ConstString("long double").GetCString(), eBasicTypeLongDouble);
 865             g_type_map.Append(ConstString("id").GetCString(), eBasicTypeObjCID);
 866             g_type_map.Append(ConstString("SEL").GetCString(), eBasicTypeObjCSel);
 867             g_type_map.Append(ConstString("nullptr").GetCString(), eBasicTypeNullPtr);
 868             g_type_map.Sort();
 869         });
 870
 871         return g_type_map.Find(name.GetCString(), eBasicTypeInvalid);
 872     }
 873     return eBasicTypeInvalid;
 874 }
 875
 876 CompilerType
 877 ClangASTContext::GetBasicType (ASTContext *ast, const ConstString &name)
 878 {
 879     if (ast)
 880     {
 881         lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration (name);
 882         return ClangASTContext::GetBasicType (ast, basic_type);
 883     }
 884     return CompilerType();
 885 }
 886
 887 uint32_t
 888 ClangASTContext::GetPointerByteSize ()
 889 {
 890     if (m_pointer_byte_size == 0)
 891         m_pointer_byte_size = GetBasicType(lldb::eBasicTypeVoid).GetPointerType().GetByteSize(nullptr);
 892     return m_pointer_byte_size;
 893 }
 894
 895 CompilerType
 896 ClangASTContext::GetBasicType (lldb::BasicType basic_type)
 897 {
 898     return GetBasicType (getASTContext(), basic_type);
 899 }
 900
 901 CompilerType
 902 ClangASTContext::GetBasicType (ASTContext *ast, lldb::BasicType basic_type)
 903 {
 904     if (ast)
 905     {
 906         lldb::opaque_compiler_type_t clang_type = nullptr;
 907
 908         switch (basic_type)
 909         {
 910             case eBasicTypeInvalid:
 911             case eBasicTypeOther:
 912                 break;
 913             case eBasicTypeVoid:
 914                 clang_type = ast->VoidTy.getAsOpaquePtr();
 915                 break;
 916             case eBasicTypeChar:
 917                 clang_type = ast->CharTy.getAsOpaquePtr();
 918                 break;
 919             case eBasicTypeSignedChar:
 920                 clang_type = ast->SignedCharTy.getAsOpaquePtr();
 921                 break;
 922             case eBasicTypeUnsignedChar:
 923                 clang_type = ast->UnsignedCharTy.getAsOpaquePtr();
 924                 break;
 925             case eBasicTypeWChar:
 926                 clang_type = ast->getWCharType().getAsOpaquePtr();
 927                 break;
 928             case eBasicTypeSignedWChar:
 929                 clang_type = ast->getSignedWCharType().getAsOpaquePtr();
 930                 break;
 931             case eBasicTypeUnsignedWChar:
 932                 clang_type = ast->getUnsignedWCharType().getAsOpaquePtr();
 933                 break;
 934             case eBasicTypeChar16:
 935                 clang_type = ast->Char16Ty.getAsOpaquePtr();
 936                 break;
 937             case eBasicTypeChar32:
 938                 clang_type = ast->Char32Ty.getAsOpaquePtr();
 939                 break;
 940             case eBasicTypeShort:
 941                 clang_type = ast->ShortTy.getAsOpaquePtr();
 942                 break;
 943             case eBasicTypeUnsignedShort:
 944                 clang_type = ast->UnsignedShortTy.getAsOpaquePtr();
 945                 break;
 946             case eBasicTypeInt:
 947                 clang_type = ast->IntTy.getAsOpaquePtr();
 948                 break;
 949             case eBasicTypeUnsignedInt:
 950                 clang_type = ast->UnsignedIntTy.getAsOpaquePtr();
 951                 break;
 952             case eBasicTypeLong:
 953                 clang_type = ast->LongTy.getAsOpaquePtr();
 954                 break;
 955             case eBasicTypeUnsignedLong:
 956                 clang_type = ast->UnsignedLongTy.getAsOpaquePtr();
 957                 break;
 958             case eBasicTypeLongLong:
 959                 clang_type = ast->LongLongTy.getAsOpaquePtr();
 960                 break;
 961             case eBasicTypeUnsignedLongLong:
 962                 clang_type = ast->UnsignedLongLongTy.getAsOpaquePtr();
 963                 break;
 964             case eBasicTypeInt128:
 965                 clang_type = ast->Int128Ty.getAsOpaquePtr();
 966                 break;
 967             case eBasicTypeUnsignedInt128:
 968                 clang_type = ast->UnsignedInt128Ty.getAsOpaquePtr();
 969                 break;
 970             case eBasicTypeBool:
 971                 clang_type = ast->BoolTy.getAsOpaquePtr();
 972                 break;
 973             case eBasicTypeHalf:
 974                 clang_type = ast->HalfTy.getAsOpaquePtr();
 975                 break;
 976             case eBasicTypeFloat:
 977                 clang_type = ast->FloatTy.getAsOpaquePtr();
 978                 break;
 979             case eBasicTypeDouble:
 980                 clang_type = ast->DoubleTy.getAsOpaquePtr();
 981                 break;
 982             case eBasicTypeLongDouble:
 983                 clang_type = ast->LongDoubleTy.getAsOpaquePtr();
 984                 break;
 985             case eBasicTypeFloatComplex:
 986                 clang_type = ast->FloatComplexTy.getAsOpaquePtr();
 987                 break;
 988             case eBasicTypeDoubleComplex:
 989                 clang_type = ast->DoubleComplexTy.getAsOpaquePtr();
 990                 break;
 991             case eBasicTypeLongDoubleComplex:
 992                 clang_type = ast->LongDoubleComplexTy.getAsOpaquePtr();
 993                 break;
 994             case eBasicTypeObjCID:
 995                 clang_type = ast->getObjCIdType().getAsOpaquePtr();
 996                 break;
 997             case eBasicTypeObjCClass:
 998                 clang_type = ast->getObjCClassType().getAsOpaquePtr();
 999                 break;
1000             case eBasicTypeObjCSel:
1001                 clang_type = ast->getObjCSelType().getAsOpaquePtr();
1002                 break;
1003             case eBasicTypeNullPtr:
1004                 clang_type = ast->NullPtrTy.getAsOpaquePtr();
1005                 break;
1006         }
1007
1008         if (clang_type)
1009             return CompilerType (GetASTContext(ast), clang_type);
1010     }
1011     return CompilerType();
1012 }
1013
1014
1015 CompilerType
1016 ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size)
1017 {
1018     ASTContext *ast = getASTContext();
1019
1020 #define streq(a,b) strcmp(a,b) == 0
1021     assert (ast != nullptr);
1022     if (ast)
1023     {
1024         switch (dw_ate)
1025         {
1026             default:
1027                 break;
1028
1029             case DW_ATE_address:
1030                 if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
1031                     return CompilerType (ast, ast->VoidPtrTy);
1032                 break;
1033
1034             case DW_ATE_boolean:
1035                 if (QualTypeMatchesBitSize (bit_size, ast, ast->BoolTy))
1036                     return CompilerType (ast, ast->BoolTy);
1037                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
1038                     return CompilerType (ast, ast->UnsignedCharTy);
1039                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
1040                     return CompilerType (ast, ast->UnsignedShortTy);
1041                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
1042                     return CompilerType (ast, ast->UnsignedIntTy);
1043                 break;
1044
1045             case DW_ATE_lo_user:
1046                 // This has been seen to mean DW_AT_complex_integer
1047                 if (type_name)
1048                 {
1049                     if (::strstr(type_name, "complex"))
1050                     {
1051                         CompilerType complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2);
1052                         return CompilerType (ast, ast->getComplexType (GetQualType(complex_int_clang_type)));
1053                     }
1054                 }
1055                 break;
1056
1057             case DW_ATE_complex_float:
1058                 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy))
1059                     return CompilerType (ast, ast->FloatComplexTy);
1060                 else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy))
1061                     return CompilerType (ast, ast->DoubleComplexTy);
1062                 else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy))
1063                     return CompilerType (ast, ast->LongDoubleComplexTy);
1064                 else
1065                 {
1066                     CompilerType complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2);
1067                     return CompilerType (ast, ast->getComplexType (GetQualType(complex_float_clang_type)));
1068                 }
1069                 break;
1070
1071             case DW_ATE_float:
1072                 if (streq(type_name, "float") && QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
1073                     return CompilerType (ast, ast->FloatTy);
1074                 if (streq(type_name, "double") && QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
1075                     return CompilerType (ast, ast->DoubleTy);
1076                 if (streq(type_name, "long double") && QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
1077                     return CompilerType (ast, ast->LongDoubleTy);
1078                 // Fall back to not requiring a name match
1079                 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
1080                     return CompilerType (ast, ast->FloatTy);
1081                 if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
1082                     return CompilerType (ast, ast->DoubleTy);
1083                 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
1084                     return CompilerType (ast, ast->LongDoubleTy);
1085                 if (QualTypeMatchesBitSize (bit_size, ast, ast->HalfTy))
1086                     return CompilerType (ast, ast->HalfTy);
1087                 break;
1088
1089             case DW_ATE_signed:
1090                 if (type_name)
1091                 {
1092                     if (streq(type_name, "wchar_t") &&
1093                         QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy) &&
1094                         (getTargetInfo() && TargetInfo::isTypeSigned (getTargetInfo()->getWCharType())))
1095                         return CompilerType (ast, ast->WCharTy);
1096                     if (streq(type_name, "void") &&
1097                         QualTypeMatchesBitSize (bit_size, ast, ast->VoidTy))
1098                         return CompilerType (ast, ast->VoidTy);
1099                     if (strstr(type_name, "long long") &&
1100                         QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
1101                         return CompilerType (ast, ast->LongLongTy);
1102                     if (strstr(type_name, "long") &&
1103                         QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
1104                         return CompilerType (ast, ast->LongTy);
1105                     if (strstr(type_name, "short") &&
1106                         QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
1107                         return CompilerType (ast, ast->ShortTy);
1108                     if (strstr(type_name, "char"))
1109                     {
1110                         if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
1111                             return CompilerType (ast, ast->CharTy);
1112                         if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
1113                             return CompilerType (ast, ast->SignedCharTy);
1114                     }
1115                     if (strstr(type_name, "int"))
1116                     {
1117                         if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
1118                             return CompilerType (ast, ast->IntTy);
1119                         if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
1120                             return CompilerType (ast, ast->Int128Ty);
1121                     }
1122                 }
1123                 // We weren't able to match up a type name, just search by size
1124                 if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
1125                     return CompilerType (ast, ast->CharTy);
1126                 if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
1127                     return CompilerType (ast, ast->ShortTy);
1128                 if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
1129                     return CompilerType (ast, ast->IntTy);
1130                 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
1131                     return CompilerType (ast, ast->LongTy);
1132                 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
1133                     return CompilerType (ast, ast->LongLongTy);
1134                 if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
1135                     return CompilerType (ast, ast->Int128Ty);
1136                 break;
1137
1138             case DW_ATE_signed_char:
1139                 if (ast->getLangOpts().CharIsSigned && type_name && streq(type_name, "char"))
1140                 {
1141                     if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
1142                         return CompilerType (ast, ast->CharTy);
1143                 }
1144                 if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
1145                     return CompilerType (ast, ast->SignedCharTy);
1146                 break;
1147
1148             case DW_ATE_unsigned:
1149                 if (type_name)
1150                 {
1151                     if (streq(type_name, "wchar_t"))
1152                     {
1153                         if (QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy))
1154                         {
1155                             if (!(getTargetInfo() && TargetInfo::isTypeSigned (getTargetInfo()->getWCharType())))
1156                                 return CompilerType (ast, ast->WCharTy);
1157                         }
1158                     }
1159                     if (strstr(type_name, "long long"))
1160                     {
1161                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
1162                             return CompilerType (ast, ast->UnsignedLongLongTy);
1163                     }
1164                     else if (strstr(type_name, "long"))
1165                     {
1166                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
1167                             return CompilerType (ast, ast->UnsignedLongTy);
1168                     }
1169                     else if (strstr(type_name, "short"))
1170                     {
1171                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
1172                             return CompilerType (ast, ast->UnsignedShortTy);
1173                     }
1174                     else if (strstr(type_name, "char"))
1175                     {
1176                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
1177                             return CompilerType (ast, ast->UnsignedCharTy);
1178                     }
1179                     else if (strstr(type_name, "int"))
1180                     {
1181                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
1182                             return CompilerType (ast, ast->UnsignedIntTy);
1183                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
1184                             return CompilerType (ast, ast->UnsignedInt128Ty);
1185                     }
1186                 }
1187                 // We weren't able to match up a type name, just search by size
1188                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
1189                     return CompilerType (ast, ast->UnsignedCharTy);
1190                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
1191                     return CompilerType (ast, ast->UnsignedShortTy);
1192                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
1193                     return CompilerType (ast, ast->UnsignedIntTy);
1194                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
1195                     return CompilerType (ast, ast->UnsignedLongTy);
1196                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
1197                     return CompilerType (ast, ast->UnsignedLongLongTy);
1198                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
1199                     return CompilerType (ast, ast->UnsignedInt128Ty);
1200                 break;
1201
1202             case DW_ATE_unsigned_char:
1203                 if (!ast->getLangOpts().CharIsSigned && type_name && streq(type_name, "char"))
1204                 {
1205                     if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
1206                         return CompilerType (ast, ast->CharTy);
1207                 }
1208                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
1209                     return CompilerType (ast, ast->UnsignedCharTy);
1210                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
1211                     return CompilerType (ast, ast->UnsignedShortTy);
1212                 break;
1213
1214             case DW_ATE_imaginary_float:
1215                 break;
1216
1217             case DW_ATE_UTF:
1218                 if (type_name)
1219                 {
1220                     if (streq(type_name, "char16_t"))
1221                     {
1222                         return CompilerType (ast, ast->Char16Ty);
1223                     }
1224                     else if (streq(type_name, "char32_t"))
1225                     {
1226                         return CompilerType (ast, ast->Char32Ty);
1227                     }
1228                 }
1229                 break;
1230         }
1231     }
1232     // This assert should fire for anything that we don't catch above so we know
1233     // to fix any issues we run into.
1234     if (type_name)
1235     {
1236         Host::SystemLog (Host::eSystemLogError, "error: need to add support for DW_TAG_base_type '%s' encoded with DW_ATE = 0x%x, bit_size = %u\n", type_name, dw_ate, bit_size);
1237     }
1238     else
1239     {
1240         Host::SystemLog (Host::eSystemLogError, "error: need to add support for DW_TAG_base_type encoded with DW_ATE = 0x%x, bit_size = %u\n", dw_ate, bit_size);
1241     }
1242     return CompilerType ();
1243 }
1244
1245 CompilerType
1246 ClangASTContext::GetUnknownAnyType(clang::ASTContext *ast)
1247 {
1248     if (ast)
1249         return CompilerType (ast, ast->UnknownAnyTy);
1250     return CompilerType();
1251 }
1252
1253 CompilerType
1254 ClangASTContext::GetCStringType (bool is_const)
1255 {
1256     ASTContext *ast = getASTContext();
1257     QualType char_type(ast->CharTy);
1258
1259     if (is_const)
1260         char_type.addConst();
1261
1262     return CompilerType (ast, ast->getPointerType(char_type));
1263 }
1264
1265 clang::DeclContext *
1266 ClangASTContext::GetTranslationUnitDecl (clang::ASTContext *ast)
1267 {
1268     return ast->getTranslationUnitDecl();
1269 }
1270
1271 clang::Decl *
1272 ClangASTContext::CopyDecl (ASTContext *dst_ast,
1273                            ASTContext *src_ast,
1274                            clang::Decl *source_decl)
1275 {
1276     FileSystemOptions file_system_options;
1277     FileManager file_manager (file_system_options);
1278     ASTImporter importer(*dst_ast, file_manager,
1279                          *src_ast, file_manager,
1280                          false);
1281
1282     return importer.Import(source_decl);
1283 }
1284
1285 bool
1286 ClangASTContext::AreTypesSame (CompilerType type1,
1287                                CompilerType type2,
1288                                bool ignore_qualifiers)
1289 {
1290     ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(type1.GetTypeSystem());
1291     if (!ast || ast != type2.GetTypeSystem())
1292         return false;
1293
1294     if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType())
1295         return true;
1296
1297     QualType type1_qual = GetQualType(type1);
1298     QualType type2_qual = GetQualType(type2);
1299
1300     if (ignore_qualifiers)
1301     {
1302         type1_qual = type1_qual.getUnqualifiedType();
1303         type2_qual = type2_qual.getUnqualifiedType();
1304     }
1305
1306     return ast->getASTContext()->hasSameType (type1_qual, type2_qual);
1307 }
1308
1309 CompilerType
1310 ClangASTContext::GetTypeForDecl (clang::NamedDecl *decl)
1311 {
1312     if (clang::ObjCInterfaceDecl *interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
1313         return GetTypeForDecl(interface_decl);
1314     if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
1315         return GetTypeForDecl(tag_decl);
1316     return CompilerType();
1317 }
1318
1319
1320 CompilerType
1321 ClangASTContext::GetTypeForDecl (TagDecl *decl)
1322 {
1323     // No need to call the getASTContext() accessor (which can create the AST
1324     // if it isn't created yet, because we can't have created a decl in this
1325     // AST if our AST didn't already exist...
1326     ASTContext *ast = &decl->getASTContext();
1327     if (ast)
1328         return CompilerType (ast, ast->getTagDeclType(decl));
1329     return CompilerType();
1330 }
1331
1332 CompilerType
1333 ClangASTContext::GetTypeForDecl (ObjCInterfaceDecl *decl)
1334 {
1335     // No need to call the getASTContext() accessor (which can create the AST
1336     // if it isn't created yet, because we can't have created a decl in this
1337     // AST if our AST didn't already exist...
1338     ASTContext *ast = &decl->getASTContext();
1339     if (ast)
1340         return CompilerType (ast, ast->getObjCInterfaceType(decl));
1341     return CompilerType();
1342 }
1343
1344 #pragma mark Structure, Unions, Classes
1345
1346 CompilerType
1347 ClangASTContext::CreateRecordType (DeclContext *decl_ctx,
1348                                    AccessType access_type,
1349                                    const char *name,
1350                                    int kind,
1351                                    LanguageType language,
1352                                    ClangASTMetadata *metadata)
1353 {
1354     ASTContext *ast = getASTContext();
1355     assert (ast != nullptr);
1356
1357     if (decl_ctx == nullptr)
1358         decl_ctx = ast->getTranslationUnitDecl();
1359
1360
1361     if (language == eLanguageTypeObjC || language == eLanguageTypeObjC_plus_plus)
1362     {
1363         bool isForwardDecl = true;
1364         bool isInternal = false;
1365         return CreateObjCClass (name, decl_ctx, isForwardDecl, isInternal, metadata);
1366     }
1367
1368     // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1369     // we will need to update this code. I was told to currently always use
1370     // the CXXRecordDecl class since we often don't know from debug information
1371     // if something is struct or a class, so we default to always use the more
1372     // complete definition just in case.
1373
1374     bool is_anonymous = (!name) || (!name[0]);
1375
1376     CXXRecordDecl *decl = CXXRecordDecl::Create (*ast,
1377                                                  (TagDecl::TagKind)kind,
1378                                                  decl_ctx,
1379                                                  SourceLocation(),
1380                                                  SourceLocation(),
1381                                                  is_anonymous ? nullptr : &ast->Idents.get(name));
1382
1383     if (is_anonymous)
1384         decl->setAnonymousStructOrUnion(true);
1385
1386     if (decl)
1387     {
1388         if (metadata)
1389             SetMetadata(ast, decl, *metadata);
1390
1391         if (access_type != eAccessNone)
1392             decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type));
1393
1394         if (decl_ctx)
1395             decl_ctx->addDecl (decl);
1396
1397         return CompilerType(ast, ast->getTagDeclType(decl));
1398     }
1399     return CompilerType();
1400 }
1401
1402 static TemplateParameterList *
1403 CreateTemplateParameterList (ASTContext *ast,
1404                              const ClangASTContext::TemplateParameterInfos &template_param_infos,
1405                              llvm::SmallVector<NamedDecl *, 8> &template_param_decls)
1406 {
1407     const bool parameter_pack = false;
1408     const bool is_typename = false;
1409     const unsigned depth = 0;
1410     const size_t num_template_params = template_param_infos.GetSize();
1411     for (size_t i=0; i<num_template_params; ++i)
1412     {
1413         const char *name = template_param_infos.names[i];
1414
1415         IdentifierInfo *identifier_info = nullptr;
1416         if (name && name[0])
1417             identifier_info = &ast->Idents.get(name);
1418         if (template_param_infos.args[i].getKind() == TemplateArgument::Integral)
1419         {
1420             template_param_decls.push_back (NonTypeTemplateParmDecl::Create (*ast,
1421                                                                              ast->getTranslationUnitDecl(), // Is this the right decl context?, SourceLocation StartLoc,
1422                                                                              SourceLocation(),
1423                                                                              SourceLocation(),
1424                                                                              depth,
1425                                                                              i,
1426                                                                              identifier_info,
1427                                                                              template_param_infos.args[i].getIntegralType(),
1428                                                                              parameter_pack,
1429                                                                              nullptr));
1430
1431         }
1432         else
1433         {
1434             template_param_decls.push_back (TemplateTypeParmDecl::Create (*ast,
1435                                                                           ast->getTranslationUnitDecl(), // Is this the right decl context?
1436                                                                           SourceLocation(),
1437                                                                           SourceLocation(),
1438                                                                           depth,
1439                                                                           i,
1440                                                                           identifier_info,
1441                                                                           is_typename,
1442                                                                           parameter_pack));
1443         }
1444     }
1445
1446     TemplateParameterList *template_param_list = TemplateParameterList::Create (*ast,
1447                                                                                 SourceLocation(),
1448                                                                                 SourceLocation(),
1449                                                                                 template_param_decls,
1450                                                                                 SourceLocation());
1451     return template_param_list;
1452 }
1453
1454 clang::FunctionTemplateDecl *
1455 ClangASTContext::CreateFunctionTemplateDecl (clang::DeclContext *decl_ctx,
1456                                              clang::FunctionDecl *func_decl,
1457                                              const char *name,
1458                                              const TemplateParameterInfos &template_param_infos)
1459 {
1460 //    /// \brief Create a function template node.
1461     ASTContext *ast = getASTContext();
1462
1463     llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1464
1465     TemplateParameterList *template_param_list = CreateTemplateParameterList (ast,
1466                                                                               template_param_infos,
1467                                                                               template_param_decls);
1468     FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create (*ast,
1469                                                                          decl_ctx,
1470                                                                          func_decl->getLocation(),
1471                                                                          func_decl->getDeclName(),
1472                                                                          template_param_list,
1473                                                                          func_decl);
1474
1475     for (size_t i=0, template_param_decl_count = template_param_decls.size();
1476          i < template_param_decl_count;
1477          ++i)
1478     {
1479         // TODO: verify which decl context we should put template_param_decls into..
1480         template_param_decls[i]->setDeclContext (func_decl);
1481     }
1482
1483     return func_tmpl_decl;
1484 }
1485
1486 void
1487 ClangASTContext::CreateFunctionTemplateSpecializationInfo (FunctionDecl *func_decl,
1488                                                            clang::FunctionTemplateDecl *func_tmpl_decl,
1489                                                            const TemplateParameterInfos &infos)
1490 {
1491     TemplateArgumentList template_args (TemplateArgumentList::OnStack,
1492                                         infos.args.data(),
1493                                         infos.args.size());
1494
1495     func_decl->setFunctionTemplateSpecialization (func_tmpl_decl,
1496                                                   &template_args,
1497                                                   nullptr);
1498 }
1499
1500
1501 ClassTemplateDecl *
1502 ClangASTContext::CreateClassTemplateDecl (DeclContext *decl_ctx,
1503                                           lldb::AccessType access_type,
1504                                           const char *class_name,
1505                                           int kind,
1506                                           const TemplateParameterInfos &template_param_infos)
1507 {
1508     ASTContext *ast = getASTContext();
1509
1510     ClassTemplateDecl *class_template_decl = nullptr;
1511     if (decl_ctx == nullptr)
1512         decl_ctx = ast->getTranslationUnitDecl();
1513
1514     IdentifierInfo &identifier_info = ast->Idents.get(class_name);
1515     DeclarationName decl_name (&identifier_info);
1516
1517     clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1518
1519     for (NamedDecl *decl : result)
1520     {
1521         class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl);
1522         if (class_template_decl)
1523             return class_template_decl;
1524     }
1525
1526     llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1527
1528     TemplateParameterList *template_param_list = CreateTemplateParameterList (ast,
1529                                                                               template_param_infos,
1530                                                                               template_param_decls);
1531
1532     CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create (*ast,
1533                                                               (TagDecl::TagKind)kind,
1534                                                               decl_ctx,  // What decl context do we use here? TU? The actual decl context?
1535                                                               SourceLocation(),
1536                                                               SourceLocation(),
1537                                                               &identifier_info);
1538
1539     for (size_t i=0, template_param_decl_count = template_param_decls.size();
1540          i < template_param_decl_count;
1541          ++i)
1542     {
1543         template_param_decls[i]->setDeclContext (template_cxx_decl);
1544     }
1545
1546     // With templated classes, we say that a class is templated with
1547     // specializations, but that the bare class has no functions.
1548     //template_cxx_decl->startDefinition();
1549     //template_cxx_decl->completeDefinition();
1550
1551     class_template_decl = ClassTemplateDecl::Create (*ast,
1552                                                      decl_ctx,  // What decl context do we use here? TU? The actual decl context?
1553                                                      SourceLocation(),
1554                                                      decl_name,
1555                                                      template_param_list,
1556                                                      template_cxx_decl,
1557                                                      nullptr);
1558
1559     if (class_template_decl)
1560     {
1561         if (access_type != eAccessNone)
1562             class_template_decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type));
1563
1564         //if (TagDecl *ctx_tag_decl = dyn_cast<TagDecl>(decl_ctx))
1565         //    CompleteTagDeclarationDefinition(GetTypeForDecl(ctx_tag_decl));
1566
1567         decl_ctx->addDecl (class_template_decl);
1568
1569 #ifdef LLDB_CONFIGURATION_DEBUG
1570         VerifyDecl(class_template_decl);
1571 #endif
1572     }
1573
1574     return class_template_decl;
1575 }
1576
1577
1578 ClassTemplateSpecializationDecl *
1579 ClangASTContext::CreateClassTemplateSpecializationDecl (DeclContext *decl_ctx,
1580                                                         ClassTemplateDecl *class_template_decl,
1581                                                         int kind,
1582                                                         const TemplateParameterInfos &template_param_infos)
1583 {
1584     ASTContext *ast = getASTContext();
1585     ClassTemplateSpecializationDecl *class_template_specialization_decl = ClassTemplateSpecializationDecl::Create (*ast,
1586                                                                                                                    (TagDecl::TagKind)kind,
1587                                                                                                                    decl_ctx,
1588                                                                                                                    SourceLocation(),
1589                                                                                                                    SourceLocation(),
1590                                                                                                                    class_template_decl,
1591                                                                                                                    &template_param_infos.args.front(),
1592                                                                                                                    template_param_infos.args.size(),
1593                                                                                                                    nullptr);
1594
1595     class_template_specialization_decl->setSpecializationKind(TSK_ExplicitSpecialization);
1596
1597     return class_template_specialization_decl;
1598 }
1599
1600 CompilerType
1601 ClangASTContext::CreateClassTemplateSpecializationType (ClassTemplateSpecializationDecl *class_template_specialization_decl)
1602 {
1603     if (class_template_specialization_decl)
1604     {
1605         ASTContext *ast = getASTContext();
1606         if (ast)
1607             return CompilerType(ast, ast->getTagDeclType(class_template_specialization_decl));
1608     }
1609     return CompilerType();
1610 }
1611
1612 static inline bool
1613 check_op_param (uint32_t op_kind, bool unary, bool binary, uint32_t num_params)
1614 {
1615     // Special-case call since it can take any number of operands
1616     if(op_kind == OO_Call)
1617         return true;
1618
1619     // The parameter count doesn't include "this"
1620     if (num_params == 0)
1621         return unary;
1622     if (num_params == 1)
1623         return binary;
1624     else
1625     return false;
1626 }
1627
1628 bool
1629 ClangASTContext::CheckOverloadedOperatorKindParameterCount (uint32_t op_kind, uint32_t num_params)
1630 {
1631     switch (op_kind)
1632     {
1633     default:
1634         break;
1635     // C++ standard allows any number of arguments to new/delete
1636     case OO_New:
1637     case OO_Array_New:
1638     case OO_Delete:
1639     case OO_Array_Delete:
1640         return true;
1641     }
1642
1643 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) case OO_##Name: return check_op_param (op_kind, Unary, Binary, num_params);
1644     switch (op_kind)
1645     {
1646 #include "clang/Basic/OperatorKinds.def"
1647         default: break;
1648     }
1649     return false;
1650 }
1651
1652 clang::AccessSpecifier
1653 ClangASTContext::UnifyAccessSpecifiers (clang::AccessSpecifier lhs, clang::AccessSpecifier rhs)
1654 {
1655     clang::AccessSpecifier ret = lhs;
1656
1657     // Make the access equal to the stricter of the field and the nested field's access
1658     switch (ret)
1659     {
1660         case clang::AS_none:
1661             break;
1662         case clang::AS_private:
1663             break;
1664         case clang::AS_protected:
1665             if (rhs == AS_private)
1666                 ret = AS_private;
1667             break;
1668         case clang::AS_public:
1669             ret = rhs;
1670             break;
1671     }
1672
1673     return ret;
1674 }
1675
1676 bool
1677 ClangASTContext::FieldIsBitfield (FieldDecl* field, uint32_t& bitfield_bit_size)
1678 {
1679     return FieldIsBitfield(getASTContext(), field, bitfield_bit_size);
1680 }
1681
1682 bool
1683 ClangASTContext::FieldIsBitfield
1684 (
1685     ASTContext *ast,
1686     FieldDecl* field,
1687     uint32_t& bitfield_bit_size
1688 )
1689 {
1690     if (ast == nullptr || field == nullptr)
1691         return false;
1692
1693     if (field->isBitField())
1694     {
1695         Expr* bit_width_expr = field->getBitWidth();
1696         if (bit_width_expr)
1697         {
1698             llvm::APSInt bit_width_apsint;
1699             if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast))
1700             {
1701                 bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX);
1702                 return true;
1703             }
1704         }
1705     }
1706     return false;
1707 }
1708
1709 bool
1710 ClangASTContext::RecordHasFields (const RecordDecl *record_decl)
1711 {
1712     if (record_decl == nullptr)
1713         return false;
1714
1715     if (!record_decl->field_empty())
1716         return true;
1717
1718     // No fields, lets check this is a CXX record and check the base classes
1719     const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1720     if (cxx_record_decl)
1721     {
1722         CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1723         for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
1724              base_class != base_class_end;
1725              ++base_class)
1726         {
1727             const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
1728             if (RecordHasFields(base_class_decl))
1729                 return true;
1730         }
1731     }
1732     return false;
1733 }
1734
1735 #pragma mark Objective C Classes
1736
1737 CompilerType
1738 ClangASTContext::CreateObjCClass
1739 (
1740     const char *name,
1741     DeclContext *decl_ctx,
1742     bool isForwardDecl,
1743     bool isInternal,
1744     ClangASTMetadata *metadata
1745 )
1746 {
1747     ASTContext *ast = getASTContext();
1748     assert (ast != nullptr);
1749     assert (name && name[0]);
1750     if (decl_ctx == nullptr)
1751         decl_ctx = ast->getTranslationUnitDecl();
1752
1753     ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create (*ast,
1754                                                          decl_ctx,
1755                                                          SourceLocation(),
1756                                                          &ast->Idents.get(name),
1757                                                          nullptr,
1758                                                          nullptr,
1759                                                          SourceLocation(),
1760                                                          /*isForwardDecl,*/
1761                                                          isInternal);
1762
1763     if (decl && metadata)
1764         SetMetadata(ast, decl, *metadata);
1765
1766     return CompilerType (ast, ast->getObjCInterfaceType(decl));
1767 }
1768
1769 static inline bool
1770 BaseSpecifierIsEmpty (const CXXBaseSpecifier *b)
1771 {
1772     return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false;
1773 }
1774
1775 uint32_t
1776 ClangASTContext::GetNumBaseClasses (const CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes)
1777 {
1778     uint32_t num_bases = 0;
1779     if (cxx_record_decl)
1780     {
1781         if (omit_empty_base_classes)
1782         {
1783             CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1784             for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
1785                  base_class != base_class_end;
1786                  ++base_class)
1787             {
1788                 // Skip empty base classes
1789                 if (omit_empty_base_classes)
1790                 {
1791                     if (BaseSpecifierIsEmpty (base_class))
1792                         continue;
1793                 }
1794                 ++num_bases;
1795             }
1796         }
1797         else
1798             num_bases = cxx_record_decl->getNumBases();
1799     }
1800     return num_bases;
1801 }
1802
1803
1804 #pragma mark Namespace Declarations
1805
1806 NamespaceDecl *
1807 ClangASTContext::GetUniqueNamespaceDeclaration (const char *name, DeclContext *decl_ctx)
1808 {
1809     NamespaceDecl *namespace_decl = nullptr;
1810     ASTContext *ast = getASTContext();
1811     TranslationUnitDecl *translation_unit_decl = ast->getTranslationUnitDecl ();
1812     if (decl_ctx == nullptr)
1813         decl_ctx = translation_unit_decl;
1814
1815     if (name)
1816     {
1817         IdentifierInfo &identifier_info = ast->Idents.get(name);
1818         DeclarationName decl_name (&identifier_info);
1819         clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1820         for (NamedDecl *decl : result)
1821         {
1822             namespace_decl = dyn_cast<clang::NamespaceDecl>(decl);
1823             if (namespace_decl)
1824                 return namespace_decl;
1825         }
1826
1827         namespace_decl = NamespaceDecl::Create(*ast,
1828                                                decl_ctx,
1829                                                false,
1830                                                SourceLocation(),
1831                                                SourceLocation(),
1832                                                &identifier_info,
1833                                                nullptr);
1834
1835         decl_ctx->addDecl (namespace_decl);
1836     }
1837     else
1838     {
1839         if (decl_ctx == translation_unit_decl)
1840         {
1841             namespace_decl = translation_unit_decl->getAnonymousNamespace();
1842             if (namespace_decl)
1843                 return namespace_decl;
1844
1845             namespace_decl = NamespaceDecl::Create(*ast,
1846                                                    decl_ctx,
1847                                                    false,
1848                                                    SourceLocation(),
1849                                                    SourceLocation(),
1850                                                    nullptr,
1851                                                    nullptr);
1852             translation_unit_decl->setAnonymousNamespace (namespace_decl);
1853             translation_unit_decl->addDecl (namespace_decl);
1854             assert (namespace_decl == translation_unit_decl->getAnonymousNamespace());
1855         }
1856         else
1857         {
1858             NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx);
1859             if (parent_namespace_decl)
1860             {
1861                 namespace_decl = parent_namespace_decl->getAnonymousNamespace();
1862                 if (namespace_decl)
1863                     return namespace_decl;
1864                 namespace_decl = NamespaceDecl::Create(*ast,
1865                                                        decl_ctx,
1866                                                        false,
1867                                                        SourceLocation(),
1868                                                        SourceLocation(),
1869                                                        nullptr,
1870                                                        nullptr);
1871                 parent_namespace_decl->setAnonymousNamespace (namespace_decl);
1872                 parent_namespace_decl->addDecl (namespace_decl);
1873                 assert (namespace_decl == parent_namespace_decl->getAnonymousNamespace());
1874             }
1875             else
1876             {
1877                 // BAD!!!
1878             }
1879         }
1880     }
1881 #ifdef LLDB_CONFIGURATION_DEBUG
1882     VerifyDecl(namespace_decl);
1883 #endif
1884     return namespace_decl;
1885 }
1886
1887
1888 clang::BlockDecl *
1889 ClangASTContext::CreateBlockDeclaration (clang::DeclContext *ctx)
1890 {
1891     if (ctx != nullptr)
1892     {
1893         clang::BlockDecl *decl = clang::BlockDecl::Create(*getASTContext(), ctx, clang::SourceLocation());
1894         ctx->addDecl(decl);
1895         return decl;
1896     }
1897     return nullptr;
1898 }
1899
1900 clang::DeclContext *
1901 FindLCABetweenDecls(clang::DeclContext *left, clang::DeclContext *right, clang::DeclContext *root)
1902 {
1903     if (root == nullptr)
1904         return nullptr;
1905
1906     std::set<clang::DeclContext *> path_left;
1907     for (clang::DeclContext *d = left; d != nullptr; d = d->getParent())
1908         path_left.insert(d);
1909
1910     for (clang::DeclContext *d = right; d != nullptr; d = d->getParent())
1911         if (path_left.find(d) != path_left.end())
1912             return d;
1913
1914     return nullptr;
1915 }
1916
1917 clang::UsingDirectiveDecl *
1918 ClangASTContext::CreateUsingDirectiveDeclaration (clang::DeclContext *decl_ctx, clang::NamespaceDecl *ns_decl)
1919 {
1920     if (decl_ctx != nullptr && ns_decl != nullptr)
1921     {
1922         clang::TranslationUnitDecl *translation_unit = (clang::TranslationUnitDecl *)GetTranslationUnitDecl(getASTContext());
1923         clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create(*getASTContext(),
1924             decl_ctx,
1925             clang::SourceLocation(),
1926             clang::SourceLocation(),
1927             clang::NestedNameSpecifierLoc(),
1928             clang::SourceLocation(),
1929             ns_decl,
1930             FindLCABetweenDecls(decl_ctx, ns_decl, translation_unit));
1931         decl_ctx->addDecl(using_decl);
1932         return using_decl;
1933     }
1934     return nullptr;
1935 }
1936
1937 clang::UsingDecl *
1938 ClangASTContext::CreateUsingDeclaration (clang::DeclContext *current_decl_ctx, clang::NamedDecl *target)
1939 {
1940     if (current_decl_ctx != nullptr && target != nullptr)
1941     {
1942         clang::UsingDecl *using_decl = clang::UsingDecl::Create(*getASTContext(),
1943             current_decl_ctx,
1944             clang::SourceLocation(),
1945             clang::NestedNameSpecifierLoc(),
1946             clang::DeclarationNameInfo(),
1947             false);
1948         clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(*getASTContext(),
1949             current_decl_ctx,
1950             clang::SourceLocation(),
1951             using_decl,
1952             target);
1953         using_decl->addShadowDecl(shadow_decl);
1954         current_decl_ctx->addDecl(using_decl);
1955         return using_decl;
1956     }
1957     return nullptr;
1958 }
1959
1960 clang::VarDecl *
1961 ClangASTContext::CreateVariableDeclaration (clang::DeclContext *decl_context, const char *name, clang::QualType type)
1962 {
1963     if (decl_context != nullptr)
1964     {
1965         clang::VarDecl *var_decl = clang::VarDecl::Create(*getASTContext(),
1966             decl_context,
1967             clang::SourceLocation(),
1968             clang::SourceLocation(),
1969             name && name[0] ? &getASTContext()->Idents.getOwn(name) : nullptr,
1970             type,
1971             nullptr,
1972             clang::SC_None);
1973         var_decl->setAccess(clang::AS_public);
1974         decl_context->addDecl(var_decl);
1975         return var_decl;
1976     }
1977     return nullptr;
1978 }
1979
1980 #pragma mark Function Types
1981
1982 FunctionDecl *
1983 ClangASTContext::CreateFunctionDeclaration (DeclContext *decl_ctx,
1984                                             const char *name,
1985                                             const CompilerType &function_clang_type,
1986                                             int storage,
1987                                             bool is_inline)
1988 {
1989     FunctionDecl *func_decl = nullptr;
1990     ASTContext *ast = getASTContext();
1991     if (decl_ctx == nullptr)
1992         decl_ctx = ast->getTranslationUnitDecl();
1993
1994
1995     const bool hasWrittenPrototype = true;
1996     const bool isConstexprSpecified = false;
1997
1998     if (name && name[0])
1999     {
2000         func_decl = FunctionDecl::Create (*ast,
2001                                           decl_ctx,
2002                                           SourceLocation(),
2003                                           SourceLocation(),
2004                                           DeclarationName (&ast->Idents.get(name)),
2005                                           GetQualType(function_clang_type),
2006                                           nullptr,
2007                                           (clang::StorageClass)storage,
2008                                           is_inline,
2009                                           hasWrittenPrototype,
2010                                           isConstexprSpecified);
2011     }
2012     else
2013     {
2014         func_decl = FunctionDecl::Create (*ast,
2015                                           decl_ctx,
2016                                           SourceLocation(),
2017                                           SourceLocation(),
2018                                           DeclarationName (),
2019                                           GetQualType(function_clang_type),
2020                                           nullptr,
2021                                           (clang::StorageClass)storage,
2022                                           is_inline,
2023                                           hasWrittenPrototype,
2024                                           isConstexprSpecified);
2025     }
2026     if (func_decl)
2027         decl_ctx->addDecl (func_decl);
2028
2029 #ifdef LLDB_CONFIGURATION_DEBUG
2030     VerifyDecl(func_decl);
2031 #endif
2032
2033     return func_decl;
2034 }
2035
2036 CompilerType
2037 ClangASTContext::CreateFunctionType (ASTContext *ast,
2038                                      const CompilerType& result_type,
2039                                      const CompilerType *args,
2040                                      unsigned num_args,
2041                                      bool is_variadic,
2042                                      unsigned type_quals)
2043 {
2044     assert (ast != nullptr);
2045     std::vector<QualType> qual_type_args;
2046     for (unsigned i=0; i<num_args; ++i)
2047         qual_type_args.push_back (GetQualType(args[i]));
2048
2049     // TODO: Detect calling convention in DWARF?
2050     FunctionProtoType::ExtProtoInfo proto_info;
2051     proto_info.Variadic = is_variadic;
2052     proto_info.ExceptionSpec = EST_None;
2053     proto_info.TypeQuals = type_quals;
2054     proto_info.RefQualifier = RQ_None;
2055
2056     return CompilerType (ast, ast->getFunctionType (GetQualType(result_type),
2057                                                     qual_type_args,
2058                                                     proto_info));
2059 }
2060
2061 ParmVarDecl *
2062 ClangASTContext::CreateParameterDeclaration (const char *name, const CompilerType &param_type, int storage)
2063 {
2064     ASTContext *ast = getASTContext();
2065     assert (ast != nullptr);
2066     return ParmVarDecl::Create(*ast,
2067                                 ast->getTranslationUnitDecl(),
2068                                 SourceLocation(),
2069                                 SourceLocation(),
2070                                 name && name[0] ? &ast->Idents.get(name) : nullptr,
2071                                 GetQualType(param_type),
2072                                 nullptr,
2073                                 (clang::StorageClass)storage,
2074                                 nullptr);
2075 }
2076
2077 void
2078 ClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params)
2079 {
2080     if (function_decl)
2081         function_decl->setParams (ArrayRef<ParmVarDecl*>(params, num_params));
2082 }
2083
2084
2085 #pragma mark Array Types
2086
2087 CompilerType
2088 ClangASTContext::CreateArrayType (const CompilerType &element_type,
2089                                   size_t element_count,
2090                                   bool is_vector)
2091 {
2092     if (element_type.IsValid())
2093     {
2094         ASTContext *ast = getASTContext();
2095         assert (ast != nullptr);
2096
2097         if (is_vector)
2098         {
2099             return CompilerType (ast, ast->getExtVectorType(GetQualType(element_type), element_count));
2100         }
2101         else
2102         {
2103
2104             llvm::APInt ap_element_count (64, element_count);
2105             if (element_count == 0)
2106             {
2107                 return CompilerType (ast, ast->getIncompleteArrayType (GetQualType(element_type),
2108                                                                        ArrayType::Normal,
2109                                                                        0));
2110             }
2111             else
2112             {
2113                 return CompilerType (ast, ast->getConstantArrayType (GetQualType(element_type),
2114                                                                      ap_element_count,
2115                                                                      ArrayType::Normal,
2116                                                                      0));
2117             }
2118         }
2119     }
2120     return CompilerType();
2121 }
2122
2123 CompilerType
2124 ClangASTContext::GetOrCreateStructForIdentifier (const ConstString &type_name,
2125                                                  const std::initializer_list< std::pair < const char *, CompilerType > >& type_fields,
2126                                                  bool packed)
2127 {
2128     CompilerType type;
2129     if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid())
2130         return type;
2131     type = CreateRecordType(nullptr, lldb::eAccessPublic, type_name.GetCString(), clang::TTK_Struct, lldb::eLanguageTypeC);
2132     StartTagDeclarationDefinition(type);
2133     for (const auto& field : type_fields)
2134         AddFieldToRecordType(type, field.first, field.second, lldb::eAccessPublic, 0);
2135     if (packed)
2136         SetIsPacked(type);
2137     CompleteTagDeclarationDefinition(type);
2138     return type;
2139 }
2140
2141 #pragma mark Enumeration Types
2142
2143 CompilerType
2144 ClangASTContext::CreateEnumerationType
2145 (
2146  const char *name,
2147  DeclContext *decl_ctx,
2148  const Declaration &decl,
2149  const CompilerType &integer_clang_type
2150  )
2151 {
2152     // TODO: Do something intelligent with the Declaration object passed in
2153     // like maybe filling in the SourceLocation with it...
2154     ASTContext *ast = getASTContext();
2155
2156     // TODO: ask about these...
2157     //    const bool IsScoped = false;
2158     //    const bool IsFixed = false;
2159
2160     EnumDecl *enum_decl = EnumDecl::Create (*ast,
2161                                             decl_ctx,
2162                                             SourceLocation(),
2163                                             SourceLocation(),
2164                                             name && name[0] ? &ast->Idents.get(name) : nullptr,
2165                                             nullptr,
2166                                             false,  // IsScoped
2167                                             false,  // IsScopedUsingClassTag
2168                                             false); // IsFixed
2169
2170
2171     if (enum_decl)
2172     {
2173         // TODO: check if we should be setting the promotion type too?
2174         enum_decl->setIntegerType(GetQualType(integer_clang_type));
2175
2176         enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
2177
2178         return CompilerType (ast, ast->getTagDeclType(enum_decl));
2179     }
2180     return CompilerType();
2181 }
2182
2183 // Disable this for now since I can't seem to get a nicely formatted float
2184 // out of the APFloat class without just getting the float, double or quad
2185 // and then using a formatted print on it which defeats the purpose. We ideally
2186 // would like to get perfect string values for any kind of float semantics
2187 // so we can support remote targets. The code below also requires a patch to
2188 // llvm::APInt.
2189 //bool
2190 //ClangASTContext::ConvertFloatValueToString (ASTContext *ast, lldb::opaque_compiler_type_t clang_type, const uint8_t* bytes, size_t byte_size, int apint_byte_order, std::string &float_str)
2191 //{
2192 //  uint32_t count = 0;
2193 //  bool is_complex = false;
2194 //  if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
2195 //  {
2196 //      unsigned num_bytes_per_float = byte_size / count;
2197 //      unsigned num_bits_per_float = num_bytes_per_float * 8;
2198 //
2199 //      float_str.clear();
2200 //      uint32_t i;
2201 //      for (i=0; i<count; i++)
2202 //      {
2203 //          APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, (APInt::ByteOrder)apint_byte_order);
2204 //          bool is_ieee = false;
2205 //          APFloat ap_float(ap_int, is_ieee);
2206 //          char s[1024];
2207 //          unsigned int hex_digits = 0;
2208 //          bool upper_case = false;
2209 //
2210 //          if (ap_float.convertToHexString(s, hex_digits, upper_case, APFloat::rmNearestTiesToEven) > 0)
2211 //          {
2212 //              if (i > 0)
2213 //                  float_str.append(", ");
2214 //              float_str.append(s);
2215 //              if (i == 1 && is_complex)
2216 //                  float_str.append(1, 'i');
2217 //          }
2218 //      }
2219 //      return !float_str.empty();
2220 //  }
2221 //  return false;
2222 //}
2223
2224 CompilerType
2225 ClangASTContext::GetIntTypeFromBitSize (clang::ASTContext *ast,
2226                                         size_t bit_size, bool is_signed)
2227 {
2228     if (ast)
2229     {
2230         if (is_signed)
2231         {
2232             if (bit_size == ast->getTypeSize(ast->SignedCharTy))
2233                 return CompilerType(ast, ast->SignedCharTy);
2234
2235             if (bit_size == ast->getTypeSize(ast->ShortTy))
2236                 return CompilerType(ast, ast->ShortTy);
2237
2238             if (bit_size == ast->getTypeSize(ast->IntTy))
2239                 return CompilerType(ast, ast->IntTy);
2240
2241             if (bit_size == ast->getTypeSize(ast->LongTy))
2242                 return CompilerType(ast, ast->LongTy);
2243
2244             if (bit_size == ast->getTypeSize(ast->LongLongTy))
2245                 return CompilerType(ast, ast->LongLongTy);
2246
2247             if (bit_size == ast->getTypeSize(ast->Int128Ty))
2248                 return CompilerType(ast, ast->Int128Ty);
2249         }
2250         else
2251         {
2252             if (bit_size == ast->getTypeSize(ast->UnsignedCharTy))
2253                 return CompilerType(ast, ast->UnsignedCharTy);
2254
2255             if (bit_size == ast->getTypeSize(ast->UnsignedShortTy))
2256                 return CompilerType(ast, ast->UnsignedShortTy);
2257
2258             if (bit_size == ast->getTypeSize(ast->UnsignedIntTy))
2259                 return CompilerType(ast, ast->UnsignedIntTy);
2260
2261             if (bit_size == ast->getTypeSize(ast->UnsignedLongTy))
2262                 return CompilerType(ast, ast->UnsignedLongTy);
2263
2264             if (bit_size == ast->getTypeSize(ast->UnsignedLongLongTy))
2265                 return CompilerType(ast, ast->UnsignedLongLongTy);
2266
2267             if (bit_size == ast->getTypeSize(ast->UnsignedInt128Ty))
2268                 return CompilerType(ast, ast->UnsignedInt128Ty);
2269         }
2270     }
2271     return CompilerType();
2272 }
2273
2274 CompilerType
2275 ClangASTContext::GetPointerSizedIntType (clang::ASTContext *ast, bool is_signed)
2276 {
2277     if (ast)
2278         return GetIntTypeFromBitSize(ast, ast->getTypeSize(ast->VoidPtrTy), is_signed);
2279     return CompilerType();
2280 }
2281
2282 void
2283 ClangASTContext::DumpDeclContextHiearchy (clang::DeclContext *decl_ctx)
2284 {
2285     if (decl_ctx)
2286     {
2287         DumpDeclContextHiearchy (decl_ctx->getParent());
2288
2289         clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl_ctx);
2290         if (named_decl)
2291         {
2292             printf ("%20s: %s\n", decl_ctx->getDeclKindName(), named_decl->getDeclName().getAsString().c_str());
2293         }
2294         else
2295         {
2296             printf ("%20s\n", decl_ctx->getDeclKindName());
2297         }
2298     }
2299 }
2300
2301 void
2302 ClangASTContext::DumpDeclHiearchy (clang::Decl *decl)
2303 {
2304     if (decl == nullptr)
2305         return;
2306     DumpDeclContextHiearchy(decl->getDeclContext());
2307
2308     clang::RecordDecl *record_decl = llvm::dyn_cast<clang::RecordDecl>(decl);
2309     if (record_decl)
2310     {
2311         printf ("%20s: %s%s\n", decl->getDeclKindName(), record_decl->getDeclName().getAsString().c_str(), record_decl->isInjectedClassName() ? " (injected class name)" : "");
2312
2313     }
2314     else
2315     {
2316         clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl);
2317         if (named_decl)
2318         {
2319             printf ("%20s: %s\n", decl->getDeclKindName(), named_decl->getDeclName().getAsString().c_str());
2320         }
2321         else
2322         {
2323             printf ("%20s\n", decl->getDeclKindName());
2324         }
2325     }
2326 }
2327
2328 bool
2329 ClangASTContext::DeclsAreEquivalent (clang::Decl *lhs_decl, clang::Decl *rhs_decl)
2330 {
2331     if (lhs_decl && rhs_decl)
2332     {
2333         //----------------------------------------------------------------------
2334         // Make sure the decl kinds match first
2335         //----------------------------------------------------------------------
2336         const clang::Decl::Kind lhs_decl_kind = lhs_decl->getKind();
2337         const clang::Decl::Kind rhs_decl_kind = rhs_decl->getKind();
2338
2339         if (lhs_decl_kind == rhs_decl_kind)
2340         {
2341             //------------------------------------------------------------------
2342             // Now check that the decl contexts kinds are all equivalent
2343             // before we have to check any names of the decl contexts...
2344             //------------------------------------------------------------------
2345             clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext();
2346             clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext();
2347             if (lhs_decl_ctx && rhs_decl_ctx)
2348             {
2349                 while (1)
2350                 {
2351                     if (lhs_decl_ctx && rhs_decl_ctx)
2352                     {
2353                         const clang::Decl::Kind lhs_decl_ctx_kind = lhs_decl_ctx->getDeclKind();
2354                         const clang::Decl::Kind rhs_decl_ctx_kind = rhs_decl_ctx->getDeclKind();
2355                         if (lhs_decl_ctx_kind == rhs_decl_ctx_kind)
2356                         {
2357                             lhs_decl_ctx = lhs_decl_ctx->getParent();
2358                             rhs_decl_ctx = rhs_decl_ctx->getParent();
2359
2360                             if (lhs_decl_ctx == nullptr && rhs_decl_ctx == nullptr)
2361                                 break;
2362                         }
2363                         else
2364                             return false;
2365                     }
2366                     else
2367                         return false;
2368                 }
2369
2370                 //--------------------------------------------------------------
2371                 // Now make sure the name of the decls match
2372                 //--------------------------------------------------------------
2373                 clang::NamedDecl *lhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(lhs_decl);
2374                 clang::NamedDecl *rhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(rhs_decl);
2375                 if (lhs_named_decl && rhs_named_decl)
2376                 {
2377                     clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName();
2378                     clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName();
2379                     if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind())
2380                     {
2381                         if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2382                             return false;
2383                     }
2384                     else
2385                         return false;
2386                 }
2387                 else
2388                     return false;
2389
2390                 //--------------------------------------------------------------
2391                 // We know that the decl context kinds all match, so now we need
2392                 // to make sure the names match as well
2393                 //--------------------------------------------------------------
2394                 lhs_decl_ctx = lhs_decl->getDeclContext();
2395                 rhs_decl_ctx = rhs_decl->getDeclContext();
2396                 while (1)
2397                 {
2398                     switch (lhs_decl_ctx->getDeclKind())
2399                     {
2400                     case clang::Decl::TranslationUnit:
2401                         // We don't care about the translation unit names
2402                         return true;
2403                     default:
2404                         {
2405                             clang::NamedDecl *lhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(lhs_decl_ctx);
2406                             clang::NamedDecl *rhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(rhs_decl_ctx);
2407                             if (lhs_named_decl && rhs_named_decl)
2408                             {
2409                                 clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName();
2410                                 clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName();
2411                                 if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind())
2412                                 {
2413                                     if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString())
2414                                         return false;
2415                                 }
2416                                 else
2417                                     return false;
2418                             }
2419                             else
2420                                 return false;
2421                         }
2422                         break;
2423
2424                     }
2425                     lhs_decl_ctx = lhs_decl_ctx->getParent();
2426                     rhs_decl_ctx = rhs_decl_ctx->getParent();
2427                 }
2428             }
2429         }
2430     }
2431     return false;
2432 }
2433 bool
2434 ClangASTContext::GetCompleteDecl (clang::ASTContext *ast,
2435                                   clang::Decl *decl)
2436 {
2437     if (!decl)
2438         return false;
2439
2440     ExternalASTSource *ast_source = ast->getExternalSource();
2441
2442     if (!ast_source)
2443         return false;
2444
2445     if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
2446     {
2447         if (tag_decl->isCompleteDefinition())
2448             return true;
2449
2450         if (!tag_decl->hasExternalLexicalStorage())
2451             return false;
2452
2453         ast_source->CompleteType(tag_decl);
2454
2455         return !tag_decl->getTypeForDecl()->isIncompleteType();
2456     }
2457     else if (clang::ObjCInterfaceDecl *objc_interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
2458     {
2459         if (objc_interface_decl->getDefinition())
2460             return true;
2461
2462         if (!objc_interface_decl->hasExternalLexicalStorage())
2463             return false;
2464
2465         ast_source->CompleteType(objc_interface_decl);
2466
2467         return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
2468     }
2469     else
2470     {
2471         return false;
2472     }
2473 }
2474
2475 void
2476 ClangASTContext::SetMetadataAsUserID (const void *object,
2477                                       user_id_t user_id)
2478 {
2479     ClangASTMetadata meta_data;
2480     meta_data.SetUserID (user_id);
2481     SetMetadata (object, meta_data);
2482 }
2483
2484 void
2485 ClangASTContext::SetMetadata (clang::ASTContext *ast,
2486                               const void *object,
2487                               ClangASTMetadata &metadata)
2488 {
2489     ClangExternalASTSourceCommon *external_source =
2490         ClangExternalASTSourceCommon::Lookup(ast->getExternalSource());
2491
2492     if (external_source)
2493         external_source->SetMetadata(object, metadata);
2494 }
2495
2496 ClangASTMetadata *
2497 ClangASTContext::GetMetadata (clang::ASTContext *ast,
2498                               const void *object)
2499 {
2500     ClangExternalASTSourceCommon *external_source =
2501         ClangExternalASTSourceCommon::Lookup(ast->getExternalSource());
2502
2503     if (external_source && external_source->HasMetadata(object))
2504         return external_source->GetMetadata(object);
2505     else
2506         return nullptr;
2507 }
2508
2509 clang::DeclContext *
2510 ClangASTContext::GetAsDeclContext (clang::CXXMethodDecl *cxx_method_decl)
2511 {
2512     return llvm::dyn_cast<clang::DeclContext>(cxx_method_decl);
2513 }
2514
2515 clang::DeclContext *
2516 ClangASTContext::GetAsDeclContext (clang::ObjCMethodDecl *objc_method_decl)
2517 {
2518     return llvm::dyn_cast<clang::DeclContext>(objc_method_decl);
2519 }
2520
2521 bool
2522 ClangASTContext::SetTagTypeKind (clang::QualType tag_qual_type, int kind) const
2523 {
2524     const clang::Type *clang_type = tag_qual_type.getTypePtr();
2525     if (clang_type)
2526     {
2527         const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(clang_type);
2528         if (tag_type)
2529         {
2530             clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(tag_type->getDecl());
2531             if (tag_decl)
2532             {
2533                 tag_decl->setTagKind ((clang::TagDecl::TagKind)kind);
2534                 return true;
2535             }
2536         }
2537     }
2538     return false;
2539 }
2540
2541
2542 bool
2543 ClangASTContext::SetDefaultAccessForRecordFields (clang::RecordDecl* record_decl,
2544                                                   int default_accessibility,
2545                                                   int *assigned_accessibilities,
2546                                                   size_t num_assigned_accessibilities)
2547 {
2548     if (record_decl)
2549     {
2550         uint32_t field_idx;
2551         clang::RecordDecl::field_iterator field, field_end;
2552         for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0;
2553              field != field_end;
2554              ++field, ++field_idx)
2555         {
2556             // If no accessibility was assigned, assign the correct one
2557             if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none)
2558                 field->setAccess ((clang::AccessSpecifier)default_accessibility);
2559         }
2560         return true;
2561     }
2562     return false;
2563 }
2564
2565 clang::DeclContext *
2566 ClangASTContext::GetDeclContextForType (const CompilerType& type)
2567 {
2568     return GetDeclContextForType(GetQualType(type));
2569 }
2570
2571 clang::DeclContext *
2572 ClangASTContext::GetDeclContextForType (clang::QualType type)
2573 {
2574     if (type.isNull())
2575         return nullptr;
2576
2577     clang::QualType qual_type = type.getCanonicalType();
2578     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2579     switch (type_class)
2580     {
2581         case clang::Type::ObjCInterface:            return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr())->getInterface();
2582         case clang::Type::ObjCObjectPointer:        return GetDeclContextForType (llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType());
2583         case clang::Type::Record:                   return llvm::cast<clang::RecordType>(qual_type)->getDecl();
2584         case clang::Type::Enum:                     return llvm::cast<clang::EnumType>(qual_type)->getDecl();
2585         case clang::Type::Typedef:                  return GetDeclContextForType (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType());
2586         case clang::Type::Auto:                     return GetDeclContextForType (llvm::cast<clang::AutoType>(qual_type)->getDeducedType());
2587         case clang::Type::Elaborated:               return GetDeclContextForType (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType());
2588         case clang::Type::Paren:                    return GetDeclContextForType (llvm::cast<clang::ParenType>(qual_type)->desugar());
2589         default:
2590             break;
2591     }
2592     // No DeclContext in this type...
2593     return nullptr;
2594 }
2595
2596 static bool
2597 GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type, bool allow_completion = true)
2598 {
2599     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2600     switch (type_class)
2601     {
2602         case clang::Type::ConstantArray:
2603         case clang::Type::IncompleteArray:
2604         case clang::Type::VariableArray:
2605             {
2606                 const clang::ArrayType *array_type = llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr());
2607
2608                 if (array_type)
2609                     return GetCompleteQualType (ast, array_type->getElementType(), allow_completion);
2610             }
2611             break;
2612         case clang::Type::Record:
2613             {
2614                 clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2615                 if (cxx_record_decl)
2616                 {
2617                     if (cxx_record_decl->hasExternalLexicalStorage())
2618                     {
2619                         const bool is_complete = cxx_record_decl->isCompleteDefinition();
2620                         const bool fields_loaded = cxx_record_decl->hasLoadedFieldsFromExternalStorage();
2621                         if (is_complete && fields_loaded)
2622                             return true;
2623
2624                         if (!allow_completion)
2625                             return false;
2626
2627                         // Call the field_begin() accessor to for it to use the external source
2628                         // to load the fields...
2629                         clang::ExternalASTSource *external_ast_source = ast->getExternalSource();
2630                         if (external_ast_source)
2631                         {
2632                             external_ast_source->CompleteType(cxx_record_decl);
2633                             if (cxx_record_decl->isCompleteDefinition())
2634                             {
2635                                 cxx_record_decl->setHasLoadedFieldsFromExternalStorage (true);
2636                                 cxx_record_decl->field_begin();
2637                             }
2638                         }
2639                     }
2640                 }
2641                 const clang::TagType *tag_type = llvm::cast<clang::TagType>(qual_type.getTypePtr());
2642                 return !tag_type->isIncompleteType();
2643             }
2644             break;
2645
2646         case clang::Type::Enum:
2647             {
2648                 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
2649                 if (tag_type)
2650                 {
2651                     clang::TagDecl *tag_decl = tag_type->getDecl();
2652                     if (tag_decl)
2653                     {
2654                         if (tag_decl->getDefinition())
2655                             return true;
2656
2657                         if (!allow_completion)
2658                             return false;
2659
2660                         if (tag_decl->hasExternalLexicalStorage())
2661                         {
2662                             if (ast)
2663                             {
2664                                 clang::ExternalASTSource *external_ast_source = ast->getExternalSource();
2665                                 if (external_ast_source)
2666                                 {
2667                                     external_ast_source->CompleteType(tag_decl);
2668                                     return !tag_type->isIncompleteType();
2669                                 }
2670                             }
2671                         }
2672                         return false;
2673                     }
2674                 }
2675
2676             }
2677             break;
2678         case clang::Type::ObjCObject:
2679         case clang::Type::ObjCInterface:
2680             {
2681                 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
2682                 if (objc_class_type)
2683                 {
2684                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2685                     // We currently can't complete objective C types through the newly added ASTContext
2686                     // because it only supports TagDecl objects right now...
2687                     if (class_interface_decl)
2688                     {
2689                         if (class_interface_decl->getDefinition())
2690                             return true;
2691
2692                         if (!allow_completion)
2693                             return false;
2694
2695                         if (class_interface_decl->hasExternalLexicalStorage())
2696                         {
2697                             if (ast)
2698                             {
2699                                 clang::ExternalASTSource *external_ast_source = ast->getExternalSource();
2700                                 if (external_ast_source)
2701                                 {
2702                                     external_ast_source->CompleteType (class_interface_decl);
2703                                     return !objc_class_type->isIncompleteType();
2704                                 }
2705                             }
2706                         }
2707                         return false;
2708                     }
2709                 }
2710             }
2711             break;
2712
2713         case clang::Type::Typedef:
2714             return GetCompleteQualType (ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType(), allow_completion);
2715
2716         case clang::Type::Auto:
2717             return GetCompleteQualType (ast, llvm::cast<clang::AutoType>(qual_type)->getDeducedType(), allow_completion);
2718
2719         case clang::Type::Elaborated:
2720             return GetCompleteQualType (ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType(), allow_completion);
2721
2722         case clang::Type::Paren:
2723             return GetCompleteQualType (ast, llvm::cast<clang::ParenType>(qual_type)->desugar(), allow_completion);
2724
2725         case clang::Type::Attributed:
2726             return GetCompleteQualType (ast, llvm::cast<clang::AttributedType>(qual_type)->getModifiedType(), allow_completion);
2727
2728         default:
2729             break;
2730     }
2731
2732     return true;
2733 }
2734
2735 static clang::ObjCIvarDecl::AccessControl
2736 ConvertAccessTypeToObjCIvarAccessControl (AccessType access)
2737 {
2738     switch (access)
2739     {
2740         case eAccessNone:      return clang::ObjCIvarDecl::None;
2741         case eAccessPublic:    return clang::ObjCIvarDecl::Public;
2742         case eAccessPrivate:   return clang::ObjCIvarDecl::Private;
2743         case eAccessProtected: return clang::ObjCIvarDecl::Protected;
2744         case eAccessPackage:   return clang::ObjCIvarDecl::Package;
2745     }
2746     return clang::ObjCIvarDecl::None;
2747 }
2748
2749
2750 //----------------------------------------------------------------------
2751 // Tests
2752 //----------------------------------------------------------------------
2753
2754 bool
2755 ClangASTContext::IsAggregateType (lldb::opaque_compiler_type_t type)
2756 {
2757     clang::QualType qual_type (GetCanonicalQualType(type));
2758
2759     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2760     switch (type_class)
2761     {
2762         case clang::Type::IncompleteArray:
2763         case clang::Type::VariableArray:
2764         case clang::Type::ConstantArray:
2765         case clang::Type::ExtVector:
2766         case clang::Type::Vector:
2767         case clang::Type::Record:
2768         case clang::Type::ObjCObject:
2769         case clang::Type::ObjCInterface:
2770             return true;
2771         case clang::Type::Auto:
2772             return IsAggregateType(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr());
2773         case clang::Type::Elaborated:
2774             return IsAggregateType(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
2775         case clang::Type::Typedef:
2776             return IsAggregateType(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
2777         case clang::Type::Paren:
2778             return IsAggregateType(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
2779         default:
2780             break;
2781     }
2782     // The clang type does have a value
2783     return false;
2784 }
2785
2786 bool
2787 ClangASTContext::IsAnonymousType (lldb::opaque_compiler_type_t type)
2788 {
2789     clang::QualType qual_type (GetCanonicalQualType(type));
2790
2791     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2792     switch (type_class)
2793     {
2794         case clang::Type::Record:
2795         {
2796             if (const clang::RecordType *record_type = llvm::dyn_cast_or_null<clang::RecordType>(qual_type.getTypePtrOrNull()))
2797             {
2798                 if (const clang::RecordDecl *record_decl = record_type->getDecl())
2799                 {
2800                     return record_decl->isAnonymousStructOrUnion();
2801                 }
2802             }
2803             break;
2804         }
2805         case clang::Type::Auto:
2806             return IsAnonymousType(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr());
2807         case clang::Type::Elaborated:
2808             return IsAnonymousType(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
2809         case clang::Type::Typedef:
2810             return IsAnonymousType(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
2811         case clang::Type::Paren:
2812             return IsAnonymousType(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
2813         default:
2814             break;
2815     }
2816     // The clang type does have a value
2817     return false;
2818 }
2819
2820 bool
2821 ClangASTContext::IsArrayType (lldb::opaque_compiler_type_t type,
2822                               CompilerType *element_type_ptr,
2823                               uint64_t *size,
2824                               bool *is_incomplete)
2825 {
2826     clang::QualType qual_type (GetCanonicalQualType(type));
2827
2828     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2829     switch (type_class)
2830     {
2831         default:
2832             break;
2833
2834         case clang::Type::ConstantArray:
2835             if (element_type_ptr)
2836                 element_type_ptr->SetCompilerType (getASTContext(), llvm::cast<clang::ConstantArrayType>(qual_type)->getElementType());
2837             if (size)
2838                 *size = llvm::cast<clang::ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULLONG_MAX);
2839             if (is_incomplete)
2840                 *is_incomplete = false;
2841             return true;
2842
2843         case clang::Type::IncompleteArray:
2844             if (element_type_ptr)
2845                 element_type_ptr->SetCompilerType (getASTContext(), llvm::cast<clang::IncompleteArrayType>(qual_type)->getElementType());
2846             if (size)
2847                 *size = 0;
2848             if (is_incomplete)
2849                 *is_incomplete = true;
2850             return true;
2851
2852         case clang::Type::VariableArray:
2853             if (element_type_ptr)
2854                 element_type_ptr->SetCompilerType (getASTContext(), llvm::cast<clang::VariableArrayType>(qual_type)->getElementType());
2855             if (size)
2856                 *size = 0;
2857             if (is_incomplete)
2858                 *is_incomplete = false;
2859             return true;
2860
2861         case clang::Type::DependentSizedArray:
2862             if (element_type_ptr)
2863                 element_type_ptr->SetCompilerType (getASTContext(), llvm::cast<clang::DependentSizedArrayType>(qual_type)->getElementType());
2864             if (size)
2865                 *size = 0;
2866             if (is_incomplete)
2867                 *is_incomplete = false;
2868             return true;
2869
2870         case clang::Type::Typedef:
2871             return IsArrayType(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
2872                                element_type_ptr,
2873                                size,
2874                                is_incomplete);
2875         case clang::Type::Auto:
2876             return IsArrayType(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(),
2877                                element_type_ptr,
2878                                size,
2879                                is_incomplete);
2880         case clang::Type::Elaborated:
2881             return IsArrayType(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(),
2882                                element_type_ptr,
2883                                size,
2884                                is_incomplete);
2885         case clang::Type::Paren:
2886             return IsArrayType(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
2887                                element_type_ptr,
2888                                size,
2889                                is_incomplete);
2890     }
2891     if (element_type_ptr)
2892         element_type_ptr->Clear();
2893     if (size)
2894         *size = 0;
2895     if (is_incomplete)
2896         *is_incomplete = false;
2897     return false;
2898 }
2899
2900 bool
2901 ClangASTContext::IsVectorType (lldb::opaque_compiler_type_t type,
2902                                CompilerType *element_type,
2903                                uint64_t *size)
2904 {
2905     clang::QualType qual_type (GetCanonicalQualType(type));
2906
2907     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2908     switch (type_class)
2909     {
2910         case clang::Type::Vector:
2911         {
2912             const clang::VectorType *vector_type = qual_type->getAs<clang::VectorType>();
2913             if (vector_type)
2914             {
2915                 if (size)
2916                     *size = vector_type->getNumElements();
2917                 if (element_type)
2918                     *element_type = CompilerType(getASTContext(), vector_type->getElementType());
2919             }
2920             return true;
2921         }
2922             break;
2923         case clang::Type::ExtVector:
2924         {
2925             const clang::ExtVectorType *ext_vector_type = qual_type->getAs<clang::ExtVectorType>();
2926             if (ext_vector_type)
2927             {
2928                 if (size)
2929                     *size = ext_vector_type->getNumElements();
2930                 if (element_type)
2931                     *element_type = CompilerType(getASTContext(), ext_vector_type->getElementType());
2932             }
2933             return true;
2934         }
2935         default:
2936             break;
2937     }
2938     return false;
2939 }
2940
2941 bool
2942 ClangASTContext::IsRuntimeGeneratedType (lldb::opaque_compiler_type_t type)
2943 {
2944     clang::DeclContext* decl_ctx = ClangASTContext::GetASTContext(getASTContext())->GetDeclContextForType(GetQualType(type));
2945     if (!decl_ctx)
2946         return false;
2947
2948     if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx))
2949         return false;
2950
2951     clang::ObjCInterfaceDecl *result_iface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
2952
2953     ClangASTMetadata* ast_metadata = ClangASTContext::GetMetadata(getASTContext(), result_iface_decl);
2954     if (!ast_metadata)
2955         return false;
2956     return (ast_metadata->GetISAPtr() != 0);
2957 }
2958
2959 bool
2960 ClangASTContext::IsCharType (lldb::opaque_compiler_type_t type)
2961 {
2962     return GetQualType(type).getUnqualifiedType()->isCharType();
2963 }
2964
2965
2966 bool
2967 ClangASTContext::IsCompleteType (lldb::opaque_compiler_type_t type)
2968 {
2969     const bool allow_completion = false;
2970     return GetCompleteQualType (getASTContext(), GetQualType(type), allow_completion);
2971 }
2972
2973 bool
2974 ClangASTContext::IsConst(lldb::opaque_compiler_type_t type)
2975 {
2976     return GetQualType(type).isConstQualified();
2977 }
2978
2979 bool
2980 ClangASTContext::IsCStringType (lldb::opaque_compiler_type_t type, uint32_t &length)
2981 {
2982     CompilerType pointee_or_element_clang_type;
2983     length = 0;
2984     Flags type_flags (GetTypeInfo (type, &pointee_or_element_clang_type));
2985
2986     if (!pointee_or_element_clang_type.IsValid())
2987         return false;
2988
2989     if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer))
2990     {
2991         if (pointee_or_element_clang_type.IsCharType())
2992         {
2993             if (type_flags.Test (eTypeIsArray))
2994             {
2995                 // We know the size of the array and it could be a C string
2996                 // since it is an array of characters
2997                 length = llvm::cast<clang::ConstantArrayType>(GetCanonicalQualType(type).getTypePtr())->getSize().getLimitedValue();
2998             }
2999             return true;
3000
3001         }
3002     }
3003     return false;
3004 }
3005
3006 bool
3007 ClangASTContext::IsFunctionType (lldb::opaque_compiler_type_t type, bool *is_variadic_ptr)
3008 {
3009     if (type)
3010     {
3011         clang::QualType qual_type (GetCanonicalQualType(type));
3012
3013         if (qual_type->isFunctionType())
3014         {
3015             if (is_variadic_ptr)
3016             {
3017                 const clang::FunctionProtoType *function_proto_type = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3018                 if (function_proto_type)
3019                     *is_variadic_ptr = function_proto_type->isVariadic();
3020                 else
3021                     *is_variadic_ptr = false;
3022             }
3023             return true;
3024         }
3025
3026         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3027         switch (type_class)
3028         {
3029             default:
3030                 break;
3031             case clang::Type::Typedef:
3032                 return IsFunctionType(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), nullptr);
3033             case clang::Type::Auto:
3034                 return IsFunctionType(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), nullptr);
3035             case clang::Type::Elaborated:
3036                 return IsFunctionType(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), nullptr);
3037             case clang::Type::Paren:
3038                 return IsFunctionType(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), nullptr);
3039             case clang::Type::LValueReference:
3040             case clang::Type::RValueReference:
3041                 {
3042                     const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3043                     if (reference_type)
3044                         return IsFunctionType(reference_type->getPointeeType().getAsOpaquePtr(), nullptr);
3045                 }
3046                 break;
3047         }
3048     }
3049     return false;
3050 }
3051
3052 // Used to detect "Homogeneous Floating-point Aggregates"
3053 uint32_t
3054 ClangASTContext::IsHomogeneousAggregate (lldb::opaque_compiler_type_t type, CompilerType* base_type_ptr)
3055 {
3056     if (!type)
3057         return 0;
3058
3059     clang::QualType qual_type(GetCanonicalQualType(type));
3060     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3061     switch (type_class)
3062     {
3063         case clang::Type::Record:
3064             if (GetCompleteType (type))
3065             {
3066                 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3067                 if (cxx_record_decl)
3068                 {
3069                     if (cxx_record_decl->getNumBases() ||
3070                         cxx_record_decl->isDynamicClass())
3071                         return 0;
3072                 }
3073                 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3074                 if (record_type)
3075                 {
3076                     const clang::RecordDecl *record_decl = record_type->getDecl();
3077                     if (record_decl)
3078                     {
3079                         // We are looking for a structure that contains only floating point types
3080                         clang::RecordDecl::field_iterator field_pos, field_end = record_decl->field_end();
3081                         uint32_t num_fields = 0;
3082                         bool is_hva = false;
3083                         bool is_hfa = false;
3084                         clang::QualType base_qual_type;
3085                         for (field_pos = record_decl->field_begin(); field_pos != field_end; ++field_pos)
3086                         {
3087                             clang::QualType field_qual_type = field_pos->getType();
3088                             if (field_qual_type->isFloatingType())
3089                             {
3090                                 if (field_qual_type->isComplexType())
3091                                     return 0;
3092                                 else
3093                                 {
3094                                     if (num_fields == 0)
3095                                         base_qual_type = field_qual_type;
3096                                     else
3097                                     {
3098                                         if (is_hva)
3099                                             return 0;
3100                                         is_hfa = true;
3101                                         if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
3102                                             return 0;
3103                                     }
3104                                 }
3105                             }
3106                             else if (field_qual_type->isVectorType() || field_qual_type->isExtVectorType())
3107                             {
3108                                 const clang::VectorType *array = field_qual_type.getTypePtr()->getAs<clang::VectorType>();
3109                                 if (array && array->getNumElements() <= 4)
3110                                 {
3111                                     if (num_fields == 0)
3112                                         base_qual_type = array->getElementType();
3113                                     else
3114                                     {
3115                                         if (is_hfa)
3116                                             return 0;
3117                                         is_hva = true;
3118                                         if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr())
3119                                             return 0;
3120                                     }
3121                                 }
3122                                 else
3123                                     return 0;
3124                             }
3125                             else
3126                                 return 0;
3127                             ++num_fields;
3128                         }
3129                         if (base_type_ptr)
3130                             *base_type_ptr = CompilerType (getASTContext(), base_qual_type);
3131                         return num_fields;
3132                     }
3133                 }
3134             }
3135             break;
3136
3137         case clang::Type::Typedef:
3138             return IsHomogeneousAggregate(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), base_type_ptr);
3139
3140         case clang::Type::Auto:
3141             return IsHomogeneousAggregate(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), base_type_ptr);
3142
3143         case clang::Type::Elaborated:
3144             return IsHomogeneousAggregate(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), base_type_ptr);
3145         default:
3146             break;
3147     }
3148     return 0;
3149 }
3150
3151 size_t
3152 ClangASTContext::GetNumberOfFunctionArguments (lldb::opaque_compiler_type_t type)
3153 {
3154     if (type)
3155     {
3156         clang::QualType qual_type (GetCanonicalQualType(type));
3157         const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3158         if (func)
3159             return func->getNumParams();
3160     }
3161     return 0;
3162 }
3163
3164 CompilerType
3165 ClangASTContext::GetFunctionArgumentAtIndex (lldb::opaque_compiler_type_t type, const size_t index)
3166 {
3167     if (type)
3168     {
3169         clang::QualType qual_type (GetCanonicalQualType(type));
3170         const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
3171         if (func)
3172         {
3173             if (index < func->getNumParams())
3174                 return CompilerType(getASTContext(), func->getParamType(index));
3175         }
3176     }
3177     return CompilerType();
3178 }
3179
3180 bool
3181 ClangASTContext::IsFunctionPointerType (lldb::opaque_compiler_type_t type)
3182 {
3183     if (type)
3184     {
3185         clang::QualType qual_type (GetCanonicalQualType(type));
3186
3187         if (qual_type->isFunctionPointerType())
3188             return true;
3189
3190         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3191         switch (type_class)
3192         {
3193             default:
3194                 break;
3195             case clang::Type::Typedef:
3196                 return IsFunctionPointerType (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
3197             case clang::Type::Auto:
3198                 return IsFunctionPointerType (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr());
3199             case clang::Type::Elaborated:
3200                 return IsFunctionPointerType (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
3201             case clang::Type::Paren:
3202                 return IsFunctionPointerType (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
3203
3204             case clang::Type::LValueReference:
3205             case clang::Type::RValueReference:
3206                 {
3207                     const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
3208                     if (reference_type)
3209                         return IsFunctionPointerType(reference_type->getPointeeType().getAsOpaquePtr());
3210                 }
3211                 break;
3212         }
3213     }
3214     return false;
3215
3216 }
3217
3218 bool
3219 ClangASTContext::IsIntegerType (lldb::opaque_compiler_type_t type, bool &is_signed)
3220 {
3221     if (!type)
3222         return false;
3223
3224     clang::QualType qual_type (GetCanonicalQualType(type));
3225     const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
3226
3227     if (builtin_type)
3228     {
3229         if (builtin_type->isInteger())
3230         {
3231             is_signed = builtin_type->isSignedInteger();
3232             return true;
3233         }
3234     }
3235
3236     return false;
3237 }
3238
3239 bool
3240 ClangASTContext::IsPointerType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
3241 {
3242     if (type)
3243     {
3244         clang::QualType qual_type (GetCanonicalQualType(type));
3245         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3246         switch (type_class)
3247         {
3248             case clang::Type::Builtin:
3249                 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
3250             {
3251                 default:
3252                     break;
3253                 case clang::BuiltinType::ObjCId:
3254                 case clang::BuiltinType::ObjCClass:
3255                     return true;
3256             }
3257                 return false;
3258             case clang::Type::ObjCObjectPointer:
3259                 if (pointee_type)
3260                     pointee_type->SetCompilerType (getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType());
3261                 return true;
3262             case clang::Type::BlockPointer:
3263                 if (pointee_type)
3264                     pointee_type->SetCompilerType (getASTContext(), llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType());
3265                 return true;
3266             case clang::Type::Pointer:
3267                 if (pointee_type)
3268                     pointee_type->SetCompilerType (getASTContext(), llvm::cast<clang::PointerType>(qual_type)->getPointeeType());
3269                 return true;
3270             case clang::Type::MemberPointer:
3271                 if (pointee_type)
3272                     pointee_type->SetCompilerType (getASTContext(), llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType());
3273                 return true;
3274             case clang::Type::Typedef:
3275                 return IsPointerType (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), pointee_type);
3276             case clang::Type::Auto:
3277                 return IsPointerType (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), pointee_type);
3278             case clang::Type::Elaborated:
3279                 return IsPointerType (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), pointee_type);
3280             case clang::Type::Paren:
3281                 return IsPointerType (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), pointee_type);
3282             default:
3283                 break;
3284         }
3285     }
3286     if (pointee_type)
3287         pointee_type->Clear();
3288     return false;
3289 }
3290
3291
3292 bool
3293 ClangASTContext::IsPointerOrReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type)
3294 {
3295     if (type)
3296     {
3297         clang::QualType qual_type (GetCanonicalQualType(type));
3298         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3299         switch (type_class)
3300         {
3301             case clang::Type::Builtin:
3302                 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
3303                 {
3304                     default:
3305                         break;
3306                     case clang::BuiltinType::ObjCId:
3307                     case clang::BuiltinType::ObjCClass:
3308                         return true;
3309                 }
3310                 return false;
3311             case clang::Type::ObjCObjectPointer:
3312                 if (pointee_type)
3313                     pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType());
3314                 return true;
3315             case clang::Type::BlockPointer:
3316                 if (pointee_type)
3317                     pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType());
3318                 return true;
3319             case clang::Type::Pointer:
3320                 if (pointee_type)
3321                     pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::PointerType>(qual_type)->getPointeeType());
3322                 return true;
3323             case clang::Type::MemberPointer:
3324                 if (pointee_type)
3325                     pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType());
3326                 return true;
3327             case clang::Type::LValueReference:
3328                 if (pointee_type)
3329                     pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::LValueReferenceType>(qual_type)->desugar());
3330                 return true;
3331             case clang::Type::RValueReference:
3332                 if (pointee_type)
3333                     pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::RValueReferenceType>(qual_type)->desugar());
3334                 return true;
3335             case clang::Type::Typedef:
3336                 return IsPointerOrReferenceType(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), pointee_type);
3337             case clang::Type::Auto:
3338                 return IsPointerOrReferenceType(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), pointee_type);
3339             case clang::Type::Elaborated:
3340                 return IsPointerOrReferenceType(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), pointee_type);
3341             case clang::Type::Paren:
3342                 return IsPointerOrReferenceType(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), pointee_type);
3343             default:
3344                 break;
3345         }
3346     }
3347     if (pointee_type)
3348         pointee_type->Clear();
3349     return false;
3350 }
3351
3352
3353 bool
3354 ClangASTContext::IsReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool* is_rvalue)
3355 {
3356     if (type)
3357     {
3358         clang::QualType qual_type (GetCanonicalQualType(type));
3359         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3360
3361         switch (type_class)
3362         {
3363             case clang::Type::LValueReference:
3364                 if (pointee_type)
3365                     pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::LValueReferenceType>(qual_type)->desugar());
3366                 if (is_rvalue)
3367                     *is_rvalue = false;
3368                 return true;
3369             case clang::Type::RValueReference:
3370                 if (pointee_type)
3371                     pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::RValueReferenceType>(qual_type)->desugar());
3372                 if (is_rvalue)
3373                     *is_rvalue = true;
3374                 return true;
3375             case clang::Type::Typedef:
3376                 return IsReferenceType (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), pointee_type, is_rvalue);
3377             case clang::Type::Auto:
3378                 return IsReferenceType (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), pointee_type, is_rvalue);
3379             case clang::Type::Elaborated:
3380                 return IsReferenceType (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), pointee_type, is_rvalue);
3381             case clang::Type::Paren:
3382                 return IsReferenceType (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), pointee_type, is_rvalue);
3383
3384             default:
3385                 break;
3386         }
3387     }
3388     if (pointee_type)
3389         pointee_type->Clear();
3390     return false;
3391 }
3392
3393 bool
3394 ClangASTContext::IsFloatingPointType (lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex)
3395 {
3396     if (type)
3397     {
3398         clang::QualType qual_type (GetCanonicalQualType(type));
3399
3400         if (const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal()))
3401         {
3402             clang::BuiltinType::Kind kind = BT->getKind();
3403             if (kind >= clang::BuiltinType::Float && kind <= clang::BuiltinType::LongDouble)
3404             {
3405                 count = 1;
3406                 is_complex = false;
3407                 return true;
3408             }
3409         }
3410         else if (const clang::ComplexType *CT = llvm::dyn_cast<clang::ComplexType>(qual_type->getCanonicalTypeInternal()))
3411         {
3412             if (IsFloatingPointType (CT->getElementType().getAsOpaquePtr(), count, is_complex))
3413             {
3414                 count = 2;
3415                 is_complex = true;
3416                 return true;
3417             }
3418         }
3419         else if (const clang::VectorType *VT = llvm::dyn_cast<clang::VectorType>(qual_type->getCanonicalTypeInternal()))
3420         {
3421             if (IsFloatingPointType (VT->getElementType().getAsOpaquePtr(), count, is_complex))
3422             {
3423                 count = VT->getNumElements();
3424                 is_complex = false;
3425                 return true;
3426             }
3427         }
3428     }
3429     count = 0;
3430     is_complex = false;
3431     return false;
3432 }
3433
3434
3435 bool
3436 ClangASTContext::IsDefined(lldb::opaque_compiler_type_t type)
3437 {
3438     if (!type)
3439         return false;
3440
3441     clang::QualType qual_type(GetQualType(type));
3442     const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
3443     if (tag_type)
3444     {
3445         clang::TagDecl *tag_decl = tag_type->getDecl();
3446         if (tag_decl)
3447             return tag_decl->isCompleteDefinition();
3448         return false;
3449     }
3450     else
3451     {
3452         const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
3453         if (objc_class_type)
3454         {
3455             clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3456             if (class_interface_decl)
3457                 return class_interface_decl->getDefinition() != nullptr;
3458             return false;
3459         }
3460     }
3461     return true;
3462 }
3463
3464 bool
3465 ClangASTContext::IsObjCClassType (const CompilerType& type)
3466 {
3467     if (type)
3468     {
3469         clang::QualType qual_type (GetCanonicalQualType(type));
3470
3471         const clang::ObjCObjectPointerType *obj_pointer_type = llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3472
3473         if (obj_pointer_type)
3474             return obj_pointer_type->isObjCClassType();
3475     }
3476     return false;
3477 }
3478
3479 bool
3480 ClangASTContext::IsObjCObjectOrInterfaceType (const CompilerType& type)
3481 {
3482     if (IsClangType(type))
3483         return GetCanonicalQualType(type)->isObjCObjectOrInterfaceType();
3484     return false;
3485 }
3486
3487 bool
3488 ClangASTContext::IsPolymorphicClass (lldb::opaque_compiler_type_t type)
3489 {
3490     if (type)
3491     {
3492         clang::QualType qual_type(GetCanonicalQualType(type));
3493         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3494         switch (type_class)
3495         {
3496             case clang::Type::Record:
3497                 if (GetCompleteType(type))
3498                 {
3499                     const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
3500                     const clang::RecordDecl *record_decl = record_type->getDecl();
3501                     if (record_decl)
3502                     {
3503                         const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
3504                         if (cxx_record_decl)
3505                             return cxx_record_decl->isPolymorphic();
3506                     }
3507                 }
3508                 break;
3509
3510             default:
3511                 break;
3512         }
3513     }
3514     return false;
3515 }
3516
3517 bool
3518 ClangASTContext::IsPossibleDynamicType (lldb::opaque_compiler_type_t type, CompilerType *dynamic_pointee_type,
3519                                            bool check_cplusplus,
3520                                            bool check_objc)
3521 {
3522     clang::QualType pointee_qual_type;
3523     if (type)
3524     {
3525         clang::QualType qual_type (GetCanonicalQualType(type));
3526         bool success = false;
3527         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3528         switch (type_class)
3529         {
3530             case clang::Type::Builtin:
3531                 if (check_objc && llvm::cast<clang::BuiltinType>(qual_type)->getKind() == clang::BuiltinType::ObjCId)
3532                 {
3533                     if (dynamic_pointee_type)
3534                         dynamic_pointee_type->SetCompilerType(this, type);
3535                     return true;
3536                 }
3537                 break;
3538
3539             case clang::Type::ObjCObjectPointer:
3540                 if (check_objc)
3541                 {
3542                     if (dynamic_pointee_type)
3543                         dynamic_pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType());
3544                     return true;
3545                 }
3546                 break;
3547
3548             case clang::Type::Pointer:
3549                 pointee_qual_type = llvm::cast<clang::PointerType>(qual_type)->getPointeeType();
3550                 success = true;
3551                 break;
3552
3553             case clang::Type::LValueReference:
3554             case clang::Type::RValueReference:
3555                 pointee_qual_type = llvm::cast<clang::ReferenceType>(qual_type)->getPointeeType();
3556                 success = true;
3557                 break;
3558
3559             case clang::Type::Typedef:
3560                 return IsPossibleDynamicType (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
3561                                               dynamic_pointee_type,
3562                                               check_cplusplus,
3563                                               check_objc);
3564
3565             case clang::Type::Auto:
3566                 return IsPossibleDynamicType (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(),
3567                                               dynamic_pointee_type,
3568                                               check_cplusplus,
3569                                               check_objc);
3570
3571             case clang::Type::Elaborated:
3572                 return IsPossibleDynamicType (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(),
3573                                               dynamic_pointee_type,
3574                                               check_cplusplus,
3575                                               check_objc);
3576
3577             case clang::Type::Paren:
3578                 return IsPossibleDynamicType (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
3579                                               dynamic_pointee_type,
3580                                               check_cplusplus,
3581                                               check_objc);
3582             default:
3583                 break;
3584         }
3585
3586         if (success)
3587         {
3588             // Check to make sure what we are pointing too is a possible dynamic C++ type
3589             // We currently accept any "void *" (in case we have a class that has been
3590             // watered down to an opaque pointer) and virtual C++ classes.
3591             const clang::Type::TypeClass pointee_type_class = pointee_qual_type.getCanonicalType()->getTypeClass();
3592             switch (pointee_type_class)
3593             {
3594                 case clang::Type::Builtin:
3595                     switch (llvm::cast<clang::BuiltinType>(pointee_qual_type)->getKind())
3596                 {
3597                     case clang::BuiltinType::UnknownAny:
3598                     case clang::BuiltinType::Void:
3599                         if (dynamic_pointee_type)
3600                             dynamic_pointee_type->SetCompilerType(getASTContext(), pointee_qual_type);
3601                         return true;
3602                     default:
3603                         break;
3604                 }
3605                     break;
3606
3607                 case clang::Type::Record:
3608                     if (check_cplusplus)
3609                     {
3610                         clang::CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl();
3611                         if (cxx_record_decl)
3612                         {
3613                             bool is_complete = cxx_record_decl->isCompleteDefinition();
3614
3615                             if (is_complete)
3616                                 success = cxx_record_decl->isDynamicClass();
3617                             else
3618                             {
3619                                 ClangASTMetadata *metadata = ClangASTContext::GetMetadata (getASTContext(), cxx_record_decl);
3620                                 if (metadata)
3621                                     success = metadata->GetIsDynamicCXXType();
3622                                 else
3623                                 {
3624                                     is_complete = CompilerType(getASTContext(), pointee_qual_type).GetCompleteType();
3625                                     if (is_complete)
3626                                         success = cxx_record_decl->isDynamicClass();
3627                                     else
3628                                         success = false;
3629                                 }
3630                             }
3631
3632                             if (success)
3633                             {
3634                                 if (dynamic_pointee_type)
3635                                     dynamic_pointee_type->SetCompilerType(getASTContext(), pointee_qual_type);
3636                                 return true;
3637                             }
3638                         }
3639                     }
3640                     break;
3641
3642                 case clang::Type::ObjCObject:
3643                 case clang::Type::ObjCInterface:
3644                     if (check_objc)
3645                     {
3646                         if (dynamic_pointee_type)
3647                             dynamic_pointee_type->SetCompilerType(getASTContext(), pointee_qual_type);
3648                         return true;
3649                     }
3650                     break;
3651
3652                 default:
3653                     break;
3654             }
3655         }
3656     }
3657     if (dynamic_pointee_type)
3658         dynamic_pointee_type->Clear();
3659     return false;
3660 }
3661
3662
3663 bool
3664 ClangASTContext::IsScalarType (lldb::opaque_compiler_type_t type)
3665 {
3666     if (!type)
3667         return false;
3668
3669     return (GetTypeInfo (type, nullptr) & eTypeIsScalar) != 0;
3670 }
3671
3672 bool
3673 ClangASTContext::IsTypedefType (lldb::opaque_compiler_type_t type)
3674 {
3675     if (!type)
3676         return false;
3677     return GetQualType(type)->getTypeClass() == clang::Type::Typedef;
3678 }
3679
3680 bool
3681 ClangASTContext::IsVoidType (lldb::opaque_compiler_type_t type)
3682 {
3683     if (!type)
3684         return false;
3685     return GetCanonicalQualType(type)->isVoidType();
3686 }
3687
3688 bool
3689 ClangASTContext::SupportsLanguage (lldb::LanguageType language)
3690 {
3691     return ClangASTContextSupportsLanguage(language);
3692 }
3693
3694 bool
3695 ClangASTContext::GetCXXClassName (const CompilerType& type, std::string &class_name)
3696 {
3697     if (type)
3698     {
3699         clang::QualType qual_type (GetCanonicalQualType(type));
3700         if (!qual_type.isNull())
3701         {
3702             clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3703             if (cxx_record_decl)
3704             {
3705                 class_name.assign(cxx_record_decl->getIdentifier()->getNameStart());
3706                 return true;
3707             }
3708         }
3709     }
3710     class_name.clear();
3711     return false;
3712 }
3713
3714
3715 bool
3716 ClangASTContext::IsCXXClassType (const CompilerType& type)
3717 {
3718     if (!type)
3719         return false;
3720
3721     clang::QualType qual_type (GetCanonicalQualType(type));
3722     if (!qual_type.isNull() && qual_type->getAsCXXRecordDecl() != nullptr)
3723         return true;
3724     return false;
3725 }
3726
3727 bool
3728 ClangASTContext::IsBeingDefined (lldb::opaque_compiler_type_t type)
3729 {
3730     if (!type)
3731         return false;
3732     clang::QualType qual_type (GetCanonicalQualType(type));
3733     const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type);
3734     if (tag_type)
3735         return tag_type->isBeingDefined();
3736     return false;
3737 }
3738
3739 bool
3740 ClangASTContext::IsObjCObjectPointerType (const CompilerType& type, CompilerType *class_type_ptr)
3741 {
3742     if (!type)
3743         return false;
3744
3745     clang::QualType qual_type (GetCanonicalQualType(type));
3746
3747     if (!qual_type.isNull() && qual_type->isObjCObjectPointerType())
3748     {
3749         if (class_type_ptr)
3750         {
3751             if (!qual_type->isObjCClassType() &&
3752                 !qual_type->isObjCIdType())
3753             {
3754                 const clang::ObjCObjectPointerType *obj_pointer_type = llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
3755                 if (obj_pointer_type == nullptr)
3756                     class_type_ptr->Clear();
3757                 else
3758                     class_type_ptr->SetCompilerType (type.GetTypeSystem(), clang::QualType(obj_pointer_type->getInterfaceType(), 0).getAsOpaquePtr());
3759             }
3760         }
3761         return true;
3762     }
3763     if (class_type_ptr)
3764         class_type_ptr->Clear();
3765     return false;
3766 }
3767
3768 bool
3769 ClangASTContext::GetObjCClassName (const CompilerType& type, std::string &class_name)
3770 {
3771     if (!type)
3772         return false;
3773
3774     clang::QualType qual_type (GetCanonicalQualType(type));
3775
3776     const clang::ObjCObjectType *object_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
3777     if (object_type)
3778     {
3779         const clang::ObjCInterfaceDecl *interface = object_type->getInterface();
3780         if (interface)
3781         {
3782             class_name = interface->getNameAsString();
3783             return true;
3784         }
3785     }
3786     return false;
3787 }
3788
3789
3790 //----------------------------------------------------------------------
3791 // Type Completion
3792 //----------------------------------------------------------------------
3793
3794 bool
3795 ClangASTContext::GetCompleteType (lldb::opaque_compiler_type_t type)
3796 {
3797     if (!type)
3798         return false;
3799     const bool allow_completion = true;
3800     return GetCompleteQualType (getASTContext(), GetQualType(type), allow_completion);
3801 }
3802
3803 ConstString
3804 ClangASTContext::GetTypeName (lldb::opaque_compiler_type_t type)
3805 {
3806     std::string type_name;
3807     if (type)
3808     {
3809         clang::PrintingPolicy printing_policy (getASTContext()->getPrintingPolicy());
3810         clang::QualType qual_type(GetQualType(type));
3811         printing_policy.SuppressTagKeyword = true;
3812         printing_policy.LangOpts.WChar = true;
3813         const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>();
3814         if (typedef_type)
3815         {
3816             const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
3817             type_name = typedef_decl->getQualifiedNameAsString();
3818         }
3819         else
3820         {
3821             type_name = qual_type.getAsString(printing_policy);
3822         }
3823     }
3824     return ConstString(type_name);
3825 }
3826
3827 uint32_t
3828 ClangASTContext::GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type)
3829 {
3830     if (!type)
3831         return 0;
3832
3833     if (pointee_or_element_clang_type)
3834         pointee_or_element_clang_type->Clear();
3835
3836     clang::QualType qual_type (GetQualType(type));
3837
3838     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3839     switch (type_class)
3840     {
3841         case clang::Type::Builtin:
3842         {
3843             const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
3844
3845             uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
3846             switch (builtin_type->getKind())
3847             {
3848                 case clang::BuiltinType::ObjCId:
3849                 case clang::BuiltinType::ObjCClass:
3850                     if (pointee_or_element_clang_type)
3851                         pointee_or_element_clang_type->SetCompilerType(getASTContext(), getASTContext()->ObjCBuiltinClassTy);
3852                     builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3853                     break;
3854
3855                 case clang::BuiltinType::ObjCSel:
3856                     if (pointee_or_element_clang_type)
3857                         pointee_or_element_clang_type->SetCompilerType(getASTContext(), getASTContext()->CharTy);
3858                     builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
3859                     break;
3860
3861                 case clang::BuiltinType::Bool:
3862                 case clang::BuiltinType::Char_U:
3863                 case clang::BuiltinType::UChar:
3864                 case clang::BuiltinType::WChar_U:
3865                 case clang::BuiltinType::Char16:
3866                 case clang::BuiltinType::Char32:
3867                 case clang::BuiltinType::UShort:
3868                 case clang::BuiltinType::UInt:
3869                 case clang::BuiltinType::ULong:
3870                 case clang::BuiltinType::ULongLong:
3871                 case clang::BuiltinType::UInt128:
3872                 case clang::BuiltinType::Char_S:
3873                 case clang::BuiltinType::SChar:
3874                 case clang::BuiltinType::WChar_S:
3875                 case clang::BuiltinType::Short:
3876                 case clang::BuiltinType::Int:
3877                 case clang::BuiltinType::Long:
3878                 case clang::BuiltinType::LongLong:
3879                 case clang::BuiltinType::Int128:
3880                 case clang::BuiltinType::Float:
3881                 case clang::BuiltinType::Double:
3882                 case clang::BuiltinType::LongDouble:
3883                     builtin_type_flags |= eTypeIsScalar;
3884                     if (builtin_type->isInteger())
3885                     {
3886                         builtin_type_flags |= eTypeIsInteger;
3887                         if (builtin_type->isSignedInteger())
3888                             builtin_type_flags |= eTypeIsSigned;
3889                     }
3890                     else if (builtin_type->isFloatingPoint())
3891                         builtin_type_flags |= eTypeIsFloat;
3892                     break;
3893                 default:
3894                     break;
3895             }
3896             return builtin_type_flags;
3897         }
3898
3899         case clang::Type::BlockPointer:
3900             if (pointee_or_element_clang_type)
3901                 pointee_or_element_clang_type->SetCompilerType(getASTContext(), qual_type->getPointeeType());
3902             return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
3903
3904         case clang::Type::Complex:
3905         {
3906             uint32_t complex_type_flags = eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex;
3907             const clang::ComplexType *complex_type = llvm::dyn_cast<clang::ComplexType>(qual_type->getCanonicalTypeInternal());
3908             if (complex_type)
3909             {
3910                 clang::QualType complex_element_type (complex_type->getElementType());
3911                 if (complex_element_type->isIntegerType())
3912                     complex_type_flags |= eTypeIsFloat;
3913                 else if (complex_element_type->isFloatingType())
3914                     complex_type_flags |= eTypeIsInteger;
3915             }
3916             return complex_type_flags;
3917         }
3918             break;
3919
3920         case clang::Type::ConstantArray:
3921         case clang::Type::DependentSizedArray:
3922         case clang::Type::IncompleteArray:
3923         case clang::Type::VariableArray:
3924             if (pointee_or_element_clang_type)
3925                 pointee_or_element_clang_type->SetCompilerType(getASTContext(), llvm::cast<clang::ArrayType>(qual_type.getTypePtr())->getElementType());
3926             return eTypeHasChildren | eTypeIsArray;
3927
3928         case clang::Type::DependentName:                    return 0;
3929         case clang::Type::DependentSizedExtVector:          return eTypeHasChildren | eTypeIsVector;
3930         case clang::Type::DependentTemplateSpecialization:  return eTypeIsTemplate;
3931         case clang::Type::Decltype:                         return 0;
3932
3933         case clang::Type::Enum:
3934             if (pointee_or_element_clang_type)
3935                 pointee_or_element_clang_type->SetCompilerType(getASTContext(), llvm::cast<clang::EnumType>(qual_type)->getDecl()->getIntegerType());
3936             return eTypeIsEnumeration | eTypeHasValue;
3937
3938         case clang::Type::Auto:
3939             return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetTypeInfo (pointee_or_element_clang_type);
3940         case clang::Type::Elaborated:
3941             return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetTypeInfo (pointee_or_element_clang_type);
3942         case clang::Type::Paren:
3943             return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetTypeInfo (pointee_or_element_clang_type);
3944
3945         case clang::Type::FunctionProto:                    return eTypeIsFuncPrototype | eTypeHasValue;
3946         case clang::Type::FunctionNoProto:                  return eTypeIsFuncPrototype | eTypeHasValue;
3947         case clang::Type::InjectedClassName:                return 0;
3948
3949         case clang::Type::LValueReference:
3950         case clang::Type::RValueReference:
3951             if (pointee_or_element_clang_type)
3952                 pointee_or_element_clang_type->SetCompilerType(getASTContext(), llvm::cast<clang::ReferenceType>(qual_type.getTypePtr())->getPointeeType());
3953             return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
3954
3955         case clang::Type::MemberPointer:                    return eTypeIsPointer   | eTypeIsMember | eTypeHasValue;
3956
3957         case clang::Type::ObjCObjectPointer:
3958             if (pointee_or_element_clang_type)
3959                 pointee_or_element_clang_type->SetCompilerType(getASTContext(), qual_type->getPointeeType());
3960             return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | eTypeHasValue;
3961
3962         case clang::Type::ObjCObject:                       return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
3963         case clang::Type::ObjCInterface:                    return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
3964
3965         case clang::Type::Pointer:
3966             if (pointee_or_element_clang_type)
3967                 pointee_or_element_clang_type->SetCompilerType(getASTContext(), qual_type->getPointeeType());
3968             return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
3969
3970         case clang::Type::Record:
3971             if (qual_type->getAsCXXRecordDecl())
3972                 return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
3973             else
3974                 return eTypeHasChildren | eTypeIsStructUnion;
3975             break;
3976         case clang::Type::SubstTemplateTypeParm:            return eTypeIsTemplate;
3977         case clang::Type::TemplateTypeParm:                 return eTypeIsTemplate;
3978         case clang::Type::TemplateSpecialization:           return eTypeIsTemplate;
3979
3980         case clang::Type::Typedef:
3981             return eTypeIsTypedef | CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTypeInfo (pointee_or_element_clang_type);
3982         case clang::Type::TypeOfExpr:                       return 0;
3983         case clang::Type::TypeOf:                           return 0;
3984         case clang::Type::UnresolvedUsing:                  return 0;
3985
3986         case clang::Type::ExtVector:
3987         case clang::Type::Vector:
3988         {
3989             uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector;
3990             const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>(qual_type->getCanonicalTypeInternal());
3991             if (vector_type)
3992             {
3993                 if (vector_type->isIntegerType())
3994                     vector_type_flags |= eTypeIsFloat;
3995                 else if (vector_type->isFloatingType())
3996                     vector_type_flags |= eTypeIsInteger;
3997             }
3998             return vector_type_flags;
3999         }
4000         default:                                            return 0;
4001     }
4002     return 0;
4003 }
4004
4005
4006
4007 lldb::LanguageType
4008 ClangASTContext::GetMinimumLanguage (lldb::opaque_compiler_type_t type)
4009 {
4010     if (!type)
4011         return lldb::eLanguageTypeC;
4012
4013     // If the type is a reference, then resolve it to what it refers to first:
4014     clang::QualType qual_type (GetCanonicalQualType(type).getNonReferenceType());
4015     if (qual_type->isAnyPointerType())
4016     {
4017         if (qual_type->isObjCObjectPointerType())
4018             return lldb::eLanguageTypeObjC;
4019
4020         clang::QualType pointee_type (qual_type->getPointeeType());
4021         if (pointee_type->getPointeeCXXRecordDecl() != nullptr)
4022             return lldb::eLanguageTypeC_plus_plus;
4023         if (pointee_type->isObjCObjectOrInterfaceType())
4024             return lldb::eLanguageTypeObjC;
4025         if (pointee_type->isObjCClassType())
4026             return lldb::eLanguageTypeObjC;
4027         if (pointee_type.getTypePtr() == getASTContext()->ObjCBuiltinIdTy.getTypePtr())
4028             return lldb::eLanguageTypeObjC;
4029     }
4030     else
4031     {
4032         if (qual_type->isObjCObjectOrInterfaceType())
4033             return lldb::eLanguageTypeObjC;
4034         if (qual_type->getAsCXXRecordDecl())
4035             return lldb::eLanguageTypeC_plus_plus;
4036         switch (qual_type->getTypeClass())
4037         {
4038             default:
4039                 break;
4040             case clang::Type::Builtin:
4041                 switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
4042             {
4043                 default:
4044                 case clang::BuiltinType::Void:
4045                 case clang::BuiltinType::Bool:
4046                 case clang::BuiltinType::Char_U:
4047                 case clang::BuiltinType::UChar:
4048                 case clang::BuiltinType::WChar_U:
4049                 case clang::BuiltinType::Char16:
4050                 case clang::BuiltinType::Char32:
4051                 case clang::BuiltinType::UShort:
4052                 case clang::BuiltinType::UInt:
4053                 case clang::BuiltinType::ULong:
4054                 case clang::BuiltinType::ULongLong:
4055                 case clang::BuiltinType::UInt128:
4056                 case clang::BuiltinType::Char_S:
4057                 case clang::BuiltinType::SChar:
4058                 case clang::BuiltinType::WChar_S:
4059                 case clang::BuiltinType::Short:
4060                 case clang::BuiltinType::Int:
4061                 case clang::BuiltinType::Long:
4062                 case clang::BuiltinType::LongLong:
4063                 case clang::BuiltinType::Int128:
4064                 case clang::BuiltinType::Float:
4065                 case clang::BuiltinType::Double:
4066                 case clang::BuiltinType::LongDouble:
4067                     break;
4068
4069                 case clang::BuiltinType::NullPtr:
4070                     return eLanguageTypeC_plus_plus;
4071
4072                 case clang::BuiltinType::ObjCId:
4073                 case clang::BuiltinType::ObjCClass:
4074                 case clang::BuiltinType::ObjCSel:
4075                     return eLanguageTypeObjC;
4076
4077                 case clang::BuiltinType::Dependent:
4078                 case clang::BuiltinType::Overload:
4079                 case clang::BuiltinType::BoundMember:
4080                 case clang::BuiltinType::UnknownAny:
4081                     break;
4082             }
4083                 break;
4084             case clang::Type::Typedef:
4085                 return CompilerType(getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetMinimumLanguage();
4086         }
4087     }
4088     return lldb::eLanguageTypeC;
4089 }
4090
4091 lldb::TypeClass
4092 ClangASTContext::GetTypeClass (lldb::opaque_compiler_type_t type)
4093 {
4094     if (!type)
4095         return lldb::eTypeClassInvalid;
4096
4097     clang::QualType qual_type(GetQualType(type));
4098
4099     switch (qual_type->getTypeClass())
4100     {
4101         case clang::Type::UnaryTransform:           break;
4102         case clang::Type::FunctionNoProto:          return lldb::eTypeClassFunction;
4103         case clang::Type::FunctionProto:            return lldb::eTypeClassFunction;
4104         case clang::Type::IncompleteArray:          return lldb::eTypeClassArray;
4105         case clang::Type::VariableArray:            return lldb::eTypeClassArray;
4106         case clang::Type::ConstantArray:            return lldb::eTypeClassArray;
4107         case clang::Type::DependentSizedArray:      return lldb::eTypeClassArray;
4108         case clang::Type::DependentSizedExtVector:  return lldb::eTypeClassVector;
4109         case clang::Type::ExtVector:                return lldb::eTypeClassVector;
4110         case clang::Type::Vector:                   return lldb::eTypeClassVector;
4111         case clang::Type::Builtin:                  return lldb::eTypeClassBuiltin;
4112         case clang::Type::ObjCObjectPointer:        return lldb::eTypeClassObjCObjectPointer;
4113         case clang::Type::BlockPointer:             return lldb::eTypeClassBlockPointer;
4114         case clang::Type::Pointer:                  return lldb::eTypeClassPointer;
4115         case clang::Type::LValueReference:          return lldb::eTypeClassReference;
4116         case clang::Type::RValueReference:          return lldb::eTypeClassReference;
4117         case clang::Type::MemberPointer:            return lldb::eTypeClassMemberPointer;
4118         case clang::Type::Complex:
4119             if (qual_type->isComplexType())
4120                 return lldb::eTypeClassComplexFloat;
4121             else
4122                 return lldb::eTypeClassComplexInteger;
4123         case clang::Type::ObjCObject:               return lldb::eTypeClassObjCObject;
4124         case clang::Type::ObjCInterface:            return lldb::eTypeClassObjCInterface;
4125         case clang::Type::Record:
4126         {
4127             const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4128             const clang::RecordDecl *record_decl = record_type->getDecl();
4129             if (record_decl->isUnion())
4130                 return lldb::eTypeClassUnion;
4131             else if (record_decl->isStruct())
4132                 return lldb::eTypeClassStruct;
4133             else
4134                 return lldb::eTypeClassClass;
4135         }
4136             break;
4137         case clang::Type::Enum:                     return lldb::eTypeClassEnumeration;
4138         case clang::Type::Typedef:                  return lldb::eTypeClassTypedef;
4139         case clang::Type::UnresolvedUsing:          break;
4140         case clang::Type::Paren:
4141             return CompilerType(getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetTypeClass();
4142         case clang::Type::Auto:
4143             return CompilerType(getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetTypeClass();
4144         case clang::Type::Elaborated:
4145             return CompilerType(getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetTypeClass();
4146
4147         case clang::Type::Attributed:               break;
4148         case clang::Type::TemplateTypeParm:         break;
4149         case clang::Type::SubstTemplateTypeParm:    break;
4150         case clang::Type::SubstTemplateTypeParmPack:break;
4151         case clang::Type::InjectedClassName:        break;
4152         case clang::Type::DependentName:            break;
4153         case clang::Type::DependentTemplateSpecialization: break;
4154         case clang::Type::PackExpansion:            break;
4155
4156         case clang::Type::TypeOfExpr:               break;
4157         case clang::Type::TypeOf:                   break;
4158         case clang::Type::Decltype:                 break;
4159         case clang::Type::TemplateSpecialization:   break;
4160         case clang::Type::Atomic:                   break;
4161         case clang::Type::Pipe:                     break;
4162
4163             // pointer type decayed from an array or function type.
4164         case clang::Type::Decayed:                  break;
4165         case clang::Type::Adjusted:                 break;
4166     }
4167     // We don't know hot to display this type...
4168     return lldb::eTypeClassOther;
4169
4170 }
4171
4172 unsigned
4173 ClangASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type)
4174 {
4175     if (type)
4176         return GetQualType(type).getQualifiers().getCVRQualifiers();
4177     return 0;
4178 }
4179
4180 //----------------------------------------------------------------------
4181 // Creating related types
4182 //----------------------------------------------------------------------
4183
4184 CompilerType
4185 ClangASTContext::GetArrayElementType (lldb::opaque_compiler_type_t type, uint64_t *stride)
4186 {
4187     if (type)
4188     {
4189         clang::QualType qual_type(GetCanonicalQualType(type));
4190
4191         const clang::Type *array_eletype = qual_type.getTypePtr()->getArrayElementTypeNoTypeQual();
4192
4193         if (!array_eletype)
4194             return CompilerType();
4195
4196         CompilerType element_type (getASTContext(), array_eletype->getCanonicalTypeUnqualified());
4197
4198         // TODO: the real stride will be >= this value.. find the real one!
4199         if (stride)
4200             *stride = element_type.GetByteSize(nullptr);
4201
4202         return element_type;
4203
4204     }
4205     return CompilerType();
4206 }
4207
4208 CompilerType
4209 ClangASTContext::GetCanonicalType (lldb::opaque_compiler_type_t type)
4210 {
4211     if (type)
4212         return CompilerType (getASTContext(), GetCanonicalQualType(type));
4213     return CompilerType();
4214 }
4215
4216 static clang::QualType
4217 GetFullyUnqualifiedType_Impl (clang::ASTContext *ast, clang::QualType qual_type)
4218 {
4219     if (qual_type->isPointerType())
4220         qual_type = ast->getPointerType(GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType()));
4221     else
4222         qual_type = qual_type.getUnqualifiedType();
4223     qual_type.removeLocalConst();
4224     qual_type.removeLocalRestrict();
4225     qual_type.removeLocalVolatile();
4226     return qual_type;
4227 }
4228
4229 CompilerType
4230 ClangASTContext::GetFullyUnqualifiedType (lldb::opaque_compiler_type_t type)
4231 {
4232     if (type)
4233         return CompilerType(getASTContext(), GetFullyUnqualifiedType_Impl(getASTContext(), GetQualType(type)));
4234     return CompilerType();
4235 }
4236
4237
4238 int
4239 ClangASTContext::GetFunctionArgumentCount (lldb::opaque_compiler_type_t type)
4240 {
4241     if (type)
4242     {
4243         const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType(type));
4244         if (func)
4245             return func->getNumParams();
4246     }
4247     return -1;
4248 }
4249
4250 CompilerType
4251 ClangASTContext::GetFunctionArgumentTypeAtIndex (lldb::opaque_compiler_type_t type, size_t idx)
4252 {
4253     if (type)
4254     {
4255         const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(GetQualType(type));
4256         if (func)
4257         {
4258             const uint32_t num_args = func->getNumParams();
4259             if (idx < num_args)
4260                 return CompilerType(getASTContext(), func->getParamType(idx));
4261         }
4262     }
4263     return CompilerType();
4264 }
4265
4266 CompilerType
4267 ClangASTContext::GetFunctionReturnType (lldb::opaque_compiler_type_t type)
4268 {
4269     if (type)
4270     {
4271         clang::QualType qual_type(GetQualType(type));
4272         const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
4273         if (func)
4274             return CompilerType(getASTContext(), func->getReturnType());
4275     }
4276     return CompilerType();
4277 }
4278
4279 size_t
4280 ClangASTContext::GetNumMemberFunctions (lldb::opaque_compiler_type_t type)
4281 {
4282     size_t num_functions = 0;
4283     if (type)
4284     {
4285         clang::QualType qual_type(GetCanonicalQualType(type));
4286         switch (qual_type->getTypeClass()) {
4287             case clang::Type::Record:
4288                 if (GetCompleteQualType (getASTContext(), qual_type))
4289                 {
4290                     const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4291                     const clang::RecordDecl *record_decl = record_type->getDecl();
4292                     assert(record_decl);
4293                     const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4294                     if (cxx_record_decl)
4295                         num_functions = std::distance(cxx_record_decl->method_begin(), cxx_record_decl->method_end());
4296                 }
4297                 break;
4298
4299             case clang::Type::ObjCObjectPointer:
4300                 if (GetCompleteType(type))
4301                 {
4302                     const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
4303                     if (objc_class_type)
4304                     {
4305                         clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
4306                         if (class_interface_decl)
4307                             num_functions = std::distance(class_interface_decl->meth_begin(), class_interface_decl->meth_end());
4308                     }
4309                 }
4310                 break;
4311
4312             case clang::Type::ObjCObject:
4313             case clang::Type::ObjCInterface:
4314                 if (GetCompleteType(type))
4315                 {
4316                     const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4317                     if (objc_class_type)
4318                     {
4319                         clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
4320                         if (class_interface_decl)
4321                             num_functions = std::distance(class_interface_decl->meth_begin(), class_interface_decl->meth_end());
4322                     }
4323                 }
4324                 break;
4325
4326
4327             case clang::Type::Typedef:
4328                 return CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumMemberFunctions();
4329
4330             case clang::Type::Auto:
4331                 return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetNumMemberFunctions();
4332
4333             case clang::Type::Elaborated:
4334                 return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumMemberFunctions();
4335
4336             case clang::Type::Paren:
4337                 return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumMemberFunctions();
4338
4339             default:
4340                 break;
4341         }
4342     }
4343     return num_functions;
4344 }
4345
4346 TypeMemberFunctionImpl
4347 ClangASTContext::GetMemberFunctionAtIndex (lldb::opaque_compiler_type_t type, size_t idx)
4348 {
4349     std::string name;
4350     MemberFunctionKind kind(MemberFunctionKind::eMemberFunctionKindUnknown);
4351     CompilerType clang_type;
4352     CompilerDecl clang_decl;
4353     if (type)
4354     {
4355         clang::QualType qual_type(GetCanonicalQualType(type));
4356         switch (qual_type->getTypeClass()) {
4357             case clang::Type::Record:
4358                 if (GetCompleteQualType (getASTContext(), qual_type))
4359                 {
4360                     const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
4361                     const clang::RecordDecl *record_decl = record_type->getDecl();
4362                     assert(record_decl);
4363                     const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
4364                     if (cxx_record_decl)
4365                     {
4366                         auto method_iter = cxx_record_decl->method_begin();
4367                         auto method_end = cxx_record_decl->method_end();
4368                         if (idx < static_cast<size_t>(std::distance(method_iter, method_end)))
4369                         {
4370                             std::advance(method_iter, idx);
4371                             clang::CXXMethodDecl *cxx_method_decl = method_iter->getCanonicalDecl();
4372                             if (cxx_method_decl)
4373                             {
4374                                 name = cxx_method_decl->getDeclName().getAsString();
4375                                 if (cxx_method_decl->isStatic())
4376                                     kind = lldb::eMemberFunctionKindStaticMethod;
4377                                 else if (llvm::isa<clang::CXXConstructorDecl>(cxx_method_decl))
4378                                     kind = lldb::eMemberFunctionKindConstructor;
4379                                 else if (llvm::isa<clang::CXXDestructorDecl>(cxx_method_decl))
4380                                     kind = lldb::eMemberFunctionKindDestructor;
4381                                 else
4382                                     kind = lldb::eMemberFunctionKindInstanceMethod;
4383                                 clang_type = CompilerType(this, cxx_method_decl->getType().getAsOpaquePtr());
4384                                 clang_decl = CompilerDecl(this, cxx_method_decl);
4385                             }
4386                         }
4387                     }
4388                 }
4389                 break;
4390
4391             case clang::Type::ObjCObjectPointer:
4392                 if (GetCompleteType(type))
4393                 {
4394                     const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
4395                     if (objc_class_type)
4396                     {
4397                         clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
4398                         if (class_interface_decl)
4399                         {
4400                             auto method_iter = class_interface_decl->meth_begin();
4401                             auto method_end = class_interface_decl->meth_end();
4402                             if (idx < static_cast<size_t>(std::distance(method_iter, method_end)))
4403                             {
4404                                 std::advance(method_iter, idx);
4405                                 clang::ObjCMethodDecl *objc_method_decl = method_iter->getCanonicalDecl();
4406                                 if (objc_method_decl)
4407                                 {
4408                                     clang_decl = CompilerDecl(this, objc_method_decl);
4409                                     name = objc_method_decl->getSelector().getAsString();
4410                                     if (objc_method_decl->isClassMethod())
4411                                         kind = lldb::eMemberFunctionKindStaticMethod;
4412                                     else
4413                                         kind = lldb::eMemberFunctionKindInstanceMethod;
4414                                 }
4415                             }
4416                         }
4417                     }
4418                 }
4419                 break;
4420
4421             case clang::Type::ObjCObject:
4422             case clang::Type::ObjCInterface:
4423                 if (GetCompleteType(type))
4424                 {
4425                     const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
4426                     if (objc_class_type)
4427                     {
4428                         clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
4429                         if (class_interface_decl)
4430                         {
4431                             auto method_iter = class_interface_decl->meth_begin();
4432                             auto method_end = class_interface_decl->meth_end();
4433                             if (idx < static_cast<size_t>(std::distance(method_iter, method_end)))
4434                             {
4435                                 std::advance(method_iter, idx);
4436                                 clang::ObjCMethodDecl *objc_method_decl = method_iter->getCanonicalDecl();
4437                                 if (objc_method_decl)
4438                                 {
4439                                     clang_decl = CompilerDecl(this, objc_method_decl);
4440                                     name = objc_method_decl->getSelector().getAsString();
4441                                     if (objc_method_decl->isClassMethod())
4442                                         kind = lldb::eMemberFunctionKindStaticMethod;
4443                                     else
4444                                         kind = lldb::eMemberFunctionKindInstanceMethod;
4445                                 }
4446                             }
4447                         }
4448                     }
4449                 }
4450                 break;
4451
4452             case clang::Type::Typedef:
4453                 return GetMemberFunctionAtIndex(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), idx);
4454
4455             case clang::Type::Auto:
4456                 return GetMemberFunctionAtIndex(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), idx);
4457
4458             case clang::Type::Elaborated:
4459                 return GetMemberFunctionAtIndex(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), idx);
4460
4461             case clang::Type::Paren:
4462                 return GetMemberFunctionAtIndex(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), idx);
4463
4464             default:
4465                 break;
4466         }
4467     }
4468
4469     if (kind == eMemberFunctionKindUnknown)
4470         return TypeMemberFunctionImpl();
4471     else
4472         return TypeMemberFunctionImpl(clang_type, clang_decl, name, kind);
4473 }
4474
4475 CompilerType
4476 ClangASTContext::GetNonReferenceType (lldb::opaque_compiler_type_t type)
4477 {
4478     if (type)
4479         return CompilerType(getASTContext(), GetQualType(type).getNonReferenceType());
4480     return CompilerType();
4481 }
4482
4483 CompilerType
4484 ClangASTContext::CreateTypedefType (const CompilerType& type,
4485                                     const char *typedef_name,
4486                                     const CompilerDeclContext &compiler_decl_ctx)
4487 {
4488     if (type && typedef_name && typedef_name[0])
4489     {
4490         ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
4491         if (!ast)
4492             return CompilerType();
4493         clang::ASTContext* clang_ast = ast->getASTContext();
4494         clang::QualType qual_type (GetQualType(type));
4495
4496         clang::DeclContext *decl_ctx = ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx);
4497         if (decl_ctx == nullptr)
4498             decl_ctx = ast->getASTContext()->getTranslationUnitDecl();
4499
4500         clang::TypedefDecl *decl = clang::TypedefDecl::Create (*clang_ast,
4501                                                                decl_ctx,
4502                                                                clang::SourceLocation(),
4503                                                                clang::SourceLocation(),
4504                                                                &clang_ast->Idents.get(typedef_name),
4505                                                                clang_ast->getTrivialTypeSourceInfo(qual_type));
4506
4507         decl->setAccess(clang::AS_public); // TODO respect proper access specifier
4508
4509         // Get a uniqued clang::QualType for the typedef decl type
4510         return CompilerType (clang_ast, clang_ast->getTypedefType (decl));
4511     }
4512     return CompilerType();
4513
4514 }
4515
4516 CompilerType
4517 ClangASTContext::GetPointeeType (lldb::opaque_compiler_type_t type)
4518 {
4519     if (type)
4520     {
4521         clang::QualType qual_type(GetQualType(type));
4522         return CompilerType (getASTContext(), qual_type.getTypePtr()->getPointeeType());
4523     }
4524     return CompilerType();
4525 }
4526
4527 CompilerType
4528 ClangASTContext::GetPointerType (lldb::opaque_compiler_type_t type)
4529 {
4530     if (type)
4531     {
4532         clang::QualType qual_type (GetQualType(type));
4533
4534         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4535         switch (type_class)
4536         {
4537             case clang::Type::ObjCObject:
4538             case clang::Type::ObjCInterface:
4539                 return CompilerType(getASTContext(), getASTContext()->getObjCObjectPointerType(qual_type));
4540
4541             default:
4542                 return CompilerType(getASTContext(), getASTContext()->getPointerType(qual_type));
4543         }
4544     }
4545     return CompilerType();
4546 }
4547
4548
4549 CompilerType
4550 ClangASTContext::GetLValueReferenceType (lldb::opaque_compiler_type_t type)
4551 {
4552     if (type)
4553         return CompilerType(this, getASTContext()->getLValueReferenceType(GetQualType(type)).getAsOpaquePtr());
4554     else
4555         return CompilerType();
4556 }
4557
4558 CompilerType
4559 ClangASTContext::GetRValueReferenceType (lldb::opaque_compiler_type_t type)
4560 {
4561     if (type)
4562         return CompilerType(this, getASTContext()->getRValueReferenceType(GetQualType(type)).getAsOpaquePtr());
4563     else
4564         return CompilerType();
4565 }
4566
4567 CompilerType
4568 ClangASTContext::AddConstModifier (lldb::opaque_compiler_type_t type)
4569 {
4570     if (type)
4571     {
4572         clang::QualType result(GetQualType(type));
4573         result.addConst();
4574         return CompilerType (this, result.getAsOpaquePtr());
4575     }
4576     return CompilerType();
4577 }
4578
4579 CompilerType
4580 ClangASTContext::AddVolatileModifier (lldb::opaque_compiler_type_t type)
4581 {
4582     if (type)
4583     {
4584         clang::QualType result(GetQualType(type));
4585         result.addVolatile();
4586         return CompilerType (this, result.getAsOpaquePtr());
4587     }
4588     return CompilerType();
4589
4590 }
4591
4592 CompilerType
4593 ClangASTContext::AddRestrictModifier (lldb::opaque_compiler_type_t type)
4594 {
4595     if (type)
4596     {
4597         clang::QualType result(GetQualType(type));
4598         result.addRestrict();
4599         return CompilerType (this, result.getAsOpaquePtr());
4600     }
4601     return CompilerType();
4602
4603 }
4604
4605 CompilerType
4606 ClangASTContext::CreateTypedef (lldb::opaque_compiler_type_t type, const char *typedef_name, const CompilerDeclContext &compiler_decl_ctx)
4607 {
4608     if (type)
4609     {
4610         clang::ASTContext* clang_ast = getASTContext();
4611         clang::QualType qual_type (GetQualType(type));
4612
4613         clang::DeclContext *decl_ctx = ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx);
4614         if (decl_ctx == nullptr)
4615             decl_ctx = getASTContext()->getTranslationUnitDecl();
4616
4617         clang::TypedefDecl *decl = clang::TypedefDecl::Create (*clang_ast,
4618                                                                decl_ctx,
4619                                                                clang::SourceLocation(),
4620                                                                clang::SourceLocation(),
4621                                                                &clang_ast->Idents.get(typedef_name),
4622                                                                clang_ast->getTrivialTypeSourceInfo(qual_type));
4623
4624         decl->setAccess(clang::AS_public); // TODO respect proper access specifier
4625
4626         // Get a uniqued clang::QualType for the typedef decl type
4627         return CompilerType (this, clang_ast->getTypedefType (decl).getAsOpaquePtr());
4628
4629     }
4630     return CompilerType();
4631
4632 }
4633
4634 CompilerType
4635 ClangASTContext::GetTypedefedType (lldb::opaque_compiler_type_t type)
4636 {
4637     if (type)
4638     {
4639         const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(GetQualType(type));
4640         if (typedef_type)
4641             return CompilerType (getASTContext(), typedef_type->getDecl()->getUnderlyingType());
4642     }
4643     return CompilerType();
4644 }
4645
4646 CompilerType
4647 ClangASTContext::RemoveFastQualifiers (const CompilerType& type)
4648 {
4649     if (IsClangType(type))
4650     {
4651         clang::QualType qual_type(GetQualType(type));
4652         qual_type.getQualifiers().removeFastQualifiers();
4653         return CompilerType (type.GetTypeSystem(), qual_type.getAsOpaquePtr());
4654     }
4655     return type;
4656 }
4657
4658
4659 //----------------------------------------------------------------------
4660 // Create related types using the current type's AST
4661 //----------------------------------------------------------------------
4662
4663 CompilerType
4664 ClangASTContext::GetBasicTypeFromAST (lldb::BasicType basic_type)
4665 {
4666     return ClangASTContext::GetBasicType(getASTContext(), basic_type);
4667 }
4668 //----------------------------------------------------------------------
4669 // Exploring the type
4670 //----------------------------------------------------------------------
4671
4672 uint64_t
4673 ClangASTContext::GetBitSize (lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope)
4674 {
4675     if (GetCompleteType (type))
4676     {
4677         clang::QualType qual_type(GetCanonicalQualType(type));
4678         switch (qual_type->getTypeClass())
4679         {
4680             case clang::Type::ObjCInterface:
4681             case clang::Type::ObjCObject:
4682             {
4683                 ExecutionContext exe_ctx (exe_scope);
4684                 Process *process = exe_ctx.GetProcessPtr();
4685                 if (process)
4686                 {
4687                     ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
4688                     if (objc_runtime)
4689                     {
4690                         uint64_t bit_size = 0;
4691                         if (objc_runtime->GetTypeBitSize(CompilerType(getASTContext(), qual_type), bit_size))
4692                             return bit_size;
4693                     }
4694                 }
4695                 else
4696                 {
4697                     static bool g_printed = false;
4698                     if (!g_printed)
4699                     {
4700                         StreamString s;
4701                         DumpTypeDescription(type, &s);
4702
4703                         llvm::outs() << "warning: trying to determine the size of type ";
4704                         llvm::outs() << s.GetString() << "\n";
4705                         llvm::outs() << "without a valid ExecutionContext. this is not reliable. please file a bug against LLDB.\n";
4706                         llvm::outs() << "backtrace:\n";
4707                         llvm::sys::PrintStackTrace(llvm::outs());
4708                         llvm::outs() << "\n";
4709                         g_printed = true;
4710                     }
4711                 }
4712             }
4713                 // fallthrough
4714             default:
4715                 const uint32_t bit_size = getASTContext()->getTypeSize (qual_type);
4716                 if (bit_size == 0)
4717                 {
4718                     if (qual_type->isIncompleteArrayType())
4719                         return getASTContext()->getTypeSize (qual_type->getArrayElementTypeNoTypeQual()->getCanonicalTypeUnqualified());
4720                 }
4721                 if (qual_type->isObjCObjectOrInterfaceType())
4722                     return bit_size + getASTContext()->getTypeSize(getASTContext()->ObjCBuiltinClassTy);
4723                 return bit_size;
4724         }
4725     }
4726     return 0;
4727 }
4728
4729 size_t
4730 ClangASTContext::GetTypeBitAlign (lldb::opaque_compiler_type_t type)
4731 {
4732     if (GetCompleteType(type))
4733         return getASTContext()->getTypeAlign(GetQualType(type));
4734     return 0;
4735 }
4736
4737
4738 lldb::Encoding
4739 ClangASTContext::GetEncoding (lldb::opaque_compiler_type_t type, uint64_t &count)
4740 {
4741     if (!type)
4742         return lldb::eEncodingInvalid;
4743
4744     count = 1;
4745     clang::QualType qual_type(GetCanonicalQualType(type));
4746
4747     switch (qual_type->getTypeClass())
4748     {
4749         case clang::Type::UnaryTransform:
4750             break;
4751
4752         case clang::Type::FunctionNoProto:
4753         case clang::Type::FunctionProto:
4754             break;
4755
4756         case clang::Type::IncompleteArray:
4757         case clang::Type::VariableArray:
4758             break;
4759
4760         case clang::Type::ConstantArray:
4761             break;
4762
4763         case clang::Type::ExtVector:
4764         case clang::Type::Vector:
4765             // TODO: Set this to more than one???
4766             break;
4767
4768         case clang::Type::Builtin:
4769             switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
4770         {
4771             case clang::BuiltinType::Void:
4772                 break;
4773
4774             case clang::BuiltinType::Bool:
4775             case clang::BuiltinType::Char_S:
4776             case clang::BuiltinType::SChar:
4777             case clang::BuiltinType::WChar_S:
4778             case clang::BuiltinType::Char16:
4779             case clang::BuiltinType::Char32:
4780             case clang::BuiltinType::Short:
4781             case clang::BuiltinType::Int:
4782             case clang::BuiltinType::Long:
4783             case clang::BuiltinType::LongLong:
4784             case clang::BuiltinType::Int128:        return lldb::eEncodingSint;
4785
4786             case clang::BuiltinType::Char_U:
4787             case clang::BuiltinType::UChar:
4788             case clang::BuiltinType::WChar_U:
4789             case clang::BuiltinType::UShort:
4790             case clang::BuiltinType::UInt:
4791             case clang::BuiltinType::ULong:
4792             case clang::BuiltinType::ULongLong:
4793             case clang::BuiltinType::UInt128:       return lldb::eEncodingUint;
4794
4795             case clang::BuiltinType::Half:
4796             case clang::BuiltinType::Float:
4797             case clang::BuiltinType::Double:
4798             case clang::BuiltinType::LongDouble:    return lldb::eEncodingIEEE754;
4799
4800             case clang::BuiltinType::ObjCClass:
4801             case clang::BuiltinType::ObjCId:
4802             case clang::BuiltinType::ObjCSel:       return lldb::eEncodingUint;
4803
4804             case clang::BuiltinType::NullPtr:       return lldb::eEncodingUint;
4805
4806             case clang::BuiltinType::Kind::ARCUnbridgedCast:
4807             case clang::BuiltinType::Kind::BoundMember:
4808             case clang::BuiltinType::Kind::BuiltinFn:
4809             case clang::BuiltinType::Kind::Dependent:
4810             case clang::BuiltinType::Kind::OCLClkEvent:
4811             case clang::BuiltinType::Kind::OCLEvent:
4812             case clang::BuiltinType::Kind::OCLImage1d:
4813             case clang::BuiltinType::Kind::OCLImage1dArray:
4814             case clang::BuiltinType::Kind::OCLImage1dBuffer:
4815             case clang::BuiltinType::Kind::OCLImage2d:
4816             case clang::BuiltinType::Kind::OCLImage2dArray:
4817             case clang::BuiltinType::Kind::OCLImage2dArrayDepth:
4818             case clang::BuiltinType::Kind::OCLImage2dArrayMSAA:
4819             case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepth:
4820             case clang::BuiltinType::Kind::OCLImage2dDepth:
4821             case clang::BuiltinType::Kind::OCLImage2dMSAA:
4822             case clang::BuiltinType::Kind::OCLImage2dMSAADepth:
4823             case clang::BuiltinType::Kind::OCLImage3d:
4824             case clang::BuiltinType::Kind::OCLQueue:
4825             case clang::BuiltinType::Kind::OCLNDRange:
4826             case clang::BuiltinType::Kind::OCLReserveID:
4827             case clang::BuiltinType::Kind::OCLSampler:
4828             case clang::BuiltinType::Kind::OMPArraySection:
4829             case clang::BuiltinType::Kind::Overload:
4830             case clang::BuiltinType::Kind::PseudoObject:
4831             case clang::BuiltinType::Kind::UnknownAny:
4832                 break;
4833         }
4834             break;
4835             // All pointer types are represented as unsigned integer encodings.
4836             // We may nee to add a eEncodingPointer if we ever need to know the
4837             // difference
4838         case clang::Type::ObjCObjectPointer:
4839         case clang::Type::BlockPointer:
4840         case clang::Type::Pointer:
4841         case clang::Type::LValueReference:
4842         case clang::Type::RValueReference:
4843         case clang::Type::MemberPointer:            return lldb::eEncodingUint;
4844         case clang::Type::Complex:
4845         {
4846             lldb::Encoding encoding = lldb::eEncodingIEEE754;
4847             if (qual_type->isComplexType())
4848                 encoding = lldb::eEncodingIEEE754;
4849             else
4850             {
4851                 const clang::ComplexType *complex_type = qual_type->getAsComplexIntegerType();
4852                 if (complex_type)
4853                     encoding = CompilerType(getASTContext(), complex_type->getElementType()).GetEncoding(count);
4854                 else
4855                     encoding = lldb::eEncodingSint;
4856             }
4857             count = 2;
4858             return encoding;
4859         }
4860
4861         case clang::Type::ObjCInterface:            break;
4862         case clang::Type::Record:                   break;
4863         case clang::Type::Enum:                     return lldb::eEncodingSint;
4864         case clang::Type::Typedef:
4865             return CompilerType(getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetEncoding(count);
4866
4867         case clang::Type::Auto:
4868             return CompilerType(getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetEncoding(count);
4869
4870         case clang::Type::Elaborated:
4871             return CompilerType(getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetEncoding(count);
4872
4873         case clang::Type::Paren:
4874             return CompilerType(getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetEncoding(count);
4875
4876         case clang::Type::DependentSizedArray:
4877         case clang::Type::DependentSizedExtVector:
4878         case clang::Type::UnresolvedUsing:
4879         case clang::Type::Attributed:
4880         case clang::Type::TemplateTypeParm:
4881         case clang::Type::SubstTemplateTypeParm:
4882         case clang::Type::SubstTemplateTypeParmPack:
4883         case clang::Type::InjectedClassName:
4884         case clang::Type::DependentName:
4885         case clang::Type::DependentTemplateSpecialization:
4886         case clang::Type::PackExpansion:
4887         case clang::Type::ObjCObject:
4888
4889         case clang::Type::TypeOfExpr:
4890         case clang::Type::TypeOf:
4891         case clang::Type::Decltype:
4892         case clang::Type::TemplateSpecialization:
4893         case clang::Type::Atomic:
4894         case clang::Type::Adjusted:
4895         case clang::Type::Pipe:
4896             break;
4897
4898             // pointer type decayed from an array or function type.
4899         case clang::Type::Decayed:
4900             break;
4901     }
4902     count = 0;
4903     return lldb::eEncodingInvalid;
4904 }
4905
4906 lldb::Format
4907 ClangASTContext::GetFormat (lldb::opaque_compiler_type_t type)
4908 {
4909     if (!type)
4910         return lldb::eFormatDefault;
4911
4912     clang::QualType qual_type(GetCanonicalQualType(type));
4913
4914     switch (qual_type->getTypeClass())
4915     {
4916         case clang::Type::UnaryTransform:
4917             break;
4918
4919         case clang::Type::FunctionNoProto:
4920         case clang::Type::FunctionProto:
4921             break;
4922
4923         case clang::Type::IncompleteArray:
4924         case clang::Type::VariableArray:
4925             break;
4926
4927         case clang::Type::ConstantArray:
4928             return lldb::eFormatVoid; // no value
4929
4930         case clang::Type::ExtVector:
4931         case clang::Type::Vector:
4932             break;
4933
4934         case clang::Type::Builtin:
4935             switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
4936         {
4937                 //default: assert(0 && "Unknown builtin type!");
4938             case clang::BuiltinType::UnknownAny:
4939             case clang::BuiltinType::Void:
4940             case clang::BuiltinType::BoundMember:
4941                 break;
4942
4943             case clang::BuiltinType::Bool:          return lldb::eFormatBoolean;
4944             case clang::BuiltinType::Char_S:
4945             case clang::BuiltinType::SChar:
4946             case clang::BuiltinType::WChar_S:
4947             case clang::BuiltinType::Char_U:
4948             case clang::BuiltinType::UChar:
4949             case clang::BuiltinType::WChar_U:       return lldb::eFormatChar;
4950             case clang::BuiltinType::Char16:        return lldb::eFormatUnicode16;
4951             case clang::BuiltinType::Char32:        return lldb::eFormatUnicode32;
4952             case clang::BuiltinType::UShort:        return lldb::eFormatUnsigned;
4953             case clang::BuiltinType::Short:         return lldb::eFormatDecimal;
4954             case clang::BuiltinType::UInt:          return lldb::eFormatUnsigned;
4955             case clang::BuiltinType::Int:           return lldb::eFormatDecimal;
4956             case clang::BuiltinType::ULong:         return lldb::eFormatUnsigned;
4957             case clang::BuiltinType::Long:          return lldb::eFormatDecimal;
4958             case clang::BuiltinType::ULongLong:     return lldb::eFormatUnsigned;
4959             case clang::BuiltinType::LongLong:      return lldb::eFormatDecimal;
4960             case clang::BuiltinType::UInt128:       return lldb::eFormatUnsigned;
4961             case clang::BuiltinType::Int128:        return lldb::eFormatDecimal;
4962             case clang::BuiltinType::Half:
4963             case clang::BuiltinType::Float:
4964             case clang::BuiltinType::Double:
4965             case clang::BuiltinType::LongDouble:    return lldb::eFormatFloat;
4966             default:
4967                 return lldb::eFormatHex;
4968         }
4969             break;
4970         case clang::Type::ObjCObjectPointer:        return lldb::eFormatHex;
4971         case clang::Type::BlockPointer:             return lldb::eFormatHex;
4972         case clang::Type::Pointer:                  return lldb::eFormatHex;
4973         case clang::Type::LValueReference:
4974         case clang::Type::RValueReference:          return lldb::eFormatHex;
4975         case clang::Type::MemberPointer:            break;
4976         case clang::Type::Complex:
4977         {
4978             if (qual_type->isComplexType())
4979                 return lldb::eFormatComplex;
4980             else
4981                 return lldb::eFormatComplexInteger;
4982         }
4983         case clang::Type::ObjCInterface:            break;
4984         case clang::Type::Record:                   break;
4985         case clang::Type::Enum:                     return lldb::eFormatEnum;
4986         case clang::Type::Typedef:
4987             return CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetFormat();
4988         case clang::Type::Auto:
4989             return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->desugar()).GetFormat();
4990         case clang::Type::Paren:
4991             return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetFormat();
4992         case clang::Type::Elaborated:
4993             return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetFormat();
4994         case clang::Type::DependentSizedArray:
4995         case clang::Type::DependentSizedExtVector:
4996         case clang::Type::UnresolvedUsing:
4997         case clang::Type::Attributed:
4998         case clang::Type::TemplateTypeParm:
4999         case clang::Type::SubstTemplateTypeParm:
5000         case clang::Type::SubstTemplateTypeParmPack:
5001         case clang::Type::InjectedClassName:
5002         case clang::Type::DependentName:
5003         case clang::Type::DependentTemplateSpecialization:
5004         case clang::Type::PackExpansion:
5005         case clang::Type::ObjCObject:
5006
5007         case clang::Type::TypeOfExpr:
5008         case clang::Type::TypeOf:
5009         case clang::Type::Decltype:
5010         case clang::Type::TemplateSpecialization:
5011         case clang::Type::Atomic:
5012         case clang::Type::Adjusted:
5013         case clang::Type::Pipe:
5014             break;
5015
5016             // pointer type decayed from an array or function type.
5017         case clang::Type::Decayed:
5018             break;
5019     }
5020     // We don't know hot to display this type...
5021     return lldb::eFormatBytes;
5022 }
5023
5024 static bool
5025 ObjCDeclHasIVars (clang::ObjCInterfaceDecl *class_interface_decl, bool check_superclass)
5026 {
5027     while (class_interface_decl)
5028     {
5029         if (class_interface_decl->ivar_size() > 0)
5030             return true;
5031
5032         if (check_superclass)
5033             class_interface_decl = class_interface_decl->getSuperClass();
5034         else
5035             break;
5036     }
5037     return false;
5038 }
5039
5040 uint32_t
5041 ClangASTContext::GetNumChildren (lldb::opaque_compiler_type_t type, bool omit_empty_base_classes)
5042 {
5043     if (!type)
5044         return 0;
5045
5046     uint32_t num_children = 0;
5047     clang::QualType qual_type(GetQualType(type));
5048     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5049     switch (type_class)
5050     {
5051         case clang::Type::Builtin:
5052             switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
5053         {
5054             case clang::BuiltinType::ObjCId:    // child is Class
5055             case clang::BuiltinType::ObjCClass: // child is Class
5056                 num_children = 1;
5057                 break;
5058
5059             default:
5060                 break;
5061         }
5062             break;
5063
5064         case clang::Type::Complex: return 0;
5065
5066         case clang::Type::Record:
5067             if (GetCompleteQualType (getASTContext(), qual_type))
5068             {
5069                 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5070                 const clang::RecordDecl *record_decl = record_type->getDecl();
5071                 assert(record_decl);
5072                 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
5073                 if (cxx_record_decl)
5074                 {
5075                     if (omit_empty_base_classes)
5076                     {
5077                         // Check each base classes to see if it or any of its
5078                         // base classes contain any fields. This can help
5079                         // limit the noise in variable views by not having to
5080                         // show base classes that contain no members.
5081                         clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
5082                         for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
5083                              base_class != base_class_end;
5084                              ++base_class)
5085                         {
5086                             const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
5087
5088                             // Skip empty base classes
5089                             if (ClangASTContext::RecordHasFields(base_class_decl) == false)
5090                                 continue;
5091
5092                             num_children++;
5093                         }
5094                     }
5095                     else
5096                     {
5097                         // Include all base classes
5098                         num_children += cxx_record_decl->getNumBases();
5099                     }
5100
5101                 }
5102                 clang::RecordDecl::field_iterator field, field_end;
5103                 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
5104                     ++num_children;
5105             }
5106             break;
5107
5108         case clang::Type::ObjCObject:
5109         case clang::Type::ObjCInterface:
5110             if (GetCompleteQualType (getASTContext(), qual_type))
5111             {
5112                 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5113                 assert (objc_class_type);
5114                 if (objc_class_type)
5115                 {
5116                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
5117
5118                     if (class_interface_decl)
5119                     {
5120
5121                         clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
5122                         if (superclass_interface_decl)
5123                         {
5124                             if (omit_empty_base_classes)
5125                             {
5126                                 if (ObjCDeclHasIVars (superclass_interface_decl, true))
5127                                     ++num_children;
5128                             }
5129                             else
5130                                 ++num_children;
5131                         }
5132
5133                         num_children += class_interface_decl->ivar_size();
5134                     }
5135                 }
5136             }
5137             break;
5138
5139         case clang::Type::ObjCObjectPointer:
5140         {
5141             const clang::ObjCObjectPointerType *pointer_type = llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr());
5142             clang::QualType pointee_type = pointer_type->getPointeeType();
5143             uint32_t num_pointee_children = CompilerType (getASTContext(),pointee_type).GetNumChildren (omit_empty_base_classes);
5144             // If this type points to a simple type, then it has 1 child
5145             if (num_pointee_children == 0)
5146                 num_children = 1;
5147             else
5148                 num_children = num_pointee_children;
5149         }
5150             break;
5151
5152         case clang::Type::Vector:
5153         case clang::Type::ExtVector:
5154             num_children = llvm::cast<clang::VectorType>(qual_type.getTypePtr())->getNumElements();
5155             break;
5156
5157         case clang::Type::ConstantArray:
5158             num_children = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
5159             break;
5160
5161         case clang::Type::Pointer:
5162         {
5163             const clang::PointerType *pointer_type = llvm::cast<clang::PointerType>(qual_type.getTypePtr());
5164             clang::QualType pointee_type (pointer_type->getPointeeType());
5165             uint32_t num_pointee_children = CompilerType (getASTContext(),pointee_type).GetNumChildren (omit_empty_base_classes);
5166             if (num_pointee_children == 0)
5167             {
5168                 // We have a pointer to a pointee type that claims it has no children.
5169                 // We will want to look at
5170                 num_children = GetNumPointeeChildren (pointee_type);
5171             }
5172             else
5173                 num_children = num_pointee_children;
5174         }
5175             break;
5176
5177         case clang::Type::LValueReference:
5178         case clang::Type::RValueReference:
5179         {
5180             const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
5181             clang::QualType pointee_type = reference_type->getPointeeType();
5182             uint32_t num_pointee_children = CompilerType (getASTContext(), pointee_type).GetNumChildren (omit_empty_base_classes);
5183             // If this type points to a simple type, then it has 1 child
5184             if (num_pointee_children == 0)
5185                 num_children = 1;
5186             else
5187                 num_children = num_pointee_children;
5188         }
5189             break;
5190
5191
5192         case clang::Type::Typedef:
5193             num_children = CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumChildren (omit_empty_base_classes);
5194             break;
5195
5196         case clang::Type::Auto:
5197             num_children = CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetNumChildren (omit_empty_base_classes);
5198             break;
5199
5200         case clang::Type::Elaborated:
5201             num_children = CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumChildren (omit_empty_base_classes);
5202             break;
5203
5204         case clang::Type::Paren:
5205             num_children = CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumChildren (omit_empty_base_classes);
5206             break;
5207         default:
5208             break;
5209     }
5210     return num_children;
5211 }
5212
5213 CompilerType
5214 ClangASTContext::GetBuiltinTypeByName (const ConstString &name)
5215 {
5216     return GetBasicType (GetBasicTypeEnumeration (name));
5217 }
5218
5219 lldb::BasicType
5220 ClangASTContext::GetBasicTypeEnumeration (lldb::opaque_compiler_type_t type)
5221 {
5222     if (type)
5223     {
5224         clang::QualType qual_type(GetQualType(type));
5225         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5226         if (type_class == clang::Type::Builtin)
5227         {
5228             switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
5229             {
5230                 case clang::BuiltinType::Void:      return eBasicTypeVoid;
5231                 case clang::BuiltinType::Bool:      return eBasicTypeBool;
5232                 case clang::BuiltinType::Char_S:    return eBasicTypeSignedChar;
5233                 case clang::BuiltinType::Char_U:    return eBasicTypeUnsignedChar;
5234                 case clang::BuiltinType::Char16:    return eBasicTypeChar16;
5235                 case clang::BuiltinType::Char32:    return eBasicTypeChar32;
5236                 case clang::BuiltinType::UChar:     return eBasicTypeUnsignedChar;
5237                 case clang::BuiltinType::SChar:     return eBasicTypeSignedChar;
5238                 case clang::BuiltinType::WChar_S:   return eBasicTypeSignedWChar;
5239                 case clang::BuiltinType::WChar_U:   return eBasicTypeUnsignedWChar;
5240                 case clang::BuiltinType::Short:     return eBasicTypeShort;
5241                 case clang::BuiltinType::UShort:    return eBasicTypeUnsignedShort;
5242                 case clang::BuiltinType::Int:       return eBasicTypeInt;
5243                 case clang::BuiltinType::UInt:      return eBasicTypeUnsignedInt;
5244                 case clang::BuiltinType::Long:      return eBasicTypeLong;
5245                 case clang::BuiltinType::ULong:     return eBasicTypeUnsignedLong;
5246                 case clang::BuiltinType::LongLong:  return eBasicTypeLongLong;
5247                 case clang::BuiltinType::ULongLong: return eBasicTypeUnsignedLongLong;
5248                 case clang::BuiltinType::Int128:    return eBasicTypeInt128;
5249                 case clang::BuiltinType::UInt128:   return eBasicTypeUnsignedInt128;
5250
5251                 case clang::BuiltinType::Half:      return eBasicTypeHalf;
5252                 case clang::BuiltinType::Float:     return eBasicTypeFloat;
5253                 case clang::BuiltinType::Double:    return eBasicTypeDouble;
5254                 case clang::BuiltinType::LongDouble:return eBasicTypeLongDouble;
5255
5256                 case clang::BuiltinType::NullPtr:   return eBasicTypeNullPtr;
5257                 case clang::BuiltinType::ObjCId:    return eBasicTypeObjCID;
5258                 case clang::BuiltinType::ObjCClass: return eBasicTypeObjCClass;
5259                 case clang::BuiltinType::ObjCSel:   return eBasicTypeObjCSel;
5260                 default:
5261                     return eBasicTypeOther;
5262             }
5263         }
5264     }
5265     return eBasicTypeInvalid;
5266 }
5267
5268 void
5269 ClangASTContext::ForEachEnumerator (lldb::opaque_compiler_type_t type, std::function <bool (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value)> const &callback)
5270 {
5271     const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type));
5272     if (enum_type)
5273     {
5274         const clang::EnumDecl *enum_decl = enum_type->getDecl();
5275         if (enum_decl)
5276         {
5277             CompilerType integer_type(this, enum_decl->getIntegerType().getAsOpaquePtr());
5278
5279             clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
5280             for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos)
5281             {
5282                 ConstString name(enum_pos->getNameAsString().c_str());
5283                 if (!callback (integer_type, name, enum_pos->getInitVal()))
5284                     break;
5285             }
5286         }
5287     }
5288 }
5289
5290
5291 #pragma mark Aggregate Types
5292
5293 uint32_t
5294 ClangASTContext::GetNumFields (lldb::opaque_compiler_type_t type)
5295 {
5296     if (!type)
5297         return 0;
5298
5299     uint32_t count = 0;
5300     clang::QualType qual_type(GetCanonicalQualType(type));
5301     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5302     switch (type_class)
5303     {
5304         case clang::Type::Record:
5305             if (GetCompleteType(type))
5306             {
5307                 const clang::RecordType *record_type = llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr());
5308                 if (record_type)
5309                 {
5310                     clang::RecordDecl *record_decl = record_type->getDecl();
5311                     if (record_decl)
5312                     {
5313                         uint32_t field_idx = 0;
5314                         clang::RecordDecl::field_iterator field, field_end;
5315                         for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
5316                             ++field_idx;
5317                         count = field_idx;
5318                     }
5319                 }
5320             }
5321             break;
5322
5323         case clang::Type::Typedef:
5324             count = CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumFields();
5325             break;
5326
5327         case clang::Type::Auto:
5328             count = CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetNumFields();
5329             break;
5330
5331         case clang::Type::Elaborated:
5332             count = CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumFields();
5333             break;
5334
5335         case clang::Type::Paren:
5336             count = CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumFields();
5337             break;
5338
5339         case clang::Type::ObjCObjectPointer:
5340             if (GetCompleteType(type))
5341             {
5342                 const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
5343                 if (objc_class_type)
5344                 {
5345                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
5346
5347                     if (class_interface_decl)
5348                         count = class_interface_decl->ivar_size();
5349                 }
5350             }
5351             break;
5352
5353         case clang::Type::ObjCObject:
5354         case clang::Type::ObjCInterface:
5355             if (GetCompleteType(type))
5356             {
5357                 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5358                 if (objc_class_type)
5359                 {
5360                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
5361
5362                     if (class_interface_decl)
5363                         count = class_interface_decl->ivar_size();
5364                 }
5365             }
5366             break;
5367
5368         default:
5369             break;
5370     }
5371     return count;
5372 }
5373
5374 static lldb::opaque_compiler_type_t
5375 GetObjCFieldAtIndex (clang::ASTContext *ast,
5376                      clang::ObjCInterfaceDecl *class_interface_decl,
5377                      size_t idx,
5378                      std::string& name,
5379                      uint64_t *bit_offset_ptr,
5380                      uint32_t *bitfield_bit_size_ptr,
5381                      bool *is_bitfield_ptr)
5382 {
5383     if (class_interface_decl)
5384     {
5385         if (idx < (class_interface_decl->ivar_size()))
5386         {
5387             clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
5388             uint32_t ivar_idx = 0;
5389
5390             for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++ivar_idx)
5391             {
5392                 if (ivar_idx == idx)
5393                 {
5394                     const clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
5395
5396                     clang::QualType ivar_qual_type(ivar_decl->getType());
5397
5398                     name.assign(ivar_decl->getNameAsString());
5399
5400                     if (bit_offset_ptr)
5401                     {
5402                         const clang::ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl);
5403                         *bit_offset_ptr = interface_layout.getFieldOffset (ivar_idx);
5404                     }
5405
5406                     const bool is_bitfield = ivar_pos->isBitField();
5407
5408                     if (bitfield_bit_size_ptr)
5409                     {
5410                         *bitfield_bit_size_ptr = 0;
5411
5412                         if (is_bitfield && ast)
5413                         {
5414                             clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth();
5415                             llvm::APSInt bitfield_apsint;
5416                             if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *ast))
5417                             {
5418                                 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5419                             }
5420                         }
5421                     }
5422                     if (is_bitfield_ptr)
5423                         *is_bitfield_ptr = is_bitfield;
5424
5425                     return ivar_qual_type.getAsOpaquePtr();
5426                 }
5427             }
5428         }
5429     }
5430     return nullptr;
5431 }
5432
5433 CompilerType
5434 ClangASTContext::GetFieldAtIndex (lldb::opaque_compiler_type_t type, size_t idx,
5435                                      std::string& name,
5436                                      uint64_t *bit_offset_ptr,
5437                                      uint32_t *bitfield_bit_size_ptr,
5438                                      bool *is_bitfield_ptr)
5439 {
5440     if (!type)
5441         return CompilerType();
5442
5443     clang::QualType qual_type(GetCanonicalQualType(type));
5444     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5445     switch (type_class)
5446     {
5447         case clang::Type::Record:
5448             if (GetCompleteType(type))
5449             {
5450                 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
5451                 const clang::RecordDecl *record_decl = record_type->getDecl();
5452                 uint32_t field_idx = 0;
5453                 clang::RecordDecl::field_iterator field, field_end;
5454                 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx)
5455                 {
5456                     if (idx == field_idx)
5457                     {
5458                         // Print the member type if requested
5459                         // Print the member name and equal sign
5460                         name.assign(field->getNameAsString());
5461
5462                         // Figure out the type byte size (field_type_info.first) and
5463                         // alignment (field_type_info.second) from the AST context.
5464                         if (bit_offset_ptr)
5465                         {
5466                             const clang::ASTRecordLayout &record_layout = getASTContext()->getASTRecordLayout(record_decl);
5467                             *bit_offset_ptr = record_layout.getFieldOffset (field_idx);
5468                         }
5469
5470                         const bool is_bitfield = field->isBitField();
5471
5472                         if (bitfield_bit_size_ptr)
5473                         {
5474                             *bitfield_bit_size_ptr = 0;
5475
5476                             if (is_bitfield)
5477                             {
5478                                 clang::Expr *bitfield_bit_size_expr = field->getBitWidth();
5479                                 llvm::APSInt bitfield_apsint;
5480                                 if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *getASTContext()))
5481                                 {
5482                                     *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
5483                                 }
5484                             }
5485                         }
5486                         if (is_bitfield_ptr)
5487                             *is_bitfield_ptr = is_bitfield;
5488
5489                         return CompilerType (getASTContext(), field->getType());
5490                     }
5491                 }
5492             }
5493             break;
5494
5495         case clang::Type::ObjCObjectPointer:
5496             if (GetCompleteType(type))
5497             {
5498                 const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
5499                 if (objc_class_type)
5500                 {
5501                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
5502                     return CompilerType (this, GetObjCFieldAtIndex(getASTContext(), class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
5503                 }
5504             }
5505             break;
5506
5507         case clang::Type::ObjCObject:
5508         case clang::Type::ObjCInterface:
5509             if (GetCompleteType(type))
5510             {
5511                 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
5512                 assert (objc_class_type);
5513                 if (objc_class_type)
5514                 {
5515                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
5516                     return CompilerType (this, GetObjCFieldAtIndex(getASTContext(), class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
5517                 }
5518             }
5519             break;
5520
5521
5522         case clang::Type::Typedef:
5523             return CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).
5524             GetFieldAtIndex (idx,
5525                              name,
5526                              bit_offset_ptr,
5527                              bitfield_bit_size_ptr,
5528                              is_bitfield_ptr);
5529
5530         case clang::Type::Auto:
5531             return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).
5532             GetFieldAtIndex (idx,
5533                              name,
5534                              bit_offset_ptr,
5535                              bitfield_bit_size_ptr,
5536                              is_bitfield_ptr);
5537
5538         case clang::Type::Elaborated:
5539             return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).
5540             GetFieldAtIndex (idx,
5541                              name,
5542                              bit_offset_ptr,
5543                              bitfield_bit_size_ptr,
5544                              is_bitfield_ptr);
5545
5546         case clang::Type::Paren:
5547             return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).
5548             GetFieldAtIndex (idx,
5549                              name,
5550                              bit_offset_ptr,
5551                              bitfield_bit_size_ptr,
5552                              is_bitfield_ptr);
5553
5554         default:
5555             break;
5556     }
5557     return CompilerType();
5558 }
5559
5560 uint32_t
5561 ClangASTContext::GetNumDirectBaseClasses (lldb::opaque_compiler_type_t type)
5562 {
5563     uint32_t count = 0;
5564     clang::QualType qual_type(GetCanonicalQualType(type));
5565     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5566     switch (type_class)
5567     {
5568         case clang::Type::Record:
5569             if (GetCompleteType(type))
5570             {
5571                 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
5572                 if (cxx_record_decl)
5573                     count = cxx_record_decl->getNumBases();
5574             }
5575             break;
5576
5577         case clang::Type::ObjCObjectPointer:
5578             count = GetPointeeType(type).GetNumDirectBaseClasses();
5579             break;
5580
5581         case clang::Type::ObjCObject:
5582             if (GetCompleteType(type))
5583             {
5584                 const clang::ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
5585                 if (objc_class_type)
5586                 {
5587                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
5588
5589                     if (class_interface_decl && class_interface_decl->getSuperClass())
5590                         count = 1;
5591                 }
5592             }
5593             break;
5594         case clang::Type::ObjCInterface:
5595             if (GetCompleteType(type))
5596             {
5597                 const clang::ObjCInterfaceType *objc_interface_type = qual_type->getAs<clang::ObjCInterfaceType>();
5598                 if (objc_interface_type)
5599                 {
5600                     clang::ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface();
5601
5602                     if (class_interface_decl && class_interface_decl->getSuperClass())
5603                         count = 1;
5604                 }
5605             }
5606             break;
5607
5608
5609         case clang::Type::Typedef:
5610             count = GetNumDirectBaseClasses(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
5611             break;
5612
5613         case clang::Type::Auto:
5614             count = GetNumDirectBaseClasses(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr());
5615             break;
5616
5617         case clang::Type::Elaborated:
5618             count = GetNumDirectBaseClasses(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
5619             break;
5620
5621         case clang::Type::Paren:
5622             return GetNumDirectBaseClasses(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
5623
5624         default:
5625             break;
5626     }
5627     return count;
5628
5629 }
5630
5631 uint32_t
5632 ClangASTContext::GetNumVirtualBaseClasses (lldb::opaque_compiler_type_t type)
5633 {
5634     uint32_t count = 0;
5635     clang::QualType qual_type(GetCanonicalQualType(type));
5636     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5637     switch (type_class)
5638     {
5639         case clang::Type::Record:
5640             if (GetCompleteType(type))
5641             {
5642                 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
5643                 if (cxx_record_decl)
5644                     count = cxx_record_decl->getNumVBases();
5645             }
5646             break;
5647
5648         case clang::Type::Typedef:
5649             count = GetNumVirtualBaseClasses(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
5650             break;
5651
5652         case clang::Type::Auto:
5653             count = GetNumVirtualBaseClasses(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr());
5654             break;
5655
5656         case clang::Type::Elaborated:
5657             count = GetNumVirtualBaseClasses(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
5658             break;
5659
5660         case clang::Type::Paren:
5661             count = GetNumVirtualBaseClasses(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
5662             break;
5663
5664         default:
5665             break;
5666     }
5667     return count;
5668
5669 }
5670
5671 CompilerType
5672 ClangASTContext::GetDirectBaseClassAtIndex (lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr)
5673 {
5674     clang::QualType qual_type(GetCanonicalQualType(type));
5675     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5676     switch (type_class)
5677     {
5678         case clang::Type::Record:
5679             if (GetCompleteType(type))
5680             {
5681                 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
5682                 if (cxx_record_decl)
5683                 {
5684                     uint32_t curr_idx = 0;
5685                     clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
5686                     for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
5687                          base_class != base_class_end;
5688                          ++base_class, ++curr_idx)
5689                     {
5690                         if (curr_idx == idx)
5691                         {
5692                             if (bit_offset_ptr)
5693                             {
5694                                 const clang::ASTRecordLayout &record_layout = getASTContext()->getASTRecordLayout(cxx_record_decl);
5695                                 const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
5696                                 if (base_class->isVirtual())
5697                                     *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
5698                                 else
5699                                     *bit_offset_ptr = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
5700                             }
5701                             return CompilerType (this, base_class->getType().getAsOpaquePtr());
5702                         }
5703                     }
5704                 }
5705             }
5706             break;
5707
5708         case clang::Type::ObjCObjectPointer:
5709             return GetPointeeType(type).GetDirectBaseClassAtIndex(idx, bit_offset_ptr);
5710
5711         case clang::Type::ObjCObject:
5712             if (idx == 0 && GetCompleteType(type))
5713             {
5714                 const clang::ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
5715                 if (objc_class_type)
5716                 {
5717                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
5718
5719                     if (class_interface_decl)
5720                     {
5721                         clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
5722                         if (superclass_interface_decl)
5723                         {
5724                             if (bit_offset_ptr)
5725                                 *bit_offset_ptr = 0;
5726                             return CompilerType (getASTContext(), getASTContext()->getObjCInterfaceType(superclass_interface_decl));
5727                         }
5728                     }
5729                 }
5730             }
5731             break;
5732         case clang::Type::ObjCInterface:
5733             if (idx == 0 && GetCompleteType(type))
5734             {
5735                 const clang::ObjCObjectType *objc_interface_type = qual_type->getAs<clang::ObjCInterfaceType>();
5736                 if (objc_interface_type)
5737                 {
5738                     clang::ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface();
5739
5740                     if (class_interface_decl)
5741                     {
5742                         clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
5743                         if (superclass_interface_decl)
5744                         {
5745                             if (bit_offset_ptr)
5746                                 *bit_offset_ptr = 0;
5747                             return CompilerType (getASTContext(), getASTContext()->getObjCInterfaceType(superclass_interface_decl));
5748                         }
5749                     }
5750                 }
5751             }
5752             break;
5753
5754
5755         case clang::Type::Typedef:
5756             return GetDirectBaseClassAtIndex (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), idx, bit_offset_ptr);
5757
5758         case clang::Type::Auto:
5759             return GetDirectBaseClassAtIndex (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), idx, bit_offset_ptr);
5760
5761         case clang::Type::Elaborated:
5762             return GetDirectBaseClassAtIndex (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), idx, bit_offset_ptr);
5763
5764         case clang::Type::Paren:
5765             return GetDirectBaseClassAtIndex (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), idx, bit_offset_ptr);
5766
5767         default:
5768             break;
5769     }
5770     return CompilerType();
5771 }
5772
5773 CompilerType
5774 ClangASTContext::GetVirtualBaseClassAtIndex (lldb::opaque_compiler_type_t type,
5775                                              size_t idx,
5776                                              uint32_t *bit_offset_ptr)
5777 {
5778     clang::QualType qual_type(GetCanonicalQualType(type));
5779     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5780     switch (type_class)
5781     {
5782         case clang::Type::Record:
5783             if (GetCompleteType(type))
5784             {
5785                 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
5786                 if (cxx_record_decl)
5787                 {
5788                     uint32_t curr_idx = 0;
5789                     clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
5790                     for (base_class = cxx_record_decl->vbases_begin(), base_class_end = cxx_record_decl->vbases_end();
5791                          base_class != base_class_end;
5792                          ++base_class, ++curr_idx)
5793                     {
5794                         if (curr_idx == idx)
5795                         {
5796                             if (bit_offset_ptr)
5797                             {
5798                                 const clang::ASTRecordLayout &record_layout = getASTContext()->getASTRecordLayout(cxx_record_decl);
5799                                 const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
5800                                 *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
5801
5802                             }
5803                             return CompilerType (this, base_class->getType().getAsOpaquePtr());
5804                         }
5805                     }
5806                 }
5807             }
5808             break;
5809
5810         case clang::Type::Typedef:
5811             return GetVirtualBaseClassAtIndex (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), idx, bit_offset_ptr);
5812
5813         case clang::Type::Auto:
5814             return GetVirtualBaseClassAtIndex (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), idx, bit_offset_ptr);
5815
5816         case clang::Type::Elaborated:
5817             return GetVirtualBaseClassAtIndex (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), idx, bit_offset_ptr);
5818
5819         case clang::Type::Paren:
5820             return  GetVirtualBaseClassAtIndex (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), idx, bit_offset_ptr);
5821
5822         default:
5823             break;
5824     }
5825     return CompilerType();
5826
5827 }
5828
5829 // If a pointer to a pointee type (the clang_type arg) says that it has no
5830 // children, then we either need to trust it, or override it and return a
5831 // different result. For example, an "int *" has one child that is an integer,
5832 // but a function pointer doesn't have any children. Likewise if a Record type
5833 // claims it has no children, then there really is nothing to show.
5834 uint32_t
5835 ClangASTContext::GetNumPointeeChildren (clang::QualType type)
5836 {
5837     if (type.isNull())
5838         return 0;
5839
5840     clang::QualType qual_type(type.getCanonicalType());
5841     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5842     switch (type_class)
5843     {
5844         case clang::Type::Builtin:
5845             switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind())
5846         {
5847             case clang::BuiltinType::UnknownAny:
5848             case clang::BuiltinType::Void:
5849             case clang::BuiltinType::NullPtr:
5850             case clang::BuiltinType::OCLEvent:
5851             case clang::BuiltinType::OCLImage1d:
5852             case clang::BuiltinType::OCLImage1dArray:
5853             case clang::BuiltinType::OCLImage1dBuffer:
5854             case clang::BuiltinType::OCLImage2d:
5855             case clang::BuiltinType::OCLImage2dArray:
5856             case clang::BuiltinType::OCLImage3d:
5857             case clang::BuiltinType::OCLSampler:
5858                 return 0;
5859             case clang::BuiltinType::Bool:
5860             case clang::BuiltinType::Char_U:
5861             case clang::BuiltinType::UChar:
5862             case clang::BuiltinType::WChar_U:
5863             case clang::BuiltinType::Char16:
5864             case clang::BuiltinType::Char32:
5865             case clang::BuiltinType::UShort:
5866             case clang::BuiltinType::UInt:
5867             case clang::BuiltinType::ULong:
5868             case clang::BuiltinType::ULongLong:
5869             case clang::BuiltinType::UInt128:
5870             case clang::BuiltinType::Char_S:
5871             case clang::BuiltinType::SChar:
5872             case clang::BuiltinType::WChar_S:
5873             case clang::BuiltinType::Short:
5874             case clang::BuiltinType::Int:
5875             case clang::BuiltinType::Long:
5876             case clang::BuiltinType::LongLong:
5877             case clang::BuiltinType::Int128:
5878             case clang::BuiltinType::Float:
5879             case clang::BuiltinType::Double:
5880             case clang::BuiltinType::LongDouble:
5881             case clang::BuiltinType::Dependent:
5882             case clang::BuiltinType::Overload:
5883             case clang::BuiltinType::ObjCId:
5884             case clang::BuiltinType::ObjCClass:
5885             case clang::BuiltinType::ObjCSel:
5886             case clang::BuiltinType::BoundMember:
5887             case clang::BuiltinType::Half:
5888             case clang::BuiltinType::ARCUnbridgedCast:
5889             case clang::BuiltinType::PseudoObject:
5890             case clang::BuiltinType::BuiltinFn:
5891             case clang::BuiltinType::OMPArraySection:
5892                 return 1;
5893             default:
5894                 return 0;
5895         }
5896             break;
5897
5898         case clang::Type::Complex:                  return 1;
5899         case clang::Type::Pointer:                  return 1;
5900         case clang::Type::BlockPointer:             return 0;   // If block pointers don't have debug info, then no children for them
5901         case clang::Type::LValueReference:          return 1;
5902         case clang::Type::RValueReference:          return 1;
5903         case clang::Type::MemberPointer:            return 0;
5904         case clang::Type::ConstantArray:            return 0;
5905         case clang::Type::IncompleteArray:          return 0;
5906         case clang::Type::VariableArray:            return 0;
5907         case clang::Type::DependentSizedArray:      return 0;
5908         case clang::Type::DependentSizedExtVector:  return 0;
5909         case clang::Type::Vector:                   return 0;
5910         case clang::Type::ExtVector:                return 0;
5911         case clang::Type::FunctionProto:            return 0;   // When we function pointers, they have no children...
5912         case clang::Type::FunctionNoProto:          return 0;   // When we function pointers, they have no children...
5913         case clang::Type::UnresolvedUsing:          return 0;
5914         case clang::Type::Paren:                    return GetNumPointeeChildren (llvm::cast<clang::ParenType>(qual_type)->desugar());
5915         case clang::Type::Typedef:                  return GetNumPointeeChildren (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType());
5916         case clang::Type::Auto:                     return GetNumPointeeChildren (llvm::cast<clang::AutoType>(qual_type)->getDeducedType());
5917         case clang::Type::Elaborated:               return GetNumPointeeChildren (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType());
5918         case clang::Type::TypeOfExpr:               return 0;
5919         case clang::Type::TypeOf:                   return 0;
5920         case clang::Type::Decltype:                 return 0;
5921         case clang::Type::Record:                   return 0;
5922         case clang::Type::Enum:                     return 1;
5923         case clang::Type::TemplateTypeParm:         return 1;
5924         case clang::Type::SubstTemplateTypeParm:    return 1;
5925         case clang::Type::TemplateSpecialization:   return 1;
5926         case clang::Type::InjectedClassName:        return 0;
5927         case clang::Type::DependentName:            return 1;
5928         case clang::Type::DependentTemplateSpecialization:  return 1;
5929         case clang::Type::ObjCObject:               return 0;
5930         case clang::Type::ObjCInterface:            return 0;
5931         case clang::Type::ObjCObjectPointer:        return 1;
5932         default:
5933             break;
5934     }
5935     return 0;
5936 }
5937
5938
5939 CompilerType
5940 ClangASTContext::GetChildCompilerTypeAtIndex (lldb::opaque_compiler_type_t type,
5941                                               ExecutionContext *exe_ctx,
5942                                               size_t idx,
5943                                               bool transparent_pointers,
5944                                               bool omit_empty_base_classes,
5945                                               bool ignore_array_bounds,
5946                                               std::string& child_name,
5947                                               uint32_t &child_byte_size,
5948                                               int32_t &child_byte_offset,
5949                                               uint32_t &child_bitfield_bit_size,
5950                                               uint32_t &child_bitfield_bit_offset,
5951                                               bool &child_is_base_class,
5952                                               bool &child_is_deref_of_parent,
5953                                               ValueObject *valobj,
5954                                               uint64_t &language_flags)
5955 {
5956     if (!type)
5957         return CompilerType();
5958
5959     clang::QualType parent_qual_type(GetCanonicalQualType(type));
5960     const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass();
5961     child_bitfield_bit_size = 0;
5962     child_bitfield_bit_offset = 0;
5963     child_is_base_class = false;
5964     language_flags = 0;
5965
5966     const bool idx_is_valid = idx < GetNumChildren (type, omit_empty_base_classes);
5967     uint32_t bit_offset;
5968     switch (parent_type_class)
5969     {
5970         case clang::Type::Builtin:
5971             if (idx_is_valid)
5972             {
5973                 switch (llvm::cast<clang::BuiltinType>(parent_qual_type)->getKind())
5974                 {
5975                     case clang::BuiltinType::ObjCId:
5976                     case clang::BuiltinType::ObjCClass:
5977                         child_name = "isa";
5978                         child_byte_size = getASTContext()->getTypeSize(getASTContext()->ObjCBuiltinClassTy) / CHAR_BIT;
5979                         return CompilerType (getASTContext(), getASTContext()->ObjCBuiltinClassTy);
5980
5981                     default:
5982                         break;
5983                 }
5984             }
5985             break;
5986
5987         case clang::Type::Record:
5988             if (idx_is_valid && GetCompleteType(type))
5989             {
5990                 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(parent_qual_type.getTypePtr());
5991                 const clang::RecordDecl *record_decl = record_type->getDecl();
5992                 assert(record_decl);
5993                 const clang::ASTRecordLayout &record_layout = getASTContext()->getASTRecordLayout(record_decl);
5994                 uint32_t child_idx = 0;
5995
5996                 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
5997                 if (cxx_record_decl)
5998                 {
5999                     // We might have base classes to print out first
6000                     clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
6001                     for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
6002                          base_class != base_class_end;
6003                          ++base_class)
6004                     {
6005                         const clang::CXXRecordDecl *base_class_decl = nullptr;
6006
6007                         // Skip empty base classes
6008                         if (omit_empty_base_classes)
6009                         {
6010                             base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
6011                             if (ClangASTContext::RecordHasFields(base_class_decl) == false)
6012                                 continue;
6013                         }
6014
6015                         if (idx == child_idx)
6016                         {
6017                             if (base_class_decl == nullptr)
6018                                 base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
6019
6020
6021                             if (base_class->isVirtual())
6022                             {
6023                                 bool handled = false;
6024                                 if (valobj)
6025                                 {
6026                                     Error err;
6027                                     AddressType addr_type = eAddressTypeInvalid;
6028                                     lldb::addr_t vtable_ptr_addr = valobj->GetCPPVTableAddress(addr_type);
6029
6030                                     if (vtable_ptr_addr != LLDB_INVALID_ADDRESS && addr_type == eAddressTypeLoad)
6031                                     {
6032
6033                                         ExecutionContext exe_ctx (valobj->GetExecutionContextRef());
6034                                         Process *process = exe_ctx.GetProcessPtr();
6035                                         if (process)
6036                                         {
6037                                             clang::VTableContextBase *vtable_ctx = getASTContext()->getVTableContext();
6038                                             if (vtable_ctx)
6039                                             {
6040                                                 if (vtable_ctx->isMicrosoft())
6041                                                 {
6042                                                     clang::MicrosoftVTableContext *msoft_vtable_ctx = static_cast<clang::MicrosoftVTableContext *>(vtable_ctx);
6043
6044                                                     if (vtable_ptr_addr)
6045                                                     {
6046                                                         const lldb::addr_t vbtable_ptr_addr = vtable_ptr_addr + record_layout.getVBPtrOffset().getQuantity();
6047
6048                                                         const lldb::addr_t vbtable_ptr = process->ReadPointerFromMemory(vbtable_ptr_addr, err);
6049                                                         if (vbtable_ptr != LLDB_INVALID_ADDRESS)
6050                                                         {
6051                                                             // Get the index into the virtual base table. The index is the index in uint32_t from vbtable_ptr
6052                                                             const unsigned vbtable_index = msoft_vtable_ctx->getVBTableIndex(cxx_record_decl, base_class_decl);
6053                                                             const lldb::addr_t base_offset_addr = vbtable_ptr + vbtable_index * 4;
6054                                                             const uint32_t base_offset = process->ReadUnsignedIntegerFromMemory(base_offset_addr, 4, UINT32_MAX, err);
6055                                                             if (base_offset != UINT32_MAX)
6056                                                             {
6057                                                                 handled = true;
6058                                                                 bit_offset = base_offset * 8;
6059                                                             }
6060                                                         }
6061                                                     }
6062                                                 }
6063                                                 else
6064                                                 {
6065                                                     clang::ItaniumVTableContext *itanium_vtable_ctx = static_cast<clang::ItaniumVTableContext *>(vtable_ctx);
6066                                                     if (vtable_ptr_addr)
6067                                                     {
6068                                                         const lldb::addr_t vtable_ptr = process->ReadPointerFromMemory(vtable_ptr_addr, err);
6069                                                         if (vtable_ptr != LLDB_INVALID_ADDRESS)
6070                                                         {
6071                                                             clang::CharUnits base_offset_offset = itanium_vtable_ctx->getVirtualBaseOffsetOffset(cxx_record_decl, base_class_decl);
6072                                                             const lldb::addr_t base_offset_addr = vtable_ptr + base_offset_offset.getQuantity();
6073                                                             const uint32_t base_offset = process->ReadUnsignedIntegerFromMemory(base_offset_addr, 4, UINT32_MAX, err);
6074                                                             if (base_offset != UINT32_MAX)
6075                                                             {
6076                                                                 handled = true;
6077                                                                 bit_offset = base_offset * 8;
6078                                                             }
6079                                                         }
6080                                                     }
6081                                                 }
6082                                             }
6083                                         }
6084                                     }
6085
6086                                 }
6087                                 if (!handled)
6088                                     bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
6089                             }
6090                             else
6091                                 bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
6092
6093                             // Base classes should be a multiple of 8 bits in size
6094                             child_byte_offset = bit_offset/8;
6095                             CompilerType base_class_clang_type(getASTContext(), base_class->getType());
6096                             child_name = base_class_clang_type.GetTypeName().AsCString("");
6097                             uint64_t base_class_clang_type_bit_size = base_class_clang_type.GetBitSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
6098
6099                             // Base classes bit sizes should be a multiple of 8 bits in size
6100                             assert (base_class_clang_type_bit_size % 8 == 0);
6101                             child_byte_size = base_class_clang_type_bit_size / 8;
6102                             child_is_base_class = true;
6103                             return base_class_clang_type;
6104                         }
6105                         // We don't increment the child index in the for loop since we might
6106                         // be skipping empty base classes
6107                         ++child_idx;
6108                     }
6109                 }
6110                 // Make sure index is in range...
6111                 uint32_t field_idx = 0;
6112                 clang::RecordDecl::field_iterator field, field_end;
6113                 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx)
6114                 {
6115                     if (idx == child_idx)
6116                     {
6117                         // Print the member type if requested
6118                         // Print the member name and equal sign
6119                         child_name.assign(field->getNameAsString().c_str());
6120
6121                         // Figure out the type byte size (field_type_info.first) and
6122                         // alignment (field_type_info.second) from the AST context.
6123                         CompilerType field_clang_type (getASTContext(), field->getType());
6124                         assert(field_idx < record_layout.getFieldCount());
6125                         child_byte_size = field_clang_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
6126
6127                         // Figure out the field offset within the current struct/union/class type
6128                         bit_offset = record_layout.getFieldOffset (field_idx);
6129                         child_byte_offset = bit_offset / 8;
6130                         if (ClangASTContext::FieldIsBitfield (getASTContext(), *field, child_bitfield_bit_size))
6131                             child_bitfield_bit_offset = bit_offset % 8;
6132
6133                         return field_clang_type;
6134                     }
6135                 }
6136             }
6137             break;
6138
6139         case clang::Type::ObjCObject:
6140         case clang::Type::ObjCInterface:
6141             if (idx_is_valid && GetCompleteType(type))
6142             {
6143                 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(parent_qual_type.getTypePtr());
6144                 assert (objc_class_type);
6145                 if (objc_class_type)
6146                 {
6147                     uint32_t child_idx = 0;
6148                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
6149
6150                     if (class_interface_decl)
6151                     {
6152
6153                         const clang::ASTRecordLayout &interface_layout = getASTContext()->getASTObjCInterfaceLayout(class_interface_decl);
6154                         clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
6155                         if (superclass_interface_decl)
6156                         {
6157                             if (omit_empty_base_classes)
6158                             {
6159                                 CompilerType base_class_clang_type (getASTContext(), getASTContext()->getObjCInterfaceType(superclass_interface_decl));
6160                                 if (base_class_clang_type.GetNumChildren(omit_empty_base_classes) > 0)
6161                                 {
6162                                     if (idx == 0)
6163                                     {
6164                                         clang::QualType ivar_qual_type(getASTContext()->getObjCInterfaceType(superclass_interface_decl));
6165
6166
6167                                         child_name.assign(superclass_interface_decl->getNameAsString().c_str());
6168
6169                                         clang::TypeInfo ivar_type_info = getASTContext()->getTypeInfo(ivar_qual_type.getTypePtr());
6170
6171                                         child_byte_size = ivar_type_info.Width / 8;
6172                                         child_byte_offset = 0;
6173                                         child_is_base_class = true;
6174
6175                                         return CompilerType (getASTContext(), ivar_qual_type);
6176                                     }
6177
6178                                     ++child_idx;
6179                                 }
6180                             }
6181                             else
6182                                 ++child_idx;
6183                         }
6184
6185                         const uint32_t superclass_idx = child_idx;
6186
6187                         if (idx < (child_idx + class_interface_decl->ivar_size()))
6188                         {
6189                             clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
6190
6191                             for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
6192                             {
6193                                 if (child_idx == idx)
6194                                 {
6195                                     clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
6196
6197                                     clang::QualType ivar_qual_type(ivar_decl->getType());
6198
6199                                     child_name.assign(ivar_decl->getNameAsString().c_str());
6200
6201                                     clang::TypeInfo  ivar_type_info = getASTContext()->getTypeInfo(ivar_qual_type.getTypePtr());
6202
6203                                     child_byte_size = ivar_type_info.Width / 8;
6204
6205                                     // Figure out the field offset within the current struct/union/class type
6206                                     // For ObjC objects, we can't trust the bit offset we get from the Clang AST, since
6207                                     // that doesn't account for the space taken up by unbacked properties, or from
6208                                     // the changing size of base classes that are newer than this class.
6209                                     // So if we have a process around that we can ask about this object, do so.
6210                                     child_byte_offset = LLDB_INVALID_IVAR_OFFSET;
6211                                     Process *process = nullptr;
6212                                     if (exe_ctx)
6213                                         process = exe_ctx->GetProcessPtr();
6214                                     if (process)
6215                                     {
6216                                         ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
6217                                         if (objc_runtime != nullptr)
6218                                         {
6219                                             CompilerType parent_ast_type (getASTContext(), parent_qual_type);
6220                                             child_byte_offset = objc_runtime->GetByteOffsetForIvar (parent_ast_type, ivar_decl->getNameAsString().c_str());
6221                                         }
6222                                     }
6223
6224                                     // Setting this to UINT32_MAX to make sure we don't compute it twice...
6225                                     bit_offset = UINT32_MAX;
6226
6227                                     if (child_byte_offset == static_cast<int32_t>(LLDB_INVALID_IVAR_OFFSET))
6228                                     {
6229                                         bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
6230                                         child_byte_offset = bit_offset / 8;
6231                                     }
6232
6233                                     // Note, the ObjC Ivar Byte offset is just that, it doesn't account for the bit offset
6234                                     // of a bitfield within its containing object.  So regardless of where we get the byte
6235                                     // offset from, we still need to get the bit offset for bitfields from the layout.
6236
6237                                     if (ClangASTContext::FieldIsBitfield (getASTContext(), ivar_decl, child_bitfield_bit_size))
6238                                     {
6239                                         if (bit_offset == UINT32_MAX)
6240                                             bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
6241
6242                                         child_bitfield_bit_offset = bit_offset % 8;
6243                                     }
6244                                     return CompilerType (getASTContext(), ivar_qual_type);
6245                                 }
6246                                 ++child_idx;
6247                             }
6248                         }
6249                     }
6250                 }
6251             }
6252             break;
6253
6254         case clang::Type::ObjCObjectPointer:
6255             if (idx_is_valid)
6256             {
6257                 CompilerType pointee_clang_type (GetPointeeType(type));
6258
6259                 if (transparent_pointers && pointee_clang_type.IsAggregateType())
6260                 {
6261                     child_is_deref_of_parent = false;
6262                     bool tmp_child_is_deref_of_parent = false;
6263                     return pointee_clang_type.GetChildCompilerTypeAtIndex (exe_ctx,
6264                                                                            idx,
6265                                                                            transparent_pointers,
6266                                                                            omit_empty_base_classes,
6267                                                                            ignore_array_bounds,
6268                                                                            child_name,
6269                                                                            child_byte_size,
6270                                                                            child_byte_offset,
6271                                                                            child_bitfield_bit_size,
6272                                                                            child_bitfield_bit_offset,
6273                                                                            child_is_base_class,
6274                                                                            tmp_child_is_deref_of_parent,
6275                                                                            valobj,
6276                                                                            language_flags);
6277                 }
6278                 else
6279                 {
6280                     child_is_deref_of_parent = true;
6281                     const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
6282                     if (parent_name)
6283                     {
6284                         child_name.assign(1, '*');
6285                         child_name += parent_name;
6286                     }
6287
6288                     // We have a pointer to an simple type
6289                     if (idx == 0 && pointee_clang_type.GetCompleteType())
6290                     {
6291                         child_byte_size = pointee_clang_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
6292                         child_byte_offset = 0;
6293                         return pointee_clang_type;
6294                     }
6295                 }
6296             }
6297             break;
6298
6299         case clang::Type::Vector:
6300         case clang::Type::ExtVector:
6301             if (idx_is_valid)
6302             {
6303                 const clang::VectorType *array = llvm::cast<clang::VectorType>(parent_qual_type.getTypePtr());
6304                 if (array)
6305                 {
6306                     CompilerType element_type (getASTContext(), array->getElementType());
6307                     if (element_type.GetCompleteType())
6308                     {
6309                         char element_name[64];
6310                         ::snprintf (element_name, sizeof (element_name), "[%" PRIu64 "]", static_cast<uint64_t>(idx));
6311                         child_name.assign(element_name);
6312                         child_byte_size = element_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
6313                         child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
6314                         return element_type;
6315                     }
6316                 }
6317             }
6318             break;
6319
6320         case clang::Type::ConstantArray:
6321         case clang::Type::IncompleteArray:
6322             if (ignore_array_bounds || idx_is_valid)
6323             {
6324                 const clang::ArrayType *array = GetQualType(type)->getAsArrayTypeUnsafe();
6325                 if (array)
6326                 {
6327                     CompilerType element_type (getASTContext(), array->getElementType());
6328                     if (element_type.GetCompleteType())
6329                     {
6330                         char element_name[64];
6331                         ::snprintf (element_name, sizeof (element_name), "[%" PRIu64 "]", static_cast<uint64_t>(idx));
6332                         child_name.assign(element_name);
6333                         child_byte_size = element_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
6334                         child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
6335                         return element_type;
6336                     }
6337                 }
6338             }
6339             break;
6340
6341
6342         case clang::Type::Pointer:
6343             if (idx_is_valid)
6344             {
6345                 CompilerType pointee_clang_type (GetPointeeType(type));
6346
6347                 // Don't dereference "void *" pointers
6348                 if (pointee_clang_type.IsVoidType())
6349                     return CompilerType();
6350
6351                 if (transparent_pointers && pointee_clang_type.IsAggregateType ())
6352                 {
6353                     child_is_deref_of_parent = false;
6354                     bool tmp_child_is_deref_of_parent = false;
6355                     return pointee_clang_type.GetChildCompilerTypeAtIndex (exe_ctx,
6356                                                                            idx,
6357                                                                            transparent_pointers,
6358                                                                            omit_empty_base_classes,
6359                                                                            ignore_array_bounds,
6360                                                                            child_name,
6361                                                                            child_byte_size,
6362                                                                            child_byte_offset,
6363                                                                            child_bitfield_bit_size,
6364                                                                            child_bitfield_bit_offset,
6365                                                                            child_is_base_class,
6366                                                                            tmp_child_is_deref_of_parent,
6367                                                                            valobj,
6368                                                                            language_flags);
6369                 }
6370                 else
6371                 {
6372                     child_is_deref_of_parent = true;
6373
6374                     const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
6375                     if (parent_name)
6376                     {
6377                         child_name.assign(1, '*');
6378                         child_name += parent_name;
6379                     }
6380
6381                     // We have a pointer to an simple type
6382                     if (idx == 0)
6383                     {
6384                         child_byte_size = pointee_clang_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
6385                         child_byte_offset = 0;
6386                         return pointee_clang_type;
6387                     }
6388                 }
6389             }
6390             break;
6391
6392         case clang::Type::LValueReference:
6393         case clang::Type::RValueReference:
6394             if (idx_is_valid)
6395             {
6396                 const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(parent_qual_type.getTypePtr());
6397                 CompilerType pointee_clang_type (getASTContext(), reference_type->getPointeeType());
6398                 if (transparent_pointers && pointee_clang_type.IsAggregateType ())
6399                 {
6400                     child_is_deref_of_parent = false;
6401                     bool tmp_child_is_deref_of_parent = false;
6402                     return pointee_clang_type.GetChildCompilerTypeAtIndex (exe_ctx,
6403                                                                            idx,
6404                                                                            transparent_pointers,
6405                                                                            omit_empty_base_classes,
6406                                                                            ignore_array_bounds,
6407                                                                            child_name,
6408                                                                            child_byte_size,
6409                                                                            child_byte_offset,
6410                                                                            child_bitfield_bit_size,
6411                                                                            child_bitfield_bit_offset,
6412                                                                            child_is_base_class,
6413                                                                            tmp_child_is_deref_of_parent,
6414                                                                            valobj,
6415                                                                            language_flags);
6416                 }
6417                 else
6418                 {
6419                     const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL;
6420                     if (parent_name)
6421                     {
6422                         child_name.assign(1, '&');
6423                         child_name += parent_name;
6424                     }
6425
6426                     // We have a pointer to an simple type
6427                     if (idx == 0)
6428                     {
6429                         child_byte_size = pointee_clang_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
6430                         child_byte_offset = 0;
6431                         return pointee_clang_type;
6432                     }
6433                 }
6434             }
6435             break;
6436
6437         case clang::Type::Typedef:
6438         {
6439             CompilerType typedefed_clang_type (getASTContext(), llvm::cast<clang::TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType());
6440             return typedefed_clang_type.GetChildCompilerTypeAtIndex (exe_ctx,
6441                                                                      idx,
6442                                                                      transparent_pointers,
6443                                                                      omit_empty_base_classes,
6444                                                                      ignore_array_bounds,
6445                                                                      child_name,
6446                                                                      child_byte_size,
6447                                                                      child_byte_offset,
6448                                                                      child_bitfield_bit_size,
6449                                                                      child_bitfield_bit_offset,
6450                                                                      child_is_base_class,
6451                                                                      child_is_deref_of_parent,
6452                                                                      valobj,
6453                                                                      language_flags);
6454         }
6455             break;
6456
6457         case clang::Type::Auto:
6458         {
6459             CompilerType elaborated_clang_type (getASTContext(), llvm::cast<clang::AutoType>(parent_qual_type)->getDeducedType());
6460             return elaborated_clang_type.GetChildCompilerTypeAtIndex (exe_ctx,
6461                                                                       idx,
6462                                                                       transparent_pointers,
6463                                                                       omit_empty_base_classes,
6464                                                                       ignore_array_bounds,
6465                                                                       child_name,
6466                                                                       child_byte_size,
6467                                                                       child_byte_offset,
6468                                                                       child_bitfield_bit_size,
6469                                                                       child_bitfield_bit_offset,
6470                                                                       child_is_base_class,
6471                                                                       child_is_deref_of_parent,
6472                                                                       valobj,
6473                                                                       language_flags);
6474         }
6475
6476         case clang::Type::Elaborated:
6477         {
6478             CompilerType elaborated_clang_type (getASTContext(), llvm::cast<clang::ElaboratedType>(parent_qual_type)->getNamedType());
6479             return elaborated_clang_type.GetChildCompilerTypeAtIndex (exe_ctx,
6480                                                                       idx,
6481                                                                       transparent_pointers,
6482                                                                       omit_empty_base_classes,
6483                                                                       ignore_array_bounds,
6484                                                                       child_name,
6485                                                                       child_byte_size,
6486                                                                       child_byte_offset,
6487                                                                       child_bitfield_bit_size,
6488                                                                       child_bitfield_bit_offset,
6489                                                                       child_is_base_class,
6490                                                                       child_is_deref_of_parent,
6491                                                                       valobj,
6492                                                                       language_flags);
6493         }
6494
6495         case clang::Type::Paren:
6496         {
6497             CompilerType paren_clang_type (getASTContext(), llvm::cast<clang::ParenType>(parent_qual_type)->desugar());
6498             return paren_clang_type.GetChildCompilerTypeAtIndex (exe_ctx,
6499                                                                  idx,
6500                                                                  transparent_pointers,
6501                                                                  omit_empty_base_classes,
6502                                                                  ignore_array_bounds,
6503                                                                  child_name,
6504                                                                  child_byte_size,
6505                                                                  child_byte_offset,
6506                                                                  child_bitfield_bit_size,
6507                                                                  child_bitfield_bit_offset,
6508                                                                  child_is_base_class,
6509                                                                  child_is_deref_of_parent,
6510                                                                  valobj,
6511                                                                  language_flags);
6512         }
6513
6514
6515         default:
6516             break;
6517     }
6518     return CompilerType();
6519 }
6520
6521 static uint32_t
6522 GetIndexForRecordBase
6523 (
6524  const clang::RecordDecl *record_decl,
6525  const clang::CXXBaseSpecifier *base_spec,
6526  bool omit_empty_base_classes
6527  )
6528 {
6529     uint32_t child_idx = 0;
6530
6531     const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
6532
6533     //    const char *super_name = record_decl->getNameAsCString();
6534     //    const char *base_name = base_spec->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString();
6535     //    printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name);
6536     //
6537     if (cxx_record_decl)
6538     {
6539         clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
6540         for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
6541              base_class != base_class_end;
6542              ++base_class)
6543         {
6544             if (omit_empty_base_classes)
6545             {
6546                 if (BaseSpecifierIsEmpty (base_class))
6547                     continue;
6548             }
6549
6550             //            printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name,
6551             //                    child_idx,
6552             //                    base_class->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString());
6553             //
6554             //
6555             if (base_class == base_spec)
6556                 return child_idx;
6557             ++child_idx;
6558         }
6559     }
6560
6561     return UINT32_MAX;
6562 }
6563
6564
6565 static uint32_t
6566 GetIndexForRecordChild (const clang::RecordDecl *record_decl,
6567                         clang::NamedDecl *canonical_decl,
6568                         bool omit_empty_base_classes)
6569 {
6570     uint32_t child_idx = ClangASTContext::GetNumBaseClasses (llvm::dyn_cast<clang::CXXRecordDecl>(record_decl),
6571                                                              omit_empty_base_classes);
6572
6573     clang::RecordDecl::field_iterator field, field_end;
6574     for (field = record_decl->field_begin(), field_end = record_decl->field_end();
6575          field != field_end;
6576          ++field, ++child_idx)
6577     {
6578         if (field->getCanonicalDecl() == canonical_decl)
6579             return child_idx;
6580     }
6581
6582     return UINT32_MAX;
6583 }
6584
6585 // Look for a child member (doesn't include base classes, but it does include
6586 // their members) in the type hierarchy. Returns an index path into "clang_type"
6587 // on how to reach the appropriate member.
6588 //
6589 //    class A
6590 //    {
6591 //    public:
6592 //        int m_a;
6593 //        int m_b;
6594 //    };
6595 //
6596 //    class B
6597 //    {
6598 //    };
6599 //
6600 //    class C :
6601 //        public B,
6602 //        public A
6603 //    {
6604 //    };
6605 //
6606 // If we have a clang type that describes "class C", and we wanted to looked
6607 // "m_b" in it:
6608 //
6609 // With omit_empty_base_classes == false we would get an integer array back with:
6610 // { 1,  1 }
6611 // The first index 1 is the child index for "class A" within class C
6612 // The second index 1 is the child index for "m_b" within class A
6613 //
6614 // With omit_empty_base_classes == true we would get an integer array back with:
6615 // { 0,  1 }
6616 // 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)
6617 // The second index 1 is the child index for "m_b" within class A
6618
6619 size_t
6620 ClangASTContext::GetIndexOfChildMemberWithName (lldb::opaque_compiler_type_t type, const char *name,
6621                                                    bool omit_empty_base_classes,
6622                                                    std::vector<uint32_t>& child_indexes)
6623 {
6624     if (type && name && name[0])
6625     {
6626         clang::QualType qual_type(GetCanonicalQualType(type));
6627         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6628         switch (type_class)
6629         {
6630             case clang::Type::Record:
6631                 if (GetCompleteType(type))
6632                 {
6633                     const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
6634                     const clang::RecordDecl *record_decl = record_type->getDecl();
6635
6636                     assert(record_decl);
6637                     uint32_t child_idx = 0;
6638
6639                     const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
6640
6641                     // Try and find a field that matches NAME
6642                     clang::RecordDecl::field_iterator field, field_end;
6643                     llvm::StringRef name_sref(name);
6644                     for (field = record_decl->field_begin(), field_end = record_decl->field_end();
6645                          field != field_end;
6646                          ++field, ++child_idx)
6647                     {
6648                         llvm::StringRef field_name = field->getName();
6649                         if (field_name.empty())
6650                         {
6651                             CompilerType field_type(getASTContext(),field->getType());
6652                             child_indexes.push_back(child_idx);
6653                             if (field_type.GetIndexOfChildMemberWithName(name,  omit_empty_base_classes, child_indexes))
6654                                 return child_indexes.size();
6655                             child_indexes.pop_back();
6656
6657                         }
6658                         else if (field_name.equals (name_sref))
6659                         {
6660                             // We have to add on the number of base classes to this index!
6661                             child_indexes.push_back (child_idx + ClangASTContext::GetNumBaseClasses (cxx_record_decl, omit_empty_base_classes));
6662                             return child_indexes.size();
6663                         }
6664                     }
6665
6666                     if (cxx_record_decl)
6667                     {
6668                         const clang::RecordDecl *parent_record_decl = cxx_record_decl;
6669
6670                         //printf ("parent = %s\n", parent_record_decl->getNameAsCString());
6671
6672                         //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl();
6673                         // Didn't find things easily, lets let clang do its thang...
6674                         clang::IdentifierInfo & ident_ref = getASTContext()->Idents.get(name_sref);
6675                         clang::DeclarationName decl_name(&ident_ref);
6676
6677                         clang::CXXBasePaths paths;
6678                         if (cxx_record_decl->lookupInBases([decl_name](const clang::CXXBaseSpecifier *specifier, clang::CXXBasePath &path) {
6679                                                                return clang::CXXRecordDecl::FindOrdinaryMember(specifier, path, decl_name);
6680                                                            },
6681                                                            paths))
6682                         {
6683                             clang::CXXBasePaths::const_paths_iterator path, path_end = paths.end();
6684                             for (path = paths.begin(); path != path_end; ++path)
6685                             {
6686                                 const size_t num_path_elements = path->size();
6687                                 for (size_t e=0; e<num_path_elements; ++e)
6688                                 {
6689                                     clang::CXXBasePathElement elem = (*path)[e];
6690
6691                                     child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes);
6692                                     if (child_idx == UINT32_MAX)
6693                                     {
6694                                         child_indexes.clear();
6695                                         return 0;
6696                                     }
6697                                     else
6698                                     {
6699                                         child_indexes.push_back (child_idx);
6700                                         parent_record_decl = llvm::cast<clang::RecordDecl>(elem.Base->getType()->getAs<clang::RecordType>()->getDecl());
6701                                     }
6702                                 }
6703                                 for (clang::NamedDecl *path_decl : path->Decls)
6704                                 {
6705                                     child_idx = GetIndexForRecordChild (parent_record_decl, path_decl, omit_empty_base_classes);
6706                                     if (child_idx == UINT32_MAX)
6707                                     {
6708                                         child_indexes.clear();
6709                                         return 0;
6710                                     }
6711                                     else
6712                                     {
6713                                         child_indexes.push_back (child_idx);
6714                                     }
6715                                 }
6716                             }
6717                             return child_indexes.size();
6718                         }
6719                     }
6720
6721                 }
6722                 break;
6723
6724             case clang::Type::ObjCObject:
6725             case clang::Type::ObjCInterface:
6726                 if (GetCompleteType(type))
6727                 {
6728                     llvm::StringRef name_sref(name);
6729                     const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
6730                     assert (objc_class_type);
6731                     if (objc_class_type)
6732                     {
6733                         uint32_t child_idx = 0;
6734                         clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
6735
6736                         if (class_interface_decl)
6737                         {
6738                             clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
6739                             clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
6740
6741                             for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
6742                             {
6743                                 const clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
6744
6745                                 if (ivar_decl->getName().equals (name_sref))
6746                                 {
6747                                     if ((!omit_empty_base_classes && superclass_interface_decl) ||
6748                                         ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
6749                                         ++child_idx;
6750
6751                                     child_indexes.push_back (child_idx);
6752                                     return child_indexes.size();
6753                                 }
6754                             }
6755
6756                             if (superclass_interface_decl)
6757                             {
6758                                 // The super class index is always zero for ObjC classes,
6759                                 // so we push it onto the child indexes in case we find
6760                                 // an ivar in our superclass...
6761                                 child_indexes.push_back (0);
6762
6763                                 CompilerType superclass_clang_type (getASTContext(), getASTContext()->getObjCInterfaceType(superclass_interface_decl));
6764                                 if (superclass_clang_type.GetIndexOfChildMemberWithName (name,
6765                                                                                          omit_empty_base_classes,
6766                                                                                          child_indexes))
6767                                 {
6768                                     // We did find an ivar in a superclass so just
6769                                     // return the results!
6770                                     return child_indexes.size();
6771                                 }
6772
6773                                 // We didn't find an ivar matching "name" in our
6774                                 // superclass, pop the superclass zero index that
6775                                 // we pushed on above.
6776                                 child_indexes.pop_back();
6777                             }
6778                         }
6779                     }
6780                 }
6781                 break;
6782
6783             case clang::Type::ObjCObjectPointer:
6784             {
6785                 CompilerType objc_object_clang_type (getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType());
6786                 return objc_object_clang_type.GetIndexOfChildMemberWithName (name,
6787                                                                              omit_empty_base_classes,
6788                                                                              child_indexes);
6789             }
6790                 break;
6791
6792
6793             case clang::Type::ConstantArray:
6794             {
6795                 //                const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr());
6796                 //                const uint64_t element_count = array->getSize().getLimitedValue();
6797                 //
6798                 //                if (idx < element_count)
6799                 //                {
6800                 //                    std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
6801                 //
6802                 //                    char element_name[32];
6803                 //                    ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
6804                 //
6805                 //                    child_name.assign(element_name);
6806                 //                    assert(field_type_info.first % 8 == 0);
6807                 //                    child_byte_size = field_type_info.first / 8;
6808                 //                    child_byte_offset = idx * child_byte_size;
6809                 //                    return array->getElementType().getAsOpaquePtr();
6810                 //                }
6811             }
6812                 break;
6813
6814                 //        case clang::Type::MemberPointerType:
6815                 //            {
6816                 //                MemberPointerType *mem_ptr_type = llvm::cast<MemberPointerType>(qual_type.getTypePtr());
6817                 //                clang::QualType pointee_type = mem_ptr_type->getPointeeType();
6818                 //
6819                 //                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
6820                 //                {
6821                 //                    return GetIndexOfChildWithName (ast,
6822                 //                                                    mem_ptr_type->getPointeeType().getAsOpaquePtr(),
6823                 //                                                    name);
6824                 //                }
6825                 //            }
6826                 //            break;
6827                 //
6828             case clang::Type::LValueReference:
6829             case clang::Type::RValueReference:
6830             {
6831                 const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
6832                 clang::QualType pointee_type(reference_type->getPointeeType());
6833                 CompilerType pointee_clang_type (getASTContext(), pointee_type);
6834
6835                 if (pointee_clang_type.IsAggregateType ())
6836                 {
6837                     return pointee_clang_type.GetIndexOfChildMemberWithName (name,
6838                                                                              omit_empty_base_classes,
6839                                                                              child_indexes);
6840                 }
6841             }
6842                 break;
6843
6844             case clang::Type::Pointer:
6845             {
6846                 CompilerType pointee_clang_type (GetPointeeType(type));
6847
6848                 if (pointee_clang_type.IsAggregateType ())
6849                 {
6850                     return pointee_clang_type.GetIndexOfChildMemberWithName (name,
6851                                                                              omit_empty_base_classes,
6852                                                                              child_indexes);
6853                 }
6854             }
6855                 break;
6856
6857             case clang::Type::Typedef:
6858                 return CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildMemberWithName (name,
6859                                                                                                                                                                 omit_empty_base_classes,
6860                                                                                                                                                                 child_indexes);
6861
6862             case clang::Type::Auto:
6863                 return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetIndexOfChildMemberWithName (name,
6864                                                                                                                                                omit_empty_base_classes,
6865                                                                                                                                                child_indexes);
6866
6867             case clang::Type::Elaborated:
6868                 return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildMemberWithName (name,
6869                                                                                                                                                    omit_empty_base_classes,
6870                                                                                                                                                    child_indexes);
6871
6872             case clang::Type::Paren:
6873                 return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildMemberWithName (name,
6874                                                                                                                                          omit_empty_base_classes,
6875                                                                                                                                          child_indexes);
6876
6877             default:
6878                 break;
6879         }
6880     }
6881     return 0;
6882 }
6883
6884
6885 // Get the index of the child of "clang_type" whose name matches. This function
6886 // doesn't descend into the children, but only looks one level deep and name
6887 // matches can include base class names.
6888
6889 uint32_t
6890 ClangASTContext::GetIndexOfChildWithName (lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes)
6891 {
6892     if (type && name && name[0])
6893     {
6894         clang::QualType qual_type(GetCanonicalQualType(type));
6895
6896         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6897
6898         switch (type_class)
6899         {
6900             case clang::Type::Record:
6901                 if (GetCompleteType(type))
6902                 {
6903                     const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
6904                     const clang::RecordDecl *record_decl = record_type->getDecl();
6905
6906                     assert(record_decl);
6907                     uint32_t child_idx = 0;
6908
6909                     const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
6910
6911                     if (cxx_record_decl)
6912                     {
6913                         clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
6914                         for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
6915                              base_class != base_class_end;
6916                              ++base_class)
6917                         {
6918                             // Skip empty base classes
6919                             clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
6920                             if (omit_empty_base_classes && ClangASTContext::RecordHasFields(base_class_decl) == false)
6921                                 continue;
6922
6923                             CompilerType base_class_clang_type (getASTContext(), base_class->getType());
6924                             std::string base_class_type_name (base_class_clang_type.GetTypeName().AsCString(""));
6925                             if (base_class_type_name.compare (name) == 0)
6926                                 return child_idx;
6927                             ++child_idx;
6928                         }
6929                     }
6930
6931                     // Try and find a field that matches NAME
6932                     clang::RecordDecl::field_iterator field, field_end;
6933                     llvm::StringRef name_sref(name);
6934                     for (field = record_decl->field_begin(), field_end = record_decl->field_end();
6935                          field != field_end;
6936                          ++field, ++child_idx)
6937                     {
6938                         if (field->getName().equals (name_sref))
6939                             return child_idx;
6940                     }
6941
6942                 }
6943                 break;
6944
6945             case clang::Type::ObjCObject:
6946             case clang::Type::ObjCInterface:
6947                 if (GetCompleteType(type))
6948                 {
6949                     llvm::StringRef name_sref(name);
6950                     const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
6951                     assert (objc_class_type);
6952                     if (objc_class_type)
6953                     {
6954                         uint32_t child_idx = 0;
6955                         clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
6956
6957                         if (class_interface_decl)
6958                         {
6959                             clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
6960                             clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
6961
6962                             for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
6963                             {
6964                                 const clang::ObjCIvarDecl* ivar_decl = *ivar_pos;
6965
6966                                 if (ivar_decl->getName().equals (name_sref))
6967                                 {
6968                                     if ((!omit_empty_base_classes && superclass_interface_decl) ||
6969                                         ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
6970                                         ++child_idx;
6971
6972                                     return child_idx;
6973                                 }
6974                             }
6975
6976                             if (superclass_interface_decl)
6977                             {
6978                                 if (superclass_interface_decl->getName().equals (name_sref))
6979                                     return 0;
6980                             }
6981                         }
6982                     }
6983                 }
6984                 break;
6985
6986             case clang::Type::ObjCObjectPointer:
6987             {
6988                 CompilerType pointee_clang_type (getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType());
6989                 return pointee_clang_type.GetIndexOfChildWithName (name, omit_empty_base_classes);
6990             }
6991                 break;
6992
6993             case clang::Type::ConstantArray:
6994             {
6995                 //                const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr());
6996                 //                const uint64_t element_count = array->getSize().getLimitedValue();
6997                 //
6998                 //                if (idx < element_count)
6999                 //                {
7000                 //                    std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
7001                 //
7002                 //                    char element_name[32];
7003                 //                    ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
7004                 //
7005                 //                    child_name.assign(element_name);
7006                 //                    assert(field_type_info.first % 8 == 0);
7007                 //                    child_byte_size = field_type_info.first / 8;
7008                 //                    child_byte_offset = idx * child_byte_size;
7009                 //                    return array->getElementType().getAsOpaquePtr();
7010                 //                }
7011             }
7012                 break;
7013
7014                 //        case clang::Type::MemberPointerType:
7015                 //            {
7016                 //                MemberPointerType *mem_ptr_type = llvm::cast<MemberPointerType>(qual_type.getTypePtr());
7017                 //                clang::QualType pointee_type = mem_ptr_type->getPointeeType();
7018                 //
7019                 //                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
7020                 //                {
7021                 //                    return GetIndexOfChildWithName (ast,
7022                 //                                                    mem_ptr_type->getPointeeType().getAsOpaquePtr(),
7023                 //                                                    name);
7024                 //                }
7025                 //            }
7026                 //            break;
7027                 //
7028             case clang::Type::LValueReference:
7029             case clang::Type::RValueReference:
7030             {
7031                 const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
7032                 CompilerType pointee_type (getASTContext(), reference_type->getPointeeType());
7033
7034                 if (pointee_type.IsAggregateType ())
7035                 {
7036                     return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes);
7037                 }
7038             }
7039                 break;
7040
7041             case clang::Type::Pointer:
7042             {
7043                 const clang::PointerType *pointer_type = llvm::cast<clang::PointerType>(qual_type.getTypePtr());
7044                 CompilerType pointee_type (getASTContext(), pointer_type->getPointeeType());
7045
7046                 if (pointee_type.IsAggregateType ())
7047                 {
7048                     return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes);
7049                 }
7050                 else
7051                 {
7052                     //                    if (parent_name)
7053                     //                    {
7054                     //                        child_name.assign(1, '*');
7055                     //                        child_name += parent_name;
7056                     //                    }
7057                     //
7058                     //                    // We have a pointer to an simple type
7059                     //                    if (idx == 0)
7060                     //                    {
7061                     //                        std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
7062                     //                        assert(clang_type_info.first % 8 == 0);
7063                     //                        child_byte_size = clang_type_info.first / 8;
7064                     //                        child_byte_offset = 0;
7065                     //                        return pointee_type.getAsOpaquePtr();
7066                     //                    }
7067                 }
7068             }
7069                 break;
7070
7071             case clang::Type::Auto:
7072                 return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetIndexOfChildWithName (name, omit_empty_base_classes);
7073
7074             case clang::Type::Elaborated:
7075                 return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildWithName (name, omit_empty_base_classes);
7076
7077             case clang::Type::Paren:
7078                 return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildWithName (name, omit_empty_base_classes);
7079
7080             case clang::Type::Typedef:
7081                 return CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildWithName (name, omit_empty_base_classes);
7082
7083             default:
7084                 break;
7085         }
7086     }
7087     return UINT32_MAX;
7088 }
7089
7090
7091 size_t
7092 ClangASTContext::GetNumTemplateArguments (lldb::opaque_compiler_type_t type)
7093 {
7094     if (!type)
7095         return 0;
7096
7097     clang::QualType qual_type (GetCanonicalQualType(type));
7098     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
7099     switch (type_class)
7100     {
7101         case clang::Type::Record:
7102             if (GetCompleteType(type))
7103             {
7104                 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
7105                 if (cxx_record_decl)
7106                 {
7107                     const clang::ClassTemplateSpecializationDecl *template_decl = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(cxx_record_decl);
7108                     if (template_decl)
7109                         return template_decl->getTemplateArgs().size();
7110                 }
7111             }
7112             break;
7113
7114         case clang::Type::Typedef:
7115             return (CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType())).GetNumTemplateArguments();
7116
7117         case clang::Type::Auto:
7118             return (CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType())).GetNumTemplateArguments();
7119
7120         case clang::Type::Elaborated:
7121             return (CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())).GetNumTemplateArguments();
7122
7123         case clang::Type::Paren:
7124             return (CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar())).GetNumTemplateArguments();
7125
7126         default:
7127             break;
7128     }
7129
7130     return 0;
7131 }
7132
7133 CompilerType
7134 ClangASTContext::GetTemplateArgument (lldb::opaque_compiler_type_t type, size_t arg_idx, lldb::TemplateArgumentKind &kind)
7135 {
7136     if (!type)
7137         return CompilerType();
7138
7139     clang::QualType qual_type (GetCanonicalQualType(type));
7140     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
7141     switch (type_class)
7142     {
7143         case clang::Type::Record:
7144             if (GetCompleteType(type))
7145             {
7146                 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
7147                 if (cxx_record_decl)
7148                 {
7149                     const clang::ClassTemplateSpecializationDecl *template_decl = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(cxx_record_decl);
7150                     if (template_decl && arg_idx < template_decl->getTemplateArgs().size())
7151                     {
7152                         const clang::TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx];
7153                         switch (template_arg.getKind())
7154                         {
7155                             case clang::TemplateArgument::Null:
7156                                 kind = eTemplateArgumentKindNull;
7157                                 return CompilerType();
7158
7159                             case clang::TemplateArgument::Type:
7160                                 kind = eTemplateArgumentKindType;
7161                                 return CompilerType(getASTContext(), template_arg.getAsType());
7162
7163                             case clang::TemplateArgument::Declaration:
7164                                 kind = eTemplateArgumentKindDeclaration;
7165                                 return CompilerType();
7166
7167                             case clang::TemplateArgument::Integral:
7168                                 kind = eTemplateArgumentKindIntegral;
7169                                 return CompilerType(getASTContext(), template_arg.getIntegralType());
7170
7171                             case clang::TemplateArgument::Template:
7172                                 kind = eTemplateArgumentKindTemplate;
7173                                 return CompilerType();
7174
7175                             case clang::TemplateArgument::TemplateExpansion:
7176                                 kind = eTemplateArgumentKindTemplateExpansion;
7177                                 return CompilerType();
7178
7179                             case clang::TemplateArgument::Expression:
7180                                 kind = eTemplateArgumentKindExpression;
7181                                 return CompilerType();
7182
7183                             case clang::TemplateArgument::Pack:
7184                                 kind = eTemplateArgumentKindPack;
7185                                 return CompilerType();
7186
7187                             default:
7188                                 assert (!"Unhandled clang::TemplateArgument::ArgKind");
7189                                 break;
7190                         }
7191                     }
7192                 }
7193             }
7194             break;
7195
7196         case clang::Type::Typedef:
7197             return (CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType())).GetTemplateArgument(arg_idx, kind);
7198
7199         case clang::Type::Auto:
7200             return (CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType())).GetTemplateArgument(arg_idx, kind);
7201
7202         case clang::Type::Elaborated:
7203             return (CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())).GetTemplateArgument(arg_idx, kind);
7204
7205         case clang::Type::Paren:
7206             return (CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar())).GetTemplateArgument(arg_idx, kind);
7207
7208         default:
7209             break;
7210     }
7211     kind = eTemplateArgumentKindNull;
7212     return CompilerType ();
7213 }
7214
7215 CompilerType
7216 ClangASTContext::GetTypeForFormatters (void* type)
7217 {
7218     if (type)
7219         return RemoveFastQualifiers(CompilerType(this, type));
7220     return CompilerType();
7221 }
7222
7223 static bool
7224 IsOperator (const char *name, clang::OverloadedOperatorKind &op_kind)
7225 {
7226     if (name == nullptr || name[0] == '\0')
7227         return false;
7228
7229 #define OPERATOR_PREFIX "operator"
7230 #define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1)
7231
7232     const char *post_op_name = nullptr;
7233
7234     bool no_space = true;
7235
7236     if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH))
7237         return false;
7238
7239     post_op_name = name + OPERATOR_PREFIX_LENGTH;
7240
7241     if (post_op_name[0] == ' ')
7242     {
7243         post_op_name++;
7244         no_space = false;
7245     }
7246
7247 #undef OPERATOR_PREFIX
7248 #undef OPERATOR_PREFIX_LENGTH
7249
7250     // This is an operator, set the overloaded operator kind to invalid
7251     // in case this is a conversion operator...
7252     op_kind = clang::NUM_OVERLOADED_OPERATORS;
7253
7254     switch (post_op_name[0])
7255     {
7256         default:
7257             if (no_space)
7258                 return false;
7259             break;
7260         case 'n':
7261             if (no_space)
7262                 return false;
7263             if  (strcmp (post_op_name, "new") == 0)
7264                 op_kind = clang::OO_New;
7265             else if (strcmp (post_op_name, "new[]") == 0)
7266                 op_kind = clang::OO_Array_New;
7267             break;
7268
7269         case 'd':
7270             if (no_space)
7271                 return false;
7272             if (strcmp (post_op_name, "delete") == 0)
7273                 op_kind = clang::OO_Delete;
7274             else if (strcmp (post_op_name, "delete[]") == 0)
7275                 op_kind = clang::OO_Array_Delete;
7276             break;
7277
7278         case '+':
7279             if (post_op_name[1] == '\0')
7280                 op_kind = clang::OO_Plus;
7281             else if (post_op_name[2] == '\0')
7282             {
7283                 if (post_op_name[1] == '=')
7284                     op_kind = clang::OO_PlusEqual;
7285                 else if (post_op_name[1] == '+')
7286                     op_kind = clang::OO_PlusPlus;
7287             }
7288             break;
7289
7290         case '-':
7291             if (post_op_name[1] == '\0')
7292                 op_kind = clang::OO_Minus;
7293             else if (post_op_name[2] == '\0')
7294             {
7295                 switch (post_op_name[1])
7296                 {
7297                     case '=': op_kind = clang::OO_MinusEqual; break;
7298                     case '-': op_kind = clang::OO_MinusMinus; break;
7299                     case '>': op_kind = clang::OO_Arrow; break;
7300                 }
7301             }
7302             else if (post_op_name[3] == '\0')
7303             {
7304                 if (post_op_name[2] == '*')
7305                     op_kind = clang::OO_ArrowStar; break;
7306             }
7307             break;
7308
7309         case '*':
7310             if (post_op_name[1] == '\0')
7311                 op_kind = clang::OO_Star;
7312             else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
7313                 op_kind = clang::OO_StarEqual;
7314             break;
7315
7316         case '/':
7317             if (post_op_name[1] == '\0')
7318                 op_kind = clang::OO_Slash;
7319             else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
7320                 op_kind = clang::OO_SlashEqual;
7321             break;
7322
7323         case '%':
7324             if (post_op_name[1] == '\0')
7325                 op_kind = clang::OO_Percent;
7326             else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
7327                 op_kind = clang::OO_PercentEqual;
7328             break;
7329
7330
7331         case '^':
7332             if (post_op_name[1] == '\0')
7333                 op_kind = clang::OO_Caret;
7334             else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
7335                 op_kind = clang::OO_CaretEqual;
7336             break;
7337
7338         case '&':
7339             if (post_op_name[1] == '\0')
7340                 op_kind = clang::OO_Amp;
7341             else if (post_op_name[2] == '\0')
7342             {
7343                 switch (post_op_name[1])
7344                 {
7345                     case '=': op_kind = clang::OO_AmpEqual; break;
7346                     case '&': op_kind = clang::OO_AmpAmp; break;
7347                 }
7348             }
7349             break;
7350
7351         case '|':
7352             if (post_op_name[1] == '\0')
7353                 op_kind = clang::OO_Pipe;
7354             else if (post_op_name[2] == '\0')
7355             {
7356                 switch (post_op_name[1])
7357                 {
7358                     case '=': op_kind = clang::OO_PipeEqual; break;
7359                     case '|': op_kind = clang::OO_PipePipe; break;
7360                 }
7361             }
7362             break;
7363
7364         case '~':
7365             if (post_op_name[1] == '\0')
7366                 op_kind = clang::OO_Tilde;
7367             break;
7368
7369         case '!':
7370             if (post_op_name[1] == '\0')
7371                 op_kind = clang::OO_Exclaim;
7372             else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
7373                 op_kind = clang::OO_ExclaimEqual;
7374             break;
7375
7376         case '=':
7377             if (post_op_name[1] == '\0')
7378                 op_kind = clang::OO_Equal;
7379             else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
7380                 op_kind = clang::OO_EqualEqual;
7381             break;
7382
7383         case '<':
7384             if (post_op_name[1] == '\0')
7385                 op_kind = clang::OO_Less;
7386             else if (post_op_name[2] == '\0')
7387             {
7388                 switch (post_op_name[1])
7389                 {
7390                     case '<': op_kind = clang::OO_LessLess; break;
7391                     case '=': op_kind = clang::OO_LessEqual; break;
7392                 }
7393             }
7394             else if (post_op_name[3] == '\0')
7395             {
7396                 if (post_op_name[2] == '=')
7397                     op_kind = clang::OO_LessLessEqual;
7398             }
7399             break;
7400
7401         case '>':
7402             if (post_op_name[1] == '\0')
7403                 op_kind = clang::OO_Greater;
7404             else if (post_op_name[2] == '\0')
7405             {
7406                 switch (post_op_name[1])
7407                 {
7408                     case '>': op_kind = clang::OO_GreaterGreater; break;
7409                     case '=': op_kind = clang::OO_GreaterEqual; break;
7410                 }
7411             }
7412             else if (post_op_name[1] == '>' &&
7413                      post_op_name[2] == '=' &&
7414                      post_op_name[3] == '\0')
7415             {
7416                 op_kind = clang::OO_GreaterGreaterEqual;
7417             }
7418             break;
7419
7420         case ',':
7421             if (post_op_name[1] == '\0')
7422                 op_kind = clang::OO_Comma;
7423             break;
7424
7425         case '(':
7426             if (post_op_name[1] == ')' && post_op_name[2] == '\0')
7427                 op_kind = clang::OO_Call;
7428             break;
7429
7430         case '[':
7431             if (post_op_name[1] == ']' && post_op_name[2] == '\0')
7432                 op_kind = clang::OO_Subscript;
7433             break;
7434     }
7435
7436     return true;
7437 }
7438
7439 clang::EnumDecl *
7440 ClangASTContext::GetAsEnumDecl (const CompilerType& type)
7441 {
7442     const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type));
7443     if (enutype)
7444         return enutype->getDecl();
7445     return NULL;
7446 }
7447
7448 clang::RecordDecl *
7449 ClangASTContext::GetAsRecordDecl (const CompilerType& type)
7450 {
7451     const clang::RecordType *record_type = llvm::dyn_cast<clang::RecordType>(GetCanonicalQualType(type));
7452     if (record_type)
7453         return record_type->getDecl();
7454     return nullptr;
7455 }
7456
7457 clang::TagDecl *
7458 ClangASTContext::GetAsTagDecl (const CompilerType& type)
7459 {
7460     clang::QualType qual_type = GetCanonicalQualType(type);
7461     if (qual_type.isNull())
7462         return nullptr;
7463     else
7464         return qual_type->getAsTagDecl();
7465 }
7466
7467 clang::CXXRecordDecl *
7468 ClangASTContext::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t type)
7469 {
7470     return GetCanonicalQualType(type)->getAsCXXRecordDecl();
7471 }
7472
7473 clang::ObjCInterfaceDecl *
7474 ClangASTContext::GetAsObjCInterfaceDecl (const CompilerType& type)
7475 {
7476     const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(GetCanonicalQualType(type));
7477     if (objc_class_type)
7478         return objc_class_type->getInterface();
7479     return nullptr;
7480 }
7481
7482 clang::FieldDecl *
7483 ClangASTContext::AddFieldToRecordType (const CompilerType& type, const char *name,
7484                                        const CompilerType &field_clang_type,
7485                                        AccessType access,
7486                                        uint32_t bitfield_bit_size)
7487 {
7488     if (!type.IsValid() || !field_clang_type.IsValid())
7489         return nullptr;
7490     ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem());
7491     if (!ast)
7492         return nullptr;
7493     clang::ASTContext* clang_ast = ast->getASTContext();
7494
7495     clang::FieldDecl *field = nullptr;
7496
7497     clang::Expr *bit_width = nullptr;
7498     if (bitfield_bit_size != 0)
7499     {
7500         llvm::APInt bitfield_bit_size_apint(clang_ast->getTypeSize(clang_ast->IntTy), bitfield_bit_size);
7501         bit_width = new (*clang_ast)clang::IntegerLiteral (*clang_ast, bitfield_bit_size_apint, clang_ast->IntTy, clang::SourceLocation());
7502     }
7503
7504     clang::RecordDecl *record_decl = ast->GetAsRecordDecl (type);
7505     if (record_decl)
7506     {
7507         field = clang::FieldDecl::Create (*clang_ast,
7508                                           record_decl,
7509                                           clang::SourceLocation(),
7510                                           clang::SourceLocation(),
7511                                           name ? &clang_ast->Idents.get(name) : nullptr,  // Identifier
7512                                           GetQualType(field_clang_type),             // Field type
7513                                           nullptr,                                    // TInfo *
7514                                           bit_width,                                  // BitWidth
7515                                           false,                                      // Mutable
7516                                           clang::ICIS_NoInit);                        // HasInit
7517
7518         if (!name)
7519         {
7520             // Determine whether this field corresponds to an anonymous
7521             // struct or union.
7522             if (const clang::TagType *TagT = field->getType()->getAs<clang::TagType>()) {
7523                 if (clang::RecordDecl *Rec = llvm::dyn_cast<clang::RecordDecl>(TagT->getDecl()))
7524                     if (!Rec->getDeclName()) {
7525                         Rec->setAnonymousStructOrUnion(true);
7526                         field->setImplicit();
7527
7528                     }
7529             }
7530         }
7531
7532         if (field)
7533         {
7534             field->setAccess (ClangASTContext::ConvertAccessTypeToAccessSpecifier (access));
7535
7536             record_decl->addDecl(field);
7537
7538 #ifdef LLDB_CONFIGURATION_DEBUG
7539             VerifyDecl(field);
7540 #endif
7541         }
7542     }
7543     else
7544     {
7545         clang::ObjCInterfaceDecl *class_interface_decl = ast->GetAsObjCInterfaceDecl (type);
7546
7547         if (class_interface_decl)
7548         {
7549             const bool is_synthesized = false;
7550
7551             field_clang_type.GetCompleteType();
7552
7553             field = clang::ObjCIvarDecl::Create (*clang_ast,
7554                                                  class_interface_decl,
7555                                                  clang::SourceLocation(),
7556                                                  clang::SourceLocation(),
7557                                                  name ? &clang_ast->Idents.get(name) : nullptr,   // Identifier
7558                                                  GetQualType(field_clang_type),           // Field type
7559                                                  nullptr,                                     // TypeSourceInfo *
7560                                                  ConvertAccessTypeToObjCIvarAccessControl (access),
7561                                                  bit_width,
7562                                                  is_synthesized);
7563
7564             if (field)
7565             {
7566                 class_interface_decl->addDecl(field);
7567
7568 #ifdef LLDB_CONFIGURATION_DEBUG
7569                 VerifyDecl(field);
7570 #endif
7571             }
7572         }
7573     }
7574     return field;
7575 }
7576
7577 void
7578 ClangASTContext::BuildIndirectFields (const CompilerType& type)
7579 {
7580     if (!type)
7581         return;
7582
7583     ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
7584     if (!ast)
7585         return;
7586
7587     clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type);
7588
7589     if (!record_decl)
7590         return;
7591
7592     typedef llvm::SmallVector <clang::IndirectFieldDecl *, 1> IndirectFieldVector;
7593
7594     IndirectFieldVector indirect_fields;
7595     clang::RecordDecl::field_iterator field_pos;
7596     clang::RecordDecl::field_iterator field_end_pos = record_decl->field_end();
7597     clang::RecordDecl::field_iterator last_field_pos = field_end_pos;
7598     for (field_pos = record_decl->field_begin(); field_pos != field_end_pos; last_field_pos = field_pos++)
7599     {
7600         if (field_pos->isAnonymousStructOrUnion())
7601         {
7602             clang::QualType field_qual_type = field_pos->getType();
7603
7604             const clang::RecordType *field_record_type = field_qual_type->getAs<clang::RecordType>();
7605
7606             if (!field_record_type)
7607                 continue;
7608
7609             clang::RecordDecl *field_record_decl = field_record_type->getDecl();
7610
7611             if (!field_record_decl)
7612                 continue;
7613
7614             for (clang::RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end();
7615                  di != de;
7616                  ++di)
7617             {
7618                 if (clang::FieldDecl *nested_field_decl = llvm::dyn_cast<clang::FieldDecl>(*di))
7619                 {
7620                     clang::NamedDecl **chain = new (*ast->getASTContext()) clang::NamedDecl*[2];
7621                     chain[0] = *field_pos;
7622                     chain[1] = nested_field_decl;
7623                     clang::IndirectFieldDecl *indirect_field = clang::IndirectFieldDecl::Create(*ast->getASTContext(),
7624                                                                                                 record_decl,
7625                                                                                                 clang::SourceLocation(),
7626                                                                                                 nested_field_decl->getIdentifier(),
7627                                                                                                 nested_field_decl->getType(),
7628                                                                                                 chain,
7629                                                                                                 2);
7630
7631                     indirect_field->setImplicit();
7632
7633                     indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(),
7634                                                                                      nested_field_decl->getAccess()));
7635
7636                     indirect_fields.push_back(indirect_field);
7637                 }
7638                 else if (clang::IndirectFieldDecl *nested_indirect_field_decl = llvm::dyn_cast<clang::IndirectFieldDecl>(*di))
7639                 {
7640                     int nested_chain_size = nested_indirect_field_decl->getChainingSize();
7641                     clang::NamedDecl **chain = new (*ast->getASTContext()) clang::NamedDecl*[nested_chain_size + 1];
7642                     chain[0] = *field_pos;
7643
7644                     int chain_index = 1;
7645                     for (clang::IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(),
7646                          nce = nested_indirect_field_decl->chain_end();
7647                          nci < nce;
7648                          ++nci)
7649                     {
7650                         chain[chain_index] = *nci;
7651                         chain_index++;
7652                     }
7653
7654                     clang::IndirectFieldDecl *indirect_field = clang::IndirectFieldDecl::Create(*ast->getASTContext(),
7655                                                                                                 record_decl,
7656                                                                                                 clang::SourceLocation(),
7657                                                                                                 nested_indirect_field_decl->getIdentifier(),
7658                                                                                                 nested_indirect_field_decl->getType(),
7659                                                                                                 chain,
7660                                                                                                 nested_chain_size + 1);
7661
7662                     indirect_field->setImplicit();
7663
7664                     indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(),
7665                                                                                      nested_indirect_field_decl->getAccess()));
7666
7667                     indirect_fields.push_back(indirect_field);
7668                 }
7669             }
7670         }
7671     }
7672
7673     // Check the last field to see if it has an incomplete array type as its
7674     // last member and if it does, the tell the record decl about it
7675     if (last_field_pos != field_end_pos)
7676     {
7677         if (last_field_pos->getType()->isIncompleteArrayType())
7678             record_decl->hasFlexibleArrayMember();
7679     }
7680
7681     for (IndirectFieldVector::iterator ifi = indirect_fields.begin(), ife = indirect_fields.end();
7682          ifi < ife;
7683          ++ifi)
7684     {
7685         record_decl->addDecl(*ifi);
7686     }
7687 }
7688
7689 void
7690 ClangASTContext::SetIsPacked (const CompilerType& type)
7691 {
7692     if (type)
7693     {
7694         ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
7695         if (ast)
7696         {
7697             clang::RecordDecl *record_decl = GetAsRecordDecl(type);
7698
7699             if (!record_decl)
7700                 return;
7701
7702             record_decl->addAttr(clang::PackedAttr::CreateImplicit(*ast->getASTContext()));
7703         }
7704     }
7705 }
7706
7707 clang::VarDecl *
7708 ClangASTContext::AddVariableToRecordType (const CompilerType& type, const char *name,
7709                                           const CompilerType &var_type,
7710                                           AccessType access)
7711 {
7712     clang::VarDecl *var_decl = nullptr;
7713
7714     if (!type.IsValid() || !var_type.IsValid())
7715         return nullptr;
7716     ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
7717     if (!ast)
7718         return nullptr;
7719
7720     clang::RecordDecl *record_decl = ast->GetAsRecordDecl (type);
7721     if (record_decl)
7722     {
7723         var_decl = clang::VarDecl::Create (*ast->getASTContext(),                      // ASTContext &
7724                                            record_decl,                                // DeclContext *
7725                                            clang::SourceLocation(),                    // clang::SourceLocation StartLoc
7726                                            clang::SourceLocation(),                    // clang::SourceLocation IdLoc
7727                                            name ? &ast->getASTContext()->Idents.get(name) : nullptr,  // clang::IdentifierInfo *
7728                                            GetQualType(var_type),                      // Variable clang::QualType
7729                                            nullptr,                                    // TypeSourceInfo *
7730                                            clang::SC_Static);                          // StorageClass
7731         if (var_decl)
7732         {
7733             var_decl->setAccess(ClangASTContext::ConvertAccessTypeToAccessSpecifier (access));
7734             record_decl->addDecl(var_decl);
7735
7736 #ifdef LLDB_CONFIGURATION_DEBUG
7737             VerifyDecl(var_decl);
7738 #endif
7739         }
7740     }
7741     return var_decl;
7742 }
7743
7744
7745 clang::CXXMethodDecl *
7746 ClangASTContext::AddMethodToCXXRecordType (lldb::opaque_compiler_type_t type, const char *name,
7747                                               const CompilerType &method_clang_type,
7748                                               lldb::AccessType access,
7749                                               bool is_virtual,
7750                                               bool is_static,
7751                                               bool is_inline,
7752                                               bool is_explicit,
7753                                               bool is_attr_used,
7754                                               bool is_artificial)
7755 {
7756     if (!type || !method_clang_type.IsValid() || name == nullptr || name[0] == '\0')
7757         return nullptr;
7758
7759     clang::QualType record_qual_type(GetCanonicalQualType(type));
7760
7761     clang::CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl();
7762
7763     if (cxx_record_decl == nullptr)
7764         return nullptr;
7765
7766     clang::QualType method_qual_type (GetQualType(method_clang_type));
7767
7768     clang::CXXMethodDecl *cxx_method_decl = nullptr;
7769
7770     clang::DeclarationName decl_name (&getASTContext()->Idents.get(name));
7771
7772     const clang::FunctionType *function_type = llvm::dyn_cast<clang::FunctionType>(method_qual_type.getTypePtr());
7773
7774     if (function_type == nullptr)
7775         return nullptr;
7776
7777     const clang::FunctionProtoType *method_function_prototype (llvm::dyn_cast<clang::FunctionProtoType>(function_type));
7778
7779     if (!method_function_prototype)
7780         return nullptr;
7781
7782     unsigned int num_params = method_function_prototype->getNumParams();
7783
7784     clang::CXXDestructorDecl *cxx_dtor_decl(nullptr);
7785     clang::CXXConstructorDecl *cxx_ctor_decl(nullptr);
7786
7787     if (is_artificial)
7788         return nullptr; // skip everything artificial
7789
7790     if (name[0] == '~')
7791     {
7792         cxx_dtor_decl = clang::CXXDestructorDecl::Create (*getASTContext(),
7793                                                           cxx_record_decl,
7794                                                           clang::SourceLocation(),
7795                                                           clang::DeclarationNameInfo (getASTContext()->DeclarationNames.getCXXDestructorName (getASTContext()->getCanonicalType (record_qual_type)), clang::SourceLocation()),
7796                                                           method_qual_type,
7797                                                           nullptr,
7798                                                           is_inline,
7799                                                           is_artificial);
7800         cxx_method_decl = cxx_dtor_decl;
7801     }
7802     else if (decl_name == cxx_record_decl->getDeclName())
7803     {
7804         cxx_ctor_decl = clang::CXXConstructorDecl::Create (*getASTContext(),
7805                                                            cxx_record_decl,
7806                                                            clang::SourceLocation(),
7807                                                            clang::DeclarationNameInfo (getASTContext()->DeclarationNames.getCXXConstructorName (getASTContext()->getCanonicalType (record_qual_type)), clang::SourceLocation()),
7808                                                            method_qual_type,
7809                                                            nullptr, // TypeSourceInfo *
7810                                                            is_explicit,
7811                                                            is_inline,
7812                                                            is_artificial,
7813                                                            false /*is_constexpr*/);
7814         cxx_method_decl = cxx_ctor_decl;
7815     }
7816     else
7817     {
7818         clang::StorageClass SC = is_static ? clang::SC_Static : clang::SC_None;
7819         clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS;
7820
7821         if (IsOperator (name, op_kind))
7822         {
7823             if (op_kind != clang::NUM_OVERLOADED_OPERATORS)
7824             {
7825                 // Check the number of operator parameters. Sometimes we have
7826                 // seen bad DWARF that doesn't correctly describe operators and
7827                 // if we try to create a method and add it to the class, clang
7828                 // will assert and crash, so we need to make sure things are
7829                 // acceptable.
7830                 if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount (op_kind, num_params))
7831                     return nullptr;
7832                 cxx_method_decl = clang::CXXMethodDecl::Create (*getASTContext(),
7833                                                                 cxx_record_decl,
7834                                                                 clang::SourceLocation(),
7835                                                                 clang::DeclarationNameInfo (getASTContext()->DeclarationNames.getCXXOperatorName (op_kind), clang::SourceLocation()),
7836                                                                 method_qual_type,
7837                                                                 nullptr, // TypeSourceInfo *
7838                                                                 SC,
7839                                                                 is_inline,
7840                                                                 false /*is_constexpr*/,
7841                                                                 clang::SourceLocation());
7842             }
7843             else if (num_params == 0)
7844             {
7845                 // Conversion operators don't take params...
7846                 cxx_method_decl = clang::CXXConversionDecl::Create (*getASTContext(),
7847                                                                     cxx_record_decl,
7848                                                                     clang::SourceLocation(),
7849                                                                     clang::DeclarationNameInfo (getASTContext()->DeclarationNames.getCXXConversionFunctionName (getASTContext()->getCanonicalType (function_type->getReturnType())), clang::SourceLocation()),
7850                                                                     method_qual_type,
7851                                                                     nullptr, // TypeSourceInfo *
7852                                                                     is_inline,
7853                                                                     is_explicit,
7854                                                                     false /*is_constexpr*/,
7855                                                                     clang::SourceLocation());
7856             }
7857         }
7858
7859         if (cxx_method_decl == nullptr)
7860         {
7861             cxx_method_decl = clang::CXXMethodDecl::Create (*getASTContext(),
7862                                                             cxx_record_decl,
7863                                                             clang::SourceLocation(),
7864                                                             clang::DeclarationNameInfo (decl_name, clang::SourceLocation()),
7865                                                             method_qual_type,
7866                                                             nullptr, // TypeSourceInfo *
7867                                                             SC,
7868                                                             is_inline,
7869                                                             false /*is_constexpr*/,
7870                                                             clang::SourceLocation());
7871         }
7872     }
7873
7874     clang::AccessSpecifier access_specifier = ClangASTContext::ConvertAccessTypeToAccessSpecifier (access);
7875
7876     cxx_method_decl->setAccess (access_specifier);
7877     cxx_method_decl->setVirtualAsWritten (is_virtual);
7878
7879     if (is_attr_used)
7880         cxx_method_decl->addAttr(clang::UsedAttr::CreateImplicit(*getASTContext()));
7881
7882     // Populate the method decl with parameter decls
7883
7884     llvm::SmallVector<clang::ParmVarDecl *, 12> params;
7885
7886     for (unsigned param_index = 0;
7887          param_index < num_params;
7888          ++param_index)
7889     {
7890         params.push_back (clang::ParmVarDecl::Create (*getASTContext(),
7891                                                       cxx_method_decl,
7892                                                       clang::SourceLocation(),
7893                                                       clang::SourceLocation(),
7894                                                       nullptr, // anonymous
7895                                                       method_function_prototype->getParamType(param_index),
7896                                                       nullptr,
7897                                                       clang::SC_None,
7898                                                       nullptr));
7899     }
7900
7901     cxx_method_decl->setParams (llvm::ArrayRef<clang::ParmVarDecl*>(params));
7902
7903     cxx_record_decl->addDecl (cxx_method_decl);
7904
7905     // Sometimes the debug info will mention a constructor (default/copy/move),
7906     // destructor, or assignment operator (copy/move) but there won't be any
7907     // version of this in the code. So we check if the function was artificially
7908     // generated and if it is trivial and this lets the compiler/backend know
7909     // that it can inline the IR for these when it needs to and we can avoid a
7910     // "missing function" error when running expressions.
7911
7912     if (is_artificial)
7913     {
7914         if (cxx_ctor_decl &&
7915             ((cxx_ctor_decl->isDefaultConstructor() && cxx_record_decl->hasTrivialDefaultConstructor ()) ||
7916              (cxx_ctor_decl->isCopyConstructor()    && cxx_record_decl->hasTrivialCopyConstructor    ()) ||
7917              (cxx_ctor_decl->isMoveConstructor()    && cxx_record_decl->hasTrivialMoveConstructor    ()) ))
7918         {
7919             cxx_ctor_decl->setDefaulted();
7920             cxx_ctor_decl->setTrivial(true);
7921         }
7922         else if (cxx_dtor_decl)
7923         {
7924             if (cxx_record_decl->hasTrivialDestructor())
7925             {
7926                 cxx_dtor_decl->setDefaulted();
7927                 cxx_dtor_decl->setTrivial(true);
7928             }
7929         }
7930         else if ((cxx_method_decl->isCopyAssignmentOperator() && cxx_record_decl->hasTrivialCopyAssignment()) ||
7931                  (cxx_method_decl->isMoveAssignmentOperator() && cxx_record_decl->hasTrivialMoveAssignment()))
7932         {
7933             cxx_method_decl->setDefaulted();
7934             cxx_method_decl->setTrivial(true);
7935         }
7936     }
7937
7938 #ifdef LLDB_CONFIGURATION_DEBUG
7939     VerifyDecl(cxx_method_decl);
7940 #endif
7941
7942     //    printf ("decl->isPolymorphic()             = %i\n", cxx_record_decl->isPolymorphic());
7943     //    printf ("decl->isAggregate()               = %i\n", cxx_record_decl->isAggregate());
7944     //    printf ("decl->isPOD()                     = %i\n", cxx_record_decl->isPOD());
7945     //    printf ("decl->isEmpty()                   = %i\n", cxx_record_decl->isEmpty());
7946     //    printf ("decl->isAbstract()                = %i\n", cxx_record_decl->isAbstract());
7947     //    printf ("decl->hasTrivialConstructor()     = %i\n", cxx_record_decl->hasTrivialConstructor());
7948     //    printf ("decl->hasTrivialCopyConstructor() = %i\n", cxx_record_decl->hasTrivialCopyConstructor());
7949     //    printf ("decl->hasTrivialCopyAssignment()  = %i\n", cxx_record_decl->hasTrivialCopyAssignment());
7950     //    printf ("decl->hasTrivialDestructor()      = %i\n", cxx_record_decl->hasTrivialDestructor());
7951     return cxx_method_decl;
7952 }
7953
7954
7955 #pragma mark C++ Base Classes
7956
7957 clang::CXXBaseSpecifier *
7958 ClangASTContext::CreateBaseClassSpecifier (lldb::opaque_compiler_type_t type, AccessType access, bool is_virtual, bool base_of_class)
7959 {
7960     if (type)
7961         return new clang::CXXBaseSpecifier (clang::SourceRange(),
7962                                             is_virtual,
7963                                             base_of_class,
7964                                             ClangASTContext::ConvertAccessTypeToAccessSpecifier (access),
7965                                             getASTContext()->getTrivialTypeSourceInfo (GetQualType(type)),
7966                                             clang::SourceLocation());
7967     return nullptr;
7968 }
7969
7970 void
7971 ClangASTContext::DeleteBaseClassSpecifiers (clang::CXXBaseSpecifier **base_classes, unsigned num_base_classes)
7972 {
7973     for (unsigned i=0; i<num_base_classes; ++i)
7974     {
7975         delete base_classes[i];
7976         base_classes[i] = nullptr;
7977     }
7978 }
7979
7980 bool
7981 ClangASTContext::SetBaseClassesForClassType (lldb::opaque_compiler_type_t type, clang::CXXBaseSpecifier const * const *base_classes,
7982                                                 unsigned num_base_classes)
7983 {
7984     if (type)
7985     {
7986         clang::CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl(type);
7987         if (cxx_record_decl)
7988         {
7989             cxx_record_decl->setBases(base_classes, num_base_classes);
7990             return true;
7991         }
7992     }
7993     return false;
7994 }
7995
7996 bool
7997 ClangASTContext::SetObjCSuperClass (const CompilerType& type, const CompilerType &superclass_clang_type)
7998 {
7999     ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem());
8000     if (!ast)
8001         return false;
8002     clang::ASTContext* clang_ast = ast->getASTContext();
8003
8004     if (type && superclass_clang_type.IsValid() && superclass_clang_type.GetTypeSystem() == type.GetTypeSystem())
8005     {
8006         clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (type);
8007         clang::ObjCInterfaceDecl *super_interface_decl = GetAsObjCInterfaceDecl (superclass_clang_type);
8008         if (class_interface_decl && super_interface_decl)
8009         {
8010             class_interface_decl->setSuperClass(clang_ast->getTrivialTypeSourceInfo(clang_ast->getObjCInterfaceType(super_interface_decl)));
8011             return true;
8012         }
8013     }
8014     return false;
8015 }
8016
8017 bool
8018 ClangASTContext::AddObjCClassProperty (const CompilerType& type,
8019                                        const char *property_name,
8020                                        const CompilerType &property_clang_type,
8021                                        clang::ObjCIvarDecl *ivar_decl,
8022                                        const char *property_setter_name,
8023                                        const char *property_getter_name,
8024                                        uint32_t property_attributes,
8025                                        ClangASTMetadata *metadata)
8026 {
8027     if (!type || !property_clang_type.IsValid() || property_name == nullptr || property_name[0] == '\0')
8028         return false;
8029     ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
8030     if (!ast)
8031         return false;
8032     clang::ASTContext* clang_ast = ast->getASTContext();
8033
8034     clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (type);
8035
8036     if (class_interface_decl)
8037     {
8038         CompilerType property_clang_type_to_access;
8039
8040         if (property_clang_type.IsValid())
8041             property_clang_type_to_access = property_clang_type;
8042         else if (ivar_decl)
8043             property_clang_type_to_access = CompilerType (clang_ast, ivar_decl->getType());
8044
8045         if (class_interface_decl && property_clang_type_to_access.IsValid())
8046         {
8047             clang::TypeSourceInfo *prop_type_source;
8048             if (ivar_decl)
8049                 prop_type_source = clang_ast->getTrivialTypeSourceInfo (ivar_decl->getType());
8050             else
8051                 prop_type_source = clang_ast->getTrivialTypeSourceInfo (GetQualType(property_clang_type));
8052
8053             clang::ObjCPropertyDecl *property_decl = clang::ObjCPropertyDecl::Create (*clang_ast,
8054                                                                                       class_interface_decl,
8055                                                                                       clang::SourceLocation(), // Source Location
8056                                                                                       &clang_ast->Idents.get(property_name),
8057                                                                                       clang::SourceLocation(), //Source Location for AT
8058                                                                                       clang::SourceLocation(), //Source location for (
8059                                                                                       ivar_decl ? ivar_decl->getType() : ClangASTContext::GetQualType(property_clang_type),
8060                                                                                       prop_type_source);
8061
8062             if (property_decl)
8063             {
8064                 if (metadata)
8065                     ClangASTContext::SetMetadata(clang_ast, property_decl, *metadata);
8066
8067                 class_interface_decl->addDecl (property_decl);
8068
8069                 clang::Selector setter_sel, getter_sel;
8070
8071                 if (property_setter_name != nullptr)
8072                 {
8073                     std::string property_setter_no_colon(property_setter_name, strlen(property_setter_name) - 1);
8074                     clang::IdentifierInfo *setter_ident = &clang_ast->Idents.get(property_setter_no_colon.c_str());
8075                     setter_sel = clang_ast->Selectors.getSelector(1, &setter_ident);
8076                 }
8077                 else if (!(property_attributes & DW_APPLE_PROPERTY_readonly))
8078                 {
8079                     std::string setter_sel_string("set");
8080                     setter_sel_string.push_back(::toupper(property_name[0]));
8081                     setter_sel_string.append(&property_name[1]);
8082                     clang::IdentifierInfo *setter_ident = &clang_ast->Idents.get(setter_sel_string.c_str());
8083                     setter_sel = clang_ast->Selectors.getSelector(1, &setter_ident);
8084                 }
8085                 property_decl->setSetterName(setter_sel);
8086                 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_setter);
8087
8088                 if (property_getter_name != nullptr)
8089                 {
8090                     clang::IdentifierInfo *getter_ident = &clang_ast->Idents.get(property_getter_name);
8091                     getter_sel = clang_ast->Selectors.getSelector(0, &getter_ident);
8092                 }
8093                 else
8094                 {
8095                     clang::IdentifierInfo *getter_ident = &clang_ast->Idents.get(property_name);
8096                     getter_sel = clang_ast->Selectors.getSelector(0, &getter_ident);
8097                 }
8098                 property_decl->setGetterName(getter_sel);
8099                 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_getter);
8100
8101                 if (ivar_decl)
8102                     property_decl->setPropertyIvarDecl (ivar_decl);
8103
8104                 if (property_attributes & DW_APPLE_PROPERTY_readonly)
8105                     property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readonly);
8106                 if (property_attributes & DW_APPLE_PROPERTY_readwrite)
8107                     property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readwrite);
8108                 if (property_attributes & DW_APPLE_PROPERTY_assign)
8109                     property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_assign);
8110                 if (property_attributes & DW_APPLE_PROPERTY_retain)
8111                     property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_retain);
8112                 if (property_attributes & DW_APPLE_PROPERTY_copy)
8113                     property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_copy);
8114                 if (property_attributes & DW_APPLE_PROPERTY_nonatomic)
8115                     property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_nonatomic);
8116
8117                 if (!getter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(getter_sel))
8118                 {
8119                     const bool isInstance = true;
8120                     const bool isVariadic = false;
8121                     const bool isSynthesized = false;
8122                     const bool isImplicitlyDeclared = true;
8123                     const bool isDefined = false;
8124                     const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None;
8125                     const bool HasRelatedResultType = false;
8126
8127                     clang::ObjCMethodDecl *getter = clang::ObjCMethodDecl::Create (*clang_ast,
8128                                                                                    clang::SourceLocation(),
8129                                                                                    clang::SourceLocation(),
8130                                                                                    getter_sel,
8131                                                                                    GetQualType(property_clang_type_to_access),
8132                                                                                    nullptr,
8133                                                                                    class_interface_decl,
8134                                                                                    isInstance,
8135                                                                                    isVariadic,
8136                                                                                    isSynthesized,
8137                                                                                    isImplicitlyDeclared,
8138                                                                                    isDefined,
8139                                                                                    impControl,
8140                                                                                    HasRelatedResultType);
8141
8142                     if (getter && metadata)
8143                         ClangASTContext::SetMetadata(clang_ast, getter, *metadata);
8144
8145                     if (getter)
8146                     {
8147                         getter->setMethodParams(*clang_ast, llvm::ArrayRef<clang::ParmVarDecl*>(), llvm::ArrayRef<clang::SourceLocation>());
8148
8149                         class_interface_decl->addDecl(getter);
8150                     }
8151                 }
8152
8153                 if (!setter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(setter_sel))
8154                 {
8155                     clang::QualType result_type = clang_ast->VoidTy;
8156
8157                     const bool isInstance = true;
8158                     const bool isVariadic = false;
8159                     const bool isSynthesized = false;
8160                     const bool isImplicitlyDeclared = true;
8161                     const bool isDefined = false;
8162                     const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None;
8163                     const bool HasRelatedResultType = false;
8164
8165                     clang::ObjCMethodDecl *setter = clang::ObjCMethodDecl::Create (*clang_ast,
8166                                                                                    clang::SourceLocation(),
8167                                                                                    clang::SourceLocation(),
8168                                                                                    setter_sel,
8169                                                                                    result_type,
8170                                                                                    nullptr,
8171                                                                                    class_interface_decl,
8172                                                                                    isInstance,
8173                                                                                    isVariadic,
8174                                                                                    isSynthesized,
8175                                                                                    isImplicitlyDeclared,
8176                                                                                    isDefined,
8177                                                                                    impControl,
8178                                                                                    HasRelatedResultType);
8179
8180                     if (setter && metadata)
8181                         ClangASTContext::SetMetadata(clang_ast, setter, *metadata);
8182
8183                     llvm::SmallVector<clang::ParmVarDecl *, 1> params;
8184
8185                     params.push_back (clang::ParmVarDecl::Create (*clang_ast,
8186                                                                   setter,
8187                                                                   clang::SourceLocation(),
8188                                                                   clang::SourceLocation(),
8189                                                                   nullptr, // anonymous
8190                                                                   GetQualType(property_clang_type_to_access),
8191                                                                   nullptr,
8192                                                                   clang::SC_Auto,
8193                                                                   nullptr));
8194
8195                     if (setter)
8196                     {
8197                         setter->setMethodParams(*clang_ast, llvm::ArrayRef<clang::ParmVarDecl*>(params), llvm::ArrayRef<clang::SourceLocation>());
8198
8199                         class_interface_decl->addDecl(setter);
8200                     }
8201                 }
8202
8203                 return true;
8204             }
8205         }
8206     }
8207     return false;
8208 }
8209
8210 bool
8211 ClangASTContext::IsObjCClassTypeAndHasIVars (const CompilerType& type, bool check_superclass)
8212 {
8213     clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (type);
8214     if (class_interface_decl)
8215         return ObjCDeclHasIVars (class_interface_decl, check_superclass);
8216     return false;
8217 }
8218
8219
8220 clang::ObjCMethodDecl *
8221 ClangASTContext::AddMethodToObjCObjectType (const CompilerType& type,
8222                                             const char *name,  // the full symbol name as seen in the symbol table (lldb::opaque_compiler_type_t type, "-[NString stringWithCString:]")
8223                                             const CompilerType &method_clang_type,
8224                                             lldb::AccessType access,
8225                                             bool is_artificial)
8226 {
8227     if (!type || !method_clang_type.IsValid())
8228         return nullptr;
8229
8230     clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type);
8231
8232     if (class_interface_decl == nullptr)
8233         return nullptr;
8234     ClangASTContext *lldb_ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
8235     if (lldb_ast == nullptr)
8236         return nullptr;
8237     clang::ASTContext *ast = lldb_ast->getASTContext();
8238
8239     const char *selector_start = ::strchr (name, ' ');
8240     if (selector_start == nullptr)
8241         return nullptr;
8242
8243     selector_start++;
8244     llvm::SmallVector<clang::IdentifierInfo *, 12> selector_idents;
8245
8246     size_t len = 0;
8247     const char *start;
8248     //printf ("name = '%s'\n", name);
8249
8250     unsigned num_selectors_with_args = 0;
8251     for (start = selector_start;
8252          start && *start != '\0' && *start != ']';
8253          start += len)
8254     {
8255         len = ::strcspn(start, ":]");
8256         bool has_arg = (start[len] == ':');
8257         if (has_arg)
8258             ++num_selectors_with_args;
8259         selector_idents.push_back (&ast->Idents.get (llvm::StringRef (start, len)));
8260         if (has_arg)
8261             len += 1;
8262     }
8263
8264
8265     if (selector_idents.size() == 0)
8266         return nullptr;
8267
8268     clang::Selector method_selector = ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0,
8269                                                                     selector_idents.data());
8270
8271     clang::QualType method_qual_type (GetQualType(method_clang_type));
8272
8273     // Populate the method decl with parameter decls
8274     const clang::Type *method_type(method_qual_type.getTypePtr());
8275
8276     if (method_type == nullptr)
8277         return nullptr;
8278
8279     const clang::FunctionProtoType *method_function_prototype (llvm::dyn_cast<clang::FunctionProtoType>(method_type));
8280
8281     if (!method_function_prototype)
8282         return nullptr;
8283
8284
8285     bool is_variadic = false;
8286     bool is_synthesized = false;
8287     bool is_defined = false;
8288     clang::ObjCMethodDecl::ImplementationControl imp_control = clang::ObjCMethodDecl::None;
8289
8290     const unsigned num_args = method_function_prototype->getNumParams();
8291
8292     if (num_args != num_selectors_with_args)
8293         return nullptr; // some debug information is corrupt.  We are not going to deal with it.
8294
8295     clang::ObjCMethodDecl *objc_method_decl = clang::ObjCMethodDecl::Create (*ast,
8296                                                                              clang::SourceLocation(), // beginLoc,
8297                                                                              clang::SourceLocation(), // endLoc,
8298                                                                              method_selector,
8299                                                                              method_function_prototype->getReturnType(),
8300                                                                              nullptr, // TypeSourceInfo *ResultTInfo,
8301                                                                              ClangASTContext::GetASTContext(ast)->GetDeclContextForType(GetQualType(type)),
8302                                                                              name[0] == '-',
8303                                                                              is_variadic,
8304                                                                              is_synthesized,
8305                                                                              true, // is_implicitly_declared; we force this to true because we don't have source locations
8306                                                                              is_defined,
8307                                                                              imp_control,
8308                                                                              false /*has_related_result_type*/);
8309
8310
8311     if (objc_method_decl == nullptr)
8312         return nullptr;
8313
8314     if (num_args > 0)
8315     {
8316         llvm::SmallVector<clang::ParmVarDecl *, 12> params;
8317
8318         for (unsigned param_index = 0; param_index < num_args; ++param_index)
8319         {
8320             params.push_back (clang::ParmVarDecl::Create (*ast,
8321                                                           objc_method_decl,
8322                                                           clang::SourceLocation(),
8323                                                           clang::SourceLocation(),
8324                                                           nullptr, // anonymous
8325                                                           method_function_prototype->getParamType(param_index),
8326                                                           nullptr,
8327                                                           clang::SC_Auto,
8328                                                           nullptr));
8329         }
8330
8331         objc_method_decl->setMethodParams(*ast, llvm::ArrayRef<clang::ParmVarDecl*>(params), llvm::ArrayRef<clang::SourceLocation>());
8332     }
8333
8334     class_interface_decl->addDecl (objc_method_decl);
8335
8336 #ifdef LLDB_CONFIGURATION_DEBUG
8337     VerifyDecl(objc_method_decl);
8338 #endif
8339
8340     return objc_method_decl;
8341 }
8342
8343 bool
8344 ClangASTContext::GetHasExternalStorage (const CompilerType &type)
8345 {
8346     if (IsClangType(type))
8347         return false;
8348
8349     clang::QualType qual_type (GetCanonicalQualType(type));
8350
8351     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
8352     switch (type_class)
8353     {
8354         case clang::Type::Record:
8355         {
8356             clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
8357             if (cxx_record_decl)
8358                 return cxx_record_decl->hasExternalLexicalStorage () || cxx_record_decl->hasExternalVisibleStorage();
8359         }
8360             break;
8361
8362         case clang::Type::Enum:
8363         {
8364             clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl();
8365             if (enum_decl)
8366                 return enum_decl->hasExternalLexicalStorage () || enum_decl->hasExternalVisibleStorage();
8367         }
8368             break;
8369
8370         case clang::Type::ObjCObject:
8371         case clang::Type::ObjCInterface:
8372         {
8373             const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
8374             assert (objc_class_type);
8375             if (objc_class_type)
8376             {
8377                 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
8378
8379                 if (class_interface_decl)
8380                     return class_interface_decl->hasExternalLexicalStorage () || class_interface_decl->hasExternalVisibleStorage ();
8381             }
8382         }
8383             break;
8384
8385         case clang::Type::Typedef:
8386             return GetHasExternalStorage (CompilerType(type.GetTypeSystem(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()));
8387
8388         case clang::Type::Auto:
8389             return GetHasExternalStorage (CompilerType(type.GetTypeSystem(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()));
8390
8391         case clang::Type::Elaborated:
8392             return GetHasExternalStorage (CompilerType(type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()));
8393
8394         case clang::Type::Paren:
8395             return GetHasExternalStorage (CompilerType(type.GetTypeSystem(), llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()));
8396
8397         default:
8398             break;
8399     }
8400     return false;
8401 }
8402
8403
8404 bool
8405 ClangASTContext::SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool has_extern)
8406 {
8407     if (!type)
8408         return false;
8409
8410     clang::QualType qual_type (GetCanonicalQualType(type));
8411
8412     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
8413     switch (type_class)
8414     {
8415         case clang::Type::Record:
8416         {
8417             clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
8418             if (cxx_record_decl)
8419             {
8420                 cxx_record_decl->setHasExternalLexicalStorage (has_extern);
8421                 cxx_record_decl->setHasExternalVisibleStorage (has_extern);
8422                 return true;
8423             }
8424         }
8425             break;
8426
8427         case clang::Type::Enum:
8428         {
8429             clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl();
8430             if (enum_decl)
8431             {
8432                 enum_decl->setHasExternalLexicalStorage (has_extern);
8433                 enum_decl->setHasExternalVisibleStorage (has_extern);
8434                 return true;
8435             }
8436         }
8437             break;
8438
8439         case clang::Type::ObjCObject:
8440         case clang::Type::ObjCInterface:
8441         {
8442             const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
8443             assert (objc_class_type);
8444             if (objc_class_type)
8445             {
8446                 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
8447
8448                 if (class_interface_decl)
8449                 {
8450                     class_interface_decl->setHasExternalLexicalStorage (has_extern);
8451                     class_interface_decl->setHasExternalVisibleStorage (has_extern);
8452                     return true;
8453                 }
8454             }
8455         }
8456             break;
8457
8458         case clang::Type::Typedef:
8459             return SetHasExternalStorage(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), has_extern);
8460
8461         case clang::Type::Auto:
8462             return SetHasExternalStorage (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), has_extern);
8463
8464         case clang::Type::Elaborated:
8465             return SetHasExternalStorage (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), has_extern);
8466
8467         case clang::Type::Paren:
8468             return SetHasExternalStorage (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), has_extern);
8469
8470         default:
8471             break;
8472     }
8473     return false;
8474 }
8475
8476
8477 bool
8478 ClangASTContext::CanImport (const CompilerType &type, lldb_private::ClangASTImporter &importer)
8479 {
8480     if (IsClangType(type))
8481     {
8482         // TODO: remove external completion BOOL
8483         // CompleteAndFetchChildren should get the Decl out and check for the
8484
8485         clang::QualType qual_type(GetCanonicalQualType(RemoveFastQualifiers(type)));
8486
8487         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
8488         switch (type_class)
8489         {
8490             case clang::Type::Record:
8491             {
8492                 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
8493                 if (cxx_record_decl)
8494                 {
8495                     if (importer.ResolveDeclOrigin (cxx_record_decl, NULL, NULL))
8496                         return true;
8497                 }
8498             }
8499                 break;
8500
8501             case clang::Type::Enum:
8502             {
8503                 clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl();
8504                 if (enum_decl)
8505                 {
8506                     if (importer.ResolveDeclOrigin (enum_decl, NULL, NULL))
8507                         return true;
8508                 }
8509             }
8510                 break;
8511
8512             case clang::Type::ObjCObject:
8513             case clang::Type::ObjCInterface:
8514             {
8515                 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
8516                 if (objc_class_type)
8517                 {
8518                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
8519                     // We currently can't complete objective C types through the newly added ASTContext
8520                     // because it only supports TagDecl objects right now...
8521                     if (class_interface_decl)
8522                     {
8523                         if (importer.ResolveDeclOrigin (class_interface_decl, NULL, NULL))
8524                             return true;
8525                     }
8526                 }
8527             }
8528                 break;
8529
8530
8531             case clang::Type::Typedef:
8532                 return CanImport(CompilerType (type.GetTypeSystem(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()), importer);
8533
8534             case clang::Type::Auto:
8535                 return CanImport(CompilerType (type.GetTypeSystem(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()), importer);
8536
8537             case clang::Type::Elaborated:
8538                 return CanImport(CompilerType (type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()), importer);
8539
8540             case clang::Type::Paren:
8541                 return CanImport(CompilerType (type.GetTypeSystem(), llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()), importer);
8542
8543             default:
8544                 break;
8545         }
8546     }
8547     return false;
8548 }
8549 bool
8550 ClangASTContext::Import (const CompilerType &type, lldb_private::ClangASTImporter &importer)
8551 {
8552     if (IsClangType(type))
8553     {
8554         // TODO: remove external completion BOOL
8555         // CompleteAndFetchChildren should get the Decl out and check for the
8556
8557         clang::QualType qual_type(GetCanonicalQualType(RemoveFastQualifiers(type)));
8558
8559         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
8560         switch (type_class)
8561         {
8562             case clang::Type::Record:
8563             {
8564                 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
8565                 if (cxx_record_decl)
8566                 {
8567                     if (importer.ResolveDeclOrigin (cxx_record_decl, NULL, NULL))
8568                         return importer.CompleteAndFetchChildren(qual_type);
8569                 }
8570             }
8571                 break;
8572
8573             case clang::Type::Enum:
8574             {
8575                 clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl();
8576                 if (enum_decl)
8577                 {
8578                     if (importer.ResolveDeclOrigin (enum_decl, NULL, NULL))
8579                         return importer.CompleteAndFetchChildren(qual_type);
8580                 }
8581             }
8582                 break;
8583
8584             case clang::Type::ObjCObject:
8585             case clang::Type::ObjCInterface:
8586             {
8587                 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
8588                 if (objc_class_type)
8589                 {
8590                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
8591                     // We currently can't complete objective C types through the newly added ASTContext
8592                     // because it only supports TagDecl objects right now...
8593                     if (class_interface_decl)
8594                     {
8595                         if (importer.ResolveDeclOrigin (class_interface_decl, NULL, NULL))
8596                             return importer.CompleteAndFetchChildren(qual_type);
8597                     }
8598                 }
8599             }
8600                 break;
8601
8602
8603             case clang::Type::Typedef:
8604                 return Import (CompilerType(type.GetTypeSystem(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()), importer);
8605
8606             case clang::Type::Auto:
8607                 return Import (CompilerType(type.GetTypeSystem(),llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()), importer);
8608
8609             case clang::Type::Elaborated:
8610                 return Import (CompilerType(type.GetTypeSystem(),llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()), importer);
8611
8612             case clang::Type::Paren:
8613                 return Import (CompilerType(type.GetTypeSystem(),llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()), importer);
8614
8615             default:
8616                 break;
8617         }
8618     }
8619     return false;
8620 }
8621
8622
8623 #pragma mark TagDecl
8624
8625 bool
8626 ClangASTContext::StartTagDeclarationDefinition (const CompilerType &type)
8627 {
8628     clang::QualType qual_type (ClangASTContext::GetQualType(type));
8629     if (!qual_type.isNull())
8630     {
8631         const clang::TagType *tag_type = qual_type->getAs<clang::TagType>();
8632         if (tag_type)
8633         {
8634             clang::TagDecl *tag_decl = tag_type->getDecl();
8635             if (tag_decl)
8636             {
8637                 tag_decl->startDefinition();
8638                 return true;
8639             }
8640         }
8641
8642         const clang::ObjCObjectType *object_type = qual_type->getAs<clang::ObjCObjectType>();
8643         if (object_type)
8644         {
8645             clang::ObjCInterfaceDecl *interface_decl = object_type->getInterface();
8646             if (interface_decl)
8647             {
8648                 interface_decl->startDefinition();
8649                 return true;
8650             }
8651         }
8652     }
8653     return false;
8654 }
8655
8656 bool
8657 ClangASTContext::CompleteTagDeclarationDefinition (const CompilerType& type)
8658 {
8659     clang::QualType qual_type (ClangASTContext::GetQualType(type));
8660     if (!qual_type.isNull())
8661     {
8662         clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
8663
8664         if (cxx_record_decl)
8665         {
8666             if (!cxx_record_decl->isCompleteDefinition())
8667                 cxx_record_decl->completeDefinition();
8668             cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true);
8669             cxx_record_decl->setHasExternalLexicalStorage (false);
8670             cxx_record_decl->setHasExternalVisibleStorage (false);
8671             return true;
8672         }
8673
8674         const clang::EnumType *enutype = qual_type->getAs<clang::EnumType>();
8675
8676         if (enutype)
8677         {
8678             clang::EnumDecl *enum_decl = enutype->getDecl();
8679
8680             if (enum_decl)
8681             {
8682                 if (!enum_decl->isCompleteDefinition())
8683                 {
8684                     ClangASTContext *lldb_ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
8685                     if (lldb_ast == nullptr)
8686                         return false;
8687                     clang::ASTContext *ast = lldb_ast->getASTContext();
8688
8689                     /// TODO This really needs to be fixed.
8690
8691                     unsigned NumPositiveBits = 1;
8692                     unsigned NumNegativeBits = 0;
8693
8694                     clang::QualType promotion_qual_type;
8695                     // If the enum integer type is less than an integer in bit width,
8696                     // then we must promote it to an integer size.
8697                     if (ast->getTypeSize(enum_decl->getIntegerType()) < ast->getTypeSize(ast->IntTy))
8698                     {
8699                         if (enum_decl->getIntegerType()->isSignedIntegerType())
8700                             promotion_qual_type = ast->IntTy;
8701                         else
8702                             promotion_qual_type = ast->UnsignedIntTy;
8703                     }
8704                     else
8705                         promotion_qual_type = enum_decl->getIntegerType();
8706
8707                     enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits);
8708                 }
8709                 return true;
8710             }
8711         }
8712     }
8713     return false;
8714 }
8715
8716 bool
8717 ClangASTContext::AddEnumerationValueToEnumerationType (lldb::opaque_compiler_type_t type,
8718                                                        const CompilerType &enumerator_clang_type,
8719                                                        const Declaration &decl,
8720                                                        const char *name,
8721                                                        int64_t enum_value,
8722                                                        uint32_t enum_value_bit_size)
8723 {
8724     if (type && enumerator_clang_type.IsValid() && name && name[0])
8725     {
8726         clang::QualType enum_qual_type (GetCanonicalQualType(type));
8727
8728         bool is_signed = false;
8729         enumerator_clang_type.IsIntegerType (is_signed);
8730         const clang::Type *clang_type = enum_qual_type.getTypePtr();
8731         if (clang_type)
8732         {
8733             const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(clang_type);
8734
8735             if (enutype)
8736             {
8737                 llvm::APSInt enum_llvm_apsint(enum_value_bit_size, is_signed);
8738                 enum_llvm_apsint = enum_value;
8739                 clang::EnumConstantDecl *enumerator_decl =
8740                 clang::EnumConstantDecl::Create (*getASTContext(),
8741                                                  enutype->getDecl(),
8742                                                  clang::SourceLocation(),
8743                                                  name ? &getASTContext()->Idents.get(name) : nullptr,    // Identifier
8744                                                  GetQualType(enumerator_clang_type),
8745                                                  nullptr,
8746                                                  enum_llvm_apsint);
8747
8748                 if (enumerator_decl)
8749                 {
8750                     enutype->getDecl()->addDecl(enumerator_decl);
8751
8752 #ifdef LLDB_CONFIGURATION_DEBUG
8753                     VerifyDecl(enumerator_decl);
8754 #endif
8755
8756                     return true;
8757                 }
8758             }
8759         }
8760     }
8761     return false;
8762 }
8763
8764 CompilerType
8765 ClangASTContext::GetEnumerationIntegerType (lldb::opaque_compiler_type_t type)
8766 {
8767     clang::QualType enum_qual_type (GetCanonicalQualType(type));
8768     const clang::Type *clang_type = enum_qual_type.getTypePtr();
8769     if (clang_type)
8770     {
8771         const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(clang_type);
8772         if (enutype)
8773         {
8774             clang::EnumDecl *enum_decl = enutype->getDecl();
8775             if (enum_decl)
8776                 return CompilerType (getASTContext(), enum_decl->getIntegerType());
8777         }
8778     }
8779     return CompilerType();
8780 }
8781
8782 CompilerType
8783 ClangASTContext::CreateMemberPointerType (const CompilerType& type, const CompilerType &pointee_type)
8784 {
8785     if (type && pointee_type.IsValid() && type.GetTypeSystem() == pointee_type.GetTypeSystem())
8786     {
8787         ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
8788         if (!ast)
8789             return CompilerType();
8790         return CompilerType (ast->getASTContext(),
8791                              ast->getASTContext()->getMemberPointerType (GetQualType(pointee_type),
8792                                                                          GetQualType(type).getTypePtr()));
8793     }
8794     return CompilerType();
8795 }
8796
8797
8798 size_t
8799 ClangASTContext::ConvertStringToFloatValue (lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size)
8800 {
8801     if (type)
8802     {
8803         clang::QualType qual_type (GetCanonicalQualType(type));
8804         uint32_t count = 0;
8805         bool is_complex = false;
8806         if (IsFloatingPointType (type, count, is_complex))
8807         {
8808             // TODO: handle complex and vector types
8809             if (count != 1)
8810                 return false;
8811
8812             llvm::StringRef s_sref(s);
8813             llvm::APFloat ap_float(getASTContext()->getFloatTypeSemantics(qual_type), s_sref);
8814
8815             const uint64_t bit_size = getASTContext()->getTypeSize (qual_type);
8816             const uint64_t byte_size = bit_size / 8;
8817             if (dst_size >= byte_size)
8818             {
8819                 if (bit_size == sizeof(float)*8)
8820                 {
8821                     float float32 = ap_float.convertToFloat();
8822                     ::memcpy (dst, &float32, byte_size);
8823                     return byte_size;
8824                 }
8825                 else if (bit_size >= 64)
8826                 {
8827                     llvm::APInt ap_int(ap_float.bitcastToAPInt());
8828                     ::memcpy (dst, ap_int.getRawData(), byte_size);
8829                     return byte_size;
8830                 }
8831             }
8832         }
8833     }
8834     return 0;
8835 }
8836
8837
8838
8839 //----------------------------------------------------------------------
8840 // Dumping types
8841 //----------------------------------------------------------------------
8842 #define DEPTH_INCREMENT 2
8843
8844 void
8845 ClangASTContext::DumpValue (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
8846                                Stream *s,
8847                                lldb::Format format,
8848                                const lldb_private::DataExtractor &data,
8849                                lldb::offset_t data_byte_offset,
8850                                size_t data_byte_size,
8851                                uint32_t bitfield_bit_size,
8852                                uint32_t bitfield_bit_offset,
8853                                bool show_types,
8854                                bool show_summary,
8855                                bool verbose,
8856                                uint32_t depth)
8857 {
8858     if (!type)
8859         return;
8860
8861     clang::QualType qual_type(GetQualType(type));
8862     switch (qual_type->getTypeClass())
8863     {
8864         case clang::Type::Record:
8865             if (GetCompleteType(type))
8866             {
8867                 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
8868                 const clang::RecordDecl *record_decl = record_type->getDecl();
8869                 assert(record_decl);
8870                 uint32_t field_bit_offset = 0;
8871                 uint32_t field_byte_offset = 0;
8872                 const clang::ASTRecordLayout &record_layout = getASTContext()->getASTRecordLayout(record_decl);
8873                 uint32_t child_idx = 0;
8874
8875                 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
8876                 if (cxx_record_decl)
8877                 {
8878                     // We might have base classes to print out first
8879                     clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
8880                     for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
8881                          base_class != base_class_end;
8882                          ++base_class)
8883                     {
8884                         const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl());
8885
8886                         // Skip empty base classes
8887                         if (verbose == false && ClangASTContext::RecordHasFields(base_class_decl) == false)
8888                             continue;
8889
8890                         if (base_class->isVirtual())
8891                             field_bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
8892                         else
8893                             field_bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
8894                         field_byte_offset = field_bit_offset / 8;
8895                         assert (field_bit_offset % 8 == 0);
8896                         if (child_idx == 0)
8897                             s->PutChar('{');
8898                         else
8899                             s->PutChar(',');
8900
8901                         clang::QualType base_class_qual_type = base_class->getType();
8902                         std::string base_class_type_name(base_class_qual_type.getAsString());
8903
8904                         // Indent and print the base class type name
8905                         s->Printf("\n%*s%s ", depth + DEPTH_INCREMENT, "", base_class_type_name.c_str());
8906
8907                         clang::TypeInfo base_class_type_info = getASTContext()->getTypeInfo(base_class_qual_type);
8908
8909                         // Dump the value of the member
8910                         CompilerType base_clang_type(getASTContext(), base_class_qual_type);
8911                         base_clang_type.DumpValue (exe_ctx,
8912                                                    s,                                   // Stream to dump to
8913                                                    base_clang_type.GetFormat(),         // The format with which to display the member
8914                                                    data,                                // Data buffer containing all bytes for this type
8915                                                    data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from
8916                                                    base_class_type_info.Width / 8,      // Size of this type in bytes
8917                                                    0,                                   // Bitfield bit size
8918                                                    0,                                   // Bitfield bit offset
8919                                                    show_types,                          // Boolean indicating if we should show the variable types
8920                                                    show_summary,                        // Boolean indicating if we should show a summary for the current type
8921                                                    verbose,                             // Verbose output?
8922                                                    depth + DEPTH_INCREMENT);            // Scope depth for any types that have children
8923
8924                         ++child_idx;
8925                     }
8926                 }
8927                 uint32_t field_idx = 0;
8928                 clang::RecordDecl::field_iterator field, field_end;
8929                 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx)
8930                 {
8931                     // Print the starting squiggly bracket (if this is the
8932                     // first member) or comma (for member 2 and beyond) for
8933                     // the struct/union/class member.
8934                     if (child_idx == 0)
8935                         s->PutChar('{');
8936                     else
8937                         s->PutChar(',');
8938
8939                     // Indent
8940                     s->Printf("\n%*s", depth + DEPTH_INCREMENT, "");
8941
8942                     clang::QualType field_type = field->getType();
8943                     // Print the member type if requested
8944                     // Figure out the type byte size (field_type_info.first) and
8945                     // alignment (field_type_info.second) from the AST context.
8946                     clang::TypeInfo field_type_info = getASTContext()->getTypeInfo(field_type);
8947                     assert(field_idx < record_layout.getFieldCount());
8948                     // Figure out the field offset within the current struct/union/class type
8949                     field_bit_offset = record_layout.getFieldOffset (field_idx);
8950                     field_byte_offset = field_bit_offset / 8;
8951                     uint32_t field_bitfield_bit_size = 0;
8952                     uint32_t field_bitfield_bit_offset = 0;
8953                     if (ClangASTContext::FieldIsBitfield (getASTContext(), *field, field_bitfield_bit_size))
8954                         field_bitfield_bit_offset = field_bit_offset % 8;
8955
8956                     if (show_types)
8957                     {
8958                         std::string field_type_name(field_type.getAsString());
8959                         if (field_bitfield_bit_size > 0)
8960                             s->Printf("(%s:%u) ", field_type_name.c_str(), field_bitfield_bit_size);
8961                         else
8962                             s->Printf("(%s) ", field_type_name.c_str());
8963                     }
8964                     // Print the member name and equal sign
8965                     s->Printf("%s = ", field->getNameAsString().c_str());
8966
8967
8968                     // Dump the value of the member
8969                     CompilerType field_clang_type (getASTContext(), field_type);
8970                     field_clang_type.DumpValue (exe_ctx,
8971                                                 s,                              // Stream to dump to
8972                                                 field_clang_type.GetFormat(),   // The format with which to display the member
8973                                                 data,                           // Data buffer containing all bytes for this type
8974                                                 data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from
8975                                                 field_type_info.Width / 8,      // Size of this type in bytes
8976                                                 field_bitfield_bit_size,        // Bitfield bit size
8977                                                 field_bitfield_bit_offset,      // Bitfield bit offset
8978                                                 show_types,                     // Boolean indicating if we should show the variable types
8979                                                 show_summary,                   // Boolean indicating if we should show a summary for the current type
8980                                                 verbose,                        // Verbose output?
8981                                                 depth + DEPTH_INCREMENT);       // Scope depth for any types that have children
8982                 }
8983
8984                 // Indent the trailing squiggly bracket
8985                 if (child_idx > 0)
8986                     s->Printf("\n%*s}", depth, "");
8987             }
8988             return;
8989
8990         case clang::Type::Enum:
8991             if (GetCompleteType(type))
8992             {
8993                 const clang::EnumType *enutype = llvm::cast<clang::EnumType>(qual_type.getTypePtr());
8994                 const clang::EnumDecl *enum_decl = enutype->getDecl();
8995                 assert(enum_decl);
8996                 clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
8997                 lldb::offset_t offset = data_byte_offset;
8998                 const int64_t enum_value = data.GetMaxU64Bitfield(&offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset);
8999                 for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos)
9000                 {
9001                     if (enum_pos->getInitVal() == enum_value)
9002                     {
9003                         s->Printf("%s", enum_pos->getNameAsString().c_str());
9004                         return;
9005                     }
9006                 }
9007                 // If we have gotten here we didn't get find the enumerator in the
9008                 // enum decl, so just print the integer.
9009                 s->Printf("%" PRIi64, enum_value);
9010             }
9011             return;
9012
9013         case clang::Type::ConstantArray:
9014         {
9015             const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr());
9016             bool is_array_of_characters = false;
9017             clang::QualType element_qual_type = array->getElementType();
9018
9019             const clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr();
9020             if (canonical_type)
9021                 is_array_of_characters = canonical_type->isCharType();
9022
9023             const uint64_t element_count = array->getSize().getLimitedValue();
9024
9025             clang::TypeInfo field_type_info = getASTContext()->getTypeInfo(element_qual_type);
9026
9027             uint32_t element_idx = 0;
9028             uint32_t element_offset = 0;
9029             uint64_t element_byte_size = field_type_info.Width / 8;
9030             uint32_t element_stride = element_byte_size;
9031
9032             if (is_array_of_characters)
9033             {
9034                 s->PutChar('"');
9035                 data.Dump(s, data_byte_offset, lldb::eFormatChar, element_byte_size, element_count, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0);
9036                 s->PutChar('"');
9037                 return;
9038             }
9039             else
9040             {
9041                 CompilerType element_clang_type(getASTContext(), element_qual_type);
9042                 lldb::Format element_format = element_clang_type.GetFormat();
9043
9044                 for (element_idx = 0; element_idx < element_count; ++element_idx)
9045                 {
9046                     // Print the starting squiggly bracket (if this is the
9047                     // first member) or comman (for member 2 and beyong) for
9048                     // the struct/union/class member.
9049                     if (element_idx == 0)
9050                         s->PutChar('{');
9051                     else
9052                         s->PutChar(',');
9053
9054                     // Indent and print the index
9055                     s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx);
9056
9057                     // Figure out the field offset within the current struct/union/class type
9058                     element_offset = element_idx * element_stride;
9059
9060                     // Dump the value of the member
9061                     element_clang_type.DumpValue (exe_ctx,
9062                                                   s,                              // Stream to dump to
9063                                                   element_format,                 // The format with which to display the element
9064                                                   data,                           // Data buffer containing all bytes for this type
9065                                                   data_byte_offset + element_offset,// Offset into "data" where to grab value from
9066                                                   element_byte_size,              // Size of this type in bytes
9067                                                   0,                              // Bitfield bit size
9068                                                   0,                              // Bitfield bit offset
9069                                                   show_types,                     // Boolean indicating if we should show the variable types
9070                                                   show_summary,                   // Boolean indicating if we should show a summary for the current type
9071                                                   verbose,                        // Verbose output?
9072                                                   depth + DEPTH_INCREMENT);       // Scope depth for any types that have children
9073                 }
9074
9075                 // Indent the trailing squiggly bracket
9076                 if (element_idx > 0)
9077                     s->Printf("\n%*s}", depth, "");
9078             }
9079         }
9080             return;
9081
9082         case clang::Type::Typedef:
9083         {
9084             clang::QualType typedef_qual_type = llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType();
9085
9086             CompilerType typedef_clang_type (getASTContext(), typedef_qual_type);
9087             lldb::Format typedef_format = typedef_clang_type.GetFormat();
9088             clang::TypeInfo typedef_type_info = getASTContext()->getTypeInfo(typedef_qual_type);
9089             uint64_t typedef_byte_size = typedef_type_info.Width / 8;
9090
9091             return typedef_clang_type.DumpValue (exe_ctx,
9092                                                  s,                  // Stream to dump to
9093                                                  typedef_format,     // The format with which to display the element
9094                                                  data,               // Data buffer containing all bytes for this type
9095                                                  data_byte_offset,   // Offset into "data" where to grab value from
9096                                                  typedef_byte_size,  // Size of this type in bytes
9097                                                  bitfield_bit_size,  // Bitfield bit size
9098                                                  bitfield_bit_offset,// Bitfield bit offset
9099                                                  show_types,         // Boolean indicating if we should show the variable types
9100                                                  show_summary,       // Boolean indicating if we should show a summary for the current type
9101                                                  verbose,            // Verbose output?
9102                                                  depth);             // Scope depth for any types that have children
9103         }
9104             break;
9105
9106         case clang::Type::Auto:
9107         {
9108             clang::QualType elaborated_qual_type = llvm::cast<clang::AutoType>(qual_type)->getDeducedType();
9109             CompilerType elaborated_clang_type (getASTContext(), elaborated_qual_type);
9110             lldb::Format elaborated_format = elaborated_clang_type.GetFormat();
9111             clang::TypeInfo elaborated_type_info = getASTContext()->getTypeInfo(elaborated_qual_type);
9112             uint64_t elaborated_byte_size = elaborated_type_info.Width / 8;
9113
9114             return elaborated_clang_type.DumpValue (exe_ctx,
9115                                                     s,                  // Stream to dump to
9116                                                     elaborated_format,  // The format with which to display the element
9117                                                     data,               // Data buffer containing all bytes for this type
9118                                                     data_byte_offset,   // Offset into "data" where to grab value from
9119                                                     elaborated_byte_size,  // Size of this type in bytes
9120                                                     bitfield_bit_size,  // Bitfield bit size
9121                                                     bitfield_bit_offset,// Bitfield bit offset
9122                                                     show_types,         // Boolean indicating if we should show the variable types
9123                                                     show_summary,       // Boolean indicating if we should show a summary for the current type
9124                                                     verbose,            // Verbose output?
9125                                                     depth);             // Scope depth for any types that have children
9126         }
9127             break;
9128
9129         case clang::Type::Elaborated:
9130         {
9131             clang::QualType elaborated_qual_type = llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType();
9132             CompilerType elaborated_clang_type (getASTContext(), elaborated_qual_type);
9133             lldb::Format elaborated_format = elaborated_clang_type.GetFormat();
9134             clang::TypeInfo elaborated_type_info = getASTContext()->getTypeInfo(elaborated_qual_type);
9135             uint64_t elaborated_byte_size = elaborated_type_info.Width / 8;
9136
9137             return elaborated_clang_type.DumpValue (exe_ctx,
9138                                                     s,                  // Stream to dump to
9139                                                     elaborated_format,  // The format with which to display the element
9140                                                     data,               // Data buffer containing all bytes for this type
9141                                                     data_byte_offset,   // Offset into "data" where to grab value from
9142                                                     elaborated_byte_size,  // Size of this type in bytes
9143                                                     bitfield_bit_size,  // Bitfield bit size
9144                                                     bitfield_bit_offset,// Bitfield bit offset
9145                                                     show_types,         // Boolean indicating if we should show the variable types
9146                                                     show_summary,       // Boolean indicating if we should show a summary for the current type
9147                                                     verbose,            // Verbose output?
9148                                                     depth);             // Scope depth for any types that have children
9149         }
9150             break;
9151
9152         case clang::Type::Paren:
9153         {
9154             clang::QualType desugar_qual_type = llvm::cast<clang::ParenType>(qual_type)->desugar();
9155             CompilerType desugar_clang_type (getASTContext(), desugar_qual_type);
9156
9157             lldb::Format desugar_format = desugar_clang_type.GetFormat();
9158             clang::TypeInfo desugar_type_info = getASTContext()->getTypeInfo(desugar_qual_type);
9159             uint64_t desugar_byte_size = desugar_type_info.Width / 8;
9160
9161             return desugar_clang_type.DumpValue (exe_ctx,
9162                                                  s,                  // Stream to dump to
9163                                                  desugar_format,  // The format with which to display the element
9164                                                  data,               // Data buffer containing all bytes for this type
9165                                                  data_byte_offset,   // Offset into "data" where to grab value from
9166                                                  desugar_byte_size,  // Size of this type in bytes
9167                                                  bitfield_bit_size,  // Bitfield bit size
9168                                                  bitfield_bit_offset,// Bitfield bit offset
9169                                                  show_types,         // Boolean indicating if we should show the variable types
9170                                                  show_summary,       // Boolean indicating if we should show a summary for the current type
9171                                                  verbose,            // Verbose output?
9172                                                  depth);             // Scope depth for any types that have children
9173         }
9174             break;
9175
9176         default:
9177             // We are down to a scalar type that we just need to display.
9178             data.Dump(s,
9179                       data_byte_offset,
9180                       format,
9181                       data_byte_size,
9182                       1,
9183                       UINT32_MAX,
9184                       LLDB_INVALID_ADDRESS,
9185                       bitfield_bit_size,
9186                       bitfield_bit_offset);
9187
9188             if (show_summary)
9189                 DumpSummary (type, exe_ctx, s, data, data_byte_offset, data_byte_size);
9190             break;
9191     }
9192 }
9193
9194
9195
9196
9197 bool
9198 ClangASTContext::DumpTypeValue (lldb::opaque_compiler_type_t type, Stream *s,
9199                                    lldb::Format format,
9200                                    const lldb_private::DataExtractor &data,
9201                                    lldb::offset_t byte_offset,
9202                                    size_t byte_size,
9203                                    uint32_t bitfield_bit_size,
9204                                    uint32_t bitfield_bit_offset,
9205                                    ExecutionContextScope *exe_scope)
9206 {
9207     if (!type)
9208         return false;
9209     if (IsAggregateType(type))
9210     {
9211         return false;
9212     }
9213     else
9214     {
9215         clang::QualType qual_type(GetQualType(type));
9216
9217         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
9218         switch (type_class)
9219         {
9220             case clang::Type::Typedef:
9221             {
9222                 clang::QualType typedef_qual_type = llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType();
9223                 CompilerType typedef_clang_type (getASTContext(), typedef_qual_type);
9224                 if (format == eFormatDefault)
9225                     format = typedef_clang_type.GetFormat();
9226                 clang::TypeInfo typedef_type_info = getASTContext()->getTypeInfo(typedef_qual_type);
9227                 uint64_t typedef_byte_size = typedef_type_info.Width / 8;
9228
9229                 return typedef_clang_type.DumpTypeValue (s,
9230                                                          format,                 // The format with which to display the element
9231                                                          data,                   // Data buffer containing all bytes for this type
9232                                                          byte_offset,            // Offset into "data" where to grab value from
9233                                                          typedef_byte_size,      // Size of this type in bytes
9234                                                          bitfield_bit_size,      // Size in bits of a bitfield value, if zero don't treat as a bitfield
9235                                                          bitfield_bit_offset,    // Offset in bits of a bitfield value if bitfield_bit_size != 0
9236                                                          exe_scope);
9237             }
9238                 break;
9239
9240             case clang::Type::Enum:
9241                 // If our format is enum or default, show the enumeration value as
9242                 // its enumeration string value, else just display it as requested.
9243                 if ((format == eFormatEnum || format == eFormatDefault) && GetCompleteType(type))
9244                 {
9245                     const clang::EnumType *enutype = llvm::cast<clang::EnumType>(qual_type.getTypePtr());
9246                     const clang::EnumDecl *enum_decl = enutype->getDecl();
9247                     assert(enum_decl);
9248                     clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
9249                     const bool is_signed = qual_type->isSignedIntegerOrEnumerationType();
9250                     lldb::offset_t offset = byte_offset;
9251                     if (is_signed)
9252                     {
9253                         const int64_t enum_svalue = data.GetMaxS64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
9254                         for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos)
9255                         {
9256                             if (enum_pos->getInitVal().getSExtValue() == enum_svalue)
9257                             {
9258                                 s->PutCString (enum_pos->getNameAsString().c_str());
9259                                 return true;
9260                             }
9261                         }
9262                         // If we have gotten here we didn't get find the enumerator in the
9263                         // enum decl, so just print the integer.
9264                         s->Printf("%" PRIi64, enum_svalue);
9265                     }
9266                     else
9267                     {
9268                         const uint64_t enum_uvalue = data.GetMaxU64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
9269                         for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos)
9270                         {
9271                             if (enum_pos->getInitVal().getZExtValue() == enum_uvalue)
9272                             {
9273                                 s->PutCString (enum_pos->getNameAsString().c_str());
9274                                 return true;
9275                             }
9276                         }
9277                         // If we have gotten here we didn't get find the enumerator in the
9278                         // enum decl, so just print the integer.
9279                         s->Printf("%" PRIu64, enum_uvalue);
9280                     }
9281                     return true;
9282                 }
9283                 // format was not enum, just fall through and dump the value as requested....
9284
9285             default:
9286                 // We are down to a scalar type that we just need to display.
9287             {
9288                 uint32_t item_count = 1;
9289                 // A few formats, we might need to modify our size and count for depending
9290                 // on how we are trying to display the value...
9291                 switch (format)
9292                 {
9293                     default:
9294                     case eFormatBoolean:
9295                     case eFormatBinary:
9296                     case eFormatComplex:
9297                     case eFormatCString:         // NULL terminated C strings
9298                     case eFormatDecimal:
9299                     case eFormatEnum:
9300                     case eFormatHex:
9301                     case eFormatHexUppercase:
9302                     case eFormatFloat:
9303                     case eFormatOctal:
9304                     case eFormatOSType:
9305                     case eFormatUnsigned:
9306                     case eFormatPointer:
9307                     case eFormatVectorOfChar:
9308                     case eFormatVectorOfSInt8:
9309                     case eFormatVectorOfUInt8:
9310                     case eFormatVectorOfSInt16:
9311                     case eFormatVectorOfUInt16:
9312                     case eFormatVectorOfSInt32:
9313                     case eFormatVectorOfUInt32:
9314                     case eFormatVectorOfSInt64:
9315                     case eFormatVectorOfUInt64:
9316                     case eFormatVectorOfFloat32:
9317                     case eFormatVectorOfFloat64:
9318                     case eFormatVectorOfUInt128:
9319                         break;
9320
9321                     case eFormatChar:
9322                     case eFormatCharPrintable:
9323                     case eFormatCharArray:
9324                     case eFormatBytes:
9325                     case eFormatBytesWithASCII:
9326                         item_count = byte_size;
9327                         byte_size = 1;
9328                         break;
9329
9330                     case eFormatUnicode16:
9331                         item_count = byte_size / 2;
9332                         byte_size = 2;
9333                         break;
9334
9335                     case eFormatUnicode32:
9336                         item_count = byte_size / 4;
9337                         byte_size = 4;
9338                         break;
9339                 }
9340                 return data.Dump (s,
9341                                   byte_offset,
9342                                   format,
9343                                   byte_size,
9344                                   item_count,
9345                                   UINT32_MAX,
9346                                   LLDB_INVALID_ADDRESS,
9347                                   bitfield_bit_size,
9348                                   bitfield_bit_offset,
9349                                   exe_scope);
9350             }
9351                 break;
9352         }
9353     }
9354     return 0;
9355 }
9356
9357
9358
9359 void
9360 ClangASTContext::DumpSummary (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
9361                                  Stream *s,
9362                                  const lldb_private::DataExtractor &data,
9363                                  lldb::offset_t data_byte_offset,
9364                                  size_t data_byte_size)
9365 {
9366     uint32_t length = 0;
9367     if (IsCStringType (type, length))
9368     {
9369         if (exe_ctx)
9370         {
9371             Process *process = exe_ctx->GetProcessPtr();
9372             if (process)
9373             {
9374                 lldb::offset_t offset = data_byte_offset;
9375                 lldb::addr_t pointer_address = data.GetMaxU64(&offset, data_byte_size);
9376                 std::vector<uint8_t> buf;
9377                 if (length > 0)
9378                     buf.resize (length);
9379                 else
9380                     buf.resize (256);
9381
9382                 lldb_private::DataExtractor cstr_data(&buf.front(), buf.size(), process->GetByteOrder(), 4);
9383                 buf.back() = '\0';
9384                 size_t bytes_read;
9385                 size_t total_cstr_len = 0;
9386                 Error error;
9387                 while ((bytes_read = process->ReadMemory (pointer_address, &buf.front(), buf.size(), error)) > 0)
9388                 {
9389                     const size_t len = strlen((const char *)&buf.front());
9390                     if (len == 0)
9391                         break;
9392                     if (total_cstr_len == 0)
9393                         s->PutCString (" \"");
9394                     cstr_data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0);
9395                     total_cstr_len += len;
9396                     if (len < buf.size())
9397                         break;
9398                     pointer_address += total_cstr_len;
9399                 }
9400                 if (total_cstr_len > 0)
9401                     s->PutChar ('"');
9402             }
9403         }
9404     }
9405 }
9406
9407 void
9408 ClangASTContext::DumpTypeDescription (lldb::opaque_compiler_type_t type)
9409 {
9410     StreamFile s (stdout, false);
9411     DumpTypeDescription (type, &s);
9412     ClangASTMetadata *metadata = ClangASTContext::GetMetadata (getASTContext(), type);
9413     if (metadata)
9414     {
9415         metadata->Dump (&s);
9416     }
9417 }
9418
9419 void
9420 ClangASTContext::DumpTypeDescription (lldb::opaque_compiler_type_t type, Stream *s)
9421 {
9422     if (type)
9423     {
9424         clang::QualType qual_type(GetQualType(type));
9425
9426         llvm::SmallVector<char, 1024> buf;
9427         llvm::raw_svector_ostream llvm_ostrm (buf);
9428
9429         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
9430         switch (type_class)
9431         {
9432             case clang::Type::ObjCObject:
9433             case clang::Type::ObjCInterface:
9434             {
9435                 GetCompleteType(type);
9436
9437                 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr());
9438                 assert (objc_class_type);
9439                 if (objc_class_type)
9440                 {
9441                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
9442                     if (class_interface_decl)
9443                     {
9444                         clang::PrintingPolicy policy = getASTContext()->getPrintingPolicy();
9445                         class_interface_decl->print(llvm_ostrm, policy, s->GetIndentLevel());
9446                     }
9447                 }
9448             }
9449                 break;
9450
9451             case clang::Type::Typedef:
9452             {
9453                 const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>();
9454                 if (typedef_type)
9455                 {
9456                     const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
9457                     std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString());
9458                     if (!clang_typedef_name.empty())
9459                     {
9460                         s->PutCString ("typedef ");
9461                         s->PutCString (clang_typedef_name.c_str());
9462                     }
9463                 }
9464             }
9465                 break;
9466
9467             case clang::Type::Auto:
9468                 CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).DumpTypeDescription(s);
9469                 return;
9470
9471             case clang::Type::Elaborated:
9472                 CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).DumpTypeDescription(s);
9473                 return;
9474
9475             case clang::Type::Paren:
9476                 CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).DumpTypeDescription(s);
9477                 return;
9478
9479             case clang::Type::Record:
9480             {
9481                 GetCompleteType(type);
9482
9483                 const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr());
9484                 const clang::RecordDecl *record_decl = record_type->getDecl();
9485                 const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
9486
9487                 if (cxx_record_decl)
9488                     cxx_record_decl->print(llvm_ostrm, getASTContext()->getPrintingPolicy(), s->GetIndentLevel());
9489                 else
9490                     record_decl->print(llvm_ostrm, getASTContext()->getPrintingPolicy(), s->GetIndentLevel());
9491             }
9492                 break;
9493
9494             default:
9495             {
9496                 const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr());
9497                 if (tag_type)
9498                 {
9499                     clang::TagDecl *tag_decl = tag_type->getDecl();
9500                     if (tag_decl)
9501                         tag_decl->print(llvm_ostrm, 0);
9502                 }
9503                 else
9504                 {
9505                     std::string clang_type_name(qual_type.getAsString());
9506                     if (!clang_type_name.empty())
9507                         s->PutCString (clang_type_name.c_str());
9508                 }
9509             }
9510         }
9511
9512         if (buf.size() > 0)
9513         {
9514             s->Write (buf.data(), buf.size());
9515         }
9516     }
9517 }
9518
9519 void
9520 ClangASTContext::DumpTypeName (const CompilerType &type)
9521 {
9522     if (IsClangType(type))
9523     {
9524         clang::QualType qual_type(GetCanonicalQualType(RemoveFastQualifiers(type)));
9525
9526         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
9527         switch (type_class)
9528         {
9529             case clang::Type::Record:
9530             {
9531                 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
9532                 if (cxx_record_decl)
9533                     printf("class %s", cxx_record_decl->getName().str().c_str());
9534             }
9535                 break;
9536
9537             case clang::Type::Enum:
9538             {
9539                 clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl();
9540                 if (enum_decl)
9541                 {
9542                     printf("enum %s", enum_decl->getName().str().c_str());
9543                 }
9544             }
9545                 break;
9546
9547             case clang::Type::ObjCObject:
9548             case clang::Type::ObjCInterface:
9549             {
9550                 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
9551                 if (objc_class_type)
9552                 {
9553                     clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
9554                     // We currently can't complete objective C types through the newly added ASTContext
9555                     // because it only supports TagDecl objects right now...
9556                     if (class_interface_decl)
9557                         printf("@class %s", class_interface_decl->getName().str().c_str());
9558                 }
9559             }
9560                 break;
9561
9562
9563             case clang::Type::Typedef:
9564                 printf("typedef %s", llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getName().str().c_str());
9565                 break;
9566
9567             case clang::Type::Auto:
9568                 printf("auto ");
9569                 return DumpTypeName (CompilerType (type.GetTypeSystem(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()));
9570
9571             case clang::Type::Elaborated:
9572                 printf("elaborated ");
9573                 return DumpTypeName (CompilerType (type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()));
9574
9575             case clang::Type::Paren:
9576                 printf("paren ");
9577                 return DumpTypeName (CompilerType (type.GetTypeSystem(), llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()));
9578
9579             default:
9580                 printf("ClangASTContext::DumpTypeName() type_class = %u", type_class);
9581                 break;
9582         }
9583     }
9584
9585 }
9586
9587
9588
9589 clang::ClassTemplateDecl *
9590 ClangASTContext::ParseClassTemplateDecl (clang::DeclContext *decl_ctx,
9591                                          lldb::AccessType access_type,
9592                                          const char *parent_name,
9593                                          int tag_decl_kind,
9594                                          const ClangASTContext::TemplateParameterInfos &template_param_infos)
9595 {
9596     if (template_param_infos.IsValid())
9597     {
9598         std::string template_basename(parent_name);
9599         template_basename.erase (template_basename.find('<'));
9600
9601         return CreateClassTemplateDecl (decl_ctx,
9602                                         access_type,
9603                                         template_basename.c_str(),
9604                                         tag_decl_kind,
9605                                         template_param_infos);
9606     }
9607     return NULL;
9608 }
9609
9610 void
9611 ClangASTContext::CompleteTagDecl (void *baton, clang::TagDecl *decl)
9612 {
9613     ClangASTContext *ast = (ClangASTContext *)baton;
9614     SymbolFile *sym_file = ast->GetSymbolFile();
9615     if (sym_file)
9616     {
9617         CompilerType clang_type = GetTypeForDecl (decl);
9618         if (clang_type)
9619             sym_file->CompleteType (clang_type);
9620     }
9621 }
9622
9623 void
9624 ClangASTContext::CompleteObjCInterfaceDecl (void *baton, clang::ObjCInterfaceDecl *decl)
9625 {
9626     ClangASTContext *ast = (ClangASTContext *)baton;
9627     SymbolFile *sym_file = ast->GetSymbolFile();
9628     if (sym_file)
9629     {
9630         CompilerType clang_type = GetTypeForDecl (decl);
9631         if (clang_type)
9632             sym_file->CompleteType (clang_type);
9633     }
9634 }
9635
9636
9637 DWARFASTParser *
9638 ClangASTContext::GetDWARFParser ()
9639 {
9640     if (!m_dwarf_ast_parser_ap)
9641         m_dwarf_ast_parser_ap.reset(new DWARFASTParserClang(*this));
9642     return m_dwarf_ast_parser_ap.get();
9643 }
9644
9645
9646 bool
9647 ClangASTContext::LayoutRecordType(void *baton,
9648                                   const clang::RecordDecl *record_decl,
9649                                   uint64_t &bit_size,
9650                                   uint64_t &alignment,
9651                                   llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
9652                                   llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
9653                                   llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets)
9654 {
9655     ClangASTContext *ast = (ClangASTContext *)baton;
9656     DWARFASTParserClang *dwarf_ast_parser = (DWARFASTParserClang *)ast->GetDWARFParser();
9657     return dwarf_ast_parser->LayoutRecordType(record_decl, bit_size, alignment, field_offsets, base_offsets, vbase_offsets);
9658 }
9659
9660 //----------------------------------------------------------------------
9661 // CompilerDecl override functions
9662 //----------------------------------------------------------------------
9663 lldb::VariableSP
9664 ClangASTContext::DeclGetVariable (void *opaque_decl)
9665 {
9666     if (llvm::dyn_cast<clang::VarDecl>((clang::Decl *)opaque_decl))
9667     {
9668         auto decl_search_it = m_decl_objects.find(opaque_decl);
9669         if (decl_search_it != m_decl_objects.end())
9670             return std::static_pointer_cast<Variable>(decl_search_it->second);
9671     }
9672     return VariableSP();
9673 }
9674
9675 void
9676 ClangASTContext::DeclLinkToObject (void *opaque_decl, std::shared_ptr<void> object)
9677 {
9678     if (m_decl_objects.find(opaque_decl) == m_decl_objects.end())
9679         m_decl_objects.insert(std::make_pair(opaque_decl, object));
9680 }
9681
9682 ConstString
9683 ClangASTContext::DeclGetName (void *opaque_decl)
9684 {
9685     if (opaque_decl)
9686     {
9687         clang::NamedDecl *nd = llvm::dyn_cast<NamedDecl>((clang::Decl*)opaque_decl);
9688         if (nd != nullptr)
9689             return ConstString(nd->getDeclName().getAsString());
9690     }
9691     return ConstString();
9692 }
9693
9694 ConstString
9695 ClangASTContext::DeclGetMangledName (void *opaque_decl)
9696 {
9697     if (opaque_decl)
9698     {
9699         clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>((clang::Decl*)opaque_decl);
9700         if (nd != nullptr && !llvm::isa<clang::ObjCMethodDecl>(nd))
9701         {
9702             clang::MangleContext *mc = getMangleContext();
9703             if (mc && mc->shouldMangleCXXName(nd))
9704             {
9705                 llvm::SmallVector<char, 1024> buf;
9706                 llvm::raw_svector_ostream llvm_ostrm (buf);
9707                 if (llvm::isa<clang::CXXConstructorDecl>(nd))
9708                 {
9709                     mc->mangleCXXCtor(llvm::dyn_cast<clang::CXXConstructorDecl>(nd), Ctor_Complete, llvm_ostrm);
9710                 }
9711                 else if (llvm::isa<clang::CXXDestructorDecl>(nd))
9712                 {
9713                     mc->mangleCXXDtor(llvm::dyn_cast<clang::CXXDestructorDecl>(nd), Dtor_Complete, llvm_ostrm);
9714                 }
9715                 else
9716                 {
9717                     mc->mangleName(nd, llvm_ostrm);
9718                 }
9719                 if (buf.size() > 0)
9720                     return ConstString(buf.data(), buf.size());
9721             }
9722         }
9723     }
9724     return ConstString();
9725 }
9726
9727 CompilerDeclContext
9728 ClangASTContext::DeclGetDeclContext (void *opaque_decl)
9729 {
9730     if (opaque_decl)
9731         return CompilerDeclContext(this, ((clang::Decl*)opaque_decl)->getDeclContext());
9732     else
9733         return CompilerDeclContext();
9734 }
9735
9736 CompilerType
9737 ClangASTContext::DeclGetFunctionReturnType(void *opaque_decl)
9738 {
9739     if (clang::FunctionDecl *func_decl = llvm::dyn_cast<clang::FunctionDecl>((clang::Decl*)opaque_decl))
9740         return CompilerType(this, func_decl->getReturnType().getAsOpaquePtr());
9741     if (clang::ObjCMethodDecl *objc_method = llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl*)opaque_decl))
9742         return CompilerType(this, objc_method->getReturnType().getAsOpaquePtr());
9743     else
9744         return CompilerType();
9745 }
9746
9747 size_t
9748 ClangASTContext::DeclGetFunctionNumArguments(void *opaque_decl)
9749 {
9750     if (clang::FunctionDecl *func_decl = llvm::dyn_cast<clang::FunctionDecl>((clang::Decl*)opaque_decl))
9751         return func_decl->param_size();
9752     if (clang::ObjCMethodDecl *objc_method = llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl*)opaque_decl))
9753         return  objc_method->param_size();
9754     else
9755         return 0;
9756 }
9757
9758 CompilerType
9759 ClangASTContext::DeclGetFunctionArgumentType (void *opaque_decl, size_t idx)
9760 {
9761     if (clang::FunctionDecl *func_decl = llvm::dyn_cast<clang::FunctionDecl>((clang::Decl*)opaque_decl))
9762     {
9763         if (idx < func_decl->param_size())
9764         {
9765             ParmVarDecl *var_decl = func_decl->getParamDecl(idx);
9766             if (var_decl)
9767                 return  CompilerType(this, var_decl->getOriginalType().getAsOpaquePtr());
9768         }
9769     }
9770     else if (clang::ObjCMethodDecl *objc_method = llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl*)opaque_decl))
9771     {
9772         if (idx < objc_method->param_size())
9773             return CompilerType(this, objc_method->parameters()[idx]->getOriginalType().getAsOpaquePtr());
9774     }
9775     return CompilerType();
9776 }
9777
9778 //----------------------------------------------------------------------
9779 // CompilerDeclContext functions
9780 //----------------------------------------------------------------------
9781
9782 std::vector<CompilerDecl>
9783 ClangASTContext::DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name)
9784 {
9785     std::vector<CompilerDecl> found_decls;
9786     if (opaque_decl_ctx)
9787     {
9788         DeclContext *root_decl_ctx = (DeclContext *)opaque_decl_ctx;
9789         std::set<DeclContext *> searched;
9790         std::multimap<DeclContext *, DeclContext *> search_queue;
9791         SymbolFile *symbol_file = GetSymbolFile();
9792
9793         for (clang::DeclContext *decl_context = root_decl_ctx; decl_context != nullptr && found_decls.empty(); decl_context = decl_context->getParent())
9794         {
9795             search_queue.insert(std::make_pair(decl_context, decl_context));
9796
9797             for (auto it = search_queue.find(decl_context); it != search_queue.end(); it++)
9798             {
9799                 if (!searched.insert(it->second).second)
9800                     continue;
9801                 symbol_file->ParseDeclsForContext(CompilerDeclContext(this, it->second));
9802
9803                 for (clang::Decl *child : it->second->decls())
9804                 {
9805                     if (clang::UsingDirectiveDecl *ud = llvm::dyn_cast<clang::UsingDirectiveDecl>(child))
9806                     {
9807                         clang::DeclContext *from = ud->getCommonAncestor();
9808                         if (searched.find(ud->getNominatedNamespace()) == searched.end())
9809                             search_queue.insert(std::make_pair(from, ud->getNominatedNamespace()));
9810                     }
9811                     else if (clang::UsingDecl *ud = llvm::dyn_cast<clang::UsingDecl>(child))
9812                     {
9813                         for (clang::UsingShadowDecl *usd : ud->shadows())
9814                         {
9815                             clang::Decl *target = usd->getTargetDecl();
9816                             if (clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(target))
9817                             {
9818                                 IdentifierInfo *ii = nd->getIdentifier();
9819                                 if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr)))
9820                                     found_decls.push_back(CompilerDecl(this, nd));
9821                             }
9822                         }
9823                     }
9824                     else if (clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(child))
9825                     {
9826                         IdentifierInfo *ii = nd->getIdentifier();
9827                         if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr)))
9828                             found_decls.push_back(CompilerDecl(this, nd));
9829                     }
9830                 }
9831             }
9832         }
9833     }
9834     return found_decls;
9835 }
9836
9837 // Look for child_decl_ctx's lookup scope in frame_decl_ctx and its parents,
9838 // and return the number of levels it took to find it, or LLDB_INVALID_DECL_LEVEL
9839 // if not found.  If the decl was imported via a using declaration, its name and/or
9840 // type, if set, will be used to check that the decl found in the scope is a match.
9841 //
9842 // The optional name is required by languages (like C++) to handle using declarations
9843 // like:
9844 //
9845 //     void poo();
9846 //     namespace ns {
9847 //         void foo();
9848 //         void goo();
9849 //     }
9850 //     void bar() {
9851 //         using ns::foo;
9852 //         // CountDeclLevels returns 0 for 'foo', 1 for 'poo', and
9853 //         // LLDB_INVALID_DECL_LEVEL for 'goo'.
9854 //     }
9855 //
9856 // The optional type is useful in the case that there's a specific overload
9857 // that we're looking for that might otherwise be shadowed, like:
9858 //
9859 //     void foo(int);
9860 //     namespace ns {
9861 //         void foo();
9862 //     }
9863 //     void bar() {
9864 //         using ns::foo;
9865 //         // CountDeclLevels returns 0 for { 'foo', void() },
9866 //         // 1 for { 'foo', void(int) }, and
9867 //         // LLDB_INVALID_DECL_LEVEL for { 'foo', void(int, int) }.
9868 //     }
9869 //
9870 // NOTE: Because file statics are at the TranslationUnit along with globals, a
9871 // function at file scope will return the same level as a function at global scope.
9872 // Ideally we'd like to treat the file scope as an additional scope just below the
9873 // global scope.  More work needs to be done to recognise that, if the decl we're
9874 // trying to look up is static, we should compare its source file with that of the
9875 // current scope and return a lower number for it.
9876 uint32_t
9877 ClangASTContext::CountDeclLevels (clang::DeclContext *frame_decl_ctx,
9878                                   clang::DeclContext *child_decl_ctx,
9879                                   ConstString *child_name,
9880                                   CompilerType *child_type)
9881 {
9882     if (frame_decl_ctx)
9883     {
9884         std::set<DeclContext *> searched;
9885         std::multimap<DeclContext *, DeclContext *> search_queue;
9886         SymbolFile *symbol_file = GetSymbolFile();
9887
9888         // Get the lookup scope for the decl we're trying to find.
9889         clang::DeclContext *parent_decl_ctx = child_decl_ctx->getParent();
9890
9891         // Look for it in our scope's decl context and its parents.
9892         uint32_t level = 0;
9893         for (clang::DeclContext *decl_ctx = frame_decl_ctx; decl_ctx != nullptr; decl_ctx = decl_ctx->getParent())
9894         {
9895             if (!decl_ctx->isLookupContext())
9896                 continue;
9897             if (decl_ctx == parent_decl_ctx)
9898                 // Found it!
9899                 return level;
9900             search_queue.insert(std::make_pair(decl_ctx, decl_ctx));
9901             for (auto it = search_queue.find(decl_ctx); it != search_queue.end(); it++)
9902             {
9903                 if (searched.find(it->second) != searched.end())
9904                     continue;
9905                 searched.insert(it->second);
9906                 symbol_file->ParseDeclsForContext(CompilerDeclContext(this, it->second));
9907
9908                 for (clang::Decl *child : it->second->decls())
9909                 {
9910                     if (clang::UsingDirectiveDecl *ud = llvm::dyn_cast<clang::UsingDirectiveDecl>(child))
9911                     {
9912                         clang::DeclContext *ns = ud->getNominatedNamespace();
9913                         if (ns == parent_decl_ctx)
9914                             // Found it!
9915                             return level;
9916                         clang::DeclContext *from = ud->getCommonAncestor();
9917                         if (searched.find(ns) == searched.end())
9918                             search_queue.insert(std::make_pair(from, ns));
9919                     }
9920                     else if (child_name)
9921                     {
9922                         if (clang::UsingDecl *ud = llvm::dyn_cast<clang::UsingDecl>(child))
9923                         {
9924                             for (clang::UsingShadowDecl *usd : ud->shadows())
9925                             {
9926                                 clang::Decl *target = usd->getTargetDecl();
9927                                 clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(target);
9928                                 if (!nd)
9929                                     continue;
9930                                 // Check names.
9931                                 IdentifierInfo *ii = nd->getIdentifier();
9932                                 if (ii == nullptr || !ii->getName().equals(child_name->AsCString(nullptr)))
9933                                     continue;
9934                                 // Check types, if one was provided.
9935                                 if (child_type)
9936                                 {
9937                                     CompilerType clang_type = ClangASTContext::GetTypeForDecl(nd);
9938                                     if (!AreTypesSame(clang_type, *child_type, /*ignore_qualifiers=*/true))
9939                                         continue;
9940                                 }
9941                                 // Found it!
9942                                 return level;
9943                             }
9944                         }
9945                     }
9946                 }
9947             }
9948             ++level;
9949         }
9950     }
9951     return LLDB_INVALID_DECL_LEVEL;
9952 }
9953
9954 bool
9955 ClangASTContext::DeclContextIsStructUnionOrClass (void *opaque_decl_ctx)
9956 {
9957     if (opaque_decl_ctx)
9958         return ((clang::DeclContext *)opaque_decl_ctx)->isRecord();
9959     else
9960         return false;
9961 }
9962
9963 ConstString
9964 ClangASTContext::DeclContextGetName (void *opaque_decl_ctx)
9965 {
9966     if (opaque_decl_ctx)
9967     {
9968         clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx);
9969         if (named_decl)
9970             return ConstString(named_decl->getName());
9971     }
9972     return ConstString();
9973 }
9974
9975 ConstString
9976 ClangASTContext::DeclContextGetScopeQualifiedName (void *opaque_decl_ctx)
9977 {
9978     if (opaque_decl_ctx)
9979     {
9980         clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx);
9981         if (named_decl)
9982             return ConstString(llvm::StringRef(named_decl->getQualifiedNameAsString()));
9983     }
9984     return ConstString();
9985 }
9986
9987 bool
9988 ClangASTContext::DeclContextIsClassMethod (void *opaque_decl_ctx,
9989                                            lldb::LanguageType *language_ptr,
9990                                            bool *is_instance_method_ptr,
9991                                            ConstString *language_object_name_ptr)
9992 {
9993     if (opaque_decl_ctx)
9994     {
9995         clang::DeclContext *decl_ctx = (clang::DeclContext *)opaque_decl_ctx;
9996         if (ObjCMethodDecl *objc_method = llvm::dyn_cast<clang::ObjCMethodDecl>(decl_ctx))
9997         {
9998             if (is_instance_method_ptr)
9999                 *is_instance_method_ptr = objc_method->isInstanceMethod();
10000             if (language_ptr)
10001                 *language_ptr = eLanguageTypeObjC;
10002             if (language_object_name_ptr)
10003                 language_object_name_ptr->SetCString("self");
10004             return true;
10005         }
10006         else if (CXXMethodDecl *cxx_method = llvm::dyn_cast<clang::CXXMethodDecl>(decl_ctx))
10007         {
10008             if (is_instance_method_ptr)
10009                 *is_instance_method_ptr = cxx_method->isInstance();
10010             if (language_ptr)
10011                 *language_ptr = eLanguageTypeC_plus_plus;
10012             if (language_object_name_ptr)
10013                 language_object_name_ptr->SetCString("this");
10014             return true;
10015         }
10016         else if (clang::FunctionDecl *function_decl = llvm::dyn_cast<clang::FunctionDecl>(decl_ctx))
10017         {
10018             ClangASTMetadata *metadata = GetMetadata (&decl_ctx->getParentASTContext(), function_decl);
10019             if (metadata && metadata->HasObjectPtr())
10020             {
10021                 if (is_instance_method_ptr)
10022                     *is_instance_method_ptr = true;
10023                 if (language_ptr)
10024                     *language_ptr = eLanguageTypeObjC;
10025                 if (language_object_name_ptr)
10026                     language_object_name_ptr->SetCString (metadata->GetObjectPtrName());
10027                 return true;
10028             }
10029         }
10030     }
10031     return false;
10032 }
10033
10034 clang::DeclContext *
10035 ClangASTContext::DeclContextGetAsDeclContext (const CompilerDeclContext &dc)
10036 {
10037     if (dc.IsClang())
10038         return (clang::DeclContext *)dc.GetOpaqueDeclContext();
10039     return nullptr;
10040 }
10041
10042
10043 ObjCMethodDecl *
10044 ClangASTContext::DeclContextGetAsObjCMethodDecl (const CompilerDeclContext &dc)
10045 {
10046     if (dc.IsClang())
10047         return llvm::dyn_cast<clang::ObjCMethodDecl>((clang::DeclContext *)dc.GetOpaqueDeclContext());
10048     return nullptr;
10049 }
10050
10051 CXXMethodDecl *
10052 ClangASTContext::DeclContextGetAsCXXMethodDecl (const CompilerDeclContext &dc)
10053 {
10054     if (dc.IsClang())
10055         return llvm::dyn_cast<clang::CXXMethodDecl>((clang::DeclContext *)dc.GetOpaqueDeclContext());
10056     return nullptr;
10057 }
10058
10059 clang::FunctionDecl *
10060 ClangASTContext::DeclContextGetAsFunctionDecl (const CompilerDeclContext &dc)
10061 {
10062     if (dc.IsClang())
10063         return llvm::dyn_cast<clang::FunctionDecl>((clang::DeclContext *)dc.GetOpaqueDeclContext());
10064     return nullptr;
10065 }
10066
10067 clang::NamespaceDecl *
10068 ClangASTContext::DeclContextGetAsNamespaceDecl (const CompilerDeclContext &dc)
10069 {
10070     if (dc.IsClang())
10071         return llvm::dyn_cast<clang::NamespaceDecl>((clang::DeclContext *)dc.GetOpaqueDeclContext());
10072     return nullptr;
10073 }
10074
10075 ClangASTMetadata *
10076 ClangASTContext::DeclContextGetMetaData (const CompilerDeclContext &dc, const void *object)
10077 {
10078     clang::ASTContext *ast = DeclContextGetClangASTContext (dc);
10079     if (ast)
10080         return ClangASTContext::GetMetadata (ast, object);
10081     return nullptr;
10082 }
10083
10084 clang::ASTContext *
10085 ClangASTContext::DeclContextGetClangASTContext (const CompilerDeclContext &dc)
10086 {
10087     ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(dc.GetTypeSystem());
10088     if (ast)
10089         return ast->getASTContext();
10090     return nullptr;
10091 }
10092
10093 ClangASTContextForExpressions::ClangASTContextForExpressions (Target &target) :
10094     ClangASTContext (target.GetArchitecture().GetTriple().getTriple().c_str()),
10095     m_target_wp(target.shared_from_this()),
10096     m_persistent_variables (new ClangPersistentVariables)
10097 {
10098 }
10099
10100 UserExpression *
10101 ClangASTContextForExpressions::GetUserExpression (const char *expr,
10102                    const char *expr_prefix,
10103                    lldb::LanguageType language,
10104                    Expression::ResultType desired_type,
10105                    const EvaluateExpressionOptions &options)
10106 {
10107     TargetSP target_sp = m_target_wp.lock();
10108     if (!target_sp)
10109         return nullptr;
10110
10111     return new ClangUserExpression(*target_sp.get(), expr, expr_prefix, language, desired_type, options);
10112 }
10113
10114 FunctionCaller *
10115 ClangASTContextForExpressions::GetFunctionCaller (const CompilerType &return_type,
10116                                                   const Address& function_address,
10117                                                   const ValueList &arg_value_list,
10118                                                   const char *name)
10119 {
10120     TargetSP target_sp = m_target_wp.lock();
10121     if (!target_sp)
10122         return nullptr;
10123
10124    Process *process = target_sp->GetProcessSP().get();
10125    if (!process)
10126        return nullptr;
10127
10128    return new ClangFunctionCaller (*process, return_type, function_address, arg_value_list, name);
10129 }
10130
10131 UtilityFunction *
10132 ClangASTContextForExpressions::GetUtilityFunction (const char *text,
10133                                                    const char *name)
10134 {
10135     TargetSP target_sp = m_target_wp.lock();
10136     if (!target_sp)
10137         return nullptr;
10138
10139     return new ClangUtilityFunction(*target_sp.get(), text, name);
10140 }
10141
10142 PersistentExpressionState *
10143 ClangASTContextForExpressions::GetPersistentExpressionState ()
10144 {
10145     return m_persistent_variables.get();
10146 }