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 <string>
  15
  16 // Other libraries and framework includes
  17
  18 // Clang headers like to use NDEBUG inside of them to enable/disable debug
  19 // related features using "#ifndef NDEBUG" preprocessor blocks to do one thing
  20 // or another. This is bad because it means that if clang was built in release
  21 // mode, it assumes that you are building in release mode which is not always
  22 // the case. You can end up with functions that are defined as empty in header
  23 // files when NDEBUG is not defined, and this can cause link errors with the
  24 // clang .a files that you have since you might be missing functions in the .a
  25 // file. So we have to define NDEBUG when including clang headers to avoid any
  26 // mismatches. This is covered by rdar://problem/8691220
  27
  28 #if !defined(NDEBUG) && !defined(LLVM_NDEBUG_OFF)
  29 #define LLDB_DEFINED_NDEBUG_FOR_CLANG
  30 #define NDEBUG
  31 // Need to include assert.h so it is as clang would expect it to be (disabled)
  32 #include <assert.h>
  33 #endif
  34
  35 #include "clang/AST/ASTContext.h"
  36 #include "clang/AST/ASTImporter.h"
  37 #include "clang/AST/Attr.h"
  38 #include "clang/AST/CXXInheritance.h"
  39 #include "clang/AST/DeclObjC.h"
  40 #include "clang/AST/DeclTemplate.h"
  41 #include "clang/AST/RecordLayout.h"
  42 #include "clang/AST/Type.h"
  43 #include "clang/Basic/Builtins.h"
  44 #include "clang/Basic/Diagnostic.h"
  45 #include "clang/Basic/FileManager.h"
  46 #include "clang/Basic/FileSystemOptions.h"
  47 #include "clang/Basic/SourceManager.h"
  48 #include "clang/Basic/TargetInfo.h"
  49 #include "clang/Basic/TargetOptions.h"
  50 #include "clang/Frontend/FrontendOptions.h"
  51 #include "clang/Frontend/LangStandard.h"
  52
  53 #ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
  54 #undef NDEBUG
  55 #undef LLDB_DEFINED_NDEBUG_FOR_CLANG
  56 // Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
  57 #include <assert.h>
  58 #endif
  59
  60 #include "lldb/Core/ArchSpec.h"
  61 #include "lldb/Core/dwarf.h"
  62 #include "lldb/Core/Flags.h"
  63 #include "lldb/Core/Log.h"
  64 #include "lldb/Core/RegularExpression.h"
  65 #include "lldb/Core/UniqueCStringMap.h"
  66 #include "lldb/Expression/ASTDumper.h"
  67 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
  68 #include "lldb/Symbol/VerifyDecl.h"
  69 #include "lldb/Target/ExecutionContext.h"
  70 #include "lldb/Target/Process.h"
  71 #include "lldb/Target/ObjCLanguageRuntime.h"
  72
  73 #include <stdio.h>
  74
  75 #include <mutex>
  76
  77 using namespace lldb;
  78 using namespace lldb_private;
  79 using namespace llvm;
  80 using namespace clang;
  81
  82 typedef llvm::DenseMap<clang::ASTContext *, ClangASTContext*> ClangASTMap;
  83
  84 static ClangASTMap &
  85 GetASTMap()
  86 {
  87     static ClangASTMap g_map;
  88     return g_map;
  89 }
  90
  91
  92 clang::AccessSpecifier
  93 ClangASTContext::ConvertAccessTypeToAccessSpecifier (AccessType access)
  94 {
  95     switch (access)
  96     {
  97     default:               break;
  98     case eAccessNone:      return AS_none;
  99     case eAccessPublic:    return AS_public;
 100     case eAccessPrivate:   return AS_private;
 101     case eAccessProtected: return AS_protected;
 102     }
 103     return AS_none;
 104 }
 105
 106
 107 static void
 108 ParseLangArgs
 109 (
 110     LangOptions &Opts,
 111     InputKind IK
 112 )
 113 {
 114     // FIXME: Cleanup per-file based stuff.
 115
 116     // Set some properties which depend solely on the input kind; it would be nice
 117     // to move these to the language standard, and have the driver resolve the
 118     // input kind + language standard.
 119     if (IK == IK_Asm) {
 120         Opts.AsmPreprocessor = 1;
 121     } else if (IK == IK_ObjC ||
 122                IK == IK_ObjCXX ||
 123                IK == IK_PreprocessedObjC ||
 124                IK == IK_PreprocessedObjCXX) {
 125         Opts.ObjC1 = Opts.ObjC2 = 1;
 126     }
 127
 128     LangStandard::Kind LangStd = LangStandard::lang_unspecified;
 129
 130     if (LangStd == LangStandard::lang_unspecified) {
 131         // Based on the base language, pick one.
 132         switch (IK) {
 133             case IK_None:
 134             case IK_AST:
 135             case IK_LLVM_IR:
 136                 assert (!"Invalid input kind!");
 137             case IK_OpenCL:
 138                 LangStd = LangStandard::lang_opencl;
 139                 break;
 140             case IK_CUDA:
 141                 LangStd = LangStandard::lang_cuda;
 142                 break;
 143             case IK_Asm:
 144             case IK_C:
 145             case IK_PreprocessedC:
 146             case IK_ObjC:
 147             case IK_PreprocessedObjC:
 148                 LangStd = LangStandard::lang_gnu99;
 149                 break;
 150             case IK_CXX:
 151             case IK_PreprocessedCXX:
 152             case IK_ObjCXX:
 153             case IK_PreprocessedObjCXX:
 154                 LangStd = LangStandard::lang_gnucxx98;
 155                 break;
 156         }
 157     }
 158
 159     const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
 160     Opts.LineComment = Std.hasLineComments();
 161     Opts.C99 = Std.isC99();
 162     Opts.CPlusPlus = Std.isCPlusPlus();
 163     Opts.CPlusPlus11 = Std.isCPlusPlus11();
 164     Opts.Digraphs = Std.hasDigraphs();
 165     Opts.GNUMode = Std.isGNUMode();
 166     Opts.GNUInline = !Std.isC99();
 167     Opts.HexFloats = Std.hasHexFloats();
 168     Opts.ImplicitInt = Std.hasImplicitInt();
 169
 170     Opts.WChar = true;
 171
 172     // OpenCL has some additional defaults.
 173     if (LangStd == LangStandard::lang_opencl) {
 174         Opts.OpenCL = 1;
 175         Opts.AltiVec = 1;
 176         Opts.CXXOperatorNames = 1;
 177         Opts.LaxVectorConversions = 1;
 178     }
 179
 180     // OpenCL and C++ both have bool, true, false keywords.
 181     Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
 182
 183 //    if (Opts.CPlusPlus)
 184 //        Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names);
 185 //
 186 //    if (Args.hasArg(OPT_fobjc_gc_only))
 187 //        Opts.setGCMode(LangOptions::GCOnly);
 188 //    else if (Args.hasArg(OPT_fobjc_gc))
 189 //        Opts.setGCMode(LangOptions::HybridGC);
 190 //
 191 //    if (Args.hasArg(OPT_print_ivar_layout))
 192 //        Opts.ObjCGCBitmapPrint = 1;
 193 //
 194 //    if (Args.hasArg(OPT_faltivec))
 195 //        Opts.AltiVec = 1;
 196 //
 197 //    if (Args.hasArg(OPT_pthread))
 198 //        Opts.POSIXThreads = 1;
 199 //
 200 //    llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility,
 201 //                                          "default");
 202 //    if (Vis == "default")
 203         Opts.setValueVisibilityMode(DefaultVisibility);
 204 //    else if (Vis == "hidden")
 205 //        Opts.setVisibilityMode(LangOptions::Hidden);
 206 //    else if (Vis == "protected")
 207 //        Opts.setVisibilityMode(LangOptions::Protected);
 208 //    else
 209 //        Diags.Report(diag::err_drv_invalid_value)
 210 //        << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
 211
 212 //    Opts.OverflowChecking = Args.hasArg(OPT_ftrapv);
 213
 214     // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
 215     // is specified, or -std is set to a conforming mode.
 216     Opts.Trigraphs = !Opts.GNUMode;
 217 //    if (Args.hasArg(OPT_trigraphs))
 218 //        Opts.Trigraphs = 1;
 219 //
 220 //    Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
 221 //                                     OPT_fno_dollars_in_identifiers,
 222 //                                     !Opts.AsmPreprocessor);
 223 //    Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
 224 //    Opts.Microsoft = Args.hasArg(OPT_fms_extensions);
 225 //    Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
 226 //    if (Args.hasArg(OPT_fno_lax_vector_conversions))
 227 //        Opts.LaxVectorConversions = 0;
 228 //    Opts.Exceptions = Args.hasArg(OPT_fexceptions);
 229 //    Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
 230 //    Opts.Blocks = Args.hasArg(OPT_fblocks);
 231 //    Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
 232 //    Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
 233 //    Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
 234 //    Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
 235 //    Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
 236 //    Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
 237 //    Opts.AccessControl = Args.hasArg(OPT_faccess_control);
 238 //    Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
 239 //    Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno);
 240 //    Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99,
 241 //                                                 Diags);
 242 //    Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
 243 //    Opts.ObjCConstantStringClass = getLastArgValue(Args,
 244 //                                                   OPT_fconstant_string_class);
 245 //    Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi);
 246 //    Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
 247 //    Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
 248 //    Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
 249 //    Opts.Static = Args.hasArg(OPT_static_define);
 250     Opts.OptimizeSize = 0;
 251
 252     // FIXME: Eliminate this dependency.
 253 //    unsigned Opt =
 254 //    Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
 255 //    Opts.Optimize = Opt != 0;
 256     unsigned Opt = 0;
 257
 258     // This is the __NO_INLINE__ define, which just depends on things like the
 259     // optimization level and -fno-inline, not actually whether the backend has
 260     // inlining enabled.
 261     //
 262     // FIXME: This is affected by other options (-fno-inline).
 263     Opts.NoInlineDefine = !Opt;
 264
 265 //    unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
 266 //    switch (SSP) {
 267 //        default:
 268 //            Diags.Report(diag::err_drv_invalid_value)
 269 //            << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
 270 //            break;
 271 //        case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break;
 272 //        case 1: Opts.setStackProtectorMode(LangOptions::SSPOn);  break;
 273 //        case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break;
 274 //    }
 275 }
 276
 277
 278 ClangASTContext::ClangASTContext (const char *target_triple) :
 279     m_target_triple(),
 280     m_ast_ap(),
 281     m_language_options_ap(),
 282     m_source_manager_ap(),
 283     m_diagnostics_engine_ap(),
 284     m_target_options_rp(),
 285     m_target_info_ap(),
 286     m_identifier_table_ap(),
 287     m_selector_table_ap(),
 288     m_builtins_ap(),
 289     m_callback_tag_decl (nullptr),
 290     m_callback_objc_decl (nullptr),
 291     m_callback_baton (nullptr),
 292     m_pointer_byte_size (0)
 293
 294 {
 295     if (target_triple && target_triple[0])
 296         SetTargetTriple (target_triple);
 297 }
 298
 299 //----------------------------------------------------------------------
 300 // Destructor
 301 //----------------------------------------------------------------------
 302 ClangASTContext::~ClangASTContext()
 303 {
 304     if (m_ast_ap.get())
 305     {
 306         GetASTMap().erase(m_ast_ap.get());
 307     }
 308
 309     m_builtins_ap.reset();
 310     m_selector_table_ap.reset();
 311     m_identifier_table_ap.reset();
 312     m_target_info_ap.reset();
 313     m_target_options_rp.reset();
 314     m_diagnostics_engine_ap.reset();
 315     m_source_manager_ap.reset();
 316     m_language_options_ap.reset();
 317     m_ast_ap.reset();
 318 }
 319
 320
 321 void
 322 ClangASTContext::Clear()
 323 {
 324     m_ast_ap.reset();
 325     m_language_options_ap.reset();
 326     m_source_manager_ap.reset();
 327     m_diagnostics_engine_ap.reset();
 328     m_target_options_rp.reset();
 329     m_target_info_ap.reset();
 330     m_identifier_table_ap.reset();
 331     m_selector_table_ap.reset();
 332     m_builtins_ap.reset();
 333     m_pointer_byte_size = 0;
 334 }
 335
 336 const char *
 337 ClangASTContext::GetTargetTriple ()
 338 {
 339     return m_target_triple.c_str();
 340 }
 341
 342 void
 343 ClangASTContext::SetTargetTriple (const char *target_triple)
 344 {
 345     Clear();
 346     m_target_triple.assign(target_triple);
 347 }
 348
 349 void
 350 ClangASTContext::SetArchitecture (const ArchSpec &arch)
 351 {
 352     SetTargetTriple(arch.GetTriple().str().c_str());
 353 }
 354
 355 bool
 356 ClangASTContext::HasExternalSource ()
 357 {
 358     ASTContext *ast = getASTContext();
 359     if (ast)
 360         return ast->getExternalSource () != nullptr;
 361     return false;
 362 }
 363
 364 void
 365 ClangASTContext::SetExternalSource (llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_ap)
 366 {
 367     ASTContext *ast = getASTContext();
 368     if (ast)
 369     {
 370         ast->setExternalSource (ast_source_ap);
 371         ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true);
 372         //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true);
 373     }
 374 }
 375
 376 void
 377 ClangASTContext::RemoveExternalSource ()
 378 {
 379     ASTContext *ast = getASTContext();
 380
 381     if (ast)
 382     {
 383         llvm::IntrusiveRefCntPtr<ExternalASTSource> empty_ast_source_ap;
 384         ast->setExternalSource (empty_ast_source_ap);
 385         ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false);
 386         //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false);
 387     }
 388 }
 389
 390
 391
 392 ASTContext *
 393 ClangASTContext::getASTContext()
 394 {
 395     if (m_ast_ap.get() == nullptr)
 396     {
 397         m_ast_ap.reset(new ASTContext (*getLanguageOptions(),
 398                                        *getSourceManager(),
 399                                        *getIdentifierTable(),
 400                                        *getSelectorTable(),
 401                                        *getBuiltinContext()));
 402         m_ast_ap->InitBuiltinTypes(*getTargetInfo());
 403
 404         if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton)
 405         {
 406             m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage();
 407             //m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage();
 408         }
 409
 410         m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false);
 411
 412         GetASTMap().insert(std::make_pair(m_ast_ap.get(), this));
 413     }
 414     return m_ast_ap.get();
 415 }
 416
 417 ClangASTContext*
 418 ClangASTContext::GetASTContext (clang::ASTContext* ast)
 419 {
 420     ClangASTContext *clang_ast = GetASTMap().lookup(ast);
 421     return clang_ast;
 422 }
 423
 424 Builtin::Context *
 425 ClangASTContext::getBuiltinContext()
 426 {
 427     if (m_builtins_ap.get() == nullptr)
 428         m_builtins_ap.reset (new Builtin::Context());
 429     return m_builtins_ap.get();
 430 }
 431
 432 IdentifierTable *
 433 ClangASTContext::getIdentifierTable()
 434 {
 435     if (m_identifier_table_ap.get() == nullptr)
 436         m_identifier_table_ap.reset(new IdentifierTable (*ClangASTContext::getLanguageOptions(), nullptr));
 437     return m_identifier_table_ap.get();
 438 }
 439
 440 LangOptions *
 441 ClangASTContext::getLanguageOptions()
 442 {
 443     if (m_language_options_ap.get() == nullptr)
 444     {
 445         m_language_options_ap.reset(new LangOptions());
 446         ParseLangArgs(*m_language_options_ap, IK_ObjCXX);
 447 //        InitializeLangOptions(*m_language_options_ap, IK_ObjCXX);
 448     }
 449     return m_language_options_ap.get();
 450 }
 451
 452 SelectorTable *
 453 ClangASTContext::getSelectorTable()
 454 {
 455     if (m_selector_table_ap.get() == nullptr)
 456         m_selector_table_ap.reset (new SelectorTable());
 457     return m_selector_table_ap.get();
 458 }
 459
 460 clang::FileManager *
 461 ClangASTContext::getFileManager()
 462 {
 463     if (m_file_manager_ap.get() == nullptr)
 464     {
 465         clang::FileSystemOptions file_system_options;
 466         m_file_manager_ap.reset(new clang::FileManager(file_system_options));
 467     }
 468     return m_file_manager_ap.get();
 469 }
 470
 471 clang::SourceManager *
 472 ClangASTContext::getSourceManager()
 473 {
 474     if (m_source_manager_ap.get() == nullptr)
 475         m_source_manager_ap.reset(new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager()));
 476     return m_source_manager_ap.get();
 477 }
 478
 479 clang::DiagnosticsEngine *
 480 ClangASTContext::getDiagnosticsEngine()
 481 {
 482     if (m_diagnostics_engine_ap.get() == nullptr)
 483     {
 484         llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs());
 485         m_diagnostics_engine_ap.reset(new DiagnosticsEngine(diag_id_sp, new DiagnosticOptions()));
 486     }
 487     return m_diagnostics_engine_ap.get();
 488 }
 489
 490 class NullDiagnosticConsumer : public DiagnosticConsumer
 491 {
 492 public:
 493     NullDiagnosticConsumer ()
 494     {
 495         m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS);
 496     }
 497
 498     void HandleDiagnostic (DiagnosticsEngine::Level DiagLevel, const Diagnostic &info)
 499     {
 500         if (m_log)
 501         {
 502             llvm::SmallVector<char, 32> diag_str(10);
 503             info.FormatDiagnostic(diag_str);
 504             diag_str.push_back('\0');
 505             m_log->Printf("Compiler diagnostic: %s\n", diag_str.data());
 506         }
 507     }
 508
 509     DiagnosticConsumer *clone (DiagnosticsEngine &Diags) const
 510     {
 511         return new NullDiagnosticConsumer ();
 512     }
 513 private:
 514     Log * m_log;
 515 };
 516
 517 DiagnosticConsumer *
 518 ClangASTContext::getDiagnosticConsumer()
 519 {
 520     if (m_diagnostic_consumer_ap.get() == nullptr)
 521         m_diagnostic_consumer_ap.reset(new NullDiagnosticConsumer);
 522
 523     return m_diagnostic_consumer_ap.get();
 524 }
 525
 526 std::shared_ptr<TargetOptions> &
 527 ClangASTContext::getTargetOptions() {
 528     if (m_target_options_rp.get() == nullptr && !m_target_triple.empty())
 529     {
 530         m_target_options_rp = std::make_shared<TargetOptions>();
 531         if (m_target_options_rp.get() != nullptr)
 532             m_target_options_rp->Triple = m_target_triple;
 533     }
 534     return m_target_options_rp;
 535 }
 536
 537
 538 TargetInfo *
 539 ClangASTContext::getTargetInfo()
 540 {
 541     // target_triple should be something like "x86_64-apple-macosx"
 542     if (m_target_info_ap.get() == nullptr && !m_target_triple.empty())
 543         m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), getTargetOptions()));
 544     return m_target_info_ap.get();
 545 }
 546
 547 #pragma mark Basic Types
 548
 549 static inline bool
 550 QualTypeMatchesBitSize(const uint64_t bit_size, ASTContext *ast, QualType qual_type)
 551 {
 552     uint64_t qual_type_bit_size = ast->getTypeSize(qual_type);
 553     if (qual_type_bit_size == bit_size)
 554         return true;
 555     return false;
 556 }
 557 ClangASTType
 558 ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, uint32_t bit_size)
 559 {
 560     return ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (getASTContext(), encoding, bit_size);
 561 }
 562
 563 ClangASTType
 564 ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast, Encoding encoding, uint32_t bit_size)
 565 {
 566     if (!ast)
 567         return ClangASTType();
 568
 569     switch (encoding)
 570     {
 571     case eEncodingInvalid:
 572         if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
 573             return ClangASTType (ast, ast->VoidPtrTy.getAsOpaquePtr());
 574         break;
 575
 576     case eEncodingUint:
 577         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
 578             return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr());
 579         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
 580             return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr());
 581         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
 582             return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr());
 583         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
 584             return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr());
 585         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
 586             return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr());
 587         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
 588             return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr());
 589         break;
 590
 591     case eEncodingSint:
 592         if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
 593             return ClangASTType (ast, ast->CharTy.getAsOpaquePtr());
 594         if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
 595             return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr());
 596         if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
 597             return ClangASTType (ast, ast->IntTy.getAsOpaquePtr());
 598         if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
 599             return ClangASTType (ast, ast->LongTy.getAsOpaquePtr());
 600         if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
 601             return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr());
 602         if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
 603             return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr());
 604         break;
 605
 606     case eEncodingIEEE754:
 607         if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
 608             return ClangASTType (ast, ast->FloatTy.getAsOpaquePtr());
 609         if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
 610             return ClangASTType (ast, ast->DoubleTy.getAsOpaquePtr());
 611         if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
 612             return ClangASTType (ast, ast->LongDoubleTy.getAsOpaquePtr());
 613         break;
 614
 615     case eEncodingVector:
 616         // Sanity check that bit_size is a multiple of 8's.
 617         if (bit_size && !(bit_size & 0x7u))
 618             return ClangASTType (ast, ast->getExtVectorType (ast->UnsignedCharTy, bit_size/8).getAsOpaquePtr());
 619         break;
 620     }
 621
 622     return ClangASTType();
 623 }
 624
 625
 626
 627 lldb::BasicType
 628 ClangASTContext::GetBasicTypeEnumeration (const ConstString &name)
 629 {
 630     if (name)
 631     {
 632         typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
 633         static TypeNameToBasicTypeMap g_type_map;
 634         static std::once_flag g_once_flag;
 635         std::call_once(g_once_flag, [](){
 636             // "void"
 637             g_type_map.Append(ConstString("void").GetCString(), eBasicTypeVoid);
 638
 639             // "char"
 640             g_type_map.Append(ConstString("char").GetCString(), eBasicTypeChar);
 641             g_type_map.Append(ConstString("signed char").GetCString(), eBasicTypeSignedChar);
 642             g_type_map.Append(ConstString("unsigned char").GetCString(), eBasicTypeUnsignedChar);
 643             g_type_map.Append(ConstString("wchar_t").GetCString(), eBasicTypeWChar);
 644             g_type_map.Append(ConstString("signed wchar_t").GetCString(), eBasicTypeSignedWChar);
 645             g_type_map.Append(ConstString("unsigned wchar_t").GetCString(), eBasicTypeUnsignedWChar);
 646             // "short"
 647             g_type_map.Append(ConstString("short").GetCString(), eBasicTypeShort);
 648             g_type_map.Append(ConstString("short int").GetCString(), eBasicTypeShort);
 649             g_type_map.Append(ConstString("unsigned short").GetCString(), eBasicTypeUnsignedShort);
 650             g_type_map.Append(ConstString("unsigned short int").GetCString(), eBasicTypeUnsignedShort);
 651
 652             // "int"
 653             g_type_map.Append(ConstString("int").GetCString(), eBasicTypeInt);
 654             g_type_map.Append(ConstString("signed int").GetCString(), eBasicTypeInt);
 655             g_type_map.Append(ConstString("unsigned int").GetCString(), eBasicTypeUnsignedInt);
 656             g_type_map.Append(ConstString("unsigned").GetCString(), eBasicTypeUnsignedInt);
 657
 658             // "long"
 659             g_type_map.Append(ConstString("long").GetCString(), eBasicTypeLong);
 660             g_type_map.Append(ConstString("long int").GetCString(), eBasicTypeLong);
 661             g_type_map.Append(ConstString("unsigned long").GetCString(), eBasicTypeUnsignedLong);
 662             g_type_map.Append(ConstString("unsigned long int").GetCString(), eBasicTypeUnsignedLong);
 663
 664             // "long long"
 665             g_type_map.Append(ConstString("long long").GetCString(), eBasicTypeLongLong);
 666             g_type_map.Append(ConstString("long long int").GetCString(), eBasicTypeLongLong);
 667             g_type_map.Append(ConstString("unsigned long long").GetCString(), eBasicTypeUnsignedLongLong);
 668             g_type_map.Append(ConstString("unsigned long long int").GetCString(), eBasicTypeUnsignedLongLong);
 669
 670             // "int128"
 671             g_type_map.Append(ConstString("__int128_t").GetCString(), eBasicTypeInt128);
 672             g_type_map.Append(ConstString("__uint128_t").GetCString(), eBasicTypeUnsignedInt128);
 673
 674             // Miscellaneous
 675             g_type_map.Append(ConstString("bool").GetCString(), eBasicTypeBool);
 676             g_type_map.Append(ConstString("float").GetCString(), eBasicTypeFloat);
 677             g_type_map.Append(ConstString("double").GetCString(), eBasicTypeDouble);
 678             g_type_map.Append(ConstString("long double").GetCString(), eBasicTypeLongDouble);
 679             g_type_map.Append(ConstString("id").GetCString(), eBasicTypeObjCID);
 680             g_type_map.Append(ConstString("SEL").GetCString(), eBasicTypeObjCSel);
 681             g_type_map.Append(ConstString("nullptr").GetCString(), eBasicTypeNullPtr);
 682             g_type_map.Sort();
 683         });
 684
 685         return g_type_map.Find(name.GetCString(), eBasicTypeInvalid);
 686     }
 687     return eBasicTypeInvalid;
 688 }
 689
 690 ClangASTType
 691 ClangASTContext::GetBasicType (ASTContext *ast, const ConstString &name)
 692 {
 693     if (ast)
 694     {
 695         lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration (name);
 696         return ClangASTContext::GetBasicType (ast, basic_type);
 697     }
 698     return ClangASTType();
 699 }
 700
 701 uint32_t
 702 ClangASTContext::GetPointerByteSize ()
 703 {
 704     if (m_pointer_byte_size == 0)
 705         m_pointer_byte_size = GetBasicType(lldb::eBasicTypeVoid).GetPointerType().GetByteSize();
 706     return m_pointer_byte_size;
 707 }
 708
 709 ClangASTType
 710 ClangASTContext::GetBasicType (lldb::BasicType basic_type)
 711 {
 712     return GetBasicType (getASTContext(), basic_type);
 713 }
 714
 715 ClangASTType
 716 ClangASTContext::GetBasicType (ASTContext *ast, lldb::BasicType basic_type)
 717 {
 718     if (ast)
 719     {
 720         clang_type_t clang_type = nullptr;
 721
 722         switch (basic_type)
 723         {
 724             case eBasicTypeInvalid:
 725             case eBasicTypeOther:
 726                 break;
 727             case eBasicTypeVoid:
 728                 clang_type = ast->VoidTy.getAsOpaquePtr();
 729                 break;
 730             case eBasicTypeChar:
 731                 clang_type = ast->CharTy.getAsOpaquePtr();
 732                 break;
 733             case eBasicTypeSignedChar:
 734                 clang_type = ast->SignedCharTy.getAsOpaquePtr();
 735                 break;
 736             case eBasicTypeUnsignedChar:
 737                 clang_type = ast->UnsignedCharTy.getAsOpaquePtr();
 738                 break;
 739             case eBasicTypeWChar:
 740                 clang_type = ast->getWCharType().getAsOpaquePtr();
 741                 break;
 742             case eBasicTypeSignedWChar:
 743                 clang_type = ast->getSignedWCharType().getAsOpaquePtr();
 744                 break;
 745             case eBasicTypeUnsignedWChar:
 746                 clang_type = ast->getUnsignedWCharType().getAsOpaquePtr();
 747                 break;
 748             case eBasicTypeChar16:
 749                 clang_type = ast->Char16Ty.getAsOpaquePtr();
 750                 break;
 751             case eBasicTypeChar32:
 752                 clang_type = ast->Char32Ty.getAsOpaquePtr();
 753                 break;
 754             case eBasicTypeShort:
 755                 clang_type = ast->ShortTy.getAsOpaquePtr();
 756                 break;
 757             case eBasicTypeUnsignedShort:
 758                 clang_type = ast->UnsignedShortTy.getAsOpaquePtr();
 759                 break;
 760             case eBasicTypeInt:
 761                 clang_type = ast->IntTy.getAsOpaquePtr();
 762                 break;
 763             case eBasicTypeUnsignedInt:
 764                 clang_type = ast->UnsignedIntTy.getAsOpaquePtr();
 765                 break;
 766             case eBasicTypeLong:
 767                 clang_type = ast->LongTy.getAsOpaquePtr();
 768                 break;
 769             case eBasicTypeUnsignedLong:
 770                 clang_type = ast->UnsignedLongTy.getAsOpaquePtr();
 771                 break;
 772             case eBasicTypeLongLong:
 773                 clang_type = ast->LongLongTy.getAsOpaquePtr();
 774                 break;
 775             case eBasicTypeUnsignedLongLong:
 776                 clang_type = ast->UnsignedLongLongTy.getAsOpaquePtr();
 777                 break;
 778             case eBasicTypeInt128:
 779                 clang_type = ast->Int128Ty.getAsOpaquePtr();
 780                 break;
 781             case eBasicTypeUnsignedInt128:
 782                 clang_type = ast->UnsignedInt128Ty.getAsOpaquePtr();
 783                 break;
 784             case eBasicTypeBool:
 785                 clang_type = ast->BoolTy.getAsOpaquePtr();
 786                 break;
 787             case eBasicTypeHalf:
 788                 clang_type = ast->HalfTy.getAsOpaquePtr();
 789                 break;
 790             case eBasicTypeFloat:
 791                 clang_type = ast->FloatTy.getAsOpaquePtr();
 792                 break;
 793             case eBasicTypeDouble:
 794                 clang_type = ast->DoubleTy.getAsOpaquePtr();
 795                 break;
 796             case eBasicTypeLongDouble:
 797                 clang_type = ast->LongDoubleTy.getAsOpaquePtr();
 798                 break;
 799             case eBasicTypeFloatComplex:
 800                 clang_type = ast->FloatComplexTy.getAsOpaquePtr();
 801                 break;
 802             case eBasicTypeDoubleComplex:
 803                 clang_type = ast->DoubleComplexTy.getAsOpaquePtr();
 804                 break;
 805             case eBasicTypeLongDoubleComplex:
 806                 clang_type = ast->LongDoubleComplexTy.getAsOpaquePtr();
 807                 break;
 808             case eBasicTypeObjCID:
 809                 clang_type = ast->getObjCIdType().getAsOpaquePtr();
 810                 break;
 811             case eBasicTypeObjCClass:
 812                 clang_type = ast->getObjCClassType().getAsOpaquePtr();
 813                 break;
 814             case eBasicTypeObjCSel:
 815                 clang_type = ast->getObjCSelType().getAsOpaquePtr();
 816                 break;
 817             case eBasicTypeNullPtr:
 818                 clang_type = ast->NullPtrTy.getAsOpaquePtr();
 819                 break;
 820         }
 821
 822         if (clang_type)
 823             return ClangASTType (ast, clang_type);
 824     }
 825     return ClangASTType();
 826 }
 827
 828
 829 ClangASTType
 830 ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size)
 831 {
 832     ASTContext *ast = getASTContext();
 833
 834 #define streq(a,b) strcmp(a,b) == 0
 835     assert (ast != nullptr);
 836     if (ast)
 837     {
 838         switch (dw_ate)
 839         {
 840             default:
 841                 break;
 842
 843             case DW_ATE_address:
 844                 if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
 845                     return ClangASTType (ast, ast->VoidPtrTy.getAsOpaquePtr());
 846                 break;
 847
 848             case DW_ATE_boolean:
 849                 if (QualTypeMatchesBitSize (bit_size, ast, ast->BoolTy))
 850                     return ClangASTType (ast, ast->BoolTy.getAsOpaquePtr());
 851                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
 852                     return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr());
 853                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
 854                     return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr());
 855                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
 856                     return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr());
 857                 break;
 858
 859             case DW_ATE_lo_user:
 860                 // This has been seen to mean DW_AT_complex_integer
 861                 if (type_name)
 862                 {
 863                     if (::strstr(type_name, "complex"))
 864                     {
 865                         ClangASTType complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2);
 866                         return ClangASTType (ast, ast->getComplexType (complex_int_clang_type.GetQualType()).getAsOpaquePtr());
 867                     }
 868                 }
 869                 break;
 870
 871             case DW_ATE_complex_float:
 872                 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy))
 873                     return ClangASTType (ast, ast->FloatComplexTy.getAsOpaquePtr());
 874                 else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy))
 875                     return ClangASTType (ast, ast->DoubleComplexTy.getAsOpaquePtr());
 876                 else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy))
 877                     return ClangASTType (ast, ast->LongDoubleComplexTy.getAsOpaquePtr());
 878                 else
 879                 {
 880                     ClangASTType complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2);
 881                     return ClangASTType (ast, ast->getComplexType (complex_float_clang_type.GetQualType()).getAsOpaquePtr());
 882                 }
 883                 break;
 884
 885             case DW_ATE_float:
 886                 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
 887                     return ClangASTType (ast, ast->FloatTy.getAsOpaquePtr());
 888                 if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
 889                     return ClangASTType (ast, ast->DoubleTy.getAsOpaquePtr());
 890                 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
 891                     return ClangASTType (ast, ast->LongDoubleTy.getAsOpaquePtr());
 892                 break;
 893
 894             case DW_ATE_signed:
 895                 if (type_name)
 896                 {
 897                     if (streq(type_name, "wchar_t") &&
 898                         QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy))
 899                         return ClangASTType (ast, ast->WCharTy.getAsOpaquePtr());
 900                     if (streq(type_name, "void") &&
 901                         QualTypeMatchesBitSize (bit_size, ast, ast->VoidTy))
 902                         return ClangASTType (ast, ast->VoidTy.getAsOpaquePtr());
 903                     if (strstr(type_name, "long long") &&
 904                         QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
 905                         return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr());
 906                     if (strstr(type_name, "long") &&
 907                         QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
 908                         return ClangASTType (ast, ast->LongTy.getAsOpaquePtr());
 909                     if (strstr(type_name, "short") &&
 910                         QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
 911                         return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr());
 912                     if (strstr(type_name, "char"))
 913                     {
 914                         if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
 915                             return ClangASTType (ast, ast->CharTy.getAsOpaquePtr());
 916                         if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
 917                             return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr());
 918                     }
 919                     if (strstr(type_name, "int"))
 920                     {
 921                         if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
 922                             return ClangASTType (ast, ast->IntTy.getAsOpaquePtr());
 923                         if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
 924                             return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr());
 925                     }
 926                 }
 927                 // We weren't able to match up a type name, just search by size
 928                 if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
 929                     return ClangASTType (ast, ast->CharTy.getAsOpaquePtr());
 930                 if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
 931                     return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr());
 932                 if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
 933                     return ClangASTType (ast, ast->IntTy.getAsOpaquePtr());
 934                 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
 935                     return ClangASTType (ast, ast->LongTy.getAsOpaquePtr());
 936                 if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
 937                     return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr());
 938                 if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
 939                     return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr());
 940                 break;
 941
 942             case DW_ATE_signed_char:
 943                 if (type_name)
 944                 {
 945                     if (streq(type_name, "signed char"))
 946                     {
 947                         if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
 948                             return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr());
 949                     }
 950                 }
 951                 if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
 952                     return ClangASTType (ast, ast->CharTy.getAsOpaquePtr());
 953                 if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
 954                     return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr());
 955                 break;
 956
 957             case DW_ATE_unsigned:
 958                 if (type_name)
 959                 {
 960                     if (strstr(type_name, "long long"))
 961                     {
 962                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
 963                             return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr());
 964                     }
 965                     else if (strstr(type_name, "long"))
 966                     {
 967                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
 968                             return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr());
 969                     }
 970                     else if (strstr(type_name, "short"))
 971                     {
 972                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
 973                             return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr());
 974                     }
 975                     else if (strstr(type_name, "char"))
 976                     {
 977                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
 978                             return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr());
 979                     }
 980                     else if (strstr(type_name, "int"))
 981                     {
 982                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
 983                             return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr());
 984                         if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
 985                             return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr());
 986                     }
 987                 }
 988                 // We weren't able to match up a type name, just search by size
 989                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
 990                     return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr());
 991                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
 992                     return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr());
 993                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
 994                     return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr());
 995                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
 996                     return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr());
 997                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
 998                     return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr());
 999                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
