1 //===-- SBModule.cpp --------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/API/SBModule.h"
11 #include "lldb/API/SBAddress.h"
12 #include "lldb/API/SBFileSpec.h"
13 #include "lldb/API/SBModuleSpec.h"
14 #include "lldb/API/SBProcess.h"
15 #include "lldb/API/SBStream.h"
16 #include "lldb/API/SBSymbolContextList.h"
17 #include "lldb/Core/Module.h"
18 #include "lldb/Core/Log.h"
19 #include "lldb/Core/Section.h"
20 #include "lldb/Core/StreamString.h"
21 #include "lldb/Core/ValueObjectList.h"
22 #include "lldb/Core/ValueObjectVariable.h"
23 #include "lldb/Symbol/ObjectFile.h"
24 #include "lldb/Symbol/SymbolVendor.h"
25 #include "lldb/Symbol/Symtab.h"
26 #include "lldb/Symbol/VariableList.h"
27 #include "lldb/Target/Target.h"
28 
29 using namespace lldb;
30 using namespace lldb_private;
31 
32 
33 SBModule::SBModule () :
34     m_opaque_sp ()
35 {
36 }
37 
38 SBModule::SBModule (const lldb::ModuleSP& module_sp) :
39     m_opaque_sp (module_sp)
40 {
41 }
42 
43 SBModule::SBModule(const SBModuleSpec &module_spec) :
44     m_opaque_sp ()
45 {
46     ModuleSP module_sp;
47     Error error = ModuleList::GetSharedModule (*module_spec.m_opaque_ap,
48                                                module_sp,
49                                                NULL,
50                                                NULL,
51                                                NULL);
52     if (module_sp)
53         SetSP(module_sp);
54 }
55 
56 SBModule::SBModule(const SBModule &rhs) :
57     m_opaque_sp (rhs.m_opaque_sp)
58 {
59 }
60 
61 SBModule::SBModule (lldb::SBProcess &process, lldb::addr_t header_addr) :
62     m_opaque_sp ()
63 {
64     ProcessSP process_sp (process.GetSP());
65     if (process_sp)
66     {
67         m_opaque_sp = process_sp->ReadModuleFromMemory (FileSpec(), header_addr);
68         if (m_opaque_sp)
69         {
70             Target &target = process_sp->GetTarget();
71             bool changed = false;
72             m_opaque_sp->SetLoadAddress(target, 0, true, changed);
73             target.GetImages().Append(m_opaque_sp);
74         }
75     }
76 }
77 
78 const SBModule &
79 SBModule::operator = (const SBModule &rhs)
80 {
81     if (this != &rhs)
82         m_opaque_sp = rhs.m_opaque_sp;
83     return *this;
84 }
85 
86 SBModule::~SBModule ()
87 {
88 }
89 
90 bool
91 SBModule::IsValid () const
92 {
93     return m_opaque_sp.get() != NULL;
94 }
95 
96 void
97 SBModule::Clear()
98 {
99     m_opaque_sp.reset();
100 }
101 
102 SBFileSpec
103 SBModule::GetFileSpec () const
104 {
105     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
106 
107     SBFileSpec file_spec;
108     ModuleSP module_sp (GetSP ());
109     if (module_sp)
110         file_spec.SetFileSpec(module_sp->GetFileSpec());
111 
112     if (log)
113     {
114         log->Printf ("SBModule(%p)::GetFileSpec () => SBFileSpec(%p)",
115         module_sp.get(), file_spec.get());
116     }
117 
118     return file_spec;
119 }
120 
121 lldb::SBFileSpec
122 SBModule::GetPlatformFileSpec () const
123 {
124     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
125 
126     SBFileSpec file_spec;
127     ModuleSP module_sp (GetSP ());
128     if (module_sp)
129         file_spec.SetFileSpec(module_sp->GetPlatformFileSpec());
130 
131     if (log)
132     {
133         log->Printf ("SBModule(%p)::GetPlatformFileSpec () => SBFileSpec(%p)",
134                      module_sp.get(), file_spec.get());
135     }
136 
137     return file_spec;
138 
139 }
140 
141 bool
142 SBModule::SetPlatformFileSpec (const lldb::SBFileSpec &platform_file)
143 {
144     bool result = false;
145     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
146 
147     ModuleSP module_sp (GetSP ());
148     if (module_sp)
149     {
150         module_sp->SetPlatformFileSpec(*platform_file);
151         result = true;
152     }
153 
154     if (log)
155     {
156         log->Printf ("SBModule(%p)::SetPlatformFileSpec (SBFileSpec(%p (%s)) => %i",
157                      module_sp.get(),
158                      platform_file.get(),
159                      platform_file->GetPath().c_str(),
160                      result);
161     }
162     return result;
163 }
164 
165 lldb::SBFileSpec
166 SBModule::GetRemoteInstallFileSpec ()
167 {
168     SBFileSpec sb_file_spec;
169     ModuleSP module_sp (GetSP ());
170     if (module_sp)
171         sb_file_spec.SetFileSpec (module_sp->GetRemoteInstallFileSpec());
172     return sb_file_spec;
173 }
174 
175 bool
176 SBModule::SetRemoteInstallFileSpec (lldb::SBFileSpec &file)
177 {
178     ModuleSP module_sp (GetSP ());
179     if (module_sp)
180     {
181         module_sp->SetRemoteInstallFileSpec(file.ref());
182         return true;
183     }
184     return false;
185 }
186 
187 
188 const uint8_t *
189 SBModule::GetUUIDBytes () const
190 {
191     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
192 
193     const uint8_t *uuid_bytes = NULL;
194     ModuleSP module_sp (GetSP ());
195     if (module_sp)
196         uuid_bytes = (const uint8_t *)module_sp->GetUUID().GetBytes();
197 
198     if (log)
199     {
200         if (uuid_bytes)
201         {
202             StreamString s;
203             module_sp->GetUUID().Dump (&s);
204             log->Printf ("SBModule(%p)::GetUUIDBytes () => %s", module_sp.get(), s.GetData());
205         }
206         else
207             log->Printf ("SBModule(%p)::GetUUIDBytes () => NULL", module_sp.get());
208     }
209     return uuid_bytes;
210 }
211 
212 
213 const char *
214 SBModule::GetUUIDString () const
215 {
216     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
217 
218     static char uuid_string_buffer[80];
219     const char *uuid_c_string = NULL;
220     std::string uuid_string;
221     ModuleSP module_sp (GetSP ());
222     if (module_sp)
223         uuid_string = module_sp->GetUUID().GetAsString();
224 
225     if (!uuid_string.empty())
226     {
227         strncpy (uuid_string_buffer, uuid_string.c_str(), sizeof (uuid_string_buffer));
228         uuid_c_string = uuid_string_buffer;
229     }
230 
231     if (log)
232     {
233         if (!uuid_string.empty())
234         {
235             StreamString s;
236             module_sp->GetUUID().Dump (&s);
237             log->Printf ("SBModule(%p)::GetUUIDString () => %s", module_sp.get(), s.GetData());
238         }
239         else
240             log->Printf ("SBModule(%p)::GetUUIDString () => NULL", module_sp.get());
241     }
242     return uuid_c_string;
243 }
244 
245 
246 bool
247 SBModule::operator == (const SBModule &rhs) const
248 {
249     if (m_opaque_sp)
250         return m_opaque_sp.get() == rhs.m_opaque_sp.get();
251     return false;
252 }
253 
254 bool
255 SBModule::operator != (const SBModule &rhs) const
256 {
257     if (m_opaque_sp)
258         return m_opaque_sp.get() != rhs.m_opaque_sp.get();
259     return false;
260 }
261 
262 ModuleSP
263 SBModule::GetSP () const
264 {
265     return m_opaque_sp;
266 }
267 
268 void
269 SBModule::SetSP (const ModuleSP &module_sp)
270 {
271     m_opaque_sp = module_sp;
272 }
273 
274 SBAddress
275 SBModule::ResolveFileAddress (lldb::addr_t vm_addr)
276 {
277     lldb::SBAddress sb_addr;
278     ModuleSP module_sp (GetSP ());
279     if (module_sp)
280     {
281         Address addr;
282         if (module_sp->ResolveFileAddress (vm_addr, addr))
283             sb_addr.ref() = addr;
284     }
285     return sb_addr;
286 }
287 
288 SBSymbolContext
289 SBModule::ResolveSymbolContextForAddress (const SBAddress& addr, uint32_t resolve_scope)
290 {
291     SBSymbolContext sb_sc;
292     ModuleSP module_sp (GetSP ());
293     if (module_sp && addr.IsValid())
294         module_sp->ResolveSymbolContextForAddress (addr.ref(), resolve_scope, *sb_sc);
295     return sb_sc;
296 }
297 
298 bool
299 SBModule::GetDescription (SBStream &description)
300 {
301     Stream &strm = description.ref();
302 
303     ModuleSP module_sp (GetSP ());
304     if (module_sp)
305     {
306         module_sp->GetDescription (&strm);
307     }
308     else
309         strm.PutCString ("No value");
310 
311     return true;
312 }
313 
314 uint32_t
315 SBModule::GetNumCompileUnits()
316 {
317     ModuleSP module_sp (GetSP ());
318     if (module_sp)
319     {
320         return module_sp->GetNumCompileUnits ();
321     }
322     return 0;
323 }
324 
325 SBCompileUnit
326 SBModule::GetCompileUnitAtIndex (uint32_t index)
327 {
328     SBCompileUnit sb_cu;
329     ModuleSP module_sp (GetSP ());
330     if (module_sp)
331     {
332         CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex (index);
333         sb_cu.reset(cu_sp.get());
334     }
335     return sb_cu;
336 }
337 
338 static Symtab *
339 GetUnifiedSymbolTable (const lldb::ModuleSP& module_sp)
340 {
341     if (module_sp)
342     {
343         SymbolVendor *symbols = module_sp->GetSymbolVendor();
344         if (symbols)
345             return symbols->GetSymtab();
346     }
347     return NULL;
348 }
349 
350 size_t
351 SBModule::GetNumSymbols ()
352 {
353     ModuleSP module_sp (GetSP ());
354     if (module_sp)
355     {
356         Symtab *symtab = GetUnifiedSymbolTable (module_sp);
357         if (symtab)
358             return symtab->GetNumSymbols();
359     }
360     return 0;
361 }
362 
363 SBSymbol
364 SBModule::GetSymbolAtIndex (size_t idx)
365 {
366     SBSymbol sb_symbol;
367     ModuleSP module_sp (GetSP ());
368     Symtab *symtab = GetUnifiedSymbolTable (module_sp);
369     if (symtab)
370         sb_symbol.SetSymbol(symtab->SymbolAtIndex (idx));
371     return sb_symbol;
372 }
373 
374 lldb::SBSymbol
375 SBModule::FindSymbol (const char *name,
376                       lldb::SymbolType symbol_type)
377 {
378     SBSymbol sb_symbol;
379     if (name && name[0])
380     {
381         ModuleSP module_sp (GetSP ());
382         Symtab *symtab = GetUnifiedSymbolTable (module_sp);
383         if (symtab)
384             sb_symbol.SetSymbol(symtab->FindFirstSymbolWithNameAndType(ConstString(name), symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny));
385     }
386     return sb_symbol;
387 }
388 
389 
390 lldb::SBSymbolContextList
391 SBModule::FindSymbols (const char *name, lldb::SymbolType symbol_type)
392 {
393     SBSymbolContextList sb_sc_list;
394     if (name && name[0])
395     {
396         ModuleSP module_sp (GetSP ());
397         Symtab *symtab = GetUnifiedSymbolTable (module_sp);
398         if (symtab)
399         {
400             std::vector<uint32_t> matching_symbol_indexes;
401             const size_t num_matches = symtab->FindAllSymbolsWithNameAndType(ConstString(name), symbol_type, matching_symbol_indexes);
402             if (num_matches)
403             {
404                 SymbolContext sc;
405                 sc.module_sp = module_sp;
406                 SymbolContextList &sc_list = *sb_sc_list;
407                 for (size_t i=0; i<num_matches; ++i)
408                 {
409                     sc.symbol = symtab->SymbolAtIndex (matching_symbol_indexes[i]);
410                     if (sc.symbol)
411                         sc_list.Append(sc);
412                 }
413             }
414         }
415     }
416     return sb_sc_list;
417 
418 }
419 
420 
421 
422 size_t
423 SBModule::GetNumSections ()
424 {
425     ModuleSP module_sp (GetSP ());
426     if (module_sp)
427     {
428         // Give the symbol vendor a chance to add to the unified section list.
429         module_sp->GetSymbolVendor();
430         SectionList *section_list = module_sp->GetSectionList();
431         if (section_list)
432             return section_list->GetSize();
433     }
434     return 0;
435 }
436 
437 SBSection
438 SBModule::GetSectionAtIndex (size_t idx)
439 {
440     SBSection sb_section;
441     ModuleSP module_sp (GetSP ());
442     if (module_sp)
443     {
444         // Give the symbol vendor a chance to add to the unified section list.
445         module_sp->GetSymbolVendor();
446         SectionList *section_list = module_sp->GetSectionList ();
447 
448         if (section_list)
449             sb_section.SetSP(section_list->GetSectionAtIndex (idx));
450     }
451     return sb_section;
452 }
453 
454 lldb::SBSymbolContextList
455 SBModule::FindFunctions (const char *name,
456                          uint32_t name_type_mask)
457 {
458     lldb::SBSymbolContextList sb_sc_list;
459     ModuleSP module_sp (GetSP ());
460     if (name && module_sp)
461     {
462         const bool append = true;
463         const bool symbols_ok = true;
464         const bool inlines_ok = true;
465         module_sp->FindFunctions (ConstString(name),
466                                   NULL,
467                                   name_type_mask,
468                                   symbols_ok,
469                                   inlines_ok,
470                                   append,
471                                   *sb_sc_list);
472     }
473     return sb_sc_list;
474 }
475 
476 
477 SBValueList
478 SBModule::FindGlobalVariables (SBTarget &target, const char *name, uint32_t max_matches)
479 {
480     SBValueList sb_value_list;
481     ModuleSP module_sp (GetSP ());
482     if (name && module_sp)
483     {
484         VariableList variable_list;
485         const uint32_t match_count = module_sp->FindGlobalVariables (ConstString (name),
486                                                                      NULL,
487                                                                      false,
488                                                                      max_matches,
489                                                                      variable_list);
490 
491         if (match_count > 0)
492         {
493             for (uint32_t i=0; i<match_count; ++i)
494             {
495                 lldb::ValueObjectSP valobj_sp;
496                 TargetSP target_sp (target.GetSP());
497                 valobj_sp = ValueObjectVariable::Create (target_sp.get(), variable_list.GetVariableAtIndex(i));
498                 if (valobj_sp)
499                     sb_value_list.Append(SBValue(valobj_sp));
500             }
501         }
502     }
503 
504     return sb_value_list;
505 }
506 
507 lldb::SBValue
508 SBModule::FindFirstGlobalVariable (lldb::SBTarget &target, const char *name)
509 {
510     SBValueList sb_value_list(FindGlobalVariables(target, name, 1));
511     if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
512         return sb_value_list.GetValueAtIndex(0);
513     return SBValue();
514 }
515 
516 lldb::SBType
517 SBModule::FindFirstType (const char *name_cstr)
518 {
519     SBType sb_type;
520     ModuleSP module_sp (GetSP ());
521     if (name_cstr && module_sp)
522     {
523         SymbolContext sc;
524         const bool exact_match = false;
525         ConstString name(name_cstr);
526 
527         sb_type = SBType (module_sp->FindFirstType(sc, name, exact_match));
528 
529         if (!sb_type.IsValid())
530             sb_type = SBType (ClangASTContext::GetBasicType (module_sp->GetClangASTContext().getASTContext(), name));
531     }
532     return sb_type;
533 }
534 
535 lldb::SBType
536 SBModule::GetBasicType(lldb::BasicType type)
537 {
538     ModuleSP module_sp (GetSP ());
539     if (module_sp)
540         return SBType (ClangASTContext::GetBasicType (module_sp->GetClangASTContext().getASTContext(), type));
541     return SBType();
542 }
543 
544 lldb::SBTypeList
545 SBModule::FindTypes (const char *type)
546 {
547     SBTypeList retval;
548 
549     ModuleSP module_sp (GetSP ());
550     if (type && module_sp)
551     {
552         SymbolContext sc;
553         TypeList type_list;
554         const bool exact_match = false;
555         ConstString name(type);
556         const uint32_t num_matches = module_sp->FindTypes (sc,
557                                                            name,
558                                                            exact_match,
559                                                            UINT32_MAX,
560                                                            type_list);
561 
562         if (num_matches > 0)
563         {
564             for (size_t idx = 0; idx < num_matches; idx++)
565             {
566                 TypeSP type_sp (type_list.GetTypeAtIndex(idx));
567                 if (type_sp)
568                     retval.Append(SBType(type_sp));
569             }
570         }
571         else
572         {
573             SBType sb_type(ClangASTContext::GetBasicType (module_sp->GetClangASTContext().getASTContext(), name));
574             if (sb_type.IsValid())
575                 retval.Append(sb_type);
576         }
577     }
578 
579     return retval;
580 }
581 
582 lldb::SBType
583 SBModule::GetTypeByID (lldb::user_id_t uid)
584 {
585     ModuleSP module_sp (GetSP ());
586     if (module_sp)
587     {
588         SymbolVendor* vendor = module_sp->GetSymbolVendor();
589         if (vendor)
590         {
591             Type *type_ptr = vendor->ResolveTypeUID(uid);
592             if (type_ptr)
593                 return SBType(type_ptr->shared_from_this());
594         }
595     }
596     return SBType();
597 }
598 
599 lldb::SBTypeList
600 SBModule::GetTypes (uint32_t type_mask)
601 {
602     SBTypeList sb_type_list;
603 
604     ModuleSP module_sp (GetSP ());
605     if (module_sp)
606     {
607         SymbolVendor* vendor = module_sp->GetSymbolVendor();
608         if (vendor)
609         {
610             TypeList type_list;
611             vendor->GetTypes (NULL, type_mask, type_list);
612             sb_type_list.m_opaque_ap->Append(type_list);
613         }
614     }
615     return sb_type_list;
616 }
617 
618 SBSection
619 SBModule::FindSection (const char *sect_name)
620 {
621     SBSection sb_section;
622 
623     ModuleSP module_sp (GetSP ());
624     if (sect_name && module_sp)
625     {
626         // Give the symbol vendor a chance to add to the unified section list.
627         module_sp->GetSymbolVendor();
628         SectionList *section_list = module_sp->GetSectionList();
629         if (section_list)
630         {
631             ConstString const_sect_name(sect_name);
632             SectionSP section_sp (section_list->FindSectionByName(const_sect_name));
633             if (section_sp)
634             {
635                 sb_section.SetSP (section_sp);
636             }
637         }
638     }
639     return sb_section;
640 }
641 
642 lldb::ByteOrder
643 SBModule::GetByteOrder ()
644 {
645     ModuleSP module_sp (GetSP ());
646     if (module_sp)
647         return module_sp->GetArchitecture().GetByteOrder();
648     return eByteOrderInvalid;
649 }
650 
651 const char *
652 SBModule::GetTriple ()
653 {
654     ModuleSP module_sp (GetSP ());
655     if (module_sp)
656     {
657         std::string triple (module_sp->GetArchitecture().GetTriple().str());
658         // Unique the string so we don't run into ownership issues since
659         // the const strings put the string into the string pool once and
660         // the strings never comes out
661         ConstString const_triple (triple.c_str());
662         return const_triple.GetCString();
663     }
664     return NULL;
665 }
666 
667 uint32_t
668 SBModule::GetAddressByteSize()
669 {
670     ModuleSP module_sp (GetSP ());
671     if (module_sp)
672         return module_sp->GetArchitecture().GetAddressByteSize();
673     return sizeof(void*);
674 }
675 
676 
677 uint32_t
678 SBModule::GetVersion (uint32_t *versions, uint32_t num_versions)
679 {
680     ModuleSP module_sp (GetSP ());
681     if (module_sp)
682         return module_sp->GetVersion(versions, num_versions);
683     else
684     {
685         if (versions && num_versions)
686         {
687             for (uint32_t i=0; i<num_versions; ++i)
688                 versions[i] = UINT32_MAX;
689         }
690         return 0;
691     }
692 }
693 
694