Error PlatformDarwinKernel::GetSharedModule (const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr, ModuleSP *old_module_sp_ptr, bool *did_create_ptr) { Error error; module_sp.reset(); const FileSpec &platform_file = module_spec.GetFileSpec(); // Treat the file's path as a kext bundle ID (e.g. "com.apple.driver.AppleIRController") and search our kext index. std::string kext_bundle_id = platform_file.GetPath(); if (!kext_bundle_id.empty()) { ConstString kext_bundle_cs(kext_bundle_id.c_str()); if (m_name_to_kext_path_map.count(kext_bundle_cs) > 0) { for (BundleIDToKextIterator it = m_name_to_kext_path_map.begin (); it != m_name_to_kext_path_map.end (); ++it) { if (it->first == kext_bundle_cs) { error = ExamineKextForMatchingUUID (it->second, module_spec.GetUUID(), module_spec.GetArchitecture(), module_sp); if (module_sp.get()) { return error; } } } } } if (kext_bundle_id.compare("mach_kernel") == 0 && module_spec.GetUUID().IsValid()) { for (auto possible_kernel : m_kernel_binaries) { if (possible_kernel.Exists()) { ModuleSpec kern_spec (possible_kernel); kern_spec.GetUUID() = module_spec.GetUUID(); ModuleSP module_sp (new Module (kern_spec)); if (module_sp && module_sp->GetObjectFile() && module_sp->MatchesModuleSpec (kern_spec)) { Error error; error = ModuleList::GetSharedModule (kern_spec, module_sp, NULL, NULL, NULL); if (module_sp && module_sp->GetObjectFile()) { return error; } } } } } // Else fall back to treating the file's path as an actual file path - defer to PlatformDarwin's GetSharedModule. return PlatformDarwin::GetSharedModule (module_spec, process, module_sp, module_search_paths_ptr, old_module_sp_ptr, did_create_ptr); }
Error PlatformDarwinKernel::ExamineKextForMatchingUUID (const FileSpec &kext_bundle_path, const lldb_private::UUID &uuid, const ArchSpec &arch, ModuleSP &exe_module_sp) { Error error; FileSpec exe_file = kext_bundle_path; Host::ResolveExecutableInBundle (exe_file); if (exe_file.Exists()) { ModuleSpec exe_spec (exe_file); exe_spec.GetUUID() = uuid; exe_spec.GetArchitecture() = arch; // First try to create a ModuleSP with the file / arch and see if the UUID matches. // If that fails (this exec file doesn't have the correct uuid), don't call GetSharedModule // (which may call in to the DebugSymbols framework and therefore can be slow.) ModuleSP module_sp (new Module (exe_file, arch)); if (module_sp && module_sp->GetObjectFile() && module_sp->MatchesModuleSpec (exe_spec)) { error = ModuleList::GetSharedModule (exe_spec, exe_module_sp, NULL, NULL, NULL); if (exe_module_sp && exe_module_sp->GetObjectFile()) { return error; } } exe_module_sp.reset(); } return error; }
addr_t DynamicLoaderPOSIXDYLD::ComputeLoadOffset() { addr_t virt_entry; if (m_load_offset != LLDB_INVALID_ADDRESS) return m_load_offset; if ((virt_entry = GetEntryPoint()) == LLDB_INVALID_ADDRESS) return LLDB_INVALID_ADDRESS; ModuleSP module = m_process->GetTarget().GetExecutableModule(); if (!module) return LLDB_INVALID_ADDRESS; ObjectFile *exe = module->GetObjectFile(); if (!exe) return LLDB_INVALID_ADDRESS; Address file_entry = exe->GetEntryPointAddress(); if (!file_entry.IsValid()) return LLDB_INVALID_ADDRESS; m_load_offset = virt_entry - file_entry.GetFileAddress(); return m_load_offset; }
// Find the load address of a symbol static lldb::addr_t findSymbolAddress( Process *proc, ConstString findName ) { assert( proc != nullptr ); ModuleSP module = proc->GetTarget().GetExecutableModule(); assert( module.get() != nullptr ); ObjectFile *exe = module->GetObjectFile(); assert( exe != nullptr ); lldb_private::Symtab *symtab = exe->GetSymtab( ); assert( symtab != nullptr ); for ( size_t i = 0; i < symtab->GetNumSymbols( ); i++ ) { const Symbol* sym = symtab->SymbolAtIndex( i ); assert( sym != nullptr ); const ConstString &symName = sym->GetName( ); if ( ConstString::Compare( findName, symName ) == 0 ) { Address addr = sym->GetAddress(); return addr.GetLoadAddress( & proc->GetTarget() ); } } return LLDB_INVALID_ADDRESS; }
void DynamicLoaderLinuxDYLD::UpdateLoadedSections(ModuleSP module, addr_t base_addr) { ObjectFile *obj_file = module->GetObjectFile(); SectionList *sections = obj_file->GetSectionList(); SectionLoadList &load_list = m_process->GetTarget().GetSectionLoadList(); const size_t num_sections = sections->GetSize(); for (unsigned i = 0; i < num_sections; ++i) { Section *section = sections->GetSectionAtIndex(i).get(); lldb::addr_t new_load_addr = section->GetFileAddress() + base_addr; lldb::addr_t old_load_addr = load_list.GetSectionLoadAddress(section); // If the file address of the section is zero then this is not an // allocatable/loadable section (property of ELF sh_addr). Skip it. if (new_load_addr == base_addr) continue; if (old_load_addr == LLDB_INVALID_ADDRESS || old_load_addr != new_load_addr) load_list.SetSectionLoadAddress(section, new_load_addr); } }
Error ModuleList::GetSharedModule(const ModuleSpec &module_spec, ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr, ModuleSP *old_module_sp_ptr, bool *did_create_ptr, bool always_create) { ModuleList &shared_module_list = GetSharedModuleList (); Mutex::Locker locker(shared_module_list.m_modules_mutex); char path[PATH_MAX]; Error error; module_sp.reset(); if (did_create_ptr) *did_create_ptr = false; if (old_module_sp_ptr) old_module_sp_ptr->reset(); const UUID *uuid_ptr = module_spec.GetUUIDPtr(); const FileSpec &module_file_spec = module_spec.GetFileSpec(); const ArchSpec &arch = module_spec.GetArchitecture(); // Make sure no one else can try and get or create a module while this // function is actively working on it by doing an extra lock on the // global mutex list. if (!always_create) { ModuleList matching_module_list; const size_t num_matching_modules = shared_module_list.FindModules (module_spec, matching_module_list); if (num_matching_modules > 0) { for (size_t module_idx = 0; module_idx < num_matching_modules; ++module_idx) { module_sp = matching_module_list.GetModuleAtIndex(module_idx); // Make sure the file for the module hasn't been modified if (module_sp->FileHasChanged()) { if (old_module_sp_ptr && !*old_module_sp_ptr) *old_module_sp_ptr = module_sp; Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_MODULES)); if (log != nullptr) log->Printf("module changed: %p, removing from global module list", static_cast<void*>(module_sp.get())); shared_module_list.Remove (module_sp); module_sp.reset(); } else { // The module matches and the module was not modified from // when it was last loaded. return error; } } } } if (module_sp) return error; module_sp.reset (new Module (module_spec)); // Make sure there are a module and an object file since we can specify // a valid file path with an architecture that might not be in that file. // By getting the object file we can guarantee that the architecture matches if (module_sp->GetObjectFile()) { // If we get in here we got the correct arch, now we just need // to verify the UUID if one was given if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) { module_sp.reset(); } else { if (module_sp->GetObjectFile() && module_sp->GetObjectFile()->GetType() == ObjectFile::eTypeStubLibrary) { module_sp.reset(); } else { if (did_create_ptr) { *did_create_ptr = true; } shared_module_list.ReplaceEquivalent(module_sp); return error; } } } else { module_sp.reset(); } if (module_search_paths_ptr) { const auto num_directories = module_search_paths_ptr->GetSize(); for (size_t idx = 0; idx < num_directories; ++idx) { auto search_path_spec = module_search_paths_ptr->GetFileSpecAtIndex(idx); if (!search_path_spec.ResolvePath()) continue; if (!search_path_spec.Exists() || !search_path_spec.IsDirectory()) continue; search_path_spec.AppendPathComponent(module_spec.GetFileSpec().GetFilename().AsCString()); if (!search_path_spec.Exists()) continue; auto resolved_module_spec(module_spec); resolved_module_spec.GetFileSpec() = search_path_spec; module_sp.reset (new Module (resolved_module_spec)); if (module_sp->GetObjectFile()) { // If we get in here we got the correct arch, now we just need // to verify the UUID if one was given if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) { module_sp.reset(); } else { if (module_sp->GetObjectFile()->GetType() == ObjectFile::eTypeStubLibrary) { module_sp.reset(); } else { if (did_create_ptr) *did_create_ptr = true; shared_module_list.ReplaceEquivalent(module_sp); return Error(); } } } else { module_sp.reset(); } } } // Either the file didn't exist where at the path, or no path was given, so // we now have to use more extreme measures to try and find the appropriate // module. // Fixup the incoming path in case the path points to a valid file, yet // the arch or UUID (if one was passed in) don't match. ModuleSpec located_binary_modulespec = Symbols::LocateExecutableObjectFile (module_spec); // Don't look for the file if it appears to be the same one we already // checked for above... if (located_binary_modulespec.GetFileSpec() != module_file_spec) { if (!located_binary_modulespec.GetFileSpec().Exists()) { located_binary_modulespec.GetFileSpec().GetPath(path, sizeof(path)); if (path[0] == '\0') module_file_spec.GetPath(path, sizeof(path)); // How can this check ever be true? This branch it is false, and we haven't modified file_spec. if (located_binary_modulespec.GetFileSpec().Exists()) { std::string uuid_str; if (uuid_ptr && uuid_ptr->IsValid()) uuid_str = uuid_ptr->GetAsString(); if (arch.IsValid()) { if (!uuid_str.empty()) error.SetErrorStringWithFormat("'%s' does not contain the %s architecture and UUID %s", path, arch.GetArchitectureName(), uuid_str.c_str()); else error.SetErrorStringWithFormat("'%s' does not contain the %s architecture.", path, arch.GetArchitectureName()); } } else { error.SetErrorStringWithFormat("'%s' does not exist", path); } if (error.Fail()) module_sp.reset(); return error; } // Make sure no one else can try and get or create a module while this // function is actively working on it by doing an extra lock on the // global mutex list. ModuleSpec platform_module_spec(module_spec); platform_module_spec.GetFileSpec() = located_binary_modulespec.GetFileSpec(); platform_module_spec.GetPlatformFileSpec() = located_binary_modulespec.GetFileSpec(); platform_module_spec.GetSymbolFileSpec() = located_binary_modulespec.GetSymbolFileSpec(); ModuleList matching_module_list; if (shared_module_list.FindModules (platform_module_spec, matching_module_list) > 0) { module_sp = matching_module_list.GetModuleAtIndex(0); // If we didn't have a UUID in mind when looking for the object file, // then we should make sure the modification time hasn't changed! if (platform_module_spec.GetUUIDPtr() == nullptr) { TimeValue file_spec_mod_time(located_binary_modulespec.GetFileSpec().GetModificationTime()); if (file_spec_mod_time.IsValid()) { if (file_spec_mod_time != module_sp->GetModificationTime()) { if (old_module_sp_ptr) *old_module_sp_ptr = module_sp; shared_module_list.Remove (module_sp); module_sp.reset(); } } } } if (!module_sp) { module_sp.reset (new Module (platform_module_spec)); // Make sure there are a module and an object file since we can specify // a valid file path with an architecture that might not be in that file. // By getting the object file we can guarantee that the architecture matches if (module_sp && module_sp->GetObjectFile()) { if (module_sp->GetObjectFile()->GetType() == ObjectFile::eTypeStubLibrary) { module_sp.reset(); } else { if (did_create_ptr) *did_create_ptr = true; shared_module_list.ReplaceEquivalent(module_sp); } } else { located_binary_modulespec.GetFileSpec().GetPath(path, sizeof(path)); if (located_binary_modulespec.GetFileSpec()) { if (arch.IsValid()) error.SetErrorStringWithFormat("unable to open %s architecture in '%s'", arch.GetArchitectureName(), path); else error.SetErrorStringWithFormat("unable to open '%s'", path); } else { std::string uuid_str; if (uuid_ptr && uuid_ptr->IsValid()) uuid_str = uuid_ptr->GetAsString(); if (!uuid_str.empty()) error.SetErrorStringWithFormat("cannot locate a module for UUID '%s'", uuid_str.c_str()); else error.SetErrorStringWithFormat("cannot locate a module"); } } } } return error; }
void Target::SetExecutableModule (ModuleSP& executable_sp, bool get_dependent_files) { m_images.Clear(); m_scratch_ast_context_ap.reset(); if (executable_sp.get()) { Timer scoped_timer (__PRETTY_FUNCTION__, "Target::SetExecutableModule (executable = '%s/%s')", executable_sp->GetFileSpec().GetDirectory().AsCString(), executable_sp->GetFileSpec().GetFilename().AsCString()); m_images.Append(executable_sp); // The first image is our exectuable file ArchSpec exe_arch = executable_sp->GetArchitecture(); // If we haven't set an architecture yet, reset our architecture based on what we found in the executable module. if (!m_arch_spec.IsValid()) m_arch_spec = exe_arch; FileSpecList dependent_files; ObjectFile * executable_objfile = executable_sp->GetObjectFile(); if (executable_objfile == NULL) { FileSpec bundle_executable(executable_sp->GetFileSpec()); if (Host::ResolveExecutableInBundle (bundle_executable)) { ModuleSP bundle_exe_module_sp(GetSharedModule(bundle_executable, exe_arch)); SetExecutableModule (bundle_exe_module_sp, get_dependent_files); if (bundle_exe_module_sp->GetObjectFile() != NULL) executable_sp = bundle_exe_module_sp; return; } } if (executable_objfile) { executable_objfile->GetDependentModules(dependent_files); for (uint32_t i=0; i<dependent_files.GetSize(); i++) { ModuleSP image_module_sp(GetSharedModule(dependent_files.GetFileSpecPointerAtIndex(i), exe_arch)); if (image_module_sp.get()) { //image_module_sp->Dump(&s);// REMOVE THIS, DEBUG ONLY ObjectFile *objfile = image_module_sp->GetObjectFile(); if (objfile) objfile->GetDependentModules(dependent_files); } } } // Now see if we know the target triple, and if so, create our scratch AST context: if (m_arch_spec.IsValid()) { m_scratch_ast_context_ap.reset (new ClangASTContext(m_arch_spec.GetTriple().str().c_str())); } } UpdateInstanceName(); }
Error ModuleList::GetSharedModule ( const FileSpec& in_file_spec, const ArchSpec& arch, const lldb_private::UUID *uuid_ptr, const ConstString *object_name_ptr, off_t object_offset, ModuleSP &module_sp, ModuleSP *old_module_sp_ptr, bool *did_create_ptr, bool always_create ) { ModuleList &shared_module_list = GetSharedModuleList (); Mutex::Locker locker(shared_module_list.m_modules_mutex); char path[PATH_MAX]; char uuid_cstr[64]; Error error; module_sp.reset(); if (did_create_ptr) *did_create_ptr = false; if (old_module_sp_ptr) old_module_sp_ptr->reset(); // First just try and get the file where it purports to be (path in // in_file_spec), then check and uuid. if (in_file_spec) { // Make sure no one else can try and get or create a module while this // function is actively working on it by doing an extra lock on the // global mutex list. if (always_create == false) { ModuleList matching_module_list; const size_t num_matching_modules = shared_module_list.FindModules (&in_file_spec, &arch, NULL, object_name_ptr, matching_module_list); if (num_matching_modules > 0) { for (uint32_t module_idx = 0; module_idx < num_matching_modules; ++module_idx) { module_sp = matching_module_list.GetModuleAtIndex(module_idx); if (uuid_ptr && uuid_ptr->IsValid()) { // We found the module we were looking for. if (module_sp->GetUUID() == *uuid_ptr) return error; } else { // If we didn't have a UUID in mind when looking for the object file, // then we should make sure the modification time hasn't changed! TimeValue file_spec_mod_time(in_file_spec.GetModificationTime()); if (file_spec_mod_time.IsValid()) { if (file_spec_mod_time == module_sp->GetModificationTime()) return error; } } if (old_module_sp_ptr && !old_module_sp_ptr->get()) *old_module_sp_ptr = module_sp; shared_module_list.Remove (module_sp); module_sp.reset(); } } } if (module_sp) return error; else { #if defined ENABLE_MODULE_SP_LOGGING ModuleSP logging_module_sp (new Module (in_file_spec, arch, object_name_ptr, object_offset), ModuleSharedPtrLogger, (void *)ConstString("a.out").GetCString()); module_sp = logging_module_sp; #else module_sp.reset (new Module (in_file_spec, arch, object_name_ptr, object_offset)); #endif // Make sure there are a module and an object file since we can specify // a valid file path with an architecture that might not be in that file. // By getting the object file we can guarantee that the architecture matches if (module_sp && module_sp->GetObjectFile()) { // If we get in here we got the correct arch, now we just need // to verify the UUID if one was given if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) module_sp.reset(); else { if (did_create_ptr) *did_create_ptr = true; shared_module_list.Append(module_sp); return error; } } } } // Either the file didn't exist where at the path, or no path was given, so // we now have to use more extreme measures to try and find the appropriate // module. // Fixup the incoming path in case the path points to a valid file, yet // the arch or UUID (if one was passed in) don't match. FileSpec file_spec = Symbols::LocateExecutableObjectFile (in_file_spec ? &in_file_spec : NULL, arch.IsValid() ? &arch : NULL, uuid_ptr); // Don't look for the file if it appears to be the same one we already // checked for above... if (file_spec != in_file_spec) { if (!file_spec.Exists()) { file_spec.GetPath(path, sizeof(path)); if (file_spec.Exists()) { if (uuid_ptr && uuid_ptr->IsValid()) uuid_ptr->GetAsCString(uuid_cstr, sizeof (uuid_cstr)); else uuid_cstr[0] = '\0'; if (arch.IsValid()) { if (uuid_cstr[0]) error.SetErrorStringWithFormat("'%s' does not contain the %s architecture and UUID %s", path, arch.GetArchitectureName(), uuid_cstr); else error.SetErrorStringWithFormat("'%s' does not contain the %s architecture.", path, arch.GetArchitectureName()); } } else { error.SetErrorStringWithFormat("'%s' does not exist", path); } return error; } // Make sure no one else can try and get or create a module while this // function is actively working on it by doing an extra lock on the // global mutex list. ModuleList matching_module_list; if (shared_module_list.FindModules (&file_spec, &arch, uuid_ptr, object_name_ptr, matching_module_list) > 0) { module_sp = matching_module_list.GetModuleAtIndex(0); // If we didn't have a UUID in mind when looking for the object file, // then we should make sure the modification time hasn't changed! if (uuid_ptr == NULL) { TimeValue file_spec_mod_time(file_spec.GetModificationTime()); if (file_spec_mod_time.IsValid()) { if (file_spec_mod_time != module_sp->GetModificationTime()) { if (old_module_sp_ptr) *old_module_sp_ptr = module_sp; shared_module_list.Remove (module_sp); module_sp.reset(); } } } } if (module_sp.get() == NULL) { #if defined ENABLE_MODULE_SP_LOGGING ModuleSP logging_module_sp (new Module (file_spec, arch, object_name_ptr, object_offset), ModuleSharedPtrLogger, 0); module_sp = logging_module_sp; #else module_sp.reset (new Module (file_spec, arch, object_name_ptr, object_offset)); #endif // Make sure there are a module and an object file since we can specify // a valid file path with an architecture that might not be in that file. // By getting the object file we can guarantee that the architecture matches if (module_sp && module_sp->GetObjectFile()) { if (did_create_ptr) *did_create_ptr = true; shared_module_list.Append(module_sp); } else { file_spec.GetPath(path, sizeof(path)); if (file_spec) { if (arch.IsValid()) error.SetErrorStringWithFormat("unable to open %s architecture in '%s'", arch.GetArchitectureName(), path); else error.SetErrorStringWithFormat("unable to open '%s'", path); } else { if (uuid_ptr && uuid_ptr->IsValid()) uuid_ptr->GetAsCString(uuid_cstr, sizeof (uuid_cstr)); else uuid_cstr[0] = '\0'; if (uuid_cstr[0]) error.SetErrorStringWithFormat("cannot locate a module for UUID '%s'", uuid_cstr); else error.SetErrorStringWithFormat("cannot locate a module"); } } } } return error; }