diff options
Diffstat (limited to 'lldb/source/Symbol/ClangASTContext.cpp')
| -rw-r--r-- | lldb/source/Symbol/ClangASTContext.cpp | 18266 |
1 files changed, 9062 insertions, 9204 deletions
diff --git a/lldb/source/Symbol/ClangASTContext.cpp b/lldb/source/Symbol/ClangASTContext.cpp index 21cfeffdb18..e7fda6d4e8a 100644 --- a/lldb/source/Symbol/ClangASTContext.cpp +++ b/lldb/source/Symbol/ClangASTContext.cpp @@ -17,7 +17,7 @@ // Other libraries and framework includes -// Clang headers like to use NDEBUG inside of them to enable/disable debug +// Clang headers like to use NDEBUG inside of them to enable/disable debug // related features using "#ifndef NDEBUG" preprocessor blocks to do one thing // or another. This is bad because it means that if clang was built in release // mode, it assumes that you are building in release mode which is not always @@ -103,2350 +103,2072 @@ using namespace lldb_private; using namespace llvm; using namespace clang; -namespace -{ - static inline bool ClangASTContextSupportsLanguage (lldb::LanguageType language) - { - return language == eLanguageTypeUnknown || // Clang is the default type system - Language::LanguageIsC(language) || - Language::LanguageIsCPlusPlus(language) || - Language::LanguageIsObjC(language) || - Language::LanguageIsPascal(language) || - // Use Clang for Rust until there is a proper language plugin for it - language == eLanguageTypeRust || - language == eLanguageTypeExtRenderScript; - } +namespace { +static inline bool +ClangASTContextSupportsLanguage(lldb::LanguageType language) { + return language == eLanguageTypeUnknown || // Clang is the default type system + Language::LanguageIsC(language) || + Language::LanguageIsCPlusPlus(language) || + Language::LanguageIsObjC(language) || + Language::LanguageIsPascal(language) || + // Use Clang for Rust until there is a proper language plugin for it + language == eLanguageTypeRust || + language == eLanguageTypeExtRenderScript; +} } -typedef lldb_private::ThreadSafeDenseMap<clang::ASTContext *, ClangASTContext*> ClangASTMap; +typedef lldb_private::ThreadSafeDenseMap<clang::ASTContext *, ClangASTContext *> + ClangASTMap; -static ClangASTMap & -GetASTMap() -{ - static ClangASTMap *g_map_ptr = nullptr; - static std::once_flag g_once_flag; - std::call_once(g_once_flag, []() { - g_map_ptr = new ClangASTMap(); // leaked on purpose to avoid spins - }); - return *g_map_ptr; +static ClangASTMap &GetASTMap() { + static ClangASTMap *g_map_ptr = nullptr; + static std::once_flag g_once_flag; + std::call_once(g_once_flag, []() { + g_map_ptr = new ClangASTMap(); // leaked on purpose to avoid spins + }); + return *g_map_ptr; } -static bool -IsOperator(const char *name, clang::OverloadedOperatorKind &op_kind) -{ - if (name == nullptr || name[0] == '\0') - return false; +static bool IsOperator(const char *name, + clang::OverloadedOperatorKind &op_kind) { + if (name == nullptr || name[0] == '\0') + return false; #define OPERATOR_PREFIX "operator" #define OPERATOR_PREFIX_LENGTH (sizeof(OPERATOR_PREFIX) - 1) - const char *post_op_name = nullptr; + const char *post_op_name = nullptr; - bool no_space = true; + bool no_space = true; - if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH)) - return false; + if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH)) + return false; - post_op_name = name + OPERATOR_PREFIX_LENGTH; + post_op_name = name + OPERATOR_PREFIX_LENGTH; - if (post_op_name[0] == ' ') - { - post_op_name++; - no_space = false; - } + if (post_op_name[0] == ' ') { + post_op_name++; + no_space = false; + } #undef OPERATOR_PREFIX #undef OPERATOR_PREFIX_LENGTH - // This is an operator, set the overloaded operator kind to invalid - // in case this is a conversion operator... - op_kind = clang::NUM_OVERLOADED_OPERATORS; - - switch (post_op_name[0]) - { - default: - if (no_space) - return false; - break; - case 'n': - if (no_space) - return false; - if (strcmp(post_op_name, "new") == 0) - op_kind = clang::OO_New; - else if (strcmp(post_op_name, "new[]") == 0) - op_kind = clang::OO_Array_New; - break; - - case 'd': - if (no_space) - return false; - if (strcmp(post_op_name, "delete") == 0) - op_kind = clang::OO_Delete; - else if (strcmp(post_op_name, "delete[]") == 0) - op_kind = clang::OO_Array_Delete; - break; - - case '+': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Plus; - else if (post_op_name[2] == '\0') - { - if (post_op_name[1] == '=') - op_kind = clang::OO_PlusEqual; - else if (post_op_name[1] == '+') - op_kind = clang::OO_PlusPlus; - } - break; - - case '-': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Minus; - else if (post_op_name[2] == '\0') - { - switch (post_op_name[1]) - { - case '=': - op_kind = clang::OO_MinusEqual; - break; - case '-': - op_kind = clang::OO_MinusMinus; - break; - case '>': - op_kind = clang::OO_Arrow; - break; - } - } - else if (post_op_name[3] == '\0') - { - if (post_op_name[2] == '*') - op_kind = clang::OO_ArrowStar; - break; - } - break; + // This is an operator, set the overloaded operator kind to invalid + // in case this is a conversion operator... + op_kind = clang::NUM_OVERLOADED_OPERATORS; + + switch (post_op_name[0]) { + default: + if (no_space) + return false; + break; + case 'n': + if (no_space) + return false; + if (strcmp(post_op_name, "new") == 0) + op_kind = clang::OO_New; + else if (strcmp(post_op_name, "new[]") == 0) + op_kind = clang::OO_Array_New; + break; + + case 'd': + if (no_space) + return false; + if (strcmp(post_op_name, "delete") == 0) + op_kind = clang::OO_Delete; + else if (strcmp(post_op_name, "delete[]") == 0) + op_kind = clang::OO_Array_Delete; + break; + + case '+': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Plus; + else if (post_op_name[2] == '\0') { + if (post_op_name[1] == '=') + op_kind = clang::OO_PlusEqual; + else if (post_op_name[1] == '+') + op_kind = clang::OO_PlusPlus; + } + break; + + case '-': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Minus; + else if (post_op_name[2] == '\0') { + switch (post_op_name[1]) { + case '=': + op_kind = clang::OO_MinusEqual; + break; + case '-': + op_kind = clang::OO_MinusMinus; + break; + case '>': + op_kind = clang::OO_Arrow; + break; + } + } else if (post_op_name[3] == '\0') { + if (post_op_name[2] == '*') + op_kind = clang::OO_ArrowStar; + break; + } + break; + + case '*': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Star; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = clang::OO_StarEqual; + break; + + case '/': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Slash; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = clang::OO_SlashEqual; + break; + + case '%': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Percent; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = clang::OO_PercentEqual; + break; + + case '^': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Caret; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = clang::OO_CaretEqual; + break; + + case '&': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Amp; + else if (post_op_name[2] == '\0') { + switch (post_op_name[1]) { + case '=': + op_kind = clang::OO_AmpEqual; + break; + case '&': + op_kind = clang::OO_AmpAmp; + break; + } + } + break; - case '*': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Star; - else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = clang::OO_StarEqual; - break; + case '|': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Pipe; + else if (post_op_name[2] == '\0') { + switch (post_op_name[1]) { + case '=': + op_kind = clang::OO_PipeEqual; + break; + case '|': + op_kind = clang::OO_PipePipe; + break; + } + } + break; + + case '~': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Tilde; + break; + + case '!': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Exclaim; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = clang::OO_ExclaimEqual; + break; + + case '=': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Equal; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = clang::OO_EqualEqual; + break; + + case '<': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Less; + else if (post_op_name[2] == '\0') { + switch (post_op_name[1]) { + case '<': + op_kind = clang::OO_LessLess; + break; + case '=': + op_kind = clang::OO_LessEqual; + break; + } + } else if (post_op_name[3] == '\0') { + if (post_op_name[2] == '=') + op_kind = clang::OO_LessLessEqual; + } + break; + + case '>': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Greater; + else if (post_op_name[2] == '\0') { + switch (post_op_name[1]) { + case '>': + op_kind = clang::OO_GreaterGreater; + break; + case '=': + op_kind = clang::OO_GreaterEqual; + break; + } + } else if (post_op_name[1] == '>' && post_op_name[2] == '=' && + post_op_name[3] == '\0') { + op_kind = clang::OO_GreaterGreaterEqual; + } + break; - case '/': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Slash; - else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = clang::OO_SlashEqual; - break; + case ',': + if (post_op_name[1] == '\0') + op_kind = clang::OO_Comma; + break; - case '%': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Percent; - else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = clang::OO_PercentEqual; - break; + case '(': + if (post_op_name[1] == ')' && post_op_name[2] == '\0') + op_kind = clang::OO_Call; + break; - case '^': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Caret; - else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = clang::OO_CaretEqual; - break; + case '[': + if (post_op_name[1] == ']' && post_op_name[2] == '\0') + op_kind = clang::OO_Subscript; + break; + } - case '&': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Amp; - else if (post_op_name[2] == '\0') - { - switch (post_op_name[1]) - { - case '=': - op_kind = clang::OO_AmpEqual; - break; - case '&': - op_kind = clang::OO_AmpAmp; - break; - } - } - break; + return true; +} - case '|': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Pipe; - else if (post_op_name[2] == '\0') - { - switch (post_op_name[1]) - { - case '=': - op_kind = clang::OO_PipeEqual; - break; - case '|': - op_kind = clang::OO_PipePipe; - break; - } - } - break; +clang::AccessSpecifier +ClangASTContext::ConvertAccessTypeToAccessSpecifier(AccessType access) { + switch (access) { + default: + break; + case eAccessNone: + return AS_none; + case eAccessPublic: + return AS_public; + case eAccessPrivate: + return AS_private; + case eAccessProtected: + return AS_protected; + } + return AS_none; +} + +static void ParseLangArgs(LangOptions &Opts, InputKind IK, const char *triple) { + // FIXME: Cleanup per-file based stuff. + + // Set some properties which depend solely on the input kind; it would be nice + // to move these to the language standard, and have the driver resolve the + // input kind + language standard. + if (IK == IK_Asm) { + Opts.AsmPreprocessor = 1; + } else if (IK == IK_ObjC || IK == IK_ObjCXX || IK == IK_PreprocessedObjC || + IK == IK_PreprocessedObjCXX) { + Opts.ObjC1 = Opts.ObjC2 = 1; + } + + LangStandard::Kind LangStd = LangStandard::lang_unspecified; + + if (LangStd == LangStandard::lang_unspecified) { + // Based on the base language, pick one. + switch (IK) { + case IK_None: + case IK_AST: + case IK_LLVM_IR: + case IK_RenderScript: + assert(!"Invalid input kind!"); + case IK_OpenCL: + LangStd = LangStandard::lang_opencl; + break; + case IK_CUDA: + case IK_PreprocessedCuda: + LangStd = LangStandard::lang_cuda; + break; + case IK_Asm: + case IK_C: + case IK_PreprocessedC: + case IK_ObjC: + case IK_PreprocessedObjC: + LangStd = LangStandard::lang_gnu99; + break; + case IK_CXX: + case IK_PreprocessedCXX: + case IK_ObjCXX: + case IK_PreprocessedObjCXX: + LangStd = LangStandard::lang_gnucxx98; + break; + } + } + + const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd); + Opts.LineComment = Std.hasLineComments(); + Opts.C99 = Std.isC99(); + Opts.CPlusPlus = Std.isCPlusPlus(); + Opts.CPlusPlus11 = Std.isCPlusPlus11(); + Opts.Digraphs = Std.hasDigraphs(); + Opts.GNUMode = Std.isGNUMode(); + Opts.GNUInline = !Std.isC99(); + Opts.HexFloats = Std.hasHexFloats(); + Opts.ImplicitInt = Std.hasImplicitInt(); + + Opts.WChar = true; + + // OpenCL has some additional defaults. + if (LangStd == LangStandard::lang_opencl) { + Opts.OpenCL = 1; + Opts.AltiVec = 1; + Opts.CXXOperatorNames = 1; + Opts.LaxVectorConversions = 1; + } + + // OpenCL and C++ both have bool, true, false keywords. + Opts.Bool = Opts.OpenCL || Opts.CPlusPlus; + + // if (Opts.CPlusPlus) + // Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names); + // + // if (Args.hasArg(OPT_fobjc_gc_only)) + // Opts.setGCMode(LangOptions::GCOnly); + // else if (Args.hasArg(OPT_fobjc_gc)) + // Opts.setGCMode(LangOptions::HybridGC); + // + // if (Args.hasArg(OPT_print_ivar_layout)) + // Opts.ObjCGCBitmapPrint = 1; + // + // if (Args.hasArg(OPT_faltivec)) + // Opts.AltiVec = 1; + // + // if (Args.hasArg(OPT_pthread)) + // Opts.POSIXThreads = 1; + // + // llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility, + // "default"); + // if (Vis == "default") + Opts.setValueVisibilityMode(DefaultVisibility); + // else if (Vis == "hidden") + // Opts.setVisibilityMode(LangOptions::Hidden); + // else if (Vis == "protected") + // Opts.setVisibilityMode(LangOptions::Protected); + // else + // Diags.Report(diag::err_drv_invalid_value) + // << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis; + + // Opts.OverflowChecking = Args.hasArg(OPT_ftrapv); + + // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs + // is specified, or -std is set to a conforming mode. + Opts.Trigraphs = !Opts.GNUMode; + // if (Args.hasArg(OPT_trigraphs)) + // Opts.Trigraphs = 1; + // + // Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers, + // OPT_fno_dollars_in_identifiers, + // !Opts.AsmPreprocessor); + // Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings); + // Opts.Microsoft = Args.hasArg(OPT_fms_extensions); + // Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings); + // if (Args.hasArg(OPT_fno_lax_vector_conversions)) + // Opts.LaxVectorConversions = 0; + // Opts.Exceptions = Args.hasArg(OPT_fexceptions); + // Opts.RTTI = !Args.hasArg(OPT_fno_rtti); + // Opts.Blocks = Args.hasArg(OPT_fblocks); + Opts.CharIsSigned = ArchSpec(triple).CharIsSignedByDefault(); + // Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar); + // Opts.Freestanding = Args.hasArg(OPT_ffreestanding); + // Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding; + // Opts.AssumeSaneOperatorNew = + // !Args.hasArg(OPT_fno_assume_sane_operator_new); + // Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions); + // Opts.AccessControl = Args.hasArg(OPT_faccess_control); + // Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors); + // Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno); + // Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, + // 99, + // Diags); + // Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime); + // Opts.ObjCConstantStringClass = getLastArgValue(Args, + // OPT_fconstant_string_class); + // Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi); + // Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior); + // Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls); + // Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags); + // Opts.Static = Args.hasArg(OPT_static_define); + Opts.OptimizeSize = 0; + + // FIXME: Eliminate this dependency. + // unsigned Opt = + // Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags); + // Opts.Optimize = Opt != 0; + unsigned Opt = 0; + + // This is the __NO_INLINE__ define, which just depends on things like the + // optimization level and -fno-inline, not actually whether the backend has + // inlining enabled. + // + // FIXME: This is affected by other options (-fno-inline). + Opts.NoInlineDefine = !Opt; + + // unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags); + // switch (SSP) { + // default: + // Diags.Report(diag::err_drv_invalid_value) + // << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << + // SSP; + // break; + // case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break; + // case 1: Opts.setStackProtectorMode(LangOptions::SSPOn); break; + // case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break; + // } +} + +ClangASTContext::ClangASTContext(const char *target_triple) + : TypeSystem(TypeSystem::eKindClang), m_target_triple(), m_ast_ap(), + m_language_options_ap(), m_source_manager_ap(), m_diagnostics_engine_ap(), + m_target_options_rp(), m_target_info_ap(), m_identifier_table_ap(), + m_selector_table_ap(), m_builtins_ap(), m_callback_tag_decl(nullptr), + m_callback_objc_decl(nullptr), m_callback_baton(nullptr), + m_pointer_byte_size(0), m_ast_owned(false) { + if (target_triple && target_triple[0]) + SetTargetTriple(target_triple); +} - case '~': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Tilde; - break; +//---------------------------------------------------------------------- +// Destructor +//---------------------------------------------------------------------- +ClangASTContext::~ClangASTContext() { Finalize(); } + +ConstString ClangASTContext::GetPluginNameStatic() { + return ConstString("clang"); +} + +ConstString ClangASTContext::GetPluginName() { + return ClangASTContext::GetPluginNameStatic(); +} + +uint32_t ClangASTContext::GetPluginVersion() { return 1; } + +lldb::TypeSystemSP ClangASTContext::CreateInstance(lldb::LanguageType language, + lldb_private::Module *module, + Target *target) { + if (ClangASTContextSupportsLanguage(language)) { + ArchSpec arch; + if (module) + arch = module->GetArchitecture(); + else if (target) + arch = target->GetArchitecture(); + + if (arch.IsValid()) { + ArchSpec fixed_arch = arch; + // LLVM wants this to be set to iOS or MacOSX; if we're working on + // a bare-boards type image, change the triple for llvm's benefit. + if (fixed_arch.GetTriple().getVendor() == llvm::Triple::Apple && + fixed_arch.GetTriple().getOS() == llvm::Triple::UnknownOS) { + if (fixed_arch.GetTriple().getArch() == llvm::Triple::arm || + fixed_arch.GetTriple().getArch() == llvm::Triple::aarch64 || + fixed_arch.GetTriple().getArch() == llvm::Triple::thumb) { + fixed_arch.GetTriple().setOS(llvm::Triple::IOS); + } else { + fixed_arch.GetTriple().setOS(llvm::Triple::MacOSX); + } + } - case '!': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Exclaim; - else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = clang::OO_ExclaimEqual; - break; + if (module) { + std::shared_ptr<ClangASTContext> ast_sp(new ClangASTContext); + if (ast_sp) { + ast_sp->SetArchitecture(fixed_arch); + } + return ast_sp; + } else if (target && target->IsValid()) { + std::shared_ptr<ClangASTContextForExpressions> ast_sp( + new ClangASTContextForExpressions(*target)); + if (ast_sp) { + ast_sp->SetArchitecture(fixed_arch); + ast_sp->m_scratch_ast_source_ap.reset( + new ClangASTSource(target->shared_from_this())); + ast_sp->m_scratch_ast_source_ap->InstallASTContext( + ast_sp->getASTContext()); + llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> proxy_ast_source( + ast_sp->m_scratch_ast_source_ap->CreateProxy()); + ast_sp->SetExternalSource(proxy_ast_source); + return ast_sp; + } + } + } + } + return lldb::TypeSystemSP(); +} - case '=': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Equal; - else if (post_op_name[1] == '=' && post_op_name[2] == '\0') - op_kind = clang::OO_EqualEqual; - break; +void ClangASTContext::EnumerateSupportedLanguages( + std::set<lldb::LanguageType> &languages_for_types, + std::set<lldb::LanguageType> &languages_for_expressions) { + static std::vector<lldb::LanguageType> s_supported_languages_for_types( + {lldb::eLanguageTypeC89, lldb::eLanguageTypeC, lldb::eLanguageTypeC11, + lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeC99, + lldb::eLanguageTypeObjC, lldb::eLanguageTypeObjC_plus_plus, + lldb::eLanguageTypeC_plus_plus_03, lldb::eLanguageTypeC_plus_plus_11, + lldb::eLanguageTypeC11, lldb::eLanguageTypeC_plus_plus_14}); - case '<': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Less; - else if (post_op_name[2] == '\0') - { - switch (post_op_name[1]) - { - case '<': - op_kind = clang::OO_LessLess; - break; - case '=': - op_kind = clang::OO_LessEqual; - break; - } - } - else if (post_op_name[3] == '\0') - { - if (post_op_name[2] == '=') - op_kind = clang::OO_LessLessEqual; - } - break; + static std::vector<lldb::LanguageType> s_supported_languages_for_expressions( + {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC_plus_plus, + lldb::eLanguageTypeC_plus_plus_03, lldb::eLanguageTypeC_plus_plus_11, + lldb::eLanguageTypeC_plus_plus_14}); - case '>': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Greater; - else if (post_op_name[2] == '\0') - { - switch (post_op_name[1]) - { - case '>': - op_kind = clang::OO_GreaterGreater; - break; - case '=': - op_kind = clang::OO_GreaterEqual; - break; - } - } - else if (post_op_name[1] == '>' && post_op_name[2] == '=' && post_op_name[3] == '\0') - { - op_kind = clang::OO_GreaterGreaterEqual; - } - break; + languages_for_types.insert(s_supported_languages_for_types.begin(), + s_supported_languages_for_types.end()); + languages_for_expressions.insert( + s_supported_languages_for_expressions.begin(), + s_supported_languages_for_expressions.end()); +} - case ',': - if (post_op_name[1] == '\0') - op_kind = clang::OO_Comma; - break; +void ClangASTContext::Initialize() { + PluginManager::RegisterPlugin(GetPluginNameStatic(), + "clang base AST context plug-in", + CreateInstance, EnumerateSupportedLanguages); +} - case '(': - if (post_op_name[1] == ')' && post_op_name[2] == '\0') - op_kind = clang::OO_Call; - break; +void ClangASTContext::Terminate() { + PluginManager::UnregisterPlugin(CreateInstance); +} - case '[': - if (post_op_name[1] == ']' && post_op_name[2] == '\0') - op_kind = clang::OO_Subscript; - break; - } +void ClangASTContext::Finalize() { + if (m_ast_ap.get()) { + GetASTMap().Erase(m_ast_ap.get()); + if (!m_ast_owned) + m_ast_ap.release(); + } - return true; + m_builtins_ap.reset(); + m_selector_table_ap.reset(); + m_identifier_table_ap.reset(); + m_target_info_ap.reset(); + m_target_options_rp.reset(); + m_diagnostics_engine_ap.reset(); + m_source_manager_ap.reset(); + m_language_options_ap.reset(); + m_ast_ap.reset(); + m_scratch_ast_source_ap.reset(); } -clang::AccessSpecifier -ClangASTContext::ConvertAccessTypeToAccessSpecifier (AccessType access) -{ - switch (access) - { - default: break; - case eAccessNone: return AS_none; - case eAccessPublic: return AS_public; - case eAccessPrivate: return AS_private; - case eAccessProtected: return AS_protected; - } - return AS_none; +void ClangASTContext::Clear() { + m_ast_ap.reset(); + m_language_options_ap.reset(); + m_source_manager_ap.reset(); + m_diagnostics_engine_ap.reset(); + m_target_options_rp.reset(); + m_target_info_ap.reset(); + m_identifier_table_ap.reset(); + m_selector_table_ap.reset(); + m_builtins_ap.reset(); + m_pointer_byte_size = 0; } -static void -ParseLangArgs (LangOptions &Opts, InputKind IK, const char* triple) -{ - // FIXME: Cleanup per-file based stuff. - - // Set some properties which depend solely on the input kind; it would be nice - // to move these to the language standard, and have the driver resolve the - // input kind + language standard. - if (IK == IK_Asm) { - Opts.AsmPreprocessor = 1; - } else if (IK == IK_ObjC || - IK == IK_ObjCXX || - IK == IK_PreprocessedObjC || - IK == IK_PreprocessedObjCXX) { - Opts.ObjC1 = Opts.ObjC2 = 1; - } - - LangStandard::Kind LangStd = LangStandard::lang_unspecified; - - if (LangStd == LangStandard::lang_unspecified) { - // Based on the base language, pick one. - switch (IK) { - case IK_None: - case IK_AST: - case IK_LLVM_IR: - case IK_RenderScript: - assert (!"Invalid input kind!"); - case IK_OpenCL: - LangStd = LangStandard::lang_opencl; - break; - case IK_CUDA: - case IK_PreprocessedCuda: - LangStd = LangStandard::lang_cuda; - break; - case IK_Asm: - case IK_C: - case IK_PreprocessedC: - case IK_ObjC: - case IK_PreprocessedObjC: - LangStd = LangStandard::lang_gnu99; - break; - case IK_CXX: - case IK_PreprocessedCXX: - case IK_ObjCXX: - case IK_PreprocessedObjCXX: - LangStd = LangStandard::lang_gnucxx98; - break; - } - } - - const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd); - Opts.LineComment = Std.hasLineComments(); - Opts.C99 = Std.isC99(); - Opts.CPlusPlus = Std.isCPlusPlus(); - Opts.CPlusPlus11 = Std.isCPlusPlus11(); - Opts.Digraphs = Std.hasDigraphs(); - Opts.GNUMode = Std.isGNUMode(); - Opts.GNUInline = !Std.isC99(); - Opts.HexFloats = Std.hasHexFloats(); - Opts.ImplicitInt = Std.hasImplicitInt(); - - Opts.WChar = true; - - // OpenCL has some additional defaults. - if (LangStd == LangStandard::lang_opencl) { - Opts.OpenCL = 1; - Opts.AltiVec = 1; - Opts.CXXOperatorNames = 1; - Opts.LaxVectorConversions = 1; - } - - // OpenCL and C++ both have bool, true, false keywords. - Opts.Bool = Opts.OpenCL || Opts.CPlusPlus; - -// if (Opts.CPlusPlus) -// Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names); -// -// if (Args.hasArg(OPT_fobjc_gc_only)) -// Opts.setGCMode(LangOptions::GCOnly); -// else if (Args.hasArg(OPT_fobjc_gc)) -// Opts.setGCMode(LangOptions::HybridGC); -// -// if (Args.hasArg(OPT_print_ivar_layout)) -// Opts.ObjCGCBitmapPrint = 1; -// -// if (Args.hasArg(OPT_faltivec)) -// Opts.AltiVec = 1; -// -// if (Args.hasArg(OPT_pthread)) -// Opts.POSIXThreads = 1; -// -// llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility, -// "default"); -// if (Vis == "default") - Opts.setValueVisibilityMode(DefaultVisibility); -// else if (Vis == "hidden") -// Opts.setVisibilityMode(LangOptions::Hidden); -// else if (Vis == "protected") -// Opts.setVisibilityMode(LangOptions::Protected); -// else -// Diags.Report(diag::err_drv_invalid_value) -// << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis; - -// Opts.OverflowChecking = Args.hasArg(OPT_ftrapv); - - // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs - // is specified, or -std is set to a conforming mode. - Opts.Trigraphs = !Opts.GNUMode; -// if (Args.hasArg(OPT_trigraphs)) -// Opts.Trigraphs = 1; -// -// Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers, -// OPT_fno_dollars_in_identifiers, -// !Opts.AsmPreprocessor); -// Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings); -// Opts.Microsoft = Args.hasArg(OPT_fms_extensions); -// Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings); -// if (Args.hasArg(OPT_fno_lax_vector_conversions)) -// Opts.LaxVectorConversions = 0; -// Opts.Exceptions = Args.hasArg(OPT_fexceptions); -// Opts.RTTI = !Args.hasArg(OPT_fno_rtti); -// Opts.Blocks = Args.hasArg(OPT_fblocks); - Opts.CharIsSigned = ArchSpec(triple).CharIsSignedByDefault(); -// Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar); -// Opts.Freestanding = Args.hasArg(OPT_ffreestanding); -// Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding; -// Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new); -// Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions); -// Opts.AccessControl = Args.hasArg(OPT_faccess_control); -// Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors); -// Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno); -// Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99, -// Diags); -// Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime); -// Opts.ObjCConstantStringClass = getLastArgValue(Args, -// OPT_fconstant_string_class); -// Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi); -// Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior); -// Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls); -// Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags); -// Opts.Static = Args.hasArg(OPT_static_define); - Opts.OptimizeSize = 0; - - // FIXME: Eliminate this dependency. -// unsigned Opt = -// Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags); -// Opts.Optimize = Opt != 0; - unsigned Opt = 0; - - // This is the __NO_INLINE__ define, which just depends on things like the - // optimization level and -fno-inline, not actually whether the backend has - // inlining enabled. - // - // FIXME: This is affected by other options (-fno-inline). - Opts.NoInlineDefine = !Opt; - -// unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags); -// switch (SSP) { -// default: -// Diags.Report(diag::err_drv_invalid_value) -// << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP; -// break; -// case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break; -// case 1: Opts.setStackProtectorMode(LangOptions::SSPOn); break; -// case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break; -// } -} - - -ClangASTContext::ClangASTContext (const char *target_triple) : - TypeSystem (TypeSystem::eKindClang), - m_target_triple (), - m_ast_ap (), - m_language_options_ap (), - m_source_manager_ap (), - m_diagnostics_engine_ap (), - m_target_options_rp (), - m_target_info_ap (), - m_identifier_table_ap (), - m_selector_table_ap (), - m_builtins_ap (), - m_callback_tag_decl (nullptr), - m_callback_objc_decl (nullptr), - m_callback_baton (nullptr), - m_pointer_byte_size (0), - m_ast_owned (false) -{ - if (target_triple && target_triple[0]) - SetTargetTriple (target_triple); +const char *ClangASTContext::GetTargetTriple() { + return m_target_triple.c_str(); } -//---------------------------------------------------------------------- -// Destructor -//---------------------------------------------------------------------- -ClangASTContext::~ClangASTContext() -{ - Finalize(); +void ClangASTContext::SetTargetTriple(const char *target_triple) { + Clear(); + m_target_triple.assign(target_triple); } -ConstString -ClangASTContext::GetPluginNameStatic() -{ - return ConstString("clang"); +void ClangASTContext::SetArchitecture(const ArchSpec &arch) { + SetTargetTriple(arch.GetTriple().str().c_str()); } -ConstString -ClangASTContext::GetPluginName() -{ - return ClangASTContext::GetPluginNameStatic(); +bool ClangASTContext::HasExternalSource() { + ASTContext *ast = getASTContext(); + if (ast) + return ast->getExternalSource() != nullptr; + return false; } -uint32_t -ClangASTContext::GetPluginVersion() -{ - return 1; +void ClangASTContext::SetExternalSource( + llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_ap) { + ASTContext *ast = getASTContext(); + if (ast) { + ast->setExternalSource(ast_source_ap); + ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true); + // ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true); + } } -lldb::TypeSystemSP -ClangASTContext::CreateInstance (lldb::LanguageType language, - lldb_private::Module *module, - Target *target) -{ - if (ClangASTContextSupportsLanguage(language)) - { - ArchSpec arch; - if (module) - arch = module->GetArchitecture(); - else if (target) - arch = target->GetArchitecture(); - - if (arch.IsValid()) - { - ArchSpec fixed_arch = arch; - // LLVM wants this to be set to iOS or MacOSX; if we're working on - // a bare-boards type image, change the triple for llvm's benefit. - if (fixed_arch.GetTriple().getVendor() == llvm::Triple::Apple && - fixed_arch.GetTriple().getOS() == llvm::Triple::UnknownOS) - { - if (fixed_arch.GetTriple().getArch() == llvm::Triple::arm || - fixed_arch.GetTriple().getArch() == llvm::Triple::aarch64 || - fixed_arch.GetTriple().getArch() == llvm::Triple::thumb) - { - fixed_arch.GetTriple().setOS(llvm::Triple::IOS); - } - else - { - fixed_arch.GetTriple().setOS(llvm::Triple::MacOSX); - } - } +void ClangASTContext::RemoveExternalSource() { + ASTContext *ast = getASTContext(); - if (module) - { - std::shared_ptr<ClangASTContext> ast_sp(new ClangASTContext); - if (ast_sp) - { - ast_sp->SetArchitecture (fixed_arch); - } - return ast_sp; - } - else if (target && target->IsValid()) - { - std::shared_ptr<ClangASTContextForExpressions> ast_sp(new ClangASTContextForExpressions(*target)); - if (ast_sp) - { - ast_sp->SetArchitecture(fixed_arch); - ast_sp->m_scratch_ast_source_ap.reset (new ClangASTSource(target->shared_from_this())); - ast_sp->m_scratch_ast_source_ap->InstallASTContext(ast_sp->getASTContext()); - llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> proxy_ast_source(ast_sp->m_scratch_ast_source_ap->CreateProxy()); - ast_sp->SetExternalSource(proxy_ast_source); - return ast_sp; - } - } - } - } - return lldb::TypeSystemSP(); -} - -void -ClangASTContext::EnumerateSupportedLanguages(std::set<lldb::LanguageType> &languages_for_types, std::set<lldb::LanguageType> &languages_for_expressions) -{ - static std::vector<lldb::LanguageType> s_supported_languages_for_types({ - lldb::eLanguageTypeC89, - lldb::eLanguageTypeC, - lldb::eLanguageTypeC11, - lldb::eLanguageTypeC_plus_plus, - lldb::eLanguageTypeC99, - lldb::eLanguageTypeObjC, - lldb::eLanguageTypeObjC_plus_plus, - lldb::eLanguageTypeC_plus_plus_03, - lldb::eLanguageTypeC_plus_plus_11, - lldb::eLanguageTypeC11, - lldb::eLanguageTypeC_plus_plus_14}); - - static std::vector<lldb::LanguageType> s_supported_languages_for_expressions({ - lldb::eLanguageTypeC_plus_plus, - lldb::eLanguageTypeObjC_plus_plus, - lldb::eLanguageTypeC_plus_plus_03, - lldb::eLanguageTypeC_plus_plus_11, - lldb::eLanguageTypeC_plus_plus_14}); - - languages_for_types.insert(s_supported_languages_for_types.begin(), s_supported_languages_for_types.end()); - languages_for_expressions.insert(s_supported_languages_for_expressions.begin(), s_supported_languages_for_expressions.end()); -} - - -void -ClangASTContext::Initialize() -{ - PluginManager::RegisterPlugin (GetPluginNameStatic(), - "clang base AST context plug-in", - CreateInstance, - EnumerateSupportedLanguages); -} - -void -ClangASTContext::Terminate() -{ - PluginManager::UnregisterPlugin (CreateInstance); -} - -void -ClangASTContext::Finalize() -{ - if (m_ast_ap.get()) - { - GetASTMap().Erase(m_ast_ap.get()); - if (!m_ast_owned) - m_ast_ap.release(); - } - - m_builtins_ap.reset(); - m_selector_table_ap.reset(); - m_identifier_table_ap.reset(); - m_target_info_ap.reset(); - m_target_options_rp.reset(); - m_diagnostics_engine_ap.reset(); - m_source_manager_ap.reset(); - m_language_options_ap.reset(); - m_ast_ap.reset(); - m_scratch_ast_source_ap.reset(); -} - -void -ClangASTContext::Clear() -{ - m_ast_ap.reset(); - m_language_options_ap.reset(); - m_source_manager_ap.reset(); - m_diagnostics_engine_ap.reset(); - m_target_options_rp.reset(); - m_target_info_ap.reset(); - m_identifier_table_ap.reset(); - m_selector_table_ap.reset(); - m_builtins_ap.reset(); - m_pointer_byte_size = 0; -} - -const char * -ClangASTContext::GetTargetTriple () -{ - return m_target_triple.c_str(); -} - -void -ClangASTContext::SetTargetTriple (const char *target_triple) -{ - Clear(); - m_target_triple.assign(target_triple); -} - -void -ClangASTContext::SetArchitecture (const ArchSpec &arch) -{ - SetTargetTriple(arch.GetTriple().str().c_str()); -} - -bool -ClangASTContext::HasExternalSource () -{ - ASTContext *ast = getASTContext(); - if (ast) - return ast->getExternalSource () != nullptr; - return false; + if (ast) { + llvm::IntrusiveRefCntPtr<ExternalASTSource> empty_ast_source_ap; + ast->setExternalSource(empty_ast_source_ap); + ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false); + // ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false); + } } -void -ClangASTContext::SetExternalSource (llvm::IntrusiveRefCntPtr<ExternalASTSource> &ast_source_ap) -{ - ASTContext *ast = getASTContext(); - if (ast) - { - ast->setExternalSource (ast_source_ap); - ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true); - //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true); - } +void ClangASTContext::setASTContext(clang::ASTContext *ast_ctx) { + if (!m_ast_owned) { + m_ast_ap.release(); + } + m_ast_owned = false; + m_ast_ap.reset(ast_ctx); + GetASTMap().Insert(ast_ctx, this); } -void -ClangASTContext::RemoveExternalSource () -{ - ASTContext *ast = getASTContext(); - - if (ast) - { - llvm::IntrusiveRefCntPtr<ExternalASTSource> empty_ast_source_ap; - ast->setExternalSource (empty_ast_source_ap); - ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false); - //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false); - } -} - -void -ClangASTContext::setASTContext(clang::ASTContext *ast_ctx) -{ - if (!m_ast_owned) { - m_ast_ap.release(); - } - m_ast_owned = false; - m_ast_ap.reset(ast_ctx); - GetASTMap().Insert(ast_ctx, this); -} - -ASTContext * -ClangASTContext::getASTContext() -{ - if (m_ast_ap.get() == nullptr) - { - m_ast_owned = true; - m_ast_ap.reset(new ASTContext (*getLanguageOptions(), - *getSourceManager(), - *getIdentifierTable(), - *getSelectorTable(), - *getBuiltinContext())); - - m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false); - - // This can be NULL if we don't know anything about the architecture or if the - // target for an architecture isn't enabled in the llvm/clang that we built - TargetInfo *target_info = getTargetInfo(); - if (target_info) - m_ast_ap->InitBuiltinTypes(*target_info); - - if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton) - { - m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage(); - //m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage(); - } - - GetASTMap().Insert(m_ast_ap.get(), this); +ASTContext *ClangASTContext::getASTContext() { + if (m_ast_ap.get() == nullptr) { + m_ast_owned = true; + m_ast_ap.reset(new ASTContext(*getLanguageOptions(), *getSourceManager(), + *getIdentifierTable(), *getSelectorTable(), + *getBuiltinContext())); + + m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false); - llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_ap (new ClangExternalASTSourceCallbacks (ClangASTContext::CompleteTagDecl, - ClangASTContext::CompleteObjCInterfaceDecl, - nullptr, - ClangASTContext::LayoutRecordType, - this)); - SetExternalSource (ast_source_ap); + // This can be NULL if we don't know anything about the architecture or if + // the + // target for an architecture isn't enabled in the llvm/clang that we built + TargetInfo *target_info = getTargetInfo(); + if (target_info) + m_ast_ap->InitBuiltinTypes(*target_info); + + if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton) { + m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage(); + // m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage(); } - return m_ast_ap.get(); + + GetASTMap().Insert(m_ast_ap.get(), this); + + llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> ast_source_ap( + new ClangExternalASTSourceCallbacks( + ClangASTContext::CompleteTagDecl, + ClangASTContext::CompleteObjCInterfaceDecl, nullptr, + ClangASTContext::LayoutRecordType, this)); + SetExternalSource(ast_source_ap); + } + return m_ast_ap.get(); } -ClangASTContext* -ClangASTContext::GetASTContext (clang::ASTContext* ast) -{ - ClangASTContext *clang_ast = GetASTMap().Lookup(ast); - return clang_ast; +ClangASTContext *ClangASTContext::GetASTContext(clang::ASTContext *ast) { + ClangASTContext *clang_ast = GetASTMap().Lookup(ast); + return clang_ast; } -Builtin::Context * -ClangASTContext::getBuiltinContext() -{ - if (m_builtins_ap.get() == nullptr) - m_builtins_ap.reset (new Builtin::Context()); - return m_builtins_ap.get(); +Builtin::Context *ClangASTContext::getBuiltinContext() { + if (m_builtins_ap.get() == nullptr) + m_builtins_ap.reset(new Builtin::Context()); + return m_builtins_ap.get(); } -IdentifierTable * -ClangASTContext::getIdentifierTable() -{ - if (m_identifier_table_ap.get() == nullptr) - m_identifier_table_ap.reset(new IdentifierTable (*ClangASTContext::getLanguageOptions(), nullptr)); - return m_identifier_table_ap.get(); +IdentifierTable *ClangASTContext::getIdentifierTable() { + if (m_identifier_table_ap.get() == nullptr) + m_identifier_table_ap.reset( + new IdentifierTable(*ClangASTContext::getLanguageOptions(), nullptr)); + return m_identifier_table_ap.get(); } -LangOptions * -ClangASTContext::getLanguageOptions() -{ - if (m_language_options_ap.get() == nullptr) - { - m_language_options_ap.reset(new LangOptions()); - ParseLangArgs(*m_language_options_ap, IK_ObjCXX, GetTargetTriple()); -// InitializeLangOptions(*m_language_options_ap, IK_ObjCXX); - } - return m_language_options_ap.get(); +LangOptions *ClangASTContext::getLanguageOptions() { + if (m_language_options_ap.get() == nullptr) { + m_language_options_ap.reset(new LangOptions()); + ParseLangArgs(*m_language_options_ap, IK_ObjCXX, GetTargetTriple()); + // InitializeLangOptions(*m_language_options_ap, IK_ObjCXX); + } + return m_language_options_ap.get(); } -SelectorTable * -ClangASTContext::getSelectorTable() -{ - if (m_selector_table_ap.get() == nullptr) - m_selector_table_ap.reset (new SelectorTable()); - return m_selector_table_ap.get(); +SelectorTable *ClangASTContext::getSelectorTable() { + if (m_selector_table_ap.get() == nullptr) + m_selector_table_ap.reset(new SelectorTable()); + return m_selector_table_ap.get(); } -clang::FileManager * -ClangASTContext::getFileManager() -{ - if (m_file_manager_ap.get() == nullptr) - { - clang::FileSystemOptions file_system_options; - m_file_manager_ap.reset(new clang::FileManager(file_system_options)); - } - return m_file_manager_ap.get(); +clang::FileManager *ClangASTContext::getFileManager() { + if (m_file_manager_ap.get() == nullptr) { + clang::FileSystemOptions file_system_options; + m_file_manager_ap.reset(new clang::FileManager(file_system_options)); + } + return m_file_manager_ap.get(); } -clang::SourceManager * -ClangASTContext::getSourceManager() -{ - if (m_source_manager_ap.get() == nullptr) - m_source_manager_ap.reset(new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager())); - return m_source_manager_ap.get(); +clang::SourceManager *ClangASTContext::getSourceManager() { + if (m_source_manager_ap.get() == nullptr) + m_source_manager_ap.reset( + new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager())); + return m_source_manager_ap.get(); } -clang::DiagnosticsEngine * -ClangASTContext::getDiagnosticsEngine() -{ - if (m_diagnostics_engine_ap.get() == nullptr) - { - llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs()); - m_diagnostics_engine_ap.reset(new DiagnosticsEngine(diag_id_sp, new DiagnosticOptions())); - } - return m_diagnostics_engine_ap.get(); +clang::DiagnosticsEngine *ClangASTContext::getDiagnosticsEngine() { + if (m_diagnostics_engine_ap.get() == nullptr) { + llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs()); + m_diagnostics_engine_ap.reset( + new DiagnosticsEngine(diag_id_sp, new DiagnosticOptions())); + } + return m_diagnostics_engine_ap.get(); } -clang::MangleContext * -ClangASTContext::getMangleContext() -{ - if (m_mangle_ctx_ap.get() == nullptr) - m_mangle_ctx_ap.reset (getASTContext()->createMangleContext()); - return m_mangle_ctx_ap.get(); +clang::MangleContext *ClangASTContext::getMangleContext() { + if (m_mangle_ctx_ap.get() == nullptr) + m_mangle_ctx_ap.reset(getASTContext()->createMangleContext()); + return m_mangle_ctx_ap.get(); } -class NullDiagnosticConsumer : public DiagnosticConsumer -{ +class NullDiagnosticConsumer : public DiagnosticConsumer { public: - NullDiagnosticConsumer () - { - m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS); - } - - void - HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const clang::Diagnostic &info) - { - if (m_log) - { - llvm::SmallVector<char, 32> diag_str(10); - info.FormatDiagnostic(diag_str); - diag_str.push_back('\0'); - m_log->Printf("Compiler diagnostic: %s\n", diag_str.data()); - } - } - - DiagnosticConsumer *clone (DiagnosticsEngine &Diags) const - { - return new NullDiagnosticConsumer (); + NullDiagnosticConsumer() { + m_log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS); + } + + void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, + const clang::Diagnostic &info) { + if (m_log) { + llvm::SmallVector<char, 32> diag_str(10); + info.FormatDiagnostic(diag_str); + diag_str.push_back('\0'); + m_log->Printf("Compiler diagnostic: %s\n", diag_str.data()); } + } + + DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const { + return new NullDiagnosticConsumer(); + } + private: - Log * m_log; + Log *m_log; }; -DiagnosticConsumer * -ClangASTContext::getDiagnosticConsumer() -{ - if (m_diagnostic_consumer_ap.get() == nullptr) - m_diagnostic_consumer_ap.reset(new NullDiagnosticConsumer); - - return m_diagnostic_consumer_ap.get(); -} +DiagnosticConsumer *ClangASTContext::getDiagnosticConsumer() { + if (m_diagnostic_consumer_ap.get() == nullptr) + m_diagnostic_consumer_ap.reset(new NullDiagnosticConsumer); -std::shared_ptr<clang::TargetOptions> & -ClangASTContext::getTargetOptions() { - if (m_target_options_rp.get() == nullptr && !m_target_triple.empty()) - { - m_target_options_rp = std::make_shared<clang::TargetOptions>(); - if (m_target_options_rp.get() != nullptr) - m_target_options_rp->Triple = m_target_triple; - } - return m_target_options_rp; + return m_diagnostic_consumer_ap.get(); } +std::shared_ptr<clang::TargetOptions> &ClangASTContext::getTargetOptions() { + if (m_target_options_rp.get() == nullptr && !m_target_triple.empty()) { + m_target_options_rp = std::make_shared<clang::TargetOptions>(); + if (m_target_options_rp.get() != nullptr) + m_target_options_rp->Triple = m_target_triple; + } + return m_target_options_rp; +} -TargetInfo * -ClangASTContext::getTargetInfo() -{ - // target_triple should be something like "x86_64-apple-macosx" - if (m_target_info_ap.get() == nullptr && !m_target_triple.empty()) - m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), getTargetOptions())); - return m_target_info_ap.get(); +TargetInfo *ClangASTContext::getTargetInfo() { + // target_triple should be something like "x86_64-apple-macosx" + if (m_target_info_ap.get() == nullptr && !m_target_triple.empty()) + m_target_info_ap.reset(TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), + getTargetOptions())); + return m_target_info_ap.get(); } #pragma mark Basic Types -static inline bool -QualTypeMatchesBitSize(const uint64_t bit_size, ASTContext *ast, QualType qual_type) -{ - uint64_t qual_type_bit_size = ast->getTypeSize(qual_type); - if (qual_type_bit_size == bit_size) - return true; - return false; +static inline bool QualTypeMatchesBitSize(const uint64_t bit_size, + ASTContext *ast, QualType qual_type) { + uint64_t qual_type_bit_size = ast->getTypeSize(qual_type); + if (qual_type_bit_size == bit_size) + return true; + return false; } CompilerType -ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, size_t bit_size) -{ - return ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (getASTContext(), encoding, bit_size); +ClangASTContext::GetBuiltinTypeForEncodingAndBitSize(Encoding encoding, + size_t bit_size) { + return ClangASTContext::GetBuiltinTypeForEncodingAndBitSize( + getASTContext(), encoding, bit_size); } -CompilerType -ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast, Encoding encoding, uint32_t bit_size) -{ - if (!ast) - return CompilerType(); - switch (encoding) - { - case eEncodingInvalid: - if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy)) - return CompilerType (ast, ast->VoidPtrTy); - break; - - case eEncodingUint: - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) - return CompilerType (ast, ast->UnsignedCharTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) - return CompilerType (ast, ast->UnsignedShortTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) - return CompilerType (ast, ast->UnsignedIntTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) - return CompilerType (ast, ast->UnsignedLongTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) - return CompilerType (ast, ast->UnsignedLongLongTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) - return CompilerType (ast, ast->UnsignedInt128Ty); - break; - - case eEncodingSint: - if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) - return CompilerType (ast, ast->SignedCharTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) - return CompilerType (ast, ast->ShortTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) - return CompilerType (ast, ast->IntTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) - return CompilerType (ast, ast->LongTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) - return CompilerType (ast, ast->LongLongTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) - return CompilerType (ast, ast->Int128Ty); - break; - - case eEncodingIEEE754: - if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy)) - return CompilerType (ast, ast->FloatTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy)) - return CompilerType (ast, ast->DoubleTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy)) - return CompilerType (ast, ast->LongDoubleTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->HalfTy)) - return CompilerType (ast, ast->HalfTy); - break; - - case eEncodingVector: - // Sanity check that bit_size is a multiple of 8's. - if (bit_size && !(bit_size & 0x7u)) - return CompilerType (ast, ast->getExtVectorType (ast->UnsignedCharTy, bit_size/8)); - break; - } - +CompilerType ClangASTContext::GetBuiltinTypeForEncodingAndBitSize( + ASTContext *ast, Encoding encoding, uint32_t bit_size) { + if (!ast) return CompilerType(); + switch (encoding) { + case eEncodingInvalid: + if (QualTypeMatchesBitSize(bit_size, ast, ast->VoidPtrTy)) + return CompilerType(ast, ast->VoidPtrTy); + break; + + case eEncodingUint: + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy)) + return CompilerType(ast, ast->UnsignedCharTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy)) + return CompilerType(ast, ast->UnsignedShortTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy)) + return CompilerType(ast, ast->UnsignedIntTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongTy)) + return CompilerType(ast, ast->UnsignedLongTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongLongTy)) + return CompilerType(ast, ast->UnsignedLongLongTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedInt128Ty)) + return CompilerType(ast, ast->UnsignedInt128Ty); + break; + + case eEncodingSint: + if (QualTypeMatchesBitSize(bit_size, ast, ast->SignedCharTy)) + return CompilerType(ast, ast->SignedCharTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->ShortTy)) + return CompilerType(ast, ast->ShortTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->IntTy)) + return CompilerType(ast, ast->IntTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->LongTy)) + return CompilerType(ast, ast->LongTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->LongLongTy)) + return CompilerType(ast, ast->LongLongTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->Int128Ty)) + return CompilerType(ast, ast->Int128Ty); + break; + + case eEncodingIEEE754: + if (QualTypeMatchesBitSize(bit_size, ast, ast->FloatTy)) + return CompilerType(ast, ast->FloatTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->DoubleTy)) + return CompilerType(ast, ast->DoubleTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleTy)) + return CompilerType(ast, ast->LongDoubleTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->HalfTy)) + return CompilerType(ast, ast->HalfTy); + break; + + case eEncodingVector: + // Sanity check that bit_size is a multiple of 8's. + if (bit_size && !(bit_size & 0x7u)) + return CompilerType( + ast, ast->getExtVectorType(ast->UnsignedCharTy, bit_size / 8)); + break; + } + + return CompilerType(); } - - lldb::BasicType -ClangASTContext::GetBasicTypeEnumeration (const ConstString &name) -{ - if (name) - { - typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap; - static TypeNameToBasicTypeMap g_type_map; - static std::once_flag g_once_flag; - std::call_once(g_once_flag, [](){ - // "void" - g_type_map.Append(ConstString("void").GetCString(), eBasicTypeVoid); - - // "char" - g_type_map.Append(ConstString("char").GetCString(), eBasicTypeChar); - g_type_map.Append(ConstString("signed char").GetCString(), eBasicTypeSignedChar); - g_type_map.Append(ConstString("unsigned char").GetCString(), eBasicTypeUnsignedChar); - g_type_map.Append(ConstString("wchar_t").GetCString(), eBasicTypeWChar); - g_type_map.Append(ConstString("signed wchar_t").GetCString(), eBasicTypeSignedWChar); - g_type_map.Append(ConstString("unsigned wchar_t").GetCString(), eBasicTypeUnsignedWChar); - // "short" - g_type_map.Append(ConstString("short").GetCString(), eBasicTypeShort); - g_type_map.Append(ConstString("short int").GetCString(), eBasicTypeShort); - g_type_map.Append(ConstString("unsigned short").GetCString(), eBasicTypeUnsignedShort); - g_type_map.Append(ConstString("unsigned short int").GetCString(), eBasicTypeUnsignedShort); - - // "int" - g_type_map.Append(ConstString("int").GetCString(), eBasicTypeInt); - g_type_map.Append(ConstString("signed int").GetCString(), eBasicTypeInt); - g_type_map.Append(ConstString("unsigned int").GetCString(), eBasicTypeUnsignedInt); - g_type_map.Append(ConstString("unsigned").GetCString(), eBasicTypeUnsignedInt); - - // "long" - g_type_map.Append(ConstString("long").GetCString(), eBasicTypeLong); - g_type_map.Append(ConstString("long int").GetCString(), eBasicTypeLong); - g_type_map.Append(ConstString("unsigned long").GetCString(), eBasicTypeUnsignedLong); - g_type_map.Append(ConstString("unsigned long int").GetCString(), eBasicTypeUnsignedLong); - - // "long long" - g_type_map.Append(ConstString("long long").GetCString(), eBasicTypeLongLong); - g_type_map.Append(ConstString("long long int").GetCString(), eBasicTypeLongLong); - g_type_map.Append(ConstString("unsigned long long").GetCString(), eBasicTypeUnsignedLongLong); - g_type_map.Append(ConstString("unsigned long long int").GetCString(), eBasicTypeUnsignedLongLong); - - // "int128" - g_type_map.Append(ConstString("__int128_t").GetCString(), eBasicTypeInt128); - g_type_map.Append(ConstString("__uint128_t").GetCString(), eBasicTypeUnsignedInt128); - - // Miscellaneous - g_type_map.Append(ConstString("bool").GetCString(), eBasicTypeBool); - g_type_map.Append(ConstString("float").GetCString(), eBasicTypeFloat); - g_type_map.Append(ConstString("double").GetCString(), eBasicTypeDouble); - g_type_map.Append(ConstString("long double").GetCString(), eBasicTypeLongDouble); - g_type_map.Append(ConstString("id").GetCString(), eBasicTypeObjCID); - g_type_map.Append(ConstString("SEL").GetCString(), eBasicTypeObjCSel); - g_type_map.Append(ConstString("nullptr").GetCString(), eBasicTypeNullPtr); - g_type_map.Sort(); - }); - - return g_type_map.Find(name.GetCString(), eBasicTypeInvalid); - } - return eBasicTypeInvalid; -} +ClangASTContext::GetBasicTypeEnumeration(const ConstString &name) { + if (name) { + typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap; + static TypeNameToBasicTypeMap g_type_map; + static std::once_flag g_once_flag; + std::call_once(g_once_flag, []() { + // "void" + g_type_map.Append(ConstString("void").GetCString(), eBasicTypeVoid); + + // "char" + g_type_map.Append(ConstString("char").GetCString(), eBasicTypeChar); + g_type_map.Append(ConstString("signed char").GetCString(), + eBasicTypeSignedChar); + g_type_map.Append(ConstString("unsigned char").GetCString(), + eBasicTypeUnsignedChar); + g_type_map.Append(ConstString("wchar_t").GetCString(), eBasicTypeWChar); + g_type_map.Append(ConstString("signed wchar_t").GetCString(), + eBasicTypeSignedWChar); + g_type_map.Append(ConstString("unsigned wchar_t").GetCString(), + eBasicTypeUnsignedWChar); + // "short" + g_type_map.Append(ConstString("short").GetCString(), eBasicTypeShort); + g_type_map.Append(ConstString("short int").GetCString(), eBasicTypeShort); + g_type_map.Append(ConstString("unsigned short").GetCString(), + eBasicTypeUnsignedShort); + g_type_map.Append(ConstString("unsigned short int").GetCString(), + eBasicTypeUnsignedShort); + + // "int" + g_type_map.Append(ConstString("int").GetCString(), eBasicTypeInt); + g_type_map.Append(ConstString("signed int").GetCString(), eBasicTypeInt); + g_type_map.Append(ConstString("unsigned int").GetCString(), + eBasicTypeUnsignedInt); + g_type_map.Append(ConstString("unsigned").GetCString(), + eBasicTypeUnsignedInt); + + // "long" + g_type_map.Append(ConstString("long").GetCString(), eBasicTypeLong); + g_type_map.Append(ConstString("long int").GetCString(), eBasicTypeLong); + g_type_map.Append(ConstString("unsigned long").GetCString(), + eBasicTypeUnsignedLong); + g_type_map.Append(ConstString("unsigned long int").GetCString(), + eBasicTypeUnsignedLong); + + // "long long" + g_type_map.Append(ConstString("long long").GetCString(), + eBasicTypeLongLong); + g_type_map.Append(ConstString("long long int").GetCString(), + eBasicTypeLongLong); + g_type_map.Append(ConstString("unsigned long long").GetCString(), + eBasicTypeUnsignedLongLong); + g_type_map.Append(ConstString("unsigned long long int").GetCString(), + eBasicTypeUnsignedLongLong); + + // "int128" + g_type_map.Append(ConstString("__int128_t").GetCString(), + eBasicTypeInt128); + g_type_map.Append(ConstString("__uint128_t").GetCString(), + eBasicTypeUnsignedInt128); + + // Miscellaneous + g_type_map.Append(ConstString("bool").GetCString(), eBasicTypeBool); + g_type_map.Append(ConstString("float").GetCString(), eBasicTypeFloat); + g_type_map.Append(ConstString("double").GetCString(), eBasicTypeDouble); + g_type_map.Append(ConstString("long double").GetCString(), + eBasicTypeLongDouble); + g_type_map.Append(ConstString("id").GetCString(), eBasicTypeObjCID); + g_type_map.Append(ConstString("SEL").GetCString(), eBasicTypeObjCSel); + g_type_map.Append(ConstString("nullptr").GetCString(), eBasicTypeNullPtr); + g_type_map.Sort(); + }); -CompilerType -ClangASTContext::GetBasicType (ASTContext *ast, const ConstString &name) -{ - if (ast) - { - lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration (name); - return ClangASTContext::GetBasicType (ast, basic_type); - } - return CompilerType(); + return g_type_map.Find(name.GetCString(), eBasicTypeInvalid); + } + return eBasicTypeInvalid; } -uint32_t -ClangASTContext::GetPointerByteSize () -{ - if (m_pointer_byte_size == 0) - m_pointer_byte_size = GetBasicType(lldb::eBasicTypeVoid).GetPointerType().GetByteSize(nullptr); - return m_pointer_byte_size; +CompilerType ClangASTContext::GetBasicType(ASTContext *ast, + const ConstString &name) { + if (ast) { + lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration(name); + return ClangASTContext::GetBasicType(ast, basic_type); + } + return CompilerType(); } -CompilerType -ClangASTContext::GetBasicType (lldb::BasicType basic_type) -{ - return GetBasicType (getASTContext(), basic_type); +uint32_t ClangASTContext::GetPointerByteSize() { + if (m_pointer_byte_size == 0) + m_pointer_byte_size = GetBasicType(lldb::eBasicTypeVoid) + .GetPointerType() + .GetByteSize(nullptr); + return m_pointer_byte_size; } -CompilerType -ClangASTContext::GetBasicType (ASTContext *ast, lldb::BasicType basic_type) -{ - if (!ast) - return CompilerType(); - lldb::opaque_compiler_type_t clang_type = GetOpaqueCompilerType(ast, basic_type); - - if (clang_type) - return CompilerType(GetASTContext(ast), clang_type); - return CompilerType(); +CompilerType ClangASTContext::GetBasicType(lldb::BasicType basic_type) { + return GetBasicType(getASTContext(), basic_type); } +CompilerType ClangASTContext::GetBasicType(ASTContext *ast, + lldb::BasicType basic_type) { + if (!ast) + return CompilerType(); + lldb::opaque_compiler_type_t clang_type = + GetOpaqueCompilerType(ast, basic_type); -CompilerType -ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size) -{ - ASTContext *ast = getASTContext(); - -#define streq(a,b) strcmp(a,b) == 0 - assert (ast != nullptr); - if (ast) - { - switch (dw_ate) - { - default: - break; - - case DW_ATE_address: - if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy)) - return CompilerType (ast, ast->VoidPtrTy); - break; - - case DW_ATE_boolean: - if (QualTypeMatchesBitSize (bit_size, ast, ast->BoolTy)) - return CompilerType (ast, ast->BoolTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) - return CompilerType (ast, ast->UnsignedCharTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) - return CompilerType (ast, ast->UnsignedShortTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) - return CompilerType (ast, ast->UnsignedIntTy); - break; - - case DW_ATE_lo_user: - // This has been seen to mean DW_AT_complex_integer - if (type_name) - { - if (::strstr(type_name, "complex")) - { - CompilerType complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2); - return CompilerType(ast, ast->getComplexType(ClangUtil::GetQualType(complex_int_clang_type))); - } - } - break; - - case DW_ATE_complex_float: - if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy)) - return CompilerType (ast, ast->FloatComplexTy); - else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy)) - return CompilerType (ast, ast->DoubleComplexTy); - else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy)) - return CompilerType (ast, ast->LongDoubleComplexTy); - else - { - CompilerType complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2); - return CompilerType(ast, ast->getComplexType(ClangUtil::GetQualType(complex_float_clang_type))); - } - break; - - case DW_ATE_float: - if (streq(type_name, "float") && QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy)) - return CompilerType (ast, ast->FloatTy); - if (streq(type_name, "double") && QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy)) - return CompilerType (ast, ast->DoubleTy); - if (streq(type_name, "long double") && QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy)) - return CompilerType (ast, ast->LongDoubleTy); - // Fall back to not requiring a name match - if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy)) - return CompilerType (ast, ast->FloatTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy)) - return CompilerType (ast, ast->DoubleTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy)) - return CompilerType (ast, ast->LongDoubleTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->HalfTy)) - return CompilerType (ast, ast->HalfTy); - break; - - case DW_ATE_signed: - if (type_name) - { - if (streq(type_name, "wchar_t") && - QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy) && - (getTargetInfo() && TargetInfo::isTypeSigned (getTargetInfo()->getWCharType()))) - return CompilerType (ast, ast->WCharTy); - if (streq(type_name, "void") && - QualTypeMatchesBitSize (bit_size, ast, ast->VoidTy)) - return CompilerType (ast, ast->VoidTy); - if (strstr(type_name, "long long") && - QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) - return CompilerType (ast, ast->LongLongTy); - if (strstr(type_name, "long") && - QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) - return CompilerType (ast, ast->LongTy); - if (strstr(type_name, "short") && - QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) - return CompilerType (ast, ast->ShortTy); - if (strstr(type_name, "char")) - { - if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) - return CompilerType (ast, ast->CharTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) - return CompilerType (ast, ast->SignedCharTy); - } - if (strstr(type_name, "int")) - { - if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) - return CompilerType (ast, ast->IntTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) - return CompilerType (ast, ast->Int128Ty); - } - } - // We weren't able to match up a type name, just search by size - if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) - return CompilerType (ast, ast->CharTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) - return CompilerType (ast, ast->ShortTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) - return CompilerType (ast, ast->IntTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) - return CompilerType (ast, ast->LongTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) - return CompilerType (ast, ast->LongLongTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) - return CompilerType (ast, ast->Int128Ty); - break; + if (clang_type) + return CompilerType(GetASTContext(ast), clang_type); + return CompilerType(); +} - case DW_ATE_signed_char: - if (ast->getLangOpts().CharIsSigned && type_name && streq(type_name, "char")) - { - if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) - return CompilerType (ast, ast->CharTy); - } - if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) - return CompilerType (ast, ast->SignedCharTy); - break; - - case DW_ATE_unsigned: - if (type_name) - { - if (streq(type_name, "wchar_t")) - { - if (QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy)) - { - if (!(getTargetInfo() && TargetInfo::isTypeSigned (getTargetInfo()->getWCharType()))) - return CompilerType (ast, ast->WCharTy); - } - } - if (strstr(type_name, "long long")) - { - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) - return CompilerType (ast, ast->UnsignedLongLongTy); - } - else if (strstr(type_name, "long")) - { - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) - return CompilerType (ast, ast->UnsignedLongTy); - } - else if (strstr(type_name, "short")) - { - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) - return CompilerType (ast, ast->UnsignedShortTy); - } - else if (strstr(type_name, "char")) - { - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) - return CompilerType (ast, ast->UnsignedCharTy); - } - else if (strstr(type_name, "int")) - { - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) - return CompilerType (ast, ast->UnsignedIntTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) - return CompilerType (ast, ast->UnsignedInt128Ty); - } - } - // We weren't able to match up a type name, just search by size - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) - return CompilerType (ast, ast->UnsignedCharTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) - return CompilerType (ast, ast->UnsignedShortTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) - return CompilerType (ast, ast->UnsignedIntTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) - return CompilerType (ast, ast->UnsignedLongTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) - return CompilerType (ast, ast->UnsignedLongLongTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) - return CompilerType (ast, ast->UnsignedInt128Ty); - break; +CompilerType ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize( + const char *type_name, uint32_t dw_ate, uint32_t bit_size) { + ASTContext *ast = getASTContext(); - case DW_ATE_unsigned_char: - if (!ast->getLangOpts().CharIsSigned && type_name && streq(type_name, "char")) - { - if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) - return CompilerType (ast, ast->CharTy); - } - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) - return CompilerType (ast, ast->UnsignedCharTy); - if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) - return CompilerType (ast, ast->UnsignedShortTy); - break; - - case DW_ATE_imaginary_float: - break; - - case DW_ATE_UTF: - if (type_name) - { - if (streq(type_name, "char16_t")) - { - return CompilerType (ast, ast->Char16Ty); - } - else if (streq(type_name, "char32_t")) - { - return CompilerType (ast, ast->Char32Ty); - } - } - break; +#define streq(a, b) strcmp(a, b) == 0 + assert(ast != nullptr); + if (ast) { + switch (dw_ate) { + default: + break; + + case DW_ATE_address: + if (QualTypeMatchesBitSize(bit_size, ast, ast->VoidPtrTy)) + return CompilerType(ast, ast->VoidPtrTy); + break; + + case DW_ATE_boolean: + if (QualTypeMatchesBitSize(bit_size, ast, ast->BoolTy)) + return CompilerType(ast, ast->BoolTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy)) + return CompilerType(ast, ast->UnsignedCharTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy)) + return CompilerType(ast, ast->UnsignedShortTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy)) + return CompilerType(ast, ast->UnsignedIntTy); + break; + + case DW_ATE_lo_user: + // This has been seen to mean DW_AT_complex_integer + if (type_name) { + if (::strstr(type_name, "complex")) { + CompilerType complex_int_clang_type = + GetBuiltinTypeForDWARFEncodingAndBitSize("int", DW_ATE_signed, + bit_size / 2); + return CompilerType(ast, ast->getComplexType(ClangUtil::GetQualType( + complex_int_clang_type))); } + } + break; + + case DW_ATE_complex_float: + if (QualTypeMatchesBitSize(bit_size, ast, ast->FloatComplexTy)) + return CompilerType(ast, ast->FloatComplexTy); + else if (QualTypeMatchesBitSize(bit_size, ast, ast->DoubleComplexTy)) + return CompilerType(ast, ast->DoubleComplexTy); + else if (QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleComplexTy)) + return CompilerType(ast, ast->LongDoubleComplexTy); + else { + CompilerType complex_float_clang_type = + GetBuiltinTypeForDWARFEncodingAndBitSize("float", DW_ATE_float, + bit_size / 2); + return CompilerType(ast, ast->getComplexType(ClangUtil::GetQualType( + complex_float_clang_type))); + } + break; + + case DW_ATE_float: + if (streq(type_name, "float") && + QualTypeMatchesBitSize(bit_size, ast, ast->FloatTy)) + return CompilerType(ast, ast->FloatTy); + if (streq(type_name, "double") && + QualTypeMatchesBitSize(bit_size, ast, ast->DoubleTy)) + return CompilerType(ast, ast->DoubleTy); + if (streq(type_name, "long double") && + QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleTy)) + return CompilerType(ast, ast->LongDoubleTy); + // Fall back to not requiring a name match + if (QualTypeMatchesBitSize(bit_size, ast, ast->FloatTy)) + return CompilerType(ast, ast->FloatTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->DoubleTy)) + return CompilerType(ast, ast->DoubleTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->LongDoubleTy)) + return CompilerType(ast, ast->LongDoubleTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->HalfTy)) + return CompilerType(ast, ast->HalfTy); + break; + + case DW_ATE_signed: + if (type_name) { + if (streq(type_name, "wchar_t") && + QualTypeMatchesBitSize(bit_size, ast, ast->WCharTy) && + (getTargetInfo() && + TargetInfo::isTypeSigned(getTargetInfo()->getWCharType()))) + return CompilerType(ast, ast->WCharTy); + if (streq(type_name, "void") && + QualTypeMatchesBitSize(bit_size, ast, ast->VoidTy)) + return CompilerType(ast, ast->VoidTy); + if (strstr(type_name, "long long") && + QualTypeMatchesBitSize(bit_size, ast, ast->LongLongTy)) + return CompilerType(ast, ast->LongLongTy); + if (strstr(type_name, "long") && + QualTypeMatchesBitSize(bit_size, ast, ast->LongTy)) + return CompilerType(ast, ast->LongTy); + if (strstr(type_name, "short") && + QualTypeMatchesBitSize(bit_size, ast, ast->ShortTy)) + return CompilerType(ast, ast->ShortTy); + if (strstr(type_name, "char")) { + if (QualTypeMatchesBitSize(bit_size, ast, ast->CharTy)) + return CompilerType(ast, ast->CharTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->SignedCharTy)) + return CompilerType(ast, ast->SignedCharTy); + } + if (strstr(type_name, "int")) { + if (QualTypeMatchesBitSize(bit_size, ast, ast->IntTy)) + return CompilerType(ast, ast->IntTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->Int128Ty)) + return CompilerType(ast, ast->Int128Ty); + } + } + // We weren't able to match up a type name, just search by size + if (QualTypeMatchesBitSize(bit_size, ast, ast->CharTy)) + return CompilerType(ast, ast->CharTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->ShortTy)) + return CompilerType(ast, ast->ShortTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->IntTy)) + return CompilerType(ast, ast->IntTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->LongTy)) + return CompilerType(ast, ast->LongTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->LongLongTy)) + return CompilerType(ast, ast->LongLongTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->Int128Ty)) + return CompilerType(ast, ast->Int128Ty); + break; + + case DW_ATE_signed_char: + if (ast->getLangOpts().CharIsSigned && type_name && + streq(type_name, "char")) { + if (QualTypeMatchesBitSize(bit_size, ast, ast->CharTy)) + return CompilerType(ast, ast->CharTy); + } + if (QualTypeMatchesBitSize(bit_size, ast, ast->SignedCharTy)) + return CompilerType(ast, ast->SignedCharTy); + break; + + case DW_ATE_unsigned: + if (type_name) { + if (streq(type_name, "wchar_t")) { + if (QualTypeMatchesBitSize(bit_size, ast, ast->WCharTy)) { + if (!(getTargetInfo() && + TargetInfo::isTypeSigned(getTargetInfo()->getWCharType()))) + return CompilerType(ast, ast->WCharTy); + } + } + if (strstr(type_name, "long long")) { + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongLongTy)) + return CompilerType(ast, ast->UnsignedLongLongTy); + } else if (strstr(type_name, "long")) { + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongTy)) + return CompilerType(ast, ast->UnsignedLongTy); + } else if (strstr(type_name, "short")) { + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy)) + return CompilerType(ast, ast->UnsignedShortTy); + } else if (strstr(type_name, "char")) { + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy)) + return CompilerType(ast, ast->UnsignedCharTy); + } else if (strstr(type_name, "int")) { + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy)) + return CompilerType(ast, ast->UnsignedIntTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedInt128Ty)) + return CompilerType(ast, ast->UnsignedInt128Ty); + } + } + // We weren't able to match up a type name, just search by size + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy)) + return CompilerType(ast, ast->UnsignedCharTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy)) + return CompilerType(ast, ast->UnsignedShortTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedIntTy)) + return CompilerType(ast, ast->UnsignedIntTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongTy)) + return CompilerType(ast, ast->UnsignedLongTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedLongLongTy)) + return CompilerType(ast, ast->UnsignedLongLongTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedInt128Ty)) + return CompilerType(ast, ast->UnsignedInt128Ty); + break; + + case DW_ATE_unsigned_char: + if (!ast->getLangOpts().CharIsSigned && type_name && + streq(type_name, "char")) { + if (QualTypeMatchesBitSize(bit_size, ast, ast->CharTy)) + return CompilerType(ast, ast->CharTy); + } + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedCharTy)) + return CompilerType(ast, ast->UnsignedCharTy); + if (QualTypeMatchesBitSize(bit_size, ast, ast->UnsignedShortTy)) + return CompilerType(ast, ast->UnsignedShortTy); + break; + + case DW_ATE_imaginary_float: + break; + + case DW_ATE_UTF: + if (type_name) { + if (streq(type_name, "char16_t")) { + return CompilerType(ast, ast->Char16Ty); + } else if (streq(type_name, "char32_t")) { + return CompilerType(ast, ast->Char32Ty); + } + } + break; } - // This assert should fire for anything that we don't catch above so we know - // to fix any issues we run into. - if (type_name) - { - Host::SystemLog (Host::eSystemLogError, "error: need to add support for DW_TAG_base_type '%s' encoded with DW_ATE = 0x%x, bit_size = %u\n", type_name, dw_ate, bit_size); - } - else - { - Host::SystemLog (Host::eSystemLogError, "error: need to add support for DW_TAG_base_type encoded with DW_ATE = 0x%x, bit_size = %u\n", dw_ate, bit_size); - } - return CompilerType (); + } + // This assert should fire for anything that we don't catch above so we know + // to fix any issues we run into. + if (type_name) { + Host::SystemLog(Host::eSystemLogError, "error: need to add support for " + "DW_TAG_base_type '%s' encoded with " + "DW_ATE = 0x%x, bit_size = %u\n", + type_name, dw_ate, bit_size); + } else { + Host::SystemLog(Host::eSystemLogError, "error: need to add support for " + "DW_TAG_base_type encoded with " + "DW_ATE = 0x%x, bit_size = %u\n", + dw_ate, bit_size); + } + return CompilerType(); } -CompilerType -ClangASTContext::GetUnknownAnyType(clang::ASTContext *ast) -{ - if (ast) - return CompilerType (ast, ast->UnknownAnyTy); - return CompilerType(); +CompilerType ClangASTContext::GetUnknownAnyType(clang::ASTContext *ast) { + if (ast) + return CompilerType(ast, ast->UnknownAnyTy); + return CompilerType(); } -CompilerType -ClangASTContext::GetCStringType (bool is_const) -{ - ASTContext *ast = getASTContext(); - QualType char_type(ast->CharTy); - - if (is_const) - char_type.addConst(); - - return CompilerType (ast, ast->getPointerType(char_type)); +CompilerType ClangASTContext::GetCStringType(bool is_const) { + ASTContext *ast = getASTContext(); + QualType char_type(ast->CharTy); + + if (is_const) + char_type.addConst(); + + return CompilerType(ast, ast->getPointerType(char_type)); } clang::DeclContext * -ClangASTContext::GetTranslationUnitDecl (clang::ASTContext *ast) -{ - return ast->getTranslationUnitDecl(); -} - -clang::Decl * -ClangASTContext::CopyDecl (ASTContext *dst_ast, - ASTContext *src_ast, - clang::Decl *source_decl) -{ - FileSystemOptions file_system_options; - FileManager file_manager (file_system_options); - ASTImporter importer(*dst_ast, file_manager, - *src_ast, file_manager, - false); - - return importer.Import(source_decl); -} - -bool -ClangASTContext::AreTypesSame (CompilerType type1, - CompilerType type2, - bool ignore_qualifiers) -{ - ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(type1.GetTypeSystem()); - if (!ast || ast != type2.GetTypeSystem()) - return false; - - if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType()) - return true; +ClangASTContext::GetTranslationUnitDecl(clang::ASTContext *ast) { + return ast->getTranslationUnitDecl(); +} - QualType type1_qual = ClangUtil::GetQualType(type1); - QualType type2_qual = ClangUtil::GetQualType(type2); +clang::Decl *ClangASTContext::CopyDecl(ASTContext *dst_ast, ASTContext *src_ast, + clang::Decl *source_decl) { + FileSystemOptions file_system_options; + FileManager file_manager(file_system_options); + ASTImporter importer(*dst_ast, file_manager, *src_ast, file_manager, false); - if (ignore_qualifiers) - { - type1_qual = type1_qual.getUnqualifiedType(); - type2_qual = type2_qual.getUnqualifiedType(); - } - - return ast->getASTContext()->hasSameType (type1_qual, type2_qual); + return importer.Import(source_decl); } -CompilerType -ClangASTContext::GetTypeForDecl (clang::NamedDecl *decl) -{ - if (clang::ObjCInterfaceDecl *interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) - return GetTypeForDecl(interface_decl); - if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) - return GetTypeForDecl(tag_decl); - return CompilerType(); +bool ClangASTContext::AreTypesSame(CompilerType type1, CompilerType type2, + bool ignore_qualifiers) { + ClangASTContext *ast = + llvm::dyn_cast_or_null<ClangASTContext>(type1.GetTypeSystem()); + if (!ast || ast != type2.GetTypeSystem()) + return false; + + if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType()) + return true; + + QualType type1_qual = ClangUtil::GetQualType(type1); + QualType type2_qual = ClangUtil::GetQualType(type2); + + if (ignore_qualifiers) { + type1_qual = type1_qual.getUnqualifiedType(); + type2_qual = type2_qual.getUnqualifiedType(); + } + + return ast->getASTContext()->hasSameType(type1_qual, type2_qual); } +CompilerType ClangASTContext::GetTypeForDecl(clang::NamedDecl *decl) { + if (clang::ObjCInterfaceDecl *interface_decl = + llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) + return GetTypeForDecl(interface_decl); + if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) + return GetTypeForDecl(tag_decl); + return CompilerType(); +} -CompilerType -ClangASTContext::GetTypeForDecl (TagDecl *decl) -{ - // No need to call the getASTContext() accessor (which can create the AST - // if it isn't created yet, because we can't have created a decl in this - // AST if our AST didn't already exist... - ASTContext *ast = &decl->getASTContext(); - if (ast) - return CompilerType (ast, ast->getTagDeclType(decl)); - return CompilerType(); +CompilerType ClangASTContext::GetTypeForDecl(TagDecl *decl) { + // No need to call the getASTContext() accessor (which can create the AST + // if it isn't created yet, because we can't have created a decl in this + // AST if our AST didn't already exist... + ASTContext *ast = &decl->getASTContext(); + if (ast) + return CompilerType(ast, ast->getTagDeclType(decl)); + return CompilerType(); } -CompilerType -ClangASTContext::GetTypeForDecl (ObjCInterfaceDecl *decl) -{ - // No need to call the getASTContext() accessor (which can create the AST - // if it isn't created yet, because we can't have created a decl in this - // AST if our AST didn't already exist... - ASTContext *ast = &decl->getASTContext(); - if (ast) - return CompilerType (ast, ast->getObjCInterfaceType(decl)); - return CompilerType(); +CompilerType ClangASTContext::GetTypeForDecl(ObjCInterfaceDecl *decl) { + // No need to call the getASTContext() accessor (which can create the AST + // if it isn't created yet, because we can't have created a decl in this + // AST if our AST didn't already exist... + ASTContext *ast = &decl->getASTContext(); + if (ast) + return CompilerType(ast, ast->getObjCInterfaceType(decl)); + return CompilerType(); } #pragma mark Structure, Unions, Classes -CompilerType -ClangASTContext::CreateRecordType (DeclContext *decl_ctx, - AccessType access_type, - const char *name, - int kind, - LanguageType language, - ClangASTMetadata *metadata) -{ - ASTContext *ast = getASTContext(); - assert (ast != nullptr); - - if (decl_ctx == nullptr) - decl_ctx = ast->getTranslationUnitDecl(); - - - if (language == eLanguageTypeObjC || language == eLanguageTypeObjC_plus_plus) - { - bool isForwardDecl = true; - bool isInternal = false; - return CreateObjCClass (name, decl_ctx, isForwardDecl, isInternal, metadata); - } - - // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and - // we will need to update this code. I was told to currently always use - // the CXXRecordDecl class since we often don't know from debug information - // if something is struct or a class, so we default to always use the more - // complete definition just in case. - - bool is_anonymous = (!name) || (!name[0]); - - CXXRecordDecl *decl = CXXRecordDecl::Create (*ast, - (TagDecl::TagKind)kind, - decl_ctx, - SourceLocation(), - SourceLocation(), - is_anonymous ? nullptr : &ast->Idents.get(name)); - - if (is_anonymous) - decl->setAnonymousStructOrUnion(true); - - if (decl) - { - if (metadata) - SetMetadata(ast, decl, *metadata); +CompilerType ClangASTContext::CreateRecordType(DeclContext *decl_ctx, + AccessType access_type, + const char *name, int kind, + LanguageType language, + ClangASTMetadata *metadata) { + ASTContext *ast = getASTContext(); + assert(ast != nullptr); - if (access_type != eAccessNone) - decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type)); - - if (decl_ctx) - decl_ctx->addDecl (decl); + if (decl_ctx == nullptr) + decl_ctx = ast->getTranslationUnitDecl(); - return CompilerType(ast, ast->getTagDeclType(decl)); - } - return CompilerType(); -} + if (language == eLanguageTypeObjC || + language == eLanguageTypeObjC_plus_plus) { + bool isForwardDecl = true; + bool isInternal = false; + return CreateObjCClass(name, decl_ctx, isForwardDecl, isInternal, metadata); + } -static TemplateParameterList * -CreateTemplateParameterList (ASTContext *ast, - const ClangASTContext::TemplateParameterInfos &template_param_infos, - llvm::SmallVector<NamedDecl *, 8> &template_param_decls) -{ - const bool parameter_pack = false; - const bool is_typename = false; - const unsigned depth = 0; - const size_t num_template_params = template_param_infos.GetSize(); - for (size_t i=0; i<num_template_params; ++i) - { - const char *name = template_param_infos.names[i]; - - IdentifierInfo *identifier_info = nullptr; - if (name && name[0]) - identifier_info = &ast->Idents.get(name); - if (template_param_infos.args[i].getKind() == TemplateArgument::Integral) - { - template_param_decls.push_back (NonTypeTemplateParmDecl::Create (*ast, - ast->getTranslationUnitDecl(), // Is this the right decl context?, SourceLocation StartLoc, - SourceLocation(), - SourceLocation(), - depth, - i, - identifier_info, - template_param_infos.args[i].getIntegralType(), - parameter_pack, - nullptr)); - - } - else - { - template_param_decls.push_back (TemplateTypeParmDecl::Create (*ast, - ast->getTranslationUnitDecl(), // Is this the right decl context? - SourceLocation(), - SourceLocation(), - depth, - i, - identifier_info, - is_typename, - parameter_pack)); - } - } + // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and + // we will need to update this code. I was told to currently always use + // the CXXRecordDecl class since we often don't know from debug information + // if something is struct or a class, so we default to always use the more + // complete definition just in case. + + bool is_anonymous = (!name) || (!name[0]); + + CXXRecordDecl *decl = CXXRecordDecl::Create( + *ast, (TagDecl::TagKind)kind, decl_ctx, SourceLocation(), + SourceLocation(), is_anonymous ? nullptr : &ast->Idents.get(name)); + + if (is_anonymous) + decl->setAnonymousStructOrUnion(true); - clang::Expr *const requires_clause = nullptr; // TODO: Concepts - TemplateParameterList *template_param_list = TemplateParameterList::Create (*ast, - SourceLocation(), - SourceLocation(), - template_param_decls, - SourceLocation(), - requires_clause); - return template_param_list; + if (decl) { + if (metadata) + SetMetadata(ast, decl, *metadata); + + if (access_type != eAccessNone) + decl->setAccess(ConvertAccessTypeToAccessSpecifier(access_type)); + + if (decl_ctx) + decl_ctx->addDecl(decl); + + return CompilerType(ast, ast->getTagDeclType(decl)); + } + return CompilerType(); } -clang::FunctionTemplateDecl * -ClangASTContext::CreateFunctionTemplateDecl (clang::DeclContext *decl_ctx, - clang::FunctionDecl *func_decl, - const char *name, - const TemplateParameterInfos &template_param_infos) -{ -// /// \brief Create a function template node. - ASTContext *ast = getASTContext(); - - llvm::SmallVector<NamedDecl *, 8> template_param_decls; - - TemplateParameterList *template_param_list = CreateTemplateParameterList (ast, - template_param_infos, - template_param_decls); - FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create (*ast, - decl_ctx, - func_decl->getLocation(), - func_decl->getDeclName(), - template_param_list, - func_decl); - - for (size_t i=0, template_param_decl_count = template_param_decls.size(); - i < template_param_decl_count; - ++i) - { - // TODO: verify which decl context we should put template_param_decls into.. - template_param_decls[i]->setDeclContext (func_decl); - } - - return func_tmpl_decl; -} - -void -ClangASTContext::CreateFunctionTemplateSpecializationInfo (FunctionDecl *func_decl, - clang::FunctionTemplateDecl *func_tmpl_decl, - const TemplateParameterInfos &infos) -{ - TemplateArgumentList template_args (TemplateArgumentList::OnStack, infos.args); - - func_decl->setFunctionTemplateSpecialization (func_tmpl_decl, - &template_args, - nullptr); -} - - -ClassTemplateDecl * -ClangASTContext::CreateClassTemplateDecl (DeclContext *decl_ctx, - lldb::AccessType access_type, - const char *class_name, - int kind, - const TemplateParameterInfos &template_param_infos) -{ - ASTContext *ast = getASTContext(); - - ClassTemplateDecl *class_template_decl = nullptr; - if (decl_ctx == nullptr) - decl_ctx = ast->getTranslationUnitDecl(); - - IdentifierInfo &identifier_info = ast->Idents.get(class_name); - DeclarationName decl_name (&identifier_info); +static TemplateParameterList *CreateTemplateParameterList( + ASTContext *ast, + const ClangASTContext::TemplateParameterInfos &template_param_infos, + llvm::SmallVector<NamedDecl *, 8> &template_param_decls) { + const bool parameter_pack = false; + const bool is_typename = false; + const unsigned depth = 0; + const size_t num_template_params = template_param_infos.GetSize(); + for (size_t i = 0; i < num_template_params; ++i) { + const char *name = template_param_infos.names[i]; + + IdentifierInfo *identifier_info = nullptr; + if (name && name[0]) + identifier_info = &ast->Idents.get(name); + if (template_param_infos.args[i].getKind() == TemplateArgument::Integral) { + template_param_decls.push_back(NonTypeTemplateParmDecl::Create( + *ast, + ast->getTranslationUnitDecl(), // Is this the right decl context?, + // SourceLocation StartLoc, + SourceLocation(), SourceLocation(), depth, i, identifier_info, + template_param_infos.args[i].getIntegralType(), parameter_pack, + nullptr)); + + } else { + template_param_decls.push_back(TemplateTypeParmDecl::Create( + *ast, + ast->getTranslationUnitDecl(), // Is this the right decl context? + SourceLocation(), SourceLocation(), depth, i, identifier_info, + is_typename, parameter_pack)); + } + } + + clang::Expr *const requires_clause = nullptr; // TODO: Concepts + TemplateParameterList *template_param_list = TemplateParameterList::Create( + *ast, SourceLocation(), SourceLocation(), template_param_decls, + SourceLocation(), requires_clause); + return template_param_list; +} + +clang::FunctionTemplateDecl *ClangASTContext::CreateFunctionTemplateDecl( + clang::DeclContext *decl_ctx, clang::FunctionDecl *func_decl, + const char *name, const TemplateParameterInfos &template_param_infos) { + // /// \brief Create a function template node. + ASTContext *ast = getASTContext(); + + llvm::SmallVector<NamedDecl *, 8> template_param_decls; + + TemplateParameterList *template_param_list = CreateTemplateParameterList( + ast, template_param_infos, template_param_decls); + FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create( + *ast, decl_ctx, func_decl->getLocation(), func_decl->getDeclName(), + template_param_list, func_decl); + + for (size_t i = 0, template_param_decl_count = template_param_decls.size(); + i < template_param_decl_count; ++i) { + // TODO: verify which decl context we should put template_param_decls into.. + template_param_decls[i]->setDeclContext(func_decl); + } + + return func_tmpl_decl; +} + +void ClangASTContext::CreateFunctionTemplateSpecializationInfo( + FunctionDecl *func_decl, clang::FunctionTemplateDecl *func_tmpl_decl, + const TemplateParameterInfos &infos) { + TemplateArgumentList template_args(TemplateArgumentList::OnStack, infos.args); + + func_decl->setFunctionTemplateSpecialization(func_tmpl_decl, &template_args, + nullptr); +} - clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name); - - for (NamedDecl *decl : result) - { - class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl); - if (class_template_decl) - return class_template_decl; - } - - llvm::SmallVector<NamedDecl *, 8> template_param_decls; - - TemplateParameterList *template_param_list = CreateTemplateParameterList (ast, - template_param_infos, - template_param_decls); - - CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create (*ast, - (TagDecl::TagKind)kind, - decl_ctx, // What decl context do we use here? TU? The actual decl context? - SourceLocation(), - SourceLocation(), - &identifier_info); - - for (size_t i=0, template_param_decl_count = template_param_decls.size(); - i < template_param_decl_count; - ++i) - { - template_param_decls[i]->setDeclContext (template_cxx_decl); - } - - // With templated classes, we say that a class is templated with - // specializations, but that the bare class has no functions. - //template_cxx_decl->startDefinition(); - //template_cxx_decl->completeDefinition(); - - class_template_decl = ClassTemplateDecl::Create (*ast, - decl_ctx, // What decl context do we use here? TU? The actual decl context? - SourceLocation(), - decl_name, - template_param_list, - template_cxx_decl, - nullptr); - +ClassTemplateDecl *ClangASTContext::CreateClassTemplateDecl( + DeclContext *decl_ctx, lldb::AccessType access_type, const char *class_name, + int kind, const TemplateParameterInfos &template_param_infos) { + ASTContext *ast = getASTContext(); + + ClassTemplateDecl *class_template_decl = nullptr; + if (decl_ctx == nullptr) + decl_ctx = ast->getTranslationUnitDecl(); + + IdentifierInfo &identifier_info = ast->Idents.get(class_name); + DeclarationName decl_name(&identifier_info); + + clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name); + + for (NamedDecl *decl : result) { + class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl); if (class_template_decl) - { - if (access_type != eAccessNone) - class_template_decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type)); - - //if (TagDecl *ctx_tag_decl = dyn_cast<TagDecl>(decl_ctx)) - // CompleteTagDeclarationDefinition(GetTypeForDecl(ctx_tag_decl)); - - decl_ctx->addDecl (class_template_decl); - + return class_template_decl; + } + + llvm::SmallVector<NamedDecl *, 8> template_param_decls; + + TemplateParameterList *template_param_list = CreateTemplateParameterList( + ast, template_param_infos, template_param_decls); + + CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create( + *ast, (TagDecl::TagKind)kind, + decl_ctx, // What decl context do we use here? TU? The actual decl + // context? + SourceLocation(), SourceLocation(), &identifier_info); + + for (size_t i = 0, template_param_decl_count = template_param_decls.size(); + i < template_param_decl_count; ++i) { + template_param_decls[i]->setDeclContext(template_cxx_decl); + } + + // With templated classes, we say that a class is templated with + // specializations, but that the bare class has no functions. + // template_cxx_decl->startDefinition(); + // template_cxx_decl->completeDefinition(); + + class_template_decl = ClassTemplateDecl::Create( + *ast, + decl_ctx, // What decl context do we use here? TU? The actual decl + // context? + SourceLocation(), decl_name, template_param_list, template_cxx_decl, + nullptr); + + if (class_template_decl) { + if (access_type != eAccessNone) + class_template_decl->setAccess( + ConvertAccessTypeToAccessSpecifier(access_type)); + + // if (TagDecl *ctx_tag_decl = dyn_cast<TagDecl>(decl_ctx)) + // CompleteTagDeclarationDefinition(GetTypeForDecl(ctx_tag_decl)); + + decl_ctx->addDecl(class_template_decl); + #ifdef LLDB_CONFIGURATION_DEBUG - VerifyDecl(class_template_decl); + VerifyDecl(class_template_decl); #endif - } + } - return class_template_decl; + return class_template_decl; } - ClassTemplateSpecializationDecl * -ClangASTContext::CreateClassTemplateSpecializationDecl (DeclContext *decl_ctx, - ClassTemplateDecl *class_template_decl, - int kind, - const TemplateParameterInfos &template_param_infos) -{ - ASTContext *ast = getASTContext(); - ClassTemplateSpecializationDecl *class_template_specialization_decl = ClassTemplateSpecializationDecl::Create (*ast, - (TagDecl::TagKind)kind, - decl_ctx, - SourceLocation(), - SourceLocation(), - class_template_decl, - template_param_infos.args, - nullptr); - - class_template_specialization_decl->setSpecializationKind(TSK_ExplicitSpecialization); - - return class_template_specialization_decl; -} +ClangASTContext::CreateClassTemplateSpecializationDecl( + DeclContext *decl_ctx, ClassTemplateDecl *class_template_decl, int kind, + const TemplateParameterInfos &template_param_infos) { + ASTContext *ast = getASTContext(); + ClassTemplateSpecializationDecl *class_template_specialization_decl = + ClassTemplateSpecializationDecl::Create( + *ast, (TagDecl::TagKind)kind, decl_ctx, SourceLocation(), + SourceLocation(), class_template_decl, template_param_infos.args, + nullptr); -CompilerType -ClangASTContext::CreateClassTemplateSpecializationType (ClassTemplateSpecializationDecl *class_template_specialization_decl) -{ - if (class_template_specialization_decl) - { - ASTContext *ast = getASTContext(); - if (ast) - return CompilerType(ast, ast->getTagDeclType(class_template_specialization_decl)); - } - return CompilerType(); + class_template_specialization_decl->setSpecializationKind( + TSK_ExplicitSpecialization); + + return class_template_specialization_decl; } -static inline bool -check_op_param(bool is_method, clang::OverloadedOperatorKind op_kind, bool unary, bool binary, uint32_t num_params) -{ - // Special-case call since it can take any number of operands - if(op_kind == OO_Call) - return true; - - // The parameter count doesn't include "this" - if (is_method) - ++num_params; - if (num_params == 1) - return unary; - if (num_params == 2) - return binary; - else +CompilerType ClangASTContext::CreateClassTemplateSpecializationType( + ClassTemplateSpecializationDecl *class_template_specialization_decl) { + if (class_template_specialization_decl) { + ASTContext *ast = getASTContext(); + if (ast) + return CompilerType( + ast, ast->getTagDeclType(class_template_specialization_decl)); + } + return CompilerType(); +} + +static inline bool check_op_param(bool is_method, + clang::OverloadedOperatorKind op_kind, + bool unary, bool binary, + uint32_t num_params) { + // Special-case call since it can take any number of operands + if (op_kind == OO_Call) + return true; + + // The parameter count doesn't include "this" + if (is_method) + ++num_params; + if (num_params == 1) + return unary; + if (num_params == 2) + return binary; + else return false; } -bool -ClangASTContext::CheckOverloadedOperatorKindParameterCount(bool is_method, clang::OverloadedOperatorKind op_kind, - uint32_t num_params) -{ - switch (op_kind) - { - default: - break; - // C++ standard allows any number of arguments to new/delete - case OO_New: - case OO_Array_New: - case OO_Delete: - case OO_Array_Delete: - return true; - } +bool ClangASTContext::CheckOverloadedOperatorKindParameterCount( + bool is_method, clang::OverloadedOperatorKind op_kind, + uint32_t num_params) { + switch (op_kind) { + default: + break; + // C++ standard allows any number of arguments to new/delete + case OO_New: + case OO_Array_New: + case OO_Delete: + case OO_Array_Delete: + return true; + } -#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \ - case OO_##Name: \ - return check_op_param(is_method, op_kind, Unary, Binary, num_params); - switch (op_kind) - { +#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \ + case OO_##Name: \ + return check_op_param(is_method, op_kind, Unary, Binary, num_params); + switch (op_kind) { #include "clang/Basic/OperatorKinds.def" - default: break; - } - return false; + default: + break; + } + return false; } clang::AccessSpecifier -ClangASTContext::UnifyAccessSpecifiers (clang::AccessSpecifier lhs, clang::AccessSpecifier rhs) -{ - // Make the access equal to the stricter of the field and the nested field's access - if (lhs == AS_none || rhs == AS_none) - return AS_none; - if (lhs == AS_private || rhs == AS_private) - return AS_private; - if (lhs == AS_protected || rhs == AS_protected) - return AS_protected; - return AS_public; +ClangASTContext::UnifyAccessSpecifiers(clang::AccessSpecifier lhs, + clang::AccessSpecifier rhs) { + // Make the access equal to the stricter of the field and the nested field's + // access + if (lhs == AS_none || rhs == AS_none) + return AS_none; + if (lhs == AS_private || rhs == AS_private) + return AS_private; + if (lhs == AS_protected || rhs == AS_protected) + return AS_protected; + return AS_public; } -bool -ClangASTContext::FieldIsBitfield (FieldDecl* field, uint32_t& bitfield_bit_size) -{ - return FieldIsBitfield(getASTContext(), field, bitfield_bit_size); +bool ClangASTContext::FieldIsBitfield(FieldDecl *field, + uint32_t &bitfield_bit_size) { + return FieldIsBitfield(getASTContext(), field, bitfield_bit_size); } -bool -ClangASTContext::FieldIsBitfield -( - ASTContext *ast, - FieldDecl* field, - uint32_t& bitfield_bit_size -) -{ - if (ast == nullptr || field == nullptr) - return false; +bool ClangASTContext::FieldIsBitfield(ASTContext *ast, FieldDecl *field, + uint32_t &bitfield_bit_size) { + if (ast == nullptr || field == nullptr) + return false; - if (field->isBitField()) - { - Expr* bit_width_expr = field->getBitWidth(); - if (bit_width_expr) - { - llvm::APSInt bit_width_apsint; - if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast)) - { - bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX); - return true; - } - } + if (field->isBitField()) { + Expr *bit_width_expr = field->getBitWidth(); + if (bit_width_expr) { + llvm::APSInt bit_width_apsint; + if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast)) { + bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX); + return true; + } } - return false; + } + return false; } -bool -ClangASTContext::RecordHasFields (const RecordDecl *record_decl) -{ - if (record_decl == nullptr) - return false; +bool ClangASTContext::RecordHasFields(const RecordDecl *record_decl) { + if (record_decl == nullptr) + return false; - if (!record_decl->field_empty()) - return true; + if (!record_decl->field_empty()) + return true; - // No fields, lets check this is a CXX record and check the base classes - const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); - if (cxx_record_decl) - { - CXXRecordDecl::base_class_const_iterator base_class, base_class_end; - for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); - base_class != base_class_end; - ++base_class) - { - const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); - if (RecordHasFields(base_class_decl)) - return true; - } + // No fields, lets check this is a CXX record and check the base classes + const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); + if (cxx_record_decl) { + CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + for (base_class = cxx_record_decl->bases_begin(), + base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; ++base_class) { + const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>( + base_class->getType()->getAs<RecordType>()->getDecl()); + if (RecordHasFields(base_class_decl)) + return true; } - return false; + } + return false; } #pragma mark Objective C Classes -CompilerType -ClangASTContext::CreateObjCClass -( - const char *name, - DeclContext *decl_ctx, - bool isForwardDecl, - bool isInternal, - ClangASTMetadata *metadata -) -{ - ASTContext *ast = getASTContext(); - assert (ast != nullptr); - assert (name && name[0]); - if (decl_ctx == nullptr) - decl_ctx = ast->getTranslationUnitDecl(); - - ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create (*ast, - decl_ctx, - SourceLocation(), - &ast->Idents.get(name), - nullptr, - nullptr, - SourceLocation(), - /*isForwardDecl,*/ - isInternal); - - if (decl && metadata) - SetMetadata(ast, decl, *metadata); - - return CompilerType (ast, ast->getObjCInterfaceType(decl)); +CompilerType ClangASTContext::CreateObjCClass(const char *name, + DeclContext *decl_ctx, + bool isForwardDecl, + bool isInternal, + ClangASTMetadata *metadata) { + ASTContext *ast = getASTContext(); + assert(ast != nullptr); + assert(name && name[0]); + if (decl_ctx == nullptr) + decl_ctx = ast->getTranslationUnitDecl(); + + ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create( + *ast, decl_ctx, SourceLocation(), &ast->Idents.get(name), nullptr, + nullptr, SourceLocation(), + /*isForwardDecl,*/ + isInternal); + + if (decl && metadata) + SetMetadata(ast, decl, *metadata); + + return CompilerType(ast, ast->getObjCInterfaceType(decl)); } -static inline bool -BaseSpecifierIsEmpty (const CXXBaseSpecifier *b) -{ - return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false; +static inline bool BaseSpecifierIsEmpty(const CXXBaseSpecifier *b) { + return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == + false; } uint32_t -ClangASTContext::GetNumBaseClasses (const CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes) -{ - uint32_t num_bases = 0; - if (cxx_record_decl) - { - if (omit_empty_base_classes) - { - CXXRecordDecl::base_class_const_iterator base_class, base_class_end; - for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); - base_class != base_class_end; - ++base_class) - { - // Skip empty base classes - if (omit_empty_base_classes) - { - if (BaseSpecifierIsEmpty (base_class)) - continue; - } - ++num_bases; - } +ClangASTContext::GetNumBaseClasses(const CXXRecordDecl *cxx_record_decl, + bool omit_empty_base_classes) { + uint32_t num_bases = 0; + if (cxx_record_decl) { + if (omit_empty_base_classes) { + CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + for (base_class = cxx_record_decl->bases_begin(), + base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; ++base_class) { + // Skip empty base classes + if (omit_empty_base_classes) { + if (BaseSpecifierIsEmpty(base_class)) + continue; } - else - num_bases = cxx_record_decl->getNumBases(); - } - return num_bases; + ++num_bases; + } + } else + num_bases = cxx_record_decl->getNumBases(); + } + return num_bases; } - #pragma mark Namespace Declarations NamespaceDecl * -ClangASTContext::GetUniqueNamespaceDeclaration (const char *name, DeclContext *decl_ctx) -{ - NamespaceDecl *namespace_decl = nullptr; - ASTContext *ast = getASTContext(); - TranslationUnitDecl *translation_unit_decl = ast->getTranslationUnitDecl (); - if (decl_ctx == nullptr) - decl_ctx = translation_unit_decl; - - if (name) - { - IdentifierInfo &identifier_info = ast->Idents.get(name); - DeclarationName decl_name (&identifier_info); - clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name); - for (NamedDecl *decl : result) - { - namespace_decl = dyn_cast<clang::NamespaceDecl>(decl); - if (namespace_decl) - return namespace_decl; - } - - namespace_decl = NamespaceDecl::Create(*ast, - decl_ctx, - false, - SourceLocation(), - SourceLocation(), - &identifier_info, - nullptr); - - decl_ctx->addDecl (namespace_decl); - } - else - { - if (decl_ctx == translation_unit_decl) - { - namespace_decl = translation_unit_decl->getAnonymousNamespace(); - if (namespace_decl) - return namespace_decl; - - namespace_decl = NamespaceDecl::Create(*ast, - decl_ctx, - false, - SourceLocation(), - SourceLocation(), - nullptr, - nullptr); - translation_unit_decl->setAnonymousNamespace (namespace_decl); - translation_unit_decl->addDecl (namespace_decl); - assert (namespace_decl == translation_unit_decl->getAnonymousNamespace()); - } - else - { - NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx); - if (parent_namespace_decl) - { - namespace_decl = parent_namespace_decl->getAnonymousNamespace(); - if (namespace_decl) - return namespace_decl; - namespace_decl = NamespaceDecl::Create(*ast, - decl_ctx, - false, - SourceLocation(), - SourceLocation(), - nullptr, - nullptr); - parent_namespace_decl->setAnonymousNamespace (namespace_decl); - parent_namespace_decl->addDecl (namespace_decl); - assert (namespace_decl == parent_namespace_decl->getAnonymousNamespace()); - } - else - { - // BAD!!! - } - } - } +ClangASTContext::GetUniqueNamespaceDeclaration(const char *name, + DeclContext *decl_ctx) { + NamespaceDecl *namespace_decl = nullptr; + ASTContext *ast = getASTContext(); + TranslationUnitDecl *translation_unit_decl = ast->getTranslationUnitDecl(); + if (decl_ctx == nullptr) + decl_ctx = translation_unit_decl; + + if (name) { + IdentifierInfo &identifier_info = ast->Idents.get(name); + DeclarationName decl_name(&identifier_info); + clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name); + for (NamedDecl *decl : result) { + namespace_decl = dyn_cast<clang::NamespaceDecl>(decl); + if (namespace_decl) + return namespace_decl; + } + + namespace_decl = + NamespaceDecl::Create(*ast, decl_ctx, false, SourceLocation(), + SourceLocation(), &identifier_info, nullptr); + + decl_ctx->addDecl(namespace_decl); + } else { + if (decl_ctx == translation_unit_decl) { + namespace_decl = translation_unit_decl->getAnonymousNamespace(); + if (namespace_decl) + return namespace_decl; + + namespace_decl = + NamespaceDecl::Create(*ast, decl_ctx, false, SourceLocation(), + SourceLocation(), nullptr, nullptr); + translation_unit_decl->setAnonymousNamespace(namespace_decl); + translation_unit_decl->addDecl(namespace_decl); + assert(namespace_decl == translation_unit_decl->getAnonymousNamespace()); + } else { + NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx); + if (parent_namespace_decl) { + namespace_decl = parent_namespace_decl->getAnonymousNamespace(); + if (namespace_decl) + return namespace_decl; + namespace_decl = + NamespaceDecl::Create(*ast, decl_ctx, false, SourceLocation(), + SourceLocation(), nullptr, nullptr); + parent_namespace_decl->setAnonymousNamespace(namespace_decl); + parent_namespace_decl->addDecl(namespace_decl); + assert(namespace_decl == + parent_namespace_decl->getAnonymousNamespace()); + } else { + // BAD!!! + } + } + } #ifdef LLDB_CONFIGURATION_DEBUG - VerifyDecl(namespace_decl); + VerifyDecl(namespace_decl); #endif - return namespace_decl; + return namespace_decl; } -NamespaceDecl * -ClangASTContext::GetUniqueNamespaceDeclaration (clang::ASTContext *ast, - const char *name, - clang::DeclContext *decl_ctx) -{ - ClangASTContext *ast_ctx = ClangASTContext::GetASTContext(ast); - if (ast_ctx == nullptr) - return nullptr; +NamespaceDecl *ClangASTContext::GetUniqueNamespaceDeclaration( + clang::ASTContext *ast, const char *name, clang::DeclContext *decl_ctx) { + ClangASTContext *ast_ctx = ClangASTContext::GetASTContext(ast); + if (ast_ctx == nullptr) + return nullptr; - return ast_ctx->GetUniqueNamespaceDeclaration(name, decl_ctx); + return ast_ctx->GetUniqueNamespaceDeclaration(name, decl_ctx); } clang::BlockDecl * -ClangASTContext::CreateBlockDeclaration (clang::DeclContext *ctx) -{ - if (ctx != nullptr) - { - clang::BlockDecl *decl = clang::BlockDecl::Create(*getASTContext(), ctx, clang::SourceLocation()); - ctx->addDecl(decl); - return decl; - } +ClangASTContext::CreateBlockDeclaration(clang::DeclContext *ctx) { + if (ctx != nullptr) { + clang::BlockDecl *decl = clang::BlockDecl::Create(*getASTContext(), ctx, + clang::SourceLocation()); + ctx->addDecl(decl); + return decl; + } + return nullptr; +} + +clang::DeclContext *FindLCABetweenDecls(clang::DeclContext *left, + clang::DeclContext *right, + clang::DeclContext *root) { + if (root == nullptr) return nullptr; -} - -clang::DeclContext * -FindLCABetweenDecls(clang::DeclContext *left, clang::DeclContext *right, clang::DeclContext *root) -{ - if (root == nullptr) - return nullptr; - std::set<clang::DeclContext *> path_left; - for (clang::DeclContext *d = left; d != nullptr; d = d->getParent()) - path_left.insert(d); + std::set<clang::DeclContext *> path_left; + for (clang::DeclContext *d = left; d != nullptr; d = d->getParent()) + path_left.insert(d); - for (clang::DeclContext *d = right; d != nullptr; d = d->getParent()) - if (path_left.find(d) != path_left.end()) - return d; + for (clang::DeclContext *d = right; d != nullptr; d = d->getParent()) + if (path_left.find(d) != path_left.end()) + return d; - return nullptr; + return nullptr; } -clang::UsingDirectiveDecl * -ClangASTContext::CreateUsingDirectiveDeclaration (clang::DeclContext *decl_ctx, clang::NamespaceDecl *ns_decl) -{ - if (decl_ctx != nullptr && ns_decl != nullptr) - { - clang::TranslationUnitDecl *translation_unit = (clang::TranslationUnitDecl *)GetTranslationUnitDecl(getASTContext()); - clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create(*getASTContext(), - decl_ctx, - clang::SourceLocation(), - clang::SourceLocation(), - clang::NestedNameSpecifierLoc(), - clang::SourceLocation(), - ns_decl, - FindLCABetweenDecls(decl_ctx, ns_decl, translation_unit)); - decl_ctx->addDecl(using_decl); - return using_decl; - } - return nullptr; +clang::UsingDirectiveDecl *ClangASTContext::CreateUsingDirectiveDeclaration( + clang::DeclContext *decl_ctx, clang::NamespaceDecl *ns_decl) { + if (decl_ctx != nullptr && ns_decl != nullptr) { + clang::TranslationUnitDecl *translation_unit = + (clang::TranslationUnitDecl *)GetTranslationUnitDecl(getASTContext()); + clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create( + *getASTContext(), decl_ctx, clang::SourceLocation(), + clang::SourceLocation(), clang::NestedNameSpecifierLoc(), + clang::SourceLocation(), ns_decl, + FindLCABetweenDecls(decl_ctx, ns_decl, translation_unit)); + decl_ctx->addDecl(using_decl); + return using_decl; + } + return nullptr; } clang::UsingDecl * -ClangASTContext::CreateUsingDeclaration (clang::DeclContext *current_decl_ctx, clang::NamedDecl *target) -{ - if (current_decl_ctx != nullptr && target != nullptr) - { - clang::UsingDecl *using_decl = clang::UsingDecl::Create(*getASTContext(), - current_decl_ctx, - clang::SourceLocation(), - clang::NestedNameSpecifierLoc(), - clang::DeclarationNameInfo(), - false); - clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(*getASTContext(), - current_decl_ctx, - clang::SourceLocation(), - using_decl, - target); - using_decl->addShadowDecl(shadow_decl); - current_decl_ctx->addDecl(using_decl); - return using_decl; - } - return nullptr; -} - -clang::VarDecl * -ClangASTContext::CreateVariableDeclaration (clang::DeclContext *decl_context, const char *name, clang::QualType type) -{ - if (decl_context != nullptr) - { - clang::VarDecl *var_decl = clang::VarDecl::Create(*getASTContext(), - decl_context, - clang::SourceLocation(), - clang::SourceLocation(), - name && name[0] ? &getASTContext()->Idents.getOwn(name) : nullptr, - type, - nullptr, - clang::SC_None); - var_decl->setAccess(clang::AS_public); - decl_context->addDecl(var_decl); - return var_decl; - } - return nullptr; +ClangASTContext::CreateUsingDeclaration(clang::DeclContext *current_decl_ctx, + clang::NamedDecl *target) { + if (current_decl_ctx != nullptr && target != nullptr) { + clang::UsingDecl *using_decl = clang::UsingDecl::Create( + *getASTContext(), current_decl_ctx, clang::SourceLocation(), + clang::NestedNameSpecifierLoc(), clang::DeclarationNameInfo(), false); + clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create( + *getASTContext(), current_decl_ctx, clang::SourceLocation(), using_decl, + target); + using_decl->addShadowDecl(shadow_decl); + current_decl_ctx->addDecl(using_decl); + return using_decl; + } + return nullptr; +} + +clang::VarDecl *ClangASTContext::CreateVariableDeclaration( + clang::DeclContext *decl_context, const char *name, clang::QualType type) { + if (decl_context != nullptr) { + clang::VarDecl *var_decl = clang::VarDecl::Create( + *getASTContext(), decl_context, clang::SourceLocation(), + clang::SourceLocation(), + name && name[0] ? &getASTContext()->Idents.getOwn(name) : nullptr, type, + nullptr, clang::SC_None); + var_decl->setAccess(clang::AS_public); + decl_context->addDecl(var_decl); + return var_decl; + } + return nullptr; } lldb::opaque_compiler_type_t -ClangASTContext::GetOpaqueCompilerType(clang::ASTContext *ast, lldb::BasicType basic_type) -{ - switch (basic_type) - { - case eBasicTypeVoid: - return ast->VoidTy.getAsOpaquePtr(); - case eBasicTypeChar: - return ast->CharTy.getAsOpaquePtr(); - case eBasicTypeSignedChar: - return ast->SignedCharTy.getAsOpaquePtr(); - case eBasicTypeUnsignedChar: - return ast->UnsignedCharTy.getAsOpaquePtr(); - case eBasicTypeWChar: - return ast->getWCharType().getAsOpaquePtr(); - case eBasicTypeSignedWChar: - return ast->getSignedWCharType().getAsOpaquePtr(); - case eBasicTypeUnsignedWChar: - return ast->getUnsignedWCharType().getAsOpaquePtr(); - case eBasicTypeChar16: - return ast->Char16Ty.getAsOpaquePtr(); - case eBasicTypeChar32: - return ast->Char32Ty.getAsOpaquePtr(); - case eBasicTypeShort: - return ast->ShortTy.getAsOpaquePtr(); - case eBasicTypeUnsignedShort: - return ast->UnsignedShortTy.getAsOpaquePtr(); - case eBasicTypeInt: - return ast->IntTy.getAsOpaquePtr(); - case eBasicTypeUnsignedInt: - return ast->UnsignedIntTy.getAsOpaquePtr(); - case eBasicTypeLong: - return ast->LongTy.getAsOpaquePtr(); - case eBasicTypeUnsignedLong: - return ast->UnsignedLongTy.getAsOpaquePtr(); - case eBasicTypeLongLong: - return ast->LongLongTy.getAsOpaquePtr(); - case eBasicTypeUnsignedLongLong: - return ast->UnsignedLongLongTy.getAsOpaquePtr(); - case eBasicTypeInt128: - return ast->Int128Ty.getAsOpaquePtr(); - case eBasicTypeUnsignedInt128: - return ast->UnsignedInt128Ty.getAsOpaquePtr(); - case eBasicTypeBool: - return ast->BoolTy.getAsOpaquePtr(); - case eBasicTypeHalf: - return ast->HalfTy.getAsOpaquePtr(); - case eBasicTypeFloat: - return ast->FloatTy.getAsOpaquePtr(); - case eBasicTypeDouble: - return ast->DoubleTy.getAsOpaquePtr(); - case eBasicTypeLongDouble: - return ast->LongDoubleTy.getAsOpaquePtr(); - case eBasicTypeFloatComplex: - return ast->FloatComplexTy.getAsOpaquePtr(); - case eBasicTypeDoubleComplex: - return ast->DoubleComplexTy.getAsOpaquePtr(); - case eBasicTypeLongDoubleComplex: - return ast->LongDoubleComplexTy.getAsOpaquePtr(); - case eBasicTypeObjCID: - return ast->getObjCIdType().getAsOpaquePtr(); - case eBasicTypeObjCClass: - return ast->getObjCClassType().getAsOpaquePtr(); - case eBasicTypeObjCSel: - return ast->getObjCSelType().getAsOpaquePtr(); - case eBasicTypeNullPtr: - return ast->NullPtrTy.getAsOpaquePtr(); - default: - return nullptr; - } +ClangASTContext::GetOpaqueCompilerType(clang::ASTContext *ast, + lldb::BasicType basic_type) { + switch (basic_type) { + case eBasicTypeVoid: + return ast->VoidTy.getAsOpaquePtr(); + case eBasicTypeChar: + return ast->CharTy.getAsOpaquePtr(); + case eBasicTypeSignedChar: + return ast->SignedCharTy.getAsOpaquePtr(); + case eBasicTypeUnsignedChar: + return ast->UnsignedCharTy.getAsOpaquePtr(); + case eBasicTypeWChar: + return ast->getWCharType().getAsOpaquePtr(); + case eBasicTypeSignedWChar: + return ast->getSignedWCharType().getAsOpaquePtr(); + case eBasicTypeUnsignedWChar: + return ast->getUnsignedWCharType().getAsOpaquePtr(); + case eBasicTypeChar16: + return ast->Char16Ty.getAsOpaquePtr(); + case eBasicTypeChar32: + return ast->Char32Ty.getAsOpaquePtr(); + case eBasicTypeShort: + return ast->ShortTy.getAsOpaquePtr(); + case eBasicTypeUnsignedShort: + return ast->UnsignedShortTy.getAsOpaquePtr(); + case eBasicTypeInt: + return ast->IntTy.getAsOpaquePtr(); + case eBasicTypeUnsignedInt: + return ast->UnsignedIntTy.getAsOpaquePtr(); + case eBasicTypeLong: + return ast->LongTy.getAsOpaquePtr(); + case eBasicTypeUnsignedLong: + return ast->UnsignedLongTy.getAsOpaquePtr(); + case eBasicTypeLongLong: + return ast->LongLongTy.getAsOpaquePtr(); + case eBasicTypeUnsignedLongLong: + return ast->UnsignedLongLongTy.getAsOpaquePtr(); + case eBasicTypeInt128: + return ast->Int128Ty.getAsOpaquePtr(); + case eBasicTypeUnsignedInt128: + return ast->UnsignedInt128Ty.getAsOpaquePtr(); + case eBasicTypeBool: + return ast->BoolTy.getAsOpaquePtr(); + case eBasicTypeHalf: + return ast->HalfTy.getAsOpaquePtr(); + case eBasicTypeFloat: + return ast->FloatTy.getAsOpaquePtr(); + case eBasicTypeDouble: + return ast->DoubleTy.getAsOpaquePtr(); + case eBasicTypeLongDouble: + return ast->LongDoubleTy.getAsOpaquePtr(); + case eBasicTypeFloatComplex: + return ast->FloatComplexTy.getAsOpaquePtr(); + case eBasicTypeDoubleComplex: + return ast->DoubleComplexTy.getAsOpaquePtr(); + case eBasicTypeLongDoubleComplex: + return ast->LongDoubleComplexTy.getAsOpaquePtr(); + case eBasicTypeObjCID: + return ast->getObjCIdType().getAsOpaquePtr(); + case eBasicTypeObjCClass: + return ast->getObjCClassType().getAsOpaquePtr(); + case eBasicTypeObjCSel: + return ast->getObjCSelType().getAsOpaquePtr(); + case eBasicTypeNullPtr: + return ast->NullPtrTy.getAsOpaquePtr(); + default: + return nullptr; + } } #pragma mark Function Types clang::DeclarationName -ClangASTContext::GetDeclarationName(const char *name, const CompilerType &function_clang_type) -{ - if (!name || !name[0]) - return clang::DeclarationName(); +ClangASTContext::GetDeclarationName(const char *name, + const CompilerType &function_clang_type) { + if (!name || !name[0]) + return clang::DeclarationName(); + + clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS; + if (!IsOperator(name, op_kind) || op_kind == clang::NUM_OVERLOADED_OPERATORS) + return DeclarationName(&getASTContext()->Idents.get( + name)); // Not operator, but a regular function. + + // Check the number of operator parameters. Sometimes we have + // seen bad DWARF that doesn't correctly describe operators and + // if we try to create a method and add it to the class, clang + // will assert and crash, so we need to make sure things are + // acceptable. + clang::QualType method_qual_type(ClangUtil::GetQualType(function_clang_type)); + const clang::FunctionProtoType *function_type = + llvm::dyn_cast<clang::FunctionProtoType>(method_qual_type.getTypePtr()); + if (function_type == nullptr) + return clang::DeclarationName(); + + const bool is_method = false; + const unsigned int num_params = function_type->getNumParams(); + if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount( + is_method, op_kind, num_params)) + return clang::DeclarationName(); + + return getASTContext()->DeclarationNames.getCXXOperatorName(op_kind); +} + +FunctionDecl *ClangASTContext::CreateFunctionDeclaration( + DeclContext *decl_ctx, const char *name, + const CompilerType &function_clang_type, int storage, bool is_inline) { + FunctionDecl *func_decl = nullptr; + ASTContext *ast = getASTContext(); + if (decl_ctx == nullptr) + decl_ctx = ast->getTranslationUnitDecl(); + + const bool hasWrittenPrototype = true; + const bool isConstexprSpecified = false; + + clang::DeclarationName declarationName = + GetDeclarationName(name, function_clang_type); + func_decl = FunctionDecl::Create( + *ast, decl_ctx, SourceLocation(), SourceLocation(), declarationName, + ClangUtil::GetQualType(function_clang_type), nullptr, + (clang::StorageClass)storage, is_inline, hasWrittenPrototype, + isConstexprSpecified); + if (func_decl) + decl_ctx->addDecl(func_decl); - clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS; - if (!IsOperator(name, op_kind) || op_kind == clang::NUM_OVERLOADED_OPERATORS) - return DeclarationName(&getASTContext()->Idents.get(name)); // Not operator, but a regular function. - - // Check the number of operator parameters. Sometimes we have - // seen bad DWARF that doesn't correctly describe operators and - // if we try to create a method and add it to the class, clang - // will assert and crash, so we need to make sure things are - // acceptable. - clang::QualType method_qual_type(ClangUtil::GetQualType(function_clang_type)); - const clang::FunctionProtoType *function_type = - llvm::dyn_cast<clang::FunctionProtoType>(method_qual_type.getTypePtr()); - if (function_type == nullptr) - return clang::DeclarationName(); - - const bool is_method = false; - const unsigned int num_params = function_type->getNumParams(); - if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount(is_method, op_kind, num_params)) - return clang::DeclarationName(); - - return getASTContext()->DeclarationNames.getCXXOperatorName(op_kind); -} - -FunctionDecl * -ClangASTContext::CreateFunctionDeclaration (DeclContext *decl_ctx, - const char *name, - const CompilerType &function_clang_type, - int storage, - bool is_inline) -{ - FunctionDecl *func_decl = nullptr; - ASTContext *ast = getASTContext(); - if (decl_ctx == nullptr) - decl_ctx = ast->getTranslationUnitDecl(); - - - const bool hasWrittenPrototype = true; - const bool isConstexprSpecified = false; - - clang::DeclarationName declarationName = GetDeclarationName(name, function_clang_type); - func_decl = FunctionDecl::Create(*ast, decl_ctx, SourceLocation(), SourceLocation(), declarationName, - ClangUtil::GetQualType(function_clang_type), nullptr, (clang::StorageClass)storage, - is_inline, hasWrittenPrototype, isConstexprSpecified); - if (func_decl) - decl_ctx->addDecl (func_decl); - #ifdef LLDB_CONFIGURATION_DEBUG - VerifyDecl(func_decl); + VerifyDecl(func_decl); #endif - - return func_decl; + + return func_decl; +} + +CompilerType ClangASTContext::CreateFunctionType( + ASTContext *ast, const CompilerType &result_type, const CompilerType *args, + unsigned num_args, bool is_variadic, unsigned type_quals) { + if (ast == nullptr) + return CompilerType(); // invalid AST + + if (!result_type || !ClangUtil::IsClangType(result_type)) + return CompilerType(); // invalid return type + + std::vector<QualType> qual_type_args; + if (num_args > 0 && args == nullptr) + return CompilerType(); // invalid argument array passed in + + // Verify that all arguments are valid and the right type + for (unsigned i = 0; i < num_args; ++i) { + if (args[i]) { + // Make sure we have a clang type in args[i] and not a type from another + // language whose name might match + const bool is_clang_type = ClangUtil::IsClangType(args[i]); + lldbassert(is_clang_type); + if (is_clang_type) + qual_type_args.push_back(ClangUtil::GetQualType(args[i])); + else + return CompilerType(); // invalid argument type (must be a clang type) + } else + return CompilerType(); // invalid argument type (empty) + } + + // TODO: Detect calling convention in DWARF? + FunctionProtoType::ExtProtoInfo proto_info; + proto_info.Variadic = is_variadic; + proto_info.ExceptionSpec = EST_None; + proto_info.TypeQuals = type_quals; + proto_info.RefQualifier = RQ_None; + + return CompilerType(ast, + ast->getFunctionType(ClangUtil::GetQualType(result_type), + qual_type_args, proto_info)); +} + +ParmVarDecl *ClangASTContext::CreateParameterDeclaration( + const char *name, const CompilerType ¶m_type, int storage) { + ASTContext *ast = getASTContext(); + assert(ast != nullptr); + return ParmVarDecl::Create(*ast, ast->getTranslationUnitDecl(), + SourceLocation(), SourceLocation(), + name && name[0] ? &ast->Idents.get(name) : nullptr, + ClangUtil::GetQualType(param_type), nullptr, + (clang::StorageClass)storage, nullptr); +} + +void ClangASTContext::SetFunctionParameters(FunctionDecl *function_decl, + ParmVarDecl **params, + unsigned num_params) { + if (function_decl) + function_decl->setParams(ArrayRef<ParmVarDecl *>(params, num_params)); } CompilerType -ClangASTContext::CreateFunctionType (ASTContext *ast, - const CompilerType& result_type, - const CompilerType *args, - unsigned num_args, - bool is_variadic, - unsigned type_quals) -{ - if (ast == nullptr) - return CompilerType(); // invalid AST - - if (!result_type || !ClangUtil::IsClangType(result_type)) - return CompilerType(); // invalid return type - - std::vector<QualType> qual_type_args; - if (num_args > 0 && args == nullptr) - return CompilerType(); // invalid argument array passed in - - // Verify that all arguments are valid and the right type - for (unsigned i=0; i<num_args; ++i) - { - if (args[i]) - { - // Make sure we have a clang type in args[i] and not a type from another - // language whose name might match - const bool is_clang_type = ClangUtil::IsClangType(args[i]); - lldbassert(is_clang_type); - if (is_clang_type) - qual_type_args.push_back(ClangUtil::GetQualType(args[i])); - else - return CompilerType(); // invalid argument type (must be a clang type) - } - else - return CompilerType(); // invalid argument type (empty) - } +ClangASTContext::CreateBlockPointerType(const CompilerType &function_type) { + QualType block_type = m_ast_ap->getBlockPointerType( + clang::QualType::getFromOpaquePtr(function_type.GetOpaqueQualType())); - // TODO: Detect calling convention in DWARF? - FunctionProtoType::ExtProtoInfo proto_info; - proto_info.Variadic = is_variadic; - proto_info.ExceptionSpec = EST_None; - proto_info.TypeQuals = type_quals; - proto_info.RefQualifier = RQ_None; - - return CompilerType(ast, ast->getFunctionType(ClangUtil::GetQualType(result_type), qual_type_args, proto_info)); + return CompilerType(this, block_type.getAsOpaquePtr()); } -ParmVarDecl * -ClangASTContext::CreateParameterDeclaration (const char *name, const CompilerType ¶m_type, int storage) -{ - ASTContext *ast = getASTContext(); - assert (ast != nullptr); - return ParmVarDecl::Create(*ast, ast->getTranslationUnitDecl(), SourceLocation(), SourceLocation(), - name && name[0] ? &ast->Idents.get(name) : nullptr, ClangUtil::GetQualType(param_type), - nullptr, (clang::StorageClass)storage, nullptr); -} +#pragma mark Array Types -void -ClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params) -{ - if (function_decl) - function_decl->setParams (ArrayRef<ParmVarDecl*>(params, num_params)); -} +CompilerType ClangASTContext::CreateArrayType(const CompilerType &element_type, + size_t element_count, + bool is_vector) { + if (element_type.IsValid()) { + ASTContext *ast = getASTContext(); + assert(ast != nullptr); + + if (is_vector) { + return CompilerType( + ast, ast->getExtVectorType(ClangUtil::GetQualType(element_type), + element_count)); + } else { + + llvm::APInt ap_element_count(64, element_count); + if (element_count == 0) { + return CompilerType(ast, ast->getIncompleteArrayType( + ClangUtil::GetQualType(element_type), + clang::ArrayType::Normal, 0)); + } else { + return CompilerType( + ast, ast->getConstantArrayType(ClangUtil::GetQualType(element_type), + ap_element_count, + clang::ArrayType::Normal, 0)); + } + } + } + return CompilerType(); +} + +CompilerType ClangASTContext::CreateStructForIdentifier( + const ConstString &type_name, + const std::initializer_list<std::pair<const char *, CompilerType>> + &type_fields, + bool packed) { + CompilerType type; + if (!type_name.IsEmpty() && + (type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)) + .IsValid()) { + lldbassert("Trying to create a type for an existing name"); + return type; + } + + type = CreateRecordType(nullptr, lldb::eAccessPublic, type_name.GetCString(), + clang::TTK_Struct, lldb::eLanguageTypeC); + StartTagDeclarationDefinition(type); + for (const auto &field : type_fields) + AddFieldToRecordType(type, field.first, field.second, lldb::eAccessPublic, + 0); + if (packed) + SetIsPacked(type); + CompleteTagDeclarationDefinition(type); + return type; +} + +CompilerType ClangASTContext::GetOrCreateStructForIdentifier( + const ConstString &type_name, + const std::initializer_list<std::pair<const char *, CompilerType>> + &type_fields, + bool packed) { + CompilerType type; + if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid()) + return type; -CompilerType -ClangASTContext::CreateBlockPointerType (const CompilerType &function_type) -{ - QualType block_type = m_ast_ap->getBlockPointerType(clang::QualType::getFromOpaquePtr(function_type.GetOpaqueQualType())); - - return CompilerType (this, block_type.getAsOpaquePtr()); + return CreateStructForIdentifier(type_name, type_fields, packed); } -#pragma mark Array Types - -CompilerType -ClangASTContext::CreateArrayType (const CompilerType &element_type, - size_t element_count, - bool is_vector) -{ - if (element_type.IsValid()) - { - ASTContext *ast = getASTContext(); - assert (ast != nullptr); - - if (is_vector) - { - return CompilerType(ast, ast->getExtVectorType(ClangUtil::GetQualType(element_type), element_count)); - } - else - { - - llvm::APInt ap_element_count (64, element_count); - if (element_count == 0) - { - return CompilerType(ast, ast->getIncompleteArrayType(ClangUtil::GetQualType(element_type), - clang::ArrayType::Normal, 0)); - } - else - { - return CompilerType(ast, ast->getConstantArrayType(ClangUtil::GetQualType(element_type), - ap_element_count, clang::ArrayType::Normal, 0)); - } - } - } - return CompilerType(); -} +#pragma mark Enumeration Types CompilerType -ClangASTContext::CreateStructForIdentifier (const ConstString &type_name, - const std::initializer_list< std::pair < const char *, CompilerType > >& type_fields, - bool packed) -{ - CompilerType type; - if (!type_name.IsEmpty() && (type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid()) - { - lldbassert("Trying to create a type for an existing name"); - return type; - } - - type = CreateRecordType(nullptr, lldb::eAccessPublic, type_name.GetCString(), clang::TTK_Struct, lldb::eLanguageTypeC); - StartTagDeclarationDefinition(type); - for (const auto& field : type_fields) - AddFieldToRecordType(type, field.first, field.second, lldb::eAccessPublic, 0); - if (packed) - SetIsPacked(type); - CompleteTagDeclarationDefinition(type); - return type; -} +ClangASTContext::CreateEnumerationType(const char *name, DeclContext *decl_ctx, + const Declaration &decl, + const CompilerType &integer_clang_type) { + // TODO: Do something intelligent with the Declaration object passed in + // like maybe filling in the SourceLocation with it... + ASTContext *ast = getASTContext(); -CompilerType -ClangASTContext::GetOrCreateStructForIdentifier (const ConstString &type_name, - const std::initializer_list< std::pair < const char *, CompilerType > >& type_fields, - bool packed) -{ - CompilerType type; - if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid()) - return type; + // TODO: ask about these... + // const bool IsScoped = false; + // const bool IsFixed = false; - return CreateStructForIdentifier (type_name, - type_fields, - packed); -} + EnumDecl *enum_decl = EnumDecl::Create( + *ast, decl_ctx, SourceLocation(), SourceLocation(), + name && name[0] ? &ast->Idents.get(name) : nullptr, nullptr, + false, // IsScoped + false, // IsScopedUsingClassTag + false); // IsFixed -#pragma mark Enumeration Types + if (enum_decl) { + // TODO: check if we should be setting the promotion type too? + enum_decl->setIntegerType(ClangUtil::GetQualType(integer_clang_type)); -CompilerType -ClangASTContext::CreateEnumerationType -( - const char *name, - DeclContext *decl_ctx, - const Declaration &decl, - const CompilerType &integer_clang_type - ) -{ - // TODO: Do something intelligent with the Declaration object passed in - // like maybe filling in the SourceLocation with it... - ASTContext *ast = getASTContext(); - - // TODO: ask about these... - // const bool IsScoped = false; - // const bool IsFixed = false; - - EnumDecl *enum_decl = EnumDecl::Create (*ast, - decl_ctx, - SourceLocation(), - SourceLocation(), - name && name[0] ? &ast->Idents.get(name) : nullptr, - nullptr, - false, // IsScoped - false, // IsScopedUsingClassTag - false); // IsFixed - - - if (enum_decl) - { - // TODO: check if we should be setting the promotion type too? - enum_decl->setIntegerType(ClangUtil::GetQualType(integer_clang_type)); + enum_decl->setAccess(AS_public); // TODO respect what's in the debug info - enum_decl->setAccess(AS_public); // TODO respect what's in the debug info - - return CompilerType (ast, ast->getTagDeclType(enum_decl)); - } - return CompilerType(); + return CompilerType(ast, ast->getTagDeclType(enum_decl)); + } + return CompilerType(); } // Disable this for now since I can't seem to get a nicely formatted float @@ -2455,8 +2177,10 @@ ClangASTContext::CreateEnumerationType // would like to get perfect string values for any kind of float semantics // so we can support remote targets. The code below also requires a patch to // llvm::APInt. -//bool -//ClangASTContext::ConvertFloatValueToString (ASTContext *ast, lldb::opaque_compiler_type_t clang_type, const uint8_t* bytes, size_t byte_size, int apint_byte_order, std::string &float_str) +// bool +// ClangASTContext::ConvertFloatValueToString (ASTContext *ast, +// lldb::opaque_compiler_type_t clang_type, const uint8_t* bytes, size_t +// byte_size, int apint_byte_order, std::string &float_str) //{ // uint32_t count = 0; // bool is_complex = false; @@ -2469,14 +2193,16 @@ ClangASTContext::CreateEnumerationType // uint32_t i; // for (i=0; i<count; i++) // { -// APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, (APInt::ByteOrder)apint_byte_order); +// APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, +// (APInt::ByteOrder)apint_byte_order); // bool is_ieee = false; // APFloat ap_float(ap_int, is_ieee); // char s[1024]; // unsigned int hex_digits = 0; // bool upper_case = false; // -// if (ap_float.convertToHexString(s, hex_digits, upper_case, APFloat::rmNearestTiesToEven) > 0) +// if (ap_float.convertToHexString(s, hex_digits, upper_case, +// APFloat::rmNearestTiesToEven) > 0) // { // if (i > 0) // float_str.append(", "); @@ -2490,2051 +2216,2116 @@ ClangASTContext::CreateEnumerationType // return false; //} -CompilerType -ClangASTContext::GetIntTypeFromBitSize (clang::ASTContext *ast, - size_t bit_size, bool is_signed) -{ - if (ast) - { - if (is_signed) - { - if (bit_size == ast->getTypeSize(ast->SignedCharTy)) - return CompilerType(ast, ast->SignedCharTy); - - if (bit_size == ast->getTypeSize(ast->ShortTy)) - return CompilerType(ast, ast->ShortTy); - - if (bit_size == ast->getTypeSize(ast->IntTy)) - return CompilerType(ast, ast->IntTy); - - if (bit_size == ast->getTypeSize(ast->LongTy)) - return CompilerType(ast, ast->LongTy); - - if (bit_size == ast->getTypeSize(ast->LongLongTy)) - return CompilerType(ast, ast->LongLongTy); - - if (bit_size == ast->getTypeSize(ast->Int128Ty)) - return CompilerType(ast, ast->Int128Ty); +CompilerType ClangASTContext::GetIntTypeFromBitSize(clang::ASTContext *ast, + size_t bit_size, + bool is_signed) { + if (ast) { + if (is_signed) { + if (bit_size == ast->getTypeSize(ast->SignedCharTy)) + return CompilerType(ast, ast->SignedCharTy); + + if (bit_size == ast->getTypeSize(ast->ShortTy)) + return CompilerType(ast, ast->ShortTy); + + if (bit_size == ast->getTypeSize(ast->IntTy)) + return CompilerType(ast, ast->IntTy); + + if (bit_size == ast->getTypeSize(ast->LongTy)) + return CompilerType(ast, ast->LongTy); + + if (bit_size == ast->getTypeSize(ast->LongLongTy)) + return CompilerType(ast, ast->LongLongTy); + + if (bit_size == ast->getTypeSize(ast->Int128Ty)) + return CompilerType(ast, ast->Int128Ty); + } else { + if (bit_size == ast->getTypeSize(ast->UnsignedCharTy)) + return CompilerType(ast, ast->UnsignedCharTy); + + if (bit_size == ast->getTypeSize(ast->UnsignedShortTy)) + return CompilerType(ast, ast->UnsignedShortTy); + + if (bit_size == ast->getTypeSize(ast->UnsignedIntTy)) + return CompilerType(ast, ast->UnsignedIntTy); + + if (bit_size == ast->getTypeSize(ast->UnsignedLongTy)) + return CompilerType(ast, ast->UnsignedLongTy); + + if (bit_size == ast->getTypeSize(ast->UnsignedLongLongTy)) + return CompilerType(ast, ast->UnsignedLongLongTy); + + if (bit_size == ast->getTypeSize(ast->UnsignedInt128Ty)) + return CompilerType(ast, ast->UnsignedInt128Ty); + } + } + return CompilerType(); +} + +CompilerType ClangASTContext::GetPointerSizedIntType(clang::ASTContext *ast, + bool is_signed) { + if (ast) + return GetIntTypeFromBitSize(ast, ast->getTypeSize(ast->VoidPtrTy), + is_signed); + return CompilerType(); +} + +void ClangASTContext::DumpDeclContextHiearchy(clang::DeclContext *decl_ctx) { + if (decl_ctx) { + DumpDeclContextHiearchy(decl_ctx->getParent()); + + clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl_ctx); + if (named_decl) { + printf("%20s: %s\n", decl_ctx->getDeclKindName(), + named_decl->getDeclName().getAsString().c_str()); + } else { + printf("%20s\n", decl_ctx->getDeclKindName()); + } + } +} + +void ClangASTContext::DumpDeclHiearchy(clang::Decl *decl) { + if (decl == nullptr) + return; + DumpDeclContextHiearchy(decl->getDeclContext()); + + clang::RecordDecl *record_decl = llvm::dyn_cast<clang::RecordDecl>(decl); + if (record_decl) { + printf("%20s: %s%s\n", decl->getDeclKindName(), + record_decl->getDeclName().getAsString().c_str(), + record_decl->isInjectedClassName() ? " (injected class name)" : ""); + + } else { + clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl); + if (named_decl) { + printf("%20s: %s\n", decl->getDeclKindName(), + named_decl->getDeclName().getAsString().c_str()); + } else { + printf("%20s\n", decl->getDeclKindName()); + } + } +} + +bool ClangASTContext::DeclsAreEquivalent(clang::Decl *lhs_decl, + clang::Decl *rhs_decl) { + if (lhs_decl && rhs_decl) { + //---------------------------------------------------------------------- + // Make sure the decl kinds match first + //---------------------------------------------------------------------- + const clang::Decl::Kind lhs_decl_kind = lhs_decl->getKind(); + const clang::Decl::Kind rhs_decl_kind = rhs_decl->getKind(); + + if (lhs_decl_kind == rhs_decl_kind) { + //------------------------------------------------------------------ + // Now check that the decl contexts kinds are all equivalent + // before we have to check any names of the decl contexts... + //------------------------------------------------------------------ + clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext(); + clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext(); + if (lhs_decl_ctx && rhs_decl_ctx) { + while (1) { + if (lhs_decl_ctx && rhs_decl_ctx) { + const clang::Decl::Kind lhs_decl_ctx_kind = + lhs_decl_ctx->getDeclKind(); + const clang::Decl::Kind rhs_decl_ctx_kind = + rhs_decl_ctx->getDeclKind(); + if (lhs_decl_ctx_kind == rhs_decl_ctx_kind) { + lhs_decl_ctx = lhs_decl_ctx->getParent(); + rhs_decl_ctx = rhs_decl_ctx->getParent(); + + if (lhs_decl_ctx == nullptr && rhs_decl_ctx == nullptr) + break; + } else + return false; + } else + return false; } - else - { - if (bit_size == ast->getTypeSize(ast->UnsignedCharTy)) - return CompilerType(ast, ast->UnsignedCharTy); - - if (bit_size == ast->getTypeSize(ast->UnsignedShortTy)) - return CompilerType(ast, ast->UnsignedShortTy); - - if (bit_size == ast->getTypeSize(ast->UnsignedIntTy)) - return CompilerType(ast, ast->UnsignedIntTy); - - if (bit_size == ast->getTypeSize(ast->UnsignedLongTy)) - return CompilerType(ast, ast->UnsignedLongTy); - - if (bit_size == ast->getTypeSize(ast->UnsignedLongLongTy)) - return CompilerType(ast, ast->UnsignedLongLongTy); - - if (bit_size == ast->getTypeSize(ast->UnsignedInt128Ty)) - return CompilerType(ast, ast->UnsignedInt128Ty); + + //-------------------------------------------------------------- + // Now make sure the name of the decls match + //-------------------------------------------------------------- + clang::NamedDecl *lhs_named_decl = + llvm::dyn_cast<clang::NamedDecl>(lhs_decl); + clang::NamedDecl *rhs_named_decl = + llvm::dyn_cast<clang::NamedDecl>(rhs_decl); + if (lhs_named_decl && rhs_named_decl) { + clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName(); + clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName(); + if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) { + if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString()) + return false; + } else + return false; + } else + return false; + + //-------------------------------------------------------------- + // We know that the decl context kinds all match, so now we need + // to make sure the names match as well + //-------------------------------------------------------------- + lhs_decl_ctx = lhs_decl->getDeclContext(); + rhs_decl_ctx = rhs_decl->getDeclContext(); + while (1) { + switch (lhs_decl_ctx->getDeclKind()) { + case clang::Decl::TranslationUnit: + // We don't care about the translation unit names + return true; + default: { + clang::NamedDecl *lhs_named_decl = + llvm::dyn_cast<clang::NamedDecl>(lhs_decl_ctx); + clang::NamedDecl *rhs_named_decl = + llvm::dyn_cast<clang::NamedDecl>(rhs_decl_ctx); + if (lhs_named_decl && rhs_named_decl) { + clang::DeclarationName lhs_decl_name = + lhs_named_decl->getDeclName(); + clang::DeclarationName rhs_decl_name = + rhs_named_decl->getDeclName(); + if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) { + if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString()) + return false; + } else + return false; + } else + return false; + } break; + } + lhs_decl_ctx = lhs_decl_ctx->getParent(); + rhs_decl_ctx = rhs_decl_ctx->getParent(); } + } } - return CompilerType(); + } + return false; } +bool ClangASTContext::GetCompleteDecl(clang::ASTContext *ast, + clang::Decl *decl) { + if (!decl) + return false; -CompilerType -ClangASTContext::GetPointerSizedIntType (clang::ASTContext *ast, bool is_signed) -{ - if (ast) - return GetIntTypeFromBitSize(ast, ast->getTypeSize(ast->VoidPtrTy), is_signed); - return CompilerType(); -} + ExternalASTSource *ast_source = ast->getExternalSource(); -void -ClangASTContext::DumpDeclContextHiearchy (clang::DeclContext *decl_ctx) -{ - if (decl_ctx) - { - DumpDeclContextHiearchy (decl_ctx->getParent()); + if (!ast_source) + return false; - clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl_ctx); - if (named_decl) - { - printf ("%20s: %s\n", decl_ctx->getDeclKindName(), named_decl->getDeclName().getAsString().c_str()); - } - else - { - printf ("%20s\n", decl_ctx->getDeclKindName()); - } - } -} + if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) { + if (tag_decl->isCompleteDefinition()) + return true; -void -ClangASTContext::DumpDeclHiearchy (clang::Decl *decl) -{ - if (decl == nullptr) - return; - DumpDeclContextHiearchy(decl->getDeclContext()); + if (!tag_decl->hasExternalLexicalStorage()) + return false; - clang::RecordDecl *record_decl = llvm::dyn_cast<clang::RecordDecl>(decl); - if (record_decl) - { - printf ("%20s: %s%s\n", decl->getDeclKindName(), record_decl->getDeclName().getAsString().c_str(), record_decl->isInjectedClassName() ? " (injected class name)" : ""); + ast_source->CompleteType(tag_decl); - } - else - { - clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl); - if (named_decl) - { - printf ("%20s: %s\n", decl->getDeclKindName(), named_decl->getDeclName().getAsString().c_str()); - } - else - { - printf ("%20s\n", decl->getDeclKindName()); - } - } -} + return !tag_decl->getTypeForDecl()->isIncompleteType(); + } else if (clang::ObjCInterfaceDecl *objc_interface_decl = + llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) { + if (objc_interface_decl->getDefinition()) + return true; -bool -ClangASTContext::DeclsAreEquivalent (clang::Decl *lhs_decl, clang::Decl *rhs_decl) -{ - if (lhs_decl && rhs_decl) - { - //---------------------------------------------------------------------- - // Make sure the decl kinds match first - //---------------------------------------------------------------------- - const clang::Decl::Kind lhs_decl_kind = lhs_decl->getKind(); - const clang::Decl::Kind rhs_decl_kind = rhs_decl->getKind(); - - if (lhs_decl_kind == rhs_decl_kind) - { - //------------------------------------------------------------------ - // Now check that the decl contexts kinds are all equivalent - // before we have to check any names of the decl contexts... - //------------------------------------------------------------------ - clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext(); - clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext(); - if (lhs_decl_ctx && rhs_decl_ctx) - { - while (1) - { - if (lhs_decl_ctx && rhs_decl_ctx) - { - const clang::Decl::Kind lhs_decl_ctx_kind = lhs_decl_ctx->getDeclKind(); - const clang::Decl::Kind rhs_decl_ctx_kind = rhs_decl_ctx->getDeclKind(); - if (lhs_decl_ctx_kind == rhs_decl_ctx_kind) - { - lhs_decl_ctx = lhs_decl_ctx->getParent(); - rhs_decl_ctx = rhs_decl_ctx->getParent(); - - if (lhs_decl_ctx == nullptr && rhs_decl_ctx == nullptr) - break; - } - else - return false; - } - else - return false; - } + if (!objc_interface_decl->hasExternalLexicalStorage()) + return false; - //-------------------------------------------------------------- - // Now make sure the name of the decls match - //-------------------------------------------------------------- - clang::NamedDecl *lhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(lhs_decl); - clang::NamedDecl *rhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(rhs_decl); - if (lhs_named_decl && rhs_named_decl) - { - clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName(); - clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName(); - if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) - { - if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString()) - return false; - } - else - return false; - } - else - return false; - - //-------------------------------------------------------------- - // We know that the decl context kinds all match, so now we need - // to make sure the names match as well - //-------------------------------------------------------------- - lhs_decl_ctx = lhs_decl->getDeclContext(); - rhs_decl_ctx = rhs_decl->getDeclContext(); - while (1) - { - switch (lhs_decl_ctx->getDeclKind()) - { - case clang::Decl::TranslationUnit: - // We don't care about the translation unit names - return true; - default: - { - clang::NamedDecl *lhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(lhs_decl_ctx); - clang::NamedDecl *rhs_named_decl = llvm::dyn_cast<clang::NamedDecl>(rhs_decl_ctx); - if (lhs_named_decl && rhs_named_decl) - { - clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName(); - clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName(); - if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) - { - if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString()) - return false; - } - else - return false; - } - else - return false; - } - break; + ast_source->CompleteType(objc_interface_decl); - } - lhs_decl_ctx = lhs_decl_ctx->getParent(); - rhs_decl_ctx = rhs_decl_ctx->getParent(); - } - } - } - } + return !objc_interface_decl->getTypeForDecl()->isIncompleteType(); + } else { return false; -} -bool -ClangASTContext::GetCompleteDecl (clang::ASTContext *ast, - clang::Decl *decl) -{ - if (!decl) - return false; - - ExternalASTSource *ast_source = ast->getExternalSource(); - - if (!ast_source) - return false; - - if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) - { - if (tag_decl->isCompleteDefinition()) - return true; - - if (!tag_decl->hasExternalLexicalStorage()) - return false; - - ast_source->CompleteType(tag_decl); - - return !tag_decl->getTypeForDecl()->isIncompleteType(); - } - else if (clang::ObjCInterfaceDecl *objc_interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) - { - if (objc_interface_decl->getDefinition()) - return true; - - if (!objc_interface_decl->hasExternalLexicalStorage()) - return false; - - ast_source->CompleteType(objc_interface_decl); - - return !objc_interface_decl->getTypeForDecl()->isIncompleteType(); - } - else - { - return false; - } + } } -void -ClangASTContext::SetMetadataAsUserID (const void *object, - user_id_t user_id) -{ - ClangASTMetadata meta_data; - meta_data.SetUserID (user_id); - SetMetadata (object, meta_data); +void ClangASTContext::SetMetadataAsUserID(const void *object, + user_id_t user_id) { + ClangASTMetadata meta_data; + meta_data.SetUserID(user_id); + SetMetadata(object, meta_data); } -void -ClangASTContext::SetMetadata (clang::ASTContext *ast, - const void *object, - ClangASTMetadata &metadata) -{ - ClangExternalASTSourceCommon *external_source = - ClangExternalASTSourceCommon::Lookup(ast->getExternalSource()); - - if (external_source) - external_source->SetMetadata(object, metadata); -} +void ClangASTContext::SetMetadata(clang::ASTContext *ast, const void *object, + ClangASTMetadata &metadata) { + ClangExternalASTSourceCommon *external_source = + ClangExternalASTSourceCommon::Lookup(ast->getExternalSource()); -ClangASTMetadata * -ClangASTContext::GetMetadata (clang::ASTContext *ast, - const void *object) -{ - ClangExternalASTSourceCommon *external_source = - ClangExternalASTSourceCommon::Lookup(ast->getExternalSource()); - - if (external_source && external_source->HasMetadata(object)) - return external_source->GetMetadata(object); - else - return nullptr; + if (external_source) + external_source->SetMetadata(object, metadata); } -clang::DeclContext * -ClangASTContext::GetAsDeclContext (clang::CXXMethodDecl *cxx_method_decl) -{ - return llvm::dyn_cast<clang::DeclContext>(cxx_method_decl); +ClangASTMetadata *ClangASTContext::GetMetadata(clang::ASTContext *ast, + const void *object) { + ClangExternalASTSourceCommon *external_source = + ClangExternalASTSourceCommon::Lookup(ast->getExternalSource()); + + if (external_source && external_source->HasMetadata(object)) + return external_source->GetMetadata(object); + else + return nullptr; } clang::DeclContext * -ClangASTContext::GetAsDeclContext (clang::ObjCMethodDecl *objc_method_decl) -{ - return llvm::dyn_cast<clang::DeclContext>(objc_method_decl); +ClangASTContext::GetAsDeclContext(clang::CXXMethodDecl *cxx_method_decl) { + return llvm::dyn_cast<clang::DeclContext>(cxx_method_decl); } -bool -ClangASTContext::SetTagTypeKind (clang::QualType tag_qual_type, int kind) const -{ - const clang::Type *clang_type = tag_qual_type.getTypePtr(); - if (clang_type) - { - const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(clang_type); - if (tag_type) - { - clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(tag_type->getDecl()); - if (tag_decl) - { - tag_decl->setTagKind ((clang::TagDecl::TagKind)kind); - return true; - } - } +clang::DeclContext * +ClangASTContext::GetAsDeclContext(clang::ObjCMethodDecl *objc_method_decl) { + return llvm::dyn_cast<clang::DeclContext>(objc_method_decl); +} + +bool ClangASTContext::SetTagTypeKind(clang::QualType tag_qual_type, + int kind) const { + const clang::Type *clang_type = tag_qual_type.getTypePtr(); + if (clang_type) { + const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(clang_type); + if (tag_type) { + clang::TagDecl *tag_decl = + llvm::dyn_cast<clang::TagDecl>(tag_type->getDecl()); + if (tag_decl) { + tag_decl->setTagKind((clang::TagDecl::TagKind)kind); + return true; + } } - return false; + } + return false; } - -bool -ClangASTContext::SetDefaultAccessForRecordFields (clang::RecordDecl* record_decl, - int default_accessibility, - int *assigned_accessibilities, - size_t num_assigned_accessibilities) -{ - if (record_decl) - { - uint32_t field_idx; - clang::RecordDecl::field_iterator field, field_end; - for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0; - field != field_end; - ++field, ++field_idx) - { - // If no accessibility was assigned, assign the correct one - if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none) - field->setAccess ((clang::AccessSpecifier)default_accessibility); - } - return true; +bool ClangASTContext::SetDefaultAccessForRecordFields( + clang::RecordDecl *record_decl, int default_accessibility, + int *assigned_accessibilities, size_t num_assigned_accessibilities) { + if (record_decl) { + uint32_t field_idx; + clang::RecordDecl::field_iterator field, field_end; + for (field = record_decl->field_begin(), + field_end = record_decl->field_end(), field_idx = 0; + field != field_end; ++field, ++field_idx) { + // If no accessibility was assigned, assign the correct one + if (field_idx < num_assigned_accessibilities && + assigned_accessibilities[field_idx] == clang::AS_none) + field->setAccess((clang::AccessSpecifier)default_accessibility); } - return false; + return true; + } + return false; } clang::DeclContext * -ClangASTContext::GetDeclContextForType (const CompilerType& type) -{ - return GetDeclContextForType(ClangUtil::GetQualType(type)); +ClangASTContext::GetDeclContextForType(const CompilerType &type) { + return GetDeclContextForType(ClangUtil::GetQualType(type)); } clang::DeclContext * -ClangASTContext::GetDeclContextForType (clang::QualType type) -{ - if (type.isNull()) - return nullptr; - - clang::QualType qual_type = type.getCanonicalType(); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::ObjCInterface: return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr())->getInterface(); - case clang::Type::ObjCObjectPointer: return GetDeclContextForType (llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()); - case clang::Type::Record: return llvm::cast<clang::RecordType>(qual_type)->getDecl(); - case clang::Type::Enum: return llvm::cast<clang::EnumType>(qual_type)->getDecl(); - case clang::Type::Typedef: return GetDeclContextForType (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()); - case clang::Type::Auto: return GetDeclContextForType (llvm::cast<clang::AutoType>(qual_type)->getDeducedType()); - case clang::Type::Elaborated: return GetDeclContextForType (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()); - case clang::Type::Paren: return GetDeclContextForType (llvm::cast<clang::ParenType>(qual_type)->desugar()); - default: - break; - } - // No DeclContext in this type... +ClangASTContext::GetDeclContextForType(clang::QualType type) { + if (type.isNull()) return nullptr; -} -static bool -GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type, bool allow_completion = true) -{ - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::ConstantArray: - case clang::Type::IncompleteArray: - case clang::Type::VariableArray: - { - const clang::ArrayType *array_type = llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr()); - - if (array_type) - return GetCompleteQualType (ast, array_type->getElementType(), allow_completion); - } - break; - case clang::Type::Record: - { - clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - { - if (cxx_record_decl->hasExternalLexicalStorage()) - { - const bool is_complete = cxx_record_decl->isCompleteDefinition(); - const bool fields_loaded = cxx_record_decl->hasLoadedFieldsFromExternalStorage(); - if (is_complete && fields_loaded) - return true; - - if (!allow_completion) - return false; - - // Call the field_begin() accessor to for it to use the external source - // to load the fields... - clang::ExternalASTSource *external_ast_source = ast->getExternalSource(); - if (external_ast_source) - { - external_ast_source->CompleteType(cxx_record_decl); - if (cxx_record_decl->isCompleteDefinition()) - { - cxx_record_decl->field_begin(); - cxx_record_decl->setHasLoadedFieldsFromExternalStorage (true); - } - } - } - } - const clang::TagType *tag_type = llvm::cast<clang::TagType>(qual_type.getTypePtr()); - return !tag_type->isIncompleteType(); + clang::QualType qual_type = type.getCanonicalType(); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::ObjCInterface: + return llvm::cast<clang::ObjCObjectType>(qual_type.getTypePtr()) + ->getInterface(); + case clang::Type::ObjCObjectPointer: + return GetDeclContextForType( + llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr()) + ->getPointeeType()); + case clang::Type::Record: + return llvm::cast<clang::RecordType>(qual_type)->getDecl(); + case clang::Type::Enum: + return llvm::cast<clang::EnumType>(qual_type)->getDecl(); + case clang::Type::Typedef: + return GetDeclContextForType(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()); + case clang::Type::Auto: + return GetDeclContextForType( + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()); + case clang::Type::Elaborated: + return GetDeclContextForType( + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()); + case clang::Type::Paren: + return GetDeclContextForType( + llvm::cast<clang::ParenType>(qual_type)->desugar()); + default: + break; + } + // No DeclContext in this type... + return nullptr; +} + +static bool GetCompleteQualType(clang::ASTContext *ast, + clang::QualType qual_type, + bool allow_completion = true) { + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::ConstantArray: + case clang::Type::IncompleteArray: + case clang::Type::VariableArray: { + const clang::ArrayType *array_type = + llvm::dyn_cast<clang::ArrayType>(qual_type.getTypePtr()); + + if (array_type) + return GetCompleteQualType(ast, array_type->getElementType(), + allow_completion); + } break; + case clang::Type::Record: { + clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) { + if (cxx_record_decl->hasExternalLexicalStorage()) { + const bool is_complete = cxx_record_decl->isCompleteDefinition(); + const bool fields_loaded = + cxx_record_decl->hasLoadedFieldsFromExternalStorage(); + if (is_complete && fields_loaded) + return true; + + if (!allow_completion) + return false; + + // Call the field_begin() accessor to for it to use the external source + // to load the fields... + clang::ExternalASTSource *external_ast_source = + ast->getExternalSource(); + if (external_ast_source) { + external_ast_source->CompleteType(cxx_record_decl); + if (cxx_record_decl->isCompleteDefinition()) { + cxx_record_decl->field_begin(); + cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true); + } + } + } + } + const clang::TagType *tag_type = + llvm::cast<clang::TagType>(qual_type.getTypePtr()); + return !tag_type->isIncompleteType(); + } break; + + case clang::Type::Enum: { + const clang::TagType *tag_type = + llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr()); + if (tag_type) { + clang::TagDecl *tag_decl = tag_type->getDecl(); + if (tag_decl) { + if (tag_decl->getDefinition()) + return true; + + if (!allow_completion) + return false; + + if (tag_decl->hasExternalLexicalStorage()) { + if (ast) { + clang::ExternalASTSource *external_ast_source = + ast->getExternalSource(); + if (external_ast_source) { + external_ast_source->CompleteType(tag_decl); + return !tag_type->isIncompleteType(); } - break; + } + } + return false; + } + } - case clang::Type::Enum: - { - const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr()); - if (tag_type) - { - clang::TagDecl *tag_decl = tag_type->getDecl(); - if (tag_decl) - { - if (tag_decl->getDefinition()) - return true; - - if (!allow_completion) - return false; - - if (tag_decl->hasExternalLexicalStorage()) - { - if (ast) - { - clang::ExternalASTSource *external_ast_source = ast->getExternalSource(); - if (external_ast_source) - { - external_ast_source->CompleteType(tag_decl); - return !tag_type->isIncompleteType(); - } - } - } - return false; - } - } - - } - break; - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - // We currently can't complete objective C types through the newly added ASTContext - // because it only supports TagDecl objects right now... - if (class_interface_decl) - { - if (class_interface_decl->getDefinition()) - return true; - - if (!allow_completion) - return false; - - if (class_interface_decl->hasExternalLexicalStorage()) - { - if (ast) - { - clang::ExternalASTSource *external_ast_source = ast->getExternalSource(); - if (external_ast_source) - { - external_ast_source->CompleteType (class_interface_decl); - return !objc_class_type->isIncompleteType(); - } - } - } - return false; - } - } + } break; + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + // We currently can't complete objective C types through the newly added + // ASTContext + // because it only supports TagDecl objects right now... + if (class_interface_decl) { + if (class_interface_decl->getDefinition()) + return true; + + if (!allow_completion) + return false; + + if (class_interface_decl->hasExternalLexicalStorage()) { + if (ast) { + clang::ExternalASTSource *external_ast_source = + ast->getExternalSource(); + if (external_ast_source) { + external_ast_source->CompleteType(class_interface_decl); + return !objc_class_type->isIncompleteType(); } - break; - - case clang::Type::Typedef: - return GetCompleteQualType (ast, llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType(), allow_completion); - - case clang::Type::Auto: - return GetCompleteQualType (ast, llvm::cast<clang::AutoType>(qual_type)->getDeducedType(), allow_completion); - - case clang::Type::Elaborated: - return GetCompleteQualType (ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType(), allow_completion); - - case clang::Type::Paren: - return GetCompleteQualType (ast, llvm::cast<clang::ParenType>(qual_type)->desugar(), allow_completion); - - case clang::Type::Attributed: - return GetCompleteQualType (ast, llvm::cast<clang::AttributedType>(qual_type)->getModifiedType(), allow_completion); - - default: - break; + } + } + return false; + } } - - return true; + } break; + + case clang::Type::Typedef: + return GetCompleteQualType(ast, llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType(), + allow_completion); + + case clang::Type::Auto: + return GetCompleteQualType( + ast, llvm::cast<clang::AutoType>(qual_type)->getDeducedType(), + allow_completion); + + case clang::Type::Elaborated: + return GetCompleteQualType( + ast, llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType(), + allow_completion); + + case clang::Type::Paren: + return GetCompleteQualType( + ast, llvm::cast<clang::ParenType>(qual_type)->desugar(), + allow_completion); + + case clang::Type::Attributed: + return GetCompleteQualType( + ast, llvm::cast<clang::AttributedType>(qual_type)->getModifiedType(), + allow_completion); + + default: + break; + } + + return true; } static clang::ObjCIvarDecl::AccessControl -ConvertAccessTypeToObjCIvarAccessControl (AccessType access) -{ - switch (access) - { - case eAccessNone: return clang::ObjCIvarDecl::None; - case eAccessPublic: return clang::ObjCIvarDecl::Public; - case eAccessPrivate: return clang::ObjCIvarDecl::Private; - case eAccessProtected: return clang::ObjCIvarDecl::Protected; - case eAccessPackage: return clang::ObjCIvarDecl::Package; - } +ConvertAccessTypeToObjCIvarAccessControl(AccessType access) { + switch (access) { + case eAccessNone: return clang::ObjCIvarDecl::None; + case eAccessPublic: + return clang::ObjCIvarDecl::Public; + case eAccessPrivate: + return clang::ObjCIvarDecl::Private; + case eAccessProtected: + return clang::ObjCIvarDecl::Protected; + case eAccessPackage: + return clang::ObjCIvarDecl::Package; + } + return clang::ObjCIvarDecl::None; } - //---------------------------------------------------------------------- // Tests //---------------------------------------------------------------------- -bool -ClangASTContext::IsAggregateType (lldb::opaque_compiler_type_t type) -{ - clang::QualType qual_type (GetCanonicalQualType(type)); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::IncompleteArray: - case clang::Type::VariableArray: - case clang::Type::ConstantArray: - case clang::Type::ExtVector: - case clang::Type::Vector: - case clang::Type::Record: - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - return true; - case clang::Type::Auto: - return IsAggregateType(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()); - case clang::Type::Elaborated: - return IsAggregateType(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); - case clang::Type::Typedef: - return IsAggregateType(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); - case clang::Type::Paren: - return IsAggregateType(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()); - default: - break; - } - // The clang type does have a value - return false; -} - -bool -ClangASTContext::IsAnonymousType (lldb::opaque_compiler_type_t type) -{ - clang::QualType qual_type (GetCanonicalQualType(type)); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - { - if (const clang::RecordType *record_type = llvm::dyn_cast_or_null<clang::RecordType>(qual_type.getTypePtrOrNull())) - { - if (const clang::RecordDecl *record_decl = record_type->getDecl()) - { - return record_decl->isAnonymousStructOrUnion(); - } - } - break; - } - case clang::Type::Auto: - return IsAnonymousType(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()); - case clang::Type::Elaborated: - return IsAnonymousType(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); - case clang::Type::Typedef: - return IsAnonymousType(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); - case clang::Type::Paren: - return IsAnonymousType(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()); - default: - break; - } - // The clang type does have a value - return false; -} - -bool -ClangASTContext::IsArrayType (lldb::opaque_compiler_type_t type, - CompilerType *element_type_ptr, - uint64_t *size, - bool *is_incomplete) -{ - clang::QualType qual_type (GetCanonicalQualType(type)); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - default: - break; - - case clang::Type::ConstantArray: - if (element_type_ptr) - element_type_ptr->SetCompilerType (getASTContext(), llvm::cast<clang::ConstantArrayType>(qual_type)->getElementType()); - if (size) - *size = llvm::cast<clang::ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULLONG_MAX); - if (is_incomplete) - *is_incomplete = false; - return true; - - case clang::Type::IncompleteArray: - if (element_type_ptr) - element_type_ptr->SetCompilerType (getASTContext(), llvm::cast<clang::IncompleteArrayType>(qual_type)->getElementType()); - if (size) - *size = 0; - if (is_incomplete) - *is_incomplete = true; - return true; +bool ClangASTContext::IsAggregateType(lldb::opaque_compiler_type_t type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::IncompleteArray: + case clang::Type::VariableArray: + case clang::Type::ConstantArray: + case clang::Type::ExtVector: + case clang::Type::Vector: + case clang::Type::Record: + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + return true; + case clang::Type::Auto: + return IsAggregateType(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr()); + case clang::Type::Elaborated: + return IsAggregateType(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr()); + case clang::Type::Typedef: + return IsAggregateType(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr()); + case clang::Type::Paren: + return IsAggregateType( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()); + default: + break; + } + // The clang type does have a value + return false; +} + +bool ClangASTContext::IsAnonymousType(lldb::opaque_compiler_type_t type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: { + if (const clang::RecordType *record_type = + llvm::dyn_cast_or_null<clang::RecordType>( + qual_type.getTypePtrOrNull())) { + if (const clang::RecordDecl *record_decl = record_type->getDecl()) { + return record_decl->isAnonymousStructOrUnion(); + } + } + break; + } + case clang::Type::Auto: + return IsAnonymousType(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr()); + case clang::Type::Elaborated: + return IsAnonymousType(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr()); + case clang::Type::Typedef: + return IsAnonymousType(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr()); + case clang::Type::Paren: + return IsAnonymousType( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()); + default: + break; + } + // The clang type does have a value + return false; +} + +bool ClangASTContext::IsArrayType(lldb::opaque_compiler_type_t type, + CompilerType *element_type_ptr, + uint64_t *size, bool *is_incomplete) { + clang::QualType qual_type(GetCanonicalQualType(type)); + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + default: + break; + + case clang::Type::ConstantArray: + if (element_type_ptr) + element_type_ptr->SetCompilerType( + getASTContext(), + llvm::cast<clang::ConstantArrayType>(qual_type)->getElementType()); + if (size) + *size = llvm::cast<clang::ConstantArrayType>(qual_type) + ->getSize() + .getLimitedValue(ULLONG_MAX); + if (is_incomplete) + *is_incomplete = false; + return true; - case clang::Type::VariableArray: - if (element_type_ptr) - element_type_ptr->SetCompilerType (getASTContext(), llvm::cast<clang::VariableArrayType>(qual_type)->getElementType()); - if (size) - *size = 0; - if (is_incomplete) - *is_incomplete = false; - return true; + case clang::Type::IncompleteArray: + if (element_type_ptr) + element_type_ptr->SetCompilerType( + getASTContext(), + llvm::cast<clang::IncompleteArrayType>(qual_type)->getElementType()); + if (size) + *size = 0; + if (is_incomplete) + *is_incomplete = true; + return true; - case clang::Type::DependentSizedArray: - if (element_type_ptr) - element_type_ptr->SetCompilerType (getASTContext(), llvm::cast<clang::DependentSizedArrayType>(qual_type)->getElementType()); - if (size) - *size = 0; - if (is_incomplete) - *is_incomplete = false; - return true; + case clang::Type::VariableArray: + if (element_type_ptr) + element_type_ptr->SetCompilerType( + getASTContext(), + llvm::cast<clang::VariableArrayType>(qual_type)->getElementType()); + if (size) + *size = 0; + if (is_incomplete) + *is_incomplete = false; + return true; - case clang::Type::Typedef: - return IsArrayType(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), - element_type_ptr, - size, - is_incomplete); - case clang::Type::Auto: - return IsArrayType(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), - element_type_ptr, - size, - is_incomplete); - case clang::Type::Elaborated: - return IsArrayType(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), - element_type_ptr, - size, - is_incomplete); - case clang::Type::Paren: - return IsArrayType(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), - element_type_ptr, - size, - is_incomplete); - } + case clang::Type::DependentSizedArray: if (element_type_ptr) - element_type_ptr->Clear(); + element_type_ptr->SetCompilerType( + getASTContext(), llvm::cast<clang::DependentSizedArrayType>(qual_type) + ->getElementType()); if (size) - *size = 0; + *size = 0; if (is_incomplete) - *is_incomplete = false; - return false; -} + *is_incomplete = false; + return true; -bool -ClangASTContext::IsVectorType (lldb::opaque_compiler_type_t type, - CompilerType *element_type, - uint64_t *size) -{ - clang::QualType qual_type (GetCanonicalQualType(type)); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Vector: - { - const clang::VectorType *vector_type = qual_type->getAs<clang::VectorType>(); - if (vector_type) - { - if (size) - *size = vector_type->getNumElements(); - if (element_type) - *element_type = CompilerType(getASTContext(), vector_type->getElementType()); - } - return true; - } - break; - case clang::Type::ExtVector: - { - const clang::ExtVectorType *ext_vector_type = qual_type->getAs<clang::ExtVectorType>(); - if (ext_vector_type) - { - if (size) - *size = ext_vector_type->getNumElements(); - if (element_type) - *element_type = CompilerType(getASTContext(), ext_vector_type->getElementType()); - } - return true; - } - default: - break; + case clang::Type::Typedef: + return IsArrayType(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + element_type_ptr, size, is_incomplete); + case clang::Type::Auto: + return IsArrayType(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + element_type_ptr, size, is_incomplete); + case clang::Type::Elaborated: + return IsArrayType(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + element_type_ptr, size, is_incomplete); + case clang::Type::Paren: + return IsArrayType( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), + element_type_ptr, size, is_incomplete); + } + if (element_type_ptr) + element_type_ptr->Clear(); + if (size) + *size = 0; + if (is_incomplete) + *is_incomplete = false; + return false; +} + +bool ClangASTContext::IsVectorType(lldb::opaque_compiler_type_t type, + CompilerType *element_type, uint64_t *size) { + clang::QualType qual_type(GetCanonicalQualType(type)); + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Vector: { + const clang::VectorType *vector_type = + qual_type->getAs<clang::VectorType>(); + if (vector_type) { + if (size) + *size = vector_type->getNumElements(); + if (element_type) + *element_type = + CompilerType(getASTContext(), vector_type->getElementType()); } + return true; + } break; + case clang::Type::ExtVector: { + const clang::ExtVectorType *ext_vector_type = + qual_type->getAs<clang::ExtVectorType>(); + if (ext_vector_type) { + if (size) + *size = ext_vector_type->getNumElements(); + if (element_type) + *element_type = + CompilerType(getASTContext(), ext_vector_type->getElementType()); + } + return true; + } + default: + break; + } + return false; +} + +bool ClangASTContext::IsRuntimeGeneratedType( + lldb::opaque_compiler_type_t type) { + clang::DeclContext *decl_ctx = ClangASTContext::GetASTContext(getASTContext()) + ->GetDeclContextForType(GetQualType(type)); + if (!decl_ctx) return false; -} -bool -ClangASTContext::IsRuntimeGeneratedType (lldb::opaque_compiler_type_t type) -{ - clang::DeclContext* decl_ctx = ClangASTContext::GetASTContext(getASTContext())->GetDeclContextForType(GetQualType(type)); - if (!decl_ctx) - return false; - - if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx)) - return false; - - clang::ObjCInterfaceDecl *result_iface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx); - - ClangASTMetadata* ast_metadata = ClangASTContext::GetMetadata(getASTContext(), result_iface_decl); - if (!ast_metadata) - return false; - return (ast_metadata->GetISAPtr() != 0); -} + if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx)) + return false; + + clang::ObjCInterfaceDecl *result_iface_decl = + llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx); -bool -ClangASTContext::IsCharType (lldb::opaque_compiler_type_t type) -{ - return GetQualType(type).getUnqualifiedType()->isCharType(); + ClangASTMetadata *ast_metadata = + ClangASTContext::GetMetadata(getASTContext(), result_iface_decl); + if (!ast_metadata) + return false; + return (ast_metadata->GetISAPtr() != 0); } +bool ClangASTContext::IsCharType(lldb::opaque_compiler_type_t type) { + return GetQualType(type).getUnqualifiedType()->isCharType(); +} -bool -ClangASTContext::IsCompleteType (lldb::opaque_compiler_type_t type) -{ - const bool allow_completion = false; - return GetCompleteQualType (getASTContext(), GetQualType(type), allow_completion); +bool ClangASTContext::IsCompleteType(lldb::opaque_compiler_type_t type) { + const bool allow_completion = false; + return GetCompleteQualType(getASTContext(), GetQualType(type), + allow_completion); } -bool -ClangASTContext::IsConst(lldb::opaque_compiler_type_t type) -{ - return GetQualType(type).isConstQualified(); +bool ClangASTContext::IsConst(lldb::opaque_compiler_type_t type) { + return GetQualType(type).isConstQualified(); } -bool -ClangASTContext::IsCStringType (lldb::opaque_compiler_type_t type, uint32_t &length) -{ - CompilerType pointee_or_element_clang_type; - length = 0; - Flags type_flags (GetTypeInfo (type, &pointee_or_element_clang_type)); - - if (!pointee_or_element_clang_type.IsValid()) - return false; - - if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer)) - { - if (pointee_or_element_clang_type.IsCharType()) - { - if (type_flags.Test (eTypeIsArray)) - { - // We know the size of the array and it could be a C string - // since it is an array of characters - length = llvm::cast<clang::ConstantArrayType>(GetCanonicalQualType(type).getTypePtr())->getSize().getLimitedValue(); - } - return true; - - } - } +bool ClangASTContext::IsCStringType(lldb::opaque_compiler_type_t type, + uint32_t &length) { + CompilerType pointee_or_element_clang_type; + length = 0; + Flags type_flags(GetTypeInfo(type, &pointee_or_element_clang_type)); + + if (!pointee_or_element_clang_type.IsValid()) return false; -} -bool -ClangASTContext::IsFunctionType (lldb::opaque_compiler_type_t type, bool *is_variadic_ptr) -{ - if (type) - { - clang::QualType qual_type (GetCanonicalQualType(type)); - - if (qual_type->isFunctionType()) - { - if (is_variadic_ptr) - { - const clang::FunctionProtoType *function_proto_type = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr()); - if (function_proto_type) - *is_variadic_ptr = function_proto_type->isVariadic(); - else - *is_variadic_ptr = false; - } - return true; - } - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - default: - break; - case clang::Type::Typedef: - return IsFunctionType(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), nullptr); - case clang::Type::Auto: - return IsFunctionType(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), nullptr); - case clang::Type::Elaborated: - return IsFunctionType(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), nullptr); - case clang::Type::Paren: - return IsFunctionType(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), nullptr); - case clang::Type::LValueReference: - case clang::Type::RValueReference: - { - const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); - if (reference_type) - return IsFunctionType(reference_type->getPointeeType().getAsOpaquePtr(), nullptr); - } - break; - } + if (type_flags.AnySet(eTypeIsArray | eTypeIsPointer)) { + if (pointee_or_element_clang_type.IsCharType()) { + if (type_flags.Test(eTypeIsArray)) { + // We know the size of the array and it could be a C string + // since it is an array of characters + length = llvm::cast<clang::ConstantArrayType>( + GetCanonicalQualType(type).getTypePtr()) + ->getSize() + .getLimitedValue(); + } + return true; + } + } + return false; +} + +bool ClangASTContext::IsFunctionType(lldb::opaque_compiler_type_t type, + bool *is_variadic_ptr) { + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + + if (qual_type->isFunctionType()) { + if (is_variadic_ptr) { + const clang::FunctionProtoType *function_proto_type = + llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr()); + if (function_proto_type) + *is_variadic_ptr = function_proto_type->isVariadic(); + else + *is_variadic_ptr = false; + } + return true; } - return false; + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + default: + break; + case clang::Type::Typedef: + return IsFunctionType(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + nullptr); + case clang::Type::Auto: + return IsFunctionType(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + nullptr); + case clang::Type::Elaborated: + return IsFunctionType(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + nullptr); + case clang::Type::Paren: + return IsFunctionType( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), + nullptr); + case clang::Type::LValueReference: + case clang::Type::RValueReference: { + const clang::ReferenceType *reference_type = + llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); + if (reference_type) + return IsFunctionType(reference_type->getPointeeType().getAsOpaquePtr(), + nullptr); + } break; + } + } + return false; } // Used to detect "Homogeneous Floating-point Aggregates" uint32_t -ClangASTContext::IsHomogeneousAggregate (lldb::opaque_compiler_type_t type, CompilerType* base_type_ptr) -{ - if (!type) - return 0; - - clang::QualType qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType (type)) - { - const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - { - if (cxx_record_decl->getNumBases() || - cxx_record_decl->isDynamicClass()) - return 0; - } - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - if (record_type) - { - const clang::RecordDecl *record_decl = record_type->getDecl(); - if (record_decl) - { - // We are looking for a structure that contains only floating point types - clang::RecordDecl::field_iterator field_pos, field_end = record_decl->field_end(); - uint32_t num_fields = 0; - bool is_hva = false; - bool is_hfa = false; - clang::QualType base_qual_type; - uint64_t base_bitwidth = 0; - for (field_pos = record_decl->field_begin(); field_pos != field_end; ++field_pos) - { - clang::QualType field_qual_type = field_pos->getType(); - uint64_t field_bitwidth = getASTContext()->getTypeSize (qual_type); - if (field_qual_type->isFloatingType()) - { - if (field_qual_type->isComplexType()) - return 0; - else - { - if (num_fields == 0) - base_qual_type = field_qual_type; - else - { - if (is_hva) - return 0; - is_hfa = true; - if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr()) - return 0; - } - } - } - else if (field_qual_type->isVectorType() || field_qual_type->isExtVectorType()) - { - if (num_fields == 0) - { - base_qual_type = field_qual_type; - base_bitwidth = field_bitwidth; - } - else - { - if (is_hfa) - return 0; - is_hva = true; - if (base_bitwidth != field_bitwidth) - return 0; - if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr()) - return 0; - } - } - else - return 0; - ++num_fields; - } - if (base_type_ptr) - *base_type_ptr = CompilerType (getASTContext(), base_qual_type); - return num_fields; - } - } - } - break; - - case clang::Type::Typedef: - return IsHomogeneousAggregate(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), base_type_ptr); - - case clang::Type::Auto: - return IsHomogeneousAggregate(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), base_type_ptr); - - case clang::Type::Elaborated: - return IsHomogeneousAggregate(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), base_type_ptr); - default: - break; - } +ClangASTContext::IsHomogeneousAggregate(lldb::opaque_compiler_type_t type, + CompilerType *base_type_ptr) { + if (!type) return 0; -} -size_t -ClangASTContext::GetNumberOfFunctionArguments (lldb::opaque_compiler_type_t type) -{ - if (type) - { - clang::QualType qual_type (GetCanonicalQualType(type)); - const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr()); - if (func) - return func->getNumParams(); - } - return 0; + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::CXXRecordDecl *cxx_record_decl = + qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) { + if (cxx_record_decl->getNumBases() || cxx_record_decl->isDynamicClass()) + return 0; + } + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(qual_type.getTypePtr()); + if (record_type) { + const clang::RecordDecl *record_decl = record_type->getDecl(); + if (record_decl) { + // We are looking for a structure that contains only floating point + // types + clang::RecordDecl::field_iterator field_pos, + field_end = record_decl->field_end(); + uint32_t num_fields = 0; + bool is_hva = false; + bool is_hfa = false; + clang::QualType base_qual_type; + uint64_t base_bitwidth = 0; + for (field_pos = record_decl->field_begin(); field_pos != field_end; + ++field_pos) { + clang::QualType field_qual_type = field_pos->getType(); + uint64_t field_bitwidth = getASTContext()->getTypeSize(qual_type); + if (field_qual_type->isFloatingType()) { + if (field_qual_type->isComplexType()) + return 0; + else { + if (num_fields == 0) + base_qual_type = field_qual_type; + else { + if (is_hva) + return 0; + is_hfa = true; + if (field_qual_type.getTypePtr() != + base_qual_type.getTypePtr()) + return 0; + } + } + } else if (field_qual_type->isVectorType() || + field_qual_type->isExtVectorType()) { + if (num_fields == 0) { + base_qual_type = field_qual_type; + base_bitwidth = field_bitwidth; + } else { + if (is_hfa) + return 0; + is_hva = true; + if (base_bitwidth != field_bitwidth) + return 0; + if (field_qual_type.getTypePtr() != base_qual_type.getTypePtr()) + return 0; + } + } else + return 0; + ++num_fields; + } + if (base_type_ptr) + *base_type_ptr = CompilerType(getASTContext(), base_qual_type); + return num_fields; + } + } + } + break; + + case clang::Type::Typedef: + return IsHomogeneousAggregate(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + base_type_ptr); + + case clang::Type::Auto: + return IsHomogeneousAggregate(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + base_type_ptr); + + case clang::Type::Elaborated: + return IsHomogeneousAggregate(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + base_type_ptr); + default: + break; + } + return 0; +} + +size_t ClangASTContext::GetNumberOfFunctionArguments( + lldb::opaque_compiler_type_t type) { + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::FunctionProtoType *func = + llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr()); + if (func) + return func->getNumParams(); + } + return 0; } CompilerType -ClangASTContext::GetFunctionArgumentAtIndex (lldb::opaque_compiler_type_t type, const size_t index) -{ - if (type) - { - clang::QualType qual_type (GetQualType(type)); - const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr()); - if (func) - { - if (index < func->getNumParams()) - return CompilerType(getASTContext(), func->getParamType(index)); - } +ClangASTContext::GetFunctionArgumentAtIndex(lldb::opaque_compiler_type_t type, + const size_t index) { + if (type) { + clang::QualType qual_type(GetQualType(type)); + const clang::FunctionProtoType *func = + llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr()); + if (func) { + if (index < func->getNumParams()) + return CompilerType(getASTContext(), func->getParamType(index)); } - return CompilerType(); + } + return CompilerType(); } -bool -ClangASTContext::IsFunctionPointerType (lldb::opaque_compiler_type_t type) -{ - if (type) - { - clang::QualType qual_type (GetCanonicalQualType(type)); - - if (qual_type->isFunctionPointerType()) - return true; - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - default: - break; - case clang::Type::Typedef: - return IsFunctionPointerType (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); - case clang::Type::Auto: - return IsFunctionPointerType (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()); - case clang::Type::Elaborated: - return IsFunctionPointerType (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); - case clang::Type::Paren: - return IsFunctionPointerType (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()); - - case clang::Type::LValueReference: - case clang::Type::RValueReference: - { - const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); - if (reference_type) - return IsFunctionPointerType(reference_type->getPointeeType().getAsOpaquePtr()); - } - break; - } - } - return false; - -} - -bool -ClangASTContext::IsBlockPointerType (lldb::opaque_compiler_type_t type, CompilerType *function_pointer_type_ptr) -{ - if (type) - { - clang::QualType qual_type (GetCanonicalQualType(type)); - - if (qual_type->isBlockPointerType()) - { - if (function_pointer_type_ptr) - { - const clang::BlockPointerType *block_pointer_type = qual_type->getAs<clang::BlockPointerType>(); - QualType pointee_type = block_pointer_type->getPointeeType(); - QualType function_pointer_type = m_ast_ap->getPointerType(pointee_type); - *function_pointer_type_ptr = CompilerType (getASTContext(), function_pointer_type); - } - return true; - } - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - default: - break; - case clang::Type::Typedef: - return IsBlockPointerType (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), function_pointer_type_ptr); - case clang::Type::Auto: - return IsBlockPointerType (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), function_pointer_type_ptr); - case clang::Type::Elaborated: - return IsBlockPointerType (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), function_pointer_type_ptr); - case clang::Type::Paren: - return IsBlockPointerType (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), function_pointer_type_ptr); - - case clang::Type::LValueReference: - case clang::Type::RValueReference: - { - const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); - if (reference_type) - return IsBlockPointerType(reference_type->getPointeeType().getAsOpaquePtr(), function_pointer_type_ptr); - } - break; - } +bool ClangASTContext::IsFunctionPointerType(lldb::opaque_compiler_type_t type) { + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + + if (qual_type->isFunctionPointerType()) + return true; + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + default: + break; + case clang::Type::Typedef: + return IsFunctionPointerType(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr()); + case clang::Type::Auto: + return IsFunctionPointerType(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr()); + case clang::Type::Elaborated: + return IsFunctionPointerType(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr()); + case clang::Type::Paren: + return IsFunctionPointerType( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()); + + case clang::Type::LValueReference: + case clang::Type::RValueReference: { + const clang::ReferenceType *reference_type = + llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); + if (reference_type) + return IsFunctionPointerType( + reference_type->getPointeeType().getAsOpaquePtr()); + } break; + } + } + return false; +} + +bool ClangASTContext::IsBlockPointerType( + lldb::opaque_compiler_type_t type, + CompilerType *function_pointer_type_ptr) { + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + + if (qual_type->isBlockPointerType()) { + if (function_pointer_type_ptr) { + const clang::BlockPointerType *block_pointer_type = + qual_type->getAs<clang::BlockPointerType>(); + QualType pointee_type = block_pointer_type->getPointeeType(); + QualType function_pointer_type = m_ast_ap->getPointerType(pointee_type); + *function_pointer_type_ptr = + CompilerType(getASTContext(), function_pointer_type); + } + return true; } + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + default: + break; + case clang::Type::Typedef: + return IsBlockPointerType(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + function_pointer_type_ptr); + case clang::Type::Auto: + return IsBlockPointerType(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + function_pointer_type_ptr); + case clang::Type::Elaborated: + return IsBlockPointerType(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + function_pointer_type_ptr); + case clang::Type::Paren: + return IsBlockPointerType( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), + function_pointer_type_ptr); + + case clang::Type::LValueReference: + case clang::Type::RValueReference: { + const clang::ReferenceType *reference_type = + llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); + if (reference_type) + return IsBlockPointerType( + reference_type->getPointeeType().getAsOpaquePtr(), + function_pointer_type_ptr); + } break; + } + } + return false; +} + +bool ClangASTContext::IsIntegerType(lldb::opaque_compiler_type_t type, + bool &is_signed) { + if (!type) return false; -} -bool -ClangASTContext::IsIntegerType (lldb::opaque_compiler_type_t type, bool &is_signed) -{ - if (!type) - return false; - - clang::QualType qual_type (GetCanonicalQualType(type)); - const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal()); - - if (builtin_type) - { - if (builtin_type->isInteger()) - { - is_signed = builtin_type->isSignedInteger(); - return true; - } + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::BuiltinType *builtin_type = + llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal()); + + if (builtin_type) { + if (builtin_type->isInteger()) { + is_signed = builtin_type->isSignedInteger(); + return true; } - - return false; + } + + return false; } -bool -ClangASTContext::IsEnumerationType(lldb::opaque_compiler_type_t type, bool &is_signed) -{ - if (type) - { - const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type)->getCanonicalTypeInternal()); +bool ClangASTContext::IsEnumerationType(lldb::opaque_compiler_type_t type, + bool &is_signed) { + if (type) { + const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>( + GetCanonicalQualType(type)->getCanonicalTypeInternal()); - if (enum_type) - { - IsIntegerType(enum_type->getDecl()->getIntegerType().getAsOpaquePtr(), is_signed); - return true; - } + if (enum_type) { + IsIntegerType(enum_type->getDecl()->getIntegerType().getAsOpaquePtr(), + is_signed); + return true; } + } - return false; + return false; } -bool -ClangASTContext::IsPointerType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) -{ - if (type) - { - clang::QualType qual_type (GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Builtin: - switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) - { - default: - break; - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCClass: - return true; - } - return false; - case clang::Type::ObjCObjectPointer: - if (pointee_type) - pointee_type->SetCompilerType (getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType()); - return true; - case clang::Type::BlockPointer: - if (pointee_type) - pointee_type->SetCompilerType (getASTContext(), llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType()); - return true; - case clang::Type::Pointer: - if (pointee_type) - pointee_type->SetCompilerType (getASTContext(), llvm::cast<clang::PointerType>(qual_type)->getPointeeType()); - return true; - case clang::Type::MemberPointer: - if (pointee_type) - pointee_type->SetCompilerType (getASTContext(), llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType()); - return true; - case clang::Type::Typedef: - return IsPointerType (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), pointee_type); - case clang::Type::Auto: - return IsPointerType (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), pointee_type); - case clang::Type::Elaborated: - return IsPointerType (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), pointee_type); - case clang::Type::Paren: - return IsPointerType (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), pointee_type); - default: - break; - } +bool ClangASTContext::IsPointerType(lldb::opaque_compiler_type_t type, + CompilerType *pointee_type) { + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Builtin: + switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) { + default: + break; + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCClass: + return true; + } + return false; + case clang::Type::ObjCObjectPointer: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type) + ->getPointeeType()); + return true; + case clang::Type::BlockPointer: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType()); + return true; + case clang::Type::Pointer: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::PointerType>(qual_type)->getPointeeType()); + return true; + case clang::Type::MemberPointer: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType()); + return true; + case clang::Type::Typedef: + return IsPointerType(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + pointee_type); + case clang::Type::Auto: + return IsPointerType(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + pointee_type); + case clang::Type::Elaborated: + return IsPointerType(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + pointee_type); + case clang::Type::Paren: + return IsPointerType( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), + pointee_type); + default: + break; } - if (pointee_type) - pointee_type->Clear(); - return false; + } + if (pointee_type) + pointee_type->Clear(); + return false; } - -bool -ClangASTContext::IsPointerOrReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type) -{ - if (type) - { - clang::QualType qual_type (GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Builtin: - switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) - { - default: - break; - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCClass: - return true; - } - return false; - case clang::Type::ObjCObjectPointer: - if (pointee_type) - pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType()); - return true; - case clang::Type::BlockPointer: - if (pointee_type) - pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType()); - return true; - case clang::Type::Pointer: - if (pointee_type) - pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::PointerType>(qual_type)->getPointeeType()); - return true; - case clang::Type::MemberPointer: - if (pointee_type) - pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType()); - return true; - case clang::Type::LValueReference: - if (pointee_type) - pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::LValueReferenceType>(qual_type)->desugar()); - return true; - case clang::Type::RValueReference: - if (pointee_type) - pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::RValueReferenceType>(qual_type)->desugar()); - return true; - case clang::Type::Typedef: - return IsPointerOrReferenceType(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), pointee_type); - case clang::Type::Auto: - return IsPointerOrReferenceType(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), pointee_type); - case clang::Type::Elaborated: - return IsPointerOrReferenceType(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), pointee_type); - case clang::Type::Paren: - return IsPointerOrReferenceType(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), pointee_type); - default: - break; - } +bool ClangASTContext::IsPointerOrReferenceType( + lldb::opaque_compiler_type_t type, CompilerType *pointee_type) { + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Builtin: + switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) { + default: + break; + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCClass: + return true; + } + return false; + case clang::Type::ObjCObjectPointer: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type) + ->getPointeeType()); + return true; + case clang::Type::BlockPointer: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::BlockPointerType>(qual_type)->getPointeeType()); + return true; + case clang::Type::Pointer: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::PointerType>(qual_type)->getPointeeType()); + return true; + case clang::Type::MemberPointer: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::MemberPointerType>(qual_type)->getPointeeType()); + return true; + case clang::Type::LValueReference: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::LValueReferenceType>(qual_type)->desugar()); + return true; + case clang::Type::RValueReference: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::RValueReferenceType>(qual_type)->desugar()); + return true; + case clang::Type::Typedef: + return IsPointerOrReferenceType(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + pointee_type); + case clang::Type::Auto: + return IsPointerOrReferenceType(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + pointee_type); + case clang::Type::Elaborated: + return IsPointerOrReferenceType( + llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + pointee_type); + case clang::Type::Paren: + return IsPointerOrReferenceType( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), + pointee_type); + default: + break; } - if (pointee_type) - pointee_type->Clear(); - return false; + } + if (pointee_type) + pointee_type->Clear(); + return false; } +bool ClangASTContext::IsReferenceType(lldb::opaque_compiler_type_t type, + CompilerType *pointee_type, + bool *is_rvalue) { + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); -bool -ClangASTContext::IsReferenceType (lldb::opaque_compiler_type_t type, CompilerType *pointee_type, bool* is_rvalue) -{ - if (type) - { - clang::QualType qual_type (GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - - switch (type_class) - { - case clang::Type::LValueReference: - if (pointee_type) - pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::LValueReferenceType>(qual_type)->desugar()); - if (is_rvalue) - *is_rvalue = false; - return true; - case clang::Type::RValueReference: - if (pointee_type) - pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::RValueReferenceType>(qual_type)->desugar()); - if (is_rvalue) - *is_rvalue = true; - return true; - case clang::Type::Typedef: - return IsReferenceType (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), pointee_type, is_rvalue); - case clang::Type::Auto: - return IsReferenceType (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), pointee_type, is_rvalue); - case clang::Type::Elaborated: - return IsReferenceType (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), pointee_type, is_rvalue); - case clang::Type::Paren: - return IsReferenceType (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), pointee_type, is_rvalue); - - default: - break; - } + switch (type_class) { + case clang::Type::LValueReference: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::LValueReferenceType>(qual_type)->desugar()); + if (is_rvalue) + *is_rvalue = false; + return true; + case clang::Type::RValueReference: + if (pointee_type) + pointee_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::RValueReferenceType>(qual_type)->desugar()); + if (is_rvalue) + *is_rvalue = true; + return true; + case clang::Type::Typedef: + return IsReferenceType(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + pointee_type, is_rvalue); + case clang::Type::Auto: + return IsReferenceType(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + pointee_type, is_rvalue); + case clang::Type::Elaborated: + return IsReferenceType(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + pointee_type, is_rvalue); + case clang::Type::Paren: + return IsReferenceType( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), + pointee_type, is_rvalue); + + default: + break; } - if (pointee_type) - pointee_type->Clear(); - return false; + } + if (pointee_type) + pointee_type->Clear(); + return false; } -bool -ClangASTContext::IsFloatingPointType (lldb::opaque_compiler_type_t type, uint32_t &count, bool &is_complex) -{ - if (type) - { - clang::QualType qual_type (GetCanonicalQualType(type)); - - if (const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal())) - { - clang::BuiltinType::Kind kind = BT->getKind(); - if (kind >= clang::BuiltinType::Float && kind <= clang::BuiltinType::LongDouble) - { - count = 1; - is_complex = false; - return true; - } - } - else if (const clang::ComplexType *CT = llvm::dyn_cast<clang::ComplexType>(qual_type->getCanonicalTypeInternal())) - { - if (IsFloatingPointType (CT->getElementType().getAsOpaquePtr(), count, is_complex)) - { - count = 2; - is_complex = true; - return true; - } - } - else if (const clang::VectorType *VT = llvm::dyn_cast<clang::VectorType>(qual_type->getCanonicalTypeInternal())) - { - if (IsFloatingPointType (VT->getElementType().getAsOpaquePtr(), count, is_complex)) - { - count = VT->getNumElements(); - is_complex = false; - return true; - } - } +bool ClangASTContext::IsFloatingPointType(lldb::opaque_compiler_type_t type, + uint32_t &count, bool &is_complex) { + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + + if (const clang::BuiltinType *BT = llvm::dyn_cast<clang::BuiltinType>( + qual_type->getCanonicalTypeInternal())) { + clang::BuiltinType::Kind kind = BT->getKind(); + if (kind >= clang::BuiltinType::Float && + kind <= clang::BuiltinType::LongDouble) { + count = 1; + is_complex = false; + return true; + } + } else if (const clang::ComplexType *CT = + llvm::dyn_cast<clang::ComplexType>( + qual_type->getCanonicalTypeInternal())) { + if (IsFloatingPointType(CT->getElementType().getAsOpaquePtr(), count, + is_complex)) { + count = 2; + is_complex = true; + return true; + } + } else if (const clang::VectorType *VT = llvm::dyn_cast<clang::VectorType>( + qual_type->getCanonicalTypeInternal())) { + if (IsFloatingPointType(VT->getElementType().getAsOpaquePtr(), count, + is_complex)) { + count = VT->getNumElements(); + is_complex = false; + return true; + } } - count = 0; - is_complex = false; - return false; + } + count = 0; + is_complex = false; + return false; } +bool ClangASTContext::IsDefined(lldb::opaque_compiler_type_t type) { + if (!type) + return false; -bool -ClangASTContext::IsDefined(lldb::opaque_compiler_type_t type) -{ - if (!type) - return false; - - clang::QualType qual_type(GetQualType(type)); - const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr()); - if (tag_type) - { - clang::TagDecl *tag_decl = tag_type->getDecl(); - if (tag_decl) - return tag_decl->isCompleteDefinition(); - return false; - } - else - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - if (class_interface_decl) - return class_interface_decl->getDefinition() != nullptr; - return false; - } + clang::QualType qual_type(GetQualType(type)); + const clang::TagType *tag_type = + llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr()); + if (tag_type) { + clang::TagDecl *tag_decl = tag_type->getDecl(); + if (tag_decl) + return tag_decl->isCompleteDefinition(); + return false; + } else { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + if (class_interface_decl) + return class_interface_decl->getDefinition() != nullptr; + return false; } - return true; + } + return true; } -bool -ClangASTContext::IsObjCClassType (const CompilerType& type) -{ - if (type) - { - clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); +bool ClangASTContext::IsObjCClassType(const CompilerType &type) { + if (type) { + clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); - const clang::ObjCObjectPointerType *obj_pointer_type = llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type); - - if (obj_pointer_type) - return obj_pointer_type->isObjCClassType(); - } - return false; + const clang::ObjCObjectPointerType *obj_pointer_type = + llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type); + + if (obj_pointer_type) + return obj_pointer_type->isObjCClassType(); + } + return false; +} + +bool ClangASTContext::IsObjCObjectOrInterfaceType(const CompilerType &type) { + if (ClangUtil::IsClangType(type)) + return ClangUtil::GetCanonicalQualType(type)->isObjCObjectOrInterfaceType(); + return false; } -bool -ClangASTContext::IsObjCObjectOrInterfaceType (const CompilerType& type) -{ - if (ClangUtil::IsClangType(type)) - return ClangUtil::GetCanonicalQualType(type)->isObjCObjectOrInterfaceType(); +bool ClangASTContext::IsClassType(lldb::opaque_compiler_type_t type) { + if (!type) return false; + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + return (type_class == clang::Type::Record); } -bool -ClangASTContext::IsClassType(lldb::opaque_compiler_type_t type) -{ - if (!type) - return false; - clang::QualType qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - return (type_class == clang::Type::Record); +bool ClangASTContext::IsEnumType(lldb::opaque_compiler_type_t type) { + if (!type) + return false; + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + return (type_class == clang::Type::Enum); } -bool -ClangASTContext::IsEnumType(lldb::opaque_compiler_type_t type) -{ - if (!type) - return false; +bool ClangASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type) { + if (type) { clang::QualType qual_type(GetCanonicalQualType(type)); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - return (type_class == clang::Type::Enum); -} - -bool -ClangASTContext::IsPolymorphicClass(lldb::opaque_compiler_type_t type) -{ - if (type) - { - clang::QualType qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - if (record_decl) - { - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - if (cxx_record_decl) - return cxx_record_decl->isPolymorphic(); - } - } - break; - - default: - break; + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + if (record_decl) { + const clang::CXXRecordDecl *cxx_record_decl = + llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); + if (cxx_record_decl) + return cxx_record_decl->isPolymorphic(); } + } + break; + + default: + break; } - return false; + } + return false; } -bool -ClangASTContext::IsPossibleDynamicType (lldb::opaque_compiler_type_t type, CompilerType *dynamic_pointee_type, - bool check_cplusplus, - bool check_objc) -{ - clang::QualType pointee_qual_type; - if (type) - { - clang::QualType qual_type (GetCanonicalQualType(type)); - bool success = false; - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Builtin: - if (check_objc && llvm::cast<clang::BuiltinType>(qual_type)->getKind() == clang::BuiltinType::ObjCId) - { - if (dynamic_pointee_type) - dynamic_pointee_type->SetCompilerType(this, type); - return true; - } - break; - - case clang::Type::ObjCObjectPointer: - if (check_objc) - { - if (auto objc_pointee_type = qual_type->getPointeeType().getTypePtrOrNull()) - { - if (auto objc_object_type = llvm::dyn_cast_or_null<clang::ObjCObjectType>(objc_pointee_type)) - { - if (objc_object_type->isObjCClass()) - return false; - } - } - if (dynamic_pointee_type) - dynamic_pointee_type->SetCompilerType(getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type)->getPointeeType()); - return true; - } - break; - - case clang::Type::Pointer: - pointee_qual_type = llvm::cast<clang::PointerType>(qual_type)->getPointeeType(); - success = true; - break; - - case clang::Type::LValueReference: - case clang::Type::RValueReference: - pointee_qual_type = llvm::cast<clang::ReferenceType>(qual_type)->getPointeeType(); - success = true; - break; - - case clang::Type::Typedef: - return IsPossibleDynamicType (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), - dynamic_pointee_type, - check_cplusplus, - check_objc); - - case clang::Type::Auto: - return IsPossibleDynamicType (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), - dynamic_pointee_type, - check_cplusplus, - check_objc); - - case clang::Type::Elaborated: - return IsPossibleDynamicType (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), - dynamic_pointee_type, - check_cplusplus, - check_objc); - - case clang::Type::Paren: - return IsPossibleDynamicType (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), - dynamic_pointee_type, - check_cplusplus, - check_objc); - default: - break; +bool ClangASTContext::IsPossibleDynamicType(lldb::opaque_compiler_type_t type, + CompilerType *dynamic_pointee_type, + bool check_cplusplus, + bool check_objc) { + clang::QualType pointee_qual_type; + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + bool success = false; + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Builtin: + if (check_objc && + llvm::cast<clang::BuiltinType>(qual_type)->getKind() == + clang::BuiltinType::ObjCId) { + if (dynamic_pointee_type) + dynamic_pointee_type->SetCompilerType(this, type); + return true; + } + break; + + case clang::Type::ObjCObjectPointer: + if (check_objc) { + if (auto objc_pointee_type = + qual_type->getPointeeType().getTypePtrOrNull()) { + if (auto objc_object_type = + llvm::dyn_cast_or_null<clang::ObjCObjectType>( + objc_pointee_type)) { + if (objc_object_type->isObjCClass()) + return false; + } } - - if (success) - { - // Check to make sure what we are pointing too is a possible dynamic C++ type - // We currently accept any "void *" (in case we have a class that has been - // watered down to an opaque pointer) and virtual C++ classes. - const clang::Type::TypeClass pointee_type_class = pointee_qual_type.getCanonicalType()->getTypeClass(); - switch (pointee_type_class) - { - case clang::Type::Builtin: - switch (llvm::cast<clang::BuiltinType>(pointee_qual_type)->getKind()) - { - case clang::BuiltinType::UnknownAny: - case clang::BuiltinType::Void: - if (dynamic_pointee_type) - dynamic_pointee_type->SetCompilerType(getASTContext(), pointee_qual_type); - return true; - default: - break; - } - break; - - case clang::Type::Record: - if (check_cplusplus) - { - clang::CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - { - bool is_complete = cxx_record_decl->isCompleteDefinition(); - - if (is_complete) - success = cxx_record_decl->isDynamicClass(); - else - { - ClangASTMetadata *metadata = ClangASTContext::GetMetadata (getASTContext(), cxx_record_decl); - if (metadata) - success = metadata->GetIsDynamicCXXType(); - else - { - is_complete = CompilerType(getASTContext(), pointee_qual_type).GetCompleteType(); - if (is_complete) - success = cxx_record_decl->isDynamicClass(); - else - success = false; - } - } - - if (success) - { - if (dynamic_pointee_type) - dynamic_pointee_type->SetCompilerType(getASTContext(), pointee_qual_type); - return true; - } - } - } - break; - - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - if (check_objc) - { - if (dynamic_pointee_type) - dynamic_pointee_type->SetCompilerType(getASTContext(), pointee_qual_type); - return true; - } - break; - - default: - break; + if (dynamic_pointee_type) + dynamic_pointee_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::ObjCObjectPointerType>(qual_type) + ->getPointeeType()); + return true; + } + break; + + case clang::Type::Pointer: + pointee_qual_type = + llvm::cast<clang::PointerType>(qual_type)->getPointeeType(); + success = true; + break; + + case clang::Type::LValueReference: + case clang::Type::RValueReference: + pointee_qual_type = + llvm::cast<clang::ReferenceType>(qual_type)->getPointeeType(); + success = true; + break; + + case clang::Type::Typedef: + return IsPossibleDynamicType(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + dynamic_pointee_type, check_cplusplus, + check_objc); + + case clang::Type::Auto: + return IsPossibleDynamicType(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + dynamic_pointee_type, check_cplusplus, + check_objc); + + case clang::Type::Elaborated: + return IsPossibleDynamicType(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + dynamic_pointee_type, check_cplusplus, + check_objc); + + case clang::Type::Paren: + return IsPossibleDynamicType( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), + dynamic_pointee_type, check_cplusplus, check_objc); + default: + break; + } + + if (success) { + // Check to make sure what we are pointing too is a possible dynamic C++ + // type + // We currently accept any "void *" (in case we have a class that has been + // watered down to an opaque pointer) and virtual C++ classes. + const clang::Type::TypeClass pointee_type_class = + pointee_qual_type.getCanonicalType()->getTypeClass(); + switch (pointee_type_class) { + case clang::Type::Builtin: + switch (llvm::cast<clang::BuiltinType>(pointee_qual_type)->getKind()) { + case clang::BuiltinType::UnknownAny: + case clang::BuiltinType::Void: + if (dynamic_pointee_type) + dynamic_pointee_type->SetCompilerType(getASTContext(), + pointee_qual_type); + return true; + default: + break; + } + break; + + case clang::Type::Record: + if (check_cplusplus) { + clang::CXXRecordDecl *cxx_record_decl = + pointee_qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) { + bool is_complete = cxx_record_decl->isCompleteDefinition(); + + if (is_complete) + success = cxx_record_decl->isDynamicClass(); + else { + ClangASTMetadata *metadata = ClangASTContext::GetMetadata( + getASTContext(), cxx_record_decl); + if (metadata) + success = metadata->GetIsDynamicCXXType(); + else { + is_complete = CompilerType(getASTContext(), pointee_qual_type) + .GetCompleteType(); + if (is_complete) + success = cxx_record_decl->isDynamicClass(); + else + success = false; + } + } + + if (success) { + if (dynamic_pointee_type) + dynamic_pointee_type->SetCompilerType(getASTContext(), + pointee_qual_type); + return true; } + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (check_objc) { + if (dynamic_pointee_type) + dynamic_pointee_type->SetCompilerType(getASTContext(), + pointee_qual_type); + return true; } + break; + + default: + break; + } } - if (dynamic_pointee_type) - dynamic_pointee_type->Clear(); - return false; + } + if (dynamic_pointee_type) + dynamic_pointee_type->Clear(); + return false; } +bool ClangASTContext::IsScalarType(lldb::opaque_compiler_type_t type) { + if (!type) + return false; -bool -ClangASTContext::IsScalarType (lldb::opaque_compiler_type_t type) -{ - if (!type) - return false; - - return (GetTypeInfo (type, nullptr) & eTypeIsScalar) != 0; + return (GetTypeInfo(type, nullptr) & eTypeIsScalar) != 0; } -bool -ClangASTContext::IsTypedefType (lldb::opaque_compiler_type_t type) -{ - if (!type) - return false; - return GetQualType(type)->getTypeClass() == clang::Type::Typedef; +bool ClangASTContext::IsTypedefType(lldb::opaque_compiler_type_t type) { + if (!type) + return false; + return GetQualType(type)->getTypeClass() == clang::Type::Typedef; } -bool -ClangASTContext::IsVoidType (lldb::opaque_compiler_type_t type) -{ - if (!type) - return false; - return GetCanonicalQualType(type)->isVoidType(); -} - -bool -ClangASTContext::SupportsLanguage (lldb::LanguageType language) -{ - return ClangASTContextSupportsLanguage(language); -} - -bool -ClangASTContext::GetCXXClassName (const CompilerType& type, std::string &class_name) -{ - if (type) - { - clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); - if (!qual_type.isNull()) - { - clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - { - class_name.assign(cxx_record_decl->getIdentifier()->getNameStart()); - return true; - } - } - } - class_name.clear(); +bool ClangASTContext::IsVoidType(lldb::opaque_compiler_type_t type) { + if (!type) return false; + return GetCanonicalQualType(type)->isVoidType(); } +bool ClangASTContext::SupportsLanguage(lldb::LanguageType language) { + return ClangASTContextSupportsLanguage(language); +} -bool -ClangASTContext::IsCXXClassType (const CompilerType& type) -{ - if (!type) - return false; - +bool ClangASTContext::GetCXXClassName(const CompilerType &type, + std::string &class_name) { + if (type) { clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); - if (!qual_type.isNull() && qual_type->getAsCXXRecordDecl() != nullptr) + if (!qual_type.isNull()) { + clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) { + class_name.assign(cxx_record_decl->getIdentifier()->getNameStart()); return true; + } + } + } + class_name.clear(); + return false; +} + +bool ClangASTContext::IsCXXClassType(const CompilerType &type) { + if (!type) return false; + + clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); + if (!qual_type.isNull() && qual_type->getAsCXXRecordDecl() != nullptr) + return true; + return false; } -bool -ClangASTContext::IsBeingDefined (lldb::opaque_compiler_type_t type) -{ - if (!type) - return false; - clang::QualType qual_type (GetCanonicalQualType(type)); - const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type); - if (tag_type) - return tag_type->isBeingDefined(); +bool ClangASTContext::IsBeingDefined(lldb::opaque_compiler_type_t type) { + if (!type) return false; + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type); + if (tag_type) + return tag_type->isBeingDefined(); + return false; } -bool -ClangASTContext::IsObjCObjectPointerType (const CompilerType& type, CompilerType *class_type_ptr) -{ - if (!type) - return false; +bool ClangASTContext::IsObjCObjectPointerType(const CompilerType &type, + CompilerType *class_type_ptr) { + if (!type) + return false; - clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); + clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); - if (!qual_type.isNull() && qual_type->isObjCObjectPointerType()) - { - if (class_type_ptr) - { - if (!qual_type->isObjCClassType() && - !qual_type->isObjCIdType()) - { - const clang::ObjCObjectPointerType *obj_pointer_type = llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type); - if (obj_pointer_type == nullptr) - class_type_ptr->Clear(); - else - class_type_ptr->SetCompilerType (type.GetTypeSystem(), clang::QualType(obj_pointer_type->getInterfaceType(), 0).getAsOpaquePtr()); - } - } - return true; + if (!qual_type.isNull() && qual_type->isObjCObjectPointerType()) { + if (class_type_ptr) { + if (!qual_type->isObjCClassType() && !qual_type->isObjCIdType()) { + const clang::ObjCObjectPointerType *obj_pointer_type = + llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type); + if (obj_pointer_type == nullptr) + class_type_ptr->Clear(); + else + class_type_ptr->SetCompilerType( + type.GetTypeSystem(), + clang::QualType(obj_pointer_type->getInterfaceType(), 0) + .getAsOpaquePtr()); + } } - if (class_type_ptr) - class_type_ptr->Clear(); - return false; + return true; + } + if (class_type_ptr) + class_type_ptr->Clear(); + return false; } -bool -ClangASTContext::GetObjCClassName (const CompilerType& type, std::string &class_name) -{ - if (!type) - return false; +bool ClangASTContext::GetObjCClassName(const CompilerType &type, + std::string &class_name) { + if (!type) + return false; - clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); + clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); - const clang::ObjCObjectType *object_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type); - if (object_type) - { - const clang::ObjCInterfaceDecl *interface = object_type->getInterface(); - if (interface) - { - class_name = interface->getNameAsString(); - return true; - } + const clang::ObjCObjectType *object_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type); + if (object_type) { + const clang::ObjCInterfaceDecl *interface = object_type->getInterface(); + if (interface) { + class_name = interface->getNameAsString(); + return true; } - return false; + } + return false; } - //---------------------------------------------------------------------- // Type Completion //---------------------------------------------------------------------- -bool -ClangASTContext::GetCompleteType (lldb::opaque_compiler_type_t type) -{ - if (!type) - return false; - const bool allow_completion = true; - return GetCompleteQualType (getASTContext(), GetQualType(type), allow_completion); +bool ClangASTContext::GetCompleteType(lldb::opaque_compiler_type_t type) { + if (!type) + return false; + const bool allow_completion = true; + return GetCompleteQualType(getASTContext(), GetQualType(type), + allow_completion); } -ConstString -ClangASTContext::GetTypeName (lldb::opaque_compiler_type_t type) -{ - std::string type_name; - if (type) - { - clang::PrintingPolicy printing_policy (getASTContext()->getPrintingPolicy()); - clang::QualType qual_type(GetQualType(type)); - printing_policy.SuppressTagKeyword = true; - const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>(); - if (typedef_type) - { - const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl(); - type_name = typedef_decl->getQualifiedNameAsString(); - } - else - { - type_name = qual_type.getAsString(printing_policy); - } +ConstString ClangASTContext::GetTypeName(lldb::opaque_compiler_type_t type) { + std::string type_name; + if (type) { + clang::PrintingPolicy printing_policy(getASTContext()->getPrintingPolicy()); + clang::QualType qual_type(GetQualType(type)); + printing_policy.SuppressTagKeyword = true; + const clang::TypedefType *typedef_type = + qual_type->getAs<clang::TypedefType>(); + if (typedef_type) { + const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl(); + type_name = typedef_decl->getQualifiedNameAsString(); + } else { + type_name = qual_type.getAsString(printing_policy); } - return ConstString(type_name); + } + return ConstString(type_name); } uint32_t -ClangASTContext::GetTypeInfo (lldb::opaque_compiler_type_t type, CompilerType *pointee_or_element_clang_type) -{ - if (!type) - return 0; - - if (pointee_or_element_clang_type) - pointee_or_element_clang_type->Clear(); - - clang::QualType qual_type (GetQualType(type)); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Builtin: - { - const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal()); - - uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue; - switch (builtin_type->getKind()) - { - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCClass: - if (pointee_or_element_clang_type) - pointee_or_element_clang_type->SetCompilerType(getASTContext(), getASTContext()->ObjCBuiltinClassTy); - builtin_type_flags |= eTypeIsPointer | eTypeIsObjC; - break; - - case clang::BuiltinType::ObjCSel: - if (pointee_or_element_clang_type) - pointee_or_element_clang_type->SetCompilerType(getASTContext(), getASTContext()->CharTy); - builtin_type_flags |= eTypeIsPointer | eTypeIsObjC; - break; - - case clang::BuiltinType::Bool: - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::WChar_U: - case clang::BuiltinType::Char16: - case clang::BuiltinType::Char32: - case clang::BuiltinType::UShort: - case clang::BuiltinType::UInt: - case clang::BuiltinType::ULong: - case clang::BuiltinType::ULongLong: - case clang::BuiltinType::UInt128: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: - case clang::BuiltinType::WChar_S: - case clang::BuiltinType::Short: - case clang::BuiltinType::Int: - case clang::BuiltinType::Long: - case clang::BuiltinType::LongLong: - case clang::BuiltinType::Int128: - case clang::BuiltinType::Float: - case clang::BuiltinType::Double: - case clang::BuiltinType::LongDouble: - builtin_type_flags |= eTypeIsScalar; - if (builtin_type->isInteger()) - { - builtin_type_flags |= eTypeIsInteger; - if (builtin_type->isSignedInteger()) - builtin_type_flags |= eTypeIsSigned; - } - else if (builtin_type->isFloatingPoint()) - builtin_type_flags |= eTypeIsFloat; - break; - default: - break; - } - return builtin_type_flags; - } - - case clang::Type::BlockPointer: - if (pointee_or_element_clang_type) - pointee_or_element_clang_type->SetCompilerType(getASTContext(), qual_type->getPointeeType()); - return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock; - - case clang::Type::Complex: - { - uint32_t complex_type_flags = eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex; - const clang::ComplexType *complex_type = llvm::dyn_cast<clang::ComplexType>(qual_type->getCanonicalTypeInternal()); - if (complex_type) - { - clang::QualType complex_element_type (complex_type->getElementType()); - if (complex_element_type->isIntegerType()) - complex_type_flags |= eTypeIsFloat; - else if (complex_element_type->isFloatingType()) - complex_type_flags |= eTypeIsInteger; - } - return complex_type_flags; - } - break; - - case clang::Type::ConstantArray: - case clang::Type::DependentSizedArray: - case clang::Type::IncompleteArray: - case clang::Type::VariableArray: - if (pointee_or_element_clang_type) - pointee_or_element_clang_type->SetCompilerType(getASTContext(), llvm::cast<clang::ArrayType>(qual_type.getTypePtr())->getElementType()); - return eTypeHasChildren | eTypeIsArray; - - case clang::Type::DependentName: return 0; - case clang::Type::DependentSizedExtVector: return eTypeHasChildren | eTypeIsVector; - case clang::Type::DependentTemplateSpecialization: return eTypeIsTemplate; - case clang::Type::Decltype: return 0; - - case clang::Type::Enum: - if (pointee_or_element_clang_type) - pointee_or_element_clang_type->SetCompilerType(getASTContext(), llvm::cast<clang::EnumType>(qual_type)->getDecl()->getIntegerType()); - return eTypeIsEnumeration | eTypeHasValue; - - case clang::Type::Auto: - return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetTypeInfo (pointee_or_element_clang_type); - case clang::Type::Elaborated: - return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetTypeInfo (pointee_or_element_clang_type); - case clang::Type::Paren: - return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetTypeInfo (pointee_or_element_clang_type); - - case clang::Type::FunctionProto: return eTypeIsFuncPrototype | eTypeHasValue; - case clang::Type::FunctionNoProto: return eTypeIsFuncPrototype | eTypeHasValue; - case clang::Type::InjectedClassName: return 0; - - case clang::Type::LValueReference: - case clang::Type::RValueReference: - if (pointee_or_element_clang_type) - pointee_or_element_clang_type->SetCompilerType(getASTContext(), llvm::cast<clang::ReferenceType>(qual_type.getTypePtr())->getPointeeType()); - return eTypeHasChildren | eTypeIsReference | eTypeHasValue; - - case clang::Type::MemberPointer: return eTypeIsPointer | eTypeIsMember | eTypeHasValue; - - case clang::Type::ObjCObjectPointer: - if (pointee_or_element_clang_type) - pointee_or_element_clang_type->SetCompilerType(getASTContext(), qual_type->getPointeeType()); - return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | eTypeHasValue; - - case clang::Type::ObjCObject: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass; - case clang::Type::ObjCInterface: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass; - - case clang::Type::Pointer: - if (pointee_or_element_clang_type) - pointee_or_element_clang_type->SetCompilerType(getASTContext(), qual_type->getPointeeType()); - return eTypeHasChildren | eTypeIsPointer | eTypeHasValue; - - case clang::Type::Record: - if (qual_type->getAsCXXRecordDecl()) - return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus; - else - return eTypeHasChildren | eTypeIsStructUnion; - break; - case clang::Type::SubstTemplateTypeParm: return eTypeIsTemplate; - case clang::Type::TemplateTypeParm: return eTypeIsTemplate; - case clang::Type::TemplateSpecialization: return eTypeIsTemplate; - - case clang::Type::Typedef: - return eTypeIsTypedef | CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTypeInfo (pointee_or_element_clang_type); - case clang::Type::TypeOfExpr: return 0; - case clang::Type::TypeOf: return 0; - case clang::Type::UnresolvedUsing: return 0; - - case clang::Type::ExtVector: - case clang::Type::Vector: - { - uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector; - const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>(qual_type->getCanonicalTypeInternal()); - if (vector_type) - { - if (vector_type->isIntegerType()) - vector_type_flags |= eTypeIsFloat; - else if (vector_type->isFloatingType()) - vector_type_flags |= eTypeIsInteger; - } - return vector_type_flags; - } - default: return 0; +ClangASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type, + CompilerType *pointee_or_element_clang_type) { + if (!type) + return 0; + + if (pointee_or_element_clang_type) + pointee_or_element_clang_type->Clear(); + + clang::QualType qual_type(GetQualType(type)); + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Builtin: { + const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>( + qual_type->getCanonicalTypeInternal()); + + uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue; + switch (builtin_type->getKind()) { + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCClass: + if (pointee_or_element_clang_type) + pointee_or_element_clang_type->SetCompilerType( + getASTContext(), getASTContext()->ObjCBuiltinClassTy); + builtin_type_flags |= eTypeIsPointer | eTypeIsObjC; + break; + + case clang::BuiltinType::ObjCSel: + if (pointee_or_element_clang_type) + pointee_or_element_clang_type->SetCompilerType(getASTContext(), + getASTContext()->CharTy); + builtin_type_flags |= eTypeIsPointer | eTypeIsObjC; + break; + + case clang::BuiltinType::Bool: + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::WChar_U: + case clang::BuiltinType::Char16: + case clang::BuiltinType::Char32: + case clang::BuiltinType::UShort: + case clang::BuiltinType::UInt: + case clang::BuiltinType::ULong: + case clang::BuiltinType::ULongLong: + case clang::BuiltinType::UInt128: + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::WChar_S: + case clang::BuiltinType::Short: + case clang::BuiltinType::Int: + case clang::BuiltinType::Long: + case clang::BuiltinType::LongLong: + case clang::BuiltinType::Int128: + case clang::BuiltinType::Float: + case clang::BuiltinType::Double: + case clang::BuiltinType::LongDouble: + builtin_type_flags |= eTypeIsScalar; + if (builtin_type->isInteger()) { + builtin_type_flags |= eTypeIsInteger; + if (builtin_type->isSignedInteger()) + builtin_type_flags |= eTypeIsSigned; + } else if (builtin_type->isFloatingPoint()) + builtin_type_flags |= eTypeIsFloat; + break; + default: + break; } + return builtin_type_flags; + } + + case clang::Type::BlockPointer: + if (pointee_or_element_clang_type) + pointee_or_element_clang_type->SetCompilerType( + getASTContext(), qual_type->getPointeeType()); + return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock; + + case clang::Type::Complex: { + uint32_t complex_type_flags = + eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex; + const clang::ComplexType *complex_type = llvm::dyn_cast<clang::ComplexType>( + qual_type->getCanonicalTypeInternal()); + if (complex_type) { + clang::QualType complex_element_type(complex_type->getElementType()); + if (complex_element_type->isIntegerType()) + complex_type_flags |= eTypeIsFloat; + else if (complex_element_type->isFloatingType()) + complex_type_flags |= eTypeIsInteger; + } + return complex_type_flags; + } break; + + case clang::Type::ConstantArray: + case clang::Type::DependentSizedArray: + case clang::Type::IncompleteArray: + case clang::Type::VariableArray: + if (pointee_or_element_clang_type) + pointee_or_element_clang_type->SetCompilerType( + getASTContext(), llvm::cast<clang::ArrayType>(qual_type.getTypePtr()) + ->getElementType()); + return eTypeHasChildren | eTypeIsArray; + + case clang::Type::DependentName: + return 0; + case clang::Type::DependentSizedExtVector: + return eTypeHasChildren | eTypeIsVector; + case clang::Type::DependentTemplateSpecialization: + return eTypeIsTemplate; + case clang::Type::Decltype: return 0; -} + case clang::Type::Enum: + if (pointee_or_element_clang_type) + pointee_or_element_clang_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::EnumType>(qual_type)->getDecl()->getIntegerType()); + return eTypeIsEnumeration | eTypeHasValue; + + case clang::Type::Auto: + return CompilerType( + getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()) + .GetTypeInfo(pointee_or_element_clang_type); + case clang::Type::Elaborated: + return CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()) + .GetTypeInfo(pointee_or_element_clang_type); + case clang::Type::Paren: + return CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar()) + .GetTypeInfo(pointee_or_element_clang_type); + + case clang::Type::FunctionProto: + return eTypeIsFuncPrototype | eTypeHasValue; + case clang::Type::FunctionNoProto: + return eTypeIsFuncPrototype | eTypeHasValue; + case clang::Type::InjectedClassName: + return 0; + case clang::Type::LValueReference: + case clang::Type::RValueReference: + if (pointee_or_element_clang_type) + pointee_or_element_clang_type->SetCompilerType( + getASTContext(), + llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()) + ->getPointeeType()); + return eTypeHasChildren | eTypeIsReference | eTypeHasValue; -lldb::LanguageType -ClangASTContext::GetMinimumLanguage (lldb::opaque_compiler_type_t type) -{ - if (!type) - return lldb::eLanguageTypeC; - - // If the type is a reference, then resolve it to what it refers to first: - clang::QualType qual_type (GetCanonicalQualType(type).getNonReferenceType()); - if (qual_type->isAnyPointerType()) - { - if (qual_type->isObjCObjectPointerType()) - return lldb::eLanguageTypeObjC; - - clang::QualType pointee_type (qual_type->getPointeeType()); - if (pointee_type->getPointeeCXXRecordDecl() != nullptr) - return lldb::eLanguageTypeC_plus_plus; - if (pointee_type->isObjCObjectOrInterfaceType()) - return lldb::eLanguageTypeObjC; - if (pointee_type->isObjCClassType()) - return lldb::eLanguageTypeObjC; - if (pointee_type.getTypePtr() == getASTContext()->ObjCBuiltinIdTy.getTypePtr()) - return lldb::eLanguageTypeObjC; - } + case clang::Type::MemberPointer: + return eTypeIsPointer | eTypeIsMember | eTypeHasValue; + + case clang::Type::ObjCObjectPointer: + if (pointee_or_element_clang_type) + pointee_or_element_clang_type->SetCompilerType( + getASTContext(), qual_type->getPointeeType()); + return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | + eTypeHasValue; + + case clang::Type::ObjCObject: + return eTypeHasChildren | eTypeIsObjC | eTypeIsClass; + case clang::Type::ObjCInterface: + return eTypeHasChildren | eTypeIsObjC | eTypeIsClass; + + case clang::Type::Pointer: + if (pointee_or_element_clang_type) + pointee_or_element_clang_type->SetCompilerType( + getASTContext(), qual_type->getPointeeType()); + return eTypeHasChildren | eTypeIsPointer | eTypeHasValue; + + case clang::Type::Record: + if (qual_type->getAsCXXRecordDecl()) + return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus; else - { - if (qual_type->isObjCObjectOrInterfaceType()) - return lldb::eLanguageTypeObjC; - if (qual_type->getAsCXXRecordDecl()) - return lldb::eLanguageTypeC_plus_plus; - switch (qual_type->getTypeClass()) - { - default: - break; - case clang::Type::Builtin: - switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) - { - default: - case clang::BuiltinType::Void: - case clang::BuiltinType::Bool: - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::WChar_U: - case clang::BuiltinType::Char16: - case clang::BuiltinType::Char32: - case clang::BuiltinType::UShort: - case clang::BuiltinType::UInt: - case clang::BuiltinType::ULong: - case clang::BuiltinType::ULongLong: - case clang::BuiltinType::UInt128: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: - case clang::BuiltinType::WChar_S: - case clang::BuiltinType::Short: - case clang::BuiltinType::Int: - case clang::BuiltinType::Long: - case clang::BuiltinType::LongLong: - case clang::BuiltinType::Int128: - case clang::BuiltinType::Float: - case clang::BuiltinType::Double: - case clang::BuiltinType::LongDouble: - break; - - case clang::BuiltinType::NullPtr: - return eLanguageTypeC_plus_plus; - - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCClass: - case clang::BuiltinType::ObjCSel: - return eLanguageTypeObjC; - - case clang::BuiltinType::Dependent: - case clang::BuiltinType::Overload: - case clang::BuiltinType::BoundMember: - case clang::BuiltinType::UnknownAny: - break; - } - break; - case clang::Type::Typedef: - return CompilerType(getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetMinimumLanguage(); - } - } + return eTypeHasChildren | eTypeIsStructUnion; + break; + case clang::Type::SubstTemplateTypeParm: + return eTypeIsTemplate; + case clang::Type::TemplateTypeParm: + return eTypeIsTemplate; + case clang::Type::TemplateSpecialization: + return eTypeIsTemplate; + + case clang::Type::Typedef: + return eTypeIsTypedef | + CompilerType(getASTContext(), + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()) + .GetTypeInfo(pointee_or_element_clang_type); + case clang::Type::TypeOfExpr: + return 0; + case clang::Type::TypeOf: + return 0; + case clang::Type::UnresolvedUsing: + return 0; + + case clang::Type::ExtVector: + case clang::Type::Vector: { + uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector; + const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>( + qual_type->getCanonicalTypeInternal()); + if (vector_type) { + if (vector_type->isIntegerType()) + vector_type_flags |= eTypeIsFloat; + else if (vector_type->isFloatingType()) + vector_type_flags |= eTypeIsInteger; + } + return vector_type_flags; + } + default: + return 0; + } + return 0; +} + +lldb::LanguageType +ClangASTContext::GetMinimumLanguage(lldb::opaque_compiler_type_t type) { + if (!type) return lldb::eLanguageTypeC; + + // If the type is a reference, then resolve it to what it refers to first: + clang::QualType qual_type(GetCanonicalQualType(type).getNonReferenceType()); + if (qual_type->isAnyPointerType()) { + if (qual_type->isObjCObjectPointerType()) + return lldb::eLanguageTypeObjC; + + clang::QualType pointee_type(qual_type->getPointeeType()); + if (pointee_type->getPointeeCXXRecordDecl() != nullptr) + return lldb::eLanguageTypeC_plus_plus; + if (pointee_type->isObjCObjectOrInterfaceType()) + return lldb::eLanguageTypeObjC; + if (pointee_type->isObjCClassType()) + return lldb::eLanguageTypeObjC; + if (pointee_type.getTypePtr() == + getASTContext()->ObjCBuiltinIdTy.getTypePtr()) + return lldb::eLanguageTypeObjC; + } else { + if (qual_type->isObjCObjectOrInterfaceType()) + return lldb::eLanguageTypeObjC; + if (qual_type->getAsCXXRecordDecl()) + return lldb::eLanguageTypeC_plus_plus; + switch (qual_type->getTypeClass()) { + default: + break; + case clang::Type::Builtin: + switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) { + default: + case clang::BuiltinType::Void: + case clang::BuiltinType::Bool: + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::WChar_U: + case clang::BuiltinType::Char16: + case clang::BuiltinType::Char32: + case clang::BuiltinType::UShort: + case clang::BuiltinType::UInt: + case clang::BuiltinType::ULong: + case clang::BuiltinType::ULongLong: + case clang::BuiltinType::UInt128: + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::WChar_S: + case clang::BuiltinType::Short: + case clang::BuiltinType::Int: + case clang::BuiltinType::Long: + case clang::BuiltinType::LongLong: + case clang::BuiltinType::Int128: + case clang::BuiltinType::Float: + case clang::BuiltinType::Double: + case clang::BuiltinType::LongDouble: + break; + + case clang::BuiltinType::NullPtr: + return eLanguageTypeC_plus_plus; + + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCClass: + case clang::BuiltinType::ObjCSel: + return eLanguageTypeObjC; + + case clang::BuiltinType::Dependent: + case clang::BuiltinType::Overload: + case clang::BuiltinType::BoundMember: + case clang::BuiltinType::UnknownAny: + break; + } + break; + case clang::Type::Typedef: + return CompilerType(getASTContext(), + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()) + .GetMinimumLanguage(); + } + } + return lldb::eLanguageTypeC; } lldb::TypeClass -ClangASTContext::GetTypeClass (lldb::opaque_compiler_type_t type) -{ - if (!type) - return lldb::eTypeClassInvalid; - - clang::QualType qual_type(GetQualType(type)); - - switch (qual_type->getTypeClass()) - { - case clang::Type::UnaryTransform: break; - case clang::Type::FunctionNoProto: return lldb::eTypeClassFunction; - case clang::Type::FunctionProto: return lldb::eTypeClassFunction; - case clang::Type::IncompleteArray: return lldb::eTypeClassArray; - case clang::Type::VariableArray: return lldb::eTypeClassArray; - case clang::Type::ConstantArray: return lldb::eTypeClassArray; - case clang::Type::DependentSizedArray: return lldb::eTypeClassArray; - case clang::Type::DependentSizedExtVector: return lldb::eTypeClassVector; - case clang::Type::ExtVector: return lldb::eTypeClassVector; - case clang::Type::Vector: return lldb::eTypeClassVector; - case clang::Type::Builtin: return lldb::eTypeClassBuiltin; - case clang::Type::ObjCObjectPointer: return lldb::eTypeClassObjCObjectPointer; - case clang::Type::BlockPointer: return lldb::eTypeClassBlockPointer; - case clang::Type::Pointer: return lldb::eTypeClassPointer; - case clang::Type::LValueReference: return lldb::eTypeClassReference; - case clang::Type::RValueReference: return lldb::eTypeClassReference; - case clang::Type::MemberPointer: return lldb::eTypeClassMemberPointer; - case clang::Type::Complex: - if (qual_type->isComplexType()) - return lldb::eTypeClassComplexFloat; - else - return lldb::eTypeClassComplexInteger; - case clang::Type::ObjCObject: return lldb::eTypeClassObjCObject; - case clang::Type::ObjCInterface: return lldb::eTypeClassObjCInterface; - case clang::Type::Record: - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - if (record_decl->isUnion()) - return lldb::eTypeClassUnion; - else if (record_decl->isStruct()) - return lldb::eTypeClassStruct; - else - return lldb::eTypeClassClass; - } - break; - case clang::Type::Enum: return lldb::eTypeClassEnumeration; - case clang::Type::Typedef: return lldb::eTypeClassTypedef; - case clang::Type::UnresolvedUsing: break; - case clang::Type::Paren: - return CompilerType(getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetTypeClass(); - case clang::Type::Auto: - return CompilerType(getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetTypeClass(); - case clang::Type::Elaborated: - return CompilerType(getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetTypeClass(); - - case clang::Type::Attributed: break; - case clang::Type::TemplateTypeParm: break; - case clang::Type::SubstTemplateTypeParm: break; - case clang::Type::SubstTemplateTypeParmPack:break; - case clang::Type::InjectedClassName: break; - case clang::Type::DependentName: break; - case clang::Type::DependentTemplateSpecialization: break; - case clang::Type::PackExpansion: break; - - case clang::Type::TypeOfExpr: break; - case clang::Type::TypeOf: break; - case clang::Type::Decltype: break; - case clang::Type::TemplateSpecialization: break; - case clang::Type::Atomic: break; - case clang::Type::Pipe: break; - - // pointer type decayed from an array or function type. - case clang::Type::Decayed: break; - case clang::Type::Adjusted: break; - } - // We don't know hot to display this type... - return lldb::eTypeClassOther; - -} - -unsigned -ClangASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) -{ - if (type) - return GetQualType(type).getQualifiers().getCVRQualifiers(); - return 0; +ClangASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) { + if (!type) + return lldb::eTypeClassInvalid; + + clang::QualType qual_type(GetQualType(type)); + + switch (qual_type->getTypeClass()) { + case clang::Type::UnaryTransform: + break; + case clang::Type::FunctionNoProto: + return lldb::eTypeClassFunction; + case clang::Type::FunctionProto: + return lldb::eTypeClassFunction; + case clang::Type::IncompleteArray: + return lldb::eTypeClassArray; + case clang::Type::VariableArray: + return lldb::eTypeClassArray; + case clang::Type::ConstantArray: + return lldb::eTypeClassArray; + case clang::Type::DependentSizedArray: + return lldb::eTypeClassArray; + case clang::Type::DependentSizedExtVector: + return lldb::eTypeClassVector; + case clang::Type::ExtVector: + return lldb::eTypeClassVector; + case clang::Type::Vector: + return lldb::eTypeClassVector; + case clang::Type::Builtin: + return lldb::eTypeClassBuiltin; + case clang::Type::ObjCObjectPointer: + return lldb::eTypeClassObjCObjectPointer; + case clang::Type::BlockPointer: + return lldb::eTypeClassBlockPointer; + case clang::Type::Pointer: + return lldb::eTypeClassPointer; + case clang::Type::LValueReference: + return lldb::eTypeClassReference; + case clang::Type::RValueReference: + return lldb::eTypeClassReference; + case clang::Type::MemberPointer: + return lldb::eTypeClassMemberPointer; + case clang::Type::Complex: + if (qual_type->isComplexType()) + return lldb::eTypeClassComplexFloat; + else + return lldb::eTypeClassComplexInteger; + case clang::Type::ObjCObject: + return lldb::eTypeClassObjCObject; + case clang::Type::ObjCInterface: + return lldb::eTypeClassObjCInterface; + case clang::Type::Record: { + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + if (record_decl->isUnion()) + return lldb::eTypeClassUnion; + else if (record_decl->isStruct()) + return lldb::eTypeClassStruct; + else + return lldb::eTypeClassClass; + } break; + case clang::Type::Enum: + return lldb::eTypeClassEnumeration; + case clang::Type::Typedef: + return lldb::eTypeClassTypedef; + case clang::Type::UnresolvedUsing: + break; + case clang::Type::Paren: + return CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar()) + .GetTypeClass(); + case clang::Type::Auto: + return CompilerType( + getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()) + .GetTypeClass(); + case clang::Type::Elaborated: + return CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()) + .GetTypeClass(); + + case clang::Type::Attributed: + break; + case clang::Type::TemplateTypeParm: + break; + case clang::Type::SubstTemplateTypeParm: + break; + case clang::Type::SubstTemplateTypeParmPack: + break; + case clang::Type::InjectedClassName: + break; + case clang::Type::DependentName: + break; + case clang::Type::DependentTemplateSpecialization: + break; + case clang::Type::PackExpansion: + break; + + case clang::Type::TypeOfExpr: + break; + case clang::Type::TypeOf: + break; + case clang::Type::Decltype: + break; + case clang::Type::TemplateSpecialization: + break; + case clang::Type::Atomic: + break; + case clang::Type::Pipe: + break; + + // pointer type decayed from an array or function type. + case clang::Type::Decayed: + break; + case clang::Type::Adjusted: + break; + } + // We don't know hot to display this type... + return lldb::eTypeClassOther; +} + +unsigned ClangASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) { + if (type) + return GetQualType(type).getQualifiers().getCVRQualifiers(); + return 0; } //---------------------------------------------------------------------- @@ -4542,1707 +4333,1822 @@ ClangASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) //---------------------------------------------------------------------- CompilerType -ClangASTContext::GetArrayElementType (lldb::opaque_compiler_type_t type, uint64_t *stride) -{ - if (type) - { - clang::QualType qual_type(GetCanonicalQualType(type)); - - const clang::Type *array_eletype = qual_type.getTypePtr()->getArrayElementTypeNoTypeQual(); - - if (!array_eletype) - return CompilerType(); - - CompilerType element_type (getASTContext(), array_eletype->getCanonicalTypeUnqualified()); - - // TODO: the real stride will be >= this value.. find the real one! - if (stride) - *stride = element_type.GetByteSize(nullptr); - - return element_type; - - } - return CompilerType(); -} +ClangASTContext::GetArrayElementType(lldb::opaque_compiler_type_t type, + uint64_t *stride) { + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); -CompilerType -ClangASTContext::GetArrayType (lldb::opaque_compiler_type_t type, uint64_t size) -{ - if (type) - { - clang::QualType qual_type(GetCanonicalQualType(type)); - if (clang::ASTContext *ast_ctx = getASTContext()) - { - if (size != 0) - return CompilerType (ast_ctx, ast_ctx->getConstantArrayType(qual_type, llvm::APInt(64, size), clang::ArrayType::ArraySizeModifier::Normal, 0)); - else - return CompilerType (ast_ctx, ast_ctx->getIncompleteArrayType(qual_type, clang::ArrayType::ArraySizeModifier::Normal, 0)); - } - } - - return CompilerType(); -} + const clang::Type *array_eletype = + qual_type.getTypePtr()->getArrayElementTypeNoTypeQual(); -CompilerType -ClangASTContext::GetCanonicalType (lldb::opaque_compiler_type_t type) -{ - if (type) - return CompilerType (getASTContext(), GetCanonicalQualType(type)); - return CompilerType(); + if (!array_eletype) + return CompilerType(); + + CompilerType element_type(getASTContext(), + array_eletype->getCanonicalTypeUnqualified()); + + // TODO: the real stride will be >= this value.. find the real one! + if (stride) + *stride = element_type.GetByteSize(nullptr); + + return element_type; + } + return CompilerType(); } -static clang::QualType -GetFullyUnqualifiedType_Impl (clang::ASTContext *ast, clang::QualType qual_type) -{ - if (qual_type->isPointerType()) - qual_type = ast->getPointerType(GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType())); - else - qual_type = qual_type.getUnqualifiedType(); - qual_type.removeLocalConst(); - qual_type.removeLocalRestrict(); - qual_type.removeLocalVolatile(); - return qual_type; +CompilerType ClangASTContext::GetArrayType(lldb::opaque_compiler_type_t type, + uint64_t size) { + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + if (clang::ASTContext *ast_ctx = getASTContext()) { + if (size != 0) + return CompilerType( + ast_ctx, ast_ctx->getConstantArrayType( + qual_type, llvm::APInt(64, size), + clang::ArrayType::ArraySizeModifier::Normal, 0)); + else + return CompilerType( + ast_ctx, + ast_ctx->getIncompleteArrayType( + qual_type, clang::ArrayType::ArraySizeModifier::Normal, 0)); + } + } + + return CompilerType(); } CompilerType -ClangASTContext::GetFullyUnqualifiedType (lldb::opaque_compiler_type_t type) -{ - if (type) - return CompilerType(getASTContext(), GetFullyUnqualifiedType_Impl(getASTContext(), GetQualType(type))); - return CompilerType(); +ClangASTContext::GetCanonicalType(lldb::opaque_compiler_type_t type) { + if (type) + return CompilerType(getASTContext(), GetCanonicalQualType(type)); + return CompilerType(); } - -int -ClangASTContext::GetFunctionArgumentCount (lldb::opaque_compiler_type_t type) -{ - if (type) - { - const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType(type)); - if (func) - return func->getNumParams(); - } - return -1; +static clang::QualType GetFullyUnqualifiedType_Impl(clang::ASTContext *ast, + clang::QualType qual_type) { + if (qual_type->isPointerType()) + qual_type = ast->getPointerType( + GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType())); + else + qual_type = qual_type.getUnqualifiedType(); + qual_type.removeLocalConst(); + qual_type.removeLocalRestrict(); + qual_type.removeLocalVolatile(); + return qual_type; } CompilerType -ClangASTContext::GetFunctionArgumentTypeAtIndex (lldb::opaque_compiler_type_t type, size_t idx) -{ - if (type) - { - const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(GetQualType(type)); - if (func) - { - const uint32_t num_args = func->getNumParams(); - if (idx < num_args) - return CompilerType(getASTContext(), func->getParamType(idx)); - } - } - return CompilerType(); +ClangASTContext::GetFullyUnqualifiedType(lldb::opaque_compiler_type_t type) { + if (type) + return CompilerType( + getASTContext(), + GetFullyUnqualifiedType_Impl(getASTContext(), GetQualType(type))); + return CompilerType(); +} + +int ClangASTContext::GetFunctionArgumentCount( + lldb::opaque_compiler_type_t type) { + if (type) { + const clang::FunctionProtoType *func = + llvm::dyn_cast<clang::FunctionProtoType>(GetCanonicalQualType(type)); + if (func) + return func->getNumParams(); + } + return -1; +} + +CompilerType ClangASTContext::GetFunctionArgumentTypeAtIndex( + lldb::opaque_compiler_type_t type, size_t idx) { + if (type) { + const clang::FunctionProtoType *func = + llvm::dyn_cast<clang::FunctionProtoType>(GetQualType(type)); + if (func) { + const uint32_t num_args = func->getNumParams(); + if (idx < num_args) + return CompilerType(getASTContext(), func->getParamType(idx)); + } + } + return CompilerType(); } CompilerType -ClangASTContext::GetFunctionReturnType (lldb::opaque_compiler_type_t type) -{ - if (type) - { - clang::QualType qual_type(GetQualType(type)); - const clang::FunctionProtoType* func = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr()); - if (func) - return CompilerType(getASTContext(), func->getReturnType()); - } - return CompilerType(); +ClangASTContext::GetFunctionReturnType(lldb::opaque_compiler_type_t type) { + if (type) { + clang::QualType qual_type(GetQualType(type)); + const clang::FunctionProtoType *func = + llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr()); + if (func) + return CompilerType(getASTContext(), func->getReturnType()); + } + return CompilerType(); } size_t -ClangASTContext::GetNumMemberFunctions (lldb::opaque_compiler_type_t type) -{ - size_t num_functions = 0; - if (type) - { - clang::QualType qual_type(GetCanonicalQualType(type)); - switch (qual_type->getTypeClass()) { - case clang::Type::Record: - if (GetCompleteQualType (getASTContext(), qual_type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - assert(record_decl); - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - if (cxx_record_decl) - num_functions = std::distance(cxx_record_decl->method_begin(), cxx_record_decl->method_end()); - } - break; - - case clang::Type::ObjCObjectPointer: - if (GetCompleteType(type)) - { - const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); - if (class_interface_decl) - num_functions = std::distance(class_interface_decl->meth_begin(), class_interface_decl->meth_end()); - } - } - break; - - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - if (GetCompleteType(type)) - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - if (class_interface_decl) - num_functions = std::distance(class_interface_decl->meth_begin(), class_interface_decl->meth_end()); - } - } - break; - - - case clang::Type::Typedef: - return CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumMemberFunctions(); - - case clang::Type::Auto: - return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetNumMemberFunctions(); - - case clang::Type::Elaborated: - return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumMemberFunctions(); - - case clang::Type::Paren: - return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumMemberFunctions(); - - default: - break; +ClangASTContext::GetNumMemberFunctions(lldb::opaque_compiler_type_t type) { + size_t num_functions = 0; + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + switch (qual_type->getTypeClass()) { + case clang::Type::Record: + if (GetCompleteQualType(getASTContext(), qual_type)) { + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + assert(record_decl); + const clang::CXXRecordDecl *cxx_record_decl = + llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); + if (cxx_record_decl) + num_functions = std::distance(cxx_record_decl->method_begin(), + cxx_record_decl->method_end()); + } + break; + + case clang::Type::ObjCObjectPointer: + if (GetCompleteType(type)) { + const clang::ObjCObjectPointerType *objc_class_type = + qual_type->getAsObjCInterfacePointerType(); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterfaceDecl(); + if (class_interface_decl) + num_functions = std::distance(class_interface_decl->meth_begin(), + class_interface_decl->meth_end()); + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (GetCompleteType(type)) { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + if (class_interface_decl) + num_functions = std::distance(class_interface_decl->meth_begin(), + class_interface_decl->meth_end()); } + } + break; + + case clang::Type::Typedef: + return CompilerType(getASTContext(), + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()) + .GetNumMemberFunctions(); + + case clang::Type::Auto: + return CompilerType( + getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()) + .GetNumMemberFunctions(); + + case clang::Type::Elaborated: + return CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()) + .GetNumMemberFunctions(); + + case clang::Type::Paren: + return CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar()) + .GetNumMemberFunctions(); + + default: + break; } - return num_functions; + } + return num_functions; } TypeMemberFunctionImpl -ClangASTContext::GetMemberFunctionAtIndex (lldb::opaque_compiler_type_t type, size_t idx) -{ - std::string name; - MemberFunctionKind kind(MemberFunctionKind::eMemberFunctionKindUnknown); - CompilerType clang_type; - CompilerDecl clang_decl; - if (type) - { - clang::QualType qual_type(GetCanonicalQualType(type)); - switch (qual_type->getTypeClass()) { - case clang::Type::Record: - if (GetCompleteQualType (getASTContext(), qual_type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - assert(record_decl); - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - if (cxx_record_decl) - { - auto method_iter = cxx_record_decl->method_begin(); - auto method_end = cxx_record_decl->method_end(); - if (idx < static_cast<size_t>(std::distance(method_iter, method_end))) - { - std::advance(method_iter, idx); - clang::CXXMethodDecl *cxx_method_decl = method_iter->getCanonicalDecl(); - if (cxx_method_decl) - { - name = cxx_method_decl->getDeclName().getAsString(); - if (cxx_method_decl->isStatic()) - kind = lldb::eMemberFunctionKindStaticMethod; - else if (llvm::isa<clang::CXXConstructorDecl>(cxx_method_decl)) - kind = lldb::eMemberFunctionKindConstructor; - else if (llvm::isa<clang::CXXDestructorDecl>(cxx_method_decl)) - kind = lldb::eMemberFunctionKindDestructor; - else - kind = lldb::eMemberFunctionKindInstanceMethod; - clang_type = CompilerType(this, cxx_method_decl->getType().getAsOpaquePtr()); - clang_decl = CompilerDecl(this, cxx_method_decl); - } - } - } - } - break; - - case clang::Type::ObjCObjectPointer: - if (GetCompleteType(type)) - { - const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); - if (class_interface_decl) - { - auto method_iter = class_interface_decl->meth_begin(); - auto method_end = class_interface_decl->meth_end(); - if (idx < static_cast<size_t>(std::distance(method_iter, method_end))) - { - std::advance(method_iter, idx); - clang::ObjCMethodDecl *objc_method_decl = method_iter->getCanonicalDecl(); - if (objc_method_decl) - { - clang_decl = CompilerDecl(this, objc_method_decl); - name = objc_method_decl->getSelector().getAsString(); - if (objc_method_decl->isClassMethod()) - kind = lldb::eMemberFunctionKindStaticMethod; - else - kind = lldb::eMemberFunctionKindInstanceMethod; - } - } - } - } - } - break; - - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - if (GetCompleteType(type)) - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - if (class_interface_decl) - { - auto method_iter = class_interface_decl->meth_begin(); - auto method_end = class_interface_decl->meth_end(); - if (idx < static_cast<size_t>(std::distance(method_iter, method_end))) - { - std::advance(method_iter, idx); - clang::ObjCMethodDecl *objc_method_decl = method_iter->getCanonicalDecl(); - if (objc_method_decl) - { - clang_decl = CompilerDecl(this, objc_method_decl); - name = objc_method_decl->getSelector().getAsString(); - if (objc_method_decl->isClassMethod()) - kind = lldb::eMemberFunctionKindStaticMethod; - else - kind = lldb::eMemberFunctionKindInstanceMethod; - } - } - } - } - } - break; - - case clang::Type::Typedef: - return GetMemberFunctionAtIndex(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), idx); - - case clang::Type::Auto: - return GetMemberFunctionAtIndex(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), idx); - - case clang::Type::Elaborated: - return GetMemberFunctionAtIndex(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), idx); - - case clang::Type::Paren: - return GetMemberFunctionAtIndex(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), idx); - - default: - break; +ClangASTContext::GetMemberFunctionAtIndex(lldb::opaque_compiler_type_t type, + size_t idx) { + std::string name; + MemberFunctionKind kind(MemberFunctionKind::eMemberFunctionKindUnknown); + CompilerType clang_type; + CompilerDecl clang_decl; + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + switch (qual_type->getTypeClass()) { + case clang::Type::Record: + if (GetCompleteQualType(getASTContext(), qual_type)) { + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + assert(record_decl); + const clang::CXXRecordDecl *cxx_record_decl = + llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); + if (cxx_record_decl) { + auto method_iter = cxx_record_decl->method_begin(); + auto method_end = cxx_record_decl->method_end(); + if (idx < + static_cast<size_t>(std::distance(method_iter, method_end))) { + std::advance(method_iter, idx); + clang::CXXMethodDecl *cxx_method_decl = + method_iter->getCanonicalDecl(); + if (cxx_method_decl) { + name = cxx_method_decl->getDeclName().getAsString(); + if (cxx_method_decl->isStatic()) + kind = lldb::eMemberFunctionKindStaticMethod; + else if (llvm::isa<clang::CXXConstructorDecl>(cxx_method_decl)) + kind = lldb::eMemberFunctionKindConstructor; + else if (llvm::isa<clang::CXXDestructorDecl>(cxx_method_decl)) + kind = lldb::eMemberFunctionKindDestructor; + else + kind = lldb::eMemberFunctionKindInstanceMethod; + clang_type = CompilerType( + this, cxx_method_decl->getType().getAsOpaquePtr()); + clang_decl = CompilerDecl(this, cxx_method_decl); + } + } } + } + break; + + case clang::Type::ObjCObjectPointer: + if (GetCompleteType(type)) { + const clang::ObjCObjectPointerType *objc_class_type = + qual_type->getAsObjCInterfacePointerType(); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterfaceDecl(); + if (class_interface_decl) { + auto method_iter = class_interface_decl->meth_begin(); + auto method_end = class_interface_decl->meth_end(); + if (idx < + static_cast<size_t>(std::distance(method_iter, method_end))) { + std::advance(method_iter, idx); + clang::ObjCMethodDecl *objc_method_decl = + method_iter->getCanonicalDecl(); + if (objc_method_decl) { + clang_decl = CompilerDecl(this, objc_method_decl); + name = objc_method_decl->getSelector().getAsString(); + if (objc_method_decl->isClassMethod()) + kind = lldb::eMemberFunctionKindStaticMethod; + else + kind = lldb::eMemberFunctionKindInstanceMethod; + } + } + } + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (GetCompleteType(type)) { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + if (class_interface_decl) { + auto method_iter = class_interface_decl->meth_begin(); + auto method_end = class_interface_decl->meth_end(); + if (idx < + static_cast<size_t>(std::distance(method_iter, method_end))) { + std::advance(method_iter, idx); + clang::ObjCMethodDecl *objc_method_decl = + method_iter->getCanonicalDecl(); + if (objc_method_decl) { + clang_decl = CompilerDecl(this, objc_method_decl); + name = objc_method_decl->getSelector().getAsString(); + if (objc_method_decl->isClassMethod()) + kind = lldb::eMemberFunctionKindStaticMethod; + else + kind = lldb::eMemberFunctionKindInstanceMethod; + } + } + } + } + } + break; + + case clang::Type::Typedef: + return GetMemberFunctionAtIndex(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + idx); + + case clang::Type::Auto: + return GetMemberFunctionAtIndex(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + idx); + + case clang::Type::Elaborated: + return GetMemberFunctionAtIndex( + llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + idx); + + case clang::Type::Paren: + return GetMemberFunctionAtIndex( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), + idx); + + default: + break; } - - if (kind == eMemberFunctionKindUnknown) - return TypeMemberFunctionImpl(); - else - return TypeMemberFunctionImpl(clang_type, clang_decl, name, kind); + } + + if (kind == eMemberFunctionKindUnknown) + return TypeMemberFunctionImpl(); + else + return TypeMemberFunctionImpl(clang_type, clang_decl, name, kind); } CompilerType -ClangASTContext::GetNonReferenceType (lldb::opaque_compiler_type_t type) -{ - if (type) - return CompilerType(getASTContext(), GetQualType(type).getNonReferenceType()); - return CompilerType(); +ClangASTContext::GetNonReferenceType(lldb::opaque_compiler_type_t type) { + if (type) + return CompilerType(getASTContext(), + GetQualType(type).getNonReferenceType()); + return CompilerType(); +} + +CompilerType ClangASTContext::CreateTypedefType( + const CompilerType &type, const char *typedef_name, + const CompilerDeclContext &compiler_decl_ctx) { + if (type && typedef_name && typedef_name[0]) { + ClangASTContext *ast = + llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); + if (!ast) + return CompilerType(); + clang::ASTContext *clang_ast = ast->getASTContext(); + clang::QualType qual_type(ClangUtil::GetQualType(type)); + + clang::DeclContext *decl_ctx = + ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx); + if (decl_ctx == nullptr) + decl_ctx = ast->getASTContext()->getTranslationUnitDecl(); + + clang::TypedefDecl *decl = clang::TypedefDecl::Create( + *clang_ast, decl_ctx, clang::SourceLocation(), clang::SourceLocation(), + &clang_ast->Idents.get(typedef_name), + clang_ast->getTrivialTypeSourceInfo(qual_type)); + + decl->setAccess(clang::AS_public); // TODO respect proper access specifier + + // Get a uniqued clang::QualType for the typedef decl type + return CompilerType(clang_ast, clang_ast->getTypedefType(decl)); + } + return CompilerType(); } CompilerType -ClangASTContext::CreateTypedefType (const CompilerType& type, - const char *typedef_name, - const CompilerDeclContext &compiler_decl_ctx) -{ - if (type && typedef_name && typedef_name[0]) - { - ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); - if (!ast) - return CompilerType(); - clang::ASTContext* clang_ast = ast->getASTContext(); - clang::QualType qual_type(ClangUtil::GetQualType(type)); - - clang::DeclContext *decl_ctx = ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx); - if (decl_ctx == nullptr) - decl_ctx = ast->getASTContext()->getTranslationUnitDecl(); - - clang::TypedefDecl *decl = clang::TypedefDecl::Create (*clang_ast, - decl_ctx, - clang::SourceLocation(), - clang::SourceLocation(), - &clang_ast->Idents.get(typedef_name), - clang_ast->getTrivialTypeSourceInfo(qual_type)); - - decl->setAccess(clang::AS_public); // TODO respect proper access specifier - - // Get a uniqued clang::QualType for the typedef decl type - return CompilerType (clang_ast, clang_ast->getTypedefType (decl)); - } - return CompilerType(); - +ClangASTContext::GetPointeeType(lldb::opaque_compiler_type_t type) { + if (type) { + clang::QualType qual_type(GetQualType(type)); + return CompilerType(getASTContext(), + qual_type.getTypePtr()->getPointeeType()); + } + return CompilerType(); } CompilerType -ClangASTContext::GetPointeeType (lldb::opaque_compiler_type_t type) -{ - if (type) - { - clang::QualType qual_type(GetQualType(type)); - return CompilerType (getASTContext(), qual_type.getTypePtr()->getPointeeType()); +ClangASTContext::GetPointerType(lldb::opaque_compiler_type_t type) { + if (type) { + clang::QualType qual_type(GetQualType(type)); + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + return CompilerType(getASTContext(), + getASTContext()->getObjCObjectPointerType(qual_type)); + + default: + return CompilerType(getASTContext(), + getASTContext()->getPointerType(qual_type)); } - return CompilerType(); + } + return CompilerType(); } CompilerType -ClangASTContext::GetPointerType (lldb::opaque_compiler_type_t type) -{ - if (type) - { - clang::QualType qual_type (GetQualType(type)); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - return CompilerType(getASTContext(), getASTContext()->getObjCObjectPointerType(qual_type)); - - default: - return CompilerType(getASTContext(), getASTContext()->getPointerType(qual_type)); - } - } +ClangASTContext::GetLValueReferenceType(lldb::opaque_compiler_type_t type) { + if (type) + return CompilerType(this, getASTContext() + ->getLValueReferenceType(GetQualType(type)) + .getAsOpaquePtr()); + else return CompilerType(); } - CompilerType -ClangASTContext::GetLValueReferenceType (lldb::opaque_compiler_type_t type) -{ - if (type) - return CompilerType(this, getASTContext()->getLValueReferenceType(GetQualType(type)).getAsOpaquePtr()); - else - return CompilerType(); +ClangASTContext::GetRValueReferenceType(lldb::opaque_compiler_type_t type) { + if (type) + return CompilerType(this, getASTContext() + ->getRValueReferenceType(GetQualType(type)) + .getAsOpaquePtr()); + else + return CompilerType(); } CompilerType -ClangASTContext::GetRValueReferenceType (lldb::opaque_compiler_type_t type) -{ - if (type) - return CompilerType(this, getASTContext()->getRValueReferenceType(GetQualType(type)).getAsOpaquePtr()); - else - return CompilerType(); +ClangASTContext::AddConstModifier(lldb::opaque_compiler_type_t type) { + if (type) { + clang::QualType result(GetQualType(type)); + result.addConst(); + return CompilerType(this, result.getAsOpaquePtr()); + } + return CompilerType(); } CompilerType -ClangASTContext::AddConstModifier (lldb::opaque_compiler_type_t type) -{ - if (type) - { - clang::QualType result(GetQualType(type)); - result.addConst(); - return CompilerType (this, result.getAsOpaquePtr()); - } - return CompilerType(); +ClangASTContext::AddVolatileModifier(lldb::opaque_compiler_type_t type) { + if (type) { + clang::QualType result(GetQualType(type)); + result.addVolatile(); + return CompilerType(this, result.getAsOpaquePtr()); + } + return CompilerType(); } CompilerType -ClangASTContext::AddVolatileModifier (lldb::opaque_compiler_type_t type) -{ - if (type) - { - clang::QualType result(GetQualType(type)); - result.addVolatile(); - return CompilerType (this, result.getAsOpaquePtr()); - } - return CompilerType(); - +ClangASTContext::AddRestrictModifier(lldb::opaque_compiler_type_t type) { + if (type) { + clang::QualType result(GetQualType(type)); + result.addRestrict(); + return CompilerType(this, result.getAsOpaquePtr()); + } + return CompilerType(); } CompilerType -ClangASTContext::AddRestrictModifier (lldb::opaque_compiler_type_t type) -{ - if (type) - { - clang::QualType result(GetQualType(type)); - result.addRestrict(); - return CompilerType (this, result.getAsOpaquePtr()); - } - return CompilerType(); - -} +ClangASTContext::CreateTypedef(lldb::opaque_compiler_type_t type, + const char *typedef_name, + const CompilerDeclContext &compiler_decl_ctx) { + if (type) { + clang::ASTContext *clang_ast = getASTContext(); + clang::QualType qual_type(GetQualType(type)); -CompilerType -ClangASTContext::CreateTypedef (lldb::opaque_compiler_type_t type, const char *typedef_name, const CompilerDeclContext &compiler_decl_ctx) -{ - if (type) - { - clang::ASTContext* clang_ast = getASTContext(); - clang::QualType qual_type (GetQualType(type)); - - clang::DeclContext *decl_ctx = ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx); - if (decl_ctx == nullptr) - decl_ctx = getASTContext()->getTranslationUnitDecl(); - - clang::TypedefDecl *decl = clang::TypedefDecl::Create (*clang_ast, - decl_ctx, - clang::SourceLocation(), - clang::SourceLocation(), - &clang_ast->Idents.get(typedef_name), - clang_ast->getTrivialTypeSourceInfo(qual_type)); - - clang::TagDecl *tdecl = nullptr; - if (!qual_type.isNull()) - { - if (const clang::RecordType *rt = qual_type->getAs<clang::RecordType>()) - tdecl = rt->getDecl(); - if (const clang::EnumType *et = qual_type->getAs<clang::EnumType>()) - tdecl = et->getDecl(); - } + clang::DeclContext *decl_ctx = + ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx); + if (decl_ctx == nullptr) + decl_ctx = getASTContext()->getTranslationUnitDecl(); - // Check whether this declaration is an anonymous struct, union, or enum, hidden behind a typedef. If so, we - // try to check whether we have a typedef tag to attach to the original record declaration - if (tdecl && !tdecl->getIdentifier() && !tdecl->getTypedefNameForAnonDecl()) - tdecl->setTypedefNameForAnonDecl(decl); + clang::TypedefDecl *decl = clang::TypedefDecl::Create( + *clang_ast, decl_ctx, clang::SourceLocation(), clang::SourceLocation(), + &clang_ast->Idents.get(typedef_name), + clang_ast->getTrivialTypeSourceInfo(qual_type)); - decl->setAccess(clang::AS_public); // TODO respect proper access specifier + clang::TagDecl *tdecl = nullptr; + if (!qual_type.isNull()) { + if (const clang::RecordType *rt = qual_type->getAs<clang::RecordType>()) + tdecl = rt->getDecl(); + if (const clang::EnumType *et = qual_type->getAs<clang::EnumType>()) + tdecl = et->getDecl(); + } - // Get a uniqued clang::QualType for the typedef decl type - return CompilerType (this, clang_ast->getTypedefType (decl).getAsOpaquePtr()); + // Check whether this declaration is an anonymous struct, union, or enum, + // hidden behind a typedef. If so, we + // try to check whether we have a typedef tag to attach to the original + // record declaration + if (tdecl && !tdecl->getIdentifier() && !tdecl->getTypedefNameForAnonDecl()) + tdecl->setTypedefNameForAnonDecl(decl); - } - return CompilerType(); + decl->setAccess(clang::AS_public); // TODO respect proper access specifier + // Get a uniqued clang::QualType for the typedef decl type + return CompilerType(this, clang_ast->getTypedefType(decl).getAsOpaquePtr()); + } + return CompilerType(); } CompilerType -ClangASTContext::GetTypedefedType (lldb::opaque_compiler_type_t type) -{ - if (type) - { - const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(GetQualType(type)); - if (typedef_type) - return CompilerType (getASTContext(), typedef_type->getDecl()->getUnderlyingType()); - } - return CompilerType(); +ClangASTContext::GetTypedefedType(lldb::opaque_compiler_type_t type) { + if (type) { + const clang::TypedefType *typedef_type = + llvm::dyn_cast<clang::TypedefType>(GetQualType(type)); + if (typedef_type) + return CompilerType(getASTContext(), + typedef_type->getDecl()->getUnderlyingType()); + } + return CompilerType(); } - //---------------------------------------------------------------------- // Create related types using the current type's AST //---------------------------------------------------------------------- -CompilerType -ClangASTContext::GetBasicTypeFromAST (lldb::BasicType basic_type) -{ - return ClangASTContext::GetBasicType(getASTContext(), basic_type); +CompilerType ClangASTContext::GetBasicTypeFromAST(lldb::BasicType basic_type) { + return ClangASTContext::GetBasicType(getASTContext(), basic_type); } //---------------------------------------------------------------------- // Exploring the type //---------------------------------------------------------------------- -uint64_t -ClangASTContext::GetBitSize (lldb::opaque_compiler_type_t type, ExecutionContextScope *exe_scope) -{ - if (GetCompleteType (type)) - { - clang::QualType qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - return getASTContext()->getTypeSize(qual_type); - else - return 0; - break; - - case clang::Type::ObjCInterface: - case clang::Type::ObjCObject: - { - ExecutionContext exe_ctx (exe_scope); - Process *process = exe_ctx.GetProcessPtr(); - if (process) - { - ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime(); - if (objc_runtime) - { - uint64_t bit_size = 0; - if (objc_runtime->GetTypeBitSize(CompilerType(getASTContext(), qual_type), bit_size)) - return bit_size; - } - } - else - { - static bool g_printed = false; - if (!g_printed) - { - StreamString s; - DumpTypeDescription(type, &s); - - llvm::outs() << "warning: trying to determine the size of type "; - llvm::outs() << s.GetString() << "\n"; - llvm::outs() << "without a valid ExecutionContext. this is not reliable. please file a bug against LLDB.\n"; - llvm::outs() << "backtrace:\n"; - llvm::sys::PrintStackTrace(llvm::outs()); - llvm::outs() << "\n"; - g_printed = true; - } - } - } - LLVM_FALLTHROUGH; - default: - const uint32_t bit_size = getASTContext()->getTypeSize (qual_type); - if (bit_size == 0) - { - if (qual_type->isIncompleteArrayType()) - return getASTContext()->getTypeSize (qual_type->getArrayElementTypeNoTypeQual()->getCanonicalTypeUnqualified()); - } - if (qual_type->isObjCObjectOrInterfaceType()) - return bit_size + getASTContext()->getTypeSize(getASTContext()->ObjCBuiltinClassTy); - return bit_size; +uint64_t ClangASTContext::GetBitSize(lldb::opaque_compiler_type_t type, + ExecutionContextScope *exe_scope) { + if (GetCompleteType(type)) { + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) + return getASTContext()->getTypeSize(qual_type); + else + return 0; + break; + + case clang::Type::ObjCInterface: + case clang::Type::ObjCObject: { + ExecutionContext exe_ctx(exe_scope); + Process *process = exe_ctx.GetProcessPtr(); + if (process) { + ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime(); + if (objc_runtime) { + uint64_t bit_size = 0; + if (objc_runtime->GetTypeBitSize( + CompilerType(getASTContext(), qual_type), bit_size)) + return bit_size; + } + } else { + static bool g_printed = false; + if (!g_printed) { + StreamString s; + DumpTypeDescription(type, &s); + + llvm::outs() << "warning: trying to determine the size of type "; + llvm::outs() << s.GetString() << "\n"; + llvm::outs() << "without a valid ExecutionContext. this is not " + "reliable. please file a bug against LLDB.\n"; + llvm::outs() << "backtrace:\n"; + llvm::sys::PrintStackTrace(llvm::outs()); + llvm::outs() << "\n"; + g_printed = true; } + } } - return 0; -} + LLVM_FALLTHROUGH; + default: + const uint32_t bit_size = getASTContext()->getTypeSize(qual_type); + if (bit_size == 0) { + if (qual_type->isIncompleteArrayType()) + return getASTContext()->getTypeSize( + qual_type->getArrayElementTypeNoTypeQual() + ->getCanonicalTypeUnqualified()); + } + if (qual_type->isObjCObjectOrInterfaceType()) + return bit_size + + getASTContext()->getTypeSize( + getASTContext()->ObjCBuiltinClassTy); + return bit_size; + } + } + return 0; +} + +size_t ClangASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) { + if (GetCompleteType(type)) + return getASTContext()->getTypeAlign(GetQualType(type)); + return 0; +} + +lldb::Encoding ClangASTContext::GetEncoding(lldb::opaque_compiler_type_t type, + uint64_t &count) { + if (!type) + return lldb::eEncodingInvalid; -size_t -ClangASTContext::GetTypeBitAlign (lldb::opaque_compiler_type_t type) -{ - if (GetCompleteType(type)) - return getASTContext()->getTypeAlign(GetQualType(type)); - return 0; + count = 1; + clang::QualType qual_type(GetCanonicalQualType(type)); + + switch (qual_type->getTypeClass()) { + case clang::Type::UnaryTransform: + break; + + case clang::Type::FunctionNoProto: + case clang::Type::FunctionProto: + break; + + case clang::Type::IncompleteArray: + case clang::Type::VariableArray: + break; + + case clang::Type::ConstantArray: + break; + + case clang::Type::ExtVector: + case clang::Type::Vector: + // TODO: Set this to more than one??? + break; + + case clang::Type::Builtin: + switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) { + case clang::BuiltinType::Void: + break; + + case clang::BuiltinType::Bool: + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::WChar_S: + case clang::BuiltinType::Char16: + case clang::BuiltinType::Char32: + case clang::BuiltinType::Short: + case clang::BuiltinType::Int: + case clang::BuiltinType::Long: + case clang::BuiltinType::LongLong: + case clang::BuiltinType::Int128: + return lldb::eEncodingSint; + + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::WChar_U: + case clang::BuiltinType::UShort: + case clang::BuiltinType::UInt: + case clang::BuiltinType::ULong: + case clang::BuiltinType::ULongLong: + case clang::BuiltinType::UInt128: + return lldb::eEncodingUint; + + case clang::BuiltinType::Half: + case clang::BuiltinType::Float: + case clang::BuiltinType::Float128: + case clang::BuiltinType::Double: + case clang::BuiltinType::LongDouble: + return lldb::eEncodingIEEE754; + + case clang::BuiltinType::ObjCClass: + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCSel: + return lldb::eEncodingUint; + + case clang::BuiltinType::NullPtr: + return lldb::eEncodingUint; + + case clang::BuiltinType::Kind::ARCUnbridgedCast: + case clang::BuiltinType::Kind::BoundMember: + case clang::BuiltinType::Kind::BuiltinFn: + case clang::BuiltinType::Kind::Dependent: + case clang::BuiltinType::Kind::OCLClkEvent: + case clang::BuiltinType::Kind::OCLEvent: + case clang::BuiltinType::Kind::OCLImage1dRO: + case clang::BuiltinType::Kind::OCLImage1dWO: + case clang::BuiltinType::Kind::OCLImage1dRW: + case clang::BuiltinType::Kind::OCLImage1dArrayRO: + case clang::BuiltinType::Kind::OCLImage1dArrayWO: + case clang::BuiltinType::Kind::OCLImage1dArrayRW: + case clang::BuiltinType::Kind::OCLImage1dBufferRO: + case clang::BuiltinType::Kind::OCLImage1dBufferWO: + case clang::BuiltinType::Kind::OCLImage1dBufferRW: + case clang::BuiltinType::Kind::OCLImage2dRO: + case clang::BuiltinType::Kind::OCLImage2dWO: + case clang::BuiltinType::Kind::OCLImage2dRW: + case clang::BuiltinType::Kind::OCLImage2dArrayRO: + case clang::BuiltinType::Kind::OCLImage2dArrayWO: + case clang::BuiltinType::Kind::OCLImage2dArrayRW: + case clang::BuiltinType::Kind::OCLImage2dArrayDepthRO: + case clang::BuiltinType::Kind::OCLImage2dArrayDepthWO: + case clang::BuiltinType::Kind::OCLImage2dArrayDepthRW: + case clang::BuiltinType::Kind::OCLImage2dArrayMSAARO: + case clang::BuiltinType::Kind::OCLImage2dArrayMSAAWO: + case clang::BuiltinType::Kind::OCLImage2dArrayMSAARW: + case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRO: + case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthWO: + case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRW: + case clang::BuiltinType::Kind::OCLImage2dDepthRO: + case clang::BuiltinType::Kind::OCLImage2dDepthWO: + case clang::BuiltinType::Kind::OCLImage2dDepthRW: + case clang::BuiltinType::Kind::OCLImage2dMSAARO: + case clang::BuiltinType::Kind::OCLImage2dMSAAWO: + case clang::BuiltinType::Kind::OCLImage2dMSAARW: + case clang::BuiltinType::Kind::OCLImage2dMSAADepthRO: + case clang::BuiltinType::Kind::OCLImage2dMSAADepthWO: + case clang::BuiltinType::Kind::OCLImage2dMSAADepthRW: + case clang::BuiltinType::Kind::OCLImage3dRO: + case clang::BuiltinType::Kind::OCLImage3dWO: + case clang::BuiltinType::Kind::OCLImage3dRW: + case clang::BuiltinType::Kind::OCLQueue: + case clang::BuiltinType::Kind::OCLNDRange: + case clang::BuiltinType::Kind::OCLReserveID: + case clang::BuiltinType::Kind::OCLSampler: + case clang::BuiltinType::Kind::OMPArraySection: + case clang::BuiltinType::Kind::Overload: + case clang::BuiltinType::Kind::PseudoObject: + case clang::BuiltinType::Kind::UnknownAny: + break; + } + break; + // All pointer types are represented as unsigned integer encodings. + // We may nee to add a eEncodingPointer if we ever need to know the + // difference + case clang::Type::ObjCObjectPointer: + case clang::Type::BlockPointer: + case clang::Type::Pointer: + case clang::Type::LValueReference: + case clang::Type::RValueReference: + case clang::Type::MemberPointer: + return lldb::eEncodingUint; + case clang::Type::Complex: { + lldb::Encoding encoding = lldb::eEncodingIEEE754; + if (qual_type->isComplexType()) + encoding = lldb::eEncodingIEEE754; + else { + const clang::ComplexType *complex_type = + qual_type->getAsComplexIntegerType(); + if (complex_type) + encoding = CompilerType(getASTContext(), complex_type->getElementType()) + .GetEncoding(count); + else + encoding = lldb::eEncodingSint; + } + count = 2; + return encoding; + } + + case clang::Type::ObjCInterface: + break; + case clang::Type::Record: + break; + case clang::Type::Enum: + return lldb::eEncodingSint; + case clang::Type::Typedef: + return CompilerType(getASTContext(), + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()) + .GetEncoding(count); + + case clang::Type::Auto: + return CompilerType( + getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()) + .GetEncoding(count); + + case clang::Type::Elaborated: + return CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()) + .GetEncoding(count); + + case clang::Type::Paren: + return CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar()) + .GetEncoding(count); + + case clang::Type::DependentSizedArray: + case clang::Type::DependentSizedExtVector: + case clang::Type::UnresolvedUsing: + case clang::Type::Attributed: + case clang::Type::TemplateTypeParm: + case clang::Type::SubstTemplateTypeParm: + case clang::Type::SubstTemplateTypeParmPack: + case clang::Type::InjectedClassName: + case clang::Type::DependentName: + case clang::Type::DependentTemplateSpecialization: + case clang::Type::PackExpansion: + case clang::Type::ObjCObject: + + case clang::Type::TypeOfExpr: + case clang::Type::TypeOf: + case clang::Type::Decltype: + case clang::Type::TemplateSpecialization: + case clang::Type::Atomic: + case clang::Type::Adjusted: + case clang::Type::Pipe: + break; + + // pointer type decayed from an array or function type. + case clang::Type::Decayed: + break; + } + count = 0; + return lldb::eEncodingInvalid; +} + +lldb::Format ClangASTContext::GetFormat(lldb::opaque_compiler_type_t type) { + if (!type) + return lldb::eFormatDefault; + + clang::QualType qual_type(GetCanonicalQualType(type)); + + switch (qual_type->getTypeClass()) { + case clang::Type::UnaryTransform: + break; + + case clang::Type::FunctionNoProto: + case clang::Type::FunctionProto: + break; + + case clang::Type::IncompleteArray: + case clang::Type::VariableArray: + break; + + case clang::Type::ConstantArray: + return lldb::eFormatVoid; // no value + + case clang::Type::ExtVector: + case clang::Type::Vector: + break; + + case clang::Type::Builtin: + switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) { + // default: assert(0 && "Unknown builtin type!"); + case clang::BuiltinType::UnknownAny: + case clang::BuiltinType::Void: + case clang::BuiltinType::BoundMember: + break; + + case clang::BuiltinType::Bool: + return lldb::eFormatBoolean; + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::WChar_S: + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::WChar_U: + return lldb::eFormatChar; + case clang::BuiltinType::Char16: + return lldb::eFormatUnicode16; + case clang::BuiltinType::Char32: + return lldb::eFormatUnicode32; + case clang::BuiltinType::UShort: + return lldb::eFormatUnsigned; + case clang::BuiltinType::Short: + return lldb::eFormatDecimal; + case clang::BuiltinType::UInt: + return lldb::eFormatUnsigned; + case clang::BuiltinType::Int: + return lldb::eFormatDecimal; + case clang::BuiltinType::ULong: + return lldb::eFormatUnsigned; + case clang::BuiltinType::Long: + return lldb::eFormatDecimal; + case clang::BuiltinType::ULongLong: + return lldb::eFormatUnsigned; + case clang::BuiltinType::LongLong: + return lldb::eFormatDecimal; + case clang::BuiltinType::UInt128: + return lldb::eFormatUnsigned; + case clang::BuiltinType::Int128: + return lldb::eFormatDecimal; + case clang::BuiltinType::Half: + case clang::BuiltinType::Float: + case clang::BuiltinType::Double: + case clang::BuiltinType::LongDouble: + return lldb::eFormatFloat; + default: + return lldb::eFormatHex; + } + break; + case clang::Type::ObjCObjectPointer: + return lldb::eFormatHex; + case clang::Type::BlockPointer: + return lldb::eFormatHex; + case clang::Type::Pointer: + return lldb::eFormatHex; + case clang::Type::LValueReference: + case clang::Type::RValueReference: + return lldb::eFormatHex; + case clang::Type::MemberPointer: + break; + case clang::Type::Complex: { + if (qual_type->isComplexType()) + return lldb::eFormatComplex; + else + return lldb::eFormatComplexInteger; + } + case clang::Type::ObjCInterface: + break; + case clang::Type::Record: + break; + case clang::Type::Enum: + return lldb::eFormatEnum; + case clang::Type::Typedef: + return CompilerType(getASTContext(), + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()) + .GetFormat(); + case clang::Type::Auto: + return CompilerType(getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->desugar()) + .GetFormat(); + case clang::Type::Paren: + return CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar()) + .GetFormat(); + case clang::Type::Elaborated: + return CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()) + .GetFormat(); + case clang::Type::DependentSizedArray: + case clang::Type::DependentSizedExtVector: + case clang::Type::UnresolvedUsing: + case clang::Type::Attributed: + case clang::Type::TemplateTypeParm: + case clang::Type::SubstTemplateTypeParm: + case clang::Type::SubstTemplateTypeParmPack: + case clang::Type::InjectedClassName: + case clang::Type::DependentName: + case clang::Type::DependentTemplateSpecialization: + case clang::Type::PackExpansion: + case clang::Type::ObjCObject: + + case clang::Type::TypeOfExpr: + case clang::Type::TypeOf: + case clang::Type::Decltype: + case clang::Type::TemplateSpecialization: + case clang::Type::Atomic: + case clang::Type::Adjusted: + case clang::Type::Pipe: + break; + + // pointer type decayed from an array or function type. + case clang::Type::Decayed: + break; + } + // We don't know hot to display this type... + return lldb::eFormatBytes; +} + +static bool ObjCDeclHasIVars(clang::ObjCInterfaceDecl *class_interface_decl, + bool check_superclass) { + while (class_interface_decl) { + if (class_interface_decl->ivar_size() > 0) + return true; + + if (check_superclass) + class_interface_decl = class_interface_decl->getSuperClass(); + else + break; + } + return false; } +uint32_t ClangASTContext::GetNumChildren(lldb::opaque_compiler_type_t type, + bool omit_empty_base_classes) { + if (!type) + return 0; -lldb::Encoding -ClangASTContext::GetEncoding (lldb::opaque_compiler_type_t type, uint64_t &count) -{ - if (!type) - return lldb::eEncodingInvalid; - - count = 1; - clang::QualType qual_type(GetCanonicalQualType(type)); - - switch (qual_type->getTypeClass()) - { - case clang::Type::UnaryTransform: - break; - - case clang::Type::FunctionNoProto: - case clang::Type::FunctionProto: - break; - - case clang::Type::IncompleteArray: - case clang::Type::VariableArray: - break; - - case clang::Type::ConstantArray: - break; - - case clang::Type::ExtVector: - case clang::Type::Vector: - // TODO: Set this to more than one??? - break; - - case clang::Type::Builtin: - switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) - { - case clang::BuiltinType::Void: - break; - - case clang::BuiltinType::Bool: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: - case clang::BuiltinType::WChar_S: - case clang::BuiltinType::Char16: - case clang::BuiltinType::Char32: - case clang::BuiltinType::Short: - case clang::BuiltinType::Int: - case clang::BuiltinType::Long: - case clang::BuiltinType::LongLong: - case clang::BuiltinType::Int128: - return lldb::eEncodingSint; - - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::WChar_U: - case clang::BuiltinType::UShort: - case clang::BuiltinType::UInt: - case clang::BuiltinType::ULong: - case clang::BuiltinType::ULongLong: - case clang::BuiltinType::UInt128: - return lldb::eEncodingUint; - - case clang::BuiltinType::Half: - case clang::BuiltinType::Float: - case clang::BuiltinType::Float128: - case clang::BuiltinType::Double: - case clang::BuiltinType::LongDouble: - return lldb::eEncodingIEEE754; - - case clang::BuiltinType::ObjCClass: - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCSel: - return lldb::eEncodingUint; - - case clang::BuiltinType::NullPtr: - return lldb::eEncodingUint; - - case clang::BuiltinType::Kind::ARCUnbridgedCast: - case clang::BuiltinType::Kind::BoundMember: - case clang::BuiltinType::Kind::BuiltinFn: - case clang::BuiltinType::Kind::Dependent: - case clang::BuiltinType::Kind::OCLClkEvent: - case clang::BuiltinType::Kind::OCLEvent: - case clang::BuiltinType::Kind::OCLImage1dRO: - case clang::BuiltinType::Kind::OCLImage1dWO: - case clang::BuiltinType::Kind::OCLImage1dRW: - case clang::BuiltinType::Kind::OCLImage1dArrayRO: - case clang::BuiltinType::Kind::OCLImage1dArrayWO: - case clang::BuiltinType::Kind::OCLImage1dArrayRW: - case clang::BuiltinType::Kind::OCLImage1dBufferRO: - case clang::BuiltinType::Kind::OCLImage1dBufferWO: - case clang::BuiltinType::Kind::OCLImage1dBufferRW: - case clang::BuiltinType::Kind::OCLImage2dRO: - case clang::BuiltinType::Kind::OCLImage2dWO: - case clang::BuiltinType::Kind::OCLImage2dRW: - case clang::BuiltinType::Kind::OCLImage2dArrayRO: - case clang::BuiltinType::Kind::OCLImage2dArrayWO: - case clang::BuiltinType::Kind::OCLImage2dArrayRW: - case clang::BuiltinType::Kind::OCLImage2dArrayDepthRO: - case clang::BuiltinType::Kind::OCLImage2dArrayDepthWO: - case clang::BuiltinType::Kind::OCLImage2dArrayDepthRW: - case clang::BuiltinType::Kind::OCLImage2dArrayMSAARO: - case clang::BuiltinType::Kind::OCLImage2dArrayMSAAWO: - case clang::BuiltinType::Kind::OCLImage2dArrayMSAARW: - case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRO: - case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthWO: - case clang::BuiltinType::Kind::OCLImage2dArrayMSAADepthRW: - case clang::BuiltinType::Kind::OCLImage2dDepthRO: - case clang::BuiltinType::Kind::OCLImage2dDepthWO: - case clang::BuiltinType::Kind::OCLImage2dDepthRW: - case clang::BuiltinType::Kind::OCLImage2dMSAARO: - case clang::BuiltinType::Kind::OCLImage2dMSAAWO: - case clang::BuiltinType::Kind::OCLImage2dMSAARW: - case clang::BuiltinType::Kind::OCLImage2dMSAADepthRO: - case clang::BuiltinType::Kind::OCLImage2dMSAADepthWO: - case clang::BuiltinType::Kind::OCLImage2dMSAADepthRW: - case clang::BuiltinType::Kind::OCLImage3dRO: - case clang::BuiltinType::Kind::OCLImage3dWO: - case clang::BuiltinType::Kind::OCLImage3dRW: - case clang::BuiltinType::Kind::OCLQueue: - case clang::BuiltinType::Kind::OCLNDRange: - case clang::BuiltinType::Kind::OCLReserveID: - case clang::BuiltinType::Kind::OCLSampler: - case clang::BuiltinType::Kind::OMPArraySection: - case clang::BuiltinType::Kind::Overload: - case clang::BuiltinType::Kind::PseudoObject: - case clang::BuiltinType::Kind::UnknownAny: - break; - } - break; - // All pointer types are represented as unsigned integer encodings. - // We may nee to add a eEncodingPointer if we ever need to know the - // difference - case clang::Type::ObjCObjectPointer: - case clang::Type::BlockPointer: - case clang::Type::Pointer: - case clang::Type::LValueReference: - case clang::Type::RValueReference: - case clang::Type::MemberPointer: return lldb::eEncodingUint; - case clang::Type::Complex: - { - lldb::Encoding encoding = lldb::eEncodingIEEE754; - if (qual_type->isComplexType()) - encoding = lldb::eEncodingIEEE754; - else - { - const clang::ComplexType *complex_type = qual_type->getAsComplexIntegerType(); - if (complex_type) - encoding = CompilerType(getASTContext(), complex_type->getElementType()).GetEncoding(count); - else - encoding = lldb::eEncodingSint; - } - count = 2; - return encoding; - } - - case clang::Type::ObjCInterface: break; - case clang::Type::Record: break; - case clang::Type::Enum: return lldb::eEncodingSint; - case clang::Type::Typedef: - return CompilerType(getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetEncoding(count); - - case clang::Type::Auto: - return CompilerType(getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetEncoding(count); - - case clang::Type::Elaborated: - return CompilerType(getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetEncoding(count); - - case clang::Type::Paren: - return CompilerType(getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetEncoding(count); - - case clang::Type::DependentSizedArray: - case clang::Type::DependentSizedExtVector: - case clang::Type::UnresolvedUsing: - case clang::Type::Attributed: - case clang::Type::TemplateTypeParm: - case clang::Type::SubstTemplateTypeParm: - case clang::Type::SubstTemplateTypeParmPack: - case clang::Type::InjectedClassName: - case clang::Type::DependentName: - case clang::Type::DependentTemplateSpecialization: - case clang::Type::PackExpansion: - case clang::Type::ObjCObject: - - case clang::Type::TypeOfExpr: - case clang::Type::TypeOf: - case clang::Type::Decltype: - case clang::Type::TemplateSpecialization: - case clang::Type::Atomic: - case clang::Type::Adjusted: - case clang::Type::Pipe: - break; + uint32_t num_children = 0; + clang::QualType qual_type(GetQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Builtin: + switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) { + case clang::BuiltinType::ObjCId: // child is Class + case clang::BuiltinType::ObjCClass: // child is Class + num_children = 1; + break; - // pointer type decayed from an array or function type. - case clang::Type::Decayed: - break; + default: + break; } - count = 0; - return lldb::eEncodingInvalid; -} + break; -lldb::Format -ClangASTContext::GetFormat (lldb::opaque_compiler_type_t type) -{ - if (!type) - return lldb::eFormatDefault; - - clang::QualType qual_type(GetCanonicalQualType(type)); - - switch (qual_type->getTypeClass()) - { - case clang::Type::UnaryTransform: - break; - - case clang::Type::FunctionNoProto: - case clang::Type::FunctionProto: - break; - - case clang::Type::IncompleteArray: - case clang::Type::VariableArray: - break; - - case clang::Type::ConstantArray: - return lldb::eFormatVoid; // no value - - case clang::Type::ExtVector: - case clang::Type::Vector: - break; - - case clang::Type::Builtin: - switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) - { - //default: assert(0 && "Unknown builtin type!"); - case clang::BuiltinType::UnknownAny: - case clang::BuiltinType::Void: - case clang::BuiltinType::BoundMember: - break; - - case clang::BuiltinType::Bool: return lldb::eFormatBoolean; - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: - case clang::BuiltinType::WChar_S: - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::WChar_U: return lldb::eFormatChar; - case clang::BuiltinType::Char16: return lldb::eFormatUnicode16; - case clang::BuiltinType::Char32: return lldb::eFormatUnicode32; - case clang::BuiltinType::UShort: return lldb::eFormatUnsigned; - case clang::BuiltinType::Short: return lldb::eFormatDecimal; - case clang::BuiltinType::UInt: return lldb::eFormatUnsigned; - case clang::BuiltinType::Int: return lldb::eFormatDecimal; - case clang::BuiltinType::ULong: return lldb::eFormatUnsigned; - case clang::BuiltinType::Long: return lldb::eFormatDecimal; - case clang::BuiltinType::ULongLong: return lldb::eFormatUnsigned; - case clang::BuiltinType::LongLong: return lldb::eFormatDecimal; - case clang::BuiltinType::UInt128: return lldb::eFormatUnsigned; - case clang::BuiltinType::Int128: return lldb::eFormatDecimal; - case clang::BuiltinType::Half: - case clang::BuiltinType::Float: - case clang::BuiltinType::Double: - case clang::BuiltinType::LongDouble: return lldb::eFormatFloat; - default: - return lldb::eFormatHex; + case clang::Type::Complex: + return 0; + + case clang::Type::Record: + if (GetCompleteQualType(getASTContext(), qual_type)) { + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + assert(record_decl); + const clang::CXXRecordDecl *cxx_record_decl = + llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); + if (cxx_record_decl) { + if (omit_empty_base_classes) { + // Check each base classes to see if it or any of its + // base classes contain any fields. This can help + // limit the noise in variable views by not having to + // show base classes that contain no members. + clang::CXXRecordDecl::base_class_const_iterator base_class, + base_class_end; + for (base_class = cxx_record_decl->bases_begin(), + base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; ++base_class) { + const clang::CXXRecordDecl *base_class_decl = + llvm::cast<clang::CXXRecordDecl>( + base_class->getType() + ->getAs<clang::RecordType>() + ->getDecl()); + + // Skip empty base classes + if (ClangASTContext::RecordHasFields(base_class_decl) == false) + continue; + + num_children++; + } + } else { + // Include all base classes + num_children += cxx_record_decl->getNumBases(); } - break; - case clang::Type::ObjCObjectPointer: return lldb::eFormatHex; - case clang::Type::BlockPointer: return lldb::eFormatHex; - case clang::Type::Pointer: return lldb::eFormatHex; - case clang::Type::LValueReference: - case clang::Type::RValueReference: return lldb::eFormatHex; - case clang::Type::MemberPointer: break; - case clang::Type::Complex: - { - if (qual_type->isComplexType()) - return lldb::eFormatComplex; - else - return lldb::eFormatComplexInteger; + } + clang::RecordDecl::field_iterator field, field_end; + for (field = record_decl->field_begin(), + field_end = record_decl->field_end(); + field != field_end; ++field) + ++num_children; + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (GetCompleteQualType(getASTContext(), qual_type)) { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); + assert(objc_class_type); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + + if (class_interface_decl) { + + clang::ObjCInterfaceDecl *superclass_interface_decl = + class_interface_decl->getSuperClass(); + if (superclass_interface_decl) { + if (omit_empty_base_classes) { + if (ObjCDeclHasIVars(superclass_interface_decl, true)) + ++num_children; + } else + ++num_children; + } + + num_children += class_interface_decl->ivar_size(); } - case clang::Type::ObjCInterface: break; - case clang::Type::Record: break; - case clang::Type::Enum: return lldb::eFormatEnum; - case clang::Type::Typedef: - return CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetFormat(); - case clang::Type::Auto: - return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->desugar()).GetFormat(); - case clang::Type::Paren: - return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetFormat(); - case clang::Type::Elaborated: - return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetFormat(); - case clang::Type::DependentSizedArray: - case clang::Type::DependentSizedExtVector: - case clang::Type::UnresolvedUsing: - case clang::Type::Attributed: - case clang::Type::TemplateTypeParm: - case clang::Type::SubstTemplateTypeParm: - case clang::Type::SubstTemplateTypeParmPack: - case clang::Type::InjectedClassName: - case clang::Type::DependentName: - case clang::Type::DependentTemplateSpecialization: - case clang::Type::PackExpansion: - case clang::Type::ObjCObject: - - case clang::Type::TypeOfExpr: - case clang::Type::TypeOf: - case clang::Type::Decltype: - case clang::Type::TemplateSpecialization: - case clang::Type::Atomic: - case clang::Type::Adjusted: - case clang::Type::Pipe: - break; - - // pointer type decayed from an array or function type. - case clang::Type::Decayed: - break; - } - // We don't know hot to display this type... - return lldb::eFormatBytes; -} - -static bool -ObjCDeclHasIVars (clang::ObjCInterfaceDecl *class_interface_decl, bool check_superclass) -{ - while (class_interface_decl) - { - if (class_interface_decl->ivar_size() > 0) - return true; - - if (check_superclass) - class_interface_decl = class_interface_decl->getSuperClass(); - else - break; - } - return false; + } + } + break; + + case clang::Type::ObjCObjectPointer: { + const clang::ObjCObjectPointerType *pointer_type = + llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr()); + clang::QualType pointee_type = pointer_type->getPointeeType(); + uint32_t num_pointee_children = + CompilerType(getASTContext(), pointee_type) + .GetNumChildren(omit_empty_base_classes); + // If this type points to a simple type, then it has 1 child + if (num_pointee_children == 0) + num_children = 1; + else + num_children = num_pointee_children; + } break; + + case clang::Type::Vector: + case clang::Type::ExtVector: + num_children = + llvm::cast<clang::VectorType>(qual_type.getTypePtr())->getNumElements(); + break; + + case clang::Type::ConstantArray: + num_children = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr()) + ->getSize() + .getLimitedValue(); + break; + + case clang::Type::Pointer: { + const clang::PointerType *pointer_type = + llvm::cast<clang::PointerType>(qual_type.getTypePtr()); + clang::QualType pointee_type(pointer_type->getPointeeType()); + uint32_t num_pointee_children = + CompilerType(getASTContext(), pointee_type) + .GetNumChildren(omit_empty_base_classes); + if (num_pointee_children == 0) { + // We have a pointer to a pointee type that claims it has no children. + // We will want to look at + num_children = GetNumPointeeChildren(pointee_type); + } else + num_children = num_pointee_children; + } break; + + case clang::Type::LValueReference: + case clang::Type::RValueReference: { + const clang::ReferenceType *reference_type = + llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); + clang::QualType pointee_type = reference_type->getPointeeType(); + uint32_t num_pointee_children = + CompilerType(getASTContext(), pointee_type) + .GetNumChildren(omit_empty_base_classes); + // If this type points to a simple type, then it has 1 child + if (num_pointee_children == 0) + num_children = 1; + else + num_children = num_pointee_children; + } break; + + case clang::Type::Typedef: + num_children = + CompilerType(getASTContext(), llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()) + .GetNumChildren(omit_empty_base_classes); + break; + + case clang::Type::Auto: + num_children = + CompilerType(getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()) + .GetNumChildren(omit_empty_base_classes); + break; + + case clang::Type::Elaborated: + num_children = + CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()) + .GetNumChildren(omit_empty_base_classes); + break; + + case clang::Type::Paren: + num_children = + CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar()) + .GetNumChildren(omit_empty_base_classes); + break; + default: + break; + } + return num_children; +} + +CompilerType ClangASTContext::GetBuiltinTypeByName(const ConstString &name) { + return GetBasicType(GetBasicTypeEnumeration(name)); } -uint32_t -ClangASTContext::GetNumChildren (lldb::opaque_compiler_type_t type, bool omit_empty_base_classes) -{ - if (!type) - return 0; - - uint32_t num_children = 0; +lldb::BasicType +ClangASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) { + if (type) { clang::QualType qual_type(GetQualType(type)); const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Builtin: - switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) - { - case clang::BuiltinType::ObjCId: // child is Class - case clang::BuiltinType::ObjCClass: // child is Class - num_children = 1; - break; - - default: - break; - } - break; - - case clang::Type::Complex: return 0; - - case clang::Type::Record: - if (GetCompleteQualType (getASTContext(), qual_type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - assert(record_decl); - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - if (cxx_record_decl) - { - if (omit_empty_base_classes) - { - // Check each base classes to see if it or any of its - // base classes contain any fields. This can help - // limit the noise in variable views by not having to - // show base classes that contain no members. - clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; - for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); - base_class != base_class_end; - ++base_class) - { - const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl()); - - // Skip empty base classes - if (ClangASTContext::RecordHasFields(base_class_decl) == false) - continue; - - num_children++; - } - } - else - { - // Include all base classes - num_children += cxx_record_decl->getNumBases(); - } - - } - clang::RecordDecl::field_iterator field, field_end; - for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field) - ++num_children; - } - break; - - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - if (GetCompleteQualType (getASTContext(), qual_type)) - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); - assert (objc_class_type); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - - if (class_interface_decl) - { - - clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); - if (superclass_interface_decl) - { - if (omit_empty_base_classes) - { - if (ObjCDeclHasIVars (superclass_interface_decl, true)) - ++num_children; - } - else - ++num_children; - } - - num_children += class_interface_decl->ivar_size(); - } - } - } - break; - - case clang::Type::ObjCObjectPointer: - { - const clang::ObjCObjectPointerType *pointer_type = llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr()); - clang::QualType pointee_type = pointer_type->getPointeeType(); - uint32_t num_pointee_children = CompilerType (getASTContext(),pointee_type).GetNumChildren (omit_empty_base_classes); - // If this type points to a simple type, then it has 1 child - if (num_pointee_children == 0) - num_children = 1; - else - num_children = num_pointee_children; - } - break; - - case clang::Type::Vector: - case clang::Type::ExtVector: - num_children = llvm::cast<clang::VectorType>(qual_type.getTypePtr())->getNumElements(); - break; - - case clang::Type::ConstantArray: - num_children = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue(); - break; - - case clang::Type::Pointer: - { - const clang::PointerType *pointer_type = llvm::cast<clang::PointerType>(qual_type.getTypePtr()); - clang::QualType pointee_type (pointer_type->getPointeeType()); - uint32_t num_pointee_children = CompilerType (getASTContext(),pointee_type).GetNumChildren (omit_empty_base_classes); - if (num_pointee_children == 0) - { - // We have a pointer to a pointee type that claims it has no children. - // We will want to look at - num_children = GetNumPointeeChildren (pointee_type); - } - else - num_children = num_pointee_children; - } - break; - - case clang::Type::LValueReference: - case clang::Type::RValueReference: - { - const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); - clang::QualType pointee_type = reference_type->getPointeeType(); - uint32_t num_pointee_children = CompilerType (getASTContext(), pointee_type).GetNumChildren (omit_empty_base_classes); - // If this type points to a simple type, then it has 1 child - if (num_pointee_children == 0) - num_children = 1; - else - num_children = num_pointee_children; - } - break; - - - case clang::Type::Typedef: - num_children = CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumChildren (omit_empty_base_classes); - break; - - case clang::Type::Auto: - num_children = CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetNumChildren (omit_empty_base_classes); - break; - - case clang::Type::Elaborated: - num_children = CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumChildren (omit_empty_base_classes); - break; - - case clang::Type::Paren: - num_children = CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumChildren (omit_empty_base_classes); - break; - default: - break; - } - return num_children; + if (type_class == clang::Type::Builtin) { + switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) { + case clang::BuiltinType::Void: + return eBasicTypeVoid; + case clang::BuiltinType::Bool: + return eBasicTypeBool; + case clang::BuiltinType::Char_S: + return eBasicTypeSignedChar; + case clang::BuiltinType::Char_U: + return eBasicTypeUnsignedChar; + case clang::BuiltinType::Char16: + return eBasicTypeChar16; + case clang::BuiltinType::Char32: + return eBasicTypeChar32; + case clang::BuiltinType::UChar: + return eBasicTypeUnsignedChar; + case clang::BuiltinType::SChar: + return eBasicTypeSignedChar; + case clang::BuiltinType::WChar_S: + return eBasicTypeSignedWChar; + case clang::BuiltinType::WChar_U: + return eBasicTypeUnsignedWChar; + case clang::BuiltinType::Short: + return eBasicTypeShort; + case clang::BuiltinType::UShort: + return eBasicTypeUnsignedShort; + case clang::BuiltinType::Int: + return eBasicTypeInt; + case clang::BuiltinType::UInt: + return eBasicTypeUnsignedInt; + case clang::BuiltinType::Long: + return eBasicTypeLong; + case clang::BuiltinType::ULong: + return eBasicTypeUnsignedLong; + case clang::BuiltinType::LongLong: + return eBasicTypeLongLong; + case clang::BuiltinType::ULongLong: + return eBasicTypeUnsignedLongLong; + case clang::BuiltinType::Int128: + return eBasicTypeInt128; + case clang::BuiltinType::UInt128: + return eBasicTypeUnsignedInt128; + + case clang::BuiltinType::Half: + return eBasicTypeHalf; + case clang::BuiltinType::Float: + return eBasicTypeFloat; + case clang::BuiltinType::Double: + return eBasicTypeDouble; + case clang::BuiltinType::LongDouble: + return eBasicTypeLongDouble; + + case clang::BuiltinType::NullPtr: + return eBasicTypeNullPtr; + case clang::BuiltinType::ObjCId: + return eBasicTypeObjCID; + case clang::BuiltinType::ObjCClass: + return eBasicTypeObjCClass; + case clang::BuiltinType::ObjCSel: + return eBasicTypeObjCSel; + default: + return eBasicTypeOther; + } + } + } + return eBasicTypeInvalid; +} + +void ClangASTContext::ForEachEnumerator( + lldb::opaque_compiler_type_t type, + std::function<bool(const CompilerType &integer_type, + const ConstString &name, + const llvm::APSInt &value)> const &callback) { + const clang::EnumType *enum_type = + llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type)); + if (enum_type) { + const clang::EnumDecl *enum_decl = enum_type->getDecl(); + if (enum_decl) { + CompilerType integer_type(this, + enum_decl->getIntegerType().getAsOpaquePtr()); + + clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; + for (enum_pos = enum_decl->enumerator_begin(), + enum_end_pos = enum_decl->enumerator_end(); + enum_pos != enum_end_pos; ++enum_pos) { + ConstString name(enum_pos->getNameAsString().c_str()); + if (!callback(integer_type, name, enum_pos->getInitVal())) + break; + } + } + } } -CompilerType -ClangASTContext::GetBuiltinTypeByName (const ConstString &name) -{ - return GetBasicType(GetBasicTypeEnumeration(name)); -} +#pragma mark Aggregate Types -lldb::BasicType -ClangASTContext::GetBasicTypeEnumeration (lldb::opaque_compiler_type_t type) -{ - if (type) - { - clang::QualType qual_type(GetQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - if (type_class == clang::Type::Builtin) - { - switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) - { - case clang::BuiltinType::Void: return eBasicTypeVoid; - case clang::BuiltinType::Bool: return eBasicTypeBool; - case clang::BuiltinType::Char_S: return eBasicTypeSignedChar; - case clang::BuiltinType::Char_U: return eBasicTypeUnsignedChar; - case clang::BuiltinType::Char16: return eBasicTypeChar16; - case clang::BuiltinType::Char32: return eBasicTypeChar32; - case clang::BuiltinType::UChar: return eBasicTypeUnsignedChar; - case clang::BuiltinType::SChar: return eBasicTypeSignedChar; - case clang::BuiltinType::WChar_S: return eBasicTypeSignedWChar; - case clang::BuiltinType::WChar_U: return eBasicTypeUnsignedWChar; - case clang::BuiltinType::Short: return eBasicTypeShort; - case clang::BuiltinType::UShort: return eBasicTypeUnsignedShort; - case clang::BuiltinType::Int: return eBasicTypeInt; - case clang::BuiltinType::UInt: return eBasicTypeUnsignedInt; - case clang::BuiltinType::Long: return eBasicTypeLong; - case clang::BuiltinType::ULong: return eBasicTypeUnsignedLong; - case clang::BuiltinType::LongLong: return eBasicTypeLongLong; - case clang::BuiltinType::ULongLong: return eBasicTypeUnsignedLongLong; - case clang::BuiltinType::Int128: return eBasicTypeInt128; - case clang::BuiltinType::UInt128: return eBasicTypeUnsignedInt128; - - case clang::BuiltinType::Half: return eBasicTypeHalf; - case clang::BuiltinType::Float: return eBasicTypeFloat; - case clang::BuiltinType::Double: return eBasicTypeDouble; - case clang::BuiltinType::LongDouble:return eBasicTypeLongDouble; - - case clang::BuiltinType::NullPtr: return eBasicTypeNullPtr; - case clang::BuiltinType::ObjCId: return eBasicTypeObjCID; - case clang::BuiltinType::ObjCClass: return eBasicTypeObjCClass; - case clang::BuiltinType::ObjCSel: return eBasicTypeObjCSel; - default: - return eBasicTypeOther; - } - } - } - return eBasicTypeInvalid; -} - -void -ClangASTContext::ForEachEnumerator (lldb::opaque_compiler_type_t type, std::function <bool (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value)> const &callback) -{ - const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type)); - if (enum_type) - { - const clang::EnumDecl *enum_decl = enum_type->getDecl(); - if (enum_decl) - { - CompilerType integer_type(this, enum_decl->getIntegerType().getAsOpaquePtr()); - - clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; - for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) - { - ConstString name(enum_pos->getNameAsString().c_str()); - if (!callback (integer_type, name, enum_pos->getInitVal())) - break; - } - } - } -} +uint32_t ClangASTContext::GetNumFields(lldb::opaque_compiler_type_t type) { + if (!type) + return 0; + uint32_t count = 0; + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::RecordType *record_type = + llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr()); + if (record_type) { + clang::RecordDecl *record_decl = record_type->getDecl(); + if (record_decl) { + uint32_t field_idx = 0; + clang::RecordDecl::field_iterator field, field_end; + for (field = record_decl->field_begin(), + field_end = record_decl->field_end(); + field != field_end; ++field) + ++field_idx; + count = field_idx; + } + } + } + break; + + case clang::Type::Typedef: + count = + CompilerType(getASTContext(), llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()) + .GetNumFields(); + break; + + case clang::Type::Auto: + count = + CompilerType(getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()) + .GetNumFields(); + break; + + case clang::Type::Elaborated: + count = CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()) + .GetNumFields(); + break; + + case clang::Type::Paren: + count = CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar()) + .GetNumFields(); + break; + + case clang::Type::ObjCObjectPointer: + if (GetCompleteType(type)) { + const clang::ObjCObjectPointerType *objc_class_type = + qual_type->getAsObjCInterfacePointerType(); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterfaceDecl(); -#pragma mark Aggregate Types + if (class_interface_decl) + count = class_interface_decl->ivar_size(); + } + } + break; -uint32_t -ClangASTContext::GetNumFields (lldb::opaque_compiler_type_t type) -{ - if (!type) - return 0; - - uint32_t count = 0; - clang::QualType qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::RecordType *record_type = llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr()); - if (record_type) - { - clang::RecordDecl *record_decl = record_type->getDecl(); - if (record_decl) - { - uint32_t field_idx = 0; - clang::RecordDecl::field_iterator field, field_end; - for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field) - ++field_idx; - count = field_idx; - } - } - } - break; - - case clang::Type::Typedef: - count = CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumFields(); - break; + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (GetCompleteType(type)) { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); - case clang::Type::Auto: - count = CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetNumFields(); - break; - - case clang::Type::Elaborated: - count = CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetNumFields(); - break; - - case clang::Type::Paren: - count = CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetNumFields(); - break; - - case clang::Type::ObjCObjectPointer: - if (GetCompleteType(type)) - { - const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); - - if (class_interface_decl) - count = class_interface_decl->ivar_size(); - } - } - break; - - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - if (GetCompleteType(type)) - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - - if (class_interface_decl) - count = class_interface_decl->ivar_size(); - } - } - break; - - default: - break; + if (class_interface_decl) + count = class_interface_decl->ivar_size(); + } } - return count; + break; + + default: + break; + } + return count; } static lldb::opaque_compiler_type_t -GetObjCFieldAtIndex (clang::ASTContext *ast, - clang::ObjCInterfaceDecl *class_interface_decl, - size_t idx, - std::string& name, - uint64_t *bit_offset_ptr, - uint32_t *bitfield_bit_size_ptr, - bool *is_bitfield_ptr) -{ - if (class_interface_decl) - { - if (idx < (class_interface_decl->ivar_size())) - { - clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); - uint32_t ivar_idx = 0; - - for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++ivar_idx) - { - if (ivar_idx == idx) - { - const clang::ObjCIvarDecl* ivar_decl = *ivar_pos; - - clang::QualType ivar_qual_type(ivar_decl->getType()); - - name.assign(ivar_decl->getNameAsString()); - - if (bit_offset_ptr) - { - const clang::ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl); - *bit_offset_ptr = interface_layout.getFieldOffset (ivar_idx); - } - - const bool is_bitfield = ivar_pos->isBitField(); - - if (bitfield_bit_size_ptr) - { - *bitfield_bit_size_ptr = 0; - - if (is_bitfield && ast) - { - clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth(); - llvm::APSInt bitfield_apsint; - if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *ast)) - { - *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue(); - } - } - } - if (is_bitfield_ptr) - *is_bitfield_ptr = is_bitfield; - - return ivar_qual_type.getAsOpaquePtr(); - } +GetObjCFieldAtIndex(clang::ASTContext *ast, + clang::ObjCInterfaceDecl *class_interface_decl, size_t idx, + std::string &name, uint64_t *bit_offset_ptr, + uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) { + if (class_interface_decl) { + if (idx < (class_interface_decl->ivar_size())) { + clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, + ivar_end = class_interface_decl->ivar_end(); + uint32_t ivar_idx = 0; + + for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; + ++ivar_pos, ++ivar_idx) { + if (ivar_idx == idx) { + const clang::ObjCIvarDecl *ivar_decl = *ivar_pos; + + clang::QualType ivar_qual_type(ivar_decl->getType()); + + name.assign(ivar_decl->getNameAsString()); + + if (bit_offset_ptr) { + const clang::ASTRecordLayout &interface_layout = + ast->getASTObjCInterfaceLayout(class_interface_decl); + *bit_offset_ptr = interface_layout.getFieldOffset(ivar_idx); + } + + const bool is_bitfield = ivar_pos->isBitField(); + + if (bitfield_bit_size_ptr) { + *bitfield_bit_size_ptr = 0; + + if (is_bitfield && ast) { + clang::Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth(); + llvm::APSInt bitfield_apsint; + if (bitfield_bit_size_expr && + bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, + *ast)) { + *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue(); + } } + } + if (is_bitfield_ptr) + *is_bitfield_ptr = is_bitfield; + + return ivar_qual_type.getAsOpaquePtr(); } + } } - return nullptr; + } + return nullptr; } -CompilerType -ClangASTContext::GetFieldAtIndex (lldb::opaque_compiler_type_t type, size_t idx, - std::string& name, - uint64_t *bit_offset_ptr, - uint32_t *bitfield_bit_size_ptr, - bool *is_bitfield_ptr) -{ - if (!type) - return CompilerType(); - - clang::QualType qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - uint32_t field_idx = 0; - clang::RecordDecl::field_iterator field, field_end; - for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx) - { - if (idx == field_idx) - { - // Print the member type if requested - // Print the member name and equal sign - name.assign(field->getNameAsString()); - - // Figure out the type byte size (field_type_info.first) and - // alignment (field_type_info.second) from the AST context. - if (bit_offset_ptr) - { - const clang::ASTRecordLayout &record_layout = getASTContext()->getASTRecordLayout(record_decl); - *bit_offset_ptr = record_layout.getFieldOffset (field_idx); - } - - const bool is_bitfield = field->isBitField(); - - if (bitfield_bit_size_ptr) - { - *bitfield_bit_size_ptr = 0; - - if (is_bitfield) - { - clang::Expr *bitfield_bit_size_expr = field->getBitWidth(); - llvm::APSInt bitfield_apsint; - if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *getASTContext())) - { - *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue(); - } - } - } - if (is_bitfield_ptr) - *is_bitfield_ptr = is_bitfield; - - return CompilerType (getASTContext(), field->getType()); - } - } - } - break; - - case clang::Type::ObjCObjectPointer: - if (GetCompleteType(type)) - { - const clang::ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); - return CompilerType (this, GetObjCFieldAtIndex(getASTContext(), class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr)); - } - } - break; - - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - if (GetCompleteType(type)) - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); - assert (objc_class_type); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - return CompilerType (this, GetObjCFieldAtIndex(getASTContext(), class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr)); - } - } - break; - - - case clang::Type::Typedef: - return CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()). - GetFieldAtIndex (idx, - name, - bit_offset_ptr, - bitfield_bit_size_ptr, - is_bitfield_ptr); - - case clang::Type::Auto: - return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()). - GetFieldAtIndex (idx, - name, - bit_offset_ptr, - bitfield_bit_size_ptr, - is_bitfield_ptr); - - case clang::Type::Elaborated: - return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()). - GetFieldAtIndex (idx, - name, - bit_offset_ptr, - bitfield_bit_size_ptr, - is_bitfield_ptr); - - case clang::Type::Paren: - return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()). - GetFieldAtIndex (idx, - name, - bit_offset_ptr, - bitfield_bit_size_ptr, - is_bitfield_ptr); - - default: - break; - } +CompilerType ClangASTContext::GetFieldAtIndex(lldb::opaque_compiler_type_t type, + size_t idx, std::string &name, + uint64_t *bit_offset_ptr, + uint32_t *bitfield_bit_size_ptr, + bool *is_bitfield_ptr) { + if (!type) return CompilerType(); -} -uint32_t -ClangASTContext::GetNumDirectBaseClasses (lldb::opaque_compiler_type_t type) -{ - uint32_t count = 0; - clang::QualType qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - count = cxx_record_decl->getNumBases(); + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + uint32_t field_idx = 0; + clang::RecordDecl::field_iterator field, field_end; + for (field = record_decl->field_begin(), + field_end = record_decl->field_end(); + field != field_end; ++field, ++field_idx) { + if (idx == field_idx) { + // Print the member type if requested + // Print the member name and equal sign + name.assign(field->getNameAsString()); + + // Figure out the type byte size (field_type_info.first) and + // alignment (field_type_info.second) from the AST context. + if (bit_offset_ptr) { + const clang::ASTRecordLayout &record_layout = + getASTContext()->getASTRecordLayout(record_decl); + *bit_offset_ptr = record_layout.getFieldOffset(field_idx); + } + + const bool is_bitfield = field->isBitField(); + + if (bitfield_bit_size_ptr) { + *bitfield_bit_size_ptr = 0; + + if (is_bitfield) { + clang::Expr *bitfield_bit_size_expr = field->getBitWidth(); + llvm::APSInt bitfield_apsint; + if (bitfield_bit_size_expr && + bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, + *getASTContext())) { + *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue(); + } } - break; - - case clang::Type::ObjCObjectPointer: - count = GetPointeeType(type).GetNumDirectBaseClasses(); - break; - - case clang::Type::ObjCObject: - if (GetCompleteType(type)) - { - const clang::ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - - if (class_interface_decl && class_interface_decl->getSuperClass()) - count = 1; - } - } - break; - case clang::Type::ObjCInterface: - if (GetCompleteType(type)) - { - const clang::ObjCInterfaceType *objc_interface_type = qual_type->getAs<clang::ObjCInterfaceType>(); - if (objc_interface_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface(); - - if (class_interface_decl && class_interface_decl->getSuperClass()) - count = 1; - } - } - break; - - - case clang::Type::Typedef: - count = GetNumDirectBaseClasses(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); - break; - - case clang::Type::Auto: - count = GetNumDirectBaseClasses(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()); - break; - - case clang::Type::Elaborated: - count = GetNumDirectBaseClasses(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); - break; - - case clang::Type::Paren: - return GetNumDirectBaseClasses(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()); - - default: - break; - } - return count; + } + if (is_bitfield_ptr) + *is_bitfield_ptr = is_bitfield; + return CompilerType(getASTContext(), field->getType()); + } + } + } + break; + + case clang::Type::ObjCObjectPointer: + if (GetCompleteType(type)) { + const clang::ObjCObjectPointerType *objc_class_type = + qual_type->getAsObjCInterfacePointerType(); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterfaceDecl(); + return CompilerType( + this, GetObjCFieldAtIndex(getASTContext(), class_interface_decl, + idx, name, bit_offset_ptr, + bitfield_bit_size_ptr, is_bitfield_ptr)); + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (GetCompleteType(type)) { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); + assert(objc_class_type); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + return CompilerType( + this, GetObjCFieldAtIndex(getASTContext(), class_interface_decl, + idx, name, bit_offset_ptr, + bitfield_bit_size_ptr, is_bitfield_ptr)); + } + } + break; + + case clang::Type::Typedef: + return CompilerType(getASTContext(), + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()) + .GetFieldAtIndex(idx, name, bit_offset_ptr, bitfield_bit_size_ptr, + is_bitfield_ptr); + + case clang::Type::Auto: + return CompilerType( + getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()) + .GetFieldAtIndex(idx, name, bit_offset_ptr, bitfield_bit_size_ptr, + is_bitfield_ptr); + + case clang::Type::Elaborated: + return CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()) + .GetFieldAtIndex(idx, name, bit_offset_ptr, bitfield_bit_size_ptr, + is_bitfield_ptr); + + case clang::Type::Paren: + return CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar()) + .GetFieldAtIndex(idx, name, bit_offset_ptr, bitfield_bit_size_ptr, + is_bitfield_ptr); + + default: + break; + } + return CompilerType(); } uint32_t -ClangASTContext::GetNumVirtualBaseClasses (lldb::opaque_compiler_type_t type) -{ - uint32_t count = 0; - clang::QualType qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - count = cxx_record_decl->getNumVBases(); - } - break; - - case clang::Type::Typedef: - count = GetNumVirtualBaseClasses(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); - break; - - case clang::Type::Auto: - count = GetNumVirtualBaseClasses(llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()); - break; - - case clang::Type::Elaborated: - count = GetNumVirtualBaseClasses(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()); - break; - - case clang::Type::Paren: - count = GetNumVirtualBaseClasses(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()); - break; - - default: - break; - } - return count; - +ClangASTContext::GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) { + uint32_t count = 0; + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::CXXRecordDecl *cxx_record_decl = + qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + count = cxx_record_decl->getNumBases(); + } + break; + + case clang::Type::ObjCObjectPointer: + count = GetPointeeType(type).GetNumDirectBaseClasses(); + break; + + case clang::Type::ObjCObject: + if (GetCompleteType(type)) { + const clang::ObjCObjectType *objc_class_type = + qual_type->getAsObjCQualifiedInterfaceType(); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + + if (class_interface_decl && class_interface_decl->getSuperClass()) + count = 1; + } + } + break; + case clang::Type::ObjCInterface: + if (GetCompleteType(type)) { + const clang::ObjCInterfaceType *objc_interface_type = + qual_type->getAs<clang::ObjCInterfaceType>(); + if (objc_interface_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_interface_type->getInterface(); + + if (class_interface_decl && class_interface_decl->getSuperClass()) + count = 1; + } + } + break; + + case clang::Type::Typedef: + count = GetNumDirectBaseClasses(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr()); + break; + + case clang::Type::Auto: + count = GetNumDirectBaseClasses(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr()); + break; + + case clang::Type::Elaborated: + count = GetNumDirectBaseClasses(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr()); + break; + + case clang::Type::Paren: + return GetNumDirectBaseClasses( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()); + + default: + break; + } + return count; } -CompilerType -ClangASTContext::GetDirectBaseClassAtIndex (lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) -{ - clang::QualType qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - { - uint32_t curr_idx = 0; - clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; - for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); - base_class != base_class_end; - ++base_class, ++curr_idx) - { - if (curr_idx == idx) - { - if (bit_offset_ptr) - { - const clang::ASTRecordLayout &record_layout = getASTContext()->getASTRecordLayout(cxx_record_decl); - const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl()); - if (base_class->isVirtual()) - *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; - else - *bit_offset_ptr = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; - } - return CompilerType (this, base_class->getType().getAsOpaquePtr()); - } - } - } - } - break; - - case clang::Type::ObjCObjectPointer: - return GetPointeeType(type).GetDirectBaseClassAtIndex(idx, bit_offset_ptr); - - case clang::Type::ObjCObject: - if (idx == 0 && GetCompleteType(type)) - { - const clang::ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - - if (class_interface_decl) - { - clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); - if (superclass_interface_decl) - { - if (bit_offset_ptr) - *bit_offset_ptr = 0; - return CompilerType (getASTContext(), getASTContext()->getObjCInterfaceType(superclass_interface_decl)); - } - } - } +uint32_t +ClangASTContext::GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) { + uint32_t count = 0; + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::CXXRecordDecl *cxx_record_decl = + qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + count = cxx_record_decl->getNumVBases(); + } + break; + + case clang::Type::Typedef: + count = GetNumVirtualBaseClasses(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr()); + break; + + case clang::Type::Auto: + count = GetNumVirtualBaseClasses(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr()); + break; + + case clang::Type::Elaborated: + count = + GetNumVirtualBaseClasses(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr()); + break; + + case clang::Type::Paren: + count = GetNumVirtualBaseClasses( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()); + break; + + default: + break; + } + return count; +} + +CompilerType ClangASTContext::GetDirectBaseClassAtIndex( + lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) { + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::CXXRecordDecl *cxx_record_decl = + qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) { + uint32_t curr_idx = 0; + clang::CXXRecordDecl::base_class_const_iterator base_class, + base_class_end; + for (base_class = cxx_record_decl->bases_begin(), + base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; ++base_class, ++curr_idx) { + if (curr_idx == idx) { + if (bit_offset_ptr) { + const clang::ASTRecordLayout &record_layout = + getASTContext()->getASTRecordLayout(cxx_record_decl); + const clang::CXXRecordDecl *base_class_decl = + llvm::cast<clang::CXXRecordDecl>( + base_class->getType() + ->getAs<clang::RecordType>() + ->getDecl()); + if (base_class->isVirtual()) + *bit_offset_ptr = + record_layout.getVBaseClassOffset(base_class_decl) + .getQuantity() * + 8; + else + *bit_offset_ptr = + record_layout.getBaseClassOffset(base_class_decl) + .getQuantity() * + 8; } - break; - case clang::Type::ObjCInterface: - if (idx == 0 && GetCompleteType(type)) - { - const clang::ObjCObjectType *objc_interface_type = qual_type->getAs<clang::ObjCInterfaceType>(); - if (objc_interface_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface(); - - if (class_interface_decl) - { - clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); - if (superclass_interface_decl) - { - if (bit_offset_ptr) - *bit_offset_ptr = 0; - return CompilerType (getASTContext(), getASTContext()->getObjCInterfaceType(superclass_interface_decl)); - } - } - } + return CompilerType(this, base_class->getType().getAsOpaquePtr()); + } + } + } + } + break; + + case clang::Type::ObjCObjectPointer: + return GetPointeeType(type).GetDirectBaseClassAtIndex(idx, bit_offset_ptr); + + case clang::Type::ObjCObject: + if (idx == 0 && GetCompleteType(type)) { + const clang::ObjCObjectType *objc_class_type = + qual_type->getAsObjCQualifiedInterfaceType(); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + + if (class_interface_decl) { + clang::ObjCInterfaceDecl *superclass_interface_decl = + class_interface_decl->getSuperClass(); + if (superclass_interface_decl) { + if (bit_offset_ptr) + *bit_offset_ptr = 0; + return CompilerType(getASTContext(), + getASTContext()->getObjCInterfaceType( + superclass_interface_decl)); + } + } + } + } + break; + case clang::Type::ObjCInterface: + if (idx == 0 && GetCompleteType(type)) { + const clang::ObjCObjectType *objc_interface_type = + qual_type->getAs<clang::ObjCInterfaceType>(); + if (objc_interface_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_interface_type->getInterface(); + + if (class_interface_decl) { + clang::ObjCInterfaceDecl *superclass_interface_decl = + class_interface_decl->getSuperClass(); + if (superclass_interface_decl) { + if (bit_offset_ptr) + *bit_offset_ptr = 0; + return CompilerType(getASTContext(), + getASTContext()->getObjCInterfaceType( + superclass_interface_decl)); + } + } + } + } + break; + + case clang::Type::Typedef: + return GetDirectBaseClassAtIndex(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + idx, bit_offset_ptr); + + case clang::Type::Auto: + return GetDirectBaseClassAtIndex(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + idx, bit_offset_ptr); + + case clang::Type::Elaborated: + return GetDirectBaseClassAtIndex( + llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + idx, bit_offset_ptr); + + case clang::Type::Paren: + return GetDirectBaseClassAtIndex( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), + idx, bit_offset_ptr); + + default: + break; + } + return CompilerType(); +} + +CompilerType ClangASTContext::GetVirtualBaseClassAtIndex( + lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) { + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::CXXRecordDecl *cxx_record_decl = + qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) { + uint32_t curr_idx = 0; + clang::CXXRecordDecl::base_class_const_iterator base_class, + base_class_end; + for (base_class = cxx_record_decl->vbases_begin(), + base_class_end = cxx_record_decl->vbases_end(); + base_class != base_class_end; ++base_class, ++curr_idx) { + if (curr_idx == idx) { + if (bit_offset_ptr) { + const clang::ASTRecordLayout &record_layout = + getASTContext()->getASTRecordLayout(cxx_record_decl); + const clang::CXXRecordDecl *base_class_decl = + llvm::cast<clang::CXXRecordDecl>( + base_class->getType() + ->getAs<clang::RecordType>() + ->getDecl()); + *bit_offset_ptr = + record_layout.getVBaseClassOffset(base_class_decl) + .getQuantity() * + 8; } - break; - - - case clang::Type::Typedef: - return GetDirectBaseClassAtIndex (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), idx, bit_offset_ptr); - - case clang::Type::Auto: - return GetDirectBaseClassAtIndex (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), idx, bit_offset_ptr); - - case clang::Type::Elaborated: - return GetDirectBaseClassAtIndex (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), idx, bit_offset_ptr); - - case clang::Type::Paren: - return GetDirectBaseClassAtIndex (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), idx, bit_offset_ptr); - - default: - break; + return CompilerType(this, base_class->getType().getAsOpaquePtr()); + } + } + } } - return CompilerType(); -} + break; -CompilerType -ClangASTContext::GetVirtualBaseClassAtIndex (lldb::opaque_compiler_type_t type, - size_t idx, - uint32_t *bit_offset_ptr) -{ - clang::QualType qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - { - uint32_t curr_idx = 0; - clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; - for (base_class = cxx_record_decl->vbases_begin(), base_class_end = cxx_record_decl->vbases_end(); - base_class != base_class_end; - ++base_class, ++curr_idx) - { - if (curr_idx == idx) - { - if (bit_offset_ptr) - { - const clang::ASTRecordLayout &record_layout = getASTContext()->getASTRecordLayout(cxx_record_decl); - const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl()); - *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; + case clang::Type::Typedef: + return GetVirtualBaseClassAtIndex(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + idx, bit_offset_ptr); - } - return CompilerType (this, base_class->getType().getAsOpaquePtr()); - } - } - } - } - break; + case clang::Type::Auto: + return GetVirtualBaseClassAtIndex(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + idx, bit_offset_ptr); - case clang::Type::Typedef: - return GetVirtualBaseClassAtIndex (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), idx, bit_offset_ptr); - - case clang::Type::Auto: - return GetVirtualBaseClassAtIndex (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), idx, bit_offset_ptr); - - case clang::Type::Elaborated: - return GetVirtualBaseClassAtIndex (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), idx, bit_offset_ptr); + case clang::Type::Elaborated: + return GetVirtualBaseClassAtIndex( + llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + idx, bit_offset_ptr); - case clang::Type::Paren: - return GetVirtualBaseClassAtIndex(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), idx, - bit_offset_ptr); - - default: - break; - } - return CompilerType(); + case clang::Type::Paren: + return GetVirtualBaseClassAtIndex( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), + idx, bit_offset_ptr); + default: + break; + } + return CompilerType(); } // If a pointer to a pointee type (the clang_type arg) says that it has no @@ -6250,776 +6156,757 @@ ClangASTContext::GetVirtualBaseClassAtIndex (lldb::opaque_compiler_type_t type, // different result. For example, an "int *" has one child that is an integer, // but a function pointer doesn't have any children. Likewise if a Record type // claims it has no children, then there really is nothing to show. -uint32_t -ClangASTContext::GetNumPointeeChildren (clang::QualType type) -{ - if (type.isNull()) - return 0; - - clang::QualType qual_type(type.getCanonicalType()); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Builtin: - switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) - { - case clang::BuiltinType::UnknownAny: - case clang::BuiltinType::Void: - case clang::BuiltinType::NullPtr: - case clang::BuiltinType::OCLEvent: - case clang::BuiltinType::OCLImage1dRO: - case clang::BuiltinType::OCLImage1dWO: - case clang::BuiltinType::OCLImage1dRW: - case clang::BuiltinType::OCLImage1dArrayRO: - case clang::BuiltinType::OCLImage1dArrayWO: - case clang::BuiltinType::OCLImage1dArrayRW: - case clang::BuiltinType::OCLImage1dBufferRO: - case clang::BuiltinType::OCLImage1dBufferWO: - case clang::BuiltinType::OCLImage1dBufferRW: - case clang::BuiltinType::OCLImage2dRO: - case clang::BuiltinType::OCLImage2dWO: - case clang::BuiltinType::OCLImage2dRW: - case clang::BuiltinType::OCLImage2dArrayRO: - case clang::BuiltinType::OCLImage2dArrayWO: - case clang::BuiltinType::OCLImage2dArrayRW: - case clang::BuiltinType::OCLImage3dRO: - case clang::BuiltinType::OCLImage3dWO: - case clang::BuiltinType::OCLImage3dRW: - case clang::BuiltinType::OCLSampler: - return 0; - case clang::BuiltinType::Bool: - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::WChar_U: - case clang::BuiltinType::Char16: - case clang::BuiltinType::Char32: - case clang::BuiltinType::UShort: - case clang::BuiltinType::UInt: - case clang::BuiltinType::ULong: - case clang::BuiltinType::ULongLong: - case clang::BuiltinType::UInt128: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: - case clang::BuiltinType::WChar_S: - case clang::BuiltinType::Short: - case clang::BuiltinType::Int: - case clang::BuiltinType::Long: - case clang::BuiltinType::LongLong: - case clang::BuiltinType::Int128: - case clang::BuiltinType::Float: - case clang::BuiltinType::Double: - case clang::BuiltinType::LongDouble: - case clang::BuiltinType::Dependent: - case clang::BuiltinType::Overload: - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCClass: - case clang::BuiltinType::ObjCSel: - case clang::BuiltinType::BoundMember: - case clang::BuiltinType::Half: - case clang::BuiltinType::ARCUnbridgedCast: - case clang::BuiltinType::PseudoObject: - case clang::BuiltinType::BuiltinFn: - case clang::BuiltinType::OMPArraySection: - return 1; - default: - return 0; - } - break; - - case clang::Type::Complex: return 1; - case clang::Type::Pointer: return 1; - case clang::Type::BlockPointer: return 0; // If block pointers don't have debug info, then no children for them - case clang::Type::LValueReference: return 1; - case clang::Type::RValueReference: return 1; - case clang::Type::MemberPointer: return 0; - case clang::Type::ConstantArray: return 0; - case clang::Type::IncompleteArray: return 0; - case clang::Type::VariableArray: return 0; - case clang::Type::DependentSizedArray: return 0; - case clang::Type::DependentSizedExtVector: return 0; - case clang::Type::Vector: return 0; - case clang::Type::ExtVector: return 0; - case clang::Type::FunctionProto: return 0; // When we function pointers, they have no children... - case clang::Type::FunctionNoProto: return 0; // When we function pointers, they have no children... - case clang::Type::UnresolvedUsing: return 0; - case clang::Type::Paren: return GetNumPointeeChildren (llvm::cast<clang::ParenType>(qual_type)->desugar()); - case clang::Type::Typedef: return GetNumPointeeChildren (llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()); - case clang::Type::Auto: return GetNumPointeeChildren (llvm::cast<clang::AutoType>(qual_type)->getDeducedType()); - case clang::Type::Elaborated: return GetNumPointeeChildren (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()); - case clang::Type::TypeOfExpr: return 0; - case clang::Type::TypeOf: return 0; - case clang::Type::Decltype: return 0; - case clang::Type::Record: return 0; - case clang::Type::Enum: return 1; - case clang::Type::TemplateTypeParm: return 1; - case clang::Type::SubstTemplateTypeParm: return 1; - case clang::Type::TemplateSpecialization: return 1; - case clang::Type::InjectedClassName: return 0; - case clang::Type::DependentName: return 1; - case clang::Type::DependentTemplateSpecialization: return 1; - case clang::Type::ObjCObject: return 0; - case clang::Type::ObjCInterface: return 0; - case clang::Type::ObjCObjectPointer: return 1; - default: - break; - } +uint32_t ClangASTContext::GetNumPointeeChildren(clang::QualType type) { + if (type.isNull()) return 0; -} + clang::QualType qual_type(type.getCanonicalType()); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Builtin: + switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) { + case clang::BuiltinType::UnknownAny: + case clang::BuiltinType::Void: + case clang::BuiltinType::NullPtr: + case clang::BuiltinType::OCLEvent: + case clang::BuiltinType::OCLImage1dRO: + case clang::BuiltinType::OCLImage1dWO: + case clang::BuiltinType::OCLImage1dRW: + case clang::BuiltinType::OCLImage1dArrayRO: + case clang::BuiltinType::OCLImage1dArrayWO: + case clang::BuiltinType::OCLImage1dArrayRW: + case clang::BuiltinType::OCLImage1dBufferRO: + case clang::BuiltinType::OCLImage1dBufferWO: + case clang::BuiltinType::OCLImage1dBufferRW: + case clang::BuiltinType::OCLImage2dRO: + case clang::BuiltinType::OCLImage2dWO: + case clang::BuiltinType::OCLImage2dRW: + case clang::BuiltinType::OCLImage2dArrayRO: + case clang::BuiltinType::OCLImage2dArrayWO: + case clang::BuiltinType::OCLImage2dArrayRW: + case clang::BuiltinType::OCLImage3dRO: + case clang::BuiltinType::OCLImage3dWO: + case clang::BuiltinType::OCLImage3dRW: + case clang::BuiltinType::OCLSampler: + return 0; + case clang::BuiltinType::Bool: + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::WChar_U: + case clang::BuiltinType::Char16: + case clang::BuiltinType::Char32: + case clang::BuiltinType::UShort: + case clang::BuiltinType::UInt: + case clang::BuiltinType::ULong: + case clang::BuiltinType::ULongLong: + case clang::BuiltinType::UInt128: + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::WChar_S: + case clang::BuiltinType::Short: + case clang::BuiltinType::Int: + case clang::BuiltinType::Long: + case clang::BuiltinType::LongLong: + case clang::BuiltinType::Int128: + case clang::BuiltinType::Float: + case clang::BuiltinType::Double: + case clang::BuiltinType::LongDouble: + case clang::BuiltinType::Dependent: + case clang::BuiltinType::Overload: + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCClass: + case clang::BuiltinType::ObjCSel: + case clang::BuiltinType::BoundMember: + case clang::BuiltinType::Half: + case clang::BuiltinType::ARCUnbridgedCast: + case clang::BuiltinType::PseudoObject: + case clang::BuiltinType::BuiltinFn: + case clang::BuiltinType::OMPArraySection: + return 1; + default: + return 0; + } + break; -CompilerType -ClangASTContext::GetChildCompilerTypeAtIndex (lldb::opaque_compiler_type_t type, - ExecutionContext *exe_ctx, - size_t idx, - bool transparent_pointers, - bool omit_empty_base_classes, - bool ignore_array_bounds, - std::string& child_name, - uint32_t &child_byte_size, - int32_t &child_byte_offset, - uint32_t &child_bitfield_bit_size, - uint32_t &child_bitfield_bit_offset, - bool &child_is_base_class, - bool &child_is_deref_of_parent, - ValueObject *valobj, - uint64_t &language_flags) -{ - if (!type) - return CompilerType(); - - clang::QualType parent_qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass(); - child_bitfield_bit_size = 0; - child_bitfield_bit_offset = 0; - child_is_base_class = false; - language_flags = 0; - - const bool idx_is_valid = idx < GetNumChildren (type, omit_empty_base_classes); - uint32_t bit_offset; - switch (parent_type_class) - { - case clang::Type::Builtin: - if (idx_is_valid) - { - switch (llvm::cast<clang::BuiltinType>(parent_qual_type)->getKind()) - { - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCClass: - child_name = "isa"; - child_byte_size = getASTContext()->getTypeSize(getASTContext()->ObjCBuiltinClassTy) / CHAR_BIT; - return CompilerType (getASTContext(), getASTContext()->ObjCBuiltinClassTy); - - default: - break; - } - } - break; - - case clang::Type::Record: - if (idx_is_valid && GetCompleteType(type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(parent_qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - assert(record_decl); - const clang::ASTRecordLayout &record_layout = getASTContext()->getASTRecordLayout(record_decl); - uint32_t child_idx = 0; - - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - if (cxx_record_decl) - { - // We might have base classes to print out first - clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; - for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); - base_class != base_class_end; - ++base_class) - { - const clang::CXXRecordDecl *base_class_decl = nullptr; - - // Skip empty base classes - if (omit_empty_base_classes) - { - base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl()); - if (ClangASTContext::RecordHasFields(base_class_decl) == false) - continue; - } - - if (idx == child_idx) - { - if (base_class_decl == nullptr) - base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl()); - - - if (base_class->isVirtual()) - { - bool handled = false; - if (valobj) - { - Error err; - AddressType addr_type = eAddressTypeInvalid; - lldb::addr_t vtable_ptr_addr = valobj->GetCPPVTableAddress(addr_type); - - if (vtable_ptr_addr != LLDB_INVALID_ADDRESS && addr_type == eAddressTypeLoad) - { - - ExecutionContext exe_ctx (valobj->GetExecutionContextRef()); - Process *process = exe_ctx.GetProcessPtr(); - if (process) - { - clang::VTableContextBase *vtable_ctx = getASTContext()->getVTableContext(); - if (vtable_ctx) - { - if (vtable_ctx->isMicrosoft()) - { - clang::MicrosoftVTableContext *msoft_vtable_ctx = static_cast<clang::MicrosoftVTableContext *>(vtable_ctx); - - if (vtable_ptr_addr) - { - const lldb::addr_t vbtable_ptr_addr = vtable_ptr_addr + record_layout.getVBPtrOffset().getQuantity(); - - const lldb::addr_t vbtable_ptr = process->ReadPointerFromMemory(vbtable_ptr_addr, err); - if (vbtable_ptr != LLDB_INVALID_ADDRESS) - { - // Get the index into the virtual base table. The index is the index in uint32_t from vbtable_ptr - const unsigned vbtable_index = msoft_vtable_ctx->getVBTableIndex(cxx_record_decl, base_class_decl); - const lldb::addr_t base_offset_addr = vbtable_ptr + vbtable_index * 4; - const uint32_t base_offset = process->ReadUnsignedIntegerFromMemory(base_offset_addr, 4, UINT32_MAX, err); - if (base_offset != UINT32_MAX) - { - handled = true; - bit_offset = base_offset * 8; - } - } - } - } - else - { - clang::ItaniumVTableContext *itanium_vtable_ctx = static_cast<clang::ItaniumVTableContext *>(vtable_ctx); - if (vtable_ptr_addr) - { - const lldb::addr_t vtable_ptr = process->ReadPointerFromMemory(vtable_ptr_addr, err); - if (vtable_ptr != LLDB_INVALID_ADDRESS) - { - clang::CharUnits base_offset_offset = itanium_vtable_ctx->getVirtualBaseOffsetOffset(cxx_record_decl, base_class_decl); - const lldb::addr_t base_offset_addr = vtable_ptr + base_offset_offset.getQuantity(); - const uint32_t base_offset_size = process->GetAddressByteSize(); - const uint64_t base_offset = process->ReadUnsignedIntegerFromMemory(base_offset_addr, base_offset_size, UINT32_MAX, err); - if (base_offset < UINT32_MAX) - { - handled = true; - bit_offset = base_offset * 8; - } - } - } - } - } - } - } - - } - if (!handled) - bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; - } - else - bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; - - // Base classes should be a multiple of 8 bits in size - child_byte_offset = bit_offset/8; - CompilerType base_class_clang_type(getASTContext(), base_class->getType()); - child_name = base_class_clang_type.GetTypeName().AsCString(""); - uint64_t base_class_clang_type_bit_size = base_class_clang_type.GetBitSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); - - // Base classes bit sizes should be a multiple of 8 bits in size - assert (base_class_clang_type_bit_size % 8 == 0); - child_byte_size = base_class_clang_type_bit_size / 8; - child_is_base_class = true; - return base_class_clang_type; - } - // We don't increment the child index in the for loop since we might - // be skipping empty base classes - ++child_idx; - } - } - // Make sure index is in range... - uint32_t field_idx = 0; - clang::RecordDecl::field_iterator field, field_end; - for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) - { - if (idx == child_idx) - { - // Print the member type if requested - // Print the member name and equal sign - child_name.assign(field->getNameAsString().c_str()); - - // Figure out the type byte size (field_type_info.first) and - // alignment (field_type_info.second) from the AST context. - CompilerType field_clang_type (getASTContext(), field->getType()); - assert(field_idx < record_layout.getFieldCount()); - child_byte_size = field_clang_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); - const uint32_t child_bit_size = child_byte_size * 8; - - // Figure out the field offset within the current struct/union/class type - bit_offset = record_layout.getFieldOffset (field_idx); - if (ClangASTContext::FieldIsBitfield (getASTContext(), *field, child_bitfield_bit_size)) - { - child_bitfield_bit_offset = bit_offset % child_bit_size; - const uint32_t child_bit_offset = bit_offset - child_bitfield_bit_offset; - child_byte_offset = child_bit_offset / 8; - } - else - { - child_byte_offset = bit_offset / 8; - } - - return field_clang_type; - } - } - } - break; - - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - if (idx_is_valid && GetCompleteType(type)) - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(parent_qual_type.getTypePtr()); - assert (objc_class_type); - if (objc_class_type) - { - uint32_t child_idx = 0; - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - - if (class_interface_decl) - { - - const clang::ASTRecordLayout &interface_layout = getASTContext()->getASTObjCInterfaceLayout(class_interface_decl); - clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); - if (superclass_interface_decl) - { - if (omit_empty_base_classes) - { - CompilerType base_class_clang_type (getASTContext(), getASTContext()->getObjCInterfaceType(superclass_interface_decl)); - if (base_class_clang_type.GetNumChildren(omit_empty_base_classes) > 0) - { - if (idx == 0) - { - clang::QualType ivar_qual_type(getASTContext()->getObjCInterfaceType(superclass_interface_decl)); - - - child_name.assign(superclass_interface_decl->getNameAsString().c_str()); - - clang::TypeInfo ivar_type_info = getASTContext()->getTypeInfo(ivar_qual_type.getTypePtr()); - - child_byte_size = ivar_type_info.Width / 8; - child_byte_offset = 0; - child_is_base_class = true; - - return CompilerType (getASTContext(), ivar_qual_type); - } - - ++child_idx; - } + case clang::Type::Complex: + return 1; + case clang::Type::Pointer: + return 1; + case clang::Type::BlockPointer: + return 0; // If block pointers don't have debug info, then no children for + // them + case clang::Type::LValueReference: + return 1; + case clang::Type::RValueReference: + return 1; + case clang::Type::MemberPointer: + return 0; + case clang::Type::ConstantArray: + return 0; + case clang::Type::IncompleteArray: + return 0; + case clang::Type::VariableArray: + return 0; + case clang::Type::DependentSizedArray: + return 0; + case clang::Type::DependentSizedExtVector: + return 0; + case clang::Type::Vector: + return 0; + case clang::Type::ExtVector: + return 0; + case clang::Type::FunctionProto: + return 0; // When we function pointers, they have no children... + case clang::Type::FunctionNoProto: + return 0; // When we function pointers, they have no children... + case clang::Type::UnresolvedUsing: + return 0; + case clang::Type::Paren: + return GetNumPointeeChildren( + llvm::cast<clang::ParenType>(qual_type)->desugar()); + case clang::Type::Typedef: + return GetNumPointeeChildren(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()); + case clang::Type::Auto: + return GetNumPointeeChildren( + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()); + case clang::Type::Elaborated: + return GetNumPointeeChildren( + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()); + case clang::Type::TypeOfExpr: + return 0; + case clang::Type::TypeOf: + return 0; + case clang::Type::Decltype: + return 0; + case clang::Type::Record: + return 0; + case clang::Type::Enum: + return 1; + case clang::Type::TemplateTypeParm: + return 1; + case clang::Type::SubstTemplateTypeParm: + return 1; + case clang::Type::TemplateSpecialization: + return 1; + case clang::Type::InjectedClassName: + return 0; + case clang::Type::DependentName: + return 1; + case clang::Type::DependentTemplateSpecialization: + return 1; + case clang::Type::ObjCObject: + return 0; + case clang::Type::ObjCInterface: + return 0; + case clang::Type::ObjCObjectPointer: + return 1; + default: + break; + } + return 0; +} + +CompilerType ClangASTContext::GetChildCompilerTypeAtIndex( + lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx, + bool transparent_pointers, bool omit_empty_base_classes, + bool ignore_array_bounds, std::string &child_name, + uint32_t &child_byte_size, int32_t &child_byte_offset, + uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset, + bool &child_is_base_class, bool &child_is_deref_of_parent, + ValueObject *valobj, uint64_t &language_flags) { + if (!type) + return CompilerType(); + + clang::QualType parent_qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass parent_type_class = + parent_qual_type->getTypeClass(); + child_bitfield_bit_size = 0; + child_bitfield_bit_offset = 0; + child_is_base_class = false; + language_flags = 0; + + const bool idx_is_valid = idx < GetNumChildren(type, omit_empty_base_classes); + uint32_t bit_offset; + switch (parent_type_class) { + case clang::Type::Builtin: + if (idx_is_valid) { + switch (llvm::cast<clang::BuiltinType>(parent_qual_type)->getKind()) { + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCClass: + child_name = "isa"; + child_byte_size = + getASTContext()->getTypeSize(getASTContext()->ObjCBuiltinClassTy) / + CHAR_BIT; + return CompilerType(getASTContext(), + getASTContext()->ObjCBuiltinClassTy); + + default: + break; + } + } + break; + + case clang::Type::Record: + if (idx_is_valid && GetCompleteType(type)) { + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(parent_qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + assert(record_decl); + const clang::ASTRecordLayout &record_layout = + getASTContext()->getASTRecordLayout(record_decl); + uint32_t child_idx = 0; + + const clang::CXXRecordDecl *cxx_record_decl = + llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); + if (cxx_record_decl) { + // We might have base classes to print out first + clang::CXXRecordDecl::base_class_const_iterator base_class, + base_class_end; + for (base_class = cxx_record_decl->bases_begin(), + base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; ++base_class) { + const clang::CXXRecordDecl *base_class_decl = nullptr; + + // Skip empty base classes + if (omit_empty_base_classes) { + base_class_decl = llvm::cast<clang::CXXRecordDecl>( + base_class->getType()->getAs<clang::RecordType>()->getDecl()); + if (ClangASTContext::RecordHasFields(base_class_decl) == false) + continue; + } + + if (idx == child_idx) { + if (base_class_decl == nullptr) + base_class_decl = llvm::cast<clang::CXXRecordDecl>( + base_class->getType()->getAs<clang::RecordType>()->getDecl()); + + if (base_class->isVirtual()) { + bool handled = false; + if (valobj) { + Error err; + AddressType addr_type = eAddressTypeInvalid; + lldb::addr_t vtable_ptr_addr = + valobj->GetCPPVTableAddress(addr_type); + + if (vtable_ptr_addr != LLDB_INVALID_ADDRESS && + addr_type == eAddressTypeLoad) { + + ExecutionContext exe_ctx(valobj->GetExecutionContextRef()); + Process *process = exe_ctx.GetProcessPtr(); + if (process) { + clang::VTableContextBase *vtable_ctx = + getASTContext()->getVTableContext(); + if (vtable_ctx) { + if (vtable_ctx->isMicrosoft()) { + clang::MicrosoftVTableContext *msoft_vtable_ctx = + static_cast<clang::MicrosoftVTableContext *>( + vtable_ctx); + + if (vtable_ptr_addr) { + const lldb::addr_t vbtable_ptr_addr = + vtable_ptr_addr + + record_layout.getVBPtrOffset().getQuantity(); + + const lldb::addr_t vbtable_ptr = + process->ReadPointerFromMemory(vbtable_ptr_addr, + err); + if (vbtable_ptr != LLDB_INVALID_ADDRESS) { + // Get the index into the virtual base table. The + // index is the index in uint32_t from vbtable_ptr + const unsigned vbtable_index = + msoft_vtable_ctx->getVBTableIndex( + cxx_record_decl, base_class_decl); + const lldb::addr_t base_offset_addr = + vbtable_ptr + vbtable_index * 4; + const uint32_t base_offset = + process->ReadUnsignedIntegerFromMemory( + base_offset_addr, 4, UINT32_MAX, err); + if (base_offset != UINT32_MAX) { + handled = true; + bit_offset = base_offset * 8; } - else - ++child_idx; + } } - - const uint32_t superclass_idx = child_idx; - - if (idx < (child_idx + class_interface_decl->ivar_size())) - { - clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); - - for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos) - { - if (child_idx == idx) - { - clang::ObjCIvarDecl* ivar_decl = *ivar_pos; - - clang::QualType ivar_qual_type(ivar_decl->getType()); - - child_name.assign(ivar_decl->getNameAsString().c_str()); - - clang::TypeInfo ivar_type_info = getASTContext()->getTypeInfo(ivar_qual_type.getTypePtr()); - - child_byte_size = ivar_type_info.Width / 8; - - // Figure out the field offset within the current struct/union/class type - // For ObjC objects, we can't trust the bit offset we get from the Clang AST, since - // that doesn't account for the space taken up by unbacked properties, or from - // the changing size of base classes that are newer than this class. - // So if we have a process around that we can ask about this object, do so. - child_byte_offset = LLDB_INVALID_IVAR_OFFSET; - Process *process = nullptr; - if (exe_ctx) - process = exe_ctx->GetProcessPtr(); - if (process) - { - ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime(); - if (objc_runtime != nullptr) - { - CompilerType parent_ast_type (getASTContext(), parent_qual_type); - child_byte_offset = objc_runtime->GetByteOffsetForIvar (parent_ast_type, ivar_decl->getNameAsString().c_str()); - } - } - - // Setting this to UINT32_MAX to make sure we don't compute it twice... - bit_offset = UINT32_MAX; - - if (child_byte_offset == static_cast<int32_t>(LLDB_INVALID_IVAR_OFFSET)) - { - bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx); - child_byte_offset = bit_offset / 8; - } - - // Note, the ObjC Ivar Byte offset is just that, it doesn't account for the bit offset - // of a bitfield within its containing object. So regardless of where we get the byte - // offset from, we still need to get the bit offset for bitfields from the layout. - - if (ClangASTContext::FieldIsBitfield (getASTContext(), ivar_decl, child_bitfield_bit_size)) - { - if (bit_offset == UINT32_MAX) - bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx); - - child_bitfield_bit_offset = bit_offset % 8; - } - return CompilerType (getASTContext(), ivar_qual_type); - } - ++child_idx; + } else { + clang::ItaniumVTableContext *itanium_vtable_ctx = + static_cast<clang::ItaniumVTableContext *>( + vtable_ctx); + if (vtable_ptr_addr) { + const lldb::addr_t vtable_ptr = + process->ReadPointerFromMemory(vtable_ptr_addr, + err); + if (vtable_ptr != LLDB_INVALID_ADDRESS) { + clang::CharUnits base_offset_offset = + itanium_vtable_ctx->getVirtualBaseOffsetOffset( + cxx_record_decl, base_class_decl); + const lldb::addr_t base_offset_addr = + vtable_ptr + base_offset_offset.getQuantity(); + const uint32_t base_offset_size = + process->GetAddressByteSize(); + const uint64_t base_offset = + process->ReadUnsignedIntegerFromMemory( + base_offset_addr, base_offset_size, + UINT32_MAX, err); + if (base_offset < UINT32_MAX) { + handled = true; + bit_offset = base_offset * 8; } + } } + } } + } } - } - break; - - case clang::Type::ObjCObjectPointer: - if (idx_is_valid) - { - CompilerType pointee_clang_type (GetPointeeType(type)); - - if (transparent_pointers && pointee_clang_type.IsAggregateType()) - { - child_is_deref_of_parent = false; - bool tmp_child_is_deref_of_parent = false; - return pointee_clang_type.GetChildCompilerTypeAtIndex (exe_ctx, - idx, - transparent_pointers, - omit_empty_base_classes, - ignore_array_bounds, - child_name, - child_byte_size, - child_byte_offset, - child_bitfield_bit_size, - child_bitfield_bit_offset, - child_is_base_class, - tmp_child_is_deref_of_parent, - valobj, - language_flags); - } - else - { - child_is_deref_of_parent = true; - const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL; - if (parent_name) - { - child_name.assign(1, '*'); - child_name += parent_name; - } - - // We have a pointer to an simple type - if (idx == 0 && pointee_clang_type.GetCompleteType()) - { - child_byte_size = pointee_clang_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); - child_byte_offset = 0; - return pointee_clang_type; - } - } - } - break; - - case clang::Type::Vector: - case clang::Type::ExtVector: - if (idx_is_valid) - { - const clang::VectorType *array = llvm::cast<clang::VectorType>(parent_qual_type.getTypePtr()); - if (array) - { - CompilerType element_type (getASTContext(), array->getElementType()); - if (element_type.GetCompleteType()) - { - char element_name[64]; - ::snprintf (element_name, sizeof (element_name), "[%" PRIu64 "]", static_cast<uint64_t>(idx)); - child_name.assign(element_name); - child_byte_size = element_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); - child_byte_offset = (int32_t)idx * (int32_t)child_byte_size; - return element_type; - } - } - } - break; - - case clang::Type::ConstantArray: - case clang::Type::IncompleteArray: - if (ignore_array_bounds || idx_is_valid) - { - const clang::ArrayType *array = GetQualType(type)->getAsArrayTypeUnsafe(); - if (array) - { - CompilerType element_type (getASTContext(), array->getElementType()); - if (element_type.GetCompleteType()) - { - char element_name[64]; - ::snprintf (element_name, sizeof (element_name), "[%" PRIu64 "]", static_cast<uint64_t>(idx)); - child_name.assign(element_name); - child_byte_size = element_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); - child_byte_offset = (int32_t)idx * (int32_t)child_byte_size; - return element_type; - } - } - } - break; - - - case clang::Type::Pointer: - if (idx_is_valid) - { - CompilerType pointee_clang_type (GetPointeeType(type)); - - // Don't dereference "void *" pointers - if (pointee_clang_type.IsVoidType()) - return CompilerType(); - - if (transparent_pointers && pointee_clang_type.IsAggregateType ()) - { - child_is_deref_of_parent = false; - bool tmp_child_is_deref_of_parent = false; - return pointee_clang_type.GetChildCompilerTypeAtIndex (exe_ctx, - idx, - transparent_pointers, - omit_empty_base_classes, - ignore_array_bounds, - child_name, - child_byte_size, - child_byte_offset, - child_bitfield_bit_size, - child_bitfield_bit_offset, - child_is_base_class, - tmp_child_is_deref_of_parent, - valobj, - language_flags); + } + if (!handled) + bit_offset = record_layout.getVBaseClassOffset(base_class_decl) + .getQuantity() * + 8; + } else + bit_offset = record_layout.getBaseClassOffset(base_class_decl) + .getQuantity() * + 8; + + // Base classes should be a multiple of 8 bits in size + child_byte_offset = bit_offset / 8; + CompilerType base_class_clang_type(getASTContext(), + base_class->getType()); + child_name = base_class_clang_type.GetTypeName().AsCString(""); + uint64_t base_class_clang_type_bit_size = + base_class_clang_type.GetBitSize( + exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); + + // Base classes bit sizes should be a multiple of 8 bits in size + assert(base_class_clang_type_bit_size % 8 == 0); + child_byte_size = base_class_clang_type_bit_size / 8; + child_is_base_class = true; + return base_class_clang_type; + } + // We don't increment the child index in the for loop since we might + // be skipping empty base classes + ++child_idx; + } + } + // Make sure index is in range... + uint32_t field_idx = 0; + clang::RecordDecl::field_iterator field, field_end; + for (field = record_decl->field_begin(), + field_end = record_decl->field_end(); + field != field_end; ++field, ++field_idx, ++child_idx) { + if (idx == child_idx) { + // Print the member type if requested + // Print the member name and equal sign + child_name.assign(field->getNameAsString().c_str()); + + // Figure out the type byte size (field_type_info.first) and + // alignment (field_type_info.second) from the AST context. + CompilerType field_clang_type(getASTContext(), field->getType()); + assert(field_idx < record_layout.getFieldCount()); + child_byte_size = field_clang_type.GetByteSize( + exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); + const uint32_t child_bit_size = child_byte_size * 8; + + // Figure out the field offset within the current struct/union/class + // type + bit_offset = record_layout.getFieldOffset(field_idx); + if (ClangASTContext::FieldIsBitfield(getASTContext(), *field, + child_bitfield_bit_size)) { + child_bitfield_bit_offset = bit_offset % child_bit_size; + const uint32_t child_bit_offset = + bit_offset - child_bitfield_bit_offset; + child_byte_offset = child_bit_offset / 8; + } else { + child_byte_offset = bit_offset / 8; + } + + return field_clang_type; + } + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (idx_is_valid && GetCompleteType(type)) { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(parent_qual_type.getTypePtr()); + assert(objc_class_type); + if (objc_class_type) { + uint32_t child_idx = 0; + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + + if (class_interface_decl) { + + const clang::ASTRecordLayout &interface_layout = + getASTContext()->getASTObjCInterfaceLayout(class_interface_decl); + clang::ObjCInterfaceDecl *superclass_interface_decl = + class_interface_decl->getSuperClass(); + if (superclass_interface_decl) { + if (omit_empty_base_classes) { + CompilerType base_class_clang_type( + getASTContext(), getASTContext()->getObjCInterfaceType( + superclass_interface_decl)); + if (base_class_clang_type.GetNumChildren( + omit_empty_base_classes) > 0) { + if (idx == 0) { + clang::QualType ivar_qual_type( + getASTContext()->getObjCInterfaceType( + superclass_interface_decl)); + + child_name.assign( + superclass_interface_decl->getNameAsString().c_str()); + + clang::TypeInfo ivar_type_info = + getASTContext()->getTypeInfo(ivar_qual_type.getTypePtr()); + + child_byte_size = ivar_type_info.Width / 8; + child_byte_offset = 0; + child_is_base_class = true; + + return CompilerType(getASTContext(), ivar_qual_type); } - else - { - child_is_deref_of_parent = true; - - const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL; - if (parent_name) - { - child_name.assign(1, '*'); - child_name += parent_name; - } - - // We have a pointer to an simple type - if (idx == 0) - { - child_byte_size = pointee_clang_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); - child_byte_offset = 0; - return pointee_clang_type; - } + + ++child_idx; + } + } else + ++child_idx; + } + + const uint32_t superclass_idx = child_idx; + + if (idx < (child_idx + class_interface_decl->ivar_size())) { + clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, + ivar_end = class_interface_decl->ivar_end(); + + for (ivar_pos = class_interface_decl->ivar_begin(); + ivar_pos != ivar_end; ++ivar_pos) { + if (child_idx == idx) { + clang::ObjCIvarDecl *ivar_decl = *ivar_pos; + + clang::QualType ivar_qual_type(ivar_decl->getType()); + + child_name.assign(ivar_decl->getNameAsString().c_str()); + + clang::TypeInfo ivar_type_info = + getASTContext()->getTypeInfo(ivar_qual_type.getTypePtr()); + + child_byte_size = ivar_type_info.Width / 8; + + // Figure out the field offset within the current + // struct/union/class type + // For ObjC objects, we can't trust the bit offset we get from + // the Clang AST, since + // that doesn't account for the space taken up by unbacked + // properties, or from + // the changing size of base classes that are newer than this + // class. + // So if we have a process around that we can ask about this + // object, do so. + child_byte_offset = LLDB_INVALID_IVAR_OFFSET; + Process *process = nullptr; + if (exe_ctx) + process = exe_ctx->GetProcessPtr(); + if (process) { + ObjCLanguageRuntime *objc_runtime = + process->GetObjCLanguageRuntime(); + if (objc_runtime != nullptr) { + CompilerType parent_ast_type(getASTContext(), + parent_qual_type); + child_byte_offset = objc_runtime->GetByteOffsetForIvar( + parent_ast_type, ivar_decl->getNameAsString().c_str()); + } } - } - break; - - case clang::Type::LValueReference: - case clang::Type::RValueReference: - if (idx_is_valid) - { - const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(parent_qual_type.getTypePtr()); - CompilerType pointee_clang_type (getASTContext(), reference_type->getPointeeType()); - if (transparent_pointers && pointee_clang_type.IsAggregateType ()) - { - child_is_deref_of_parent = false; - bool tmp_child_is_deref_of_parent = false; - return pointee_clang_type.GetChildCompilerTypeAtIndex (exe_ctx, - idx, - transparent_pointers, - omit_empty_base_classes, - ignore_array_bounds, - child_name, - child_byte_size, - child_byte_offset, - child_bitfield_bit_size, - child_bitfield_bit_offset, - child_is_base_class, - tmp_child_is_deref_of_parent, - valobj, - language_flags); + + // Setting this to UINT32_MAX to make sure we don't compute it + // twice... + bit_offset = UINT32_MAX; + + if (child_byte_offset == + static_cast<int32_t>(LLDB_INVALID_IVAR_OFFSET)) { + bit_offset = interface_layout.getFieldOffset(child_idx - + superclass_idx); + child_byte_offset = bit_offset / 8; } - else - { - const char *parent_name = valobj ? valobj->GetName().GetCString() : NULL; - if (parent_name) - { - child_name.assign(1, '&'); - child_name += parent_name; - } - - // We have a pointer to an simple type - if (idx == 0) - { - child_byte_size = pointee_clang_type.GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); - child_byte_offset = 0; - return pointee_clang_type; - } + + // Note, the ObjC Ivar Byte offset is just that, it doesn't + // account for the bit offset + // of a bitfield within its containing object. So regardless of + // where we get the byte + // offset from, we still need to get the bit offset for + // bitfields from the layout. + + if (ClangASTContext::FieldIsBitfield(getASTContext(), ivar_decl, + child_bitfield_bit_size)) { + if (bit_offset == UINT32_MAX) + bit_offset = interface_layout.getFieldOffset( + child_idx - superclass_idx); + + child_bitfield_bit_offset = bit_offset % 8; } + return CompilerType(getASTContext(), ivar_qual_type); + } + ++child_idx; } - break; - - case clang::Type::Typedef: - { - CompilerType typedefed_clang_type (getASTContext(), llvm::cast<clang::TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType()); - return typedefed_clang_type.GetChildCompilerTypeAtIndex (exe_ctx, - idx, - transparent_pointers, - omit_empty_base_classes, - ignore_array_bounds, - child_name, - child_byte_size, - child_byte_offset, - child_bitfield_bit_size, - child_bitfield_bit_offset, - child_is_base_class, - child_is_deref_of_parent, - valobj, - language_flags); + } } - break; - - case clang::Type::Auto: - { - CompilerType elaborated_clang_type (getASTContext(), llvm::cast<clang::AutoType>(parent_qual_type)->getDeducedType()); - return elaborated_clang_type.GetChildCompilerTypeAtIndex (exe_ctx, - idx, - transparent_pointers, - omit_empty_base_classes, - ignore_array_bounds, - child_name, - child_byte_size, - child_byte_offset, - child_bitfield_bit_size, - child_bitfield_bit_offset, - child_is_base_class, - child_is_deref_of_parent, - valobj, - language_flags); + } + } + break; + + case clang::Type::ObjCObjectPointer: + if (idx_is_valid) { + CompilerType pointee_clang_type(GetPointeeType(type)); + + if (transparent_pointers && pointee_clang_type.IsAggregateType()) { + child_is_deref_of_parent = false; + bool tmp_child_is_deref_of_parent = false; + return pointee_clang_type.GetChildCompilerTypeAtIndex( + exe_ctx, idx, transparent_pointers, omit_empty_base_classes, + ignore_array_bounds, child_name, child_byte_size, child_byte_offset, + child_bitfield_bit_size, child_bitfield_bit_offset, + child_is_base_class, tmp_child_is_deref_of_parent, valobj, + language_flags); + } else { + child_is_deref_of_parent = true; + const char *parent_name = + valobj ? valobj->GetName().GetCString() : NULL; + if (parent_name) { + child_name.assign(1, '*'); + child_name += parent_name; } - - case clang::Type::Elaborated: - { - CompilerType elaborated_clang_type (getASTContext(), llvm::cast<clang::ElaboratedType>(parent_qual_type)->getNamedType()); - return elaborated_clang_type.GetChildCompilerTypeAtIndex (exe_ctx, - idx, - transparent_pointers, - omit_empty_base_classes, - ignore_array_bounds, - child_name, - child_byte_size, - child_byte_offset, - child_bitfield_bit_size, - child_bitfield_bit_offset, - child_is_base_class, - child_is_deref_of_parent, - valobj, - language_flags); + + // We have a pointer to an simple type + if (idx == 0 && pointee_clang_type.GetCompleteType()) { + child_byte_size = pointee_clang_type.GetByteSize( + exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); + child_byte_offset = 0; + return pointee_clang_type; } - - case clang::Type::Paren: - { - CompilerType paren_clang_type (getASTContext(), llvm::cast<clang::ParenType>(parent_qual_type)->desugar()); - return paren_clang_type.GetChildCompilerTypeAtIndex (exe_ctx, - idx, - transparent_pointers, - omit_empty_base_classes, - ignore_array_bounds, - child_name, - child_byte_size, - child_byte_offset, - child_bitfield_bit_size, - child_bitfield_bit_offset, - child_is_base_class, - child_is_deref_of_parent, - valobj, - language_flags); + } + } + break; + + case clang::Type::Vector: + case clang::Type::ExtVector: + if (idx_is_valid) { + const clang::VectorType *array = + llvm::cast<clang::VectorType>(parent_qual_type.getTypePtr()); + if (array) { + CompilerType element_type(getASTContext(), array->getElementType()); + if (element_type.GetCompleteType()) { + char element_name[64]; + ::snprintf(element_name, sizeof(element_name), "[%" PRIu64 "]", + static_cast<uint64_t>(idx)); + child_name.assign(element_name); + child_byte_size = element_type.GetByteSize( + exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); + child_byte_offset = (int32_t)idx * (int32_t)child_byte_size; + return element_type; } - - - default: - break; + } + } + break; + + case clang::Type::ConstantArray: + case clang::Type::IncompleteArray: + if (ignore_array_bounds || idx_is_valid) { + const clang::ArrayType *array = GetQualType(type)->getAsArrayTypeUnsafe(); + if (array) { + CompilerType element_type(getASTContext(), array->getElementType()); + if (element_type.GetCompleteType()) { + char element_name[64]; + ::snprintf(element_name, sizeof(element_name), "[%" PRIu64 "]", + static_cast<uint64_t>(idx)); + child_name.assign(element_name); + child_byte_size = element_type.GetByteSize( + exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); + child_byte_offset = (int32_t)idx * (int32_t)child_byte_size; + return element_type; + } + } } - return CompilerType(); -} + break; -static uint32_t -GetIndexForRecordBase -( - const clang::RecordDecl *record_decl, - const clang::CXXBaseSpecifier *base_spec, - bool omit_empty_base_classes - ) -{ - uint32_t child_idx = 0; - - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - - // const char *super_name = record_decl->getNameAsCString(); - // const char *base_name = base_spec->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString(); - // printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name); - // - if (cxx_record_decl) - { - clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; - for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); - base_class != base_class_end; - ++base_class) - { - if (omit_empty_base_classes) - { - if (BaseSpecifierIsEmpty (base_class)) - continue; - } - - // printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name, - // child_idx, - // base_class->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString()); - // - // - if (base_class == base_spec) - return child_idx; - ++child_idx; + case clang::Type::Pointer: + if (idx_is_valid) { + CompilerType pointee_clang_type(GetPointeeType(type)); + + // Don't dereference "void *" pointers + if (pointee_clang_type.IsVoidType()) + return CompilerType(); + + if (transparent_pointers && pointee_clang_type.IsAggregateType()) { + child_is_deref_of_parent = false; + bool tmp_child_is_deref_of_parent = false; + return pointee_clang_type.GetChildCompilerTypeAtIndex( + exe_ctx, idx, transparent_pointers, omit_empty_base_classes, + ignore_array_bounds, child_name, child_byte_size, child_byte_offset, + child_bitfield_bit_size, child_bitfield_bit_offset, + child_is_base_class, tmp_child_is_deref_of_parent, valobj, + language_flags); + } else { + child_is_deref_of_parent = true; + + const char *parent_name = + valobj ? valobj->GetName().GetCString() : NULL; + if (parent_name) { + child_name.assign(1, '*'); + child_name += parent_name; } - } - - return UINT32_MAX; -} + // We have a pointer to an simple type + if (idx == 0) { + child_byte_size = pointee_clang_type.GetByteSize( + exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); + child_byte_offset = 0; + return pointee_clang_type; + } + } + } + break; + + case clang::Type::LValueReference: + case clang::Type::RValueReference: + if (idx_is_valid) { + const clang::ReferenceType *reference_type = + llvm::cast<clang::ReferenceType>(parent_qual_type.getTypePtr()); + CompilerType pointee_clang_type(getASTContext(), + reference_type->getPointeeType()); + if (transparent_pointers && pointee_clang_type.IsAggregateType()) { + child_is_deref_of_parent = false; + bool tmp_child_is_deref_of_parent = false; + return pointee_clang_type.GetChildCompilerTypeAtIndex( + exe_ctx, idx, transparent_pointers, omit_empty_base_classes, + ignore_array_bounds, child_name, child_byte_size, child_byte_offset, + child_bitfield_bit_size, child_bitfield_bit_offset, + child_is_base_class, tmp_child_is_deref_of_parent, valobj, + language_flags); + } else { + const char *parent_name = + valobj ? valobj->GetName().GetCString() : NULL; + if (parent_name) { + child_name.assign(1, '&'); + child_name += parent_name; + } -static uint32_t -GetIndexForRecordChild (const clang::RecordDecl *record_decl, - clang::NamedDecl *canonical_decl, - bool omit_empty_base_classes) -{ - uint32_t child_idx = ClangASTContext::GetNumBaseClasses (llvm::dyn_cast<clang::CXXRecordDecl>(record_decl), - omit_empty_base_classes); - - clang::RecordDecl::field_iterator field, field_end; - for (field = record_decl->field_begin(), field_end = record_decl->field_end(); - field != field_end; - ++field, ++child_idx) - { - if (field->getCanonicalDecl() == canonical_decl) - return child_idx; - } - - return UINT32_MAX; + // We have a pointer to an simple type + if (idx == 0) { + child_byte_size = pointee_clang_type.GetByteSize( + exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL); + child_byte_offset = 0; + return pointee_clang_type; + } + } + } + break; + + case clang::Type::Typedef: { + CompilerType typedefed_clang_type( + getASTContext(), llvm::cast<clang::TypedefType>(parent_qual_type) + ->getDecl() + ->getUnderlyingType()); + return typedefed_clang_type.GetChildCompilerTypeAtIndex( + exe_ctx, idx, transparent_pointers, omit_empty_base_classes, + ignore_array_bounds, child_name, child_byte_size, child_byte_offset, + child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class, + child_is_deref_of_parent, valobj, language_flags); + } break; + + case clang::Type::Auto: { + CompilerType elaborated_clang_type( + getASTContext(), + llvm::cast<clang::AutoType>(parent_qual_type)->getDeducedType()); + return elaborated_clang_type.GetChildCompilerTypeAtIndex( + exe_ctx, idx, transparent_pointers, omit_empty_base_classes, + ignore_array_bounds, child_name, child_byte_size, child_byte_offset, + child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class, + child_is_deref_of_parent, valobj, language_flags); + } + + case clang::Type::Elaborated: { + CompilerType elaborated_clang_type( + getASTContext(), + llvm::cast<clang::ElaboratedType>(parent_qual_type)->getNamedType()); + return elaborated_clang_type.GetChildCompilerTypeAtIndex( + exe_ctx, idx, transparent_pointers, omit_empty_base_classes, + ignore_array_bounds, child_name, child_byte_size, child_byte_offset, + child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class, + child_is_deref_of_parent, valobj, language_flags); + } + + case clang::Type::Paren: { + CompilerType paren_clang_type( + getASTContext(), + llvm::cast<clang::ParenType>(parent_qual_type)->desugar()); + return paren_clang_type.GetChildCompilerTypeAtIndex( + exe_ctx, idx, transparent_pointers, omit_empty_base_classes, + ignore_array_bounds, child_name, child_byte_size, child_byte_offset, + child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class, + child_is_deref_of_parent, valobj, language_flags); + } + + default: + break; + } + return CompilerType(); +} + +static uint32_t GetIndexForRecordBase(const clang::RecordDecl *record_decl, + const clang::CXXBaseSpecifier *base_spec, + bool omit_empty_base_classes) { + uint32_t child_idx = 0; + + const clang::CXXRecordDecl *cxx_record_decl = + llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); + + // const char *super_name = record_decl->getNameAsCString(); + // const char *base_name = + // base_spec->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString(); + // printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name); + // + if (cxx_record_decl) { + clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + for (base_class = cxx_record_decl->bases_begin(), + base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; ++base_class) { + if (omit_empty_base_classes) { + if (BaseSpecifierIsEmpty(base_class)) + continue; + } + + // printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", + // super_name, base_name, + // child_idx, + // base_class->getType()->getAs<clang::RecordType>()->getDecl()->getNameAsCString()); + // + // + if (base_class == base_spec) + return child_idx; + ++child_idx; + } + } + + return UINT32_MAX; +} + +static uint32_t GetIndexForRecordChild(const clang::RecordDecl *record_decl, + clang::NamedDecl *canonical_decl, + bool omit_empty_base_classes) { + uint32_t child_idx = ClangASTContext::GetNumBaseClasses( + llvm::dyn_cast<clang::CXXRecordDecl>(record_decl), + omit_empty_base_classes); + + clang::RecordDecl::field_iterator field, field_end; + for (field = record_decl->field_begin(), field_end = record_decl->field_end(); + field != field_end; ++field, ++child_idx) { + if (field->getCanonicalDecl() == canonical_decl) + return child_idx; + } + + return UINT32_MAX; } // Look for a child member (doesn't include base classes, but it does include @@ -7046,2859 +6933,2849 @@ GetIndexForRecordChild (const clang::RecordDecl *record_decl, // If we have a clang type that describes "class C", and we wanted to looked // "m_b" in it: // -// With omit_empty_base_classes == false we would get an integer array back with: +// With omit_empty_base_classes == false we would get an integer array back +// with: // { 1, 1 } // The first index 1 is the child index for "class A" within class C // The second index 1 is the child index for "m_b" within class A // // With omit_empty_base_classes == true we would get an integer array back with: // { 0, 1 } -// The first index 0 is the child index for "class A" within class C (since class B doesn't have any members it doesn't count) +// The first index 0 is the child index for "class A" within class C (since +// class B doesn't have any members it doesn't count) // The second index 1 is the child index for "m_b" within class A -size_t -ClangASTContext::GetIndexOfChildMemberWithName (lldb::opaque_compiler_type_t type, const char *name, - bool omit_empty_base_classes, - std::vector<uint32_t>& child_indexes) -{ - if (type && name && name[0]) - { - clang::QualType qual_type(GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - - assert(record_decl); - uint32_t child_idx = 0; - - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - - // Try and find a field that matches NAME - clang::RecordDecl::field_iterator field, field_end; - llvm::StringRef name_sref(name); - for (field = record_decl->field_begin(), field_end = record_decl->field_end(); - field != field_end; - ++field, ++child_idx) - { - llvm::StringRef field_name = field->getName(); - if (field_name.empty()) - { - CompilerType field_type(getASTContext(),field->getType()); - child_indexes.push_back(child_idx); - if (field_type.GetIndexOfChildMemberWithName(name, omit_empty_base_classes, child_indexes)) - return child_indexes.size(); - child_indexes.pop_back(); - - } - else if (field_name.equals (name_sref)) - { - // We have to add on the number of base classes to this index! - child_indexes.push_back (child_idx + ClangASTContext::GetNumBaseClasses (cxx_record_decl, omit_empty_base_classes)); - return child_indexes.size(); - } - } - - if (cxx_record_decl) - { - const clang::RecordDecl *parent_record_decl = cxx_record_decl; - - //printf ("parent = %s\n", parent_record_decl->getNameAsCString()); - - //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl(); - // Didn't find things easily, lets let clang do its thang... - clang::IdentifierInfo & ident_ref = getASTContext()->Idents.get(name_sref); - clang::DeclarationName decl_name(&ident_ref); - - clang::CXXBasePaths paths; - if (cxx_record_decl->lookupInBases([decl_name](const clang::CXXBaseSpecifier *specifier, clang::CXXBasePath &path) { - return clang::CXXRecordDecl::FindOrdinaryMember(specifier, path, decl_name); - }, - paths)) - { - clang::CXXBasePaths::const_paths_iterator path, path_end = paths.end(); - for (path = paths.begin(); path != path_end; ++path) - { - const size_t num_path_elements = path->size(); - for (size_t e=0; e<num_path_elements; ++e) - { - clang::CXXBasePathElement elem = (*path)[e]; - - child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes); - if (child_idx == UINT32_MAX) - { - child_indexes.clear(); - return 0; - } - else - { - child_indexes.push_back (child_idx); - parent_record_decl = llvm::cast<clang::RecordDecl>(elem.Base->getType()->getAs<clang::RecordType>()->getDecl()); - } - } - for (clang::NamedDecl *path_decl : path->Decls) - { - child_idx = GetIndexForRecordChild (parent_record_decl, path_decl, omit_empty_base_classes); - if (child_idx == UINT32_MAX) - { - child_indexes.clear(); - return 0; - } - else - { - child_indexes.push_back (child_idx); - } - } - } - return child_indexes.size(); - } - } - +size_t ClangASTContext::GetIndexOfChildMemberWithName( + lldb::opaque_compiler_type_t type, const char *name, + bool omit_empty_base_classes, std::vector<uint32_t> &child_indexes) { + if (type && name && name[0]) { + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + + assert(record_decl); + uint32_t child_idx = 0; + + const clang::CXXRecordDecl *cxx_record_decl = + llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); + + // Try and find a field that matches NAME + clang::RecordDecl::field_iterator field, field_end; + llvm::StringRef name_sref(name); + for (field = record_decl->field_begin(), + field_end = record_decl->field_end(); + field != field_end; ++field, ++child_idx) { + llvm::StringRef field_name = field->getName(); + if (field_name.empty()) { + CompilerType field_type(getASTContext(), field->getType()); + child_indexes.push_back(child_idx); + if (field_type.GetIndexOfChildMemberWithName( + name, omit_empty_base_classes, child_indexes)) + return child_indexes.size(); + child_indexes.pop_back(); + + } else if (field_name.equals(name_sref)) { + // We have to add on the number of base classes to this index! + child_indexes.push_back( + child_idx + ClangASTContext::GetNumBaseClasses( + cxx_record_decl, omit_empty_base_classes)); + return child_indexes.size(); + } + } + + if (cxx_record_decl) { + const clang::RecordDecl *parent_record_decl = cxx_record_decl; + + // printf ("parent = %s\n", parent_record_decl->getNameAsCString()); + + // const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl(); + // Didn't find things easily, lets let clang do its thang... + clang::IdentifierInfo &ident_ref = + getASTContext()->Idents.get(name_sref); + clang::DeclarationName decl_name(&ident_ref); + + clang::CXXBasePaths paths; + if (cxx_record_decl->lookupInBases( + [decl_name](const clang::CXXBaseSpecifier *specifier, + clang::CXXBasePath &path) { + return clang::CXXRecordDecl::FindOrdinaryMember( + specifier, path, decl_name); + }, + paths)) { + clang::CXXBasePaths::const_paths_iterator path, + path_end = paths.end(); + for (path = paths.begin(); path != path_end; ++path) { + const size_t num_path_elements = path->size(); + for (size_t e = 0; e < num_path_elements; ++e) { + clang::CXXBasePathElement elem = (*path)[e]; + + child_idx = GetIndexForRecordBase(parent_record_decl, elem.Base, + omit_empty_base_classes); + if (child_idx == UINT32_MAX) { + child_indexes.clear(); + return 0; + } else { + child_indexes.push_back(child_idx); + parent_record_decl = llvm::cast<clang::RecordDecl>( + elem.Base->getType() + ->getAs<clang::RecordType>() + ->getDecl()); } - break; - - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - if (GetCompleteType(type)) - { - llvm::StringRef name_sref(name); - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); - assert (objc_class_type); - if (objc_class_type) - { - uint32_t child_idx = 0; - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - - if (class_interface_decl) - { - clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); - clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); - - for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx) - { - const clang::ObjCIvarDecl* ivar_decl = *ivar_pos; - - if (ivar_decl->getName().equals (name_sref)) - { - if ((!omit_empty_base_classes && superclass_interface_decl) || - ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true))) - ++child_idx; - - child_indexes.push_back (child_idx); - return child_indexes.size(); - } - } - - if (superclass_interface_decl) - { - // The super class index is always zero for ObjC classes, - // so we push it onto the child indexes in case we find - // an ivar in our superclass... - child_indexes.push_back (0); - - CompilerType superclass_clang_type (getASTContext(), getASTContext()->getObjCInterfaceType(superclass_interface_decl)); - if (superclass_clang_type.GetIndexOfChildMemberWithName (name, - omit_empty_base_classes, - child_indexes)) - { - // We did find an ivar in a superclass so just - // return the results! - return child_indexes.size(); - } - - // We didn't find an ivar matching "name" in our - // superclass, pop the superclass zero index that - // we pushed on above. - child_indexes.pop_back(); - } - } - } + } + for (clang::NamedDecl *path_decl : path->Decls) { + child_idx = GetIndexForRecordChild( + parent_record_decl, path_decl, omit_empty_base_classes); + if (child_idx == UINT32_MAX) { + child_indexes.clear(); + return 0; + } else { + child_indexes.push_back(child_idx); } - break; - - case clang::Type::ObjCObjectPointer: - { - CompilerType objc_object_clang_type (getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()); - return objc_object_clang_type.GetIndexOfChildMemberWithName (name, - omit_empty_base_classes, - child_indexes); + } } - break; - - - case clang::Type::ConstantArray: - { - // const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr()); - // const uint64_t element_count = array->getSize().getLimitedValue(); - // - // if (idx < element_count) - // { - // std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType()); - // - // char element_name[32]; - // ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx); - // - // child_name.assign(element_name); - // assert(field_type_info.first % 8 == 0); - // child_byte_size = field_type_info.first / 8; - // child_byte_offset = idx * child_byte_size; - // return array->getElementType().getAsOpaquePtr(); - // } - } - break; - - // case clang::Type::MemberPointerType: - // { - // MemberPointerType *mem_ptr_type = llvm::cast<MemberPointerType>(qual_type.getTypePtr()); - // clang::QualType pointee_type = mem_ptr_type->getPointeeType(); - // - // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) - // { - // return GetIndexOfChildWithName (ast, - // mem_ptr_type->getPointeeType().getAsOpaquePtr(), - // name); - // } - // } - // break; - // - case clang::Type::LValueReference: - case clang::Type::RValueReference: - { - const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); - clang::QualType pointee_type(reference_type->getPointeeType()); - CompilerType pointee_clang_type (getASTContext(), pointee_type); - - if (pointee_clang_type.IsAggregateType ()) - { - return pointee_clang_type.GetIndexOfChildMemberWithName (name, - omit_empty_base_classes, - child_indexes); - } + return child_indexes.size(); + } + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (GetCompleteType(type)) { + llvm::StringRef name_sref(name); + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); + assert(objc_class_type); + if (objc_class_type) { + uint32_t child_idx = 0; + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + + if (class_interface_decl) { + clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, + ivar_end = class_interface_decl->ivar_end(); + clang::ObjCInterfaceDecl *superclass_interface_decl = + class_interface_decl->getSuperClass(); + + for (ivar_pos = class_interface_decl->ivar_begin(); + ivar_pos != ivar_end; ++ivar_pos, ++child_idx) { + const clang::ObjCIvarDecl *ivar_decl = *ivar_pos; + + if (ivar_decl->getName().equals(name_sref)) { + if ((!omit_empty_base_classes && superclass_interface_decl) || + (omit_empty_base_classes && + ObjCDeclHasIVars(superclass_interface_decl, true))) + ++child_idx; + + child_indexes.push_back(child_idx); + return child_indexes.size(); + } } - break; - - case clang::Type::Pointer: - { - CompilerType pointee_clang_type (GetPointeeType(type)); - - if (pointee_clang_type.IsAggregateType ()) - { - return pointee_clang_type.GetIndexOfChildMemberWithName (name, - omit_empty_base_classes, - child_indexes); - } + + if (superclass_interface_decl) { + // The super class index is always zero for ObjC classes, + // so we push it onto the child indexes in case we find + // an ivar in our superclass... + child_indexes.push_back(0); + + CompilerType superclass_clang_type( + getASTContext(), getASTContext()->getObjCInterfaceType( + superclass_interface_decl)); + if (superclass_clang_type.GetIndexOfChildMemberWithName( + name, omit_empty_base_classes, child_indexes)) { + // We did find an ivar in a superclass so just + // return the results! + return child_indexes.size(); + } + + // We didn't find an ivar matching "name" in our + // superclass, pop the superclass zero index that + // we pushed on above. + child_indexes.pop_back(); } - break; - - case clang::Type::Typedef: - return CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildMemberWithName (name, - omit_empty_base_classes, - child_indexes); - - case clang::Type::Auto: - return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetIndexOfChildMemberWithName (name, - omit_empty_base_classes, - child_indexes); - - case clang::Type::Elaborated: - return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildMemberWithName (name, - omit_empty_base_classes, - child_indexes); - - case clang::Type::Paren: - return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildMemberWithName (name, - omit_empty_base_classes, - child_indexes); - - default: - break; + } } + } + break; + + case clang::Type::ObjCObjectPointer: { + CompilerType objc_object_clang_type( + getASTContext(), + llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr()) + ->getPointeeType()); + return objc_object_clang_type.GetIndexOfChildMemberWithName( + name, omit_empty_base_classes, child_indexes); + } break; + + case clang::Type::ConstantArray: { + // const clang::ConstantArrayType *array = + // llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr()); + // const uint64_t element_count = + // array->getSize().getLimitedValue(); + // + // if (idx < element_count) + // { + // std::pair<uint64_t, unsigned> field_type_info = + // ast->getTypeInfo(array->getElementType()); + // + // char element_name[32]; + // ::snprintf (element_name, sizeof (element_name), + // "%s[%u]", parent_name ? parent_name : "", idx); + // + // child_name.assign(element_name); + // assert(field_type_info.first % 8 == 0); + // child_byte_size = field_type_info.first / 8; + // child_byte_offset = idx * child_byte_size; + // return array->getElementType().getAsOpaquePtr(); + // } + } break; + + // case clang::Type::MemberPointerType: + // { + // MemberPointerType *mem_ptr_type = + // llvm::cast<MemberPointerType>(qual_type.getTypePtr()); + // clang::QualType pointee_type = + // mem_ptr_type->getPointeeType(); + // + // if (ClangASTContext::IsAggregateType + // (pointee_type.getAsOpaquePtr())) + // { + // return GetIndexOfChildWithName (ast, + // mem_ptr_type->getPointeeType().getAsOpaquePtr(), + // name); + // } + // } + // break; + // + case clang::Type::LValueReference: + case clang::Type::RValueReference: { + const clang::ReferenceType *reference_type = + llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); + clang::QualType pointee_type(reference_type->getPointeeType()); + CompilerType pointee_clang_type(getASTContext(), pointee_type); + + if (pointee_clang_type.IsAggregateType()) { + return pointee_clang_type.GetIndexOfChildMemberWithName( + name, omit_empty_base_classes, child_indexes); + } + } break; + + case clang::Type::Pointer: { + CompilerType pointee_clang_type(GetPointeeType(type)); + + if (pointee_clang_type.IsAggregateType()) { + return pointee_clang_type.GetIndexOfChildMemberWithName( + name, omit_empty_base_classes, child_indexes); + } + } break; + + case clang::Type::Typedef: + return CompilerType(getASTContext(), + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()) + .GetIndexOfChildMemberWithName(name, omit_empty_base_classes, + child_indexes); + + case clang::Type::Auto: + return CompilerType( + getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()) + .GetIndexOfChildMemberWithName(name, omit_empty_base_classes, + child_indexes); + + case clang::Type::Elaborated: + return CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()) + .GetIndexOfChildMemberWithName(name, omit_empty_base_classes, + child_indexes); + + case clang::Type::Paren: + return CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar()) + .GetIndexOfChildMemberWithName(name, omit_empty_base_classes, + child_indexes); + + default: + break; } - return 0; + } + return 0; } - // Get the index of the child of "clang_type" whose name matches. This function // doesn't descend into the children, but only looks one level deep and name // matches can include base class names. uint32_t -ClangASTContext::GetIndexOfChildWithName (lldb::opaque_compiler_type_t type, const char *name, bool omit_empty_base_classes) -{ - if (type && name && name[0]) - { - clang::QualType qual_type(GetCanonicalQualType(type)); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - - assert(record_decl); - uint32_t child_idx = 0; - - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - - if (cxx_record_decl) - { - clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; - for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); - base_class != base_class_end; - ++base_class) - { - // Skip empty base classes - clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl()); - if (omit_empty_base_classes && ClangASTContext::RecordHasFields(base_class_decl) == false) - continue; - - CompilerType base_class_clang_type (getASTContext(), base_class->getType()); - std::string base_class_type_name (base_class_clang_type.GetTypeName().AsCString("")); - if (base_class_type_name.compare (name) == 0) - return child_idx; - ++child_idx; - } - } - - // Try and find a field that matches NAME - clang::RecordDecl::field_iterator field, field_end; - llvm::StringRef name_sref(name); - for (field = record_decl->field_begin(), field_end = record_decl->field_end(); - field != field_end; - ++field, ++child_idx) - { - if (field->getName().equals (name_sref)) - return child_idx; - } - - } - break; - - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - if (GetCompleteType(type)) - { - llvm::StringRef name_sref(name); - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); - assert (objc_class_type); - if (objc_class_type) - { - uint32_t child_idx = 0; - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - - if (class_interface_decl) - { - clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); - clang::ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); - - for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx) - { - const clang::ObjCIvarDecl* ivar_decl = *ivar_pos; - - if (ivar_decl->getName().equals (name_sref)) - { - if ((!omit_empty_base_classes && superclass_interface_decl) || - ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true))) - ++child_idx; - - return child_idx; - } - } - - if (superclass_interface_decl) - { - if (superclass_interface_decl->getName().equals (name_sref)) - return 0; - } - } - } - } - break; - - case clang::Type::ObjCObjectPointer: - { - CompilerType pointee_clang_type (getASTContext(), llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()); - return pointee_clang_type.GetIndexOfChildWithName (name, omit_empty_base_classes); - } - break; - - case clang::Type::ConstantArray: - { - // const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr()); - // const uint64_t element_count = array->getSize().getLimitedValue(); - // - // if (idx < element_count) - // { - // std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType()); - // - // char element_name[32]; - // ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx); - // - // child_name.assign(element_name); - // assert(field_type_info.first % 8 == 0); - // child_byte_size = field_type_info.first / 8; - // child_byte_offset = idx * child_byte_size; - // return array->getElementType().getAsOpaquePtr(); - // } - } - break; - - // case clang::Type::MemberPointerType: - // { - // MemberPointerType *mem_ptr_type = llvm::cast<MemberPointerType>(qual_type.getTypePtr()); - // clang::QualType pointee_type = mem_ptr_type->getPointeeType(); - // - // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) - // { - // return GetIndexOfChildWithName (ast, - // mem_ptr_type->getPointeeType().getAsOpaquePtr(), - // name); - // } - // } - // break; - // - case clang::Type::LValueReference: - case clang::Type::RValueReference: - { - const clang::ReferenceType *reference_type = llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); - CompilerType pointee_type (getASTContext(), reference_type->getPointeeType()); - - if (pointee_type.IsAggregateType ()) - { - return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes); - } - } - break; - - case clang::Type::Pointer: - { - const clang::PointerType *pointer_type = llvm::cast<clang::PointerType>(qual_type.getTypePtr()); - CompilerType pointee_type (getASTContext(), pointer_type->getPointeeType()); - - if (pointee_type.IsAggregateType ()) - { - return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes); - } - else - { - // if (parent_name) - // { - // child_name.assign(1, '*'); - // child_name += parent_name; - // } - // - // // We have a pointer to an simple type - // if (idx == 0) - // { - // std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type); - // assert(clang_type_info.first % 8 == 0); - // child_byte_size = clang_type_info.first / 8; - // child_byte_offset = 0; - // return pointee_type.getAsOpaquePtr(); - // } - } - } - break; +ClangASTContext::GetIndexOfChildWithName(lldb::opaque_compiler_type_t type, + const char *name, + bool omit_empty_base_classes) { + if (type && name && name[0]) { + clang::QualType qual_type(GetCanonicalQualType(type)); - case clang::Type::Auto: - return CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).GetIndexOfChildWithName (name, omit_empty_base_classes); - - case clang::Type::Elaborated: - return CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildWithName (name, omit_empty_base_classes); - - case clang::Type::Paren: - return CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildWithName (name, omit_empty_base_classes); - - case clang::Type::Typedef: - return CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildWithName (name, omit_empty_base_classes); - - default: - break; + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + + assert(record_decl); + uint32_t child_idx = 0; + + const clang::CXXRecordDecl *cxx_record_decl = + llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); + + if (cxx_record_decl) { + clang::CXXRecordDecl::base_class_const_iterator base_class, + base_class_end; + for (base_class = cxx_record_decl->bases_begin(), + base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; ++base_class) { + // Skip empty base classes + clang::CXXRecordDecl *base_class_decl = + llvm::cast<clang::CXXRecordDecl>( + base_class->getType() + ->getAs<clang::RecordType>() + ->getDecl()); + if (omit_empty_base_classes && + ClangASTContext::RecordHasFields(base_class_decl) == false) + continue; + + CompilerType base_class_clang_type(getASTContext(), + base_class->getType()); + std::string base_class_type_name( + base_class_clang_type.GetTypeName().AsCString("")); + if (base_class_type_name.compare(name) == 0) + return child_idx; + ++child_idx; + } } - } - return UINT32_MAX; -} + // Try and find a field that matches NAME + clang::RecordDecl::field_iterator field, field_end; + llvm::StringRef name_sref(name); + for (field = record_decl->field_begin(), + field_end = record_decl->field_end(); + field != field_end; ++field, ++child_idx) { + if (field->getName().equals(name_sref)) + return child_idx; + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (GetCompleteType(type)) { + llvm::StringRef name_sref(name); + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); + assert(objc_class_type); + if (objc_class_type) { + uint32_t child_idx = 0; + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + + if (class_interface_decl) { + clang::ObjCInterfaceDecl::ivar_iterator ivar_pos, + ivar_end = class_interface_decl->ivar_end(); + clang::ObjCInterfaceDecl *superclass_interface_decl = + class_interface_decl->getSuperClass(); + + for (ivar_pos = class_interface_decl->ivar_begin(); + ivar_pos != ivar_end; ++ivar_pos, ++child_idx) { + const clang::ObjCIvarDecl *ivar_decl = *ivar_pos; + + if (ivar_decl->getName().equals(name_sref)) { + if ((!omit_empty_base_classes && superclass_interface_decl) || + (omit_empty_base_classes && + ObjCDeclHasIVars(superclass_interface_decl, true))) + ++child_idx; -size_t -ClangASTContext::GetNumTemplateArguments (lldb::opaque_compiler_type_t type) -{ - if (!type) - return 0; + return child_idx; + } + } - clang::QualType qual_type (GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - { - const clang::ClassTemplateSpecializationDecl *template_decl = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(cxx_record_decl); - if (template_decl) - return template_decl->getTemplateArgs().size(); - } + if (superclass_interface_decl) { + if (superclass_interface_decl->getName().equals(name_sref)) + return 0; } - break; - - case clang::Type::Typedef: - return (CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType())).GetNumTemplateArguments(); - - case clang::Type::Auto: - return (CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType())).GetNumTemplateArguments(); - - case clang::Type::Elaborated: - return (CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())).GetNumTemplateArguments(); - - case clang::Type::Paren: - return (CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar())).GetNumTemplateArguments(); - - default: - break; - } + } + } + } + break; + + case clang::Type::ObjCObjectPointer: { + CompilerType pointee_clang_type( + getASTContext(), + llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr()) + ->getPointeeType()); + return pointee_clang_type.GetIndexOfChildWithName( + name, omit_empty_base_classes); + } break; + + case clang::Type::ConstantArray: { + // const clang::ConstantArrayType *array = + // llvm::cast<clang::ConstantArrayType>(parent_qual_type.getTypePtr()); + // const uint64_t element_count = + // array->getSize().getLimitedValue(); + // + // if (idx < element_count) + // { + // std::pair<uint64_t, unsigned> field_type_info = + // ast->getTypeInfo(array->getElementType()); + // + // char element_name[32]; + // ::snprintf (element_name, sizeof (element_name), + // "%s[%u]", parent_name ? parent_name : "", idx); + // + // child_name.assign(element_name); + // assert(field_type_info.first % 8 == 0); + // child_byte_size = field_type_info.first / 8; + // child_byte_offset = idx * child_byte_size; + // return array->getElementType().getAsOpaquePtr(); + // } + } break; + + // case clang::Type::MemberPointerType: + // { + // MemberPointerType *mem_ptr_type = + // llvm::cast<MemberPointerType>(qual_type.getTypePtr()); + // clang::QualType pointee_type = + // mem_ptr_type->getPointeeType(); + // + // if (ClangASTContext::IsAggregateType + // (pointee_type.getAsOpaquePtr())) + // { + // return GetIndexOfChildWithName (ast, + // mem_ptr_type->getPointeeType().getAsOpaquePtr(), + // name); + // } + // } + // break; + // + case clang::Type::LValueReference: + case clang::Type::RValueReference: { + const clang::ReferenceType *reference_type = + llvm::cast<clang::ReferenceType>(qual_type.getTypePtr()); + CompilerType pointee_type(getASTContext(), + reference_type->getPointeeType()); + + if (pointee_type.IsAggregateType()) { + return pointee_type.GetIndexOfChildWithName(name, + omit_empty_base_classes); + } + } break; + + case clang::Type::Pointer: { + const clang::PointerType *pointer_type = + llvm::cast<clang::PointerType>(qual_type.getTypePtr()); + CompilerType pointee_type(getASTContext(), + pointer_type->getPointeeType()); + + if (pointee_type.IsAggregateType()) { + return pointee_type.GetIndexOfChildWithName(name, + omit_empty_base_classes); + } else { + // if (parent_name) + // { + // child_name.assign(1, '*'); + // child_name += parent_name; + // } + // + // // We have a pointer to an simple type + // if (idx == 0) + // { + // std::pair<uint64_t, unsigned> clang_type_info + // = ast->getTypeInfo(pointee_type); + // assert(clang_type_info.first % 8 == 0); + // child_byte_size = clang_type_info.first / 8; + // child_byte_offset = 0; + // return pointee_type.getAsOpaquePtr(); + // } + } + } break; + + case clang::Type::Auto: + return CompilerType( + getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()) + .GetIndexOfChildWithName(name, omit_empty_base_classes); + + case clang::Type::Elaborated: + return CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()) + .GetIndexOfChildWithName(name, omit_empty_base_classes); + + case clang::Type::Paren: + return CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar()) + .GetIndexOfChildWithName(name, omit_empty_base_classes); + + case clang::Type::Typedef: + return CompilerType(getASTContext(), + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType()) + .GetIndexOfChildWithName(name, omit_empty_base_classes); - return 0; + default: + break; + } + } + return UINT32_MAX; } -CompilerType -ClangASTContext::GetTemplateArgument (lldb::opaque_compiler_type_t type, size_t arg_idx, lldb::TemplateArgumentKind &kind) -{ - if (!type) - return CompilerType(); +size_t +ClangASTContext::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) { + if (!type) + return 0; - clang::QualType qual_type (GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - { - const clang::ClassTemplateSpecializationDecl *template_decl = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(cxx_record_decl); - if (template_decl && arg_idx < template_decl->getTemplateArgs().size()) - { - const clang::TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx]; - switch (template_arg.getKind()) - { - case clang::TemplateArgument::Null: - kind = eTemplateArgumentKindNull; - return CompilerType(); - - case clang::TemplateArgument::Type: - kind = eTemplateArgumentKindType; - return CompilerType(getASTContext(), template_arg.getAsType()); - - case clang::TemplateArgument::Declaration: - kind = eTemplateArgumentKindDeclaration; - return CompilerType(); - - case clang::TemplateArgument::Integral: - kind = eTemplateArgumentKindIntegral; - return CompilerType(getASTContext(), template_arg.getIntegralType()); - - case clang::TemplateArgument::Template: - kind = eTemplateArgumentKindTemplate; - return CompilerType(); - - case clang::TemplateArgument::TemplateExpansion: - kind = eTemplateArgumentKindTemplateExpansion; - return CompilerType(); - - case clang::TemplateArgument::Expression: - kind = eTemplateArgumentKindExpression; - return CompilerType(); - - case clang::TemplateArgument::Pack: - kind = eTemplateArgumentKindPack; - return CompilerType(); - - default: - assert (!"Unhandled clang::TemplateArgument::ArgKind"); - break; - } - } - } - } - break; - - case clang::Type::Typedef: - return (CompilerType (getASTContext(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType())).GetTemplateArgument(arg_idx, kind); - - case clang::Type::Auto: - return (CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType())).GetTemplateArgument(arg_idx, kind); - - case clang::Type::Elaborated: - return (CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())).GetTemplateArgument(arg_idx, kind); - - case clang::Type::Paren: - return (CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar())).GetTemplateArgument(arg_idx, kind); - - default: - break; - } - kind = eTemplateArgumentKindNull; - return CompilerType (); + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::CXXRecordDecl *cxx_record_decl = + qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) { + const clang::ClassTemplateSpecializationDecl *template_decl = + llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>( + cxx_record_decl); + if (template_decl) + return template_decl->getTemplateArgs().size(); + } + } + break; + + case clang::Type::Typedef: + return (CompilerType(getASTContext(), + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType())) + .GetNumTemplateArguments(); + + case clang::Type::Auto: + return (CompilerType( + getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType())) + .GetNumTemplateArguments(); + + case clang::Type::Elaborated: + return (CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())) + .GetNumTemplateArguments(); + + case clang::Type::Paren: + return (CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar())) + .GetNumTemplateArguments(); + + default: + break; + } + + return 0; } CompilerType -ClangASTContext::GetTypeForFormatters (void* type) -{ - if (type) - return ClangUtil::RemoveFastQualifiers(CompilerType(this, type)); +ClangASTContext::GetTemplateArgument(lldb::opaque_compiler_type_t type, + size_t arg_idx, + lldb::TemplateArgumentKind &kind) { + if (!type) return CompilerType(); -} -clang::EnumDecl * -ClangASTContext::GetAsEnumDecl (const CompilerType& type) -{ - const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(ClangUtil::GetCanonicalQualType(type)); - if (enutype) - return enutype->getDecl(); - return NULL; -} + clang::QualType qual_type(GetCanonicalQualType(type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::CXXRecordDecl *cxx_record_decl = + qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) { + const clang::ClassTemplateSpecializationDecl *template_decl = + llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>( + cxx_record_decl); + if (template_decl && + arg_idx < template_decl->getTemplateArgs().size()) { + const clang::TemplateArgument &template_arg = + template_decl->getTemplateArgs()[arg_idx]; + switch (template_arg.getKind()) { + case clang::TemplateArgument::Null: + kind = eTemplateArgumentKindNull; + return CompilerType(); -clang::RecordDecl * -ClangASTContext::GetAsRecordDecl (const CompilerType& type) -{ - const clang::RecordType *record_type = llvm::dyn_cast<clang::RecordType>(ClangUtil::GetCanonicalQualType(type)); - if (record_type) - return record_type->getDecl(); - return nullptr; -} + case clang::TemplateArgument::Type: + kind = eTemplateArgumentKindType; + return CompilerType(getASTContext(), template_arg.getAsType()); -clang::TagDecl * -ClangASTContext::GetAsTagDecl (const CompilerType& type) -{ - clang::QualType qual_type = ClangUtil::GetCanonicalQualType(type); - if (qual_type.isNull()) - return nullptr; - else - return qual_type->getAsTagDecl(); + case clang::TemplateArgument::Declaration: + kind = eTemplateArgumentKindDeclaration; + return CompilerType(); + + case clang::TemplateArgument::Integral: + kind = eTemplateArgumentKindIntegral; + return CompilerType(getASTContext(), + template_arg.getIntegralType()); + + case clang::TemplateArgument::Template: + kind = eTemplateArgumentKindTemplate; + return CompilerType(); + + case clang::TemplateArgument::TemplateExpansion: + kind = eTemplateArgumentKindTemplateExpansion; + return CompilerType(); + + case clang::TemplateArgument::Expression: + kind = eTemplateArgumentKindExpression; + return CompilerType(); + + case clang::TemplateArgument::Pack: + kind = eTemplateArgumentKindPack; + return CompilerType(); + + default: + assert(!"Unhandled clang::TemplateArgument::ArgKind"); + break; + } + } + } + } + break; + + case clang::Type::Typedef: + return (CompilerType(getASTContext(), + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType())) + .GetTemplateArgument(arg_idx, kind); + + case clang::Type::Auto: + return (CompilerType( + getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType())) + .GetTemplateArgument(arg_idx, kind); + + case clang::Type::Elaborated: + return (CompilerType( + getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())) + .GetTemplateArgument(arg_idx, kind); + + case clang::Type::Paren: + return (CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar())) + .GetTemplateArgument(arg_idx, kind); + + default: + break; + } + kind = eTemplateArgumentKindNull; + return CompilerType(); +} + +CompilerType ClangASTContext::GetTypeForFormatters(void *type) { + if (type) + return ClangUtil::RemoveFastQualifiers(CompilerType(this, type)); + return CompilerType(); +} + +clang::EnumDecl *ClangASTContext::GetAsEnumDecl(const CompilerType &type) { + const clang::EnumType *enutype = + llvm::dyn_cast<clang::EnumType>(ClangUtil::GetCanonicalQualType(type)); + if (enutype) + return enutype->getDecl(); + return NULL; +} + +clang::RecordDecl *ClangASTContext::GetAsRecordDecl(const CompilerType &type) { + const clang::RecordType *record_type = + llvm::dyn_cast<clang::RecordType>(ClangUtil::GetCanonicalQualType(type)); + if (record_type) + return record_type->getDecl(); + return nullptr; +} + +clang::TagDecl *ClangASTContext::GetAsTagDecl(const CompilerType &type) { + clang::QualType qual_type = ClangUtil::GetCanonicalQualType(type); + if (qual_type.isNull()) + return nullptr; + else + return qual_type->getAsTagDecl(); } clang::CXXRecordDecl * -ClangASTContext::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t type) -{ - return GetCanonicalQualType(type)->getAsCXXRecordDecl(); +ClangASTContext::GetAsCXXRecordDecl(lldb::opaque_compiler_type_t type) { + return GetCanonicalQualType(type)->getAsCXXRecordDecl(); } clang::ObjCInterfaceDecl * -ClangASTContext::GetAsObjCInterfaceDecl (const CompilerType& type) -{ - const clang::ObjCObjectType *objc_class_type = - llvm::dyn_cast<clang::ObjCObjectType>(ClangUtil::GetCanonicalQualType(type)); - if (objc_class_type) - return objc_class_type->getInterface(); +ClangASTContext::GetAsObjCInterfaceDecl(const CompilerType &type) { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>( + ClangUtil::GetCanonicalQualType(type)); + if (objc_class_type) + return objc_class_type->getInterface(); + return nullptr; +} + +clang::FieldDecl *ClangASTContext::AddFieldToRecordType( + const CompilerType &type, const char *name, + const CompilerType &field_clang_type, AccessType access, + uint32_t bitfield_bit_size) { + if (!type.IsValid() || !field_clang_type.IsValid()) return nullptr; -} + ClangASTContext *ast = + llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem()); + if (!ast) + return nullptr; + clang::ASTContext *clang_ast = ast->getASTContext(); + + clang::FieldDecl *field = nullptr; + + clang::Expr *bit_width = nullptr; + if (bitfield_bit_size != 0) { + llvm::APInt bitfield_bit_size_apint( + clang_ast->getTypeSize(clang_ast->IntTy), bitfield_bit_size); + bit_width = new (*clang_ast) + clang::IntegerLiteral(*clang_ast, bitfield_bit_size_apint, + clang_ast->IntTy, clang::SourceLocation()); + } + + clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type); + if (record_decl) { + field = clang::FieldDecl::Create( + *clang_ast, record_decl, clang::SourceLocation(), + clang::SourceLocation(), + name ? &clang_ast->Idents.get(name) : nullptr, // Identifier + ClangUtil::GetQualType(field_clang_type), // Field type + nullptr, // TInfo * + bit_width, // BitWidth + false, // Mutable + clang::ICIS_NoInit); // HasInit + + if (!name) { + // Determine whether this field corresponds to an anonymous + // struct or union. + if (const clang::TagType *TagT = + field->getType()->getAs<clang::TagType>()) { + if (clang::RecordDecl *Rec = + llvm::dyn_cast<clang::RecordDecl>(TagT->getDecl())) + if (!Rec->getDeclName()) { + Rec->setAnonymousStructOrUnion(true); + field->setImplicit(); + } + } + } + + if (field) { + field->setAccess( + ClangASTContext::ConvertAccessTypeToAccessSpecifier(access)); + + record_decl->addDecl(field); -clang::FieldDecl * -ClangASTContext::AddFieldToRecordType (const CompilerType& type, const char *name, - const CompilerType &field_clang_type, - AccessType access, - uint32_t bitfield_bit_size) -{ - if (!type.IsValid() || !field_clang_type.IsValid()) - return nullptr; - ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem()); - if (!ast) - return nullptr; - clang::ASTContext* clang_ast = ast->getASTContext(); - - clang::FieldDecl *field = nullptr; - - clang::Expr *bit_width = nullptr; - if (bitfield_bit_size != 0) - { - llvm::APInt bitfield_bit_size_apint(clang_ast->getTypeSize(clang_ast->IntTy), bitfield_bit_size); - bit_width = new (*clang_ast)clang::IntegerLiteral (*clang_ast, bitfield_bit_size_apint, clang_ast->IntTy, clang::SourceLocation()); - } - - clang::RecordDecl *record_decl = ast->GetAsRecordDecl (type); - if (record_decl) - { - field = clang::FieldDecl::Create(*clang_ast, record_decl, clang::SourceLocation(), clang::SourceLocation(), - name ? &clang_ast->Idents.get(name) : nullptr, // Identifier - ClangUtil::GetQualType(field_clang_type), // Field type - nullptr, // TInfo * - bit_width, // BitWidth - false, // Mutable - clang::ICIS_NoInit); // HasInit - - if (!name) - { - // Determine whether this field corresponds to an anonymous - // struct or union. - if (const clang::TagType *TagT = field->getType()->getAs<clang::TagType>()) { - if (clang::RecordDecl *Rec = llvm::dyn_cast<clang::RecordDecl>(TagT->getDecl())) - if (!Rec->getDeclName()) { - Rec->setAnonymousStructOrUnion(true); - field->setImplicit(); - - } - } - } - - if (field) - { - field->setAccess (ClangASTContext::ConvertAccessTypeToAccessSpecifier (access)); - - record_decl->addDecl(field); - #ifdef LLDB_CONFIGURATION_DEBUG - VerifyDecl(field); + VerifyDecl(field); #endif - } } - else - { - clang::ObjCInterfaceDecl *class_interface_decl = ast->GetAsObjCInterfaceDecl (type); - - if (class_interface_decl) - { - const bool is_synthesized = false; - - field_clang_type.GetCompleteType(); - - field = clang::ObjCIvarDecl::Create( - *clang_ast, class_interface_decl, clang::SourceLocation(), clang::SourceLocation(), - name ? &clang_ast->Idents.get(name) : nullptr, // Identifier - ClangUtil::GetQualType(field_clang_type), // Field type - nullptr, // TypeSourceInfo * - ConvertAccessTypeToObjCIvarAccessControl(access), bit_width, is_synthesized); - - if (field) - { - class_interface_decl->addDecl(field); - + } else { + clang::ObjCInterfaceDecl *class_interface_decl = + ast->GetAsObjCInterfaceDecl(type); + + if (class_interface_decl) { + const bool is_synthesized = false; + + field_clang_type.GetCompleteType(); + + field = clang::ObjCIvarDecl::Create( + *clang_ast, class_interface_decl, clang::SourceLocation(), + clang::SourceLocation(), + name ? &clang_ast->Idents.get(name) : nullptr, // Identifier + ClangUtil::GetQualType(field_clang_type), // Field type + nullptr, // TypeSourceInfo * + ConvertAccessTypeToObjCIvarAccessControl(access), bit_width, + is_synthesized); + + if (field) { + class_interface_decl->addDecl(field); + #ifdef LLDB_CONFIGURATION_DEBUG - VerifyDecl(field); + VerifyDecl(field); #endif - } + } + } + } + return field; +} + +void ClangASTContext::BuildIndirectFields(const CompilerType &type) { + if (!type) + return; + + ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); + if (!ast) + return; + + clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type); + + if (!record_decl) + return; + + typedef llvm::SmallVector<clang::IndirectFieldDecl *, 1> IndirectFieldVector; + + IndirectFieldVector indirect_fields; + clang::RecordDecl::field_iterator field_pos; + clang::RecordDecl::field_iterator field_end_pos = record_decl->field_end(); + clang::RecordDecl::field_iterator last_field_pos = field_end_pos; + for (field_pos = record_decl->field_begin(); field_pos != field_end_pos; + last_field_pos = field_pos++) { + if (field_pos->isAnonymousStructOrUnion()) { + clang::QualType field_qual_type = field_pos->getType(); + + const clang::RecordType *field_record_type = + field_qual_type->getAs<clang::RecordType>(); + + if (!field_record_type) + continue; + + clang::RecordDecl *field_record_decl = field_record_type->getDecl(); + + if (!field_record_decl) + continue; + + for (clang::RecordDecl::decl_iterator + di = field_record_decl->decls_begin(), + de = field_record_decl->decls_end(); + di != de; ++di) { + if (clang::FieldDecl *nested_field_decl = + llvm::dyn_cast<clang::FieldDecl>(*di)) { + clang::NamedDecl **chain = + new (*ast->getASTContext()) clang::NamedDecl *[2]; + chain[0] = *field_pos; + chain[1] = nested_field_decl; + clang::IndirectFieldDecl *indirect_field = + clang::IndirectFieldDecl::Create( + *ast->getASTContext(), record_decl, clang::SourceLocation(), + nested_field_decl->getIdentifier(), + nested_field_decl->getType(), {chain, 2}); + + indirect_field->setImplicit(); + + indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers( + field_pos->getAccess(), nested_field_decl->getAccess())); + + indirect_fields.push_back(indirect_field); + } else if (clang::IndirectFieldDecl *nested_indirect_field_decl = + llvm::dyn_cast<clang::IndirectFieldDecl>(*di)) { + size_t nested_chain_size = + nested_indirect_field_decl->getChainingSize(); + clang::NamedDecl **chain = new (*ast->getASTContext()) + clang::NamedDecl *[nested_chain_size + 1]; + chain[0] = *field_pos; + + int chain_index = 1; + for (clang::IndirectFieldDecl::chain_iterator + nci = nested_indirect_field_decl->chain_begin(), + nce = nested_indirect_field_decl->chain_end(); + nci < nce; ++nci) { + chain[chain_index] = *nci; + chain_index++; + } + + clang::IndirectFieldDecl *indirect_field = + clang::IndirectFieldDecl::Create( + *ast->getASTContext(), record_decl, clang::SourceLocation(), + nested_indirect_field_decl->getIdentifier(), + nested_indirect_field_decl->getType(), + {chain, nested_chain_size + 1}); + + indirect_field->setImplicit(); + + indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers( + field_pos->getAccess(), nested_indirect_field_decl->getAccess())); + + indirect_fields.push_back(indirect_field); } + } } - return field; + } + + // Check the last field to see if it has an incomplete array type as its + // last member and if it does, the tell the record decl about it + if (last_field_pos != field_end_pos) { + if (last_field_pos->getType()->isIncompleteArrayType()) + record_decl->hasFlexibleArrayMember(); + } + + for (IndirectFieldVector::iterator ifi = indirect_fields.begin(), + ife = indirect_fields.end(); + ifi < ife; ++ifi) { + record_decl->addDecl(*ifi); + } } -void -ClangASTContext::BuildIndirectFields (const CompilerType& type) -{ - if (!type) - return; +void ClangASTContext::SetIsPacked(const CompilerType &type) { + if (type) { + ClangASTContext *ast = + llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); + if (ast) { + clang::RecordDecl *record_decl = GetAsRecordDecl(type); - ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); - if (!ast) + if (!record_decl) return; - clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type); - - if (!record_decl) - return; - - typedef llvm::SmallVector <clang::IndirectFieldDecl *, 1> IndirectFieldVector; - - IndirectFieldVector indirect_fields; - clang::RecordDecl::field_iterator field_pos; - clang::RecordDecl::field_iterator field_end_pos = record_decl->field_end(); - clang::RecordDecl::field_iterator last_field_pos = field_end_pos; - for (field_pos = record_decl->field_begin(); field_pos != field_end_pos; last_field_pos = field_pos++) - { - if (field_pos->isAnonymousStructOrUnion()) - { - clang::QualType field_qual_type = field_pos->getType(); - - const clang::RecordType *field_record_type = field_qual_type->getAs<clang::RecordType>(); - - if (!field_record_type) - continue; - - clang::RecordDecl *field_record_decl = field_record_type->getDecl(); - - if (!field_record_decl) - continue; - - for (clang::RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end(); - di != de; - ++di) - { - if (clang::FieldDecl *nested_field_decl = llvm::dyn_cast<clang::FieldDecl>(*di)) - { - clang::NamedDecl **chain = new (*ast->getASTContext()) clang::NamedDecl*[2]; - chain[0] = *field_pos; - chain[1] = nested_field_decl; - clang::IndirectFieldDecl *indirect_field = clang::IndirectFieldDecl::Create(*ast->getASTContext(), - record_decl, - clang::SourceLocation(), - nested_field_decl->getIdentifier(), - nested_field_decl->getType(), - {chain, 2}); - - indirect_field->setImplicit(); - - indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(), - nested_field_decl->getAccess())); - - indirect_fields.push_back(indirect_field); - } - else if (clang::IndirectFieldDecl *nested_indirect_field_decl = llvm::dyn_cast<clang::IndirectFieldDecl>(*di)) - { - size_t nested_chain_size = nested_indirect_field_decl->getChainingSize(); - clang::NamedDecl **chain = new (*ast->getASTContext()) clang::NamedDecl*[nested_chain_size + 1]; - chain[0] = *field_pos; - - int chain_index = 1; - for (clang::IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(), - nce = nested_indirect_field_decl->chain_end(); - nci < nce; - ++nci) - { - chain[chain_index] = *nci; - chain_index++; - } - - clang::IndirectFieldDecl *indirect_field = clang::IndirectFieldDecl::Create(*ast->getASTContext(), - record_decl, - clang::SourceLocation(), - nested_indirect_field_decl->getIdentifier(), - nested_indirect_field_decl->getType(), - {chain, nested_chain_size + 1}); - - indirect_field->setImplicit(); - - indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(), - nested_indirect_field_decl->getAccess())); - - indirect_fields.push_back(indirect_field); - } - } - } - } - - // Check the last field to see if it has an incomplete array type as its - // last member and if it does, the tell the record decl about it - if (last_field_pos != field_end_pos) - { - if (last_field_pos->getType()->isIncompleteArrayType()) - record_decl->hasFlexibleArrayMember(); - } - - for (IndirectFieldVector::iterator ifi = indirect_fields.begin(), ife = indirect_fields.end(); - ifi < ife; - ++ifi) - { - record_decl->addDecl(*ifi); - } -} - -void -ClangASTContext::SetIsPacked (const CompilerType& type) -{ - if (type) - { - ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); - if (ast) - { - clang::RecordDecl *record_decl = GetAsRecordDecl(type); - - if (!record_decl) - return; - - record_decl->addAttr(clang::PackedAttr::CreateImplicit(*ast->getASTContext())); - } + record_decl->addAttr( + clang::PackedAttr::CreateImplicit(*ast->getASTContext())); } + } } -clang::VarDecl * -ClangASTContext::AddVariableToRecordType (const CompilerType& type, const char *name, - const CompilerType &var_type, - AccessType access) -{ - clang::VarDecl *var_decl = nullptr; - - if (!type.IsValid() || !var_type.IsValid()) - return nullptr; - ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); - if (!ast) - return nullptr; - - clang::RecordDecl *record_decl = ast->GetAsRecordDecl (type); - if (record_decl) - { - var_decl = - clang::VarDecl::Create(*ast->getASTContext(), // ASTContext & - record_decl, // DeclContext * - clang::SourceLocation(), // clang::SourceLocation StartLoc - clang::SourceLocation(), // clang::SourceLocation IdLoc - name ? &ast->getASTContext()->Idents.get(name) : nullptr, // clang::IdentifierInfo * - ClangUtil::GetQualType(var_type), // Variable clang::QualType - nullptr, // TypeSourceInfo * - clang::SC_Static); // StorageClass - if (var_decl) - { - var_decl->setAccess(ClangASTContext::ConvertAccessTypeToAccessSpecifier (access)); - record_decl->addDecl(var_decl); - +clang::VarDecl *ClangASTContext::AddVariableToRecordType( + const CompilerType &type, const char *name, const CompilerType &var_type, + AccessType access) { + clang::VarDecl *var_decl = nullptr; + + if (!type.IsValid() || !var_type.IsValid()) + return nullptr; + ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); + if (!ast) + return nullptr; + + clang::RecordDecl *record_decl = ast->GetAsRecordDecl(type); + if (record_decl) { + var_decl = clang::VarDecl::Create( + *ast->getASTContext(), // ASTContext & + record_decl, // DeclContext * + clang::SourceLocation(), // clang::SourceLocation StartLoc + clang::SourceLocation(), // clang::SourceLocation IdLoc + name ? &ast->getASTContext()->Idents.get(name) + : nullptr, // clang::IdentifierInfo * + ClangUtil::GetQualType(var_type), // Variable clang::QualType + nullptr, // TypeSourceInfo * + clang::SC_Static); // StorageClass + if (var_decl) { + var_decl->setAccess( + ClangASTContext::ConvertAccessTypeToAccessSpecifier(access)); + record_decl->addDecl(var_decl); + #ifdef LLDB_CONFIGURATION_DEBUG - VerifyDecl(var_decl); + VerifyDecl(var_decl); #endif - } } - return var_decl; + } + return var_decl; } +clang::CXXMethodDecl *ClangASTContext::AddMethodToCXXRecordType( + lldb::opaque_compiler_type_t type, const char *name, + const CompilerType &method_clang_type, lldb::AccessType access, + bool is_virtual, bool is_static, bool is_inline, bool is_explicit, + bool is_attr_used, bool is_artificial) { + if (!type || !method_clang_type.IsValid() || name == nullptr || + name[0] == '\0') + return nullptr; + + clang::QualType record_qual_type(GetCanonicalQualType(type)); + + clang::CXXRecordDecl *cxx_record_decl = + record_qual_type->getAsCXXRecordDecl(); + + if (cxx_record_decl == nullptr) + return nullptr; + + clang::QualType method_qual_type(ClangUtil::GetQualType(method_clang_type)); + + clang::CXXMethodDecl *cxx_method_decl = nullptr; + + clang::DeclarationName decl_name(&getASTContext()->Idents.get(name)); + + const clang::FunctionType *function_type = + llvm::dyn_cast<clang::FunctionType>(method_qual_type.getTypePtr()); + + if (function_type == nullptr) + return nullptr; + + const clang::FunctionProtoType *method_function_prototype( + llvm::dyn_cast<clang::FunctionProtoType>(function_type)); + + if (!method_function_prototype) + return nullptr; + + unsigned int num_params = method_function_prototype->getNumParams(); + + clang::CXXDestructorDecl *cxx_dtor_decl(nullptr); + clang::CXXConstructorDecl *cxx_ctor_decl(nullptr); + + if (is_artificial) + return nullptr; // skip everything artificial + + if (name[0] == '~') { + cxx_dtor_decl = clang::CXXDestructorDecl::Create( + *getASTContext(), cxx_record_decl, clang::SourceLocation(), + clang::DeclarationNameInfo( + getASTContext()->DeclarationNames.getCXXDestructorName( + getASTContext()->getCanonicalType(record_qual_type)), + clang::SourceLocation()), + method_qual_type, nullptr, is_inline, is_artificial); + cxx_method_decl = cxx_dtor_decl; + } else if (decl_name == cxx_record_decl->getDeclName()) { + cxx_ctor_decl = clang::CXXConstructorDecl::Create( + *getASTContext(), cxx_record_decl, clang::SourceLocation(), + clang::DeclarationNameInfo( + getASTContext()->DeclarationNames.getCXXConstructorName( + getASTContext()->getCanonicalType(record_qual_type)), + clang::SourceLocation()), + method_qual_type, + nullptr, // TypeSourceInfo * + is_explicit, is_inline, is_artificial, false /*is_constexpr*/); + cxx_method_decl = cxx_ctor_decl; + } else { + clang::StorageClass SC = is_static ? clang::SC_Static : clang::SC_None; + clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS; + + if (IsOperator(name, op_kind)) { + if (op_kind != clang::NUM_OVERLOADED_OPERATORS) { + // Check the number of operator parameters. Sometimes we have + // seen bad DWARF that doesn't correctly describe operators and + // if we try to create a method and add it to the class, clang + // will assert and crash, so we need to make sure things are + // acceptable. + const bool is_method = true; + if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount( + is_method, op_kind, num_params)) + return nullptr; + cxx_method_decl = clang::CXXMethodDecl::Create( + *getASTContext(), cxx_record_decl, clang::SourceLocation(), + clang::DeclarationNameInfo( + getASTContext()->DeclarationNames.getCXXOperatorName(op_kind), + clang::SourceLocation()), + method_qual_type, + nullptr, // TypeSourceInfo * + SC, is_inline, false /*is_constexpr*/, clang::SourceLocation()); + } else if (num_params == 0) { + // Conversion operators don't take params... + cxx_method_decl = clang::CXXConversionDecl::Create( + *getASTContext(), cxx_record_decl, clang::SourceLocation(), + clang::DeclarationNameInfo( + getASTContext()->DeclarationNames.getCXXConversionFunctionName( + getASTContext()->getCanonicalType( + function_type->getReturnType())), + clang::SourceLocation()), + method_qual_type, + nullptr, // TypeSourceInfo * + is_inline, is_explicit, false /*is_constexpr*/, + clang::SourceLocation()); + } + } + + if (cxx_method_decl == nullptr) { + cxx_method_decl = clang::CXXMethodDecl::Create( + *getASTContext(), cxx_record_decl, clang::SourceLocation(), + clang::DeclarationNameInfo(decl_name, clang::SourceLocation()), + method_qual_type, + nullptr, // TypeSourceInfo * + SC, is_inline, false /*is_constexpr*/, clang::SourceLocation()); + } + } + + clang::AccessSpecifier access_specifier = + ClangASTContext::ConvertAccessTypeToAccessSpecifier(access); + + cxx_method_decl->setAccess(access_specifier); + cxx_method_decl->setVirtualAsWritten(is_virtual); + + if (is_attr_used) + cxx_method_decl->addAttr(clang::UsedAttr::CreateImplicit(*getASTContext())); + + // Populate the method decl with parameter decls + + llvm::SmallVector<clang::ParmVarDecl *, 12> params; + + for (unsigned param_index = 0; param_index < num_params; ++param_index) { + params.push_back(clang::ParmVarDecl::Create( + *getASTContext(), cxx_method_decl, clang::SourceLocation(), + clang::SourceLocation(), + nullptr, // anonymous + method_function_prototype->getParamType(param_index), nullptr, + clang::SC_None, nullptr)); + } + + cxx_method_decl->setParams(llvm::ArrayRef<clang::ParmVarDecl *>(params)); + + cxx_record_decl->addDecl(cxx_method_decl); + + // Sometimes the debug info will mention a constructor (default/copy/move), + // destructor, or assignment operator (copy/move) but there won't be any + // version of this in the code. So we check if the function was artificially + // generated and if it is trivial and this lets the compiler/backend know + // that it can inline the IR for these when it needs to and we can avoid a + // "missing function" error when running expressions. + + if (is_artificial) { + if (cxx_ctor_decl && ((cxx_ctor_decl->isDefaultConstructor() && + cxx_record_decl->hasTrivialDefaultConstructor()) || + (cxx_ctor_decl->isCopyConstructor() && + cxx_record_decl->hasTrivialCopyConstructor()) || + (cxx_ctor_decl->isMoveConstructor() && + cxx_record_decl->hasTrivialMoveConstructor()))) { + cxx_ctor_decl->setDefaulted(); + cxx_ctor_decl->setTrivial(true); + } else if (cxx_dtor_decl) { + if (cxx_record_decl->hasTrivialDestructor()) { + cxx_dtor_decl->setDefaulted(); + cxx_dtor_decl->setTrivial(true); + } + } else if ((cxx_method_decl->isCopyAssignmentOperator() && + cxx_record_decl->hasTrivialCopyAssignment()) || + (cxx_method_decl->isMoveAssignmentOperator() && + cxx_record_decl->hasTrivialMoveAssignment())) { + cxx_method_decl->setDefaulted(); + cxx_method_decl->setTrivial(true); + } + } -clang::CXXMethodDecl * -ClangASTContext::AddMethodToCXXRecordType (lldb::opaque_compiler_type_t type, const char *name, - const CompilerType &method_clang_type, - lldb::AccessType access, - bool is_virtual, - bool is_static, - bool is_inline, - bool is_explicit, - bool is_attr_used, - bool is_artificial) -{ - if (!type || !method_clang_type.IsValid() || name == nullptr || name[0] == '\0') - return nullptr; - - clang::QualType record_qual_type(GetCanonicalQualType(type)); - - clang::CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl(); - - if (cxx_record_decl == nullptr) - return nullptr; - - clang::QualType method_qual_type(ClangUtil::GetQualType(method_clang_type)); - - clang::CXXMethodDecl *cxx_method_decl = nullptr; - - clang::DeclarationName decl_name (&getASTContext()->Idents.get(name)); - - const clang::FunctionType *function_type = llvm::dyn_cast<clang::FunctionType>(method_qual_type.getTypePtr()); - - if (function_type == nullptr) - return nullptr; - - const clang::FunctionProtoType *method_function_prototype (llvm::dyn_cast<clang::FunctionProtoType>(function_type)); - - if (!method_function_prototype) - return nullptr; - - unsigned int num_params = method_function_prototype->getNumParams(); - - clang::CXXDestructorDecl *cxx_dtor_decl(nullptr); - clang::CXXConstructorDecl *cxx_ctor_decl(nullptr); - - if (is_artificial) - return nullptr; // skip everything artificial - - if (name[0] == '~') - { - cxx_dtor_decl = clang::CXXDestructorDecl::Create (*getASTContext(), - cxx_record_decl, - clang::SourceLocation(), - clang::DeclarationNameInfo (getASTContext()->DeclarationNames.getCXXDestructorName (getASTContext()->getCanonicalType (record_qual_type)), clang::SourceLocation()), - method_qual_type, - nullptr, - is_inline, - is_artificial); - cxx_method_decl = cxx_dtor_decl; - } - else if (decl_name == cxx_record_decl->getDeclName()) - { - cxx_ctor_decl = clang::CXXConstructorDecl::Create (*getASTContext(), - cxx_record_decl, - clang::SourceLocation(), - clang::DeclarationNameInfo (getASTContext()->DeclarationNames.getCXXConstructorName (getASTContext()->getCanonicalType (record_qual_type)), clang::SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - is_explicit, - is_inline, - is_artificial, - false /*is_constexpr*/); - cxx_method_decl = cxx_ctor_decl; - } - else - { - clang::StorageClass SC = is_static ? clang::SC_Static : clang::SC_None; - clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS; - - if (IsOperator (name, op_kind)) - { - if (op_kind != clang::NUM_OVERLOADED_OPERATORS) - { - // Check the number of operator parameters. Sometimes we have - // seen bad DWARF that doesn't correctly describe operators and - // if we try to create a method and add it to the class, clang - // will assert and crash, so we need to make sure things are - // acceptable. - const bool is_method = true; - if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount(is_method, op_kind, num_params)) - return nullptr; - cxx_method_decl = clang::CXXMethodDecl::Create (*getASTContext(), - cxx_record_decl, - clang::SourceLocation(), - clang::DeclarationNameInfo (getASTContext()->DeclarationNames.getCXXOperatorName (op_kind), clang::SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - SC, - is_inline, - false /*is_constexpr*/, - clang::SourceLocation()); - } - else if (num_params == 0) - { - // Conversion operators don't take params... - cxx_method_decl = clang::CXXConversionDecl::Create (*getASTContext(), - cxx_record_decl, - clang::SourceLocation(), - clang::DeclarationNameInfo (getASTContext()->DeclarationNames.getCXXConversionFunctionName (getASTContext()->getCanonicalType (function_type->getReturnType())), clang::SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - is_inline, - is_explicit, - false /*is_constexpr*/, - clang::SourceLocation()); - } - } - - if (cxx_method_decl == nullptr) - { - cxx_method_decl = clang::CXXMethodDecl::Create (*getASTContext(), - cxx_record_decl, - clang::SourceLocation(), - clang::DeclarationNameInfo (decl_name, clang::SourceLocation()), - method_qual_type, - nullptr, // TypeSourceInfo * - SC, - is_inline, - false /*is_constexpr*/, - clang::SourceLocation()); - } - } - - clang::AccessSpecifier access_specifier = ClangASTContext::ConvertAccessTypeToAccessSpecifier (access); - - cxx_method_decl->setAccess (access_specifier); - cxx_method_decl->setVirtualAsWritten (is_virtual); - - if (is_attr_used) - cxx_method_decl->addAttr(clang::UsedAttr::CreateImplicit(*getASTContext())); - - // Populate the method decl with parameter decls - - llvm::SmallVector<clang::ParmVarDecl *, 12> params; - - for (unsigned param_index = 0; - param_index < num_params; - ++param_index) - { - params.push_back (clang::ParmVarDecl::Create (*getASTContext(), - cxx_method_decl, - clang::SourceLocation(), - clang::SourceLocation(), - nullptr, // anonymous - method_function_prototype->getParamType(param_index), - nullptr, - clang::SC_None, - nullptr)); - } - - cxx_method_decl->setParams (llvm::ArrayRef<clang::ParmVarDecl*>(params)); - - cxx_record_decl->addDecl (cxx_method_decl); - - // Sometimes the debug info will mention a constructor (default/copy/move), - // destructor, or assignment operator (copy/move) but there won't be any - // version of this in the code. So we check if the function was artificially - // generated and if it is trivial and this lets the compiler/backend know - // that it can inline the IR for these when it needs to and we can avoid a - // "missing function" error when running expressions. - - if (is_artificial) - { - if (cxx_ctor_decl && - ((cxx_ctor_decl->isDefaultConstructor() && cxx_record_decl->hasTrivialDefaultConstructor ()) || - (cxx_ctor_decl->isCopyConstructor() && cxx_record_decl->hasTrivialCopyConstructor ()) || - (cxx_ctor_decl->isMoveConstructor() && cxx_record_decl->hasTrivialMoveConstructor ()) )) - { - cxx_ctor_decl->setDefaulted(); - cxx_ctor_decl->setTrivial(true); - } - else if (cxx_dtor_decl) - { - if (cxx_record_decl->hasTrivialDestructor()) - { - cxx_dtor_decl->setDefaulted(); - cxx_dtor_decl->setTrivial(true); - } - } - else if ((cxx_method_decl->isCopyAssignmentOperator() && cxx_record_decl->hasTrivialCopyAssignment()) || - (cxx_method_decl->isMoveAssignmentOperator() && cxx_record_decl->hasTrivialMoveAssignment())) - { - cxx_method_decl->setDefaulted(); - cxx_method_decl->setTrivial(true); - } - } - #ifdef LLDB_CONFIGURATION_DEBUG - VerifyDecl(cxx_method_decl); + VerifyDecl(cxx_method_decl); #endif - - // printf ("decl->isPolymorphic() = %i\n", cxx_record_decl->isPolymorphic()); - // printf ("decl->isAggregate() = %i\n", cxx_record_decl->isAggregate()); - // printf ("decl->isPOD() = %i\n", cxx_record_decl->isPOD()); - // printf ("decl->isEmpty() = %i\n", cxx_record_decl->isEmpty()); - // printf ("decl->isAbstract() = %i\n", cxx_record_decl->isAbstract()); - // printf ("decl->hasTrivialConstructor() = %i\n", cxx_record_decl->hasTrivialConstructor()); - // printf ("decl->hasTrivialCopyConstructor() = %i\n", cxx_record_decl->hasTrivialCopyConstructor()); - // printf ("decl->hasTrivialCopyAssignment() = %i\n", cxx_record_decl->hasTrivialCopyAssignment()); - // printf ("decl->hasTrivialDestructor() = %i\n", cxx_record_decl->hasTrivialDestructor()); - return cxx_method_decl; -} + // printf ("decl->isPolymorphic() = %i\n", + // cxx_record_decl->isPolymorphic()); + // printf ("decl->isAggregate() = %i\n", + // cxx_record_decl->isAggregate()); + // printf ("decl->isPOD() = %i\n", + // cxx_record_decl->isPOD()); + // printf ("decl->isEmpty() = %i\n", + // cxx_record_decl->isEmpty()); + // printf ("decl->isAbstract() = %i\n", + // cxx_record_decl->isAbstract()); + // printf ("decl->hasTrivialConstructor() = %i\n", + // cxx_record_decl->hasTrivialConstructor()); + // printf ("decl->hasTrivialCopyConstructor() = %i\n", + // cxx_record_decl->hasTrivialCopyConstructor()); + // printf ("decl->hasTrivialCopyAssignment() = %i\n", + // cxx_record_decl->hasTrivialCopyAssignment()); + // printf ("decl->hasTrivialDestructor() = %i\n", + // cxx_record_decl->hasTrivialDestructor()); + return cxx_method_decl; +} #pragma mark C++ Base Classes clang::CXXBaseSpecifier * -ClangASTContext::CreateBaseClassSpecifier (lldb::opaque_compiler_type_t type, AccessType access, bool is_virtual, bool base_of_class) -{ - if (type) - return new clang::CXXBaseSpecifier (clang::SourceRange(), - is_virtual, - base_of_class, - ClangASTContext::ConvertAccessTypeToAccessSpecifier (access), - getASTContext()->getTrivialTypeSourceInfo (GetQualType(type)), - clang::SourceLocation()); - return nullptr; -} - -void -ClangASTContext::DeleteBaseClassSpecifiers (clang::CXXBaseSpecifier **base_classes, unsigned num_base_classes) -{ - for (unsigned i=0; i<num_base_classes; ++i) - { - delete base_classes[i]; - base_classes[i] = nullptr; - } -} +ClangASTContext::CreateBaseClassSpecifier(lldb::opaque_compiler_type_t type, + AccessType access, bool is_virtual, + bool base_of_class) { + if (type) + return new clang::CXXBaseSpecifier( + clang::SourceRange(), is_virtual, base_of_class, + ClangASTContext::ConvertAccessTypeToAccessSpecifier(access), + getASTContext()->getTrivialTypeSourceInfo(GetQualType(type)), + clang::SourceLocation()); + return nullptr; +} + +void ClangASTContext::DeleteBaseClassSpecifiers( + clang::CXXBaseSpecifier **base_classes, unsigned num_base_classes) { + for (unsigned i = 0; i < num_base_classes; ++i) { + delete base_classes[i]; + base_classes[i] = nullptr; + } +} + +bool ClangASTContext::SetBaseClassesForClassType( + lldb::opaque_compiler_type_t type, + clang::CXXBaseSpecifier const *const *base_classes, + unsigned num_base_classes) { + if (type) { + clang::CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl(type); + if (cxx_record_decl) { + cxx_record_decl->setBases(base_classes, num_base_classes); + return true; + } + } + return false; +} + +bool ClangASTContext::SetObjCSuperClass( + const CompilerType &type, const CompilerType &superclass_clang_type) { + ClangASTContext *ast = + llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem()); + if (!ast) + return false; + clang::ASTContext *clang_ast = ast->getASTContext(); + + if (type && superclass_clang_type.IsValid() && + superclass_clang_type.GetTypeSystem() == type.GetTypeSystem()) { + clang::ObjCInterfaceDecl *class_interface_decl = + GetAsObjCInterfaceDecl(type); + clang::ObjCInterfaceDecl *super_interface_decl = + GetAsObjCInterfaceDecl(superclass_clang_type); + if (class_interface_decl && super_interface_decl) { + class_interface_decl->setSuperClass(clang_ast->getTrivialTypeSourceInfo( + clang_ast->getObjCInterfaceType(super_interface_decl))); + return true; + } + } + return false; +} + +bool ClangASTContext::AddObjCClassProperty( + const CompilerType &type, const char *property_name, + const CompilerType &property_clang_type, clang::ObjCIvarDecl *ivar_decl, + const char *property_setter_name, const char *property_getter_name, + uint32_t property_attributes, ClangASTMetadata *metadata) { + if (!type || !property_clang_type.IsValid() || property_name == nullptr || + property_name[0] == '\0') + return false; + ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); + if (!ast) + return false; + clang::ASTContext *clang_ast = ast->getASTContext(); + + clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type); + + if (class_interface_decl) { + CompilerType property_clang_type_to_access; + + if (property_clang_type.IsValid()) + property_clang_type_to_access = property_clang_type; + else if (ivar_decl) + property_clang_type_to_access = + CompilerType(clang_ast, ivar_decl->getType()); + + if (class_interface_decl && property_clang_type_to_access.IsValid()) { + clang::TypeSourceInfo *prop_type_source; + if (ivar_decl) + prop_type_source = + clang_ast->getTrivialTypeSourceInfo(ivar_decl->getType()); + else + prop_type_source = clang_ast->getTrivialTypeSourceInfo( + ClangUtil::GetQualType(property_clang_type)); + + clang::ObjCPropertyDecl *property_decl = clang::ObjCPropertyDecl::Create( + *clang_ast, class_interface_decl, + clang::SourceLocation(), // Source Location + &clang_ast->Idents.get(property_name), + clang::SourceLocation(), // Source Location for AT + clang::SourceLocation(), // Source location for ( + ivar_decl ? ivar_decl->getType() + : ClangUtil::GetQualType(property_clang_type), + prop_type_source); + + if (property_decl) { + if (metadata) + ClangASTContext::SetMetadata(clang_ast, property_decl, *metadata); + + class_interface_decl->addDecl(property_decl); + + clang::Selector setter_sel, getter_sel; + + if (property_setter_name != nullptr) { + std::string property_setter_no_colon( + property_setter_name, strlen(property_setter_name) - 1); + clang::IdentifierInfo *setter_ident = + &clang_ast->Idents.get(property_setter_no_colon.c_str()); + setter_sel = clang_ast->Selectors.getSelector(1, &setter_ident); + } else if (!(property_attributes & DW_APPLE_PROPERTY_readonly)) { + std::string setter_sel_string("set"); + setter_sel_string.push_back(::toupper(property_name[0])); + setter_sel_string.append(&property_name[1]); + clang::IdentifierInfo *setter_ident = + &clang_ast->Idents.get(setter_sel_string.c_str()); + setter_sel = clang_ast->Selectors.getSelector(1, &setter_ident); + } + property_decl->setSetterName(setter_sel); + property_decl->setPropertyAttributes( + clang::ObjCPropertyDecl::OBJC_PR_setter); + + if (property_getter_name != nullptr) { + clang::IdentifierInfo *getter_ident = + &clang_ast->Idents.get(property_getter_name); + getter_sel = clang_ast->Selectors.getSelector(0, &getter_ident); + } else { + clang::IdentifierInfo *getter_ident = + &clang_ast->Idents.get(property_name); + getter_sel = clang_ast->Selectors.getSelector(0, &getter_ident); + } + property_decl->setGetterName(getter_sel); + property_decl->setPropertyAttributes( + clang::ObjCPropertyDecl::OBJC_PR_getter); + + if (ivar_decl) + property_decl->setPropertyIvarDecl(ivar_decl); + + if (property_attributes & DW_APPLE_PROPERTY_readonly) + property_decl->setPropertyAttributes( + clang::ObjCPropertyDecl::OBJC_PR_readonly); + if (property_attributes & DW_APPLE_PROPERTY_readwrite) + property_decl->setPropertyAttributes( + clang::ObjCPropertyDecl::OBJC_PR_readwrite); + if (property_attributes & DW_APPLE_PROPERTY_assign) + property_decl->setPropertyAttributes( + clang::ObjCPropertyDecl::OBJC_PR_assign); + if (property_attributes & DW_APPLE_PROPERTY_retain) + property_decl->setPropertyAttributes( + clang::ObjCPropertyDecl::OBJC_PR_retain); + if (property_attributes & DW_APPLE_PROPERTY_copy) + property_decl->setPropertyAttributes( + clang::ObjCPropertyDecl::OBJC_PR_copy); + if (property_attributes & DW_APPLE_PROPERTY_nonatomic) + property_decl->setPropertyAttributes( + clang::ObjCPropertyDecl::OBJC_PR_nonatomic); + if (property_attributes & clang::ObjCPropertyDecl::OBJC_PR_nullability) + property_decl->setPropertyAttributes( + clang::ObjCPropertyDecl::OBJC_PR_nullability); + if (property_attributes & + clang::ObjCPropertyDecl::OBJC_PR_null_resettable) + property_decl->setPropertyAttributes( + clang::ObjCPropertyDecl::OBJC_PR_null_resettable); + if (property_attributes & clang::ObjCPropertyDecl::OBJC_PR_class) + property_decl->setPropertyAttributes( + clang::ObjCPropertyDecl::OBJC_PR_class); + + const bool isInstance = + (property_attributes & clang::ObjCPropertyDecl::OBJC_PR_class) == 0; + + if (!getter_sel.isNull() && + !(isInstance + ? class_interface_decl->lookupInstanceMethod(getter_sel) + : class_interface_decl->lookupClassMethod(getter_sel))) { + const bool isVariadic = false; + const bool isSynthesized = false; + const bool isImplicitlyDeclared = true; + const bool isDefined = false; + const clang::ObjCMethodDecl::ImplementationControl impControl = + clang::ObjCMethodDecl::None; + const bool HasRelatedResultType = false; + + clang::ObjCMethodDecl *getter = clang::ObjCMethodDecl::Create( + *clang_ast, clang::SourceLocation(), clang::SourceLocation(), + getter_sel, ClangUtil::GetQualType(property_clang_type_to_access), + nullptr, class_interface_decl, isInstance, isVariadic, + isSynthesized, isImplicitlyDeclared, isDefined, impControl, + HasRelatedResultType); + + if (getter && metadata) + ClangASTContext::SetMetadata(clang_ast, getter, *metadata); + + if (getter) { + getter->setMethodParams(*clang_ast, + llvm::ArrayRef<clang::ParmVarDecl *>(), + llvm::ArrayRef<clang::SourceLocation>()); + + class_interface_decl->addDecl(getter); + } + } -bool -ClangASTContext::SetBaseClassesForClassType (lldb::opaque_compiler_type_t type, clang::CXXBaseSpecifier const * const *base_classes, - unsigned num_base_classes) -{ - if (type) - { - clang::CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl(type); - if (cxx_record_decl) - { - cxx_record_decl->setBases(base_classes, num_base_classes); - return true; + if (!setter_sel.isNull() && + !(isInstance + ? class_interface_decl->lookupInstanceMethod(setter_sel) + : class_interface_decl->lookupClassMethod(setter_sel))) { + clang::QualType result_type = clang_ast->VoidTy; + const bool isVariadic = false; + const bool isSynthesized = false; + const bool isImplicitlyDeclared = true; + const bool isDefined = false; + const clang::ObjCMethodDecl::ImplementationControl impControl = + clang::ObjCMethodDecl::None; + const bool HasRelatedResultType = false; + + clang::ObjCMethodDecl *setter = clang::ObjCMethodDecl::Create( + *clang_ast, clang::SourceLocation(), clang::SourceLocation(), + setter_sel, result_type, nullptr, class_interface_decl, + isInstance, isVariadic, isSynthesized, isImplicitlyDeclared, + isDefined, impControl, HasRelatedResultType); + + if (setter && metadata) + ClangASTContext::SetMetadata(clang_ast, setter, *metadata); + + llvm::SmallVector<clang::ParmVarDecl *, 1> params; + + params.push_back(clang::ParmVarDecl::Create( + *clang_ast, setter, clang::SourceLocation(), + clang::SourceLocation(), + nullptr, // anonymous + ClangUtil::GetQualType(property_clang_type_to_access), nullptr, + clang::SC_Auto, nullptr)); + + if (setter) { + setter->setMethodParams( + *clang_ast, llvm::ArrayRef<clang::ParmVarDecl *>(params), + llvm::ArrayRef<clang::SourceLocation>()); + + class_interface_decl->addDecl(setter); + } } + + return true; + } } - return false; + } + return false; } -bool -ClangASTContext::SetObjCSuperClass (const CompilerType& type, const CompilerType &superclass_clang_type) -{ - ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem()); - if (!ast) - return false; - clang::ASTContext* clang_ast = ast->getASTContext(); - - if (type && superclass_clang_type.IsValid() && superclass_clang_type.GetTypeSystem() == type.GetTypeSystem()) - { - clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (type); - clang::ObjCInterfaceDecl *super_interface_decl = GetAsObjCInterfaceDecl (superclass_clang_type); - if (class_interface_decl && super_interface_decl) - { - class_interface_decl->setSuperClass(clang_ast->getTrivialTypeSourceInfo(clang_ast->getObjCInterfaceType(super_interface_decl))); - return true; - } - } - return false; +bool ClangASTContext::IsObjCClassTypeAndHasIVars(const CompilerType &type, + bool check_superclass) { + clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type); + if (class_interface_decl) + return ObjCDeclHasIVars(class_interface_decl, check_superclass); + return false; } -bool -ClangASTContext::AddObjCClassProperty (const CompilerType& type, - const char *property_name, - const CompilerType &property_clang_type, - clang::ObjCIvarDecl *ivar_decl, - const char *property_setter_name, - const char *property_getter_name, - uint32_t property_attributes, - ClangASTMetadata *metadata) -{ - if (!type || !property_clang_type.IsValid() || property_name == nullptr || property_name[0] == '\0') - return false; - ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); - if (!ast) - return false; - clang::ASTContext* clang_ast = ast->getASTContext(); - - clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (type); - - if (class_interface_decl) - { - CompilerType property_clang_type_to_access; - - if (property_clang_type.IsValid()) - property_clang_type_to_access = property_clang_type; - else if (ivar_decl) - property_clang_type_to_access = CompilerType (clang_ast, ivar_decl->getType()); - - if (class_interface_decl && property_clang_type_to_access.IsValid()) - { - clang::TypeSourceInfo *prop_type_source; - if (ivar_decl) - prop_type_source = clang_ast->getTrivialTypeSourceInfo (ivar_decl->getType()); - else - prop_type_source = clang_ast->getTrivialTypeSourceInfo(ClangUtil::GetQualType(property_clang_type)); - - clang::ObjCPropertyDecl *property_decl = clang::ObjCPropertyDecl::Create( - *clang_ast, class_interface_decl, - clang::SourceLocation(), // Source Location - &clang_ast->Idents.get(property_name), - clang::SourceLocation(), // Source Location for AT - clang::SourceLocation(), // Source location for ( - ivar_decl ? ivar_decl->getType() : ClangUtil::GetQualType(property_clang_type), prop_type_source); - - if (property_decl) - { - if (metadata) - ClangASTContext::SetMetadata(clang_ast, property_decl, *metadata); - - class_interface_decl->addDecl (property_decl); - - clang::Selector setter_sel, getter_sel; - - if (property_setter_name != nullptr) - { - std::string property_setter_no_colon(property_setter_name, strlen(property_setter_name) - 1); - clang::IdentifierInfo *setter_ident = &clang_ast->Idents.get(property_setter_no_colon.c_str()); - setter_sel = clang_ast->Selectors.getSelector(1, &setter_ident); - } - else if (!(property_attributes & DW_APPLE_PROPERTY_readonly)) - { - std::string setter_sel_string("set"); - setter_sel_string.push_back(::toupper(property_name[0])); - setter_sel_string.append(&property_name[1]); - clang::IdentifierInfo *setter_ident = &clang_ast->Idents.get(setter_sel_string.c_str()); - setter_sel = clang_ast->Selectors.getSelector(1, &setter_ident); - } - property_decl->setSetterName(setter_sel); - property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_setter); - - if (property_getter_name != nullptr) - { - clang::IdentifierInfo *getter_ident = &clang_ast->Idents.get(property_getter_name); - getter_sel = clang_ast->Selectors.getSelector(0, &getter_ident); - } - else - { - clang::IdentifierInfo *getter_ident = &clang_ast->Idents.get(property_name); - getter_sel = clang_ast->Selectors.getSelector(0, &getter_ident); - } - property_decl->setGetterName(getter_sel); - property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_getter); - - if (ivar_decl) - property_decl->setPropertyIvarDecl (ivar_decl); - - if (property_attributes & DW_APPLE_PROPERTY_readonly) - property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readonly); - if (property_attributes & DW_APPLE_PROPERTY_readwrite) - property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readwrite); - if (property_attributes & DW_APPLE_PROPERTY_assign) - property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_assign); - if (property_attributes & DW_APPLE_PROPERTY_retain) - property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_retain); - if (property_attributes & DW_APPLE_PROPERTY_copy) - property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_copy); - if (property_attributes & DW_APPLE_PROPERTY_nonatomic) - property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_nonatomic); - if (property_attributes & clang::ObjCPropertyDecl::OBJC_PR_nullability) - property_decl->setPropertyAttributes(clang::ObjCPropertyDecl::OBJC_PR_nullability); - if (property_attributes & clang::ObjCPropertyDecl::OBJC_PR_null_resettable) - property_decl->setPropertyAttributes(clang::ObjCPropertyDecl::OBJC_PR_null_resettable); - if (property_attributes & clang::ObjCPropertyDecl::OBJC_PR_class) - property_decl->setPropertyAttributes(clang::ObjCPropertyDecl::OBJC_PR_class); - - const bool isInstance = (property_attributes & clang::ObjCPropertyDecl::OBJC_PR_class) == 0; - - if (!getter_sel.isNull() && - !(isInstance ? class_interface_decl->lookupInstanceMethod(getter_sel) - : class_interface_decl->lookupClassMethod(getter_sel))) - { - const bool isVariadic = false; - const bool isSynthesized = false; - const bool isImplicitlyDeclared = true; - const bool isDefined = false; - const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None; - const bool HasRelatedResultType = false; - - clang::ObjCMethodDecl *getter = clang::ObjCMethodDecl::Create( - *clang_ast, clang::SourceLocation(), clang::SourceLocation(), getter_sel, - ClangUtil::GetQualType(property_clang_type_to_access), nullptr, class_interface_decl, - isInstance, isVariadic, isSynthesized, isImplicitlyDeclared, isDefined, impControl, - HasRelatedResultType); - - if (getter && metadata) - ClangASTContext::SetMetadata(clang_ast, getter, *metadata); - - if (getter) - { - getter->setMethodParams(*clang_ast, llvm::ArrayRef<clang::ParmVarDecl*>(), llvm::ArrayRef<clang::SourceLocation>()); - - class_interface_decl->addDecl(getter); - } - } +clang::ObjCMethodDecl *ClangASTContext::AddMethodToObjCObjectType( + const CompilerType &type, + const char *name, // the full symbol name as seen in the symbol table + // (lldb::opaque_compiler_type_t type, "-[NString + // stringWithCString:]") + const CompilerType &method_clang_type, lldb::AccessType access, + bool is_artificial, bool is_variadic) { + if (!type || !method_clang_type.IsValid()) + return nullptr; - if (!setter_sel.isNull() && - !(isInstance ? class_interface_decl->lookupInstanceMethod(setter_sel) - : class_interface_decl->lookupClassMethod(setter_sel))) - { - clang::QualType result_type = clang_ast->VoidTy; - const bool isVariadic = false; - const bool isSynthesized = false; - const bool isImplicitlyDeclared = true; - const bool isDefined = false; - const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None; - const bool HasRelatedResultType = false; - - clang::ObjCMethodDecl *setter = clang::ObjCMethodDecl::Create (*clang_ast, - clang::SourceLocation(), - clang::SourceLocation(), - setter_sel, - result_type, - nullptr, - class_interface_decl, - isInstance, - isVariadic, - isSynthesized, - isImplicitlyDeclared, - isDefined, - impControl, - HasRelatedResultType); - - if (setter && metadata) - ClangASTContext::SetMetadata(clang_ast, setter, *metadata); - - llvm::SmallVector<clang::ParmVarDecl *, 1> params; - - params.push_back(clang::ParmVarDecl::Create( - *clang_ast, setter, clang::SourceLocation(), clang::SourceLocation(), - nullptr, // anonymous - ClangUtil::GetQualType(property_clang_type_to_access), nullptr, clang::SC_Auto, nullptr)); - - if (setter) - { - setter->setMethodParams(*clang_ast, llvm::ArrayRef<clang::ParmVarDecl*>(params), llvm::ArrayRef<clang::SourceLocation>()); - - class_interface_decl->addDecl(setter); - } - } - - return true; - } - } - } - return false; -} + clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type); -bool -ClangASTContext::IsObjCClassTypeAndHasIVars (const CompilerType& type, bool check_superclass) -{ - clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (type); - if (class_interface_decl) - return ObjCDeclHasIVars (class_interface_decl, check_superclass); - return false; -} + if (class_interface_decl == nullptr) + return nullptr; + ClangASTContext *lldb_ast = + llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); + if (lldb_ast == nullptr) + return nullptr; + clang::ASTContext *ast = lldb_ast->getASTContext(); + const char *selector_start = ::strchr(name, ' '); + if (selector_start == nullptr) + return nullptr; -clang::ObjCMethodDecl * -ClangASTContext::AddMethodToObjCObjectType (const CompilerType& type, - const char *name, // the full symbol name as seen in the symbol table (lldb::opaque_compiler_type_t type, "-[NString stringWithCString:]") - const CompilerType &method_clang_type, - lldb::AccessType access, - bool is_artificial, - bool is_variadic) -{ - if (!type || !method_clang_type.IsValid()) - return nullptr; - - clang::ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(type); - - if (class_interface_decl == nullptr) - return nullptr; - ClangASTContext *lldb_ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); - if (lldb_ast == nullptr) - return nullptr; - clang::ASTContext *ast = lldb_ast->getASTContext(); - - const char *selector_start = ::strchr (name, ' '); - if (selector_start == nullptr) - return nullptr; - - selector_start++; - llvm::SmallVector<clang::IdentifierInfo *, 12> selector_idents; - - size_t len = 0; - const char *start; - //printf ("name = '%s'\n", name); - - unsigned num_selectors_with_args = 0; - for (start = selector_start; - start && *start != '\0' && *start != ']'; - start += len) - { - len = ::strcspn(start, ":]"); - bool has_arg = (start[len] == ':'); - if (has_arg) - ++num_selectors_with_args; - selector_idents.push_back (&ast->Idents.get (llvm::StringRef (start, len))); - if (has_arg) - len += 1; - } - - - if (selector_idents.size() == 0) - return nullptr; - - clang::Selector method_selector = ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0, - selector_idents.data()); - - clang::QualType method_qual_type(ClangUtil::GetQualType(method_clang_type)); - - // Populate the method decl with parameter decls - const clang::Type *method_type(method_qual_type.getTypePtr()); - - if (method_type == nullptr) - return nullptr; - - const clang::FunctionProtoType *method_function_prototype (llvm::dyn_cast<clang::FunctionProtoType>(method_type)); - - if (!method_function_prototype) - return nullptr; - - - bool is_synthesized = false; - bool is_defined = false; - clang::ObjCMethodDecl::ImplementationControl imp_control = clang::ObjCMethodDecl::None; - - const unsigned num_args = method_function_prototype->getNumParams(); - - if (num_args != num_selectors_with_args) - return nullptr; // some debug information is corrupt. We are not going to deal with it. - - clang::ObjCMethodDecl *objc_method_decl = clang::ObjCMethodDecl::Create( - *ast, - clang::SourceLocation(), // beginLoc, - clang::SourceLocation(), // endLoc, - method_selector, method_function_prototype->getReturnType(), - nullptr, // TypeSourceInfo *ResultTInfo, - ClangASTContext::GetASTContext(ast)->GetDeclContextForType(ClangUtil::GetQualType(type)), name[0] == '-', - is_variadic, is_synthesized, - true, // is_implicitly_declared; we force this to true because we don't have source locations - is_defined, imp_control, false /*has_related_result_type*/); - - if (objc_method_decl == nullptr) - return nullptr; - - if (num_args > 0) - { - llvm::SmallVector<clang::ParmVarDecl *, 12> params; - - for (unsigned param_index = 0; param_index < num_args; ++param_index) - { - params.push_back (clang::ParmVarDecl::Create (*ast, - objc_method_decl, - clang::SourceLocation(), - clang::SourceLocation(), - nullptr, // anonymous - method_function_prototype->getParamType(param_index), - nullptr, - clang::SC_Auto, - nullptr)); - } - - objc_method_decl->setMethodParams(*ast, llvm::ArrayRef<clang::ParmVarDecl*>(params), llvm::ArrayRef<clang::SourceLocation>()); + selector_start++; + llvm::SmallVector<clang::IdentifierInfo *, 12> selector_idents; + + size_t len = 0; + const char *start; + // printf ("name = '%s'\n", name); + + unsigned num_selectors_with_args = 0; + for (start = selector_start; start && *start != '\0' && *start != ']'; + start += len) { + len = ::strcspn(start, ":]"); + bool has_arg = (start[len] == ':'); + if (has_arg) + ++num_selectors_with_args; + selector_idents.push_back(&ast->Idents.get(llvm::StringRef(start, len))); + if (has_arg) + len += 1; + } + + if (selector_idents.size() == 0) + return nullptr; + + clang::Selector method_selector = ast->Selectors.getSelector( + num_selectors_with_args ? selector_idents.size() : 0, + selector_idents.data()); + + clang::QualType method_qual_type(ClangUtil::GetQualType(method_clang_type)); + + // Populate the method decl with parameter decls + const clang::Type *method_type(method_qual_type.getTypePtr()); + + if (method_type == nullptr) + return nullptr; + + const clang::FunctionProtoType *method_function_prototype( + llvm::dyn_cast<clang::FunctionProtoType>(method_type)); + + if (!method_function_prototype) + return nullptr; + + bool is_synthesized = false; + bool is_defined = false; + clang::ObjCMethodDecl::ImplementationControl imp_control = + clang::ObjCMethodDecl::None; + + const unsigned num_args = method_function_prototype->getNumParams(); + + if (num_args != num_selectors_with_args) + return nullptr; // some debug information is corrupt. We are not going to + // deal with it. + + clang::ObjCMethodDecl *objc_method_decl = clang::ObjCMethodDecl::Create( + *ast, + clang::SourceLocation(), // beginLoc, + clang::SourceLocation(), // endLoc, + method_selector, method_function_prototype->getReturnType(), + nullptr, // TypeSourceInfo *ResultTInfo, + ClangASTContext::GetASTContext(ast)->GetDeclContextForType( + ClangUtil::GetQualType(type)), + name[0] == '-', is_variadic, is_synthesized, + true, // is_implicitly_declared; we force this to true because we don't + // have source locations + is_defined, imp_control, false /*has_related_result_type*/); + + if (objc_method_decl == nullptr) + return nullptr; + + if (num_args > 0) { + llvm::SmallVector<clang::ParmVarDecl *, 12> params; + + for (unsigned param_index = 0; param_index < num_args; ++param_index) { + params.push_back(clang::ParmVarDecl::Create( + *ast, objc_method_decl, clang::SourceLocation(), + clang::SourceLocation(), + nullptr, // anonymous + method_function_prototype->getParamType(param_index), nullptr, + clang::SC_Auto, nullptr)); } - - class_interface_decl->addDecl (objc_method_decl); - + + objc_method_decl->setMethodParams( + *ast, llvm::ArrayRef<clang::ParmVarDecl *>(params), + llvm::ArrayRef<clang::SourceLocation>()); + } + + class_interface_decl->addDecl(objc_method_decl); + #ifdef LLDB_CONFIGURATION_DEBUG - VerifyDecl(objc_method_decl); + VerifyDecl(objc_method_decl); #endif - - return objc_method_decl; + + return objc_method_decl; } -bool -ClangASTContext::GetHasExternalStorage (const CompilerType &type) -{ - if (ClangUtil::IsClangType(type)) - return false; +bool ClangASTContext::GetHasExternalStorage(const CompilerType &type) { + if (ClangUtil::IsClangType(type)) + return false; - clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); + clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type)); - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - { - clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - return cxx_record_decl->hasExternalLexicalStorage () || cxx_record_decl->hasExternalVisibleStorage(); - } - break; + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: { + clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + return cxx_record_decl->hasExternalLexicalStorage() || + cxx_record_decl->hasExternalVisibleStorage(); + } break; - case clang::Type::Enum: - { - clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl(); - if (enum_decl) - return enum_decl->hasExternalLexicalStorage () || enum_decl->hasExternalVisibleStorage(); - } - break; + case clang::Type::Enum: { + clang::EnumDecl *enum_decl = + llvm::cast<clang::EnumType>(qual_type)->getDecl(); + if (enum_decl) + return enum_decl->hasExternalLexicalStorage() || + enum_decl->hasExternalVisibleStorage(); + } break; - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); - assert (objc_class_type); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - - if (class_interface_decl) - return class_interface_decl->hasExternalLexicalStorage () || class_interface_decl->hasExternalVisibleStorage (); - } - } - break; + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); + assert(objc_class_type); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + + if (class_interface_decl) + return class_interface_decl->hasExternalLexicalStorage() || + class_interface_decl->hasExternalVisibleStorage(); + } + } break; + + case clang::Type::Typedef: + return GetHasExternalStorage(CompilerType( + type.GetTypeSystem(), llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr())); + + case clang::Type::Auto: + return GetHasExternalStorage(CompilerType( + type.GetTypeSystem(), llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr())); + + case clang::Type::Elaborated: + return GetHasExternalStorage(CompilerType( + type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr())); + + case clang::Type::Paren: + return GetHasExternalStorage(CompilerType( + type.GetTypeSystem(), + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())); + + default: + break; + } + return false; +} + +bool ClangASTContext::SetHasExternalStorage(lldb::opaque_compiler_type_t type, + bool has_extern) { + if (!type) + return false; - case clang::Type::Typedef: - return GetHasExternalStorage (CompilerType(type.GetTypeSystem(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr())); + clang::QualType qual_type(GetCanonicalQualType(type)); - case clang::Type::Auto: - return GetHasExternalStorage (CompilerType(type.GetTypeSystem(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr())); - - case clang::Type::Elaborated: - return GetHasExternalStorage (CompilerType(type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr())); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: { + clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) { + cxx_record_decl->setHasExternalLexicalStorage(has_extern); + cxx_record_decl->setHasExternalVisibleStorage(has_extern); + return true; + } + } break; - case clang::Type::Paren: - return GetHasExternalStorage (CompilerType(type.GetTypeSystem(), llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())); + case clang::Type::Enum: { + clang::EnumDecl *enum_decl = + llvm::cast<clang::EnumType>(qual_type)->getDecl(); + if (enum_decl) { + enum_decl->setHasExternalLexicalStorage(has_extern); + enum_decl->setHasExternalVisibleStorage(has_extern); + return true; + } + } break; - default: - break; + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); + assert(objc_class_type); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + + if (class_interface_decl) { + class_interface_decl->setHasExternalLexicalStorage(has_extern); + class_interface_decl->setHasExternalVisibleStorage(has_extern); + return true; + } } - return false; -} + } break; + case clang::Type::Typedef: + return SetHasExternalStorage(llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType() + .getAsOpaquePtr(), + has_extern); -bool -ClangASTContext::SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool has_extern) -{ - if (!type) - return false; - - clang::QualType qual_type (GetCanonicalQualType(type)); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - { - clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - { - cxx_record_decl->setHasExternalLexicalStorage (has_extern); - cxx_record_decl->setHasExternalVisibleStorage (has_extern); - return true; - } - } - break; - - case clang::Type::Enum: - { - clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl(); - if (enum_decl) - { - enum_decl->setHasExternalLexicalStorage (has_extern); - enum_decl->setHasExternalVisibleStorage (has_extern); - return true; - } - } - break; - - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); - assert (objc_class_type); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - - if (class_interface_decl) - { - class_interface_decl->setHasExternalLexicalStorage (has_extern); - class_interface_decl->setHasExternalVisibleStorage (has_extern); - return true; - } - } - } - break; - - case clang::Type::Typedef: - return SetHasExternalStorage(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), has_extern); - - case clang::Type::Auto: - return SetHasExternalStorage (llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr(), has_extern); - - case clang::Type::Elaborated: - return SetHasExternalStorage (llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), has_extern); - - case clang::Type::Paren: - return SetHasExternalStorage (llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), has_extern); - - default: - break; - } - return false; -} + case clang::Type::Auto: + return SetHasExternalStorage(llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr(), + has_extern); + + case clang::Type::Elaborated: + return SetHasExternalStorage(llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr(), + has_extern); + + case clang::Type::Paren: + return SetHasExternalStorage( + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(), + has_extern); + default: + break; + } + return false; +} #pragma mark TagDecl -bool -ClangASTContext::StartTagDeclarationDefinition (const CompilerType &type) -{ - clang::QualType qual_type(ClangUtil::GetQualType(type)); - if (!qual_type.isNull()) - { - const clang::TagType *tag_type = qual_type->getAs<clang::TagType>(); - if (tag_type) - { - clang::TagDecl *tag_decl = tag_type->getDecl(); - if (tag_decl) - { - tag_decl->startDefinition(); - return true; - } - } - - const clang::ObjCObjectType *object_type = qual_type->getAs<clang::ObjCObjectType>(); - if (object_type) - { - clang::ObjCInterfaceDecl *interface_decl = object_type->getInterface(); - if (interface_decl) - { - interface_decl->startDefinition(); - return true; - } - } +bool ClangASTContext::StartTagDeclarationDefinition(const CompilerType &type) { + clang::QualType qual_type(ClangUtil::GetQualType(type)); + if (!qual_type.isNull()) { + const clang::TagType *tag_type = qual_type->getAs<clang::TagType>(); + if (tag_type) { + clang::TagDecl *tag_decl = tag_type->getDecl(); + if (tag_decl) { + tag_decl->startDefinition(); + return true; + } } - return false; -} -bool -ClangASTContext::CompleteTagDeclarationDefinition (const CompilerType& type) -{ - clang::QualType qual_type(ClangUtil::GetQualType(type)); - if (!qual_type.isNull()) - { - // Make sure we use the same methodology as ClangASTContext::StartTagDeclarationDefinition() - // as to how we start/end the definition. Previously we were calling - const clang::TagType *tag_type = qual_type->getAs<clang::TagType>(); - if (tag_type) - { - clang::TagDecl *tag_decl = tag_type->getDecl(); - if (tag_decl) - { - clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast_or_null<clang::CXXRecordDecl>(tag_decl); - - if (cxx_record_decl) - { - if (!cxx_record_decl->isCompleteDefinition()) - cxx_record_decl->completeDefinition(); - cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true); - cxx_record_decl->setHasExternalLexicalStorage (false); - cxx_record_decl->setHasExternalVisibleStorage (false); - return true; - } - } + const clang::ObjCObjectType *object_type = + qual_type->getAs<clang::ObjCObjectType>(); + if (object_type) { + clang::ObjCInterfaceDecl *interface_decl = object_type->getInterface(); + if (interface_decl) { + interface_decl->startDefinition(); + return true; + } + } + } + return false; +} + +bool ClangASTContext::CompleteTagDeclarationDefinition( + const CompilerType &type) { + clang::QualType qual_type(ClangUtil::GetQualType(type)); + if (!qual_type.isNull()) { + // Make sure we use the same methodology as + // ClangASTContext::StartTagDeclarationDefinition() + // as to how we start/end the definition. Previously we were calling + const clang::TagType *tag_type = qual_type->getAs<clang::TagType>(); + if (tag_type) { + clang::TagDecl *tag_decl = tag_type->getDecl(); + if (tag_decl) { + clang::CXXRecordDecl *cxx_record_decl = + llvm::dyn_cast_or_null<clang::CXXRecordDecl>(tag_decl); + + if (cxx_record_decl) { + if (!cxx_record_decl->isCompleteDefinition()) + cxx_record_decl->completeDefinition(); + cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true); + cxx_record_decl->setHasExternalLexicalStorage(false); + cxx_record_decl->setHasExternalVisibleStorage(false); + return true; } + } + } - const clang::EnumType *enutype = qual_type->getAs<clang::EnumType>(); - - if (enutype) - { - clang::EnumDecl *enum_decl = enutype->getDecl(); - - if (enum_decl) - { - if (!enum_decl->isCompleteDefinition()) - { - ClangASTContext *lldb_ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); - if (lldb_ast == nullptr) - return false; - clang::ASTContext *ast = lldb_ast->getASTContext(); - - /// TODO This really needs to be fixed. - - QualType integer_type(enum_decl->getIntegerType()); - if (!integer_type.isNull()) - { - unsigned NumPositiveBits = 1; - unsigned NumNegativeBits = 0; - - clang::QualType promotion_qual_type; - // If the enum integer type is less than an integer in bit width, - // then we must promote it to an integer size. - if (ast->getTypeSize(enum_decl->getIntegerType()) < ast->getTypeSize(ast->IntTy)) - { - if (enum_decl->getIntegerType()->isSignedIntegerType()) - promotion_qual_type = ast->IntTy; - else - promotion_qual_type = ast->UnsignedIntTy; - } - else - promotion_qual_type = enum_decl->getIntegerType(); - - enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits); - } - } - return true; - } + const clang::EnumType *enutype = qual_type->getAs<clang::EnumType>(); + + if (enutype) { + clang::EnumDecl *enum_decl = enutype->getDecl(); + + if (enum_decl) { + if (!enum_decl->isCompleteDefinition()) { + ClangASTContext *lldb_ast = + llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); + if (lldb_ast == nullptr) + return false; + clang::ASTContext *ast = lldb_ast->getASTContext(); + + /// TODO This really needs to be fixed. + + QualType integer_type(enum_decl->getIntegerType()); + if (!integer_type.isNull()) { + unsigned NumPositiveBits = 1; + unsigned NumNegativeBits = 0; + + clang::QualType promotion_qual_type; + // If the enum integer type is less than an integer in bit width, + // then we must promote it to an integer size. + if (ast->getTypeSize(enum_decl->getIntegerType()) < + ast->getTypeSize(ast->IntTy)) { + if (enum_decl->getIntegerType()->isSignedIntegerType()) + promotion_qual_type = ast->IntTy; + else + promotion_qual_type = ast->UnsignedIntTy; + } else + promotion_qual_type = enum_decl->getIntegerType(); + + enum_decl->completeDefinition(enum_decl->getIntegerType(), + promotion_qual_type, NumPositiveBits, + NumNegativeBits); + } } + return true; + } } - return false; + } + return false; } -bool -ClangASTContext::AddEnumerationValueToEnumerationType (lldb::opaque_compiler_type_t type, - const CompilerType &enumerator_clang_type, - const Declaration &decl, - const char *name, - int64_t enum_value, - uint32_t enum_value_bit_size) -{ - if (type && enumerator_clang_type.IsValid() && name && name[0]) - { - clang::QualType enum_qual_type (GetCanonicalQualType(type)); - - bool is_signed = false; - enumerator_clang_type.IsIntegerType (is_signed); - const clang::Type *clang_type = enum_qual_type.getTypePtr(); - if (clang_type) - { - const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(clang_type); - - if (enutype) - { - llvm::APSInt enum_llvm_apsint(enum_value_bit_size, is_signed); - enum_llvm_apsint = enum_value; - clang::EnumConstantDecl *enumerator_decl = clang::EnumConstantDecl::Create( - *getASTContext(), enutype->getDecl(), clang::SourceLocation(), - name ? &getASTContext()->Idents.get(name) : nullptr, // Identifier - ClangUtil::GetQualType(enumerator_clang_type), nullptr, enum_llvm_apsint); - - if (enumerator_decl) - { - enutype->getDecl()->addDecl(enumerator_decl); - +bool ClangASTContext::AddEnumerationValueToEnumerationType( + lldb::opaque_compiler_type_t type, + const CompilerType &enumerator_clang_type, const Declaration &decl, + const char *name, int64_t enum_value, uint32_t enum_value_bit_size) { + if (type && enumerator_clang_type.IsValid() && name && name[0]) { + clang::QualType enum_qual_type(GetCanonicalQualType(type)); + + bool is_signed = false; + enumerator_clang_type.IsIntegerType(is_signed); + const clang::Type *clang_type = enum_qual_type.getTypePtr(); + if (clang_type) { + const clang::EnumType *enutype = + llvm::dyn_cast<clang::EnumType>(clang_type); + + if (enutype) { + llvm::APSInt enum_llvm_apsint(enum_value_bit_size, is_signed); + enum_llvm_apsint = enum_value; + clang::EnumConstantDecl *enumerator_decl = + clang::EnumConstantDecl::Create( + *getASTContext(), enutype->getDecl(), clang::SourceLocation(), + name ? &getASTContext()->Idents.get(name) + : nullptr, // Identifier + ClangUtil::GetQualType(enumerator_clang_type), + nullptr, enum_llvm_apsint); + + if (enumerator_decl) { + enutype->getDecl()->addDecl(enumerator_decl); + #ifdef LLDB_CONFIGURATION_DEBUG - VerifyDecl(enumerator_decl); + VerifyDecl(enumerator_decl); #endif - - return true; - } - } + + return true; } + } } - return false; + } + return false; } CompilerType -ClangASTContext::GetEnumerationIntegerType (lldb::opaque_compiler_type_t type) -{ - clang::QualType enum_qual_type (GetCanonicalQualType(type)); - const clang::Type *clang_type = enum_qual_type.getTypePtr(); - if (clang_type) - { - const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(clang_type); - if (enutype) - { - clang::EnumDecl *enum_decl = enutype->getDecl(); - if (enum_decl) - return CompilerType (getASTContext(), enum_decl->getIntegerType()); - } +ClangASTContext::GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) { + clang::QualType enum_qual_type(GetCanonicalQualType(type)); + const clang::Type *clang_type = enum_qual_type.getTypePtr(); + if (clang_type) { + const clang::EnumType *enutype = + llvm::dyn_cast<clang::EnumType>(clang_type); + if (enutype) { + clang::EnumDecl *enum_decl = enutype->getDecl(); + if (enum_decl) + return CompilerType(getASTContext(), enum_decl->getIntegerType()); } - return CompilerType(); + } + return CompilerType(); } CompilerType -ClangASTContext::CreateMemberPointerType (const CompilerType& type, const CompilerType &pointee_type) -{ - if (type && pointee_type.IsValid() && type.GetTypeSystem() == pointee_type.GetTypeSystem()) - { - ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); - if (!ast) - return CompilerType(); - return CompilerType(ast->getASTContext(), - ast->getASTContext()->getMemberPointerType(ClangUtil::GetQualType(pointee_type), - ClangUtil::GetQualType(type).getTypePtr())); - } - return CompilerType(); +ClangASTContext::CreateMemberPointerType(const CompilerType &type, + const CompilerType &pointee_type) { + if (type && pointee_type.IsValid() && + type.GetTypeSystem() == pointee_type.GetTypeSystem()) { + ClangASTContext *ast = + llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); + if (!ast) + return CompilerType(); + return CompilerType(ast->getASTContext(), + ast->getASTContext()->getMemberPointerType( + ClangUtil::GetQualType(pointee_type), + ClangUtil::GetQualType(type).getTypePtr())); + } + return CompilerType(); } - size_t -ClangASTContext::ConvertStringToFloatValue (lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size) -{ - if (type) - { - clang::QualType qual_type (GetCanonicalQualType(type)); - uint32_t count = 0; - bool is_complex = false; - if (IsFloatingPointType (type, count, is_complex)) - { - // TODO: handle complex and vector types - if (count != 1) - return false; - - llvm::StringRef s_sref(s); - llvm::APFloat ap_float(getASTContext()->getFloatTypeSemantics(qual_type), s_sref); - - const uint64_t bit_size = getASTContext()->getTypeSize (qual_type); - const uint64_t byte_size = bit_size / 8; - if (dst_size >= byte_size) - { - Scalar scalar = ap_float.bitcastToAPInt().zextOrTrunc(llvm::NextPowerOf2(byte_size) * 8); - lldb_private::Error get_data_error; - if (scalar.GetAsMemoryData(dst, byte_size, lldb_private::endian::InlHostByteOrder(), get_data_error)) - return byte_size; - } - } - } - return 0; -} +ClangASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type, + const char *s, uint8_t *dst, + size_t dst_size) { + if (type) { + clang::QualType qual_type(GetCanonicalQualType(type)); + uint32_t count = 0; + bool is_complex = false; + if (IsFloatingPointType(type, count, is_complex)) { + // TODO: handle complex and vector types + if (count != 1) + return false; + llvm::StringRef s_sref(s); + llvm::APFloat ap_float(getASTContext()->getFloatTypeSemantics(qual_type), + s_sref); + const uint64_t bit_size = getASTContext()->getTypeSize(qual_type); + const uint64_t byte_size = bit_size / 8; + if (dst_size >= byte_size) { + Scalar scalar = ap_float.bitcastToAPInt().zextOrTrunc( + llvm::NextPowerOf2(byte_size) * 8); + lldb_private::Error get_data_error; + if (scalar.GetAsMemoryData(dst, byte_size, + lldb_private::endian::InlHostByteOrder(), + get_data_error)) + return byte_size; + } + } + } + return 0; +} //---------------------------------------------------------------------- // Dumping types //---------------------------------------------------------------------- #define DEPTH_INCREMENT 2 -void -ClangASTContext::DumpValue (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, - Stream *s, - lldb::Format format, - const lldb_private::DataExtractor &data, - lldb::offset_t data_byte_offset, - size_t data_byte_size, - uint32_t bitfield_bit_size, - uint32_t bitfield_bit_offset, - bool show_types, - bool show_summary, - bool verbose, - uint32_t depth) -{ - if (!type) - return; - +void ClangASTContext::DumpValue( + lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s, + lldb::Format format, const lldb_private::DataExtractor &data, + lldb::offset_t data_byte_offset, size_t data_byte_size, + uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types, + bool show_summary, bool verbose, uint32_t depth) { + if (!type) + return; + + clang::QualType qual_type(GetQualType(type)); + switch (qual_type->getTypeClass()) { + case clang::Type::Record: + if (GetCompleteType(type)) { + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + assert(record_decl); + uint32_t field_bit_offset = 0; + uint32_t field_byte_offset = 0; + const clang::ASTRecordLayout &record_layout = + getASTContext()->getASTRecordLayout(record_decl); + uint32_t child_idx = 0; + + const clang::CXXRecordDecl *cxx_record_decl = + llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); + if (cxx_record_decl) { + // We might have base classes to print out first + clang::CXXRecordDecl::base_class_const_iterator base_class, + base_class_end; + for (base_class = cxx_record_decl->bases_begin(), + base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; ++base_class) { + const clang::CXXRecordDecl *base_class_decl = + llvm::cast<clang::CXXRecordDecl>( + base_class->getType()->getAs<clang::RecordType>()->getDecl()); + + // Skip empty base classes + if (verbose == false && + ClangASTContext::RecordHasFields(base_class_decl) == false) + continue; + + if (base_class->isVirtual()) + field_bit_offset = + record_layout.getVBaseClassOffset(base_class_decl) + .getQuantity() * + 8; + else + field_bit_offset = record_layout.getBaseClassOffset(base_class_decl) + .getQuantity() * + 8; + field_byte_offset = field_bit_offset / 8; + assert(field_bit_offset % 8 == 0); + if (child_idx == 0) + s->PutChar('{'); + else + s->PutChar(','); + + clang::QualType base_class_qual_type = base_class->getType(); + std::string base_class_type_name(base_class_qual_type.getAsString()); + + // Indent and print the base class type name + s->Printf("\n%*s%s ", depth + DEPTH_INCREMENT, "", + base_class_type_name.c_str()); + + clang::TypeInfo base_class_type_info = + getASTContext()->getTypeInfo(base_class_qual_type); + + // Dump the value of the member + CompilerType base_clang_type(getASTContext(), base_class_qual_type); + base_clang_type.DumpValue( + exe_ctx, + s, // Stream to dump to + base_clang_type + .GetFormat(), // The format with which to display the member + data, // Data buffer containing all bytes for this type + data_byte_offset + field_byte_offset, // Offset into "data" where + // to grab value from + base_class_type_info.Width / 8, // Size of this type in bytes + 0, // Bitfield bit size + 0, // Bitfield bit offset + show_types, // Boolean indicating if we should show the variable + // types + show_summary, // Boolean indicating if we should show a summary + // for the current type + verbose, // Verbose output? + depth + DEPTH_INCREMENT); // Scope depth for any types that have + // children + + ++child_idx; + } + } + uint32_t field_idx = 0; + clang::RecordDecl::field_iterator field, field_end; + for (field = record_decl->field_begin(), + field_end = record_decl->field_end(); + field != field_end; ++field, ++field_idx, ++child_idx) { + // Print the starting squiggly bracket (if this is the + // first member) or comma (for member 2 and beyond) for + // the struct/union/class member. + if (child_idx == 0) + s->PutChar('{'); + else + s->PutChar(','); + + // Indent + s->Printf("\n%*s", depth + DEPTH_INCREMENT, ""); + + clang::QualType field_type = field->getType(); + // Print the member type if requested + // Figure out the type byte size (field_type_info.first) and + // alignment (field_type_info.second) from the AST context. + clang::TypeInfo field_type_info = + getASTContext()->getTypeInfo(field_type); + assert(field_idx < record_layout.getFieldCount()); + // Figure out the field offset within the current struct/union/class + // type + field_bit_offset = record_layout.getFieldOffset(field_idx); + field_byte_offset = field_bit_offset / 8; + uint32_t field_bitfield_bit_size = 0; + uint32_t field_bitfield_bit_offset = 0; + if (ClangASTContext::FieldIsBitfield(getASTContext(), *field, + field_bitfield_bit_size)) + field_bitfield_bit_offset = field_bit_offset % 8; + + if (show_types) { + std::string field_type_name(field_type.getAsString()); + if (field_bitfield_bit_size > 0) + s->Printf("(%s:%u) ", field_type_name.c_str(), + field_bitfield_bit_size); + else + s->Printf("(%s) ", field_type_name.c_str()); + } + // Print the member name and equal sign + s->Printf("%s = ", field->getNameAsString().c_str()); + + // Dump the value of the member + CompilerType field_clang_type(getASTContext(), field_type); + field_clang_type.DumpValue( + exe_ctx, + s, // Stream to dump to + field_clang_type + .GetFormat(), // The format with which to display the member + data, // Data buffer containing all bytes for this type + data_byte_offset + field_byte_offset, // Offset into "data" where to + // grab value from + field_type_info.Width / 8, // Size of this type in bytes + field_bitfield_bit_size, // Bitfield bit size + field_bitfield_bit_offset, // Bitfield bit offset + show_types, // Boolean indicating if we should show the variable + // types + show_summary, // Boolean indicating if we should show a summary for + // the current type + verbose, // Verbose output? + depth + DEPTH_INCREMENT); // Scope depth for any types that have + // children + } + + // Indent the trailing squiggly bracket + if (child_idx > 0) + s->Printf("\n%*s}", depth, ""); + } + return; + + case clang::Type::Enum: + if (GetCompleteType(type)) { + const clang::EnumType *enutype = + llvm::cast<clang::EnumType>(qual_type.getTypePtr()); + const clang::EnumDecl *enum_decl = enutype->getDecl(); + assert(enum_decl); + clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; + lldb::offset_t offset = data_byte_offset; + const int64_t enum_value = data.GetMaxU64Bitfield( + &offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset); + for (enum_pos = enum_decl->enumerator_begin(), + enum_end_pos = enum_decl->enumerator_end(); + enum_pos != enum_end_pos; ++enum_pos) { + if (enum_pos->getInitVal() == enum_value) { + s->Printf("%s", enum_pos->getNameAsString().c_str()); + return; + } + } + // If we have gotten here we didn't get find the enumerator in the + // enum decl, so just print the integer. + s->Printf("%" PRIi64, enum_value); + } + return; + + case clang::Type::ConstantArray: { + const clang::ConstantArrayType *array = + llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr()); + bool is_array_of_characters = false; + clang::QualType element_qual_type = array->getElementType(); + + const clang::Type *canonical_type = + element_qual_type->getCanonicalTypeInternal().getTypePtr(); + if (canonical_type) + is_array_of_characters = canonical_type->isCharType(); + + const uint64_t element_count = array->getSize().getLimitedValue(); + + clang::TypeInfo field_type_info = + getASTContext()->getTypeInfo(element_qual_type); + + uint32_t element_idx = 0; + uint32_t element_offset = 0; + uint64_t element_byte_size = field_type_info.Width / 8; + uint32_t element_stride = element_byte_size; + + if (is_array_of_characters) { + s->PutChar('"'); + data.Dump(s, data_byte_offset, lldb::eFormatChar, element_byte_size, + element_count, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); + s->PutChar('"'); + return; + } else { + CompilerType element_clang_type(getASTContext(), element_qual_type); + lldb::Format element_format = element_clang_type.GetFormat(); + + for (element_idx = 0; element_idx < element_count; ++element_idx) { + // Print the starting squiggly bracket (if this is the + // first member) or comman (for member 2 and beyong) for + // the struct/union/class member. + if (element_idx == 0) + s->PutChar('{'); + else + s->PutChar(','); + + // Indent and print the index + s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx); + + // Figure out the field offset within the current struct/union/class + // type + element_offset = element_idx * element_stride; + + // Dump the value of the member + element_clang_type.DumpValue( + exe_ctx, + s, // Stream to dump to + element_format, // The format with which to display the element + data, // Data buffer containing all bytes for this type + data_byte_offset + + element_offset, // Offset into "data" where to grab value from + element_byte_size, // Size of this type in bytes + 0, // Bitfield bit size + 0, // Bitfield bit offset + show_types, // Boolean indicating if we should show the variable + // types + show_summary, // Boolean indicating if we should show a summary for + // the current type + verbose, // Verbose output? + depth + DEPTH_INCREMENT); // Scope depth for any types that have + // children + } + + // Indent the trailing squiggly bracket + if (element_idx > 0) + s->Printf("\n%*s}", depth, ""); + } + } + return; + + case clang::Type::Typedef: { + clang::QualType typedef_qual_type = + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType(); + + CompilerType typedef_clang_type(getASTContext(), typedef_qual_type); + lldb::Format typedef_format = typedef_clang_type.GetFormat(); + clang::TypeInfo typedef_type_info = + getASTContext()->getTypeInfo(typedef_qual_type); + uint64_t typedef_byte_size = typedef_type_info.Width / 8; + + return typedef_clang_type.DumpValue( + exe_ctx, + s, // Stream to dump to + typedef_format, // The format with which to display the element + data, // Data buffer containing all bytes for this type + data_byte_offset, // Offset into "data" where to grab value from + typedef_byte_size, // Size of this type in bytes + bitfield_bit_size, // Bitfield bit size + bitfield_bit_offset, // Bitfield bit offset + show_types, // Boolean indicating if we should show the variable types + show_summary, // Boolean indicating if we should show a summary for the + // current type + verbose, // Verbose output? + depth); // Scope depth for any types that have children + } break; + + case clang::Type::Auto: { + clang::QualType elaborated_qual_type = + llvm::cast<clang::AutoType>(qual_type)->getDeducedType(); + CompilerType elaborated_clang_type(getASTContext(), elaborated_qual_type); + lldb::Format elaborated_format = elaborated_clang_type.GetFormat(); + clang::TypeInfo elaborated_type_info = + getASTContext()->getTypeInfo(elaborated_qual_type); + uint64_t elaborated_byte_size = elaborated_type_info.Width / 8; + + return elaborated_clang_type.DumpValue( + exe_ctx, + s, // Stream to dump to + elaborated_format, // The format with which to display the element + data, // Data buffer containing all bytes for this type + data_byte_offset, // Offset into "data" where to grab value from + elaborated_byte_size, // Size of this type in bytes + bitfield_bit_size, // Bitfield bit size + bitfield_bit_offset, // Bitfield bit offset + show_types, // Boolean indicating if we should show the variable types + show_summary, // Boolean indicating if we should show a summary for the + // current type + verbose, // Verbose output? + depth); // Scope depth for any types that have children + } break; + + case clang::Type::Elaborated: { + clang::QualType elaborated_qual_type = + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType(); + CompilerType elaborated_clang_type(getASTContext(), elaborated_qual_type); + lldb::Format elaborated_format = elaborated_clang_type.GetFormat(); + clang::TypeInfo elaborated_type_info = + getASTContext()->getTypeInfo(elaborated_qual_type); + uint64_t elaborated_byte_size = elaborated_type_info.Width / 8; + + return elaborated_clang_type.DumpValue( + exe_ctx, + s, // Stream to dump to + elaborated_format, // The format with which to display the element + data, // Data buffer containing all bytes for this type + data_byte_offset, // Offset into "data" where to grab value from + elaborated_byte_size, // Size of this type in bytes + bitfield_bit_size, // Bitfield bit size + bitfield_bit_offset, // Bitfield bit offset + show_types, // Boolean indicating if we should show the variable types + show_summary, // Boolean indicating if we should show a summary for the + // current type + verbose, // Verbose output? + depth); // Scope depth for any types that have children + } break; + + case clang::Type::Paren: { + clang::QualType desugar_qual_type = + llvm::cast<clang::ParenType>(qual_type)->desugar(); + CompilerType desugar_clang_type(getASTContext(), desugar_qual_type); + + lldb::Format desugar_format = desugar_clang_type.GetFormat(); + clang::TypeInfo desugar_type_info = + getASTContext()->getTypeInfo(desugar_qual_type); + uint64_t desugar_byte_size = desugar_type_info.Width / 8; + + return desugar_clang_type.DumpValue( + exe_ctx, + s, // Stream to dump to + desugar_format, // The format with which to display the element + data, // Data buffer containing all bytes for this type + data_byte_offset, // Offset into "data" where to grab value from + desugar_byte_size, // Size of this type in bytes + bitfield_bit_size, // Bitfield bit size + bitfield_bit_offset, // Bitfield bit offset + show_types, // Boolean indicating if we should show the variable types + show_summary, // Boolean indicating if we should show a summary for the + // current type + verbose, // Verbose output? + depth); // Scope depth for any types that have children + } break; + + default: + // We are down to a scalar type that we just need to display. + data.Dump(s, data_byte_offset, format, data_byte_size, 1, UINT32_MAX, + LLDB_INVALID_ADDRESS, bitfield_bit_size, bitfield_bit_offset); + + if (show_summary) + DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size); + break; + } +} + +bool ClangASTContext::DumpTypeValue( + lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format, + const lldb_private::DataExtractor &data, lldb::offset_t byte_offset, + size_t byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, + ExecutionContextScope *exe_scope) { + if (!type) + return false; + if (IsAggregateType(type)) { + return false; + } else { clang::QualType qual_type(GetQualType(type)); - switch (qual_type->getTypeClass()) - { - case clang::Type::Record: - if (GetCompleteType(type)) - { - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - assert(record_decl); - uint32_t field_bit_offset = 0; - uint32_t field_byte_offset = 0; - const clang::ASTRecordLayout &record_layout = getASTContext()->getASTRecordLayout(record_decl); - uint32_t child_idx = 0; - - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - if (cxx_record_decl) - { - // We might have base classes to print out first - clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end; - for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); - base_class != base_class_end; - ++base_class) - { - const clang::CXXRecordDecl *base_class_decl = llvm::cast<clang::CXXRecordDecl>(base_class->getType()->getAs<clang::RecordType>()->getDecl()); - - // Skip empty base classes - if (verbose == false && ClangASTContext::RecordHasFields(base_class_decl) == false) - continue; - - if (base_class->isVirtual()) - field_bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; - else - field_bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; - field_byte_offset = field_bit_offset / 8; - assert (field_bit_offset % 8 == 0); - if (child_idx == 0) - s->PutChar('{'); - else - s->PutChar(','); - - clang::QualType base_class_qual_type = base_class->getType(); - std::string base_class_type_name(base_class_qual_type.getAsString()); - - // Indent and print the base class type name - s->Printf("\n%*s%s ", depth + DEPTH_INCREMENT, "", base_class_type_name.c_str()); - - clang::TypeInfo base_class_type_info = getASTContext()->getTypeInfo(base_class_qual_type); - - // Dump the value of the member - CompilerType base_clang_type(getASTContext(), base_class_qual_type); - base_clang_type.DumpValue (exe_ctx, - s, // Stream to dump to - base_clang_type.GetFormat(), // The format with which to display the member - data, // Data buffer containing all bytes for this type - data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from - base_class_type_info.Width / 8, // Size of this type in bytes - 0, // Bitfield bit size - 0, // Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth + DEPTH_INCREMENT); // Scope depth for any types that have children - - ++child_idx; - } - } - uint32_t field_idx = 0; - clang::RecordDecl::field_iterator field, field_end; - for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) - { - // Print the starting squiggly bracket (if this is the - // first member) or comma (for member 2 and beyond) for - // the struct/union/class member. - if (child_idx == 0) - s->PutChar('{'); - else - s->PutChar(','); - - // Indent - s->Printf("\n%*s", depth + DEPTH_INCREMENT, ""); - - clang::QualType field_type = field->getType(); - // Print the member type if requested - // Figure out the type byte size (field_type_info.first) and - // alignment (field_type_info.second) from the AST context. - clang::TypeInfo field_type_info = getASTContext()->getTypeInfo(field_type); - assert(field_idx < record_layout.getFieldCount()); - // Figure out the field offset within the current struct/union/class type - field_bit_offset = record_layout.getFieldOffset (field_idx); - field_byte_offset = field_bit_offset / 8; - uint32_t field_bitfield_bit_size = 0; - uint32_t field_bitfield_bit_offset = 0; - if (ClangASTContext::FieldIsBitfield (getASTContext(), *field, field_bitfield_bit_size)) - field_bitfield_bit_offset = field_bit_offset % 8; - - if (show_types) - { - std::string field_type_name(field_type.getAsString()); - if (field_bitfield_bit_size > 0) - s->Printf("(%s:%u) ", field_type_name.c_str(), field_bitfield_bit_size); - else - s->Printf("(%s) ", field_type_name.c_str()); - } - // Print the member name and equal sign - s->Printf("%s = ", field->getNameAsString().c_str()); - - - // Dump the value of the member - CompilerType field_clang_type (getASTContext(), field_type); - field_clang_type.DumpValue (exe_ctx, - s, // Stream to dump to - field_clang_type.GetFormat(), // The format with which to display the member - data, // Data buffer containing all bytes for this type - data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from - field_type_info.Width / 8, // Size of this type in bytes - field_bitfield_bit_size, // Bitfield bit size - field_bitfield_bit_offset, // Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth + DEPTH_INCREMENT); // Scope depth for any types that have children - } - - // Indent the trailing squiggly bracket - if (child_idx > 0) - s->Printf("\n%*s}", depth, ""); - } - return; - - case clang::Type::Enum: - if (GetCompleteType(type)) - { - const clang::EnumType *enutype = llvm::cast<clang::EnumType>(qual_type.getTypePtr()); - const clang::EnumDecl *enum_decl = enutype->getDecl(); - assert(enum_decl); - clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; - lldb::offset_t offset = data_byte_offset; - const int64_t enum_value = data.GetMaxU64Bitfield(&offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset); - for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) - { - if (enum_pos->getInitVal() == enum_value) - { - s->Printf("%s", enum_pos->getNameAsString().c_str()); - return; - } - } - // If we have gotten here we didn't get find the enumerator in the - // enum decl, so just print the integer. - s->Printf("%" PRIi64, enum_value); + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Typedef: { + clang::QualType typedef_qual_type = + llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getUnderlyingType(); + CompilerType typedef_clang_type(getASTContext(), typedef_qual_type); + if (format == eFormatDefault) + format = typedef_clang_type.GetFormat(); + clang::TypeInfo typedef_type_info = + getASTContext()->getTypeInfo(typedef_qual_type); + uint64_t typedef_byte_size = typedef_type_info.Width / 8; + + return typedef_clang_type.DumpTypeValue( + s, + format, // The format with which to display the element + data, // Data buffer containing all bytes for this type + byte_offset, // Offset into "data" where to grab value from + typedef_byte_size, // Size of this type in bytes + bitfield_bit_size, // Size in bits of a bitfield value, if zero don't + // treat as a bitfield + bitfield_bit_offset, // Offset in bits of a bitfield value if + // bitfield_bit_size != 0 + exe_scope); + } break; + + case clang::Type::Enum: + // If our format is enum or default, show the enumeration value as + // its enumeration string value, else just display it as requested. + if ((format == eFormatEnum || format == eFormatDefault) && + GetCompleteType(type)) { + const clang::EnumType *enutype = + llvm::cast<clang::EnumType>(qual_type.getTypePtr()); + const clang::EnumDecl *enum_decl = enutype->getDecl(); + assert(enum_decl); + clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; + const bool is_signed = qual_type->isSignedIntegerOrEnumerationType(); + lldb::offset_t offset = byte_offset; + if (is_signed) { + const int64_t enum_svalue = data.GetMaxS64Bitfield( + &offset, byte_size, bitfield_bit_size, bitfield_bit_offset); + for (enum_pos = enum_decl->enumerator_begin(), + enum_end_pos = enum_decl->enumerator_end(); + enum_pos != enum_end_pos; ++enum_pos) { + if (enum_pos->getInitVal().getSExtValue() == enum_svalue) { + s->PutCString(enum_pos->getNameAsString().c_str()); + return true; } - return; - - case clang::Type::ConstantArray: - { - const clang::ConstantArrayType *array = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr()); - bool is_array_of_characters = false; - clang::QualType element_qual_type = array->getElementType(); - - const clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr(); - if (canonical_type) - is_array_of_characters = canonical_type->isCharType(); - - const uint64_t element_count = array->getSize().getLimitedValue(); - - clang::TypeInfo field_type_info = getASTContext()->getTypeInfo(element_qual_type); - - uint32_t element_idx = 0; - uint32_t element_offset = 0; - uint64_t element_byte_size = field_type_info.Width / 8; - uint32_t element_stride = element_byte_size; - - if (is_array_of_characters) - { - s->PutChar('"'); - data.Dump(s, data_byte_offset, lldb::eFormatChar, element_byte_size, element_count, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); - s->PutChar('"'); - return; + } + // If we have gotten here we didn't get find the enumerator in the + // enum decl, so just print the integer. + s->Printf("%" PRIi64, enum_svalue); + } else { + const uint64_t enum_uvalue = data.GetMaxU64Bitfield( + &offset, byte_size, bitfield_bit_size, bitfield_bit_offset); + for (enum_pos = enum_decl->enumerator_begin(), + enum_end_pos = enum_decl->enumerator_end(); + enum_pos != enum_end_pos; ++enum_pos) { + if (enum_pos->getInitVal().getZExtValue() == enum_uvalue) { + s->PutCString(enum_pos->getNameAsString().c_str()); + return true; } - else - { - CompilerType element_clang_type(getASTContext(), element_qual_type); - lldb::Format element_format = element_clang_type.GetFormat(); - - for (element_idx = 0; element_idx < element_count; ++element_idx) - { - // Print the starting squiggly bracket (if this is the - // first member) or comman (for member 2 and beyong) for - // the struct/union/class member. - if (element_idx == 0) - s->PutChar('{'); - else - s->PutChar(','); - - // Indent and print the index - s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx); - - // Figure out the field offset within the current struct/union/class type - element_offset = element_idx * element_stride; - - // Dump the value of the member - element_clang_type.DumpValue (exe_ctx, - s, // Stream to dump to - element_format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - data_byte_offset + element_offset,// Offset into "data" where to grab value from - element_byte_size, // Size of this type in bytes - 0, // Bitfield bit size - 0, // Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth + DEPTH_INCREMENT); // Scope depth for any types that have children - } - - // Indent the trailing squiggly bracket - if (element_idx > 0) - s->Printf("\n%*s}", depth, ""); - } - } - return; - - case clang::Type::Typedef: - { - clang::QualType typedef_qual_type = llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType(); - - CompilerType typedef_clang_type (getASTContext(), typedef_qual_type); - lldb::Format typedef_format = typedef_clang_type.GetFormat(); - clang::TypeInfo typedef_type_info = getASTContext()->getTypeInfo(typedef_qual_type); - uint64_t typedef_byte_size = typedef_type_info.Width / 8; - - return typedef_clang_type.DumpValue (exe_ctx, - s, // Stream to dump to - typedef_format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - data_byte_offset, // Offset into "data" where to grab value from - typedef_byte_size, // Size of this type in bytes - bitfield_bit_size, // Bitfield bit size - bitfield_bit_offset,// Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth); // Scope depth for any types that have children + } + // If we have gotten here we didn't get find the enumerator in the + // enum decl, so just print the integer. + s->Printf("%" PRIu64, enum_uvalue); } - break; - - case clang::Type::Auto: - { - clang::QualType elaborated_qual_type = llvm::cast<clang::AutoType>(qual_type)->getDeducedType(); - CompilerType elaborated_clang_type (getASTContext(), elaborated_qual_type); - lldb::Format elaborated_format = elaborated_clang_type.GetFormat(); - clang::TypeInfo elaborated_type_info = getASTContext()->getTypeInfo(elaborated_qual_type); - uint64_t elaborated_byte_size = elaborated_type_info.Width / 8; - - return elaborated_clang_type.DumpValue (exe_ctx, - s, // Stream to dump to - elaborated_format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - data_byte_offset, // Offset into "data" where to grab value from - elaborated_byte_size, // Size of this type in bytes - bitfield_bit_size, // Bitfield bit size - bitfield_bit_offset,// Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth); // Scope depth for any types that have children + return true; + } + // format was not enum, just fall through and dump the value as + // requested.... + LLVM_FALLTHROUGH; + + default: + // We are down to a scalar type that we just need to display. + { + uint32_t item_count = 1; + // A few formats, we might need to modify our size and count for + // depending + // on how we are trying to display the value... + switch (format) { + default: + case eFormatBoolean: + case eFormatBinary: + case eFormatComplex: + case eFormatCString: // NULL terminated C strings + case eFormatDecimal: + case eFormatEnum: + case eFormatHex: + case eFormatHexUppercase: + case eFormatFloat: + case eFormatOctal: + case eFormatOSType: + case eFormatUnsigned: + case eFormatPointer: + case eFormatVectorOfChar: + case eFormatVectorOfSInt8: + case eFormatVectorOfUInt8: + case eFormatVectorOfSInt16: + case eFormatVectorOfUInt16: + case eFormatVectorOfSInt32: + case eFormatVectorOfUInt32: + case eFormatVectorOfSInt64: + case eFormatVectorOfUInt64: + case eFormatVectorOfFloat32: + case eFormatVectorOfFloat64: + case eFormatVectorOfUInt128: + break; + + case eFormatChar: + case eFormatCharPrintable: + case eFormatCharArray: + case eFormatBytes: + case eFormatBytesWithASCII: + item_count = byte_size; + byte_size = 1; + break; + + case eFormatUnicode16: + item_count = byte_size / 2; + byte_size = 2; + break; + + case eFormatUnicode32: + item_count = byte_size / 4; + byte_size = 4; + break; } + return data.Dump(s, byte_offset, format, byte_size, item_count, + UINT32_MAX, LLDB_INVALID_ADDRESS, bitfield_bit_size, + bitfield_bit_offset, exe_scope); + } + break; + } + } + return 0; +} + +void ClangASTContext::DumpSummary(lldb::opaque_compiler_type_t type, + ExecutionContext *exe_ctx, Stream *s, + const lldb_private::DataExtractor &data, + lldb::offset_t data_byte_offset, + size_t data_byte_size) { + uint32_t length = 0; + if (IsCStringType(type, length)) { + if (exe_ctx) { + Process *process = exe_ctx->GetProcessPtr(); + if (process) { + lldb::offset_t offset = data_byte_offset; + lldb::addr_t pointer_address = data.GetMaxU64(&offset, data_byte_size); + std::vector<uint8_t> buf; + if (length > 0) + buf.resize(length); + else + buf.resize(256); + + lldb_private::DataExtractor cstr_data(&buf.front(), buf.size(), + process->GetByteOrder(), 4); + buf.back() = '\0'; + size_t bytes_read; + size_t total_cstr_len = 0; + Error error; + while ((bytes_read = process->ReadMemory(pointer_address, &buf.front(), + buf.size(), error)) > 0) { + const size_t len = strlen((const char *)&buf.front()); + if (len == 0) break; - - case clang::Type::Elaborated: - { - clang::QualType elaborated_qual_type = llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType(); - CompilerType elaborated_clang_type (getASTContext(), elaborated_qual_type); - lldb::Format elaborated_format = elaborated_clang_type.GetFormat(); - clang::TypeInfo elaborated_type_info = getASTContext()->getTypeInfo(elaborated_qual_type); - uint64_t elaborated_byte_size = elaborated_type_info.Width / 8; - - return elaborated_clang_type.DumpValue (exe_ctx, - s, // Stream to dump to - elaborated_format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - data_byte_offset, // Offset into "data" where to grab value from - elaborated_byte_size, // Size of this type in bytes - bitfield_bit_size, // Bitfield bit size - bitfield_bit_offset,// Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth); // Scope depth for any types that have children - } + if (total_cstr_len == 0) + s->PutCString(" \""); + cstr_data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX, + LLDB_INVALID_ADDRESS, 0, 0); + total_cstr_len += len; + if (len < buf.size()) break; - - case clang::Type::Paren: - { - clang::QualType desugar_qual_type = llvm::cast<clang::ParenType>(qual_type)->desugar(); - CompilerType desugar_clang_type (getASTContext(), desugar_qual_type); - - lldb::Format desugar_format = desugar_clang_type.GetFormat(); - clang::TypeInfo desugar_type_info = getASTContext()->getTypeInfo(desugar_qual_type); - uint64_t desugar_byte_size = desugar_type_info.Width / 8; - - return desugar_clang_type.DumpValue (exe_ctx, - s, // Stream to dump to - desugar_format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - data_byte_offset, // Offset into "data" where to grab value from - desugar_byte_size, // Size of this type in bytes - bitfield_bit_size, // Bitfield bit size - bitfield_bit_offset,// Bitfield bit offset - show_types, // Boolean indicating if we should show the variable types - show_summary, // Boolean indicating if we should show a summary for the current type - verbose, // Verbose output? - depth); // Scope depth for any types that have children + pointer_address += total_cstr_len; } - break; - - default: - // We are down to a scalar type that we just need to display. - data.Dump(s, - data_byte_offset, - format, - data_byte_size, - 1, - UINT32_MAX, - LLDB_INVALID_ADDRESS, - bitfield_bit_size, - bitfield_bit_offset); - - if (show_summary) - DumpSummary (type, exe_ctx, s, data, data_byte_offset, data_byte_size); - break; + if (total_cstr_len > 0) + s->PutChar('"'); + } } + } } - - - -bool -ClangASTContext::DumpTypeValue (lldb::opaque_compiler_type_t type, Stream *s, - lldb::Format format, - const lldb_private::DataExtractor &data, - lldb::offset_t byte_offset, - size_t byte_size, - uint32_t bitfield_bit_size, - uint32_t bitfield_bit_offset, - ExecutionContextScope *exe_scope) -{ - if (!type) - return false; - if (IsAggregateType(type)) - { - return false; - } - else - { - clang::QualType qual_type(GetQualType(type)); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Typedef: - { - clang::QualType typedef_qual_type = llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType(); - CompilerType typedef_clang_type (getASTContext(), typedef_qual_type); - if (format == eFormatDefault) - format = typedef_clang_type.GetFormat(); - clang::TypeInfo typedef_type_info = getASTContext()->getTypeInfo(typedef_qual_type); - uint64_t typedef_byte_size = typedef_type_info.Width / 8; - - return typedef_clang_type.DumpTypeValue (s, - format, // The format with which to display the element - data, // Data buffer containing all bytes for this type - byte_offset, // Offset into "data" where to grab value from - typedef_byte_size, // Size of this type in bytes - bitfield_bit_size, // Size in bits of a bitfield value, if zero don't treat as a bitfield - bitfield_bit_offset, // Offset in bits of a bitfield value if bitfield_bit_size != 0 - exe_scope); - } - break; - - case clang::Type::Enum: - // If our format is enum or default, show the enumeration value as - // its enumeration string value, else just display it as requested. - if ((format == eFormatEnum || format == eFormatDefault) && GetCompleteType(type)) - { - const clang::EnumType *enutype = llvm::cast<clang::EnumType>(qual_type.getTypePtr()); - const clang::EnumDecl *enum_decl = enutype->getDecl(); - assert(enum_decl); - clang::EnumDecl::enumerator_iterator enum_pos, enum_end_pos; - const bool is_signed = qual_type->isSignedIntegerOrEnumerationType(); - lldb::offset_t offset = byte_offset; - if (is_signed) - { - const int64_t enum_svalue = data.GetMaxS64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset); - for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) - { - if (enum_pos->getInitVal().getSExtValue() == enum_svalue) - { - s->PutCString (enum_pos->getNameAsString().c_str()); - return true; - } - } - // If we have gotten here we didn't get find the enumerator in the - // enum decl, so just print the integer. - s->Printf("%" PRIi64, enum_svalue); - } - else - { - const uint64_t enum_uvalue = data.GetMaxU64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset); - for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) - { - if (enum_pos->getInitVal().getZExtValue() == enum_uvalue) - { - s->PutCString (enum_pos->getNameAsString().c_str()); - return true; - } - } - // If we have gotten here we didn't get find the enumerator in the - // enum decl, so just print the integer. - s->Printf("%" PRIu64, enum_uvalue); - } - return true; - } - // format was not enum, just fall through and dump the value as requested.... - LLVM_FALLTHROUGH; - - default: - // We are down to a scalar type that we just need to display. - { - uint32_t item_count = 1; - // A few formats, we might need to modify our size and count for depending - // on how we are trying to display the value... - switch (format) - { - default: - case eFormatBoolean: - case eFormatBinary: - case eFormatComplex: - case eFormatCString: // NULL terminated C strings - case eFormatDecimal: - case eFormatEnum: - case eFormatHex: - case eFormatHexUppercase: - case eFormatFloat: - case eFormatOctal: - case eFormatOSType: - case eFormatUnsigned: - case eFormatPointer: - case eFormatVectorOfChar: - case eFormatVectorOfSInt8: - case eFormatVectorOfUInt8: - case eFormatVectorOfSInt16: - case eFormatVectorOfUInt16: - case eFormatVectorOfSInt32: - case eFormatVectorOfUInt32: - case eFormatVectorOfSInt64: - case eFormatVectorOfUInt64: - case eFormatVectorOfFloat32: - case eFormatVectorOfFloat64: - case eFormatVectorOfUInt128: - break; - - case eFormatChar: - case eFormatCharPrintable: - case eFormatCharArray: - case eFormatBytes: - case eFormatBytesWithASCII: - item_count = byte_size; - byte_size = 1; - break; - - case eFormatUnicode16: - item_count = byte_size / 2; - byte_size = 2; - break; - - case eFormatUnicode32: - item_count = byte_size / 4; - byte_size = 4; - break; - } - return data.Dump (s, - byte_offset, - format, - byte_size, - item_count, - UINT32_MAX, - LLDB_INVALID_ADDRESS, - bitfield_bit_size, - bitfield_bit_offset, - exe_scope); - } - break; - } - } - return 0; +void ClangASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) { + StreamFile s(stdout, false); + DumpTypeDescription(type, &s); + ClangASTMetadata *metadata = + ClangASTContext::GetMetadata(getASTContext(), type); + if (metadata) { + metadata->Dump(&s); + } } +void ClangASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type, + Stream *s) { + if (type) { + clang::QualType qual_type(GetQualType(type)); + llvm::SmallVector<char, 1024> buf; + llvm::raw_svector_ostream llvm_ostrm(buf); -void -ClangASTContext::DumpSummary (lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, - Stream *s, - const lldb_private::DataExtractor &data, - lldb::offset_t data_byte_offset, - size_t data_byte_size) -{ - uint32_t length = 0; - if (IsCStringType (type, length)) - { - if (exe_ctx) - { - Process *process = exe_ctx->GetProcessPtr(); - if (process) - { - lldb::offset_t offset = data_byte_offset; - lldb::addr_t pointer_address = data.GetMaxU64(&offset, data_byte_size); - std::vector<uint8_t> buf; - if (length > 0) - buf.resize (length); - else - buf.resize (256); - - lldb_private::DataExtractor cstr_data(&buf.front(), buf.size(), process->GetByteOrder(), 4); - buf.back() = '\0'; - size_t bytes_read; - size_t total_cstr_len = 0; - Error error; - while ((bytes_read = process->ReadMemory (pointer_address, &buf.front(), buf.size(), error)) > 0) - { - const size_t len = strlen((const char *)&buf.front()); - if (len == 0) - break; - if (total_cstr_len == 0) - s->PutCString (" \""); - cstr_data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); - total_cstr_len += len; - if (len < buf.size()) - break; - pointer_address += total_cstr_len; - } - if (total_cstr_len > 0) - s->PutChar ('"'); - } + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: { + GetCompleteType(type); + + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); + assert(objc_class_type); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + if (class_interface_decl) { + clang::PrintingPolicy policy = getASTContext()->getPrintingPolicy(); + class_interface_decl->print(llvm_ostrm, policy, s->GetIndentLevel()); + } + } + } break; + + case clang::Type::Typedef: { + const clang::TypedefType *typedef_type = + qual_type->getAs<clang::TypedefType>(); + if (typedef_type) { + const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl(); + std::string clang_typedef_name( + typedef_decl->getQualifiedNameAsString()); + if (!clang_typedef_name.empty()) { + s->PutCString("typedef "); + s->PutCString(clang_typedef_name.c_str()); } + } + } break; + + case clang::Type::Auto: + CompilerType(getASTContext(), + llvm::cast<clang::AutoType>(qual_type)->getDeducedType()) + .DumpTypeDescription(s); + return; + + case clang::Type::Elaborated: + CompilerType(getASTContext(), + llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()) + .DumpTypeDescription(s); + return; + + case clang::Type::Paren: + CompilerType(getASTContext(), + llvm::cast<clang::ParenType>(qual_type)->desugar()) + .DumpTypeDescription(s); + return; + + case clang::Type::Record: { + GetCompleteType(type); + + const clang::RecordType *record_type = + llvm::cast<clang::RecordType>(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + const clang::CXXRecordDecl *cxx_record_decl = + llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); + + if (cxx_record_decl) + cxx_record_decl->print(llvm_ostrm, getASTContext()->getPrintingPolicy(), + s->GetIndentLevel()); + else + record_decl->print(llvm_ostrm, getASTContext()->getPrintingPolicy(), + s->GetIndentLevel()); + } break; + + default: { + const clang::TagType *tag_type = + llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr()); + if (tag_type) { + clang::TagDecl *tag_decl = tag_type->getDecl(); + if (tag_decl) + tag_decl->print(llvm_ostrm, 0); + } else { + std::string clang_type_name(qual_type.getAsString()); + if (!clang_type_name.empty()) + s->PutCString(clang_type_name.c_str()); + } } -} - -void -ClangASTContext::DumpTypeDescription (lldb::opaque_compiler_type_t type) -{ - StreamFile s (stdout, false); - DumpTypeDescription (type, &s); - ClangASTMetadata *metadata = ClangASTContext::GetMetadata (getASTContext(), type); - if (metadata) - { - metadata->Dump (&s); } -} -void -ClangASTContext::DumpTypeDescription (lldb::opaque_compiler_type_t type, Stream *s) -{ - if (type) - { - clang::QualType qual_type(GetQualType(type)); - - llvm::SmallVector<char, 1024> buf; - llvm::raw_svector_ostream llvm_ostrm (buf); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - { - GetCompleteType(type); - - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type.getTypePtr()); - assert (objc_class_type); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - if (class_interface_decl) - { - clang::PrintingPolicy policy = getASTContext()->getPrintingPolicy(); - class_interface_decl->print(llvm_ostrm, policy, s->GetIndentLevel()); - } - } - } - break; - - case clang::Type::Typedef: - { - const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>(); - if (typedef_type) - { - const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl(); - std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString()); - if (!clang_typedef_name.empty()) - { - s->PutCString ("typedef "); - s->PutCString (clang_typedef_name.c_str()); - } - } - } - break; - - case clang::Type::Auto: - CompilerType (getASTContext(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType()).DumpTypeDescription(s); - return; - - case clang::Type::Elaborated: - CompilerType (getASTContext(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType()).DumpTypeDescription(s); - return; - - case clang::Type::Paren: - CompilerType (getASTContext(), llvm::cast<clang::ParenType>(qual_type)->desugar()).DumpTypeDescription(s); - return; - - case clang::Type::Record: - { - GetCompleteType(type); - - const clang::RecordType *record_type = llvm::cast<clang::RecordType>(qual_type.getTypePtr()); - const clang::RecordDecl *record_decl = record_type->getDecl(); - const clang::CXXRecordDecl *cxx_record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl); - - if (cxx_record_decl) - cxx_record_decl->print(llvm_ostrm, getASTContext()->getPrintingPolicy(), s->GetIndentLevel()); - else - record_decl->print(llvm_ostrm, getASTContext()->getPrintingPolicy(), s->GetIndentLevel()); - } - break; - - default: - { - const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type.getTypePtr()); - if (tag_type) - { - clang::TagDecl *tag_decl = tag_type->getDecl(); - if (tag_decl) - tag_decl->print(llvm_ostrm, 0); - } - else - { - std::string clang_type_name(qual_type.getAsString()); - if (!clang_type_name.empty()) - s->PutCString (clang_type_name.c_str()); - } - } - } - - if (buf.size() > 0) - { - s->Write (buf.data(), buf.size()); - } + if (buf.size() > 0) { + s->Write(buf.data(), buf.size()); } + } } -void -ClangASTContext::DumpTypeName (const CompilerType &type) -{ - if (ClangUtil::IsClangType(type)) - { - clang::QualType qual_type(ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type))); - - const clang::Type::TypeClass type_class = qual_type->getTypeClass(); - switch (type_class) - { - case clang::Type::Record: - { - const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); - if (cxx_record_decl) - printf("class %s", cxx_record_decl->getName().str().c_str()); - } - break; - - case clang::Type::Enum: - { - clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl(); - if (enum_decl) - { - printf("enum %s", enum_decl->getName().str().c_str()); - } - } - break; - - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type); - if (objc_class_type) - { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - // We currently can't complete objective C types through the newly added ASTContext - // because it only supports TagDecl objects right now... - if (class_interface_decl) - printf("@class %s", class_interface_decl->getName().str().c_str()); - } - } - break; +void ClangASTContext::DumpTypeName(const CompilerType &type) { + if (ClangUtil::IsClangType(type)) { + clang::QualType qual_type( + ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type))); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) { + case clang::Type::Record: { + const clang::CXXRecordDecl *cxx_record_decl = + qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + printf("class %s", cxx_record_decl->getName().str().c_str()); + } break; + + case clang::Type::Enum: { + clang::EnumDecl *enum_decl = + llvm::cast<clang::EnumType>(qual_type)->getDecl(); + if (enum_decl) { + printf("enum %s", enum_decl->getName().str().c_str()); + } + } break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: { + const clang::ObjCObjectType *objc_class_type = + llvm::dyn_cast<clang::ObjCObjectType>(qual_type); + if (objc_class_type) { + clang::ObjCInterfaceDecl *class_interface_decl = + objc_class_type->getInterface(); + // We currently can't complete objective C types through the newly added + // ASTContext + // because it only supports TagDecl objects right now... + if (class_interface_decl) + printf("@class %s", class_interface_decl->getName().str().c_str()); + } + } break; + + case clang::Type::Typedef: + printf("typedef %s", llvm::cast<clang::TypedefType>(qual_type) + ->getDecl() + ->getName() + .str() + .c_str()); + break; + + case clang::Type::Auto: + printf("auto "); + return DumpTypeName(CompilerType(type.GetTypeSystem(), + llvm::cast<clang::AutoType>(qual_type) + ->getDeducedType() + .getAsOpaquePtr())); + + case clang::Type::Elaborated: + printf("elaborated "); + return DumpTypeName(CompilerType( + type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type) + ->getNamedType() + .getAsOpaquePtr())); + + case clang::Type::Paren: + printf("paren "); + return DumpTypeName(CompilerType( + type.GetTypeSystem(), + llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())); - case clang::Type::Typedef: - printf("typedef %s", llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getName().str().c_str()); - break; - - case clang::Type::Auto: - printf("auto "); - return DumpTypeName (CompilerType (type.GetTypeSystem(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr())); - - case clang::Type::Elaborated: - printf("elaborated "); - return DumpTypeName (CompilerType (type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr())); - - case clang::Type::Paren: - printf("paren "); - return DumpTypeName (CompilerType (type.GetTypeSystem(), llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())); - - default: - printf("ClangASTContext::DumpTypeName() type_class = %u", type_class); - break; - } + default: + printf("ClangASTContext::DumpTypeName() type_class = %u", type_class); + break; } - + } } +clang::ClassTemplateDecl *ClangASTContext::ParseClassTemplateDecl( + clang::DeclContext *decl_ctx, lldb::AccessType access_type, + const char *parent_name, int tag_decl_kind, + const ClangASTContext::TemplateParameterInfos &template_param_infos) { + if (template_param_infos.IsValid()) { + std::string template_basename(parent_name); + template_basename.erase(template_basename.find('<')); - -clang::ClassTemplateDecl * -ClangASTContext::ParseClassTemplateDecl (clang::DeclContext *decl_ctx, - lldb::AccessType access_type, - const char *parent_name, - int tag_decl_kind, - const ClangASTContext::TemplateParameterInfos &template_param_infos) -{ - if (template_param_infos.IsValid()) - { - std::string template_basename(parent_name); - template_basename.erase (template_basename.find('<')); - - return CreateClassTemplateDecl (decl_ctx, - access_type, - template_basename.c_str(), - tag_decl_kind, - template_param_infos); - } - return NULL; + return CreateClassTemplateDecl(decl_ctx, access_type, + template_basename.c_str(), tag_decl_kind, + template_param_infos); + } + return NULL; } -void -ClangASTContext::CompleteTagDecl (void *baton, clang::TagDecl *decl) -{ - ClangASTContext *ast = (ClangASTContext *)baton; - SymbolFile *sym_file = ast->GetSymbolFile(); - if (sym_file) - { - CompilerType clang_type = GetTypeForDecl (decl); - if (clang_type) - sym_file->CompleteType (clang_type); - } +void ClangASTContext::CompleteTagDecl(void *baton, clang::TagDecl *decl) { + ClangASTContext *ast = (ClangASTContext *)baton; + SymbolFile *sym_file = ast->GetSymbolFile(); + if (sym_file) { + CompilerType clang_type = GetTypeForDecl(decl); + if (clang_type) + sym_file->CompleteType(clang_type); + } } -void -ClangASTContext::CompleteObjCInterfaceDecl (void *baton, clang::ObjCInterfaceDecl *decl) -{ - ClangASTContext *ast = (ClangASTContext *)baton; - SymbolFile *sym_file = ast->GetSymbolFile(); - if (sym_file) - { - CompilerType clang_type = GetTypeForDecl (decl); - if (clang_type) - sym_file->CompleteType (clang_type); - } +void ClangASTContext::CompleteObjCInterfaceDecl( + void *baton, clang::ObjCInterfaceDecl *decl) { + ClangASTContext *ast = (ClangASTContext *)baton; + SymbolFile *sym_file = ast->GetSymbolFile(); + if (sym_file) { + CompilerType clang_type = GetTypeForDecl(decl); + if (clang_type) + sym_file->CompleteType(clang_type); + } } -DWARFASTParser * -ClangASTContext::GetDWARFParser() -{ - if (!m_dwarf_ast_parser_ap) - m_dwarf_ast_parser_ap.reset(new DWARFASTParserClang(*this)); - return m_dwarf_ast_parser_ap.get(); +DWARFASTParser *ClangASTContext::GetDWARFParser() { + if (!m_dwarf_ast_parser_ap) + m_dwarf_ast_parser_ap.reset(new DWARFASTParserClang(*this)); + return m_dwarf_ast_parser_ap.get(); } -PDBASTParser * -ClangASTContext::GetPDBParser() -{ - if (!m_pdb_ast_parser_ap) - m_pdb_ast_parser_ap.reset(new PDBASTParser(*this)); - return m_pdb_ast_parser_ap.get(); +PDBASTParser *ClangASTContext::GetPDBParser() { + if (!m_pdb_ast_parser_ap) + m_pdb_ast_parser_ap.reset(new PDBASTParser(*this)); + return m_pdb_ast_parser_ap.get(); } -bool -ClangASTContext::LayoutRecordType(void *baton, - const clang::RecordDecl *record_decl, - uint64_t &bit_size, - uint64_t &alignment, - llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets, - llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets, - llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets) -{ - ClangASTContext *ast = (ClangASTContext *)baton; - DWARFASTParserClang *dwarf_ast_parser = (DWARFASTParserClang *)ast->GetDWARFParser(); - return dwarf_ast_parser->GetClangASTImporter().LayoutRecordType(record_decl, bit_size, alignment, field_offsets, - base_offsets, vbase_offsets); +bool ClangASTContext::LayoutRecordType( + void *baton, const clang::RecordDecl *record_decl, uint64_t &bit_size, + uint64_t &alignment, + llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets, + llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> + &base_offsets, + llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> + &vbase_offsets) { + ClangASTContext *ast = (ClangASTContext *)baton; + DWARFASTParserClang *dwarf_ast_parser = + (DWARFASTParserClang *)ast->GetDWARFParser(); + return dwarf_ast_parser->GetClangASTImporter().LayoutRecordType( + record_decl, bit_size, alignment, field_offsets, base_offsets, + vbase_offsets); } //---------------------------------------------------------------------- // CompilerDecl override functions //---------------------------------------------------------------------- -ConstString -ClangASTContext::DeclGetName (void *opaque_decl) -{ - if (opaque_decl) - { - clang::NamedDecl *nd = llvm::dyn_cast<NamedDecl>((clang::Decl*)opaque_decl); - if (nd != nullptr) - return ConstString(nd->getDeclName().getAsString()); - } - return ConstString(); -} - -ConstString -ClangASTContext::DeclGetMangledName (void *opaque_decl) -{ - if (opaque_decl) - { - clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>((clang::Decl*)opaque_decl); - if (nd != nullptr && !llvm::isa<clang::ObjCMethodDecl>(nd)) - { - clang::MangleContext *mc = getMangleContext(); - if (mc && mc->shouldMangleCXXName(nd)) - { - llvm::SmallVector<char, 1024> buf; - llvm::raw_svector_ostream llvm_ostrm (buf); - if (llvm::isa<clang::CXXConstructorDecl>(nd)) - { - mc->mangleCXXCtor(llvm::dyn_cast<clang::CXXConstructorDecl>(nd), Ctor_Complete, llvm_ostrm); - } - else if (llvm::isa<clang::CXXDestructorDecl>(nd)) - { - mc->mangleCXXDtor(llvm::dyn_cast<clang::CXXDestructorDecl>(nd), Dtor_Complete, llvm_ostrm); - } - else - { - mc->mangleName(nd, llvm_ostrm); - } - if (buf.size() > 0) - return ConstString(buf.data(), buf.size()); - } +ConstString ClangASTContext::DeclGetName(void *opaque_decl) { + if (opaque_decl) { + clang::NamedDecl *nd = + llvm::dyn_cast<NamedDecl>((clang::Decl *)opaque_decl); + if (nd != nullptr) + return ConstString(nd->getDeclName().getAsString()); + } + return ConstString(); +} + +ConstString ClangASTContext::DeclGetMangledName(void *opaque_decl) { + if (opaque_decl) { + clang::NamedDecl *nd = + llvm::dyn_cast<clang::NamedDecl>((clang::Decl *)opaque_decl); + if (nd != nullptr && !llvm::isa<clang::ObjCMethodDecl>(nd)) { + clang::MangleContext *mc = getMangleContext(); + if (mc && mc->shouldMangleCXXName(nd)) { + llvm::SmallVector<char, 1024> buf; + llvm::raw_svector_ostream llvm_ostrm(buf); + if (llvm::isa<clang::CXXConstructorDecl>(nd)) { + mc->mangleCXXCtor(llvm::dyn_cast<clang::CXXConstructorDecl>(nd), + Ctor_Complete, llvm_ostrm); + } else if (llvm::isa<clang::CXXDestructorDecl>(nd)) { + mc->mangleCXXDtor(llvm::dyn_cast<clang::CXXDestructorDecl>(nd), + Dtor_Complete, llvm_ostrm); + } else { + mc->mangleName(nd, llvm_ostrm); } + if (buf.size() > 0) + return ConstString(buf.data(), buf.size()); + } } - return ConstString(); + } + return ConstString(); } -CompilerDeclContext -ClangASTContext::DeclGetDeclContext (void *opaque_decl) -{ - if (opaque_decl) - return CompilerDeclContext(this, ((clang::Decl*)opaque_decl)->getDeclContext()); - else - return CompilerDeclContext(); +CompilerDeclContext ClangASTContext::DeclGetDeclContext(void *opaque_decl) { + if (opaque_decl) + return CompilerDeclContext(this, + ((clang::Decl *)opaque_decl)->getDeclContext()); + else + return CompilerDeclContext(); } -CompilerType -ClangASTContext::DeclGetFunctionReturnType(void *opaque_decl) -{ - if (clang::FunctionDecl *func_decl = llvm::dyn_cast<clang::FunctionDecl>((clang::Decl*)opaque_decl)) - return CompilerType(this, func_decl->getReturnType().getAsOpaquePtr()); - if (clang::ObjCMethodDecl *objc_method = llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl*)opaque_decl)) - return CompilerType(this, objc_method->getReturnType().getAsOpaquePtr()); - else - return CompilerType(); +CompilerType ClangASTContext::DeclGetFunctionReturnType(void *opaque_decl) { + if (clang::FunctionDecl *func_decl = + llvm::dyn_cast<clang::FunctionDecl>((clang::Decl *)opaque_decl)) + return CompilerType(this, func_decl->getReturnType().getAsOpaquePtr()); + if (clang::ObjCMethodDecl *objc_method = + llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl *)opaque_decl)) + return CompilerType(this, objc_method->getReturnType().getAsOpaquePtr()); + else + return CompilerType(); } -size_t -ClangASTContext::DeclGetFunctionNumArguments(void *opaque_decl) -{ - if (clang::FunctionDecl *func_decl = llvm::dyn_cast<clang::FunctionDecl>((clang::Decl*)opaque_decl)) - return func_decl->param_size(); - if (clang::ObjCMethodDecl *objc_method = llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl*)opaque_decl)) - return objc_method->param_size(); - else - return 0; +size_t ClangASTContext::DeclGetFunctionNumArguments(void *opaque_decl) { + if (clang::FunctionDecl *func_decl = + llvm::dyn_cast<clang::FunctionDecl>((clang::Decl *)opaque_decl)) + return func_decl->param_size(); + if (clang::ObjCMethodDecl *objc_method = + llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl *)opaque_decl)) + return objc_method->param_size(); + else + return 0; } -CompilerType -ClangASTContext::DeclGetFunctionArgumentType (void *opaque_decl, size_t idx) -{ - if (clang::FunctionDecl *func_decl = llvm::dyn_cast<clang::FunctionDecl>((clang::Decl*)opaque_decl)) - { - if (idx < func_decl->param_size()) - { - ParmVarDecl *var_decl = func_decl->getParamDecl(idx); - if (var_decl) - return CompilerType(this, var_decl->getOriginalType().getAsOpaquePtr()); - } - } - else if (clang::ObjCMethodDecl *objc_method = llvm::dyn_cast<clang::ObjCMethodDecl>((clang::Decl*)opaque_decl)) - { - if (idx < objc_method->param_size()) - return CompilerType(this, objc_method->parameters()[idx]->getOriginalType().getAsOpaquePtr()); +CompilerType ClangASTContext::DeclGetFunctionArgumentType(void *opaque_decl, + size_t idx) { + if (clang::FunctionDecl *func_decl = + llvm::dyn_cast<clang::FunctionDecl>((clang::Decl *)opaque_decl)) { + if (idx < func_decl->param_size()) { + ParmVarDecl *var_decl = func_decl->getParamDecl(idx); + if (var_decl) + return CompilerType(this, var_decl->getOriginalType().getAsOpaquePtr()); } - return CompilerType(); + } else if (clang::ObjCMethodDecl *objc_method = + llvm::dyn_cast<clang::ObjCMethodDecl>( + (clang::Decl *)opaque_decl)) { + if (idx < objc_method->param_size()) + return CompilerType( + this, + objc_method->parameters()[idx]->getOriginalType().getAsOpaquePtr()); + } + return CompilerType(); } //---------------------------------------------------------------------- // CompilerDeclContext functions //---------------------------------------------------------------------- -std::vector<CompilerDecl> -ClangASTContext::DeclContextFindDeclByName(void *opaque_decl_ctx, - ConstString name, - const bool ignore_using_decls) -{ - std::vector<CompilerDecl> found_decls; - if (opaque_decl_ctx) - { - DeclContext *root_decl_ctx = (DeclContext *)opaque_decl_ctx; - std::set<DeclContext *> searched; - std::multimap<DeclContext *, DeclContext *> search_queue; - SymbolFile *symbol_file = GetSymbolFile(); - - for (clang::DeclContext *decl_context = root_decl_ctx; decl_context != nullptr && found_decls.empty(); decl_context = decl_context->getParent()) - { - search_queue.insert(std::make_pair(decl_context, decl_context)); - - for (auto it = search_queue.find(decl_context); it != search_queue.end(); it++) - { - if (!searched.insert(it->second).second) - continue; - symbol_file->ParseDeclsForContext(CompilerDeclContext(this, it->second)); - - for (clang::Decl *child : it->second->decls()) - { - if (clang::UsingDirectiveDecl *ud = llvm::dyn_cast<clang::UsingDirectiveDecl>(child)) - { - if (ignore_using_decls) - continue; - clang::DeclContext *from = ud->getCommonAncestor(); - if (searched.find(ud->getNominatedNamespace()) == searched.end()) - search_queue.insert(std::make_pair(from, ud->getNominatedNamespace())); - } - else if (clang::UsingDecl *ud = llvm::dyn_cast<clang::UsingDecl>(child)) - { - if (ignore_using_decls) - continue; - for (clang::UsingShadowDecl *usd : ud->shadows()) - { - clang::Decl *target = usd->getTargetDecl(); - if (clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(target)) - { - IdentifierInfo *ii = nd->getIdentifier(); - if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr))) - found_decls.push_back(CompilerDecl(this, nd)); - } - } - } - else if (clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(child)) - { - IdentifierInfo *ii = nd->getIdentifier(); - if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr))) - found_decls.push_back(CompilerDecl(this, nd)); - } - } +std::vector<CompilerDecl> ClangASTContext::DeclContextFindDeclByName( + void *opaque_decl_ctx, ConstString name, const bool ignore_using_decls) { + std::vector<CompilerDecl> found_decls; + if (opaque_decl_ctx) { + DeclContext *root_decl_ctx = (DeclContext *)opaque_decl_ctx; + std::set<DeclContext *> searched; + std::multimap<DeclContext *, DeclContext *> search_queue; + SymbolFile *symbol_file = GetSymbolFile(); + + for (clang::DeclContext *decl_context = root_decl_ctx; + decl_context != nullptr && found_decls.empty(); + decl_context = decl_context->getParent()) { + search_queue.insert(std::make_pair(decl_context, decl_context)); + + for (auto it = search_queue.find(decl_context); it != search_queue.end(); + it++) { + if (!searched.insert(it->second).second) + continue; + symbol_file->ParseDeclsForContext( + CompilerDeclContext(this, it->second)); + + for (clang::Decl *child : it->second->decls()) { + if (clang::UsingDirectiveDecl *ud = + llvm::dyn_cast<clang::UsingDirectiveDecl>(child)) { + if (ignore_using_decls) + continue; + clang::DeclContext *from = ud->getCommonAncestor(); + if (searched.find(ud->getNominatedNamespace()) == searched.end()) + search_queue.insert( + std::make_pair(from, ud->getNominatedNamespace())); + } else if (clang::UsingDecl *ud = + llvm::dyn_cast<clang::UsingDecl>(child)) { + if (ignore_using_decls) + continue; + for (clang::UsingShadowDecl *usd : ud->shadows()) { + clang::Decl *target = usd->getTargetDecl(); + if (clang::NamedDecl *nd = + llvm::dyn_cast<clang::NamedDecl>(target)) { + IdentifierInfo *ii = nd->getIdentifier(); + if (ii != nullptr && + ii->getName().equals(name.AsCString(nullptr))) + found_decls.push_back(CompilerDecl(this, nd)); + } } + } else if (clang::NamedDecl *nd = + llvm::dyn_cast<clang::NamedDecl>(child)) { + IdentifierInfo *ii = nd->getIdentifier(); + if (ii != nullptr && ii->getName().equals(name.AsCString(nullptr))) + found_decls.push_back(CompilerDecl(this, nd)); + } } + } } - return found_decls; + } + return found_decls; } // Look for child_decl_ctx's lookup scope in frame_decl_ctx and its parents, -// and return the number of levels it took to find it, or LLDB_INVALID_DECL_LEVEL -// if not found. If the decl was imported via a using declaration, its name and/or -// type, if set, will be used to check that the decl found in the scope is a match. +// and return the number of levels it took to find it, or +// LLDB_INVALID_DECL_LEVEL +// if not found. If the decl was imported via a using declaration, its name +// and/or +// type, if set, will be used to check that the decl found in the scope is a +// match. // -// The optional name is required by languages (like C++) to handle using declarations +// The optional name is required by languages (like C++) to handle using +// declarations // like: // // void poo(); @@ -9927,288 +9804,269 @@ ClangASTContext::DeclContextFindDeclByName(void *opaque_decl_ctx, // } // // NOTE: Because file statics are at the TranslationUnit along with globals, a -// function at file scope will return the same level as a function at global scope. -// Ideally we'd like to treat the file scope as an additional scope just below the -// global scope. More work needs to be done to recognise that, if the decl we're -// trying to look up is static, we should compare its source file with that of the +// function at file scope will return the same level as a function at global +// scope. +// Ideally we'd like to treat the file scope as an additional scope just below +// the +// global scope. More work needs to be done to recognise that, if the decl +// we're +// trying to look up is static, we should compare its source file with that of +// the // current scope and return a lower number for it. -uint32_t -ClangASTContext::CountDeclLevels (clang::DeclContext *frame_decl_ctx, - clang::DeclContext *child_decl_ctx, - ConstString *child_name, - CompilerType *child_type) -{ - if (frame_decl_ctx) - { - std::set<DeclContext *> searched; - std::multimap<DeclContext *, DeclContext *> search_queue; - SymbolFile *symbol_file = GetSymbolFile(); - - // Get the lookup scope for the decl we're trying to find. - clang::DeclContext *parent_decl_ctx = child_decl_ctx->getParent(); - - // Look for it in our scope's decl context and its parents. - uint32_t level = 0; - for (clang::DeclContext *decl_ctx = frame_decl_ctx; decl_ctx != nullptr; decl_ctx = decl_ctx->getParent()) - { - if (!decl_ctx->isLookupContext()) - continue; - if (decl_ctx == parent_decl_ctx) - // Found it! - return level; - search_queue.insert(std::make_pair(decl_ctx, decl_ctx)); - for (auto it = search_queue.find(decl_ctx); it != search_queue.end(); it++) - { - if (searched.find(it->second) != searched.end()) +uint32_t ClangASTContext::CountDeclLevels(clang::DeclContext *frame_decl_ctx, + clang::DeclContext *child_decl_ctx, + ConstString *child_name, + CompilerType *child_type) { + if (frame_decl_ctx) { + std::set<DeclContext *> searched; + std::multimap<DeclContext *, DeclContext *> search_queue; + SymbolFile *symbol_file = GetSymbolFile(); + + // Get the lookup scope for the decl we're trying to find. + clang::DeclContext *parent_decl_ctx = child_decl_ctx->getParent(); + + // Look for it in our scope's decl context and its parents. + uint32_t level = 0; + for (clang::DeclContext *decl_ctx = frame_decl_ctx; decl_ctx != nullptr; + decl_ctx = decl_ctx->getParent()) { + if (!decl_ctx->isLookupContext()) + continue; + if (decl_ctx == parent_decl_ctx) + // Found it! + return level; + search_queue.insert(std::make_pair(decl_ctx, decl_ctx)); + for (auto it = search_queue.find(decl_ctx); it != search_queue.end(); + it++) { + if (searched.find(it->second) != searched.end()) + continue; + + // Currently DWARF has one shared translation unit for all Decls at top + // level, so this + // would erroneously find using statements anywhere. So don't look at + // the top-level + // translation unit. + // TODO fix this and add a testcase that depends on it. + + if (llvm::isa<clang::TranslationUnitDecl>(it->second)) + continue; + + searched.insert(it->second); + symbol_file->ParseDeclsForContext( + CompilerDeclContext(this, it->second)); + + for (clang::Decl *child : it->second->decls()) { + if (clang::UsingDirectiveDecl *ud = + llvm::dyn_cast<clang::UsingDirectiveDecl>(child)) { + clang::DeclContext *ns = ud->getNominatedNamespace(); + if (ns == parent_decl_ctx) + // Found it! + return level; + clang::DeclContext *from = ud->getCommonAncestor(); + if (searched.find(ns) == searched.end()) + search_queue.insert(std::make_pair(from, ns)); + } else if (child_name) { + if (clang::UsingDecl *ud = + llvm::dyn_cast<clang::UsingDecl>(child)) { + for (clang::UsingShadowDecl *usd : ud->shadows()) { + clang::Decl *target = usd->getTargetDecl(); + clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(target); + if (!nd) + continue; + // Check names. + IdentifierInfo *ii = nd->getIdentifier(); + if (ii == nullptr || + !ii->getName().equals(child_name->AsCString(nullptr))) + continue; + // Check types, if one was provided. + if (child_type) { + CompilerType clang_type = ClangASTContext::GetTypeForDecl(nd); + if (!AreTypesSame(clang_type, *child_type, + /*ignore_qualifiers=*/true)) continue; - - // Currently DWARF has one shared translation unit for all Decls at top level, so this - // would erroneously find using statements anywhere. So don't look at the top-level - // translation unit. - // TODO fix this and add a testcase that depends on it. - - if (llvm::isa<clang::TranslationUnitDecl>(it->second)) - continue; - - searched.insert(it->second); - symbol_file->ParseDeclsForContext(CompilerDeclContext(this, it->second)); - - for (clang::Decl *child : it->second->decls()) - { - if (clang::UsingDirectiveDecl *ud = llvm::dyn_cast<clang::UsingDirectiveDecl>(child)) - { - clang::DeclContext *ns = ud->getNominatedNamespace(); - if (ns == parent_decl_ctx) - // Found it! - return level; - clang::DeclContext *from = ud->getCommonAncestor(); - if (searched.find(ns) == searched.end()) - search_queue.insert(std::make_pair(from, ns)); - } - else if (child_name) - { - if (clang::UsingDecl *ud = llvm::dyn_cast<clang::UsingDecl>(child)) - { - for (clang::UsingShadowDecl *usd : ud->shadows()) - { - clang::Decl *target = usd->getTargetDecl(); - clang::NamedDecl *nd = llvm::dyn_cast<clang::NamedDecl>(target); - if (!nd) - continue; - // Check names. - IdentifierInfo *ii = nd->getIdentifier(); - if (ii == nullptr || !ii->getName().equals(child_name->AsCString(nullptr))) - continue; - // Check types, if one was provided. - if (child_type) - { - CompilerType clang_type = ClangASTContext::GetTypeForDecl(nd); - if (!AreTypesSame(clang_type, *child_type, /*ignore_qualifiers=*/true)) - continue; - } - // Found it! - return level; - } - } - } } + // Found it! + return level; + } } - ++level; + } } + } + ++level; } - return LLDB_INVALID_DECL_LEVEL; + } + return LLDB_INVALID_DECL_LEVEL; } -bool -ClangASTContext::DeclContextIsStructUnionOrClass (void *opaque_decl_ctx) -{ - if (opaque_decl_ctx) - return ((clang::DeclContext *)opaque_decl_ctx)->isRecord(); - else - return false; +bool ClangASTContext::DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) { + if (opaque_decl_ctx) + return ((clang::DeclContext *)opaque_decl_ctx)->isRecord(); + else + return false; } -ConstString -ClangASTContext::DeclContextGetName (void *opaque_decl_ctx) -{ - if (opaque_decl_ctx) - { - clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx); - if (named_decl) - return ConstString(named_decl->getName()); - } - return ConstString(); +ConstString ClangASTContext::DeclContextGetName(void *opaque_decl_ctx) { + if (opaque_decl_ctx) { + clang::NamedDecl *named_decl = + llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx); + if (named_decl) + return ConstString(named_decl->getName()); + } + return ConstString(); } ConstString -ClangASTContext::DeclContextGetScopeQualifiedName (void *opaque_decl_ctx) -{ - if (opaque_decl_ctx) - { - clang::NamedDecl *named_decl = llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx); - if (named_decl) - return ConstString(llvm::StringRef(named_decl->getQualifiedNameAsString())); - } - return ConstString(); -} - -bool -ClangASTContext::DeclContextIsClassMethod (void *opaque_decl_ctx, - lldb::LanguageType *language_ptr, - bool *is_instance_method_ptr, - ConstString *language_object_name_ptr) -{ - if (opaque_decl_ctx) - { - clang::DeclContext *decl_ctx = (clang::DeclContext *)opaque_decl_ctx; - if (ObjCMethodDecl *objc_method = llvm::dyn_cast<clang::ObjCMethodDecl>(decl_ctx)) - { - if (is_instance_method_ptr) - *is_instance_method_ptr = objc_method->isInstanceMethod(); - if (language_ptr) - *language_ptr = eLanguageTypeObjC; - if (language_object_name_ptr) - language_object_name_ptr->SetCString("self"); - return true; - } - else if (CXXMethodDecl *cxx_method = llvm::dyn_cast<clang::CXXMethodDecl>(decl_ctx)) - { - if (is_instance_method_ptr) - *is_instance_method_ptr = cxx_method->isInstance(); - if (language_ptr) - *language_ptr = eLanguageTypeC_plus_plus; - if (language_object_name_ptr) - language_object_name_ptr->SetCString("this"); - return true; - } - else if (clang::FunctionDecl *function_decl = llvm::dyn_cast<clang::FunctionDecl>(decl_ctx)) - { - ClangASTMetadata *metadata = GetMetadata (&decl_ctx->getParentASTContext(), function_decl); - if (metadata && metadata->HasObjectPtr()) - { - if (is_instance_method_ptr) - *is_instance_method_ptr = true; - if (language_ptr) - *language_ptr = eLanguageTypeObjC; - if (language_object_name_ptr) - language_object_name_ptr->SetCString (metadata->GetObjectPtrName()); - return true; - } - } +ClangASTContext::DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) { + if (opaque_decl_ctx) { + clang::NamedDecl *named_decl = + llvm::dyn_cast<clang::NamedDecl>((clang::DeclContext *)opaque_decl_ctx); + if (named_decl) + return ConstString( + llvm::StringRef(named_decl->getQualifiedNameAsString())); + } + return ConstString(); +} + +bool ClangASTContext::DeclContextIsClassMethod( + void *opaque_decl_ctx, lldb::LanguageType *language_ptr, + bool *is_instance_method_ptr, ConstString *language_object_name_ptr) { + if (opaque_decl_ctx) { + clang::DeclContext *decl_ctx = (clang::DeclContext *)opaque_decl_ctx; + if (ObjCMethodDecl *objc_method = + llvm::dyn_cast<clang::ObjCMethodDecl>(decl_ctx)) { + if (is_instance_method_ptr) + *is_instance_method_ptr = objc_method->isInstanceMethod(); + if (language_ptr) + *language_ptr = eLanguageTypeObjC; + if (language_object_name_ptr) + language_object_name_ptr->SetCString("self"); + return true; + } else if (CXXMethodDecl *cxx_method = + llvm::dyn_cast<clang::CXXMethodDecl>(decl_ctx)) { + if (is_instance_method_ptr) + *is_instance_method_ptr = cxx_method->isInstance(); + if (language_ptr) + *language_ptr = eLanguageTypeC_plus_plus; + if (language_object_name_ptr) + language_object_name_ptr->SetCString("this"); + return true; + } else if (clang::FunctionDecl *function_decl = + llvm::dyn_cast<clang::FunctionDecl>(decl_ctx)) { + ClangASTMetadata *metadata = + GetMetadata(&decl_ctx->getParentASTContext(), function_decl); + if (metadata && metadata->HasObjectPtr()) { + if (is_instance_method_ptr) + *is_instance_method_ptr = true; + if (language_ptr) + *language_ptr = eLanguageTypeObjC; + if (language_object_name_ptr) + language_object_name_ptr->SetCString(metadata->GetObjectPtrName()); + return true; + } } - return false; + } + return false; } clang::DeclContext * -ClangASTContext::DeclContextGetAsDeclContext (const CompilerDeclContext &dc) -{ - if (dc.IsClang()) - return (clang::DeclContext *)dc.GetOpaqueDeclContext(); - return nullptr; +ClangASTContext::DeclContextGetAsDeclContext(const CompilerDeclContext &dc) { + if (dc.IsClang()) + return (clang::DeclContext *)dc.GetOpaqueDeclContext(); + return nullptr; } - ObjCMethodDecl * -ClangASTContext::DeclContextGetAsObjCMethodDecl (const CompilerDeclContext &dc) -{ - if (dc.IsClang()) - return llvm::dyn_cast<clang::ObjCMethodDecl>((clang::DeclContext *)dc.GetOpaqueDeclContext()); - return nullptr; +ClangASTContext::DeclContextGetAsObjCMethodDecl(const CompilerDeclContext &dc) { + if (dc.IsClang()) + return llvm::dyn_cast<clang::ObjCMethodDecl>( + (clang::DeclContext *)dc.GetOpaqueDeclContext()); + return nullptr; } CXXMethodDecl * -ClangASTContext::DeclContextGetAsCXXMethodDecl (const CompilerDeclContext &dc) -{ - if (dc.IsClang()) - return llvm::dyn_cast<clang::CXXMethodDecl>((clang::DeclContext *)dc.GetOpaqueDeclContext()); - return nullptr; +ClangASTContext::DeclContextGetAsCXXMethodDecl(const CompilerDeclContext &dc) { + if (dc.IsClang()) + return llvm::dyn_cast<clang::CXXMethodDecl>( + (clang::DeclContext *)dc.GetOpaqueDeclContext()); + return nullptr; } clang::FunctionDecl * -ClangASTContext::DeclContextGetAsFunctionDecl (const CompilerDeclContext &dc) -{ - if (dc.IsClang()) - return llvm::dyn_cast<clang::FunctionDecl>((clang::DeclContext *)dc.GetOpaqueDeclContext()); - return nullptr; +ClangASTContext::DeclContextGetAsFunctionDecl(const CompilerDeclContext &dc) { + if (dc.IsClang()) + return llvm::dyn_cast<clang::FunctionDecl>( + (clang::DeclContext *)dc.GetOpaqueDeclContext()); + return nullptr; } clang::NamespaceDecl * -ClangASTContext::DeclContextGetAsNamespaceDecl (const CompilerDeclContext &dc) -{ - if (dc.IsClang()) - return llvm::dyn_cast<clang::NamespaceDecl>((clang::DeclContext *)dc.GetOpaqueDeclContext()); - return nullptr; +ClangASTContext::DeclContextGetAsNamespaceDecl(const CompilerDeclContext &dc) { + if (dc.IsClang()) + return llvm::dyn_cast<clang::NamespaceDecl>( + (clang::DeclContext *)dc.GetOpaqueDeclContext()); + return nullptr; } ClangASTMetadata * -ClangASTContext::DeclContextGetMetaData (const CompilerDeclContext &dc, const void *object) -{ - clang::ASTContext *ast = DeclContextGetClangASTContext (dc); - if (ast) - return ClangASTContext::GetMetadata (ast, object); - return nullptr; +ClangASTContext::DeclContextGetMetaData(const CompilerDeclContext &dc, + const void *object) { + clang::ASTContext *ast = DeclContextGetClangASTContext(dc); + if (ast) + return ClangASTContext::GetMetadata(ast, object); + return nullptr; } clang::ASTContext * -ClangASTContext::DeclContextGetClangASTContext (const CompilerDeclContext &dc) -{ - ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(dc.GetTypeSystem()); - if (ast) - return ast->getASTContext(); +ClangASTContext::DeclContextGetClangASTContext(const CompilerDeclContext &dc) { + ClangASTContext *ast = + llvm::dyn_cast_or_null<ClangASTContext>(dc.GetTypeSystem()); + if (ast) + return ast->getASTContext(); + return nullptr; +} + +ClangASTContextForExpressions::ClangASTContextForExpressions(Target &target) + : ClangASTContext(target.GetArchitecture().GetTriple().getTriple().c_str()), + m_target_wp(target.shared_from_this()), + m_persistent_variables(new ClangPersistentVariables) {} + +UserExpression *ClangASTContextForExpressions::GetUserExpression( + const char *expr, const char *expr_prefix, lldb::LanguageType language, + Expression::ResultType desired_type, + const EvaluateExpressionOptions &options) { + TargetSP target_sp = m_target_wp.lock(); + if (!target_sp) return nullptr; + + return new ClangUserExpression(*target_sp.get(), expr, expr_prefix, language, + desired_type, options); } -ClangASTContextForExpressions::ClangASTContextForExpressions (Target &target) : - ClangASTContext (target.GetArchitecture().GetTriple().getTriple().c_str()), - m_target_wp(target.shared_from_this()), - m_persistent_variables (new ClangPersistentVariables) -{ -} - -UserExpression * -ClangASTContextForExpressions::GetUserExpression (const char *expr, - const char *expr_prefix, - lldb::LanguageType language, - Expression::ResultType desired_type, - const EvaluateExpressionOptions &options) -{ - TargetSP target_sp = m_target_wp.lock(); - if (!target_sp) - return nullptr; - - return new ClangUserExpression(*target_sp.get(), expr, expr_prefix, language, desired_type, options); -} - -FunctionCaller * -ClangASTContextForExpressions::GetFunctionCaller (const CompilerType &return_type, - const Address& function_address, - const ValueList &arg_value_list, - const char *name) -{ - TargetSP target_sp = m_target_wp.lock(); - if (!target_sp) - return nullptr; - - Process *process = target_sp->GetProcessSP().get(); - if (!process) - return nullptr; - - return new ClangFunctionCaller (*process, return_type, function_address, arg_value_list, name); +FunctionCaller *ClangASTContextForExpressions::GetFunctionCaller( + const CompilerType &return_type, const Address &function_address, + const ValueList &arg_value_list, const char *name) { + TargetSP target_sp = m_target_wp.lock(); + if (!target_sp) + return nullptr; + + Process *process = target_sp->GetProcessSP().get(); + if (!process) + return nullptr; + + return new ClangFunctionCaller(*process, return_type, function_address, + arg_value_list, name); } UtilityFunction * -ClangASTContextForExpressions::GetUtilityFunction (const char *text, - const char *name) -{ - TargetSP target_sp = m_target_wp.lock(); - if (!target_sp) - return nullptr; - - return new ClangUtilityFunction(*target_sp.get(), text, name); +ClangASTContextForExpressions::GetUtilityFunction(const char *text, + const char *name) { + TargetSP target_sp = m_target_wp.lock(); + if (!target_sp) + return nullptr; + + return new ClangUtilityFunction(*target_sp.get(), text, name); } PersistentExpressionState * -ClangASTContextForExpressions::GetPersistentExpressionState () -{ - return m_persistent_variables.get(); +ClangASTContextForExpressions::GetPersistentExpressionState() { + return m_persistent_variables.get(); } |
