1 //===-- ObjCLanguageRuntime.cpp ---------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 #include "clang/AST/Type.h"
10 
11 #include "lldb/Core/Log.h"
12 #include "lldb/Core/MappedHash.h"
13 #include "lldb/Core/Module.h"
14 #include "lldb/Core/PluginManager.h"
15 #include "lldb/Core/Timer.h"
16 #include "lldb/Core/ValueObject.h"
17 #include "lldb/Symbol/ClangASTContext.h"
18 #include "lldb/Symbol/SymbolContext.h"
19 #include "lldb/Symbol/SymbolFile.h"
20 #include "lldb/Symbol/Type.h"
21 #include "lldb/Symbol/TypeList.h"
22 #include "lldb/Target/ObjCLanguageRuntime.h"
23 #include "lldb/Target/Target.h"
24 
25 #include "llvm/ADT/StringRef.h"
26 
27 using namespace lldb;
28 using namespace lldb_private;
29 
30 //----------------------------------------------------------------------
31 // Destructor
32 //----------------------------------------------------------------------
33 ObjCLanguageRuntime::~ObjCLanguageRuntime()
34 {
35 }
36 
37 ObjCLanguageRuntime::ObjCLanguageRuntime (Process *process) :
38     LanguageRuntime (process),
39     m_impl_cache(),
40     m_has_new_literals_and_indexing (eLazyBoolCalculate),
41     m_isa_to_descriptor(),
42     m_hash_to_isa_map(),
43     m_type_size_cache(),
44     m_isa_to_descriptor_stop_id (UINT32_MAX),
45     m_complete_class_cache(),
46     m_negative_complete_class_cache()
47 {
48 }
49 
50 bool
51 ObjCLanguageRuntime::AddClass (ObjCISA isa, const ClassDescriptorSP &descriptor_sp, const char *class_name)
52 {
53     if (isa != 0)
54     {
55         m_isa_to_descriptor[isa] = descriptor_sp;
56         // class_name is assumed to be valid
57         m_hash_to_isa_map.insert(std::make_pair(MappedHash::HashStringUsingDJB(class_name), isa));
58         return true;
59     }
60     return false;
61 }
62 
63 void
64 ObjCLanguageRuntime::AddToMethodCache (lldb::addr_t class_addr, lldb::addr_t selector, lldb::addr_t impl_addr)
65 {
66     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
67     if (log)
68     {
69         log->Printf ("Caching: class 0x%" PRIx64 " selector 0x%" PRIx64 " implementation 0x%" PRIx64 ".", class_addr, selector, impl_addr);
70     }
71     m_impl_cache.insert (std::pair<ClassAndSel,lldb::addr_t> (ClassAndSel(class_addr, selector), impl_addr));
72 }
73 
74 lldb::addr_t
75 ObjCLanguageRuntime::LookupInMethodCache (lldb::addr_t class_addr, lldb::addr_t selector)
76 {
77     MsgImplMap::iterator pos, end = m_impl_cache.end();
78     pos = m_impl_cache.find (ClassAndSel(class_addr, selector));
79     if (pos != end)
80         return (*pos).second;
81     return LLDB_INVALID_ADDRESS;
82 }
83 
84 
85 lldb::TypeSP
86 ObjCLanguageRuntime::LookupInCompleteClassCache (ConstString &name)
87 {
88     CompleteClassMap::iterator complete_class_iter = m_complete_class_cache.find(name);
89 
90     if (complete_class_iter != m_complete_class_cache.end())
91     {
92         // Check the weak pointer to make sure the type hasn't been unloaded
93         TypeSP complete_type_sp (complete_class_iter->second.lock());
94 
95         if (complete_type_sp)
96             return complete_type_sp;
97         else
98             m_complete_class_cache.erase(name);
99     }
100 
101     if (m_negative_complete_class_cache.count(name) > 0)
102         return TypeSP();
103 
104     const ModuleList &modules = m_process->GetTarget().GetImages();
105 
106     SymbolContextList sc_list;
107     const size_t matching_symbols = modules.FindSymbolsWithNameAndType (name,
108                                                                         eSymbolTypeObjCClass,
109                                                                         sc_list);
110 
111     if (matching_symbols)
112     {
113         SymbolContext sc;
114 
115         sc_list.GetContextAtIndex(0, sc);
116 
117         ModuleSP module_sp(sc.module_sp);
118 
119         if (!module_sp)
120             return TypeSP();
121 
122         const SymbolContext null_sc;
123         const bool exact_match = true;
124         const uint32_t max_matches = UINT32_MAX;
125         TypeList types;
126 
127         llvm::DenseSet<SymbolFile *> searched_symbol_files;
128         const uint32_t num_types = module_sp->FindTypes (null_sc,
129                                                          name,
130                                                          exact_match,
131                                                          max_matches,
132                                                          searched_symbol_files,
133                                                          types);
134 
135         if (num_types)
136         {
137             uint32_t i;
138             for (i = 0; i < num_types; ++i)
139             {
140                 TypeSP type_sp (types.GetTypeAtIndex(i));
141 
142                 if (ClangASTContext::IsObjCObjectOrInterfaceType(type_sp->GetForwardCompilerType ()))
143                 {
144                     if (type_sp->IsCompleteObjCClass())
145                     {
146                         m_complete_class_cache[name] = type_sp;
147                         return type_sp;
148                     }
149                 }
150             }
151         }
152     }
153     m_negative_complete_class_cache.insert(name);
154     return TypeSP();
155 }
156 
157 size_t
158 ObjCLanguageRuntime::GetByteOffsetForIvar (CompilerType &parent_qual_type, const char *ivar_name)
159 {
160     return LLDB_INVALID_IVAR_OFFSET;
161 }
162 
163 bool
164 ObjCLanguageRuntime::ClassDescriptor::IsPointerValid (lldb::addr_t value,
165                                                       uint32_t ptr_size,
166                                                       bool allow_NULLs,
167                                                       bool allow_tagged,
168                                                       bool check_version_specific) const
169 {
170     if (!value)
171         return allow_NULLs;
172     if ( (value % 2) == 1  && allow_tagged)
173         return true;
174     if ((value % ptr_size) == 0)
175         return (check_version_specific ? CheckPointer(value,ptr_size) : true);
176     else
177         return false;
178 }
179 
180 ObjCLanguageRuntime::ObjCISA
181 ObjCLanguageRuntime::GetISA(const ConstString &name)
182 {
183     ISAToDescriptorIterator pos = GetDescriptorIterator (name);
184     if (pos != m_isa_to_descriptor.end())
185         return pos->first;
186     return 0;
187 }
188 
189 ObjCLanguageRuntime::ISAToDescriptorIterator
190 ObjCLanguageRuntime::GetDescriptorIterator (const ConstString &name)
191 {
192     ISAToDescriptorIterator end = m_isa_to_descriptor.end();
193 
194     if (name)
195     {
196         UpdateISAToDescriptorMap();
197         if (m_hash_to_isa_map.empty())
198         {
199             // No name hashes were provided, we need to just linearly power through the
200             // names and find a match
201             for (ISAToDescriptorIterator pos = m_isa_to_descriptor.begin(); pos != end; ++pos)
202             {
203                 if (pos->second->GetClassName() == name)
204                     return pos;
205             }
206         }
207         else
208         {
209             // Name hashes were provided, so use them to efficiently lookup name to isa/descriptor
210             const uint32_t name_hash = MappedHash::HashStringUsingDJB (name.GetCString());
211             std::pair <HashToISAIterator, HashToISAIterator> range = m_hash_to_isa_map.equal_range(name_hash);
212             for (HashToISAIterator range_pos = range.first; range_pos != range.second; ++range_pos)
213             {
214                 ISAToDescriptorIterator pos = m_isa_to_descriptor.find (range_pos->second);
215                 if (pos != m_isa_to_descriptor.end())
216                 {
217                     if (pos->second->GetClassName() == name)
218                         return pos;
219                 }
220             }
221         }
222     }
223     return end;
224 }
225 
226 std::pair<ObjCLanguageRuntime::ISAToDescriptorIterator,ObjCLanguageRuntime::ISAToDescriptorIterator>
227 ObjCLanguageRuntime::GetDescriptorIteratorPair (bool update_if_needed)
228 {
229     if (update_if_needed)
230         UpdateISAToDescriptorMapIfNeeded();
231 
232     return std::pair<ObjCLanguageRuntime::ISAToDescriptorIterator,
233                      ObjCLanguageRuntime::ISAToDescriptorIterator>(
234                         m_isa_to_descriptor.begin(),
235                         m_isa_to_descriptor.end());
236 }
237 
238 
239 ObjCLanguageRuntime::ObjCISA
240 ObjCLanguageRuntime::GetParentClass(ObjCLanguageRuntime::ObjCISA isa)
241 {
242     ClassDescriptorSP objc_class_sp (GetClassDescriptorFromISA(isa));
243     if (objc_class_sp)
244     {
245         ClassDescriptorSP objc_super_class_sp (objc_class_sp->GetSuperclass());
246         if (objc_super_class_sp)
247             return objc_super_class_sp->GetISA();
248     }
249     return 0;
250 }
251 
252 ConstString
253 ObjCLanguageRuntime::GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa)
254 {
255     ClassDescriptorSP objc_class_sp (GetNonKVOClassDescriptor(isa));
256     if (objc_class_sp)
257         return objc_class_sp->GetClassName();
258     return ConstString();
259 }
260 
261 ObjCLanguageRuntime::ClassDescriptorSP
262 ObjCLanguageRuntime::GetClassDescriptorFromClassName (const ConstString &class_name)
263 {
264     ISAToDescriptorIterator pos = GetDescriptorIterator (class_name);
265     if (pos != m_isa_to_descriptor.end())
266         return pos->second;
267     return ClassDescriptorSP();
268 
269 }
270 
271 ObjCLanguageRuntime::ClassDescriptorSP
272 ObjCLanguageRuntime::GetClassDescriptor (ValueObject& valobj)
273 {
274     ClassDescriptorSP objc_class_sp;
275     // if we get an invalid VO (which might still happen when playing around
276     // with pointers returned by the expression parser, don't consider this
277     // a valid ObjC object)
278     if (valobj.GetCompilerType().IsValid())
279     {
280         addr_t isa_pointer = valobj.GetPointerValue();
281         if (isa_pointer != LLDB_INVALID_ADDRESS)
282         {
283             ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
284 
285             Process *process = exe_ctx.GetProcessPtr();
286             if (process)
287             {
288                 Error error;
289                 ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error);
290                 if (isa != LLDB_INVALID_ADDRESS)
291                     objc_class_sp = GetClassDescriptorFromISA (isa);
292             }
293         }
294     }
295     return objc_class_sp;
296 }
297 
298 ObjCLanguageRuntime::ClassDescriptorSP
299 ObjCLanguageRuntime::GetNonKVOClassDescriptor (ValueObject& valobj)
300 {
301     ObjCLanguageRuntime::ClassDescriptorSP objc_class_sp (GetClassDescriptor (valobj));
302     if (objc_class_sp)
303     {
304         if (!objc_class_sp->IsKVO())
305             return objc_class_sp;
306 
307         ClassDescriptorSP non_kvo_objc_class_sp(objc_class_sp->GetSuperclass());
308         if (non_kvo_objc_class_sp && non_kvo_objc_class_sp->IsValid())
309             return non_kvo_objc_class_sp;
310     }
311     return ClassDescriptorSP();
312 }
313 
314 
315 ObjCLanguageRuntime::ClassDescriptorSP
316 ObjCLanguageRuntime::GetClassDescriptorFromISA (ObjCISA isa)
317 {
318     if (isa)
319     {
320         UpdateISAToDescriptorMap();
321         ObjCLanguageRuntime::ISAToDescriptorIterator pos = m_isa_to_descriptor.find(isa);
322         if (pos != m_isa_to_descriptor.end())
323             return pos->second;
324     }
325     return ClassDescriptorSP();
326 }
327 
328 ObjCLanguageRuntime::ClassDescriptorSP
329 ObjCLanguageRuntime::GetNonKVOClassDescriptor (ObjCISA isa)
330 {
331     if (isa)
332     {
333         ClassDescriptorSP objc_class_sp = GetClassDescriptorFromISA (isa);
334         if (objc_class_sp && objc_class_sp->IsValid())
335         {
336             if (!objc_class_sp->IsKVO())
337                 return objc_class_sp;
338 
339             ClassDescriptorSP non_kvo_objc_class_sp(objc_class_sp->GetSuperclass());
340             if (non_kvo_objc_class_sp && non_kvo_objc_class_sp->IsValid())
341                 return non_kvo_objc_class_sp;
342         }
343     }
344     return ClassDescriptorSP();
345 }
346 
347 
348 CompilerType
349 ObjCLanguageRuntime::EncodingToType::RealizeType (const char* name, bool for_expression)
350 {
351     if (m_scratch_ast_ctx_ap)
352         return RealizeType(*m_scratch_ast_ctx_ap, name, for_expression);
353     return CompilerType();
354 }
355 
356 CompilerType
357 ObjCLanguageRuntime::EncodingToType::RealizeType (ClangASTContext& ast_ctx, const char* name, bool for_expression)
358 {
359     clang::ASTContext *clang_ast = ast_ctx.getASTContext();
360     if (!clang_ast)
361         return CompilerType();
362     return RealizeType(*clang_ast, name, for_expression);
363 }
364 
365 ObjCLanguageRuntime::EncodingToType::~EncodingToType() {}
366 
367 ObjCLanguageRuntime::EncodingToTypeSP
368 ObjCLanguageRuntime::GetEncodingToType ()
369 {
370     return nullptr;
371 }
372 
373 bool
374 ObjCLanguageRuntime::GetTypeBitSize (const CompilerType& compiler_type,
375                                      uint64_t &size)
376 {
377     void *opaque_ptr = compiler_type.GetOpaqueQualType();
378     size = m_type_size_cache.Lookup(opaque_ptr);
379     // an ObjC object will at least have an ISA, so 0 is definitely not OK
380     if (size > 0)
381         return true;
382 
383     ClassDescriptorSP class_descriptor_sp = GetClassDescriptorFromClassName(compiler_type.GetTypeName());
384     if (!class_descriptor_sp)
385         return false;
386 
387     int32_t max_offset = INT32_MIN;
388     uint64_t sizeof_max = 0;
389     bool found = false;
390 
391     for (size_t idx = 0;
392          idx < class_descriptor_sp->GetNumIVars();
393          idx++)
394     {
395         const auto& ivar = class_descriptor_sp->GetIVarAtIndex(idx);
396         int32_t cur_offset = ivar.m_offset;
397         if (cur_offset > max_offset)
398         {
399             max_offset = cur_offset;
400             sizeof_max = ivar.m_size;
401             found = true;
402         }
403     }
404 
405     size = 8 * (max_offset + sizeof_max);
406     if (found)
407         m_type_size_cache.Insert(opaque_ptr, size);
408 
409     return found;
410 }
411 
412 //------------------------------------------------------------------
413 // Exception breakpoint Precondition class for ObjC:
414 //------------------------------------------------------------------
415 void
416 ObjCLanguageRuntime::ObjCExceptionPrecondition::AddClassName(const char *class_name)
417 {
418     m_class_names.insert(class_name);
419 }
420 
421 ObjCLanguageRuntime::ObjCExceptionPrecondition::ObjCExceptionPrecondition()
422 {
423 }
424 
425 bool
426 ObjCLanguageRuntime::ObjCExceptionPrecondition::EvaluatePrecondition(StoppointCallbackContext &context)
427 {
428     return true;
429 }
430 
431 void
432 ObjCLanguageRuntime::ObjCExceptionPrecondition::GetDescription(Stream &stream, lldb::DescriptionLevel level)
433 {
434 }
435 
436 Error
437 ObjCLanguageRuntime::ObjCExceptionPrecondition::ConfigurePrecondition(Args &args)
438 {
439     Error error;
440     if (args.GetArgumentCount() > 0)
441         error.SetErrorString("The ObjC Exception breakpoint doesn't support extra options.");
442     return error;
443 }
444