Error AdbClient::PullFile (const FileSpec &remote_file, const FileSpec &local_file) { auto error = StartSync (); if (error.Fail ()) return error; const auto local_file_path = local_file.GetPath (); llvm::FileRemover local_file_remover (local_file_path.c_str ()); std::ofstream dst (local_file_path, std::ios::out | std::ios::binary); if (!dst.is_open ()) return Error ("Unable to open local file %s", local_file_path.c_str()); const auto remote_file_path = remote_file.GetPath (false); error = SendSyncRequest (kRECV, remote_file_path.length (), remote_file_path.c_str ()); if (error.Fail ()) return error; std::vector<char> chunk; bool eof = false; while (!eof) { error = PullFileChunk (chunk, eof); if (error.Fail ()) return error; if (!eof) dst.write (&chunk[0], chunk.size ()); } local_file_remover.releaseFile (); return error; }
static Error save_socket_id_to_file(const std::string &socket_id, const FileSpec &file_spec) { FileSpec temp_file_spec(file_spec.GetDirectory().AsCString(), false); auto error = FileSystem::MakeDirectory(temp_file_spec, eFilePermissionsDirectoryDefault); if (error.Fail()) return Error("Failed to create directory %s: %s", temp_file_spec.GetCString(), error.AsCString()); llvm::SmallString<PATH_MAX> temp_file_path; temp_file_spec.AppendPathComponent("port-file.%%%%%%"); auto err_code = llvm::sys::fs::createUniqueFile(temp_file_spec.GetCString(), temp_file_path); if (err_code) return Error("Failed to create temp file: %s", err_code.message().c_str()); llvm::FileRemover tmp_file_remover(temp_file_path.c_str()); { std::ofstream temp_file(temp_file_path.c_str(), std::ios::out); if (!temp_file.is_open()) return Error("Failed to open temp file %s", temp_file_path.c_str()); temp_file << socket_id; } err_code = llvm::sys::fs::rename(temp_file_path.c_str(), file_spec.GetPath()); if (err_code) return Error("Failed to rename file %s to %s: %s", temp_file_path.c_str(), file_spec.GetPath().c_str(), err_code.message().c_str()); tmp_file_remover.releaseFile(); return Error(); }
Error ModuleCache::CreateHostSysRootModuleSymLink (const FileSpec &sysroot_module_path_spec, const FileSpec &module_file_path) { const auto error = MakeDirectory (FileSpec (sysroot_module_path_spec.GetDirectory ().AsCString (), false)); if (error.Fail ()) return error; return FileSystem::Symlink (sysroot_module_path_spec.GetPath ().c_str (), module_file_path.GetPath ().c_str ()); }
Error AdbClient::PushFile (const FileSpec &local_file, const FileSpec &remote_file) { auto error = StartSync (); if (error.Fail ()) return error; const auto local_file_path (local_file.GetPath ()); std::ifstream src (local_file_path.c_str(), std::ios::in | std::ios::binary); if (!src.is_open ()) return Error ("Unable to open local file %s", local_file_path.c_str()); std::stringstream file_description; file_description << remote_file.GetPath(false).c_str() << "," << kDefaultMode; std::string file_description_str = file_description.str(); error = SendSyncRequest (kSEND, file_description_str.length(), file_description_str.c_str()); if (error.Fail ()) return error; char chunk[kMaxPushData]; while (!src.eof() && !src.read(chunk, kMaxPushData).bad()) { size_t chunk_size = src.gcount(); error = SendSyncRequest(kDATA, chunk_size, chunk); if (error.Fail ()) return Error ("Failed to send file chunk: %s", error.AsCString ()); } error = SendSyncRequest(kDONE, local_file.GetModificationTime().seconds(), nullptr); if (error.Fail ()) return error; std::string response_id; uint32_t data_len; error = ReadSyncHeader (response_id, data_len); if (error.Fail ()) return Error ("Failed to read DONE response: %s", error.AsCString ()); if (response_id == kFAIL) { std::string error_message (data_len, 0); error = ReadAllBytes (&error_message[0], data_len); if (error.Fail ()) return Error ("Failed to read DONE error message: %s", error.AsCString ()); return Error ("Failed to push file: %s", error_message.c_str ()); } else if (response_id != kOKAY) return Error ("Got unexpected DONE response: %s", response_id.c_str ()); // If there was an error reading the source file, finish the adb file // transfer first so that adb isn't expecting any more data. if (src.bad()) return Error ("Failed read on %s", local_file_path.c_str()); return error; }
Error ModuleCache::Put (const FileSpec &root_dir_spec, const char *hostname, const ModuleSpec &module_spec, const FileSpec &tmp_file) { const auto module_spec_dir = GetModuleDirectory (root_dir_spec, module_spec.GetUUID ()); auto error = MakeDirectory (module_spec_dir); if (error.Fail ()) return error; const auto module_file_path = JoinPath (module_spec_dir, module_spec.GetFileSpec ().GetFilename ().AsCString ()); const auto tmp_file_path = tmp_file.GetPath (); const auto err_code = llvm::sys::fs::copy_file (tmp_file_path.c_str (), module_file_path.GetPath ().c_str ()); if (err_code) { error.SetErrorStringWithFormat ("failed to copy file %s to %s: %s", tmp_file_path.c_str (), module_file_path.GetPath ().c_str (), err_code.message ().c_str ()); } // Create sysroot link to a module. const auto sysroot_module_path_spec = GetHostSysRootModulePath (root_dir_spec, hostname, module_spec.GetFileSpec ()); return CreateHostSysRootModuleSymLink (sysroot_module_path_spec, module_file_path); }
Error AdbClient::Stat (const FileSpec &remote_file, uint32_t &mode, uint32_t &size, uint32_t &mtime) { auto error = StartSync (); if (error.Fail ()) return error; const std::string remote_file_path (remote_file.GetPath (false)); error = SendSyncRequest (kSTAT, remote_file_path.length (), remote_file_path.c_str ()); if (error.Fail ()) return Error ("Failed to send request: %s", error.AsCString ()); static const size_t stat_len = strlen (kSTAT); static const size_t response_len = stat_len + (sizeof (uint32_t) * 3); std::vector<char> buffer (response_len); error = ReadAllBytes (&buffer[0], buffer.size ()); if (error.Fail ()) return Error ("Failed to read response: %s", error.AsCString ()); DataExtractor extractor (&buffer[0], buffer.size (), eByteOrderLittle, sizeof (void*)); offset_t offset = 0; const void* command = extractor.GetData (&offset, stat_len); if (!command) return Error ("Failed to get response command"); const char* command_str = static_cast<const char*> (command); if (strncmp (command_str, kSTAT, stat_len)) return Error ("Got invalid stat command: %s", command_str); mode = extractor.GetU32 (&offset); size = extractor.GetU32 (&offset); mtime = extractor.GetU32 (&offset); return Error (); }
StructuredData::ObjectSP StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) { StructuredData::ObjectSP return_sp; auto buffer_or_error = llvm::MemoryBuffer::getFile(input_spec.GetPath()); if (!buffer_or_error) { error.SetErrorStringWithFormatv("could not open input file: {0} - {1}.", input_spec.GetPath(), buffer_or_error.getError().message()); return return_sp; } JSONParser json_parser(buffer_or_error.get()->getBuffer()); return_sp = ParseJSONValue(json_parser); return return_sp; }
bool PathMappingList::FindFile (const FileSpec &orig_spec, FileSpec &new_spec) const { if (!m_pairs.empty()) { char orig_path[PATH_MAX]; char new_path[PATH_MAX]; const size_t orig_path_len = orig_spec.GetPath (orig_path, sizeof(orig_path)); if (orig_path_len > 0) { const_iterator pos, end = m_pairs.end(); for (pos = m_pairs.begin(); pos != end; ++pos) { const size_t prefix_len = pos->first.GetLength(); if (orig_path_len >= prefix_len) { if (::strncmp (pos->first.GetCString(), orig_path, prefix_len) == 0) { const size_t new_path_len = snprintf(new_path, sizeof(new_path), "%s/%s", pos->second.GetCString(), orig_path + prefix_len); if (new_path_len < sizeof(new_path)) { new_spec.SetFile (new_path, true); if (new_spec.Exists()) return true; } } } } } } new_spec.Clear(); return false; }
void PlatformDarwinKernel::GetUserSpecifiedDirectoriesToSearch (std::vector<lldb_private::FileSpec> &directories) { FileSpecList user_dirs(GetGlobalProperties()->GetKextDirectories()); std::vector<FileSpec> possible_sdk_dirs; const uint32_t user_dirs_count = user_dirs.GetSize(); for (uint32_t i = 0; i < user_dirs_count; i++) { FileSpec dir = user_dirs.GetFileSpecAtIndex (i); dir.ResolvePath(); if (dir.Exists() && dir.IsDirectory()) { directories.push_back (dir); possible_sdk_dirs.push_back (dir); // does this directory have a *.sdk or *.kdk that we should look in? // Is there a "System/Library/Extensions" subdir of this directory? std::string dir_sle_path = dir.GetPath(); dir_sle_path.append ("/System/Library/Extensions"); FileSpec dir_sle(dir_sle_path.c_str(), true); if (dir_sle.Exists() && dir_sle.IsDirectory()) { directories.push_back (dir_sle); } } } SearchSDKsForKextDirectories (possible_sdk_dirs, directories); }
Error PlatformiOSSimulator::GetSymbolFile(const FileSpec &platform_file, const UUID *uuid_ptr, FileSpec &local_file) { Error error; char platform_file_path[PATH_MAX]; if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) { char resolved_path[PATH_MAX]; const char *sdk_dir = GetSDKDirectoryAsCString(); if (sdk_dir) { ::snprintf(resolved_path, sizeof(resolved_path), "%s/%s", sdk_dir, platform_file_path); // First try in the SDK and see if the file is in there local_file.SetFile(resolved_path, true); if (local_file.Exists()) return error; // Else fall back to the actual path itself local_file.SetFile(platform_file_path, true); if (local_file.Exists()) return error; } error.SetErrorStringWithFormat( "unable to locate a platform file for '%s' in platform '%s'", platform_file_path, GetPluginName().GetCString()); } else { error.SetErrorString("invalid platform file argument"); } return error; }
bool PlatformRemoteGDBServer::GetModuleSpec (const FileSpec& module_file_spec, const ArchSpec& arch, ModuleSpec &module_spec) { Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM); const auto module_path = module_file_spec.GetPath (false); if (!m_gdb_client.GetModuleInfo (module_file_spec, arch, module_spec)) { if (log) log->Printf ("PlatformRemoteGDBServer::%s - failed to get module info for %s:%s", __FUNCTION__, module_path.c_str (), arch.GetTriple ().getTriple ().c_str ()); return false; } if (log) { StreamString stream; module_spec.Dump (stream); log->Printf ("PlatformRemoteGDBServer::%s - got module info for (%s:%s) : %s", __FUNCTION__, module_path.c_str (), arch.GetTriple ().getTriple ().c_str (), stream.GetString ().c_str ()); } return true; }
Error PlatformRemoteAppleWatch::GetSymbolFile(const FileSpec &platform_file, const UUID *uuid_ptr, FileSpec &local_file) { Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST); Error error; char platform_file_path[PATH_MAX]; if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) { char resolved_path[PATH_MAX]; const char *os_version_dir = GetDeviceSupportDirectoryForOSVersion(); if (os_version_dir) { ::snprintf(resolved_path, sizeof(resolved_path), "%s/%s", os_version_dir, platform_file_path); local_file.SetFile(resolved_path, true); if (local_file.Exists()) { if (log) { log->Printf("Found a copy of %s in the DeviceSupport dir %s", platform_file_path, os_version_dir); } return error; } ::snprintf(resolved_path, sizeof(resolved_path), "%s/Symbols.Internal/%s", os_version_dir, platform_file_path); local_file.SetFile(resolved_path, true); if (local_file.Exists()) { if (log) { log->Printf( "Found a copy of %s in the DeviceSupport dir %s/Symbols.Internal", platform_file_path, os_version_dir); } return error; } ::snprintf(resolved_path, sizeof(resolved_path), "%s/Symbols/%s", os_version_dir, platform_file_path); local_file.SetFile(resolved_path, true); if (local_file.Exists()) { if (log) { log->Printf("Found a copy of %s in the DeviceSupport dir %s/Symbols", platform_file_path, os_version_dir); } return error; } } local_file = platform_file; if (local_file.Exists()) return error; error.SetErrorStringWithFormat( "unable to locate a platform file for '%s' in platform '%s'", platform_file_path, GetPluginName().GetCString()); } else { error.SetErrorString("invalid platform file argument"); } return error; }
llvm::sys::TimePoint<> FileSystem::GetModificationTime(const FileSpec &file_spec) { llvm::sys::fs::file_status status; std::error_code ec = llvm::sys::fs::status(file_spec.GetPath(), status); if (ec) return llvm::sys::TimePoint<>(); return status.getLastModificationTime(); }
Error PlatformRemoteiOS::GetSymbolFile (const FileSpec &platform_file, const UUID *uuid_ptr, FileSpec &local_file) { Error error; char platform_file_path[PATH_MAX]; if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) { char resolved_path[PATH_MAX]; const char * os_version_dir = GetDeviceSupportDirectoryForOSVersion(); if (os_version_dir) { ::snprintf (resolved_path, sizeof(resolved_path), "%s/%s", os_version_dir, platform_file_path); local_file.SetFile(resolved_path, true); if (local_file.Exists()) return error; ::snprintf (resolved_path, sizeof(resolved_path), "%s/Symbols.Internal/%s", os_version_dir, platform_file_path); local_file.SetFile(resolved_path, true); if (local_file.Exists()) return error; ::snprintf (resolved_path, sizeof(resolved_path), "%s/Symbols/%s", os_version_dir, platform_file_path); local_file.SetFile(resolved_path, true); if (local_file.Exists()) return error; } local_file = platform_file; if (local_file.Exists()) return error; error.SetErrorStringWithFormat ("unable to locate a platform file for '%s' in platform '%s'", platform_file_path, GetPluginName().GetCString()); } else { error.SetErrorString ("invalid platform file argument"); } return error; }
FileSpec::EnumerateDirectoryResult PlatformDarwinKernel::GetKextDirectoriesInSDK (void *baton, FileSpec::FileType file_type, const FileSpec &file_spec) { if (file_type == FileSpec::eFileTypeDirectory && (file_spec.GetFileNameExtension() == ConstString("sdk") || file_spec.GetFileNameExtension() == ConstString("kdk"))) { std::string kext_directory_path = file_spec.GetPath(); // Append the raw directory path, e.g. /Library/Developer/KDKs/KDK_10.10_14A298i.kdk // to the directory search list -- there may be kexts sitting directly // in that directory instead of being in a System/Library/Extensions subdir. ((std::vector<lldb_private::FileSpec> *)baton)->push_back(file_spec); // Check to see if there is a System/Library/Extensions subdir & add it if it exists std::string sle_kext_directory_path (kext_directory_path); sle_kext_directory_path.append ("/System/Library/Extensions"); FileSpec sle_kext_directory (sle_kext_directory_path.c_str(), true); if (sle_kext_directory.Exists() && sle_kext_directory.IsDirectory()) { ((std::vector<lldb_private::FileSpec> *)baton)->push_back(sle_kext_directory); } // Check to see if there is a Library/Extensions subdir & add it if it exists std::string le_kext_directory_path (kext_directory_path); le_kext_directory_path.append ("/Library/Extensions"); FileSpec le_kext_directory (le_kext_directory_path.c_str(), true); if (le_kext_directory.Exists() && le_kext_directory.IsDirectory()) { ((std::vector<lldb_private::FileSpec> *)baton)->push_back(le_kext_directory); } // Check to see if there is a System/Library/Kernels subdir & add it if it exists std::string slk_kernel_path (kext_directory_path); slk_kernel_path.append ("/System/Library/Kernels"); FileSpec slk_kernel_directory (slk_kernel_path.c_str(), true); if (slk_kernel_directory.Exists() && slk_kernel_directory.IsDirectory()) { ((std::vector<lldb_private::FileSpec> *)baton)->push_back(slk_kernel_directory); } // Check to see if there is a System/Library/Extensions/KDK subdir & add it if it exists std::string slek_kernel_path (kext_directory_path); slek_kernel_path.append ("/System/Library/Extensions/KDK"); FileSpec slek_kernel_directory (slek_kernel_path.c_str(), true); if (slek_kernel_directory.Exists() && slek_kernel_directory.IsDirectory()) { ((std::vector<lldb_private::FileSpec> *)baton)->push_back(slek_kernel_directory); } } return FileSpec::eEnumerateDirectoryResultNext; }
bool Symbol::SetReExportedSymbolSharedLibrary(const FileSpec &fspec) { if (m_type == eSymbolTypeReExported) { // For eSymbolTypeReExported, the "const char *" from a ConstString // is used as the offset in the address range base address. m_addr_range.SetByteSize( (uintptr_t)ConstString(fspec.GetPath().c_str()).GetCString()); return true; } return false; }
FileSpec Symbols::FindSymbolFileInBundle (const FileSpec& dsym_bundle_fspec, const lldb_private::UUID *uuid, const ArchSpec *arch) { char path[PATH_MAX]; FileSpec dsym_fspec; if (dsym_bundle_fspec.GetPath(path, sizeof(path))) { ::strncat (path, "/Contents/Resources/DWARF", sizeof(path) - strlen(path) - 1); lldb_utility::CleanUp <DIR *, int> dirp (opendir(path), NULL, closedir); if (dirp.is_valid()) { dsym_fspec.GetDirectory().SetCString(path); struct dirent* dp; while ((dp = readdir(dirp.get())) != NULL) { // Only search directories if (dp->d_type == DT_DIR || dp->d_type == DT_UNKNOWN) { if (dp->d_namlen == 1 && dp->d_name[0] == '.') continue; if (dp->d_namlen == 2 && dp->d_name[0] == '.' && dp->d_name[1] == '.') continue; } if (dp->d_type == DT_REG || dp->d_type == DT_UNKNOWN) { dsym_fspec.GetFilename().SetCString(dp->d_name); ModuleSpecList module_specs; if (ObjectFile::GetModuleSpecifications(dsym_fspec, 0, 0, module_specs)) { ModuleSpec spec; for (size_t i = 0; i < module_specs.GetSize(); ++i) { assert(module_specs.GetModuleSpecAtIndex(i, spec)); if ((uuid == NULL || (spec.GetUUIDPtr() && spec.GetUUID() == *uuid)) && (arch == NULL || (spec.GetArchitecturePtr() && spec.GetArchitecture().IsCompatibleMatch(*arch)))) { return dsym_fspec; } } } } } } } dsym_fspec.Clear(); return dsym_fspec; }
FileSpec Symbols::FindSymbolFileInBundle(const FileSpec &dsym_bundle_fspec, const lldb_private::UUID *uuid, const ArchSpec *arch) { char path[PATH_MAX]; if (dsym_bundle_fspec.GetPath(path, sizeof(path)) == 0) return {}; ::strncat(path, "/Contents/Resources/DWARF", sizeof(path) - strlen(path) - 1); DIR *dirp = opendir(path); if (!dirp) return {}; // Make sure we close the directory before exiting this scope. CleanUp cleanup_dir(closedir, dirp); FileSpec dsym_fspec; dsym_fspec.GetDirectory().SetCString(path); struct dirent *dp; while ((dp = readdir(dirp)) != NULL) { // Only search directories if (dp->d_type == DT_DIR || dp->d_type == DT_UNKNOWN) { if (dp->d_namlen == 1 && dp->d_name[0] == '.') continue; if (dp->d_namlen == 2 && dp->d_name[0] == '.' && dp->d_name[1] == '.') continue; } if (dp->d_type == DT_REG || dp->d_type == DT_UNKNOWN) { dsym_fspec.GetFilename().SetCString(dp->d_name); ModuleSpecList module_specs; if (ObjectFile::GetModuleSpecifications(dsym_fspec, 0, 0, module_specs)) { ModuleSpec spec; for (size_t i = 0; i < module_specs.GetSize(); ++i) { bool got_spec = module_specs.GetModuleSpecAtIndex(i, spec); UNUSED_IF_ASSERT_DISABLED(got_spec); assert(got_spec); if ((uuid == NULL || (spec.GetUUIDPtr() && spec.GetUUID() == *uuid)) && (arch == NULL || (spec.GetArchitecturePtr() && spec.GetArchitecture().IsCompatibleMatch(*arch)))) { return dsym_fspec; } } } } } return {}; }
Error PlatformAndroid::GetFile (const FileSpec& source, const FileSpec& destination) { if (IsHost() || !m_remote_platform_sp) return PlatformLinux::GetFile(source, destination); FileSpec source_spec (source.GetPath (false), false, FileSpec::ePathSyntaxPosix); if (source_spec.IsRelative()) source_spec = GetRemoteWorkingDirectory ().CopyByAppendingPathComponent (source_spec.GetCString (false)); AdbClient adb (m_device_id); return adb.PullFile (source_spec, destination); }
Error FileSystem::MakeDirectory(const FileSpec &file_spec, uint32_t file_permissions) { // On Win32, the mode parameter is ignored, as Windows files and directories support a // different permission model than POSIX. Error error; const auto err_code = llvm::sys::fs::create_directories(file_spec.GetPath(), true); if (err_code) { error.SetErrorString(err_code.message().c_str()); } return error; }
File::File (const FileSpec& filespec, uint32_t options, uint32_t permissions) : m_descriptor (kInvalidDescriptor), m_stream (kInvalidStream), m_options (0), m_own_stream (false), m_own_descriptor (false), m_is_interactive (eLazyBoolCalculate), m_is_real_terminal (eLazyBoolCalculate) { if (filespec) { Open (filespec.GetPath().c_str(), options, permissions); } }
Error PlatformAndroid::PutFile (const FileSpec& source, const FileSpec& destination, uint32_t uid, uint32_t gid) { if (IsHost() || !m_remote_platform_sp) return PlatformLinux::PutFile (source, destination, uid, gid); FileSpec destination_spec (destination.GetPath (false), false, FileSpec::ePathSyntaxPosix); if (destination_spec.IsRelative()) destination_spec = GetRemoteWorkingDirectory ().CopyByAppendingPathComponent (destination_spec.GetCString (false)); AdbClient adb (m_device_id); // TODO: Set correct uid and gid on remote file. return adb.PushFile(source, destination_spec); }
Error AdbClient::ShellToFile(const char *command, uint32_t timeout_ms, const FileSpec &output_file_spec) { std::vector<char> output_buffer; auto error = internalShell(command, timeout_ms, output_buffer); if (error.Fail()) return error; const auto output_filename = output_file_spec.GetPath(); std::ofstream dst(output_filename, std::ios::out | std::ios::binary); if (!dst.is_open()) return Error("Unable to open local file %s", output_filename.c_str()); dst.write(&output_buffer[0], output_buffer.size()); dst.close(); if (!dst) return Error("Failed to write file %s", output_filename.c_str()); return Error(); }
static FileSpec resolveCompDir(const FileSpec &path) { bool is_symlink = SymbolFileDWARF::GetSymlinkPaths().FindFileIndex( 0, path, /*full*/ true) != UINT32_MAX; if (!is_symlink) return path; namespace fs = llvm::sys::fs; if (fs::get_file_type(path.GetPath(), false) != fs::file_type::symlink_file) return path; FileSpec resolved_symlink; const auto error = FileSystem::Instance().Readlink(path, resolved_symlink); if (error.Success()) return resolved_symlink; return path; }
static FileSpec LocateDSYMMachFileInDSYMBundle ( const FileSpec& dsym_bundle_fspec, const lldb_private::UUID *uuid, const ArchSpec *arch) { char path[PATH_MAX]; FileSpec dsym_fspec; if (dsym_bundle_fspec.GetPath(path, sizeof(path))) { ::strncat (path, "/Contents/Resources/DWARF", sizeof(path) - strlen(path) - 1); lldb_utility::CleanUp <DIR *, int> dirp (opendir(path), NULL, closedir); if (dirp.is_valid()) { dsym_fspec.GetDirectory().SetCString(path); struct dirent* dp; while ((dp = readdir(dirp.get())) != NULL) { // Only search directories if (dp->d_type == DT_DIR || dp->d_type == DT_UNKNOWN) { if (dp->d_namlen == 1 && dp->d_name[0] == '.') continue; if (dp->d_namlen == 2 && dp->d_name[0] == '.' && dp->d_name[1] == '.') continue; } if (dp->d_type == DT_REG || dp->d_type == DT_UNKNOWN) { dsym_fspec.GetFilename().SetCString(dp->d_name); if (FileAtPathContainsArchAndUUID (dsym_fspec, arch, uuid)) return dsym_fspec; } } } } dsym_fspec.Clear(); return dsym_fspec; }
FileSpec::EnumerateDirectoryResult PlatformDarwinKernel::GetKextDirectoriesInSDK (void *baton, FileSpec::FileType file_type, const FileSpec &file_spec) { if (file_type == FileSpec::eFileTypeDirectory && (file_spec.GetFileNameExtension() == ConstString("sdk") || file_spec.GetFileNameExtension() == ConstString("kdk"))) { std::string kext_directory_path = file_spec.GetPath(); kext_directory_path.append ("/System/Library/Extensions"); FileSpec kext_directory (kext_directory_path.c_str(), true); if (kext_directory.Exists() && kext_directory.IsDirectory()) { ((std::vector<lldb_private::FileSpec> *)baton)->push_back(kext_directory); } } return FileSpec::eEnumerateDirectoryResultNext; }
Error Platform::ResolveExecutable (const FileSpec &exe_file, const ArchSpec &exe_arch, lldb::ModuleSP &exe_module_sp, const FileSpecList *module_search_paths_ptr) { Error error; if (exe_file.Exists()) { ModuleSpec module_spec (exe_file, exe_arch); if (module_spec.GetArchitecture().IsValid()) { error = ModuleList::GetSharedModule (module_spec, exe_module_sp, module_search_paths_ptr, NULL, NULL); } 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 for (uint32_t idx = 0; GetSupportedArchitectureAtIndex (idx, module_spec.GetArchitecture()); ++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() && exe_module_sp) break; } } } else { error.SetErrorStringWithFormat ("'%s' does not exist", exe_file.GetPath().c_str()); } return error; }
size_t ObjectFile::GetModuleSpecifications(const FileSpec &file, lldb::offset_t file_offset, lldb::offset_t file_size, ModuleSpecList &specs) { DataBufferSP data_sp = DataBufferLLVM::CreateSliceFromPath(file.GetPath(), 512, file_offset); if (data_sp) { if (file_size == 0) { const lldb::offset_t actual_file_size = file.GetByteSize(); if (actual_file_size > file_offset) file_size = actual_file_size - file_offset; } return ObjectFile::GetModuleSpecifications(file, // file spec data_sp, // data bytes 0, // data offset file_offset, // file offset file_size, // file length specs); } return 0; }
ModuleSpec GDBRemoteCommunicationServerCommon::GetModuleInfo( const std::string &module_path, const std::string &triple) { ArchSpec arch(triple.c_str()); const FileSpec req_module_path_spec(module_path.c_str(), true); const FileSpec module_path_spec = FindModuleFile(req_module_path_spec.GetPath(), arch); const ModuleSpec module_spec(module_path_spec, arch); ModuleSpecList module_specs; if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0, module_specs)) return ModuleSpec(); ModuleSpec matched_module_spec; if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec)) return ModuleSpec(); return matched_module_spec; }
FileSpec::EnumerateDirectoryResult PlatformDarwinKernel::GetKextsInDirectory (void *baton, FileSpec::FileType file_type, const FileSpec &file_spec) { if (file_type == FileSpec::eFileTypeDirectory && file_spec.GetFileNameExtension() == ConstString("kext")) { ((std::vector<lldb_private::FileSpec> *)baton)->push_back(file_spec); std::string kext_bundle_path = file_spec.GetPath(); std::string search_here_too; std::string contents_plugins_path = kext_bundle_path + "/Contents/PlugIns"; FileSpec contents_plugins (contents_plugins_path.c_str(), false); if (contents_plugins.Exists() && contents_plugins.IsDirectory()) { search_here_too = contents_plugins_path; } else { std::string plugins_path = kext_bundle_path + "/PlugIns"; FileSpec plugins (plugins_path.c_str(), false); if (plugins.Exists() && plugins.IsDirectory()) { search_here_too = plugins_path; } } if (!search_here_too.empty()) { const bool find_directories = true; const bool find_files = false; const bool find_other = false; FileSpec::EnumerateDirectory (search_here_too.c_str(), find_directories, find_files, find_other, GetKextsInDirectory, baton); } } return FileSpec::eEnumerateDirectoryResultNext; }