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