1254721Semaste//===-- ClangASTContext.cpp -------------------------------------*- C++ -*-===// 2254721Semaste// 3254721Semaste// The LLVM Compiler Infrastructure 4254721Semaste// 5254721Semaste// This file is distributed under the University of Illinois Open Source 6254721Semaste// License. See LICENSE.TXT for details. 7254721Semaste// 8254721Semaste//===----------------------------------------------------------------------===// 9254721Semaste 10254721Semaste#include "lldb/Symbol/ClangASTContext.h" 11254721Semaste 12254721Semaste// C Includes 13254721Semaste// C++ Includes 14254721Semaste#include <string> 15254721Semaste 16254721Semaste// Other libraries and framework includes 17254721Semaste 18254721Semaste// Clang headers like to use NDEBUG inside of them to enable/disable debug 19254721Semaste// releated features using "#ifndef NDEBUG" preprocessor blocks to do one thing 20254721Semaste// or another. This is bad because it means that if clang was built in release 21254721Semaste// mode, it assumes that you are building in release mode which is not always 22254721Semaste// the case. You can end up with functions that are defined as empty in header 23254721Semaste// files when NDEBUG is not defined, and this can cause link errors with the 24254721Semaste// clang .a files that you have since you might be missing functions in the .a 25254721Semaste// file. So we have to define NDEBUG when including clang headers to avoid any 26254721Semaste// mismatches. This is covered by rdar://problem/8691220 27254721Semaste 28254721Semaste#if !defined(NDEBUG) && !defined(LLVM_NDEBUG_OFF) 29254721Semaste#define LLDB_DEFINED_NDEBUG_FOR_CLANG 30254721Semaste#define NDEBUG 31254721Semaste// Need to include assert.h so it is as clang would expect it to be (disabled) 32254721Semaste#include <assert.h> 33254721Semaste#endif 34254721Semaste 35254721Semaste#include "clang/AST/ASTContext.h" 36254721Semaste#include "clang/AST/ASTImporter.h" 37254721Semaste#include "clang/AST/Attr.h" 38254721Semaste#include "clang/AST/CXXInheritance.h" 39254721Semaste#include "clang/AST/DeclObjC.h" 40254721Semaste#include "clang/AST/DeclTemplate.h" 41254721Semaste#include "clang/AST/RecordLayout.h" 42254721Semaste#include "clang/AST/Type.h" 43254721Semaste#include "clang/Basic/Builtins.h" 44254721Semaste#include "clang/Basic/Diagnostic.h" 45254721Semaste#include "clang/Basic/FileManager.h" 46254721Semaste#include "clang/Basic/FileSystemOptions.h" 47254721Semaste#include "clang/Basic/SourceManager.h" 48254721Semaste#include "clang/Basic/TargetInfo.h" 49254721Semaste#include "clang/Basic/TargetOptions.h" 50254721Semaste#include "clang/Frontend/FrontendOptions.h" 51254721Semaste#include "clang/Frontend/LangStandard.h" 52254721Semaste 53254721Semaste#ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG 54254721Semaste#undef NDEBUG 55254721Semaste#undef LLDB_DEFINED_NDEBUG_FOR_CLANG 56254721Semaste// Need to re-include assert.h so it is as _we_ would expect it to be (enabled) 57254721Semaste#include <assert.h> 58254721Semaste#endif 59254721Semaste 60254721Semaste#include "lldb/Core/ArchSpec.h" 61254721Semaste#include "lldb/Core/dwarf.h" 62254721Semaste#include "lldb/Core/Flags.h" 63254721Semaste#include "lldb/Core/Log.h" 64254721Semaste#include "lldb/Core/RegularExpression.h" 65254721Semaste#include "lldb/Core/UniqueCStringMap.h" 66254721Semaste#include "lldb/Expression/ASTDumper.h" 67254721Semaste#include "lldb/Symbol/ClangExternalASTSourceCommon.h" 68254721Semaste#include "lldb/Symbol/VerifyDecl.h" 69254721Semaste#include "lldb/Target/ExecutionContext.h" 70254721Semaste#include "lldb/Target/Process.h" 71254721Semaste#include "lldb/Target/ObjCLanguageRuntime.h" 72254721Semaste 73254721Semaste#include <stdio.h> 74254721Semaste 75254721Semaste#include <mutex> 76254721Semaste 77254721Semasteusing namespace lldb; 78254721Semasteusing namespace lldb_private; 79254721Semasteusing namespace llvm; 80254721Semasteusing namespace clang; 81254721Semaste 82254721Semasteclang::AccessSpecifier 83254721SemasteClangASTContext::ConvertAccessTypeToAccessSpecifier (AccessType access) 84254721Semaste{ 85254721Semaste switch (access) 86254721Semaste { 87254721Semaste default: break; 88254721Semaste case eAccessNone: return AS_none; 89254721Semaste case eAccessPublic: return AS_public; 90254721Semaste case eAccessPrivate: return AS_private; 91254721Semaste case eAccessProtected: return AS_protected; 92254721Semaste } 93254721Semaste return AS_none; 94254721Semaste} 95254721Semaste 96254721Semaste 97254721Semastestatic void 98254721SemasteParseLangArgs 99254721Semaste( 100254721Semaste LangOptions &Opts, 101254721Semaste InputKind IK 102254721Semaste) 103254721Semaste{ 104254721Semaste // FIXME: Cleanup per-file based stuff. 105254721Semaste 106254721Semaste // Set some properties which depend soley on the input kind; it would be nice 107254721Semaste // to move these to the language standard, and have the driver resolve the 108254721Semaste // input kind + language standard. 109254721Semaste if (IK == IK_Asm) { 110254721Semaste Opts.AsmPreprocessor = 1; 111254721Semaste } else if (IK == IK_ObjC || 112254721Semaste IK == IK_ObjCXX || 113254721Semaste IK == IK_PreprocessedObjC || 114254721Semaste IK == IK_PreprocessedObjCXX) { 115254721Semaste Opts.ObjC1 = Opts.ObjC2 = 1; 116254721Semaste } 117254721Semaste 118254721Semaste LangStandard::Kind LangStd = LangStandard::lang_unspecified; 119254721Semaste 120254721Semaste if (LangStd == LangStandard::lang_unspecified) { 121254721Semaste // Based on the base language, pick one. 122254721Semaste switch (IK) { 123254721Semaste case IK_None: 124254721Semaste case IK_AST: 125254721Semaste case IK_LLVM_IR: 126254721Semaste assert (!"Invalid input kind!"); 127254721Semaste case IK_OpenCL: 128254721Semaste LangStd = LangStandard::lang_opencl; 129254721Semaste break; 130254721Semaste case IK_CUDA: 131254721Semaste LangStd = LangStandard::lang_cuda; 132254721Semaste break; 133254721Semaste case IK_Asm: 134254721Semaste case IK_C: 135254721Semaste case IK_PreprocessedC: 136254721Semaste case IK_ObjC: 137254721Semaste case IK_PreprocessedObjC: 138254721Semaste LangStd = LangStandard::lang_gnu99; 139254721Semaste break; 140254721Semaste case IK_CXX: 141254721Semaste case IK_PreprocessedCXX: 142254721Semaste case IK_ObjCXX: 143254721Semaste case IK_PreprocessedObjCXX: 144254721Semaste LangStd = LangStandard::lang_gnucxx98; 145254721Semaste break; 146254721Semaste } 147254721Semaste } 148254721Semaste 149254721Semaste const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd); 150254721Semaste Opts.LineComment = Std.hasLineComments(); 151254721Semaste Opts.C99 = Std.isC99(); 152254721Semaste Opts.CPlusPlus = Std.isCPlusPlus(); 153254721Semaste Opts.CPlusPlus11 = Std.isCPlusPlus11(); 154254721Semaste Opts.Digraphs = Std.hasDigraphs(); 155254721Semaste Opts.GNUMode = Std.isGNUMode(); 156254721Semaste Opts.GNUInline = !Std.isC99(); 157254721Semaste Opts.HexFloats = Std.hasHexFloats(); 158254721Semaste Opts.ImplicitInt = Std.hasImplicitInt(); 159254721Semaste 160254721Semaste Opts.WChar = true; 161254721Semaste 162254721Semaste // OpenCL has some additional defaults. 163254721Semaste if (LangStd == LangStandard::lang_opencl) { 164254721Semaste Opts.OpenCL = 1; 165254721Semaste Opts.AltiVec = 1; 166254721Semaste Opts.CXXOperatorNames = 1; 167254721Semaste Opts.LaxVectorConversions = 1; 168254721Semaste } 169254721Semaste 170254721Semaste // OpenCL and C++ both have bool, true, false keywords. 171254721Semaste Opts.Bool = Opts.OpenCL || Opts.CPlusPlus; 172254721Semaste 173254721Semaste// if (Opts.CPlusPlus) 174254721Semaste// Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names); 175254721Semaste// 176254721Semaste// if (Args.hasArg(OPT_fobjc_gc_only)) 177254721Semaste// Opts.setGCMode(LangOptions::GCOnly); 178254721Semaste// else if (Args.hasArg(OPT_fobjc_gc)) 179254721Semaste// Opts.setGCMode(LangOptions::HybridGC); 180254721Semaste// 181254721Semaste// if (Args.hasArg(OPT_print_ivar_layout)) 182254721Semaste// Opts.ObjCGCBitmapPrint = 1; 183254721Semaste// 184254721Semaste// if (Args.hasArg(OPT_faltivec)) 185254721Semaste// Opts.AltiVec = 1; 186254721Semaste// 187254721Semaste// if (Args.hasArg(OPT_pthread)) 188254721Semaste// Opts.POSIXThreads = 1; 189254721Semaste// 190254721Semaste// llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility, 191254721Semaste// "default"); 192254721Semaste// if (Vis == "default") 193254721Semaste Opts.setValueVisibilityMode(DefaultVisibility); 194254721Semaste// else if (Vis == "hidden") 195254721Semaste// Opts.setVisibilityMode(LangOptions::Hidden); 196254721Semaste// else if (Vis == "protected") 197254721Semaste// Opts.setVisibilityMode(LangOptions::Protected); 198254721Semaste// else 199254721Semaste// Diags.Report(diag::err_drv_invalid_value) 200254721Semaste// << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis; 201254721Semaste 202254721Semaste// Opts.OverflowChecking = Args.hasArg(OPT_ftrapv); 203254721Semaste 204254721Semaste // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs 205254721Semaste // is specified, or -std is set to a conforming mode. 206254721Semaste Opts.Trigraphs = !Opts.GNUMode; 207254721Semaste// if (Args.hasArg(OPT_trigraphs)) 208254721Semaste// Opts.Trigraphs = 1; 209254721Semaste// 210254721Semaste// Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers, 211254721Semaste// OPT_fno_dollars_in_identifiers, 212254721Semaste// !Opts.AsmPreprocessor); 213254721Semaste// Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings); 214254721Semaste// Opts.Microsoft = Args.hasArg(OPT_fms_extensions); 215254721Semaste// Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings); 216254721Semaste// if (Args.hasArg(OPT_fno_lax_vector_conversions)) 217254721Semaste// Opts.LaxVectorConversions = 0; 218254721Semaste// Opts.Exceptions = Args.hasArg(OPT_fexceptions); 219254721Semaste// Opts.RTTI = !Args.hasArg(OPT_fno_rtti); 220254721Semaste// Opts.Blocks = Args.hasArg(OPT_fblocks); 221254721Semaste// Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char); 222254721Semaste// Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar); 223254721Semaste// Opts.Freestanding = Args.hasArg(OPT_ffreestanding); 224254721Semaste// Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding; 225254721Semaste// Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new); 226254721Semaste// Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions); 227254721Semaste// Opts.AccessControl = Args.hasArg(OPT_faccess_control); 228254721Semaste// Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors); 229254721Semaste// Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno); 230254721Semaste// Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99, 231254721Semaste// Diags); 232254721Semaste// Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime); 233254721Semaste// Opts.ObjCConstantStringClass = getLastArgValue(Args, 234254721Semaste// OPT_fconstant_string_class); 235254721Semaste// Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi); 236254721Semaste// Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior); 237254721Semaste// Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls); 238254721Semaste// Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags); 239254721Semaste// Opts.Static = Args.hasArg(OPT_static_define); 240254721Semaste Opts.OptimizeSize = 0; 241254721Semaste 242254721Semaste // FIXME: Eliminate this dependency. 243254721Semaste// unsigned Opt = 244254721Semaste// Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags); 245254721Semaste// Opts.Optimize = Opt != 0; 246254721Semaste unsigned Opt = 0; 247254721Semaste 248254721Semaste // This is the __NO_INLINE__ define, which just depends on things like the 249254721Semaste // optimization level and -fno-inline, not actually whether the backend has 250254721Semaste // inlining enabled. 251254721Semaste // 252254721Semaste // FIXME: This is affected by other options (-fno-inline). 253254721Semaste Opts.NoInlineDefine = !Opt; 254254721Semaste 255254721Semaste// unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags); 256254721Semaste// switch (SSP) { 257254721Semaste// default: 258254721Semaste// Diags.Report(diag::err_drv_invalid_value) 259254721Semaste// << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP; 260254721Semaste// break; 261254721Semaste// case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break; 262254721Semaste// case 1: Opts.setStackProtectorMode(LangOptions::SSPOn); break; 263254721Semaste// case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break; 264254721Semaste// } 265254721Semaste} 266254721Semaste 267254721Semaste 268254721SemasteClangASTContext::ClangASTContext (const char *target_triple) : 269254721Semaste m_target_triple(), 270254721Semaste m_ast_ap(), 271254721Semaste m_language_options_ap(), 272254721Semaste m_source_manager_ap(), 273254721Semaste m_diagnostics_engine_ap(), 274254721Semaste m_target_options_rp(), 275254721Semaste m_target_info_ap(), 276254721Semaste m_identifier_table_ap(), 277254721Semaste m_selector_table_ap(), 278254721Semaste m_builtins_ap(), 279254721Semaste m_callback_tag_decl (NULL), 280254721Semaste m_callback_objc_decl (NULL), 281254721Semaste m_callback_baton (NULL), 282254721Semaste m_pointer_byte_size (0) 283254721Semaste 284254721Semaste{ 285254721Semaste if (target_triple && target_triple[0]) 286254721Semaste SetTargetTriple (target_triple); 287254721Semaste} 288254721Semaste 289254721Semaste//---------------------------------------------------------------------- 290254721Semaste// Destructor 291254721Semaste//---------------------------------------------------------------------- 292254721SemasteClangASTContext::~ClangASTContext() 293254721Semaste{ 294254721Semaste m_builtins_ap.reset(); 295254721Semaste m_selector_table_ap.reset(); 296254721Semaste m_identifier_table_ap.reset(); 297254721Semaste m_target_info_ap.reset(); 298254721Semaste m_target_options_rp.reset(); 299254721Semaste m_diagnostics_engine_ap.reset(); 300254721Semaste m_source_manager_ap.reset(); 301254721Semaste m_language_options_ap.reset(); 302254721Semaste m_ast_ap.reset(); 303254721Semaste} 304254721Semaste 305254721Semaste 306254721Semastevoid 307254721SemasteClangASTContext::Clear() 308254721Semaste{ 309254721Semaste m_ast_ap.reset(); 310254721Semaste m_language_options_ap.reset(); 311254721Semaste m_source_manager_ap.reset(); 312254721Semaste m_diagnostics_engine_ap.reset(); 313254721Semaste m_target_options_rp.reset(); 314254721Semaste m_target_info_ap.reset(); 315254721Semaste m_identifier_table_ap.reset(); 316254721Semaste m_selector_table_ap.reset(); 317254721Semaste m_builtins_ap.reset(); 318254721Semaste m_pointer_byte_size = 0; 319254721Semaste} 320254721Semaste 321254721Semasteconst char * 322254721SemasteClangASTContext::GetTargetTriple () 323254721Semaste{ 324254721Semaste return m_target_triple.c_str(); 325254721Semaste} 326254721Semaste 327254721Semastevoid 328254721SemasteClangASTContext::SetTargetTriple (const char *target_triple) 329254721Semaste{ 330254721Semaste Clear(); 331254721Semaste m_target_triple.assign(target_triple); 332254721Semaste} 333254721Semaste 334254721Semastevoid 335254721SemasteClangASTContext::SetArchitecture (const ArchSpec &arch) 336254721Semaste{ 337254721Semaste SetTargetTriple(arch.GetTriple().str().c_str()); 338254721Semaste} 339254721Semaste 340254721Semastebool 341254721SemasteClangASTContext::HasExternalSource () 342254721Semaste{ 343254721Semaste ASTContext *ast = getASTContext(); 344254721Semaste if (ast) 345254721Semaste return ast->getExternalSource () != NULL; 346254721Semaste return false; 347254721Semaste} 348254721Semaste 349254721Semastevoid 350254721SemasteClangASTContext::SetExternalSource (llvm::OwningPtr<ExternalASTSource> &ast_source_ap) 351254721Semaste{ 352254721Semaste ASTContext *ast = getASTContext(); 353254721Semaste if (ast) 354254721Semaste { 355254721Semaste ast->setExternalSource (ast_source_ap); 356254721Semaste ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true); 357254721Semaste //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true); 358254721Semaste } 359254721Semaste} 360254721Semaste 361254721Semastevoid 362254721SemasteClangASTContext::RemoveExternalSource () 363254721Semaste{ 364254721Semaste ASTContext *ast = getASTContext(); 365254721Semaste 366254721Semaste if (ast) 367254721Semaste { 368254721Semaste llvm::OwningPtr<ExternalASTSource> empty_ast_source_ap; 369254721Semaste ast->setExternalSource (empty_ast_source_ap); 370254721Semaste ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false); 371254721Semaste //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false); 372254721Semaste } 373254721Semaste} 374254721Semaste 375254721Semaste 376254721Semaste 377254721SemasteASTContext * 378254721SemasteClangASTContext::getASTContext() 379254721Semaste{ 380254721Semaste if (m_ast_ap.get() == NULL) 381254721Semaste { 382254721Semaste m_ast_ap.reset(new ASTContext (*getLanguageOptions(), 383254721Semaste *getSourceManager(), 384254721Semaste getTargetInfo(), 385254721Semaste *getIdentifierTable(), 386254721Semaste *getSelectorTable(), 387254721Semaste *getBuiltinContext(), 388254721Semaste 0)); 389254721Semaste 390254721Semaste if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton) 391254721Semaste { 392254721Semaste m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage(); 393254721Semaste //m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage(); 394254721Semaste } 395254721Semaste 396254721Semaste m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false); 397254721Semaste } 398254721Semaste return m_ast_ap.get(); 399254721Semaste} 400254721Semaste 401254721SemasteBuiltin::Context * 402254721SemasteClangASTContext::getBuiltinContext() 403254721Semaste{ 404254721Semaste if (m_builtins_ap.get() == NULL) 405254721Semaste m_builtins_ap.reset (new Builtin::Context()); 406254721Semaste return m_builtins_ap.get(); 407254721Semaste} 408254721Semaste 409254721SemasteIdentifierTable * 410254721SemasteClangASTContext::getIdentifierTable() 411254721Semaste{ 412254721Semaste if (m_identifier_table_ap.get() == NULL) 413254721Semaste m_identifier_table_ap.reset(new IdentifierTable (*ClangASTContext::getLanguageOptions(), NULL)); 414254721Semaste return m_identifier_table_ap.get(); 415254721Semaste} 416254721Semaste 417254721SemasteLangOptions * 418254721SemasteClangASTContext::getLanguageOptions() 419254721Semaste{ 420254721Semaste if (m_language_options_ap.get() == NULL) 421254721Semaste { 422254721Semaste m_language_options_ap.reset(new LangOptions()); 423254721Semaste ParseLangArgs(*m_language_options_ap, IK_ObjCXX); 424254721Semaste// InitializeLangOptions(*m_language_options_ap, IK_ObjCXX); 425254721Semaste } 426254721Semaste return m_language_options_ap.get(); 427254721Semaste} 428254721Semaste 429254721SemasteSelectorTable * 430254721SemasteClangASTContext::getSelectorTable() 431254721Semaste{ 432254721Semaste if (m_selector_table_ap.get() == NULL) 433254721Semaste m_selector_table_ap.reset (new SelectorTable()); 434254721Semaste return m_selector_table_ap.get(); 435254721Semaste} 436254721Semaste 437254721Semasteclang::FileManager * 438254721SemasteClangASTContext::getFileManager() 439254721Semaste{ 440254721Semaste if (m_file_manager_ap.get() == NULL) 441254721Semaste { 442254721Semaste clang::FileSystemOptions file_system_options; 443254721Semaste m_file_manager_ap.reset(new clang::FileManager(file_system_options)); 444254721Semaste } 445254721Semaste return m_file_manager_ap.get(); 446254721Semaste} 447254721Semaste 448254721Semasteclang::SourceManager * 449254721SemasteClangASTContext::getSourceManager() 450254721Semaste{ 451254721Semaste if (m_source_manager_ap.get() == NULL) 452254721Semaste m_source_manager_ap.reset(new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager())); 453254721Semaste return m_source_manager_ap.get(); 454254721Semaste} 455254721Semaste 456254721Semasteclang::DiagnosticsEngine * 457254721SemasteClangASTContext::getDiagnosticsEngine() 458254721Semaste{ 459254721Semaste if (m_diagnostics_engine_ap.get() == NULL) 460254721Semaste { 461254721Semaste llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs()); 462254721Semaste m_diagnostics_engine_ap.reset(new DiagnosticsEngine(diag_id_sp, new DiagnosticOptions())); 463254721Semaste } 464254721Semaste return m_diagnostics_engine_ap.get(); 465254721Semaste} 466254721Semaste 467254721Semasteclass NullDiagnosticConsumer : public DiagnosticConsumer 468254721Semaste{ 469254721Semastepublic: 470254721Semaste NullDiagnosticConsumer () 471254721Semaste { 472254721Semaste m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS); 473254721Semaste } 474254721Semaste 475254721Semaste void HandleDiagnostic (DiagnosticsEngine::Level DiagLevel, const Diagnostic &info) 476254721Semaste { 477254721Semaste if (m_log) 478254721Semaste { 479254721Semaste llvm::SmallVector<char, 32> diag_str(10); 480254721Semaste info.FormatDiagnostic(diag_str); 481254721Semaste diag_str.push_back('\0'); 482254721Semaste m_log->Printf("Compiler diagnostic: %s\n", diag_str.data()); 483254721Semaste } 484254721Semaste } 485254721Semaste 486254721Semaste DiagnosticConsumer *clone (DiagnosticsEngine &Diags) const 487254721Semaste { 488254721Semaste return new NullDiagnosticConsumer (); 489254721Semaste } 490254721Semasteprivate: 491254721Semaste Log * m_log; 492254721Semaste}; 493254721Semaste 494254721SemasteDiagnosticConsumer * 495254721SemasteClangASTContext::getDiagnosticConsumer() 496254721Semaste{ 497254721Semaste if (m_diagnostic_consumer_ap.get() == NULL) 498254721Semaste m_diagnostic_consumer_ap.reset(new NullDiagnosticConsumer); 499254721Semaste 500254721Semaste return m_diagnostic_consumer_ap.get(); 501254721Semaste} 502254721Semaste 503254721SemasteTargetOptions * 504254721SemasteClangASTContext::getTargetOptions() 505254721Semaste{ 506254721Semaste if (m_target_options_rp.getPtr() == NULL && !m_target_triple.empty()) 507254721Semaste { 508254721Semaste m_target_options_rp.reset (); 509254721Semaste m_target_options_rp = new TargetOptions(); 510254721Semaste if (m_target_options_rp.getPtr() != NULL) 511254721Semaste m_target_options_rp->Triple = m_target_triple; 512254721Semaste } 513254721Semaste return m_target_options_rp.getPtr(); 514254721Semaste} 515254721Semaste 516254721Semaste 517254721SemasteTargetInfo * 518254721SemasteClangASTContext::getTargetInfo() 519254721Semaste{ 520254721Semaste // target_triple should be something like "x86_64-apple-macosx" 521254721Semaste if (m_target_info_ap.get() == NULL && !m_target_triple.empty()) 522254721Semaste m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), getTargetOptions())); 523254721Semaste return m_target_info_ap.get(); 524254721Semaste} 525254721Semaste 526254721Semaste#pragma mark Basic Types 527254721Semaste 528254721Semastestatic inline bool 529254721SemasteQualTypeMatchesBitSize(const uint64_t bit_size, ASTContext *ast, QualType qual_type) 530254721Semaste{ 531254721Semaste uint64_t qual_type_bit_size = ast->getTypeSize(qual_type); 532254721Semaste if (qual_type_bit_size == bit_size) 533254721Semaste return true; 534254721Semaste return false; 535254721Semaste} 536254721SemasteClangASTType 537254721SemasteClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, uint32_t bit_size) 538254721Semaste{ 539254721Semaste return ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (getASTContext(), encoding, bit_size); 540254721Semaste} 541254721Semaste 542254721SemasteClangASTType 543254721SemasteClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast, Encoding encoding, uint32_t bit_size) 544254721Semaste{ 545254721Semaste if (!ast) 546254721Semaste return ClangASTType(); 547254721Semaste 548254721Semaste switch (encoding) 549254721Semaste { 550254721Semaste case eEncodingInvalid: 551254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy)) 552254721Semaste return ClangASTType (ast, ast->VoidPtrTy.getAsOpaquePtr()); 553254721Semaste break; 554254721Semaste 555254721Semaste case eEncodingUint: 556254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) 557254721Semaste return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr()); 558254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) 559254721Semaste return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr()); 560254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) 561254721Semaste return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr()); 562254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) 563254721Semaste return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr()); 564254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) 565254721Semaste return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr()); 566254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) 567254721Semaste return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr()); 568254721Semaste break; 569254721Semaste 570254721Semaste case eEncodingSint: 571254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) 572254721Semaste return ClangASTType (ast, ast->CharTy.getAsOpaquePtr()); 573254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) 574254721Semaste return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr()); 575254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) 576254721Semaste return ClangASTType (ast, ast->IntTy.getAsOpaquePtr()); 577254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) 578254721Semaste return ClangASTType (ast, ast->LongTy.getAsOpaquePtr()); 579254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) 580254721Semaste return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr()); 581254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) 582254721Semaste return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr()); 583254721Semaste break; 584254721Semaste 585254721Semaste case eEncodingIEEE754: 586254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy)) 587254721Semaste return ClangASTType (ast, ast->FloatTy.getAsOpaquePtr()); 588254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy)) 589254721Semaste return ClangASTType (ast, ast->DoubleTy.getAsOpaquePtr()); 590254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy)) 591254721Semaste return ClangASTType (ast, ast->LongDoubleTy.getAsOpaquePtr()); 592254721Semaste break; 593254721Semaste 594254721Semaste case eEncodingVector: 595254721Semaste // Sanity check that bit_size is a multiple of 8's. 596254721Semaste if (bit_size && !(bit_size & 0x7u)) 597254721Semaste return ClangASTType (ast, ast->getExtVectorType (ast->UnsignedCharTy, bit_size/8).getAsOpaquePtr()); 598254721Semaste break; 599254721Semaste } 600254721Semaste 601254721Semaste return ClangASTType(); 602254721Semaste} 603254721Semaste 604254721Semaste 605254721Semaste 606254721Semastelldb::BasicType 607254721SemasteClangASTContext::GetBasicTypeEnumeration (const ConstString &name) 608254721Semaste{ 609254721Semaste if (name) 610254721Semaste { 611254721Semaste typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap; 612254721Semaste static TypeNameToBasicTypeMap g_type_map; 613254721Semaste static std::once_flag g_once_flag; 614254721Semaste std::call_once(g_once_flag, [](){ 615254721Semaste // "void" 616254721Semaste g_type_map.Append(ConstString("void").GetCString(), eBasicTypeVoid); 617254721Semaste 618254721Semaste // "char" 619254721Semaste g_type_map.Append(ConstString("char").GetCString(), eBasicTypeChar); 620254721Semaste g_type_map.Append(ConstString("signed char").GetCString(), eBasicTypeSignedChar); 621254721Semaste g_type_map.Append(ConstString("unsigned char").GetCString(), eBasicTypeUnsignedChar); 622254721Semaste g_type_map.Append(ConstString("wchar_t").GetCString(), eBasicTypeWChar); 623254721Semaste g_type_map.Append(ConstString("signed wchar_t").GetCString(), eBasicTypeSignedWChar); 624254721Semaste g_type_map.Append(ConstString("unsigned wchar_t").GetCString(), eBasicTypeUnsignedWChar); 625254721Semaste // "short" 626254721Semaste g_type_map.Append(ConstString("short").GetCString(), eBasicTypeShort); 627254721Semaste g_type_map.Append(ConstString("short int").GetCString(), eBasicTypeShort); 628254721Semaste g_type_map.Append(ConstString("unsigned short").GetCString(), eBasicTypeUnsignedShort); 629254721Semaste g_type_map.Append(ConstString("unsigned short int").GetCString(), eBasicTypeUnsignedShort); 630254721Semaste 631254721Semaste // "int" 632254721Semaste g_type_map.Append(ConstString("int").GetCString(), eBasicTypeInt); 633254721Semaste g_type_map.Append(ConstString("signed int").GetCString(), eBasicTypeInt); 634254721Semaste g_type_map.Append(ConstString("unsigned int").GetCString(), eBasicTypeUnsignedInt); 635254721Semaste g_type_map.Append(ConstString("unsigned").GetCString(), eBasicTypeUnsignedInt); 636254721Semaste 637254721Semaste // "long" 638254721Semaste g_type_map.Append(ConstString("long").GetCString(), eBasicTypeLong); 639254721Semaste g_type_map.Append(ConstString("long int").GetCString(), eBasicTypeLong); 640254721Semaste g_type_map.Append(ConstString("unsigned long").GetCString(), eBasicTypeUnsignedLong); 641254721Semaste g_type_map.Append(ConstString("unsigned long int").GetCString(), eBasicTypeUnsignedLong); 642254721Semaste 643254721Semaste // "long long" 644254721Semaste g_type_map.Append(ConstString("long long").GetCString(), eBasicTypeLongLong); 645254721Semaste g_type_map.Append(ConstString("long long int").GetCString(), eBasicTypeLongLong); 646254721Semaste g_type_map.Append(ConstString("unsigned long long").GetCString(), eBasicTypeUnsignedLongLong); 647254721Semaste g_type_map.Append(ConstString("unsigned long long int").GetCString(), eBasicTypeUnsignedLongLong); 648254721Semaste 649254721Semaste // "int128" 650254721Semaste g_type_map.Append(ConstString("__int128_t").GetCString(), eBasicTypeInt128); 651254721Semaste g_type_map.Append(ConstString("__uint128_t").GetCString(), eBasicTypeUnsignedInt128); 652254721Semaste 653254721Semaste // Miscelaneous 654254721Semaste g_type_map.Append(ConstString("bool").GetCString(), eBasicTypeBool); 655254721Semaste g_type_map.Append(ConstString("float").GetCString(), eBasicTypeFloat); 656254721Semaste g_type_map.Append(ConstString("double").GetCString(), eBasicTypeDouble); 657254721Semaste g_type_map.Append(ConstString("long double").GetCString(), eBasicTypeLongDouble); 658254721Semaste g_type_map.Append(ConstString("id").GetCString(), eBasicTypeObjCID); 659254721Semaste g_type_map.Append(ConstString("SEL").GetCString(), eBasicTypeObjCSel); 660254721Semaste g_type_map.Append(ConstString("nullptr").GetCString(), eBasicTypeNullPtr); 661254721Semaste g_type_map.Sort(); 662254721Semaste }); 663254721Semaste 664254721Semaste return g_type_map.Find(name.GetCString(), eBasicTypeInvalid); 665254721Semaste } 666254721Semaste return eBasicTypeInvalid; 667254721Semaste} 668254721Semaste 669254721SemasteClangASTType 670254721SemasteClangASTContext::GetBasicType (ASTContext *ast, const ConstString &name) 671254721Semaste{ 672254721Semaste if (ast) 673254721Semaste { 674254721Semaste lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration (name); 675254721Semaste return ClangASTContext::GetBasicType (ast, basic_type); 676254721Semaste } 677254721Semaste return ClangASTType(); 678254721Semaste} 679254721Semaste 680254721Semasteuint32_t 681254721SemasteClangASTContext::GetPointerByteSize () 682254721Semaste{ 683254721Semaste if (m_pointer_byte_size == 0) 684254721Semaste m_pointer_byte_size = GetBasicType(lldb::eBasicTypeVoid).GetPointerType().GetByteSize(); 685254721Semaste return m_pointer_byte_size; 686254721Semaste} 687254721Semaste 688254721SemasteClangASTType 689254721SemasteClangASTContext::GetBasicType (lldb::BasicType basic_type) 690254721Semaste{ 691254721Semaste return GetBasicType (getASTContext(), basic_type); 692254721Semaste} 693254721Semaste 694254721SemasteClangASTType 695254721SemasteClangASTContext::GetBasicType (ASTContext *ast, lldb::BasicType basic_type) 696254721Semaste{ 697254721Semaste if (ast) 698254721Semaste { 699254721Semaste clang_type_t clang_type = NULL; 700254721Semaste 701254721Semaste switch (basic_type) 702254721Semaste { 703254721Semaste case eBasicTypeInvalid: 704254721Semaste case eBasicTypeOther: 705254721Semaste break; 706254721Semaste case eBasicTypeVoid: 707254721Semaste clang_type = ast->VoidTy.getAsOpaquePtr(); 708254721Semaste break; 709254721Semaste case eBasicTypeChar: 710254721Semaste clang_type = ast->CharTy.getAsOpaquePtr(); 711254721Semaste break; 712254721Semaste case eBasicTypeSignedChar: 713254721Semaste clang_type = ast->SignedCharTy.getAsOpaquePtr(); 714254721Semaste break; 715254721Semaste case eBasicTypeUnsignedChar: 716254721Semaste clang_type = ast->UnsignedCharTy.getAsOpaquePtr(); 717254721Semaste break; 718254721Semaste case eBasicTypeWChar: 719254721Semaste clang_type = ast->getWCharType().getAsOpaquePtr(); 720254721Semaste break; 721254721Semaste case eBasicTypeSignedWChar: 722254721Semaste clang_type = ast->getSignedWCharType().getAsOpaquePtr(); 723254721Semaste break; 724254721Semaste case eBasicTypeUnsignedWChar: 725254721Semaste clang_type = ast->getUnsignedWCharType().getAsOpaquePtr(); 726254721Semaste break; 727254721Semaste case eBasicTypeChar16: 728254721Semaste clang_type = ast->Char16Ty.getAsOpaquePtr(); 729254721Semaste break; 730254721Semaste case eBasicTypeChar32: 731254721Semaste clang_type = ast->Char32Ty.getAsOpaquePtr(); 732254721Semaste break; 733254721Semaste case eBasicTypeShort: 734254721Semaste clang_type = ast->ShortTy.getAsOpaquePtr(); 735254721Semaste break; 736254721Semaste case eBasicTypeUnsignedShort: 737254721Semaste clang_type = ast->UnsignedShortTy.getAsOpaquePtr(); 738254721Semaste break; 739254721Semaste case eBasicTypeInt: 740254721Semaste clang_type = ast->IntTy.getAsOpaquePtr(); 741254721Semaste break; 742254721Semaste case eBasicTypeUnsignedInt: 743254721Semaste clang_type = ast->UnsignedIntTy.getAsOpaquePtr(); 744254721Semaste break; 745254721Semaste case eBasicTypeLong: 746254721Semaste clang_type = ast->LongTy.getAsOpaquePtr(); 747254721Semaste break; 748254721Semaste case eBasicTypeUnsignedLong: 749254721Semaste clang_type = ast->UnsignedLongTy.getAsOpaquePtr(); 750254721Semaste break; 751254721Semaste case eBasicTypeLongLong: 752254721Semaste clang_type = ast->LongLongTy.getAsOpaquePtr(); 753254721Semaste break; 754254721Semaste case eBasicTypeUnsignedLongLong: 755254721Semaste clang_type = ast->UnsignedLongLongTy.getAsOpaquePtr(); 756254721Semaste break; 757254721Semaste case eBasicTypeInt128: 758254721Semaste clang_type = ast->Int128Ty.getAsOpaquePtr(); 759254721Semaste break; 760254721Semaste case eBasicTypeUnsignedInt128: 761254721Semaste clang_type = ast->UnsignedInt128Ty.getAsOpaquePtr(); 762254721Semaste break; 763254721Semaste case eBasicTypeBool: 764254721Semaste clang_type = ast->BoolTy.getAsOpaquePtr(); 765254721Semaste break; 766254721Semaste case eBasicTypeHalf: 767254721Semaste clang_type = ast->HalfTy.getAsOpaquePtr(); 768254721Semaste break; 769254721Semaste case eBasicTypeFloat: 770254721Semaste clang_type = ast->FloatTy.getAsOpaquePtr(); 771254721Semaste break; 772254721Semaste case eBasicTypeDouble: 773254721Semaste clang_type = ast->DoubleTy.getAsOpaquePtr(); 774254721Semaste break; 775254721Semaste case eBasicTypeLongDouble: 776254721Semaste clang_type = ast->LongDoubleTy.getAsOpaquePtr(); 777254721Semaste break; 778254721Semaste case eBasicTypeFloatComplex: 779254721Semaste clang_type = ast->FloatComplexTy.getAsOpaquePtr(); 780254721Semaste break; 781254721Semaste case eBasicTypeDoubleComplex: 782254721Semaste clang_type = ast->DoubleComplexTy.getAsOpaquePtr(); 783254721Semaste break; 784254721Semaste case eBasicTypeLongDoubleComplex: 785254721Semaste clang_type = ast->LongDoubleComplexTy.getAsOpaquePtr(); 786254721Semaste break; 787254721Semaste case eBasicTypeObjCID: 788254721Semaste clang_type = ast->getObjCIdType().getAsOpaquePtr(); 789254721Semaste break; 790254721Semaste case eBasicTypeObjCClass: 791254721Semaste clang_type = ast->getObjCClassType().getAsOpaquePtr(); 792254721Semaste break; 793254721Semaste case eBasicTypeObjCSel: 794254721Semaste clang_type = ast->getObjCSelType().getAsOpaquePtr(); 795254721Semaste break; 796254721Semaste case eBasicTypeNullPtr: 797254721Semaste clang_type = ast->NullPtrTy.getAsOpaquePtr(); 798254721Semaste break; 799254721Semaste } 800254721Semaste 801254721Semaste if (clang_type) 802254721Semaste return ClangASTType (ast, clang_type); 803254721Semaste } 804254721Semaste return ClangASTType(); 805254721Semaste} 806254721Semaste 807254721Semaste 808254721SemasteClangASTType 809254721SemasteClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size) 810254721Semaste{ 811254721Semaste ASTContext *ast = getASTContext(); 812254721Semaste 813254721Semaste#define streq(a,b) strcmp(a,b) == 0 814254721Semaste assert (ast != NULL); 815254721Semaste if (ast) 816254721Semaste { 817254721Semaste switch (dw_ate) 818254721Semaste { 819254721Semaste default: 820254721Semaste break; 821254721Semaste 822254721Semaste case DW_ATE_address: 823254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy)) 824254721Semaste return ClangASTType (ast, ast->VoidPtrTy.getAsOpaquePtr()); 825254721Semaste break; 826254721Semaste 827254721Semaste case DW_ATE_boolean: 828254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->BoolTy)) 829254721Semaste return ClangASTType (ast, ast->BoolTy.getAsOpaquePtr()); 830254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) 831254721Semaste return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr()); 832254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) 833254721Semaste return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr()); 834254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) 835254721Semaste return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr()); 836254721Semaste break; 837254721Semaste 838254721Semaste case DW_ATE_lo_user: 839254721Semaste // This has been seen to mean DW_AT_complex_integer 840254721Semaste if (type_name) 841254721Semaste { 842254721Semaste if (::strstr(type_name, "complex")) 843254721Semaste { 844254721Semaste ClangASTType complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2); 845254721Semaste return ClangASTType (ast, ast->getComplexType (complex_int_clang_type.GetQualType()).getAsOpaquePtr()); 846254721Semaste } 847254721Semaste } 848254721Semaste break; 849254721Semaste 850254721Semaste case DW_ATE_complex_float: 851254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy)) 852254721Semaste return ClangASTType (ast, ast->FloatComplexTy.getAsOpaquePtr()); 853254721Semaste else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy)) 854254721Semaste return ClangASTType (ast, ast->DoubleComplexTy.getAsOpaquePtr()); 855254721Semaste else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy)) 856254721Semaste return ClangASTType (ast, ast->LongDoubleComplexTy.getAsOpaquePtr()); 857254721Semaste else 858254721Semaste { 859254721Semaste ClangASTType complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2); 860254721Semaste return ClangASTType (ast, ast->getComplexType (complex_float_clang_type.GetQualType()).getAsOpaquePtr()); 861254721Semaste } 862254721Semaste break; 863254721Semaste 864254721Semaste case DW_ATE_float: 865254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy)) 866254721Semaste return ClangASTType (ast, ast->FloatTy.getAsOpaquePtr()); 867254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy)) 868254721Semaste return ClangASTType (ast, ast->DoubleTy.getAsOpaquePtr()); 869254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy)) 870254721Semaste return ClangASTType (ast, ast->LongDoubleTy.getAsOpaquePtr()); 871254721Semaste break; 872254721Semaste 873254721Semaste case DW_ATE_signed: 874254721Semaste if (type_name) 875254721Semaste { 876254721Semaste if (streq(type_name, "wchar_t") && 877254721Semaste QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy)) 878254721Semaste return ClangASTType (ast, ast->WCharTy.getAsOpaquePtr()); 879254721Semaste if (streq(type_name, "void") && 880254721Semaste QualTypeMatchesBitSize (bit_size, ast, ast->VoidTy)) 881254721Semaste return ClangASTType (ast, ast->VoidTy.getAsOpaquePtr()); 882254721Semaste if (strstr(type_name, "long long") && 883254721Semaste QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) 884254721Semaste return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr()); 885254721Semaste if (strstr(type_name, "long") && 886254721Semaste QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) 887254721Semaste return ClangASTType (ast, ast->LongTy.getAsOpaquePtr()); 888254721Semaste if (strstr(type_name, "short") && 889254721Semaste QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) 890254721Semaste return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr()); 891254721Semaste if (strstr(type_name, "char")) 892254721Semaste { 893254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) 894254721Semaste return ClangASTType (ast, ast->CharTy.getAsOpaquePtr()); 895254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) 896254721Semaste return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr()); 897254721Semaste } 898254721Semaste if (strstr(type_name, "int")) 899254721Semaste { 900254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) 901254721Semaste return ClangASTType (ast, ast->IntTy.getAsOpaquePtr()); 902254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) 903254721Semaste return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr()); 904254721Semaste } 905254721Semaste } 906254721Semaste // We weren't able to match up a type name, just search by size 907254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) 908254721Semaste return ClangASTType (ast, ast->CharTy.getAsOpaquePtr()); 909254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) 910254721Semaste return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr()); 911254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) 912254721Semaste return ClangASTType (ast, ast->IntTy.getAsOpaquePtr()); 913254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) 914254721Semaste return ClangASTType (ast, ast->LongTy.getAsOpaquePtr()); 915254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) 916254721Semaste return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr()); 917254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) 918254721Semaste return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr()); 919254721Semaste break; 920254721Semaste 921254721Semaste case DW_ATE_signed_char: 922254721Semaste if (type_name) 923254721Semaste { 924254721Semaste if (streq(type_name, "signed char")) 925254721Semaste { 926254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) 927254721Semaste return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr()); 928254721Semaste } 929254721Semaste } 930254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) 931254721Semaste return ClangASTType (ast, ast->CharTy.getAsOpaquePtr()); 932254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) 933254721Semaste return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr()); 934254721Semaste break; 935254721Semaste 936254721Semaste case DW_ATE_unsigned: 937254721Semaste if (type_name) 938254721Semaste { 939254721Semaste if (strstr(type_name, "long long")) 940254721Semaste { 941254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) 942254721Semaste return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr()); 943254721Semaste } 944254721Semaste else if (strstr(type_name, "long")) 945254721Semaste { 946254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) 947254721Semaste return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr()); 948254721Semaste } 949254721Semaste else if (strstr(type_name, "short")) 950254721Semaste { 951254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) 952254721Semaste return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr()); 953254721Semaste } 954254721Semaste else if (strstr(type_name, "char")) 955254721Semaste { 956254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) 957254721Semaste return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr()); 958254721Semaste } 959254721Semaste else if (strstr(type_name, "int")) 960254721Semaste { 961254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) 962254721Semaste return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr()); 963254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) 964254721Semaste return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr()); 965254721Semaste } 966254721Semaste } 967254721Semaste // We weren't able to match up a type name, just search by size 968254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) 969254721Semaste return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr()); 970254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) 971254721Semaste return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr()); 972254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) 973254721Semaste return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr()); 974254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) 975254721Semaste return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr()); 976254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) 977254721Semaste return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr()); 978254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) 979254721Semaste return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr()); 980254721Semaste break; 981254721Semaste 982254721Semaste case DW_ATE_unsigned_char: 983254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) 984254721Semaste return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr()); 985254721Semaste if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) 986254721Semaste return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr()); 987254721Semaste break; 988254721Semaste 989254721Semaste case DW_ATE_imaginary_float: 990254721Semaste break; 991254721Semaste 992254721Semaste case DW_ATE_UTF: 993254721Semaste if (type_name) 994254721Semaste { 995254721Semaste if (streq(type_name, "char16_t")) 996254721Semaste { 997254721Semaste return ClangASTType (ast, ast->Char16Ty.getAsOpaquePtr()); 998254721Semaste } 999254721Semaste else if (streq(type_name, "char32_t")) 1000254721Semaste { 1001254721Semaste return ClangASTType (ast, ast->Char32Ty.getAsOpaquePtr()); 1002254721Semaste } 1003254721Semaste } 1004254721Semaste break; 1005254721Semaste } 1006254721Semaste } 1007254721Semaste // This assert should fire for anything that we don't catch above so we know 1008254721Semaste // to fix any issues we run into. 1009254721Semaste if (type_name) 1010254721Semaste { 1011254721Semaste 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); 1012254721Semaste } 1013254721Semaste else 1014254721Semaste { 1015254721Semaste 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); 1016254721Semaste } 1017254721Semaste return ClangASTType (); 1018254721Semaste} 1019254721Semaste 1020254721SemasteClangASTType 1021254721SemasteClangASTContext::GetUnknownAnyType(clang::ASTContext *ast) 1022254721Semaste{ 1023254721Semaste if (ast) 1024254721Semaste return ClangASTType (ast, ast->UnknownAnyTy.getAsOpaquePtr()); 1025254721Semaste return ClangASTType(); 1026254721Semaste} 1027254721Semaste 1028254721SemasteClangASTType 1029254721SemasteClangASTContext::GetCStringType (bool is_const) 1030254721Semaste{ 1031254721Semaste ASTContext *ast = getASTContext(); 1032254721Semaste QualType char_type(ast->CharTy); 1033254721Semaste 1034254721Semaste if (is_const) 1035254721Semaste char_type.addConst(); 1036254721Semaste 1037254721Semaste return ClangASTType (ast, ast->getPointerType(char_type).getAsOpaquePtr()); 1038254721Semaste} 1039254721Semaste 1040254721Semasteclang::DeclContext * 1041254721SemasteClangASTContext::GetTranslationUnitDecl (clang::ASTContext *ast) 1042254721Semaste{ 1043254721Semaste return ast->getTranslationUnitDecl(); 1044254721Semaste} 1045254721Semaste 1046254721SemasteClangASTType 1047254721SemasteClangASTContext::CopyType (ASTContext *dst_ast, 1048254721Semaste ClangASTType src) 1049254721Semaste{ 1050254721Semaste FileSystemOptions file_system_options; 1051254721Semaste ASTContext *src_ast = src.GetASTContext(); 1052254721Semaste FileManager file_manager (file_system_options); 1053254721Semaste ASTImporter importer(*dst_ast, file_manager, 1054254721Semaste *src_ast, file_manager, 1055254721Semaste false); 1056254721Semaste 1057254721Semaste QualType dst (importer.Import(src.GetQualType())); 1058254721Semaste 1059254721Semaste return ClangASTType (dst_ast, dst.getAsOpaquePtr()); 1060254721Semaste} 1061254721Semaste 1062254721Semaste 1063254721Semasteclang::Decl * 1064254721SemasteClangASTContext::CopyDecl (ASTContext *dst_ast, 1065254721Semaste ASTContext *src_ast, 1066254721Semaste clang::Decl *source_decl) 1067254721Semaste{ 1068254721Semaste FileSystemOptions file_system_options; 1069254721Semaste FileManager file_manager (file_system_options); 1070254721Semaste ASTImporter importer(*dst_ast, file_manager, 1071254721Semaste *src_ast, file_manager, 1072254721Semaste false); 1073254721Semaste 1074254721Semaste return importer.Import(source_decl); 1075254721Semaste} 1076254721Semaste 1077254721Semastebool 1078254721SemasteClangASTContext::AreTypesSame (ClangASTType type1, 1079254721Semaste ClangASTType type2, 1080254721Semaste bool ignore_qualifiers) 1081254721Semaste{ 1082254721Semaste ASTContext *ast = type1.GetASTContext(); 1083254721Semaste if (ast != type2.GetASTContext()) 1084254721Semaste return false; 1085254721Semaste 1086254721Semaste if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType()) 1087254721Semaste return true; 1088254721Semaste 1089254721Semaste QualType type1_qual = type1.GetQualType(); 1090254721Semaste QualType type2_qual = type2.GetQualType(); 1091254721Semaste 1092254721Semaste if (ignore_qualifiers) 1093254721Semaste { 1094254721Semaste type1_qual = type1_qual.getUnqualifiedType(); 1095254721Semaste type2_qual = type2_qual.getUnqualifiedType(); 1096254721Semaste } 1097254721Semaste 1098254721Semaste return ast->hasSameType (type1_qual, type2_qual); 1099254721Semaste} 1100254721Semaste 1101254721Semaste 1102254721SemasteClangASTType 1103254721SemasteClangASTContext::GetTypeForDecl (TagDecl *decl) 1104254721Semaste{ 1105254721Semaste // No need to call the getASTContext() accessor (which can create the AST 1106254721Semaste // if it isn't created yet, because we can't have created a decl in this 1107254721Semaste // AST if our AST didn't already exist... 1108254721Semaste ASTContext *ast = m_ast_ap.get(); 1109254721Semaste if (ast) 1110254721Semaste return ClangASTType (ast, ast->getTagDeclType(decl).getAsOpaquePtr()); 1111254721Semaste return ClangASTType(); 1112254721Semaste} 1113254721Semaste 1114254721SemasteClangASTType 1115254721SemasteClangASTContext::GetTypeForDecl (ObjCInterfaceDecl *decl) 1116254721Semaste{ 1117254721Semaste // No need to call the getASTContext() accessor (which can create the AST 1118254721Semaste // if it isn't created yet, because we can't have created a decl in this 1119254721Semaste // AST if our AST didn't already exist... 1120254721Semaste ASTContext *ast = m_ast_ap.get(); 1121254721Semaste if (ast) 1122254721Semaste return ClangASTType (ast, ast->getObjCInterfaceType(decl).getAsOpaquePtr()); 1123254721Semaste return ClangASTType(); 1124254721Semaste} 1125254721Semaste 1126254721Semaste#pragma mark Structure, Unions, Classes 1127254721Semaste 1128254721SemasteClangASTType 1129254721SemasteClangASTContext::CreateRecordType (DeclContext *decl_ctx, 1130254721Semaste AccessType access_type, 1131254721Semaste const char *name, 1132254721Semaste int kind, 1133254721Semaste LanguageType language, 1134254721Semaste ClangASTMetadata *metadata) 1135254721Semaste{ 1136254721Semaste ASTContext *ast = getASTContext(); 1137254721Semaste assert (ast != NULL); 1138254721Semaste 1139254721Semaste if (decl_ctx == NULL) 1140254721Semaste decl_ctx = ast->getTranslationUnitDecl(); 1141254721Semaste 1142254721Semaste 1143254721Semaste if (language == eLanguageTypeObjC || language == eLanguageTypeObjC_plus_plus) 1144254721Semaste { 1145254721Semaste bool isForwardDecl = true; 1146254721Semaste bool isInternal = false; 1147254721Semaste return CreateObjCClass (name, decl_ctx, isForwardDecl, isInternal, metadata); 1148254721Semaste } 1149254721Semaste 1150254721Semaste // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and 1151254721Semaste // we will need to update this code. I was told to currently always use 1152254721Semaste // the CXXRecordDecl class since we often don't know from debug information 1153254721Semaste // if something is struct or a class, so we default to always use the more 1154254721Semaste // complete definition just in case. 1155269024Semaste 1156269024Semaste bool is_anonymous = (!name) || (!name[0]); 1157269024Semaste 1158254721Semaste CXXRecordDecl *decl = CXXRecordDecl::Create (*ast, 1159254721Semaste (TagDecl::TagKind)kind, 1160254721Semaste decl_ctx, 1161254721Semaste SourceLocation(), 1162254721Semaste SourceLocation(), 1163269024Semaste is_anonymous ? NULL : &ast->Idents.get(name)); 1164254721Semaste 1165269024Semaste if (is_anonymous) 1166269024Semaste decl->setAnonymousStructOrUnion(true); 1167269024Semaste 1168254721Semaste if (decl) 1169254721Semaste { 1170254721Semaste if (metadata) 1171254721Semaste SetMetadata(ast, decl, *metadata); 1172254721Semaste 1173254721Semaste if (access_type != eAccessNone) 1174254721Semaste decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type)); 1175254721Semaste 1176254721Semaste if (decl_ctx) 1177254721Semaste decl_ctx->addDecl (decl); 1178254721Semaste 1179254721Semaste return ClangASTType(ast, ast->getTagDeclType(decl).getAsOpaquePtr()); 1180254721Semaste } 1181254721Semaste return ClangASTType(); 1182254721Semaste} 1183254721Semaste 1184254721Semastestatic TemplateParameterList * 1185254721SemasteCreateTemplateParameterList (ASTContext *ast, 1186254721Semaste const ClangASTContext::TemplateParameterInfos &template_param_infos, 1187254721Semaste llvm::SmallVector<NamedDecl *, 8> &template_param_decls) 1188254721Semaste{ 1189254721Semaste const bool parameter_pack = false; 1190254721Semaste const bool is_typename = false; 1191254721Semaste const unsigned depth = 0; 1192254721Semaste const size_t num_template_params = template_param_infos.GetSize(); 1193254721Semaste for (size_t i=0; i<num_template_params; ++i) 1194254721Semaste { 1195254721Semaste const char *name = template_param_infos.names[i]; 1196254721Semaste 1197254721Semaste IdentifierInfo *identifier_info = NULL; 1198254721Semaste if (name && name[0]) 1199254721Semaste identifier_info = &ast->Idents.get(name); 1200254721Semaste if (template_param_infos.args[i].getKind() == TemplateArgument::Integral) 1201254721Semaste { 1202254721Semaste template_param_decls.push_back (NonTypeTemplateParmDecl::Create (*ast, 1203254721Semaste ast->getTranslationUnitDecl(), // Is this the right decl context?, SourceLocation StartLoc, 1204254721Semaste SourceLocation(), 1205254721Semaste SourceLocation(), 1206254721Semaste depth, 1207254721Semaste i, 1208254721Semaste identifier_info, 1209254721Semaste template_param_infos.args[i].getIntegralType(), 1210254721Semaste parameter_pack, 1211254721Semaste NULL)); 1212254721Semaste 1213254721Semaste } 1214254721Semaste else 1215254721Semaste { 1216254721Semaste template_param_decls.push_back (TemplateTypeParmDecl::Create (*ast, 1217254721Semaste ast->getTranslationUnitDecl(), // Is this the right decl context? 1218254721Semaste SourceLocation(), 1219254721Semaste SourceLocation(), 1220254721Semaste depth, 1221254721Semaste i, 1222254721Semaste identifier_info, 1223254721Semaste is_typename, 1224254721Semaste parameter_pack)); 1225254721Semaste } 1226254721Semaste } 1227254721Semaste 1228254721Semaste TemplateParameterList *template_param_list = TemplateParameterList::Create (*ast, 1229254721Semaste SourceLocation(), 1230254721Semaste SourceLocation(), 1231254721Semaste &template_param_decls.front(), 1232254721Semaste template_param_decls.size(), 1233254721Semaste SourceLocation()); 1234254721Semaste return template_param_list; 1235254721Semaste} 1236254721Semaste 1237254721Semasteclang::FunctionTemplateDecl * 1238254721SemasteClangASTContext::CreateFunctionTemplateDecl (clang::DeclContext *decl_ctx, 1239254721Semaste clang::FunctionDecl *func_decl, 1240254721Semaste const char *name, 1241254721Semaste const TemplateParameterInfos &template_param_infos) 1242254721Semaste{ 1243254721Semaste// /// \brief Create a function template node. 1244254721Semaste ASTContext *ast = getASTContext(); 1245254721Semaste 1246254721Semaste llvm::SmallVector<NamedDecl *, 8> template_param_decls; 1247254721Semaste 1248254721Semaste TemplateParameterList *template_param_list = CreateTemplateParameterList (ast, 1249254721Semaste template_param_infos, 1250254721Semaste template_param_decls); 1251254721Semaste FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create (*ast, 1252254721Semaste decl_ctx, 1253254721Semaste func_decl->getLocation(), 1254254721Semaste func_decl->getDeclName(), 1255254721Semaste template_param_list, 1256254721Semaste func_decl); 1257254721Semaste 1258254721Semaste for (size_t i=0, template_param_decl_count = template_param_decls.size(); 1259254721Semaste i < template_param_decl_count; 1260254721Semaste ++i) 1261254721Semaste { 1262254721Semaste // TODO: verify which decl context we should put template_param_decls into.. 1263254721Semaste template_param_decls[i]->setDeclContext (func_decl); 1264254721Semaste } 1265254721Semaste 1266254721Semaste return func_tmpl_decl; 1267254721Semaste} 1268254721Semaste 1269254721Semastevoid 1270254721SemasteClangASTContext::CreateFunctionTemplateSpecializationInfo (FunctionDecl *func_decl, 1271254721Semaste clang::FunctionTemplateDecl *func_tmpl_decl, 1272254721Semaste const TemplateParameterInfos &infos) 1273254721Semaste{ 1274254721Semaste TemplateArgumentList template_args (TemplateArgumentList::OnStack, 1275254721Semaste infos.args.data(), 1276254721Semaste infos.args.size()); 1277254721Semaste 1278254721Semaste func_decl->setFunctionTemplateSpecialization (func_tmpl_decl, 1279254721Semaste &template_args, 1280254721Semaste NULL); 1281254721Semaste} 1282254721Semaste 1283254721Semaste 1284254721SemasteClassTemplateDecl * 1285254721SemasteClangASTContext::CreateClassTemplateDecl (DeclContext *decl_ctx, 1286254721Semaste lldb::AccessType access_type, 1287254721Semaste const char *class_name, 1288254721Semaste int kind, 1289254721Semaste const TemplateParameterInfos &template_param_infos) 1290254721Semaste{ 1291254721Semaste ASTContext *ast = getASTContext(); 1292254721Semaste 1293254721Semaste ClassTemplateDecl *class_template_decl = NULL; 1294254721Semaste if (decl_ctx == NULL) 1295254721Semaste decl_ctx = ast->getTranslationUnitDecl(); 1296254721Semaste 1297254721Semaste IdentifierInfo &identifier_info = ast->Idents.get(class_name); 1298254721Semaste DeclarationName decl_name (&identifier_info); 1299254721Semaste 1300254721Semaste clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name); 1301254721Semaste 1302254721Semaste for (NamedDecl *decl : result) 1303254721Semaste { 1304254721Semaste class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl); 1305254721Semaste if (class_template_decl) 1306254721Semaste return class_template_decl; 1307254721Semaste } 1308254721Semaste 1309254721Semaste llvm::SmallVector<NamedDecl *, 8> template_param_decls; 1310254721Semaste 1311254721Semaste TemplateParameterList *template_param_list = CreateTemplateParameterList (ast, 1312254721Semaste template_param_infos, 1313254721Semaste template_param_decls); 1314254721Semaste 1315254721Semaste CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create (*ast, 1316254721Semaste (TagDecl::TagKind)kind, 1317254721Semaste decl_ctx, // What decl context do we use here? TU? The actual decl context? 1318254721Semaste SourceLocation(), 1319254721Semaste SourceLocation(), 1320254721Semaste &identifier_info); 1321254721Semaste 1322254721Semaste for (size_t i=0, template_param_decl_count = template_param_decls.size(); 1323254721Semaste i < template_param_decl_count; 1324254721Semaste ++i) 1325254721Semaste { 1326254721Semaste template_param_decls[i]->setDeclContext (template_cxx_decl); 1327254721Semaste } 1328254721Semaste 1329254721Semaste // With templated classes, we say that a class is templated with 1330254721Semaste // specializations, but that the bare class has no functions. 1331254721Semaste //template_cxx_decl->startDefinition(); 1332254721Semaste //template_cxx_decl->completeDefinition(); 1333254721Semaste 1334254721Semaste class_template_decl = ClassTemplateDecl::Create (*ast, 1335254721Semaste decl_ctx, // What decl context do we use here? TU? The actual decl context? 1336254721Semaste SourceLocation(), 1337254721Semaste decl_name, 1338254721Semaste template_param_list, 1339254721Semaste template_cxx_decl, 1340254721Semaste NULL); 1341254721Semaste 1342254721Semaste if (class_template_decl) 1343254721Semaste { 1344254721Semaste if (access_type != eAccessNone) 1345254721Semaste class_template_decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type)); 1346254721Semaste 1347254721Semaste //if (TagDecl *ctx_tag_decl = dyn_cast<TagDecl>(decl_ctx)) 1348254721Semaste // CompleteTagDeclarationDefinition(GetTypeForDecl(ctx_tag_decl)); 1349254721Semaste 1350254721Semaste decl_ctx->addDecl (class_template_decl); 1351254721Semaste 1352254721Semaste#ifdef LLDB_CONFIGURATION_DEBUG 1353254721Semaste VerifyDecl(class_template_decl); 1354254721Semaste#endif 1355254721Semaste } 1356254721Semaste 1357254721Semaste return class_template_decl; 1358254721Semaste} 1359254721Semaste 1360254721Semaste 1361254721SemasteClassTemplateSpecializationDecl * 1362254721SemasteClangASTContext::CreateClassTemplateSpecializationDecl (DeclContext *decl_ctx, 1363254721Semaste ClassTemplateDecl *class_template_decl, 1364254721Semaste int kind, 1365254721Semaste const TemplateParameterInfos &template_param_infos) 1366254721Semaste{ 1367254721Semaste ASTContext *ast = getASTContext(); 1368254721Semaste ClassTemplateSpecializationDecl *class_template_specialization_decl = ClassTemplateSpecializationDecl::Create (*ast, 1369254721Semaste (TagDecl::TagKind)kind, 1370254721Semaste decl_ctx, 1371254721Semaste SourceLocation(), 1372254721Semaste SourceLocation(), 1373254721Semaste class_template_decl, 1374254721Semaste &template_param_infos.args.front(), 1375254721Semaste template_param_infos.args.size(), 1376254721Semaste NULL); 1377254721Semaste 1378254721Semaste class_template_specialization_decl->setSpecializationKind(TSK_ExplicitSpecialization); 1379254721Semaste 1380254721Semaste return class_template_specialization_decl; 1381254721Semaste} 1382254721Semaste 1383254721SemasteClangASTType 1384254721SemasteClangASTContext::CreateClassTemplateSpecializationType (ClassTemplateSpecializationDecl *class_template_specialization_decl) 1385254721Semaste{ 1386254721Semaste if (class_template_specialization_decl) 1387254721Semaste { 1388254721Semaste ASTContext *ast = getASTContext(); 1389254721Semaste if (ast) 1390254721Semaste return ClangASTType(ast, ast->getTagDeclType(class_template_specialization_decl).getAsOpaquePtr()); 1391254721Semaste } 1392254721Semaste return ClangASTType(); 1393254721Semaste} 1394254721Semaste 1395254721Semastestatic bool 1396254721SemasteIsOperator (const char *name, OverloadedOperatorKind &op_kind) 1397254721Semaste{ 1398254721Semaste if (name == NULL || name[0] == '\0') 1399254721Semaste return false; 1400254721Semaste 1401254721Semaste#define OPERATOR_PREFIX "operator" 1402254721Semaste#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1) 1403254721Semaste 1404254721Semaste const char *post_op_name = NULL; 1405254721Semaste 1406254721Semaste bool no_space = true; 1407254721Semaste 1408254721Semaste if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH)) 1409254721Semaste return false; 1410254721Semaste 1411254721Semaste post_op_name = name + OPERATOR_PREFIX_LENGTH; 1412254721Semaste 1413254721Semaste if (post_op_name[0] == ' ') 1414254721Semaste { 1415254721Semaste post_op_name++; 1416254721Semaste no_space = false; 1417254721Semaste } 1418254721Semaste 1419254721Semaste#undef OPERATOR_PREFIX 1420254721Semaste#undef OPERATOR_PREFIX_LENGTH 1421254721Semaste 1422254721Semaste // This is an operator, set the overloaded operator kind to invalid 1423254721Semaste // in case this is a conversion operator... 1424254721Semaste op_kind = NUM_OVERLOADED_OPERATORS; 1425254721Semaste 1426254721Semaste switch (post_op_name[0]) 1427254721Semaste { 1428254721Semaste default: 1429254721Semaste if (no_space) 1430254721Semaste return false; 1431254721Semaste break; 1432254721Semaste case 'n': 1433254721Semaste if (no_space) 1434254721Semaste return false; 1435254721Semaste if (strcmp (post_op_name, "new") == 0) 1436254721Semaste op_kind = OO_New; 1437254721Semaste else if (strcmp (post_op_name, "new[]") == 0) 1438254721Semaste op_kind = OO_Array_New; 1439254721Semaste break; 1440254721Semaste 1441254721Semaste case 'd': 1442254721Semaste if (no_space) 1443254721Semaste return false; 1444254721Semaste if (strcmp (post_op_name, "delete") == 0) 1445254721Semaste op_kind = OO_Delete; 1446254721Semaste else if (strcmp (post_op_name, "delete[]") == 0) 1447254721Semaste op_kind = OO_Array_Delete; 1448254721Semaste break; 1449254721Semaste 1450254721Semaste case '+': 1451254721Semaste if (post_op_name[1] == '\0') 1452254721Semaste op_kind = OO_Plus; 1453254721Semaste else if (post_op_name[2] == '\0') 1454254721Semaste { 1455254721Semaste if (post_op_name[1] == '=') 1456254721Semaste op_kind = OO_PlusEqual; 1457254721Semaste else if (post_op_name[1] == '+') 1458254721Semaste op_kind = OO_PlusPlus; 1459254721Semaste } 1460254721Semaste break; 1461254721Semaste 1462254721Semaste case '-': 1463254721Semaste if (post_op_name[1] == '\0') 1464254721Semaste op_kind = OO_Minus; 1465254721Semaste else if (post_op_name[2] == '\0') 1466254721Semaste { 1467254721Semaste switch (post_op_name[1]) 1468254721Semaste { 1469254721Semaste case '=': op_kind = OO_MinusEqual; break; 1470254721Semaste case '-': op_kind = OO_MinusMinus; break; 1471254721Semaste case '>': op_kind = OO_Arrow; break; 1472254721Semaste } 1473254721Semaste } 1474254721Semaste else if (post_op_name[3] == '\0') 1475254721Semaste { 1476254721Semaste if (post_op_name[2] == '*') 1477254721Semaste op_kind = OO_ArrowStar; break; 1478254721Semaste } 1479254721Semaste break; 1480254721Semaste 1481254721Semaste case '*': 1482254721Semaste if (post_op_name[1] == '\0') 1483254721Semaste op_kind = OO_Star; 1484254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1485254721Semaste op_kind = OO_StarEqual; 1486254721Semaste break; 1487254721Semaste 1488254721Semaste case '/': 1489254721Semaste if (post_op_name[1] == '\0') 1490254721Semaste op_kind = OO_Slash; 1491254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1492254721Semaste op_kind = OO_SlashEqual; 1493254721Semaste break; 1494254721Semaste 1495254721Semaste case '%': 1496254721Semaste if (post_op_name[1] == '\0') 1497254721Semaste op_kind = OO_Percent; 1498254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1499254721Semaste op_kind = OO_PercentEqual; 1500254721Semaste break; 1501254721Semaste 1502254721Semaste 1503254721Semaste case '^': 1504254721Semaste if (post_op_name[1] == '\0') 1505254721Semaste op_kind = OO_Caret; 1506254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1507254721Semaste op_kind = OO_CaretEqual; 1508254721Semaste break; 1509254721Semaste 1510254721Semaste case '&': 1511254721Semaste if (post_op_name[1] == '\0') 1512254721Semaste op_kind = OO_Amp; 1513254721Semaste else if (post_op_name[2] == '\0') 1514254721Semaste { 1515254721Semaste switch (post_op_name[1]) 1516254721Semaste { 1517254721Semaste case '=': op_kind = OO_AmpEqual; break; 1518254721Semaste case '&': op_kind = OO_AmpAmp; break; 1519254721Semaste } 1520254721Semaste } 1521254721Semaste break; 1522254721Semaste 1523254721Semaste case '|': 1524254721Semaste if (post_op_name[1] == '\0') 1525254721Semaste op_kind = OO_Pipe; 1526254721Semaste else if (post_op_name[2] == '\0') 1527254721Semaste { 1528254721Semaste switch (post_op_name[1]) 1529254721Semaste { 1530254721Semaste case '=': op_kind = OO_PipeEqual; break; 1531254721Semaste case '|': op_kind = OO_PipePipe; break; 1532254721Semaste } 1533254721Semaste } 1534254721Semaste break; 1535254721Semaste 1536254721Semaste case '~': 1537254721Semaste if (post_op_name[1] == '\0') 1538254721Semaste op_kind = OO_Tilde; 1539254721Semaste break; 1540254721Semaste 1541254721Semaste case '!': 1542254721Semaste if (post_op_name[1] == '\0') 1543254721Semaste op_kind = OO_Exclaim; 1544254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1545254721Semaste op_kind = OO_ExclaimEqual; 1546254721Semaste break; 1547254721Semaste 1548254721Semaste case '=': 1549254721Semaste if (post_op_name[1] == '\0') 1550254721Semaste op_kind = OO_Equal; 1551254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 1552254721Semaste op_kind = OO_EqualEqual; 1553254721Semaste break; 1554254721Semaste 1555254721Semaste case '<': 1556254721Semaste if (post_op_name[1] == '\0') 1557254721Semaste op_kind = OO_Less; 1558254721Semaste else if (post_op_name[2] == '\0') 1559254721Semaste { 1560254721Semaste switch (post_op_name[1]) 1561254721Semaste { 1562254721Semaste case '<': op_kind = OO_LessLess; break; 1563254721Semaste case '=': op_kind = OO_LessEqual; break; 1564254721Semaste } 1565254721Semaste } 1566254721Semaste else if (post_op_name[3] == '\0') 1567254721Semaste { 1568254721Semaste if (post_op_name[2] == '=') 1569254721Semaste op_kind = OO_LessLessEqual; 1570254721Semaste } 1571254721Semaste break; 1572254721Semaste 1573254721Semaste case '>': 1574254721Semaste if (post_op_name[1] == '\0') 1575254721Semaste op_kind = OO_Greater; 1576254721Semaste else if (post_op_name[2] == '\0') 1577254721Semaste { 1578254721Semaste switch (post_op_name[1]) 1579254721Semaste { 1580254721Semaste case '>': op_kind = OO_GreaterGreater; break; 1581254721Semaste case '=': op_kind = OO_GreaterEqual; break; 1582254721Semaste } 1583254721Semaste } 1584254721Semaste else if (post_op_name[1] == '>' && 1585254721Semaste post_op_name[2] == '=' && 1586254721Semaste post_op_name[3] == '\0') 1587254721Semaste { 1588254721Semaste op_kind = OO_GreaterGreaterEqual; 1589254721Semaste } 1590254721Semaste break; 1591254721Semaste 1592254721Semaste case ',': 1593254721Semaste if (post_op_name[1] == '\0') 1594254721Semaste op_kind = OO_Comma; 1595254721Semaste break; 1596254721Semaste 1597254721Semaste case '(': 1598254721Semaste if (post_op_name[1] == ')' && post_op_name[2] == '\0') 1599254721Semaste op_kind = OO_Call; 1600254721Semaste break; 1601254721Semaste 1602254721Semaste case '[': 1603254721Semaste if (post_op_name[1] == ']' && post_op_name[2] == '\0') 1604254721Semaste op_kind = OO_Subscript; 1605254721Semaste break; 1606254721Semaste } 1607254721Semaste 1608254721Semaste return true; 1609254721Semaste} 1610254721Semaste 1611254721Semastestatic inline bool 1612254721Semastecheck_op_param (uint32_t op_kind, bool unary, bool binary, uint32_t num_params) 1613254721Semaste{ 1614254721Semaste // Special-case call since it can take any number of operands 1615254721Semaste if(op_kind == OO_Call) 1616254721Semaste return true; 1617254721Semaste 1618254721Semaste // The parameter count doens't include "this" 1619254721Semaste if (num_params == 0) 1620254721Semaste return unary; 1621254721Semaste if (num_params == 1) 1622254721Semaste return binary; 1623254721Semaste else 1624254721Semaste return false; 1625254721Semaste} 1626254721Semaste 1627254721Semastebool 1628254721SemasteClangASTContext::CheckOverloadedOperatorKindParameterCount (uint32_t op_kind, uint32_t num_params) 1629254721Semaste{ 1630254721Semaste switch (op_kind) 1631254721Semaste { 1632254721Semaste default: 1633254721Semaste break; 1634254721Semaste // C++ standard allows any number of arguments to new/delete 1635254721Semaste case OO_New: 1636254721Semaste case OO_Array_New: 1637254721Semaste case OO_Delete: 1638254721Semaste case OO_Array_Delete: 1639254721Semaste return true; 1640254721Semaste } 1641254721Semaste 1642254721Semaste#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) case OO_##Name: return check_op_param (op_kind, Unary, Binary, num_params); 1643254721Semaste switch (op_kind) 1644254721Semaste { 1645254721Semaste#include "clang/Basic/OperatorKinds.def" 1646254721Semaste default: break; 1647254721Semaste } 1648254721Semaste return false; 1649254721Semaste} 1650254721Semaste 1651254721Semasteclang::AccessSpecifier 1652254721SemasteClangASTContext::UnifyAccessSpecifiers (clang::AccessSpecifier lhs, clang::AccessSpecifier rhs) 1653254721Semaste{ 1654254721Semaste clang::AccessSpecifier ret = lhs; 1655254721Semaste 1656254721Semaste // Make the access equal to the stricter of the field and the nested field's access 1657254721Semaste switch (ret) 1658254721Semaste { 1659254721Semaste case clang::AS_none: 1660254721Semaste break; 1661254721Semaste case clang::AS_private: 1662254721Semaste break; 1663254721Semaste case clang::AS_protected: 1664254721Semaste if (rhs == AS_private) 1665254721Semaste ret = AS_private; 1666254721Semaste break; 1667254721Semaste case clang::AS_public: 1668254721Semaste ret = rhs; 1669254721Semaste break; 1670254721Semaste } 1671254721Semaste 1672254721Semaste return ret; 1673254721Semaste} 1674254721Semaste 1675254721Semastebool 1676254721SemasteClangASTContext::FieldIsBitfield (FieldDecl* field, uint32_t& bitfield_bit_size) 1677254721Semaste{ 1678254721Semaste return FieldIsBitfield(getASTContext(), field, bitfield_bit_size); 1679254721Semaste} 1680254721Semaste 1681254721Semastebool 1682254721SemasteClangASTContext::FieldIsBitfield 1683254721Semaste( 1684254721Semaste ASTContext *ast, 1685254721Semaste FieldDecl* field, 1686254721Semaste uint32_t& bitfield_bit_size 1687254721Semaste) 1688254721Semaste{ 1689254721Semaste if (ast == NULL || field == NULL) 1690254721Semaste return false; 1691254721Semaste 1692254721Semaste if (field->isBitField()) 1693254721Semaste { 1694254721Semaste Expr* bit_width_expr = field->getBitWidth(); 1695254721Semaste if (bit_width_expr) 1696254721Semaste { 1697254721Semaste llvm::APSInt bit_width_apsint; 1698254721Semaste if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast)) 1699254721Semaste { 1700254721Semaste bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX); 1701254721Semaste return true; 1702254721Semaste } 1703254721Semaste } 1704254721Semaste } 1705254721Semaste return false; 1706254721Semaste} 1707254721Semaste 1708254721Semastebool 1709254721SemasteClangASTContext::RecordHasFields (const RecordDecl *record_decl) 1710254721Semaste{ 1711254721Semaste if (record_decl == NULL) 1712254721Semaste return false; 1713254721Semaste 1714254721Semaste if (!record_decl->field_empty()) 1715254721Semaste return true; 1716254721Semaste 1717254721Semaste // No fields, lets check this is a CXX record and check the base classes 1718254721Semaste const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 1719254721Semaste if (cxx_record_decl) 1720254721Semaste { 1721254721Semaste CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 1722254721Semaste for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 1723254721Semaste base_class != base_class_end; 1724254721Semaste ++base_class) 1725254721Semaste { 1726254721Semaste const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 1727254721Semaste if (RecordHasFields(base_class_decl)) 1728254721Semaste return true; 1729254721Semaste } 1730254721Semaste } 1731254721Semaste return false; 1732254721Semaste} 1733254721Semaste 1734254721Semaste#pragma mark Objective C Classes 1735254721Semaste 1736254721SemasteClangASTType 1737254721SemasteClangASTContext::CreateObjCClass 1738254721Semaste( 1739254721Semaste const char *name, 1740254721Semaste DeclContext *decl_ctx, 1741254721Semaste bool isForwardDecl, 1742254721Semaste bool isInternal, 1743254721Semaste ClangASTMetadata *metadata 1744254721Semaste) 1745254721Semaste{ 1746254721Semaste ASTContext *ast = getASTContext(); 1747254721Semaste assert (ast != NULL); 1748254721Semaste assert (name && name[0]); 1749254721Semaste if (decl_ctx == NULL) 1750254721Semaste decl_ctx = ast->getTranslationUnitDecl(); 1751254721Semaste 1752254721Semaste ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create (*ast, 1753254721Semaste decl_ctx, 1754254721Semaste SourceLocation(), 1755254721Semaste &ast->Idents.get(name), 1756254721Semaste NULL, 1757254721Semaste SourceLocation(), 1758254721Semaste /*isForwardDecl,*/ 1759254721Semaste isInternal); 1760254721Semaste 1761254721Semaste if (decl && metadata) 1762254721Semaste SetMetadata(ast, decl, *metadata); 1763254721Semaste 1764254721Semaste return ClangASTType (ast, ast->getObjCInterfaceType(decl)); 1765254721Semaste} 1766254721Semaste 1767254721Semastestatic inline bool 1768254721SemasteBaseSpecifierIsEmpty (const CXXBaseSpecifier *b) 1769254721Semaste{ 1770254721Semaste return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false; 1771254721Semaste} 1772254721Semaste 1773254721Semasteuint32_t 1774254721SemasteClangASTContext::GetNumBaseClasses (const CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes) 1775254721Semaste{ 1776254721Semaste uint32_t num_bases = 0; 1777254721Semaste if (cxx_record_decl) 1778254721Semaste { 1779254721Semaste if (omit_empty_base_classes) 1780254721Semaste { 1781254721Semaste CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 1782254721Semaste for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 1783254721Semaste base_class != base_class_end; 1784254721Semaste ++base_class) 1785254721Semaste { 1786254721Semaste // Skip empty base classes 1787254721Semaste if (omit_empty_base_classes) 1788254721Semaste { 1789254721Semaste if (BaseSpecifierIsEmpty (base_class)) 1790254721Semaste continue; 1791254721Semaste } 1792254721Semaste ++num_bases; 1793254721Semaste } 1794254721Semaste } 1795254721Semaste else 1796254721Semaste num_bases = cxx_record_decl->getNumBases(); 1797254721Semaste } 1798254721Semaste return num_bases; 1799254721Semaste} 1800254721Semaste 1801254721Semaste 1802254721Semaste#pragma mark Namespace Declarations 1803254721Semaste 1804254721SemasteNamespaceDecl * 1805254721SemasteClangASTContext::GetUniqueNamespaceDeclaration (const char *name, DeclContext *decl_ctx) 1806254721Semaste{ 1807254721Semaste NamespaceDecl *namespace_decl = NULL; 1808254721Semaste ASTContext *ast = getASTContext(); 1809254721Semaste TranslationUnitDecl *translation_unit_decl = ast->getTranslationUnitDecl (); 1810254721Semaste if (decl_ctx == NULL) 1811254721Semaste decl_ctx = translation_unit_decl; 1812254721Semaste 1813254721Semaste if (name) 1814254721Semaste { 1815254721Semaste IdentifierInfo &identifier_info = ast->Idents.get(name); 1816254721Semaste DeclarationName decl_name (&identifier_info); 1817254721Semaste clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name); 1818254721Semaste for (NamedDecl *decl : result) 1819254721Semaste { 1820254721Semaste namespace_decl = dyn_cast<clang::NamespaceDecl>(decl); 1821254721Semaste if (namespace_decl) 1822254721Semaste return namespace_decl; 1823254721Semaste } 1824254721Semaste 1825254721Semaste namespace_decl = NamespaceDecl::Create(*ast, 1826254721Semaste decl_ctx, 1827254721Semaste false, 1828254721Semaste SourceLocation(), 1829254721Semaste SourceLocation(), 1830254721Semaste &identifier_info, 1831254721Semaste NULL); 1832254721Semaste 1833254721Semaste decl_ctx->addDecl (namespace_decl); 1834254721Semaste } 1835254721Semaste else 1836254721Semaste { 1837254721Semaste if (decl_ctx == translation_unit_decl) 1838254721Semaste { 1839254721Semaste namespace_decl = translation_unit_decl->getAnonymousNamespace(); 1840254721Semaste if (namespace_decl) 1841254721Semaste return namespace_decl; 1842254721Semaste 1843254721Semaste namespace_decl = NamespaceDecl::Create(*ast, 1844254721Semaste decl_ctx, 1845254721Semaste false, 1846254721Semaste SourceLocation(), 1847254721Semaste SourceLocation(), 1848254721Semaste NULL, 1849254721Semaste NULL); 1850254721Semaste translation_unit_decl->setAnonymousNamespace (namespace_decl); 1851254721Semaste translation_unit_decl->addDecl (namespace_decl); 1852254721Semaste assert (namespace_decl == translation_unit_decl->getAnonymousNamespace()); 1853254721Semaste } 1854254721Semaste else 1855254721Semaste { 1856254721Semaste NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx); 1857254721Semaste if (parent_namespace_decl) 1858254721Semaste { 1859254721Semaste namespace_decl = parent_namespace_decl->getAnonymousNamespace(); 1860254721Semaste if (namespace_decl) 1861254721Semaste return namespace_decl; 1862254721Semaste namespace_decl = NamespaceDecl::Create(*ast, 1863254721Semaste decl_ctx, 1864254721Semaste false, 1865254721Semaste SourceLocation(), 1866254721Semaste SourceLocation(), 1867254721Semaste NULL, 1868254721Semaste NULL); 1869254721Semaste parent_namespace_decl->setAnonymousNamespace (namespace_decl); 1870254721Semaste parent_namespace_decl->addDecl (namespace_decl); 1871254721Semaste assert (namespace_decl == parent_namespace_decl->getAnonymousNamespace()); 1872254721Semaste } 1873254721Semaste else 1874254721Semaste { 1875254721Semaste // BAD!!! 1876254721Semaste } 1877254721Semaste } 1878254721Semaste 1879254721Semaste 1880254721Semaste if (namespace_decl) 1881254721Semaste { 1882254721Semaste // If we make it here, we are creating the anonymous namespace decl 1883254721Semaste // for the first time, so we need to do the using directive magic 1884254721Semaste // like SEMA does 1885254721Semaste UsingDirectiveDecl* using_directive_decl = UsingDirectiveDecl::Create (*ast, 1886254721Semaste decl_ctx, 1887254721Semaste SourceLocation(), 1888254721Semaste SourceLocation(), 1889254721Semaste NestedNameSpecifierLoc(), 1890254721Semaste SourceLocation(), 1891254721Semaste namespace_decl, 1892254721Semaste decl_ctx); 1893254721Semaste using_directive_decl->setImplicit(); 1894254721Semaste decl_ctx->addDecl(using_directive_decl); 1895254721Semaste } 1896254721Semaste } 1897254721Semaste#ifdef LLDB_CONFIGURATION_DEBUG 1898254721Semaste VerifyDecl(namespace_decl); 1899254721Semaste#endif 1900254721Semaste return namespace_decl; 1901254721Semaste} 1902254721Semaste 1903254721Semaste 1904254721Semaste#pragma mark Function Types 1905254721Semaste 1906254721SemasteFunctionDecl * 1907254721SemasteClangASTContext::CreateFunctionDeclaration (DeclContext *decl_ctx, 1908254721Semaste const char *name, 1909254721Semaste const ClangASTType &function_clang_type, 1910254721Semaste int storage, 1911254721Semaste bool is_inline) 1912254721Semaste{ 1913254721Semaste FunctionDecl *func_decl = NULL; 1914254721Semaste ASTContext *ast = getASTContext(); 1915254721Semaste if (decl_ctx == NULL) 1916254721Semaste decl_ctx = ast->getTranslationUnitDecl(); 1917254721Semaste 1918254721Semaste 1919254721Semaste const bool hasWrittenPrototype = true; 1920254721Semaste const bool isConstexprSpecified = false; 1921254721Semaste 1922254721Semaste if (name && name[0]) 1923254721Semaste { 1924254721Semaste func_decl = FunctionDecl::Create (*ast, 1925254721Semaste decl_ctx, 1926254721Semaste SourceLocation(), 1927254721Semaste SourceLocation(), 1928254721Semaste DeclarationName (&ast->Idents.get(name)), 1929254721Semaste function_clang_type.GetQualType(), 1930254721Semaste NULL, 1931254721Semaste (FunctionDecl::StorageClass)storage, 1932254721Semaste is_inline, 1933254721Semaste hasWrittenPrototype, 1934254721Semaste isConstexprSpecified); 1935254721Semaste } 1936254721Semaste else 1937254721Semaste { 1938254721Semaste func_decl = FunctionDecl::Create (*ast, 1939254721Semaste decl_ctx, 1940254721Semaste SourceLocation(), 1941254721Semaste SourceLocation(), 1942254721Semaste DeclarationName (), 1943254721Semaste function_clang_type.GetQualType(), 1944254721Semaste NULL, 1945254721Semaste (FunctionDecl::StorageClass)storage, 1946254721Semaste is_inline, 1947254721Semaste hasWrittenPrototype, 1948254721Semaste isConstexprSpecified); 1949254721Semaste } 1950254721Semaste if (func_decl) 1951254721Semaste decl_ctx->addDecl (func_decl); 1952254721Semaste 1953254721Semaste#ifdef LLDB_CONFIGURATION_DEBUG 1954254721Semaste VerifyDecl(func_decl); 1955254721Semaste#endif 1956254721Semaste 1957254721Semaste return func_decl; 1958254721Semaste} 1959254721Semaste 1960254721SemasteClangASTType 1961254721SemasteClangASTContext::CreateFunctionType (ASTContext *ast, 1962254721Semaste const ClangASTType& result_type, 1963254721Semaste const ClangASTType *args, 1964254721Semaste unsigned num_args, 1965254721Semaste bool is_variadic, 1966254721Semaste unsigned type_quals) 1967254721Semaste{ 1968254721Semaste assert (ast != NULL); 1969254721Semaste std::vector<QualType> qual_type_args; 1970254721Semaste for (unsigned i=0; i<num_args; ++i) 1971254721Semaste qual_type_args.push_back (args[i].GetQualType()); 1972254721Semaste 1973254721Semaste // TODO: Detect calling convention in DWARF? 1974254721Semaste FunctionProtoType::ExtProtoInfo proto_info; 1975254721Semaste proto_info.Variadic = is_variadic; 1976254721Semaste proto_info.ExceptionSpecType = EST_None; 1977254721Semaste proto_info.TypeQuals = type_quals; 1978254721Semaste proto_info.RefQualifier = RQ_None; 1979254721Semaste proto_info.NumExceptions = 0; 1980254721Semaste proto_info.Exceptions = NULL; 1981254721Semaste 1982254721Semaste return ClangASTType (ast, ast->getFunctionType (result_type.GetQualType(), 1983254721Semaste qual_type_args, 1984254721Semaste proto_info).getAsOpaquePtr()); 1985254721Semaste} 1986254721Semaste 1987254721SemasteParmVarDecl * 1988254721SemasteClangASTContext::CreateParameterDeclaration (const char *name, const ClangASTType ¶m_type, int storage) 1989254721Semaste{ 1990254721Semaste ASTContext *ast = getASTContext(); 1991254721Semaste assert (ast != NULL); 1992254721Semaste return ParmVarDecl::Create(*ast, 1993254721Semaste ast->getTranslationUnitDecl(), 1994254721Semaste SourceLocation(), 1995254721Semaste SourceLocation(), 1996254721Semaste name && name[0] ? &ast->Idents.get(name) : NULL, 1997254721Semaste param_type.GetQualType(), 1998254721Semaste NULL, 1999254721Semaste (VarDecl::StorageClass)storage, 2000254721Semaste 0); 2001254721Semaste} 2002254721Semaste 2003254721Semastevoid 2004254721SemasteClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params) 2005254721Semaste{ 2006254721Semaste if (function_decl) 2007254721Semaste function_decl->setParams (ArrayRef<ParmVarDecl*>(params, num_params)); 2008254721Semaste} 2009254721Semaste 2010254721Semaste 2011254721Semaste#pragma mark Array Types 2012254721Semaste 2013254721SemasteClangASTType 2014254721SemasteClangASTContext::CreateArrayType (const ClangASTType &element_type, 2015254721Semaste size_t element_count, 2016254721Semaste bool is_vector) 2017254721Semaste{ 2018254721Semaste if (element_type.IsValid()) 2019254721Semaste { 2020254721Semaste ASTContext *ast = getASTContext(); 2021254721Semaste assert (ast != NULL); 2022254721Semaste 2023254721Semaste if (is_vector) 2024254721Semaste { 2025254721Semaste return ClangASTType (ast, ast->getExtVectorType(element_type.GetQualType(), element_count).getAsOpaquePtr()); 2026254721Semaste } 2027254721Semaste else 2028254721Semaste { 2029254721Semaste 2030254721Semaste llvm::APInt ap_element_count (64, element_count); 2031254721Semaste if (element_count == 0) 2032254721Semaste { 2033254721Semaste return ClangASTType (ast, ast->getIncompleteArrayType (element_type.GetQualType(), 2034254721Semaste ArrayType::Normal, 2035254721Semaste 0).getAsOpaquePtr()); 2036254721Semaste } 2037254721Semaste else 2038254721Semaste { 2039254721Semaste return ClangASTType (ast, ast->getConstantArrayType (element_type.GetQualType(), 2040254721Semaste ap_element_count, 2041254721Semaste ArrayType::Normal, 2042254721Semaste 0).getAsOpaquePtr()); 2043254721Semaste } 2044254721Semaste } 2045254721Semaste } 2046254721Semaste return ClangASTType(); 2047254721Semaste} 2048254721Semaste 2049254721Semaste 2050254721Semaste 2051254721Semaste#pragma mark Enumeration Types 2052254721Semaste 2053254721SemasteClangASTType 2054254721SemasteClangASTContext::CreateEnumerationType 2055254721Semaste( 2056254721Semaste const char *name, 2057254721Semaste DeclContext *decl_ctx, 2058254721Semaste const Declaration &decl, 2059254721Semaste const ClangASTType &integer_clang_type 2060254721Semaste) 2061254721Semaste{ 2062254721Semaste // TODO: Do something intelligent with the Declaration object passed in 2063254721Semaste // like maybe filling in the SourceLocation with it... 2064254721Semaste ASTContext *ast = getASTContext(); 2065254721Semaste 2066254721Semaste // TODO: ask about these... 2067254721Semaste// const bool IsScoped = false; 2068254721Semaste// const bool IsFixed = false; 2069254721Semaste 2070254721Semaste EnumDecl *enum_decl = EnumDecl::Create (*ast, 2071254721Semaste decl_ctx, 2072254721Semaste SourceLocation(), 2073254721Semaste SourceLocation(), 2074254721Semaste name && name[0] ? &ast->Idents.get(name) : NULL, 2075254721Semaste NULL, 2076254721Semaste false, // IsScoped 2077254721Semaste false, // IsScopedUsingClassTag 2078254721Semaste false); // IsFixed 2079254721Semaste 2080254721Semaste 2081254721Semaste if (enum_decl) 2082254721Semaste { 2083254721Semaste // TODO: check if we should be setting the promotion type too? 2084254721Semaste enum_decl->setIntegerType(integer_clang_type.GetQualType()); 2085254721Semaste 2086254721Semaste enum_decl->setAccess(AS_public); // TODO respect what's in the debug info 2087254721Semaste 2088254721Semaste return ClangASTType (ast, ast->getTagDeclType(enum_decl).getAsOpaquePtr()); 2089254721Semaste } 2090254721Semaste return ClangASTType(); 2091254721Semaste} 2092254721Semaste 2093254721Semaste// Disable this for now since I can't seem to get a nicely formatted float 2094254721Semaste// out of the APFloat class without just getting the float, double or quad 2095254721Semaste// and then using a formatted print on it which defeats the purpose. We ideally 2096254721Semaste// would like to get perfect string values for any kind of float semantics 2097254721Semaste// so we can support remote targets. The code below also requires a patch to 2098254721Semaste// llvm::APInt. 2099254721Semaste//bool 2100254721Semaste//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) 2101254721Semaste//{ 2102254721Semaste// uint32_t count = 0; 2103254721Semaste// bool is_complex = false; 2104254721Semaste// if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex)) 2105254721Semaste// { 2106254721Semaste// unsigned num_bytes_per_float = byte_size / count; 2107254721Semaste// unsigned num_bits_per_float = num_bytes_per_float * 8; 2108254721Semaste// 2109254721Semaste// float_str.clear(); 2110254721Semaste// uint32_t i; 2111254721Semaste// for (i=0; i<count; i++) 2112254721Semaste// { 2113254721Semaste// APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, (APInt::ByteOrder)apint_byte_order); 2114254721Semaste// bool is_ieee = false; 2115254721Semaste// APFloat ap_float(ap_int, is_ieee); 2116254721Semaste// char s[1024]; 2117254721Semaste// unsigned int hex_digits = 0; 2118254721Semaste// bool upper_case = false; 2119254721Semaste// 2120254721Semaste// if (ap_float.convertToHexString(s, hex_digits, upper_case, APFloat::rmNearestTiesToEven) > 0) 2121254721Semaste// { 2122254721Semaste// if (i > 0) 2123254721Semaste// float_str.append(", "); 2124254721Semaste// float_str.append(s); 2125254721Semaste// if (i == 1 && is_complex) 2126254721Semaste// float_str.append(1, 'i'); 2127254721Semaste// } 2128254721Semaste// } 2129254721Semaste// return !float_str.empty(); 2130254721Semaste// } 2131254721Semaste// return false; 2132254721Semaste//} 2133254721Semaste 2134254721Semaste 2135254721SemasteClangASTType 2136254721SemasteClangASTContext::GetFloatTypeFromBitSize (clang::ASTContext *ast, 2137254721Semaste size_t bit_size) 2138254721Semaste{ 2139254721Semaste if (ast) 2140254721Semaste { 2141254721Semaste if (bit_size == ast->getTypeSize(ast->FloatTy)) 2142254721Semaste return ClangASTType(ast, ast->FloatTy.getAsOpaquePtr()); 2143254721Semaste else if (bit_size == ast->getTypeSize(ast->DoubleTy)) 2144254721Semaste return ClangASTType(ast, ast->DoubleTy.getAsOpaquePtr()); 2145254721Semaste else if (bit_size == ast->getTypeSize(ast->LongDoubleTy)) 2146254721Semaste return ClangASTType(ast, ast->LongDoubleTy.getAsOpaquePtr()); 2147254721Semaste else if (bit_size == ast->getTypeSize(ast->HalfTy)) 2148254721Semaste return ClangASTType(ast, ast->HalfTy.getAsOpaquePtr()); 2149254721Semaste } 2150254721Semaste return ClangASTType(); 2151254721Semaste} 2152254721Semaste 2153254721Semastebool 2154254721SemasteClangASTContext::GetCompleteDecl (clang::ASTContext *ast, 2155254721Semaste clang::Decl *decl) 2156254721Semaste{ 2157254721Semaste if (!decl) 2158254721Semaste return false; 2159254721Semaste 2160254721Semaste ExternalASTSource *ast_source = ast->getExternalSource(); 2161254721Semaste 2162254721Semaste if (!ast_source) 2163254721Semaste return false; 2164254721Semaste 2165254721Semaste if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) 2166254721Semaste { 2167254721Semaste if (tag_decl->isCompleteDefinition()) 2168254721Semaste return true; 2169254721Semaste 2170254721Semaste if (!tag_decl->hasExternalLexicalStorage()) 2171254721Semaste return false; 2172254721Semaste 2173254721Semaste ast_source->CompleteType(tag_decl); 2174254721Semaste 2175254721Semaste return !tag_decl->getTypeForDecl()->isIncompleteType(); 2176254721Semaste } 2177254721Semaste else if (clang::ObjCInterfaceDecl *objc_interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) 2178254721Semaste { 2179254721Semaste if (objc_interface_decl->getDefinition()) 2180254721Semaste return true; 2181254721Semaste 2182254721Semaste if (!objc_interface_decl->hasExternalLexicalStorage()) 2183254721Semaste return false; 2184254721Semaste 2185254721Semaste ast_source->CompleteType(objc_interface_decl); 2186254721Semaste 2187254721Semaste return !objc_interface_decl->getTypeForDecl()->isIncompleteType(); 2188254721Semaste } 2189254721Semaste else 2190254721Semaste { 2191254721Semaste return false; 2192254721Semaste } 2193254721Semaste} 2194254721Semaste 2195254721Semastevoid 2196254721SemasteClangASTContext::SetMetadataAsUserID (const void *object, 2197254721Semaste user_id_t user_id) 2198254721Semaste{ 2199254721Semaste ClangASTMetadata meta_data; 2200254721Semaste meta_data.SetUserID (user_id); 2201254721Semaste SetMetadata (object, meta_data); 2202254721Semaste} 2203254721Semaste 2204254721Semastevoid 2205254721SemasteClangASTContext::SetMetadata (clang::ASTContext *ast, 2206254721Semaste const void *object, 2207254721Semaste ClangASTMetadata &metadata) 2208254721Semaste{ 2209254721Semaste ClangExternalASTSourceCommon *external_source = 2210254721Semaste static_cast<ClangExternalASTSourceCommon*>(ast->getExternalSource()); 2211254721Semaste 2212254721Semaste if (external_source) 2213254721Semaste external_source->SetMetadata(object, metadata); 2214254721Semaste} 2215254721Semaste 2216254721SemasteClangASTMetadata * 2217254721SemasteClangASTContext::GetMetadata (clang::ASTContext *ast, 2218254721Semaste const void *object) 2219254721Semaste{ 2220254721Semaste ClangExternalASTSourceCommon *external_source = 2221254721Semaste static_cast<ClangExternalASTSourceCommon*>(ast->getExternalSource()); 2222254721Semaste 2223254721Semaste if (external_source && external_source->HasMetadata(object)) 2224254721Semaste return external_source->GetMetadata(object); 2225254721Semaste else 2226254721Semaste return NULL; 2227254721Semaste} 2228254721Semaste 2229254721Semasteclang::DeclContext * 2230254721SemasteClangASTContext::GetAsDeclContext (clang::CXXMethodDecl *cxx_method_decl) 2231254721Semaste{ 2232254721Semaste return llvm::dyn_cast<clang::DeclContext>(cxx_method_decl); 2233254721Semaste} 2234254721Semaste 2235254721Semasteclang::DeclContext * 2236254721SemasteClangASTContext::GetAsDeclContext (clang::ObjCMethodDecl *objc_method_decl) 2237254721Semaste{ 2238254721Semaste return llvm::dyn_cast<clang::DeclContext>(objc_method_decl); 2239254721Semaste} 2240254721Semaste 2241254721Semaste 2242254721Semastebool 2243254721SemasteClangASTContext::GetClassMethodInfoForDeclContext (clang::DeclContext *decl_ctx, 2244254721Semaste lldb::LanguageType &language, 2245254721Semaste bool &is_instance_method, 2246254721Semaste ConstString &language_object_name) 2247254721Semaste{ 2248254721Semaste language_object_name.Clear(); 2249254721Semaste language = eLanguageTypeUnknown; 2250254721Semaste is_instance_method = false; 2251254721Semaste 2252254721Semaste if (decl_ctx) 2253254721Semaste { 2254254721Semaste if (clang::CXXMethodDecl *method_decl = llvm::dyn_cast<clang::CXXMethodDecl>(decl_ctx)) 2255254721Semaste { 2256254721Semaste if (method_decl->isStatic()) 2257254721Semaste { 2258254721Semaste is_instance_method = false; 2259254721Semaste } 2260254721Semaste else 2261254721Semaste { 2262254721Semaste language_object_name.SetCString("this"); 2263254721Semaste is_instance_method = true; 2264254721Semaste } 2265254721Semaste language = eLanguageTypeC_plus_plus; 2266254721Semaste return true; 2267254721Semaste } 2268254721Semaste else if (clang::ObjCMethodDecl *method_decl = llvm::dyn_cast<clang::ObjCMethodDecl>(decl_ctx)) 2269254721Semaste { 2270254721Semaste // Both static and instance methods have a "self" object in objective C 2271254721Semaste language_object_name.SetCString("self"); 2272254721Semaste if (method_decl->isInstanceMethod()) 2273254721Semaste { 2274254721Semaste is_instance_method = true; 2275254721Semaste } 2276254721Semaste else 2277254721Semaste { 2278254721Semaste is_instance_method = false; 2279254721Semaste } 2280254721Semaste language = eLanguageTypeObjC; 2281254721Semaste return true; 2282254721Semaste } 2283254721Semaste else if (clang::FunctionDecl *function_decl = llvm::dyn_cast<clang::FunctionDecl>(decl_ctx)) 2284254721Semaste { 2285254721Semaste ClangASTMetadata *metadata = GetMetadata (&decl_ctx->getParentASTContext(), function_decl); 2286254721Semaste if (metadata && metadata->HasObjectPtr()) 2287254721Semaste { 2288254721Semaste language_object_name.SetCString (metadata->GetObjectPtrName()); 2289254721Semaste language = eLanguageTypeObjC; 2290254721Semaste is_instance_method = true; 2291254721Semaste } 2292254721Semaste return true; 2293254721Semaste } 2294254721Semaste } 2295254721Semaste return false; 2296254721Semaste} 2297254721Semaste 2298