Greg Clayton | 9b8ff51 | 2012-02-01 01:46:19 +0000 | [diff] [blame] | 1 | //===-- ObjCLanguageRuntime.cpp ---------------------------------*- C++ -*-===// |
Jim Ingham | 642036f | 2010-09-23 02:01:19 +0000 | [diff] [blame] | 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
Jim Ingham | 324067b | 2010-09-30 00:54:27 +0000 | [diff] [blame] | 9 | #include "clang/AST/Type.h" |
Jim Ingham | 642036f | 2010-09-23 02:01:19 +0000 | [diff] [blame] | 10 | |
Jim Ingham | b66cd07 | 2010-09-28 01:25:32 +0000 | [diff] [blame] | 11 | #include "lldb/Core/Log.h" |
Greg Clayton | 49ce896 | 2012-08-29 21:13:06 +0000 | [diff] [blame] | 12 | #include "lldb/Core/Module.h" |
Jim Ingham | 642036f | 2010-09-23 02:01:19 +0000 | [diff] [blame] | 13 | #include "lldb/Core/PluginManager.h" |
Jim Ingham | 324067b | 2010-09-30 00:54:27 +0000 | [diff] [blame] | 14 | #include "lldb/Core/ValueObject.h" |
| 15 | #include "lldb/Symbol/ClangASTContext.h" |
Jim Ingham | ef80aab | 2011-05-02 18:13:59 +0000 | [diff] [blame] | 16 | #include "lldb/Symbol/Type.h" |
Greg Clayton | 49ce896 | 2012-08-29 21:13:06 +0000 | [diff] [blame] | 17 | #include "lldb/Symbol/TypeList.h" |
Jim Ingham | b66cd07 | 2010-09-28 01:25:32 +0000 | [diff] [blame] | 18 | #include "lldb/Target/ObjCLanguageRuntime.h" |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 19 | #include "lldb/Target/Target.h" |
Jim Ingham | 642036f | 2010-09-23 02:01:19 +0000 | [diff] [blame] | 20 | |
| 21 | using namespace lldb; |
| 22 | using namespace lldb_private; |
| 23 | |
| 24 | //---------------------------------------------------------------------- |
| 25 | // Destructor |
| 26 | //---------------------------------------------------------------------- |
| 27 | ObjCLanguageRuntime::~ObjCLanguageRuntime() |
| 28 | { |
| 29 | } |
| 30 | |
| 31 | ObjCLanguageRuntime::ObjCLanguageRuntime (Process *process) : |
Sean Callanan | 6e12c7a | 2012-03-08 02:39:03 +0000 | [diff] [blame] | 32 | LanguageRuntime (process), |
Sean Callanan | 6fe8d36 | 2012-09-15 01:05:12 +0000 | [diff] [blame] | 33 | m_has_new_literals_and_indexing (eLazyBoolCalculate), |
Greg Clayton | a510437 | 2012-10-11 18:07:21 +0000 | [diff] [blame] | 34 | m_isa_to_descriptor_cache(), |
Greg Clayton | 90c6cd5 | 2012-10-25 16:54:22 +0000 | [diff] [blame] | 35 | m_isa_to_descriptor_cache_stop_id (UINT32_MAX) |
Jim Ingham | 642036f | 2010-09-23 02:01:19 +0000 | [diff] [blame] | 36 | { |
| 37 | |
Jim Ingham | b66cd07 | 2010-09-28 01:25:32 +0000 | [diff] [blame] | 38 | } |
| 39 | |
| 40 | void |
| 41 | ObjCLanguageRuntime::AddToMethodCache (lldb::addr_t class_addr, lldb::addr_t selector, lldb::addr_t impl_addr) |
| 42 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 43 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); |
Jim Ingham | b66cd07 | 2010-09-28 01:25:32 +0000 | [diff] [blame] | 44 | if (log) |
| 45 | { |
Daniel Malea | 5f35a4b | 2012-11-29 21:49:15 +0000 | [diff] [blame^] | 46 | log->Printf ("Caching: class 0x%" PRIx64 " selector 0x%" PRIx64 " implementation 0x%" PRIx64 ".", class_addr, selector, impl_addr); |
Jim Ingham | b66cd07 | 2010-09-28 01:25:32 +0000 | [diff] [blame] | 47 | } |
| 48 | m_impl_cache.insert (std::pair<ClassAndSel,lldb::addr_t> (ClassAndSel(class_addr, selector), impl_addr)); |
| 49 | } |
| 50 | |
| 51 | lldb::addr_t |
| 52 | ObjCLanguageRuntime::LookupInMethodCache (lldb::addr_t class_addr, lldb::addr_t selector) |
| 53 | { |
| 54 | MsgImplMap::iterator pos, end = m_impl_cache.end(); |
| 55 | pos = m_impl_cache.find (ClassAndSel(class_addr, selector)); |
| 56 | if (pos != end) |
| 57 | return (*pos).second; |
| 58 | return LLDB_INVALID_ADDRESS; |
| 59 | } |
Jim Ingham | ef80aab | 2011-05-02 18:13:59 +0000 | [diff] [blame] | 60 | |
Jim Ingham | 5851366 | 2011-06-24 22:03:24 +0000 | [diff] [blame] | 61 | |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 62 | lldb::TypeSP |
| 63 | ObjCLanguageRuntime::LookupInCompleteClassCache (ConstString &name) |
| 64 | { |
| 65 | CompleteClassMap::iterator complete_class_iter = m_complete_class_cache.find(name); |
| 66 | |
| 67 | if (complete_class_iter != m_complete_class_cache.end()) |
| 68 | { |
Greg Clayton | ef22b90 | 2012-10-23 22:41:19 +0000 | [diff] [blame] | 69 | // Check the weak pointer to make sure the type hasn't been unloaded |
| 70 | TypeSP complete_type_sp (complete_class_iter->second.lock()); |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 71 | |
Greg Clayton | ef22b90 | 2012-10-23 22:41:19 +0000 | [diff] [blame] | 72 | if (complete_type_sp) |
| 73 | return complete_type_sp; |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 74 | else |
Greg Clayton | ef22b90 | 2012-10-23 22:41:19 +0000 | [diff] [blame] | 75 | m_complete_class_cache.erase(name); |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 76 | } |
| 77 | |
Enrico Granata | 146d952 | 2012-11-08 02:22:02 +0000 | [diff] [blame] | 78 | const ModuleList &modules = m_process->GetTarget().GetImages(); |
Greg Clayton | ef22b90 | 2012-10-23 22:41:19 +0000 | [diff] [blame] | 79 | |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 80 | SymbolContextList sc_list; |
Greg Clayton | ef22b90 | 2012-10-23 22:41:19 +0000 | [diff] [blame] | 81 | const size_t matching_symbols = modules.FindSymbolsWithNameAndType (name, |
| 82 | eSymbolTypeObjCClass, |
| 83 | sc_list); |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 84 | |
Greg Clayton | ef22b90 | 2012-10-23 22:41:19 +0000 | [diff] [blame] | 85 | if (matching_symbols) |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 86 | { |
Greg Clayton | ef22b90 | 2012-10-23 22:41:19 +0000 | [diff] [blame] | 87 | SymbolContext sc; |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 88 | |
Greg Clayton | ef22b90 | 2012-10-23 22:41:19 +0000 | [diff] [blame] | 89 | sc_list.GetContextAtIndex(0, sc); |
| 90 | |
| 91 | ModuleSP module_sp(sc.module_sp); |
| 92 | |
| 93 | if (!module_sp) |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 94 | return TypeSP(); |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 95 | |
Greg Clayton | ef22b90 | 2012-10-23 22:41:19 +0000 | [diff] [blame] | 96 | const SymbolContext null_sc; |
| 97 | const bool exact_match = true; |
| 98 | const uint32_t max_matches = UINT32_MAX; |
| 99 | TypeList types; |
| 100 | |
| 101 | const uint32_t num_types = module_sp->FindTypes (null_sc, |
| 102 | name, |
| 103 | exact_match, |
| 104 | max_matches, |
| 105 | types); |
| 106 | |
| 107 | if (num_types) |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 108 | { |
Greg Clayton | ef22b90 | 2012-10-23 22:41:19 +0000 | [diff] [blame] | 109 | TypeSP incomplete_type_sp; |
| 110 | |
| 111 | uint32_t i; |
| 112 | for (i = 0; i < num_types; ++i) |
| 113 | { |
| 114 | TypeSP type_sp (types.GetTypeAtIndex(i)); |
| 115 | |
| 116 | if (ClangASTContext::IsObjCClassType(type_sp->GetClangForwardType())) |
| 117 | { |
| 118 | if (type_sp->IsCompleteObjCClass()) |
| 119 | { |
| 120 | m_complete_class_cache[name] = type_sp; |
| 121 | return type_sp; |
| 122 | } |
| 123 | else if (!incomplete_type_sp) |
| 124 | incomplete_type_sp = type_sp; |
| 125 | } |
| 126 | } |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 127 | } |
| 128 | } |
Sean Callanan | 931acec | 2012-02-22 23:57:45 +0000 | [diff] [blame] | 129 | return TypeSP(); |
| 130 | } |
| 131 | |
Jim Ingham | 5851366 | 2011-06-24 22:03:24 +0000 | [diff] [blame] | 132 | size_t |
| 133 | ObjCLanguageRuntime::GetByteOffsetForIvar (ClangASTType &parent_qual_type, const char *ivar_name) |
| 134 | { |
| 135 | return LLDB_INVALID_IVAR_OFFSET; |
| 136 | } |
| 137 | |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 138 | |
Greg Clayton | 662e567 | 2012-01-19 03:24:53 +0000 | [diff] [blame] | 139 | uint32_t |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 140 | ObjCLanguageRuntime::ParseMethodName (const char *name, |
Greg Clayton | e14d3d3 | 2012-01-19 00:52:59 +0000 | [diff] [blame] | 141 | ConstString *class_name, // Class name (with category if any) |
| 142 | ConstString *selector_name, // selector on its own |
| 143 | ConstString *name_sans_category, // Full function prototype with no category |
| 144 | ConstString *class_name_sans_category)// Class name with no category (or empty if no category as answer will be in "class_name" |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 145 | { |
Greg Clayton | e14d3d3 | 2012-01-19 00:52:59 +0000 | [diff] [blame] | 146 | if (class_name) |
| 147 | class_name->Clear(); |
| 148 | if (selector_name) |
| 149 | selector_name->Clear(); |
| 150 | if (name_sans_category) |
| 151 | name_sans_category->Clear(); |
| 152 | if (class_name_sans_category) |
| 153 | class_name_sans_category->Clear(); |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 154 | |
Greg Clayton | 662e567 | 2012-01-19 03:24:53 +0000 | [diff] [blame] | 155 | uint32_t result = 0; |
| 156 | |
Jim Ingham | fdf24ef | 2011-09-08 22:13:49 +0000 | [diff] [blame] | 157 | if (IsPossibleObjCMethodName (name)) |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 158 | { |
| 159 | int name_len = strlen (name); |
| 160 | // Objective C methods must have at least: |
| 161 | // "-[" or "+[" prefix |
| 162 | // One character for a class name |
| 163 | // One character for the space between the class name |
| 164 | // One character for the method name |
| 165 | // "]" suffix |
| 166 | if (name_len >= 6 && name[name_len - 1] == ']') |
| 167 | { |
Greg Clayton | e14d3d3 | 2012-01-19 00:52:59 +0000 | [diff] [blame] | 168 | const char *selector_name_ptr = strchr (name, ' '); |
Greg Clayton | 00db215 | 2011-10-04 22:41:51 +0000 | [diff] [blame] | 169 | if (selector_name_ptr) |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 170 | { |
| 171 | if (class_name) |
Greg Clayton | 662e567 | 2012-01-19 03:24:53 +0000 | [diff] [blame] | 172 | { |
Greg Clayton | 00db215 | 2011-10-04 22:41:51 +0000 | [diff] [blame] | 173 | class_name->SetCStringWithLength (name + 2, selector_name_ptr - name - 2); |
Greg Clayton | 662e567 | 2012-01-19 03:24:53 +0000 | [diff] [blame] | 174 | ++result; |
| 175 | } |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 176 | |
| 177 | // Skip the space |
Greg Clayton | 00db215 | 2011-10-04 22:41:51 +0000 | [diff] [blame] | 178 | ++selector_name_ptr; |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 179 | // Extract the objective C basename and add it to the |
| 180 | // accelerator tables |
Greg Clayton | 00db215 | 2011-10-04 22:41:51 +0000 | [diff] [blame] | 181 | size_t selector_name_len = name_len - (selector_name_ptr - name) - 1; |
| 182 | if (selector_name) |
Greg Clayton | 662e567 | 2012-01-19 03:24:53 +0000 | [diff] [blame] | 183 | { |
Greg Clayton | 00db215 | 2011-10-04 22:41:51 +0000 | [diff] [blame] | 184 | selector_name->SetCStringWithLength (selector_name_ptr, selector_name_len); |
Greg Clayton | 662e567 | 2012-01-19 03:24:53 +0000 | [diff] [blame] | 185 | ++result; |
| 186 | } |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 187 | |
| 188 | // Also see if this is a "category" on our class. If so strip off the category name, |
| 189 | // and add the class name without it to the basename table. |
| 190 | |
Greg Clayton | e14d3d3 | 2012-01-19 00:52:59 +0000 | [diff] [blame] | 191 | if (name_sans_category || class_name_sans_category) |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 192 | { |
Greg Clayton | e14d3d3 | 2012-01-19 00:52:59 +0000 | [diff] [blame] | 193 | const char *open_paren = strchr (name, '('); |
Greg Clayton | e14d3d3 | 2012-01-19 00:52:59 +0000 | [diff] [blame] | 194 | if (open_paren) |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 195 | { |
Greg Clayton | e14d3d3 | 2012-01-19 00:52:59 +0000 | [diff] [blame] | 196 | if (class_name_sans_category) |
Greg Clayton | 662e567 | 2012-01-19 03:24:53 +0000 | [diff] [blame] | 197 | { |
Greg Clayton | e14d3d3 | 2012-01-19 00:52:59 +0000 | [diff] [blame] | 198 | class_name_sans_category->SetCStringWithLength (name + 2, open_paren - name - 2); |
Greg Clayton | 662e567 | 2012-01-19 03:24:53 +0000 | [diff] [blame] | 199 | ++result; |
| 200 | } |
Sean Callanan | c1cd379 | 2012-01-19 01:10:27 +0000 | [diff] [blame] | 201 | |
| 202 | if (name_sans_category) |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 203 | { |
Greg Clayton | 662e567 | 2012-01-19 03:24:53 +0000 | [diff] [blame] | 204 | const char *close_paren = strchr (open_paren, ')'); |
| 205 | if (open_paren < close_paren) |
Sean Callanan | c1cd379 | 2012-01-19 01:10:27 +0000 | [diff] [blame] | 206 | { |
| 207 | std::string buffer (name, open_paren - name); |
| 208 | buffer.append (close_paren + 1); |
| 209 | name_sans_category->SetCString (buffer.c_str()); |
Greg Clayton | 662e567 | 2012-01-19 03:24:53 +0000 | [diff] [blame] | 210 | ++result; |
Sean Callanan | c1cd379 | 2012-01-19 01:10:27 +0000 | [diff] [blame] | 211 | } |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 212 | } |
| 213 | } |
| 214 | } |
| 215 | } |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 216 | } |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 217 | } |
Greg Clayton | 662e567 | 2012-01-19 03:24:53 +0000 | [diff] [blame] | 218 | return result; |
Jim Ingham | 3ad4da0 | 2011-08-15 01:32:22 +0000 | [diff] [blame] | 219 | } |
Enrico Granata | ae2ae94 | 2012-09-04 18:47:54 +0000 | [diff] [blame] | 220 | |
| 221 | bool |
| 222 | ObjCLanguageRuntime::ClassDescriptor::IsPointerValid (lldb::addr_t value, |
| 223 | uint32_t ptr_size, |
| 224 | bool allow_NULLs, |
| 225 | bool allow_tagged, |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 226 | bool check_version_specific) const |
Enrico Granata | ae2ae94 | 2012-09-04 18:47:54 +0000 | [diff] [blame] | 227 | { |
| 228 | if (!value) |
| 229 | return allow_NULLs; |
| 230 | if ( (value % 2) == 1 && allow_tagged) |
| 231 | return true; |
| 232 | if ((value % ptr_size) == 0) |
| 233 | return (check_version_specific ? CheckPointer(value,ptr_size) : true); |
| 234 | else |
| 235 | return false; |
| 236 | } |
| 237 | |
| 238 | ObjCLanguageRuntime::ObjCISA |
Sean Callanan | c718b96 | 2012-09-11 21:44:01 +0000 | [diff] [blame] | 239 | ObjCLanguageRuntime::GetISA(const ConstString &name) |
| 240 | { |
Sean Callanan | 6fe8d36 | 2012-09-15 01:05:12 +0000 | [diff] [blame] | 241 | UpdateISAToDescriptorMap(); |
Sean Callanan | c718b96 | 2012-09-11 21:44:01 +0000 | [diff] [blame] | 242 | for (const ISAToDescriptorMap::value_type &val : m_isa_to_descriptor_cache) |
| 243 | if (val.second && val.second->GetClassName() == name) |
| 244 | return val.first; |
Sean Callanan | c718b96 | 2012-09-11 21:44:01 +0000 | [diff] [blame] | 245 | return 0; |
| 246 | } |
| 247 | |
| 248 | ObjCLanguageRuntime::ObjCISA |
Enrico Granata | ae2ae94 | 2012-09-04 18:47:54 +0000 | [diff] [blame] | 249 | ObjCLanguageRuntime::GetParentClass(ObjCLanguageRuntime::ObjCISA isa) |
| 250 | { |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 251 | ClassDescriptorSP objc_class_sp (GetClassDescriptor(isa)); |
| 252 | if (objc_class_sp) |
Enrico Granata | ae2ae94 | 2012-09-04 18:47:54 +0000 | [diff] [blame] | 253 | { |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 254 | ClassDescriptorSP objc_super_class_sp (objc_class_sp->GetSuperclass()); |
| 255 | if (objc_super_class_sp) |
| 256 | return objc_super_class_sp->GetISA(); |
Enrico Granata | ae2ae94 | 2012-09-04 18:47:54 +0000 | [diff] [blame] | 257 | } |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 258 | return 0; |
Enrico Granata | ae2ae94 | 2012-09-04 18:47:54 +0000 | [diff] [blame] | 259 | } |
| 260 | |
Enrico Granata | ae2ae94 | 2012-09-04 18:47:54 +0000 | [diff] [blame] | 261 | ConstString |
| 262 | ObjCLanguageRuntime::GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) |
| 263 | { |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 264 | ClassDescriptorSP objc_class_sp (GetNonKVOClassDescriptor(isa)); |
| 265 | if (objc_class_sp) |
| 266 | return objc_class_sp->GetClassName(); |
| 267 | return ConstString(); |
Enrico Granata | ae2ae94 | 2012-09-04 18:47:54 +0000 | [diff] [blame] | 268 | } |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 269 | |
| 270 | ObjCLanguageRuntime::ClassDescriptorSP |
Greg Clayton | a510437 | 2012-10-11 18:07:21 +0000 | [diff] [blame] | 271 | ObjCLanguageRuntime::GetClassDescriptor (const ConstString &class_name) |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 272 | { |
Greg Clayton | a510437 | 2012-10-11 18:07:21 +0000 | [diff] [blame] | 273 | UpdateISAToDescriptorMap(); |
| 274 | for (const ISAToDescriptorMap::value_type &val : m_isa_to_descriptor_cache) |
| 275 | if (val.second && val.second->GetClassName() == class_name) |
| 276 | return val.second; |
| 277 | return ClassDescriptorSP(); |
| 278 | |
| 279 | } |
| 280 | |
| 281 | ObjCLanguageRuntime::ClassDescriptorSP |
| 282 | ObjCLanguageRuntime::GetClassDescriptor (ValueObject& valobj) |
| 283 | { |
| 284 | ClassDescriptorSP objc_class_sp; |
| 285 | // if we get an invalid VO (which might still happen when playing around |
| 286 | // with pointers returned by the expression parser, don't consider this |
| 287 | // a valid ObjC object) |
| 288 | if (valobj.GetValue().GetContextType() != Value::eContextTypeInvalid) |
| 289 | { |
| 290 | addr_t isa_pointer = valobj.GetPointerValue(); |
| 291 | if (isa_pointer != LLDB_INVALID_ADDRESS) |
| 292 | { |
| 293 | ExecutionContext exe_ctx (valobj.GetExecutionContextRef()); |
| 294 | |
| 295 | Process *process = exe_ctx.GetProcessPtr(); |
| 296 | if (process) |
| 297 | { |
| 298 | Error error; |
| 299 | ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error); |
| 300 | if (isa != LLDB_INVALID_ADDRESS) |
| 301 | objc_class_sp = GetClassDescriptor (isa); |
| 302 | } |
| 303 | } |
| 304 | } |
| 305 | return objc_class_sp; |
| 306 | } |
| 307 | |
| 308 | ObjCLanguageRuntime::ClassDescriptorSP |
| 309 | ObjCLanguageRuntime::GetNonKVOClassDescriptor (ValueObject& valobj) |
| 310 | { |
| 311 | ObjCLanguageRuntime::ClassDescriptorSP objc_class_sp (GetClassDescriptor (valobj)); |
| 312 | if (objc_class_sp) |
| 313 | { |
| 314 | if (!objc_class_sp->IsKVO()) |
| 315 | return objc_class_sp; |
| 316 | |
| 317 | ClassDescriptorSP non_kvo_objc_class_sp(objc_class_sp->GetSuperclass()); |
| 318 | if (non_kvo_objc_class_sp && non_kvo_objc_class_sp->IsValid()) |
| 319 | return non_kvo_objc_class_sp; |
| 320 | } |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 321 | return ClassDescriptorSP(); |
| 322 | } |
| 323 | |
Greg Clayton | a510437 | 2012-10-11 18:07:21 +0000 | [diff] [blame] | 324 | |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 325 | ObjCLanguageRuntime::ClassDescriptorSP |
| 326 | ObjCLanguageRuntime::GetClassDescriptor (ObjCISA isa) |
| 327 | { |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 328 | if (isa) |
| 329 | { |
Greg Clayton | a510437 | 2012-10-11 18:07:21 +0000 | [diff] [blame] | 330 | UpdateISAToDescriptorMap(); |
| 331 | ObjCLanguageRuntime::ISAToDescriptorIterator pos = m_isa_to_descriptor_cache.find(isa); |
| 332 | if (pos != m_isa_to_descriptor_cache.end()) |
| 333 | return pos->second; |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 334 | } |
Greg Clayton | a510437 | 2012-10-11 18:07:21 +0000 | [diff] [blame] | 335 | return ClassDescriptorSP(); |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 336 | } |
| 337 | |
| 338 | ObjCLanguageRuntime::ClassDescriptorSP |
| 339 | ObjCLanguageRuntime::GetNonKVOClassDescriptor (ObjCISA isa) |
| 340 | { |
| 341 | if (isa) |
| 342 | { |
| 343 | ClassDescriptorSP objc_class_sp = GetClassDescriptor (isa); |
| 344 | if (objc_class_sp && objc_class_sp->IsValid()) |
| 345 | { |
Greg Clayton | a510437 | 2012-10-11 18:07:21 +0000 | [diff] [blame] | 346 | if (!objc_class_sp->IsKVO()) |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 347 | return objc_class_sp; |
Greg Clayton | a510437 | 2012-10-11 18:07:21 +0000 | [diff] [blame] | 348 | |
| 349 | ClassDescriptorSP non_kvo_objc_class_sp(objc_class_sp->GetSuperclass()); |
| 350 | if (non_kvo_objc_class_sp && non_kvo_objc_class_sp->IsValid()) |
| 351 | return non_kvo_objc_class_sp; |
Greg Clayton | be2f3aa | 2012-10-09 17:51:53 +0000 | [diff] [blame] | 352 | } |
| 353 | } |
| 354 | return ClassDescriptorSP(); |
| 355 | } |
| 356 | |
| 357 | |
| 358 | |