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