1000                     return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr());
1001                 break;
1002
1003             case DW_ATE_unsigned_char:
1004                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
1005                     return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr());
1006                 if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
1007                     return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr());
1008                 break;
1009
1010             case DW_ATE_imaginary_float:
1011                 break;
1012
1013             case DW_ATE_UTF:
1014                 if (type_name)
1015                 {
1016                     if (streq(type_name, "char16_t"))
1017                     {
1018                         return ClangASTType (ast, ast->Char16Ty.getAsOpaquePtr());
1019                     }
1020                     else if (streq(type_name, "char32_t"))
1021                     {
1022                         return ClangASTType (ast, ast->Char32Ty.getAsOpaquePtr());
1023                     }
1024                 }
1025                 break;
1026         }
1027     }
1028     // This assert should fire for anything that we don't catch above so we know
1029     // to fix any issues we run into.
1030     if (type_name)
1031     {
1032         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);
1033     }
1034     else
1035     {
1036         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);
1037     }
1038     return ClangASTType ();
1039 }
1040
1041 ClangASTType
1042 ClangASTContext::GetUnknownAnyType(clang::ASTContext *ast)
1043 {
1044     if (ast)
1045         return ClangASTType (ast, ast->UnknownAnyTy.getAsOpaquePtr());
1046     return ClangASTType();
1047 }
1048
1049 ClangASTType
1050 ClangASTContext::GetCStringType (bool is_const)
1051 {
1052     ASTContext *ast = getASTContext();
1053     QualType char_type(ast->CharTy);
1054
1055     if (is_const)
1056         char_type.addConst();
1057
1058     return ClangASTType (ast, ast->getPointerType(char_type).getAsOpaquePtr());
1059 }
1060
1061 clang::DeclContext *
1062 ClangASTContext::GetTranslationUnitDecl (clang::ASTContext *ast)
1063 {
1064     return ast->getTranslationUnitDecl();
1065 }
1066
1067 ClangASTType
1068 ClangASTContext::CopyType (ASTContext *dst_ast,
1069                            ClangASTType src)
1070 {
1071     FileSystemOptions file_system_options;
1072     ASTContext *src_ast = src.GetASTContext();
1073     FileManager file_manager (file_system_options);
1074     ASTImporter importer(*dst_ast, file_manager,
1075                          *src_ast, file_manager,
1076                          false);
1077
1078     QualType dst (importer.Import(src.GetQualType()));
1079
1080     return ClangASTType (dst_ast, dst.getAsOpaquePtr());
1081 }
1082
1083
1084 clang::Decl *
1085 ClangASTContext::CopyDecl (ASTContext *dst_ast,
1086                            ASTContext *src_ast,
1087                            clang::Decl *source_decl)
1088 {
1089     FileSystemOptions file_system_options;
1090     FileManager file_manager (file_system_options);
1091     ASTImporter importer(*dst_ast, file_manager,
1092                          *src_ast, file_manager,
1093                          false);
1094
1095     return importer.Import(source_decl);
1096 }
1097
1098 bool
1099 ClangASTContext::AreTypesSame (ClangASTType type1,
1100                                ClangASTType type2,
1101                                bool ignore_qualifiers)
1102 {
1103     ASTContext *ast = type1.GetASTContext();
1104     if (ast != type2.GetASTContext())
1105         return false;
1106
1107     if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType())
1108         return true;
1109
1110     QualType type1_qual = type1.GetQualType();
1111     QualType type2_qual = type2.GetQualType();
1112
1113     if (ignore_qualifiers)
1114     {
1115         type1_qual = type1_qual.getUnqualifiedType();
1116         type2_qual = type2_qual.getUnqualifiedType();
1117     }
1118
1119     return ast->hasSameType (type1_qual, type2_qual);
1120 }
1121
1122
1123 ClangASTType
1124 ClangASTContext::GetTypeForDecl (TagDecl *decl)
1125 {
1126     // No need to call the getASTContext() accessor (which can create the AST
1127     // if it isn't created yet, because we can't have created a decl in this
1128     // AST if our AST didn't already exist...
1129     ASTContext *ast = m_ast_ap.get();
1130     if (ast)
1131         return ClangASTType (ast, ast->getTagDeclType(decl).getAsOpaquePtr());
1132     return ClangASTType();
1133 }
1134
1135 ClangASTType
1136 ClangASTContext::GetTypeForDecl (ObjCInterfaceDecl *decl)
1137 {
1138     // No need to call the getASTContext() accessor (which can create the AST
1139     // if it isn't created yet, because we can't have created a decl in this
1140     // AST if our AST didn't already exist...
1141     ASTContext *ast = m_ast_ap.get();
1142     if (ast)
1143         return ClangASTType (ast, ast->getObjCInterfaceType(decl).getAsOpaquePtr());
1144     return ClangASTType();
1145 }
1146
1147 #pragma mark Structure, Unions, Classes
1148
1149 ClangASTType
1150 ClangASTContext::CreateRecordType (DeclContext *decl_ctx,
1151                                    AccessType access_type,
1152                                    const char *name,
1153                                    int kind,
1154                                    LanguageType language,
1155                                    ClangASTMetadata *metadata)
1156 {
1157     ASTContext *ast = getASTContext();
1158     assert (ast != nullptr);
1159
1160     if (decl_ctx == nullptr)
1161         decl_ctx = ast->getTranslationUnitDecl();
1162
1163
1164     if (language == eLanguageTypeObjC || language == eLanguageTypeObjC_plus_plus)
1165     {
1166         bool isForwardDecl = true;
1167         bool isInternal = false;
1168         return CreateObjCClass (name, decl_ctx, isForwardDecl, isInternal, metadata);
1169     }
1170
1171     // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1172     // we will need to update this code. I was told to currently always use
1173     // the CXXRecordDecl class since we often don't know from debug information
1174     // if something is struct or a class, so we default to always use the more
1175     // complete definition just in case.
1176
1177     bool is_anonymous = (!name) || (!name[0]);
1178
1179     CXXRecordDecl *decl = CXXRecordDecl::Create (*ast,
1180                                                  (TagDecl::TagKind)kind,
1181                                                  decl_ctx,
1182                                                  SourceLocation(),
1183                                                  SourceLocation(),
1184                                                  is_anonymous ? nullptr : &ast->Idents.get(name));
1185
1186     if (is_anonymous)
1187         decl->setAnonymousStructOrUnion(true);
1188
1189     if (decl)
1190     {
1191         if (metadata)
1192             SetMetadata(ast, decl, *metadata);
1193
1194         if (access_type != eAccessNone)
1195             decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type));
1196
1197         if (decl_ctx)
1198             decl_ctx->addDecl (decl);
1199
1200         return ClangASTType(ast, ast->getTagDeclType(decl).getAsOpaquePtr());
1201     }
1202     return ClangASTType();
1203 }
1204
1205 static TemplateParameterList *
1206 CreateTemplateParameterList (ASTContext *ast,
1207                              const ClangASTContext::TemplateParameterInfos &template_param_infos,
1208                              llvm::SmallVector<NamedDecl *, 8> &template_param_decls)
1209 {
1210     const bool parameter_pack = false;
1211     const bool is_typename = false;
1212     const unsigned depth = 0;
1213     const size_t num_template_params = template_param_infos.GetSize();
1214     for (size_t i=0; i<num_template_params; ++i)
1215     {
1216         const char *name = template_param_infos.names[i];
1217
1218         IdentifierInfo *identifier_info = nullptr;
1219         if (name && name[0])
1220             identifier_info = &ast->Idents.get(name);
1221         if (template_param_infos.args[i].getKind() == TemplateArgument::Integral)
1222         {
1223             template_param_decls.push_back (NonTypeTemplateParmDecl::Create (*ast,
1224                                                                              ast->getTranslationUnitDecl(), // Is this the right decl context?, SourceLocation StartLoc,
1225                                                                              SourceLocation(),
1226                                                                              SourceLocation(),
1227                                                                              depth,
1228                                                                              i,
1229                                                                              identifier_info,
1230                                                                              template_param_infos.args[i].getIntegralType(),
1231                                                                              parameter_pack,
1232                                                                              nullptr));
1233
1234         }
1235         else
1236         {
1237             template_param_decls.push_back (TemplateTypeParmDecl::Create (*ast,
1238                                                                           ast->getTranslationUnitDecl(), // Is this the right decl context?
1239                                                                           SourceLocation(),
1240                                                                           SourceLocation(),
1241                                                                           depth,
1242                                                                           i,
1243                                                                           identifier_info,
1244                                                                           is_typename,
1245                                                                           parameter_pack));
1246         }
1247     }
1248
1249     TemplateParameterList *template_param_list = TemplateParameterList::Create (*ast,
1250                                                                                 SourceLocation(),
1251                                                                                 SourceLocation(),
1252                                                                                 &template_param_decls.front(),
1253                                                                                 template_param_decls.size(),
1254                                                                                 SourceLocation());
1255     return template_param_list;
1256 }
1257
1258 clang::FunctionTemplateDecl *
1259 ClangASTContext::CreateFunctionTemplateDecl (clang::DeclContext *decl_ctx,
1260                                              clang::FunctionDecl *func_decl,
1261                                              const char *name,
1262                                              const TemplateParameterInfos &template_param_infos)
1263 {
1264 //    /// \brief Create a function template node.
1265     ASTContext *ast = getASTContext();
1266
1267     llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1268
1269     TemplateParameterList *template_param_list = CreateTemplateParameterList (ast,
1270                                                                               template_param_infos,
1271                                                                               template_param_decls);
1272     FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create (*ast,
1273                                                                          decl_ctx,
1274                                                                          func_decl->getLocation(),
1275                                                                          func_decl->getDeclName(),
1276                                                                          template_param_list,
1277                                                                          func_decl);
1278
1279     for (size_t i=0, template_param_decl_count = template_param_decls.size();
1280          i < template_param_decl_count;
1281          ++i)
1282     {
1283         // TODO: verify which decl context we should put template_param_decls into..
1284         template_param_decls[i]->setDeclContext (func_decl);
1285     }
1286
1287     return func_tmpl_decl;
1288 }
1289
1290 void
1291 ClangASTContext::CreateFunctionTemplateSpecializationInfo (FunctionDecl *func_decl,
1292                                                            clang::FunctionTemplateDecl *func_tmpl_decl,
1293                                                            const TemplateParameterInfos &infos)
1294 {
1295     TemplateArgumentList template_args (TemplateArgumentList::OnStack,
1296                                         infos.args.data(),
1297                                         infos.args.size());
1298
1299     func_decl->setFunctionTemplateSpecialization (func_tmpl_decl,
1300                                                   &template_args,
1301                                                   nullptr);
1302 }
1303
1304
1305 ClassTemplateDecl *
1306 ClangASTContext::CreateClassTemplateDecl (DeclContext *decl_ctx,
1307                                           lldb::AccessType access_type,
1308                                           const char *class_name,
1309                                           int kind,
1310                                           const TemplateParameterInfos &template_param_infos)
1311 {
1312     ASTContext *ast = getASTContext();
1313
1314     ClassTemplateDecl *class_template_decl = nullptr;
1315     if (decl_ctx == nullptr)
1316         decl_ctx = ast->getTranslationUnitDecl();
1317
1318     IdentifierInfo &identifier_info = ast->Idents.get(class_name);
1319     DeclarationName decl_name (&identifier_info);
1320
1321     clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1322
1323     for (NamedDecl *decl : result)
1324     {
1325         class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl);
1326         if (class_template_decl)
1327             return class_template_decl;
1328     }
1329
1330     llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1331
1332     TemplateParameterList *template_param_list = CreateTemplateParameterList (ast,
1333                                                                               template_param_infos,
1334                                                                               template_param_decls);
1335
1336     CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create (*ast,
1337                                                               (TagDecl::TagKind)kind,
1338                                                               decl_ctx,  // What decl context do we use here? TU? The actual decl context?
1339                                                               SourceLocation(),
1340                                                               SourceLocation(),
1341                                                               &identifier_info);
1342
1343     for (size_t i=0, template_param_decl_count = template_param_decls.size();
1344          i < template_param_decl_count;
1345          ++i)
1346     {
1347         template_param_decls[i]->setDeclContext (template_cxx_decl);
1348     }
1349
1350     // With templated classes, we say that a class is templated with
1351     // specializations, but that the bare class has no functions.
1352     //template_cxx_decl->startDefinition();
1353     //template_cxx_decl->completeDefinition();
1354
1355     class_template_decl = ClassTemplateDecl::Create (*ast,
1356                                                      decl_ctx,  // What decl context do we use here? TU? The actual decl context?
1357                                                      SourceLocation(),
1358                                                      decl_name,
1359                                                      template_param_list,
1360                                                      template_cxx_decl,
1361                                                      nullptr);
1362
1363     if (class_template_decl)
1364     {
1365         if (access_type != eAccessNone)
1366             class_template_decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type));
1367
1368         //if (TagDecl *ctx_tag_decl = dyn_cast<TagDecl>(decl_ctx))
1369         //    CompleteTagDeclarationDefinition(GetTypeForDecl(ctx_tag_decl));
1370
1371         decl_ctx->addDecl (class_template_decl);
1372
1373 #ifdef LLDB_CONFIGURATION_DEBUG
1374         VerifyDecl(class_template_decl);
1375 #endif
1376     }
1377
1378     return class_template_decl;
1379 }
1380
1381
1382 ClassTemplateSpecializationDecl *
1383 ClangASTContext::CreateClassTemplateSpecializationDecl (DeclContext *decl_ctx,
1384                                                         ClassTemplateDecl *class_template_decl,
1385                                                         int kind,
1386                                                         const TemplateParameterInfos &template_param_infos)
1387 {
1388     ASTContext *ast = getASTContext();
1389     ClassTemplateSpecializationDecl *class_template_specialization_decl = ClassTemplateSpecializationDecl::Create (*ast,
1390                                                                                                                    (TagDecl::TagKind)kind,
1391                                                                                                                    decl_ctx,
1392                                                                                                                    SourceLocation(),
1393                                                                                                                    SourceLocation(),
1394                                                                                                                    class_template_decl,
1395                                                                                                                    &template_param_infos.args.front(),
1396                                                                                                                    template_param_infos.args.size(),
1397                                                                                                                    nullptr);
1398
1399     class_template_specialization_decl->setSpecializationKind(TSK_ExplicitSpecialization);
1400
1401     return class_template_specialization_decl;
1402 }
1403
1404 ClangASTType
1405 ClangASTContext::CreateClassTemplateSpecializationType (ClassTemplateSpecializationDecl *class_template_specialization_decl)
1406 {
1407     if (class_template_specialization_decl)
1408     {
1409         ASTContext *ast = getASTContext();
1410         if (ast)
1411             return ClangASTType(ast, ast->getTagDeclType(class_template_specialization_decl).getAsOpaquePtr());
1412     }
1413     return ClangASTType();
1414 }
1415
1416 static inline bool
1417 check_op_param (uint32_t op_kind, bool unary, bool binary, uint32_t num_params)
1418 {
1419     // Special-case call since it can take any number of operands
1420     if(op_kind == OO_Call)
1421         return true;
1422
1423     // The parameter count doesn't include "this"
1424     if (num_params == 0)
1425         return unary;
1426     if (num_params == 1)
1427         return binary;
1428     else
1429     return false;
1430 }
1431
1432 bool
1433 ClangASTContext::CheckOverloadedOperatorKindParameterCount (uint32_t op_kind, uint32_t num_params)
1434 {
1435     switch (op_kind)
1436     {
1437     default:
1438         break;
1439     // C++ standard allows any number of arguments to new/delete
1440     case OO_New:
1441     case OO_Array_New:
1442     case OO_Delete:
1443     case OO_Array_Delete:
1444         return true;
1445     }
1446
1447 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) case OO_##Name: return check_op_param (op_kind, Unary, Binary, num_params);
1448     switch (op_kind)
1449     {
1450 #include "clang/Basic/OperatorKinds.def"
1451         default: break;
1452     }
1453     return false;
1454 }
1455
1456 clang::AccessSpecifier
1457 ClangASTContext::UnifyAccessSpecifiers (clang::AccessSpecifier lhs, clang::AccessSpecifier rhs)
1458 {
1459     clang::AccessSpecifier ret = lhs;
1460
1461     // Make the access equal to the stricter of the field and the nested field's access
1462     switch (ret)
1463     {
1464         case clang::AS_none:
1465             break;
1466         case clang::AS_private:
1467             break;
1468         case clang::AS_protected:
1469             if (rhs == AS_private)
1470                 ret = AS_private;
1471             break;
1472         case clang::AS_public:
1473             ret = rhs;
1474             break;
1475     }
1476
1477     return ret;
1478 }
1479
1480 bool
1481 ClangASTContext::FieldIsBitfield (FieldDecl* field, uint32_t& bitfield_bit_size)
1482 {
1483     return FieldIsBitfield(getASTContext(), field, bitfield_bit_size);
1484 }
1485
1486 bool
1487 ClangASTContext::FieldIsBitfield
1488 (
1489     ASTContext *ast,
1490     FieldDecl* field,
1491     uint32_t& bitfield_bit_size
1492 )
1493 {
1494     if (ast == nullptr || field == nullptr)
1495         return false;
1496
1497     if (field->isBitField())
1498     {
1499         Expr* bit_width_expr = field->getBitWidth();
1500         if (bit_width_expr)
1501         {
1502             llvm::APSInt bit_width_apsint;
1503             if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast))
1504             {
1505                 bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX);
1506                 return true;
1507             }
1508         }
1509     }
1510     return false;
1511 }
1512
1513 bool
1514 ClangASTContext::RecordHasFields (const RecordDecl *record_decl)
1515 {
1516     if (record_decl == nullptr)
1517         return false;
1518
1519     if (!record_decl->field_empty())
1520         return true;
1521
1522     // No fields, lets check this is a CXX record and check the base classes
1523     const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1524     if (cxx_record_decl)
1525     {
1526         CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1527         for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
1528              base_class != base_class_end;
1529              ++base_class)
1530         {
1531             const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
1532             if (RecordHasFields(base_class_decl))
1533                 return true;
1534         }
1535     }
1536     return false;
1537 }
1538
1539 #pragma mark Objective C Classes
1540
1541 ClangASTType
1542 ClangASTContext::CreateObjCClass
1543 (
1544     const char *name,
1545     DeclContext *decl_ctx,
1546     bool isForwardDecl,
1547     bool isInternal,
1548     ClangASTMetadata *metadata
1549 )
1550 {
1551     ASTContext *ast = getASTContext();
1552     assert (ast != nullptr);
1553     assert (name && name[0]);
1554     if (decl_ctx == nullptr)
1555         decl_ctx = ast->getTranslationUnitDecl();
1556
1557     ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create (*ast,
1558                                                          decl_ctx,
1559                                                          SourceLocation(),
1560                                                          &ast->Idents.get(name),
1561                                                          nullptr,
1562                                                          SourceLocation(),
1563                                                          /*isForwardDecl,*/
1564                                                          isInternal);
1565
1566     if (decl && metadata)
1567         SetMetadata(ast, decl, *metadata);
1568
1569     return ClangASTType (ast, ast->getObjCInterfaceType(decl));
1570 }
1571
1572 static inline bool
1573 BaseSpecifierIsEmpty (const CXXBaseSpecifier *b)
1574 {
1575     return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false;
1576 }
1577
1578 uint32_t
1579 ClangASTContext::GetNumBaseClasses (const CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes)
1580 {
1581     uint32_t num_bases = 0;
1582     if (cxx_record_decl)
1583     {
1584         if (omit_empty_base_classes)
1585         {
1586             CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1587             for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
1588                  base_class != base_class_end;
1589                  ++base_class)
1590             {
1591                 // Skip empty base classes
1592                 if (omit_empty_base_classes)
1593                 {
1594                     if (BaseSpecifierIsEmpty (base_class))
1595                         continue;
1596                 }
1597                 ++num_bases;
1598             }
1599         }
1600         else
1601             num_bases = cxx_record_decl->getNumBases();
1602     }
1603     return num_bases;
1604 }
1605
1606
1607 #pragma mark Namespace Declarations
1608
1609 NamespaceDecl *
1610 ClangASTContext::GetUniqueNamespaceDeclaration (const char *name, DeclContext *decl_ctx)
1611 {
1612     NamespaceDecl *namespace_decl = nullptr;
1613     ASTContext *ast = getASTContext();
1614     TranslationUnitDecl *translation_unit_decl = ast->getTranslationUnitDecl ();
1615     if (decl_ctx == nullptr)
1616         decl_ctx = translation_unit_decl;
1617
1618     if (name)
1619     {
1620         IdentifierInfo &identifier_info = ast->Idents.get(name);
1621         DeclarationName decl_name (&identifier_info);
1622         clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1623         for (NamedDecl *decl : result)
1624         {
1625             namespace_decl = dyn_cast<clang::NamespaceDecl>(decl);
1626             if (namespace_decl)
1627                 return namespace_decl;
1628         }
1629
1630         namespace_decl = NamespaceDecl::Create(*ast,
1631                                                decl_ctx,
1632                                                false,
1633                                                SourceLocation(),
1634                                                SourceLocation(),
1635                                                &identifier_info,
1636                                                nullptr);
1637
1638         decl_ctx->addDecl (namespace_decl);
1639     }
1640     else
1641     {
1642         if (decl_ctx == translation_unit_decl)
1643         {
1644             namespace_decl = translation_unit_decl->getAnonymousNamespace();
1645             if (namespace_decl)
1646                 return namespace_decl;
1647
1648             namespace_decl = NamespaceDecl::Create(*ast,
1649                                                    decl_ctx,
1650                                                    false,
1651                                                    SourceLocation(),
1652                                                    SourceLocation(),
1653                                                    nullptr,
1654                                                    nullptr);
1655             translation_unit_decl->setAnonymousNamespace (namespace_decl);
1656             translation_unit_decl->addDecl (namespace_decl);
1657             assert (namespace_decl == translation_unit_decl->getAnonymousNamespace());
1658         }
1659         else
1660         {
1661             NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx);
1662             if (parent_namespace_decl)
1663             {
1664                 namespace_decl = parent_namespace_decl->getAnonymousNamespace();
1665                 if (namespace_decl)
1666                     return namespace_decl;
1667                 namespace_decl = NamespaceDecl::Create(*ast,
1668                                                        decl_ctx,
1669                                                        false,
1670                                                        SourceLocation(),
1671                                                        SourceLocation(),
1672                                                        nullptr,
1673                                                        nullptr);
1674                 parent_namespace_decl->setAnonymousNamespace (namespace_decl);
1675                 parent_namespace_decl->addDecl (namespace_decl);
1676                 assert (namespace_decl == parent_namespace_decl->getAnonymousNamespace());
1677             }
1678             else
1679             {
1680                 // BAD!!!
1681             }
1682         }
1683
1684
1685         if (namespace_decl)
1686         {
1687             // If we make it here, we are creating the anonymous namespace decl
1688             // for the first time, so we need to do the using directive magic
1689             // like SEMA does
1690             UsingDirectiveDecl* using_directive_decl = UsingDirectiveDecl::Create (*ast,
1691                                                                                    decl_ctx,
1692                                                                                    SourceLocation(),
1693                                                                                    SourceLocation(),
1694                                                                                    NestedNameSpecifierLoc(),
1695                                                                                    SourceLocation(),
1696                                                                                    namespace_decl,
1697                                                                                    decl_ctx);
1698             using_directive_decl->setImplicit();
1699             decl_ctx->addDecl(using_directive_decl);
1700         }
1701     }
1702 #ifdef LLDB_CONFIGURATION_DEBUG
1703     VerifyDecl(namespace_decl);
1704 #endif
1705     return namespace_decl;
1706 }
1707
1708
1709 #pragma mark Function Types
1710
1711 FunctionDecl *
1712 ClangASTContext::CreateFunctionDeclaration (DeclContext *decl_ctx,
1713                                             const char *name,
1714                                             const ClangASTType &function_clang_type,
1715                                             int storage,
1716                                             bool is_inline)
1717 {
1718     FunctionDecl *func_decl = nullptr;
1719     ASTContext *ast = getASTContext();
1720     if (decl_ctx == nullptr)
1721         decl_ctx = ast->getTranslationUnitDecl();
1722
1723
1724     const bool hasWrittenPrototype = true;
1725     const bool isConstexprSpecified = false;
1726
1727     if (name && name[0])
1728     {
1729         func_decl = FunctionDecl::Create (*ast,
1730                                           decl_ctx,
1731                                           SourceLocation(),
1732                                           SourceLocation(),
1733                                           DeclarationName (&ast->Idents.get(name)),
1734                                           function_clang_type.GetQualType(),
1735                                           nullptr,
1736                                           (FunctionDecl::StorageClass)storage,
1737                                           is_inline,
1738                                           hasWrittenPrototype,
1739                                           isConstexprSpecified);
1740     }
1741     else
1742     {
1743         func_decl = FunctionDecl::Create (*ast,
1744                                           decl_ctx,
1745                                           SourceLocation(),
1746                                           SourceLocation(),
1747                                           DeclarationName (),
1748                                           function_clang_type.GetQualType(),
1749                                           nullptr,
1750                                           (FunctionDecl::StorageClass)storage,
1751                                           is_inline,
1752                                           hasWrittenPrototype,
1753                                           isConstexprSpecified);
1754     }
1755     if (func_decl)
1756         decl_ctx->addDecl (func_decl);
1757
1758 #ifdef LLDB_CONFIGURATION_DEBUG
1759     VerifyDecl(func_decl);
1760 #endif
1761
1762     return func_decl;
1763 }
1764
1765 ClangASTType
1766 ClangASTContext::CreateFunctionType (ASTContext *ast,
1767                                      const ClangASTType& result_type,
1768                                      const ClangASTType *args,
1769                                      unsigned num_args,
1770                                      bool is_variadic,
1771                                      unsigned type_quals)
1772 {
1773     assert (ast != nullptr);
1774     std::vector<QualType> qual_type_args;
1775     for (unsigned i=0; i<num_args; ++i)
1776         qual_type_args.push_back (args[i].GetQualType());
1777
1778     // TODO: Detect calling convention in DWARF?
1779     FunctionProtoType::ExtProtoInfo proto_info;
1780     proto_info.Variadic = is_variadic;
1781     proto_info.ExceptionSpecType = EST_None;
1782     proto_info.TypeQuals = type_quals;
1783     proto_info.RefQualifier = RQ_None;
1784     proto_info.NumExceptions = 0;
1785     proto_info.Exceptions = nullptr;
1786
1787     return ClangASTType (ast, ast->getFunctionType (result_type.GetQualType(),
1788                                                     qual_type_args,
1789                                                     proto_info).getAsOpaquePtr());
1790 }
1791
1792 ParmVarDecl *
1793 ClangASTContext::CreateParameterDeclaration (const char *name, const ClangASTType &param_type, int storage)
1794 {
1795     ASTContext *ast = getASTContext();
1796     assert (ast != nullptr);
1797     return ParmVarDecl::Create(*ast,
1798                                 ast->getTranslationUnitDecl(),
1799                                 SourceLocation(),
1800                                 SourceLocation(),
1801                                 name && name[0] ? &ast->Idents.get(name) : nullptr,
1802                                 param_type.GetQualType(),
1803                                 nullptr,
1804                                 (VarDecl::StorageClass)storage,
1805                                 nullptr);
1806 }
1807
1808 void
1809 ClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params)
1810 {
1811     if (function_decl)
1812         function_decl->setParams (ArrayRef<ParmVarDecl*>(params, num_params));
1813 }
1814
1815
1816 #pragma mark Array Types
1817
1818 ClangASTType
1819 ClangASTContext::CreateArrayType (const ClangASTType &element_type,
1820                                   size_t element_count,
1821                                   bool is_vector)
1822 {
1823     if (element_type.IsValid())
1824     {
1825         ASTContext *ast = getASTContext();
1826         assert (ast != nullptr);
1827
1828         if (is_vector)
1829         {
1830             return ClangASTType (ast, ast->getExtVectorType(element_type.GetQualType(), element_count).getAsOpaquePtr());
1831         }
1832         else
1833         {
1834
1835             llvm::APInt ap_element_count (64, element_count);
1836             if (element_count == 0)
1837             {
1838                 return ClangASTType (ast, ast->getIncompleteArrayType (element_type.GetQualType(),
1839                                                                        ArrayType::Normal,
1840                                                                        0).getAsOpaquePtr());
1841             }
1842             else
1843             {
1844                 return ClangASTType (ast, ast->getConstantArrayType (element_type.GetQualType(),
1845                                                                      ap_element_count,
1846                                                                      ArrayType::Normal,
1847                                                                      0).getAsOpaquePtr());
1848             }
1849         }
1850     }
1851     return ClangASTType();
1852 }
1853
1854
1855
1856 #pragma mark Enumeration Types
1857
1858 ClangASTType
1859 ClangASTContext::CreateEnumerationType
1860 (
1861     const char *name,
1862     DeclContext *decl_ctx,
1863     const Declaration &decl,
1864     const ClangASTType &integer_clang_type
1865 )
1866 {
1867     // TODO: Do something intelligent with the Declaration object passed in
1868     // like maybe filling in the SourceLocation with it...
1869     ASTContext *ast = getASTContext();
1870
1871     // TODO: ask about these...
1872 //    const bool IsScoped = false;
1873 //    const bool IsFixed = false;
1874
1875     EnumDecl *enum_decl = EnumDecl::Create (*ast,
1876                                             decl_ctx,
1877                                             SourceLocation(),
1878                                             SourceLocation(),
1879                                             name && name[0] ? &ast->Idents.get(name) : nullptr,
1880                                             nullptr,
1881                                             false,  // IsScoped
1882                                             false,  // IsScopedUsingClassTag
1883                                             false); // IsFixed
1884
1885
1886     if (enum_decl)
1887     {
1888         // TODO: check if we should be setting the promotion type too?
1889         enum_decl->setIntegerType(integer_clang_type.GetQualType());
1890
1891         enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
1892
1893         return ClangASTType (ast, ast->getTagDeclType(enum_decl).getAsOpaquePtr());
1894     }
1895     return ClangASTType();
1896 }
1897
1898 // Disable this for now since I can't seem to get a nicely formatted float
1899 // out of the APFloat class without just getting the float, double or quad
1900 // and then using a formatted print on it which defeats the purpose. We ideally
1901 // would like to get perfect string values for any kind of float semantics
1902 // so we can support remote targets. The code below also requires a patch to
1903 // llvm::APInt.
1904 //bool
1905 //ClangASTContext::ConvertFloatValueToString (ASTContext *ast, clang_type_t clang_type, const uint8_t* bytes, size_t byte_size, int apint_byte_order, std::string &float_str)
1906 //{
1907 //  uint32_t count = 0;
1908 //  bool is_complex = false;
1909 //  if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
1910 //  {
1911 //      unsigned num_bytes_per_float = byte_size / count;
1912 //      unsigned num_bits_per_float = num_bytes_per_float * 8;
1913 //
1914 //      float_str.clear();
1915 //      uint32_t i;
1916 //      for (i=0; i<count; i++)
1917 //      {
1918 //          APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, (APInt::ByteOrder)apint_byte_order);
1919 //          bool is_ieee = false;
1920 //          APFloat ap_float(ap_int, is_ieee);
1921 //          char s[1024];
1922 //          unsigned int hex_digits = 0;
1923 //          bool upper_case = false;
1924 //
1925 //          if (ap_float.convertToHexString(s, hex_digits, upper_case, APFloat::rmNearestTiesToEven) > 0)
1926 //          {
1927 //              if (i > 0)
1928 //                  float_str.append(", ");
1929 //              float_str.append(s);
1930 //              if (i == 1 && is_complex)
1931 //                  float_str.append(1, 'i');
1932 //          }
1933 //      }
1934 //      return !float_str.empty();
1935 //  }
1936 //  return false;
1937 //}
1938
1939 ClangASTType
1940 ClangASTContext::GetIntTypeFromBitSize (clang::ASTContext *ast,
1941                                         size_t bit_size, bool is_signed)
1942 {
1943     if (ast)
1944     {
1945         if (is_signed)
1946         {
1947             if (bit_size == ast->getTypeSize(ast->SignedCharTy))
1948                 return ClangASTType(ast, ast->SignedCharTy.getAsOpaquePtr());
1949
1950             if (bit_size == ast->getTypeSize(ast->ShortTy))
1951                 return ClangASTType(ast, ast->ShortTy.getAsOpaquePtr());
1952
1953             if (bit_size == ast->getTypeSize(ast->IntTy))
1954                 return ClangASTType(ast, ast->IntTy.getAsOpaquePtr());
1955
1956             if (bit_size == ast->getTypeSize(ast->LongTy))
1957                 return ClangASTType(ast, ast->LongTy.getAsOpaquePtr());
1958
1959             if (bit_size == ast->getTypeSize(ast->LongLongTy))
1960                 return ClangASTType(ast, ast->LongLongTy.getAsOpaquePtr());
1961
1962             if (bit_size == ast->getTypeSize(ast->Int128Ty))
1963                 return ClangASTType(ast, ast->Int128Ty.getAsOpaquePtr());
1964         }
1965         else
1966         {
1967             if (bit_size == ast->getTypeSize(ast->UnsignedCharTy))
1968                 return ClangASTType(ast, ast->UnsignedCharTy.getAsOpaquePtr());
1969
1970             if (bit_size == ast->getTypeSize(ast->UnsignedShortTy))
1971                 return ClangASTType(ast, ast->UnsignedShortTy.getAsOpaquePtr());
1972
1973             if (bit_size == ast->getTypeSize(ast->UnsignedIntTy))
1974                 return ClangASTType(ast, ast->UnsignedIntTy.getAsOpaquePtr());
1975
1976             if (bit_size == ast->getTypeSize(ast->UnsignedLongTy))
1977                 return ClangASTType(ast, ast->UnsignedLongTy.getAsOpaquePtr());
1978
1979             if (bit_size == ast->getTypeSize(ast->UnsignedLongLongTy))
1980                 return ClangASTType(ast, ast->UnsignedLongLongTy.getAsOpaquePtr());
1981
1982             if (bit_size == ast->getTypeSize(ast->UnsignedInt128Ty))
1983                 return ClangASTType(ast, ast->UnsignedInt128Ty.getAsOpaquePtr());
1984         }
1985     }
1986     return ClangASTType();
1987 }
1988
1989 ClangASTType
1990 ClangASTContext::GetPointerSizedIntType (clang::ASTContext *ast, bool is_signed)
1991 {
1992     if (ast)
1993         return GetIntTypeFromBitSize(ast, ast->getTypeSize(ast->VoidPtrTy), is_signed);
1994     return ClangASTType();
1995 }
1996
1997 ClangASTType
1998 ClangASTContext::GetFloatTypeFromBitSize (clang::ASTContext *ast,
1999                                           size_t bit_size)
2000 {
2001     if (ast)
2002     {
2003         if (bit_size == ast->getTypeSize(ast->FloatTy))
2004             return ClangASTType(ast, ast->FloatTy.getAsOpaquePtr());
2005         else if (bit_size == ast->getTypeSize(ast->DoubleTy))
2006             return ClangASTType(ast, ast->DoubleTy.getAsOpaquePtr());
2007         else if (bit_size == ast->getTypeSize(ast->LongDoubleTy))
2008             return ClangASTType(ast, ast->LongDoubleTy.getAsOpaquePtr());
2009         else if (bit_size == ast->getTypeSize(ast->HalfTy))
2010             return ClangASTType(ast, ast->HalfTy.getAsOpaquePtr());
2011     }
2012     return ClangASTType();
2013 }
2014
2015 bool
2016 ClangASTContext::GetCompleteDecl (clang::ASTContext *ast,
2017                                   clang::Decl *decl)
2018 {
2019     if (!decl)
2020         return false;
2021
2022     ExternalASTSource *ast_source = ast->getExternalSource();
2023
2024     if (!ast_source)
2025         return false;
2026
2027     if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
2028     {
2029         if (tag_decl->isCompleteDefinition())
2030             return true;
2031
2032         if (!tag_decl->hasExternalLexicalStorage())
2033             return false;
2034
2035         ast_source->CompleteType(tag_decl);
2036
2037         return !tag_decl->getTypeForDecl()->isIncompleteType();
2038     }
2039     else if (clang::ObjCInterfaceDecl *objc_interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
2040     {
2041         if (objc_interface_decl->getDefinition())
2042             return true;
2043
2044         if (!objc_interface_decl->hasExternalLexicalStorage())
2045             return false;
2046
2047         ast_source->CompleteType(objc_interface_decl);
2048
2049         return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
2050     }
2051     else
2052     {
2053         return false;
2054     }
2055 }
2056
2057 void
2058 ClangASTContext::SetMetadataAsUserID (const void *object,
2059                                       user_id_t user_id)
2060 {
2061     ClangASTMetadata meta_data;
2062     meta_data.SetUserID (user_id);
2063     SetMetadata (object, meta_data);
2064 }
2065
2066 void
2067 ClangASTContext::SetMetadata (clang::ASTContext *ast,
2068                               const void *object,
2069                               ClangASTMetadata &metadata)
2070 {
2071     ClangExternalASTSourceCommon *external_source =
2072         static_cast<ClangExternalASTSourceCommon*>(ast->getExternalSource());
2073
2074     if (external_source)
2075         external_source->SetMetadata(object, metadata);
2076 }
2077
2078 ClangASTMetadata *
2079 ClangASTContext::GetMetadata (clang::ASTContext *ast,
2080                               const void *object)
2081 {
2082     ClangExternalASTSourceCommon *external_source =
2083         static_cast<ClangExternalASTSourceCommon*>(ast->getExternalSource());
2084
2085     if (external_source && external_source->HasMetadata(object))
2086         return external_source->GetMetadata(object);
2087     else
2088         return nullptr;
2089 }
2090
2091 clang::DeclContext *
2092 ClangASTContext::GetAsDeclContext (clang::CXXMethodDecl *cxx_method_decl)
2093 {
2094     return llvm::dyn_cast<clang::DeclContext>(cxx_method_decl);
2095 }
2096
2097 clang::DeclContext *
2098 ClangASTContext::GetAsDeclContext (clang::ObjCMethodDecl *objc_method_decl)
2099 {
2100     return llvm::dyn_cast<clang::DeclContext>(objc_method_decl);
2101 }
2102
2103
2104 bool
2105 ClangASTContext::GetClassMethodInfoForDeclContext (clang::DeclContext *decl_ctx,
2106                                                    lldb::LanguageType &language,
2107                                                    bool &is_instance_method,
2108                                                    ConstString &language_object_name)
2109 {
2110     language_object_name.Clear();
2111     language = eLanguageTypeUnknown;
2112     is_instance_method = false;
2113
2114     if (decl_ctx)
2115     {
2116         if (clang::CXXMethodDecl *method_decl = llvm::dyn_cast<clang::CXXMethodDecl>(decl_ctx))
2117         {
2118             if (method_decl->isStatic())
2119             {
2120                 is_instance_method = false;
2121             }
2122             else
2123             {
2124                 language_object_name.SetCString("this");
2125                 is_instance_method = true;
2126             }
2127             language = eLanguageTypeC_plus_plus;
2128             return true;
2129         }
2130         else if (clang::ObjCMethodDecl *method_decl = llvm::dyn_cast<clang::ObjCMethodDecl>(decl_ctx))
2131         {
2132             // Both static and instance methods have a "self" object in objective C
2133             language_object_name.SetCString("self");
2134             if (method_decl->isInstanceMethod())
2135             {
2136                 is_instance_method = true;
2137             }
2138             else
2139             {
2140                 is_instance_method = false;
2141             }
2142             language = eLanguageTypeObjC;
2143             return true;
2144         }
2145         else if (clang::FunctionDecl *function_decl = llvm::dyn_cast<clang::FunctionDecl>(decl_ctx))
2146         {
2147             ClangASTMetadata *metadata = GetMetadata (&decl_ctx->getParentASTContext(), function_decl);
2148             if (metadata && metadata->HasObjectPtr())
2149             {
2150                 language_object_name.SetCString (metadata->GetObjectPtrName());
2151                 language = eLanguageTypeObjC;
2152                 is_instance_method = true;
2153             }
2154             return true;
2155         }
2156     }
2157     return false;
2158 }
2159