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