DisassemblerSP Disassembler::FindPlugin (const ArchSpec &arch, const char *flavor, const char *plugin_name) { Timer scoped_timer (__PRETTY_FUNCTION__, "Disassembler::FindPlugin (arch = %s, plugin_name = %s)", arch.GetArchitectureName(), plugin_name); DisassemblerCreateInstance create_callback = NULL; if (plugin_name) { ConstString const_plugin_name (plugin_name); create_callback = PluginManager::GetDisassemblerCreateCallbackForPluginName (const_plugin_name); if (create_callback) { DisassemblerSP disassembler_sp(create_callback(arch, flavor)); if (disassembler_sp.get()) return disassembler_sp; } } else { for (uint32_t idx = 0; (create_callback = PluginManager::GetDisassemblerCreateCallbackAtIndex(idx)) != NULL; ++idx) { DisassemblerSP disassembler_sp(create_callback(arch, flavor)); if (disassembler_sp.get()) return disassembler_sp; } } return DisassemblerSP(); }
void ObjectFileJIT::Dump (Stream *s) { ModuleSP module_sp(GetModule()); if (module_sp) { lldb_private::Mutex::Locker locker(module_sp->GetMutex()); s->Printf("%p: ", static_cast<void*>(this)); s->Indent(); s->PutCString("ObjectFileJIT"); ArchSpec arch; if (GetArchitecture(arch)) *s << ", arch = " << arch.GetArchitectureName(); s->EOL(); SectionList *sections = GetSectionList(); if (sections) sections->Dump(s, NULL, true, UINT32_MAX); if (m_symtab_ap.get()) m_symtab_ap->Dump(s, NULL, eSortOrderNone); } }
void ObjectContainerUniversalMachO::Dump (Stream *s) const { s->Printf("%.*p: ", (int)sizeof(void*) * 2, this); s->Indent(); const size_t num_archs = GetNumArchitectures(); const size_t num_objects = GetNumObjects(); s->Printf("ObjectContainerUniversalMachO, num_archs = %u, num_objects = %u", num_archs, num_objects); uint32_t i; ArchSpec arch; s->IndentMore(); for (i=0; i<num_archs; i++) { s->Indent(); GetArchitectureAtIndex(i, arch); s->Printf("arch[%u] = %s\n", arch.GetArchitectureName()); } for (i=0; i<num_objects; i++) { s->Indent(); s->Printf("object[%u] = %s\n", GetObjectNameAtIndex (i)); } s->IndentLess(); s->EOL(); }
std::string TestClient::GenerateLogFileName(const ArchSpec &arch) const { char *log_directory = getenv("LOG_FILE_DIRECTORY"); if (!log_directory) return ""; if (!llvm::sys::fs::is_directory(log_directory)) { GTEST_LOG_(WARNING) << "Cannot access log directory: " << log_directory; return ""; } std::string log_file_name; raw_string_ostream log_file(log_file_name); log_file << log_directory << "/lldb-" << m_test_case_name << '-' << m_test_name << '-' << arch.GetArchitectureName() << ".log"; return log_file.str(); }
TEST(ArchSpecTest, TestSetTriple) { ArchSpec AS; // Various flavors of valid triples. EXPECT_TRUE(AS.SetTriple("12-10-apple-darwin")); EXPECT_EQ(uint32_t(llvm::MachO::CPU_TYPE_ARM), AS.GetMachOCPUType()); EXPECT_EQ(10u, AS.GetMachOCPUSubType()); EXPECT_TRUE(llvm::StringRef(AS.GetTriple().str()) .consume_front("armv7f-apple-darwin")); EXPECT_EQ(ArchSpec::eCore_arm_armv7f, AS.GetCore()); AS = ArchSpec(); EXPECT_TRUE(AS.SetTriple("18.100-apple-darwin")); EXPECT_EQ(uint32_t(llvm::MachO::CPU_TYPE_POWERPC), AS.GetMachOCPUType()); EXPECT_EQ(100u, AS.GetMachOCPUSubType()); EXPECT_TRUE(llvm::StringRef(AS.GetTriple().str()) .consume_front("powerpc-apple-darwin")); EXPECT_EQ(ArchSpec::eCore_ppc_ppc970, AS.GetCore()); AS = ArchSpec(); EXPECT_TRUE(AS.SetTriple("i686-pc-windows")); EXPECT_EQ(llvm::Triple::x86, AS.GetTriple().getArch()); EXPECT_EQ(llvm::Triple::PC, AS.GetTriple().getVendor()); EXPECT_EQ(llvm::Triple::Win32, AS.GetTriple().getOS()); EXPECT_TRUE( llvm::StringRef(AS.GetTriple().str()).consume_front("i686-pc-windows")); EXPECT_STREQ("i686", AS.GetArchitectureName()); EXPECT_EQ(ArchSpec::eCore_x86_32_i686, AS.GetCore()); // Various flavors of invalid triples. AS = ArchSpec(); EXPECT_FALSE(AS.SetTriple("unknown-unknown-unknown")); AS = ArchSpec(); EXPECT_FALSE(AS.SetTriple("unknown")); AS = ArchSpec(); EXPECT_FALSE(AS.SetTriple("")); }
Error PlatformKalimba::ResolveExecutable (const FileSpec &exe_file, const ArchSpec &exe_arch, lldb::ModuleSP &exe_module_sp, const FileSpecList *module_search_paths_ptr) { Error error; char exe_path[PATH_MAX]; FileSpec resolved_exe_file (exe_file); if (!resolved_exe_file.Exists()) { exe_file.GetPath(exe_path, sizeof(exe_path)); error.SetErrorStringWithFormat("unable to find executable for '%s'", exe_path); } if (error.Success()) { ModuleSpec module_spec (resolved_exe_file, exe_arch); if (exe_arch.IsValid()) { error = ModuleList::GetSharedModule (module_spec, exe_module_sp, NULL, NULL, NULL); if (error.Fail()) { // If we failed, it may be because the vendor and os aren't known. If that is the // case, try setting them to the host architecture and give it another try. llvm::Triple &module_triple = module_spec.GetArchitecture().GetTriple(); bool is_vendor_specified = (module_triple.getVendor() != llvm::Triple::UnknownVendor); bool is_os_specified = (module_triple.getOS() != llvm::Triple::UnknownOS); if (!is_vendor_specified || !is_os_specified) { const llvm::Triple &host_triple = Host::GetArchitecture (Host::eSystemDefaultArchitecture).GetTriple(); if (!is_vendor_specified) module_triple.setVendorName (host_triple.getVendorName()); if (!is_os_specified) module_triple.setOSName (host_triple.getOSName()); error = ModuleList::GetSharedModule (module_spec, exe_module_sp, NULL, NULL, NULL); } } // TODO find out why exe_module_sp might be NULL if (!exe_module_sp || exe_module_sp->GetObjectFile() == NULL) { exe_module_sp.reset(); error.SetErrorStringWithFormat ("'%s' doesn't contain the architecture %s", exe_file.GetPath().c_str(), exe_arch.GetArchitectureName()); } } else { // No valid architecture was specified, ask the platform for // the architectures that we should be using (in the correct order) // and see if we can find a match that way StreamString arch_names; for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, module_spec.GetArchitecture()); ++idx) { error = ModuleList::GetSharedModule (module_spec, exe_module_sp, NULL, NULL, NULL); // Did we find an executable using one of the if (error.Success()) { if (exe_module_sp && exe_module_sp->GetObjectFile()) break; else error.SetErrorToGenericError(); } if (idx > 0) arch_names.PutCString (", "); arch_names.PutCString (module_spec.GetArchitecture().GetArchitectureName()); } if (error.Fail() || !exe_module_sp) { error.SetErrorStringWithFormat ("'%s' doesn't contain any '%s' platform architectures: %s", exe_file.GetPath().c_str(), GetPluginName().GetCString(), arch_names.GetString().c_str()); } } } return error; }
Error PlatformFreeBSD::ResolveExecutable (const FileSpec &exe_file, const ArchSpec &exe_arch, lldb::ModuleSP &exe_module_sp, const FileSpecList *module_search_paths_ptr) { Error error; // Nothing special to do here, just use the actual file and architecture char exe_path[PATH_MAX]; FileSpec resolved_exe_file (exe_file); if (IsHost()) { // If we have "ls" as the exe_file, resolve the executable loation based on // the current path variables if (!resolved_exe_file.Exists()) { exe_file.GetPath(exe_path, sizeof(exe_path)); resolved_exe_file.SetFile(exe_path, true); } if (!resolved_exe_file.Exists()) resolved_exe_file.ResolveExecutableLocation (); // Resolve any executable within a bundle on MacOSX //Host::ResolveExecutableInBundle (resolved_exe_file); if (resolved_exe_file.Exists()) error.Clear(); else { exe_file.GetPath(exe_path, sizeof(exe_path)); error.SetErrorStringWithFormat("unable to find executable for '%s'", exe_path); } } else { if (m_remote_platform_sp) { error = m_remote_platform_sp->ResolveExecutable (exe_file, exe_arch, exe_module_sp, module_search_paths_ptr); } else { // We may connect to a process and use the provided executable (Don't use local $PATH). // Resolve any executable within a bundle on MacOSX Host::ResolveExecutableInBundle (resolved_exe_file); if (resolved_exe_file.Exists()) { error.Clear(); } else { exe_file.GetPath(exe_path, sizeof(exe_path)); error.SetErrorStringWithFormat("the platform is not currently connected, and '%s' doesn't exist in the system root.", exe_path); } } } if (error.Success()) { ModuleSpec module_spec (resolved_exe_file, exe_arch); if (module_spec.GetArchitecture().IsValid()) { error = ModuleList::GetSharedModule (module_spec, exe_module_sp, module_search_paths_ptr, NULL, NULL); if (!exe_module_sp || exe_module_sp->GetObjectFile() == NULL) { exe_module_sp.reset(); error.SetErrorStringWithFormat ("'%s%s%s' doesn't contain the architecture %s", exe_file.GetDirectory().AsCString(""), exe_file.GetDirectory() ? "/" : "", exe_file.GetFilename().AsCString(""), exe_arch.GetArchitectureName()); } } else { // No valid architecture was specified, ask the platform for // the architectures that we should be using (in the correct order) // and see if we can find a match that way StreamString arch_names; ArchSpec platform_arch; for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, platform_arch); ++idx) { error = ModuleList::GetSharedModule (module_spec, exe_module_sp, module_search_paths_ptr, NULL, NULL); // Did we find an executable using one of the if (error.Success()) { if (exe_module_sp && exe_module_sp->GetObjectFile()) break; else error.SetErrorToGenericError(); } if (idx > 0) arch_names.PutCString (", "); arch_names.PutCString (platform_arch.GetArchitectureName()); } if (error.Fail() || !exe_module_sp) { error.SetErrorStringWithFormat ("'%s%s%s' doesn't contain any '%s' platform architectures: %s", exe_file.GetDirectory().AsCString(""), exe_file.GetDirectory() ? "/" : "", exe_file.GetFilename().AsCString(""), GetShortPluginName(), arch_names.GetString().c_str()); } } } else { error.SetErrorStringWithFormat ("'%s%s%s' does not exist", exe_file.GetDirectory().AsCString(""), exe_file.GetDirectory() ? "/" : "", exe_file.GetFilename().AsCString("")); } return error; }
Error TargetList::CreateTargetInternal (Debugger &debugger, const char *user_exe_path, const ArchSpec& specified_arch, bool get_dependent_files, lldb::PlatformSP &platform_sp, lldb::TargetSP &target_sp, bool is_dummy_target) { Timer scoped_timer (__PRETTY_FUNCTION__, "TargetList::CreateTarget (file = '%s', arch = '%s')", user_exe_path, specified_arch.GetArchitectureName()); Error error; ArchSpec arch(specified_arch); if (arch.IsValid()) { if (!platform_sp || !platform_sp->IsCompatibleArchitecture(arch, false, NULL)) platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch); } if (!platform_sp) platform_sp = debugger.GetPlatformList().GetSelectedPlatform(); if (!arch.IsValid()) arch = specified_arch; FileSpec file (user_exe_path, false); if (!file.Exists() && user_exe_path && user_exe_path[0] == '~') { // we want to expand the tilde but we don't want to resolve any symbolic links // so we can't use the FileSpec constructor's resolve flag llvm::SmallString<64> unglobbed_path(user_exe_path); FileSpec::ResolveUsername(unglobbed_path); if (unglobbed_path.empty()) file = FileSpec(user_exe_path, false); else file = FileSpec(unglobbed_path.c_str(), false); } bool user_exe_path_is_bundle = false; char resolved_bundle_exe_path[PATH_MAX]; resolved_bundle_exe_path[0] = '\0'; if (file) { if (file.GetFileType() == FileSpec::eFileTypeDirectory) user_exe_path_is_bundle = true; if (file.IsRelative() && user_exe_path) { // Ignore paths that start with "./" and "../" if (!((user_exe_path[0] == '.' && user_exe_path[1] == '/') || (user_exe_path[0] == '.' && user_exe_path[1] == '.' && user_exe_path[2] == '/'))) { char cwd[PATH_MAX]; if (getcwd (cwd, sizeof(cwd))) { std::string cwd_user_exe_path (cwd); cwd_user_exe_path += '/'; cwd_user_exe_path += user_exe_path; FileSpec cwd_file (cwd_user_exe_path.c_str(), false); if (cwd_file.Exists()) file = cwd_file; } } } ModuleSP exe_module_sp; if (platform_sp) { FileSpecList executable_search_paths (Target::GetDefaultExecutableSearchPaths()); ModuleSpec module_spec(file, arch); error = platform_sp->ResolveExecutable (module_spec, exe_module_sp, executable_search_paths.GetSize() ? &executable_search_paths : NULL); } if (error.Success() && exe_module_sp) { if (exe_module_sp->GetObjectFile() == NULL) { if (arch.IsValid()) { error.SetErrorStringWithFormat("\"%s\" doesn't contain architecture %s", file.GetPath().c_str(), arch.GetArchitectureName()); } else { error.SetErrorStringWithFormat("unsupported file type \"%s\"", file.GetPath().c_str()); } return error; } target_sp.reset(new Target(debugger, arch, platform_sp, is_dummy_target)); target_sp->SetExecutableModule (exe_module_sp, get_dependent_files); if (user_exe_path_is_bundle) exe_module_sp->GetFileSpec().GetPath(resolved_bundle_exe_path, sizeof(resolved_bundle_exe_path)); } } else { // No file was specified, just create an empty target with any arch // if a valid arch was specified target_sp.reset(new Target(debugger, arch, platform_sp, is_dummy_target)); } if (target_sp) { // Set argv0 with what the user typed, unless the user specified a // directory. If the user specified a directory, then it is probably a // bundle that was resolved and we need to use the resolved bundle path if (user_exe_path) { // Use exactly what the user typed as the first argument when we exec or posix_spawn if (user_exe_path_is_bundle && resolved_bundle_exe_path[0]) { target_sp->SetArg0 (resolved_bundle_exe_path); } else { // Use resolved path target_sp->SetArg0 (file.GetPath().c_str()); } } if (file.GetDirectory()) { FileSpec file_dir; file_dir.GetDirectory() = file.GetDirectory(); target_sp->GetExecutableSearchPaths ().Append (file_dir); } // Don't put the dummy target in the target list, it's held separately. if (!is_dummy_target) { Mutex::Locker locker(m_target_list_mutex); m_selected_target_idx = m_target_list.size(); m_target_list.push_back(target_sp); // Now prime this from the dummy target: target_sp->PrimeFromDummyTarget(debugger.GetDummyTarget()); } else { m_dummy_target_sp = target_sp; } } return error; }
Error TargetList::CreateTarget ( Debugger &debugger, const FileSpec& file, const ArchSpec& specified_arch, bool get_dependent_files, PlatformSP &platform_sp, TargetSP &target_sp ) { Timer scoped_timer (__PRETTY_FUNCTION__, "TargetList::CreateTarget (file = '%s/%s', arch = '%s')", file.GetDirectory().AsCString(), file.GetFilename().AsCString(), specified_arch.GetArchitectureName()); Error error; ArchSpec arch(specified_arch); if (platform_sp) { if (arch.IsValid()) { if (!platform_sp->IsCompatibleArchitecture(arch)) platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch); } } else if (arch.IsValid()) { platform_sp = Platform::GetPlatformForArchitecture(specified_arch, &arch); } if (!platform_sp) platform_sp = debugger.GetPlatformList().GetSelectedPlatform(); if (!arch.IsValid()) arch = specified_arch; if (file) { ModuleSP exe_module_sp; FileSpec resolved_file(file); if (platform_sp) { FileSpecList executable_search_paths (Target::GetDefaultExecutableSearchPaths()); error = platform_sp->ResolveExecutable (file, arch, exe_module_sp, executable_search_paths.GetSize() ? &executable_search_paths : NULL); } if (error.Success() && exe_module_sp) { if (exe_module_sp->GetObjectFile() == NULL) { if (arch.IsValid()) { error.SetErrorStringWithFormat("\"%s%s%s\" doesn't contain architecture %s", file.GetDirectory().AsCString(), file.GetDirectory() ? "/" : "", file.GetFilename().AsCString(), arch.GetArchitectureName()); } else { error.SetErrorStringWithFormat("unsupported file type \"%s%s%s\"", file.GetDirectory().AsCString(), file.GetDirectory() ? "/" : "", file.GetFilename().AsCString()); } return error; } target_sp.reset(new Target(debugger, arch, platform_sp)); target_sp->SetExecutableModule (exe_module_sp, get_dependent_files); } } else { // No file was specified, just create an empty target with any arch // if a valid arch was specified target_sp.reset(new Target(debugger, arch, platform_sp)); } if (target_sp) { target_sp->UpdateInstanceName(); Mutex::Locker locker(m_target_list_mutex); m_selected_target_idx = m_target_list.size(); m_target_list.push_back(target_sp); } return error; }
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; }