[lldb][Android] Support zip .so file

[splhack]

Summary

In Android API level 23 and above, dynamic loader is able to load .so file
directly from APK, which is zip file.
https://android.googlesource.com/platform/bionic/+/master/
android-changes-for-ndk-developers.md#
opening-shared-libraries-directly-from-an-apk

The .so file is page aligned and uncompressed, so
ObjectFileELF::GetModuleSpecifications works with .so file offset and size
directly from zip file without extracting it. (D152757)

GDBRemoteCommunicationServerCommon::GetModuleInfo returns a module spec to LLDB
with "zip_path!/so_path" file spec, which is passed through from Android
dynamic loader, and the .so file offset and size.

PlatformAndroid::DownloadModuleSlice uses 'shell dd' to download the .so file
slice from the zip file with the .so file offset and size.

Depends on D152757

AndroidPlatformTest is added in D152855

[bulbazord]

This is definitely useful to support, I had a few comments mostly about matching lldb's coding style.

Also, are you running clang-format on your patches? There are a few places where I'm not sure if the formatting is right.

lldb/source/Host/CMakeLists.txt

110–122

I don't think this is correct to do. lldbHost is different than other libraries in that it's meant to provide functionality that lldb and lldb-server needs to work on the host system. Unconditionally adding a host subdirectory for android even when we're on Linux doesn't make sense to do.

lldb/source/Host/android/HostInfoAndroid.cpp

107 ↗

(On Diff #530715)

You can avoid using std::string here (and invoking the constructor) by using an llvm::StringLiteral. Like so:

static constexpr llvm::StringLiteral k_zip_separator("!/");

108 ↗

(On Diff #530715)

It's not obvious what the type of path is, please write out the type instead of using auto.

119–126 ↗

(On Diff #530715)

It's not obvious what the types of these are (except for zip_file_spec), please write out the types explicitly.

126 ↗

(On Diff #530715)

It's not obvious what 0 is as the parameter here, please make it look something like this:
/* offset = */ 0);

lldb/source/Plugins/Platform/Android/PlatformAndroid.cpp

257–260

Maybe it would be a good idea to centralize the run-as logic somewhere, right now it's pretty ad-hoc.

lldb/unittests/Host/CMakeLists.txt

42

Why not just match on "Android"?

[splhack]

@bulbazord thanks for reviewing! will address the types, formats.

lldb/source/Host/CMakeLists.txt

110–122

I agree with that, however, I think this is pretty much only way to unblock writing and running unit tests for the Android host system, which has been no tests at all. The AndroidPlatformTest D152855 requires this to run the tests on Linux, and Android is basically Linux, so, hope it still makes sense for the unit testing capability. (only android/LibcGlue.cpp is not buildable for Linux target.)

lldb/source/Plugins/Platform/Android/PlatformAndroid.cpp

257–260

Will look into these run-as things with D152494 centralize and if plugin.platform.android.platform-run-as possible.

lldb/unittests/Host/CMakeLists.txt

42

The reason is, as commented above, to run AndroidPlatformTest D152855 on Linux.

[bulbazord]

lldb/source/Host/CMakeLists.txt

110–122

I see. You want to be able to run the android host tests but that's not easy to do right now. I think this is a reasonable thing to want to do (especially since so much of android support in lldb is not well tested AFAIK).

Instead of making this functionality specific to android hosts, why not make it possible to do on all platforms? This would do a few things:

• It would make it easier to test on more than just Linux and Android machines.
• It would open up the possibility of being able to use an apk on the host machine instead of needing to fetch it from the remote device via adb shell dd. An optimization for sure, but for large shared objects this may be able to improve performance.

What do you think?

lldb/source/Host/android/ZipFile.cpp

1 ↗

(On Diff #530715)

BTW, I haven't looked at this file too closely yet, but I think a better candidate for its location would be lldbUtility. It doesn't rely on anything else from lldb other than something else in lldbUtility.

[splhack]

lldb/source/Host/CMakeLists.txt

110–122

Yeah, sounds great to me! will update move things around.

• include/lldb/Utility/ZipFile.h
• source/Utility/ZipFile.cpp
• HostInfoAndroid::ResolveZipPath -> ZipFile::ResolveBionicZipPath (this is bionic libc specific)

[splhack]

• ZipFile: zip file parser in Utility
  • include/lldb/Utility/ZipFile.h
  • source/Utility/ZipFile.cpp

• ZipFileResolver: bionic zip .so file resolver, depends on Host::FileSystem
  • include/lldb/Host/common/ZipFileResolver.h
  • source/Host/common/ZipFileResolver.cpp

• ZipFileResolverTest
  • unittests/Host/common

[splhack]

rebase onto D152757

[splhack]

lldb/source/Plugins/Platform/Android/PlatformAndroid.cpp

257–260

run-as is centralized in D152933

[splhack]

remove 'Depends on' from commit message.

[splhack]

rebase

[splhack]

Fixed diff dependencies in order to fix CI
https://reviews.llvm.org/B238937

[bulbazord]

Thanks for reworking it! You may want to wait a little bit before landing so others have some time to look over it, but I don't see anything that should prevent this from going in.

[mib]

lldb/include/lldb/Host/common/ZipFileResolver.h

31

This function name sounds like the the bionic linker is in the zip file which is not the case IIUC. I'm fine with adding a zip file resolver in lldb but I'd prefer if it had a generic name, otherwise, this should be a plugin.

lldb/source/Utility/ZipFile.cpp

20–22

Did you just copy & past the this file from somewhere else of did you implement it yourself ?

[mib]

lldb/include/lldb/Host/common/ZipFileResolver.h

31

what about this instead ?

[splhack]

lldb/include/lldb/Host/common/ZipFileResolver.h

31

Yes, should be good. will update this diff.

(Why it had "Bionic" because I thought the path encoding "zip_path!/lib_path" is bionic specific.)

lldb/source/Utility/ZipFile.cpp

20–22

I implemented this code.

logic

• Linear search the end of central directory record from the file end because it is located at the end of the file with comment (64KB max)
• Linear search the file from the central directory records that is pointed by the end of central directory record.
• Get the file offset and size from the local file header that is pointed by the central directory record
• Use unaligned_uint16_t/unaligned_uint32_t since Zip header is 1 byte aligned.

[clayborg]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

1336

might be good to init this to an invalid value in case code changes over time?

[splhack]

Rename ResolveBionicPath to ResolveSharedLibraryPath.

[splhack]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

1336

yup, sounds good. will add with assert.

[splhack]

Added eFileKindInvalid with assert

[splhack]

rebase

[splhack]

rebase

[splhack]

ResolveSharedLibraryPathWithZipExisting and ResolveSharedLibraryPathWithZipMissing are failing on Windows. Looking into.
https://lab.llvm.org/buildbot/#/builders/219/builds/3674

[splhack]

Fixed Windows test failures in D153390

lldb/include/lldb/Host/common/ZipFileResolver.h

+//===-- ZipFileResolver.h ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_HOST_ZIPFILERESOLVER_H
+#define LLDB_HOST_ZIPFILERESOLVER_H
+
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+
+/// In Android API level 23 and above, bionic dynamic linker is able to load
+/// .so file directly from APK or .zip file. This is a utility class to resolve
+/// the file spec in order to get the zip path and the .so file offset and size
+/// if the file spec contains "zip_path!/so_path".
+/// https://android.googlesource.com/platform/bionic/+/master/
+/// android-changes-for-ndk-developers.md#
+/// opening-shared-libraries-directly-from-an-apk
+class ZipFileResolver {
+public:
+  enum FileKind {
+    eFileKindInvalid = 0,
+    eFileKindNormal,
+    eFileKindZip,
+  };
+
+  static bool ResolveSharedLibraryPath(const FileSpec &file_spec,
+                                       FileKind &file_kind,
+                                       std::string &file_path,
+                                       lldb::offset_t &so_file_offset,
+                                       lldb::offset_t &so_file_size);
+};
+
+} // end of namespace lldb_private
+
+#endif // LLDB_HOST_ZIPFILERESOLVER_H

lldb/include/lldb/Utility/ZipFile.h

+//===-- ZipFile.h -----------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_ZIPFILE_H
+#define LLDB_UTILITY_ZIPFILE_H
+
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+
+/// In Android API level 23 and above, bionic dynamic linker is able to load
+/// .so file directly from APK or .zip file. This is a utility class to find
+/// .so file offset and size from zip file.
+/// https://android.googlesource.com/platform/bionic/+/master/
+/// android-changes-for-ndk-developers.md#
+/// opening-shared-libraries-directly-from-an-apk
+class ZipFile {
+public:
+  static bool Find(lldb::DataBufferSP zip_data, const llvm::StringRef file_path,
+                   lldb::offset_t &file_offset, lldb::offset_t &file_size);
+};
+
+} // end of namespace lldb_private
+
+#endif // LLDB_UTILITY_ZIPFILE_H

lldb/source/Host/CMakeLists.txt

add_host_subdirectory(common
   common/PseudoTerminal.cpp
   common/SocketAddress.cpp
   common/Socket.cpp
   common/TCPSocket.cpp
   common/Terminal.cpp
   common/ThreadLauncher.cpp
   common/UDPSocket.cpp
   common/XML.cpp
+  common/ZipFileResolver.cpp
   )
 
 if (LLDB_ENABLE_LIBEDIT)
   add_host_subdirectory(common
     common/Editline.cpp
     )
 endif()
 
else()
   elseif (CMAKE_SYSTEM_NAME MATCHES "Linux|Android")
     add_host_subdirectory(linux
       linux/AbstractSocket.cpp
       linux/Host.cpp
       linux/HostInfoLinux.cpp
       linux/LibcGlue.cpp
       linux/Support.cpp
       )
     if (CMAKE_SYSTEM_NAME MATCHES "Android")
       add_host_subdirectory(android
         android/HostInfoAndroid.cpp
         android/LibcGlue.cpp
         )
     endif()
   elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
     add_host_subdirectory(freebsd
       freebsd/Host.cpp
       freebsd/HostInfoFreeBSD.cpp
       )
 
   elseif (CMAKE_SYSTEM_NAME MATCHES "NetBSD")
     add_host_subdirectory(netbsd
       netbsd/HostNetBSD.cpp
       netbsd/HostInfoNetBSD.cpp
       )
 
   elseif (CMAKE_SYSTEM_NAME MATCHES "OpenBSD")
     add_host_subdirectory(openbsd
       openbsd/Host.cpp

lldb/source/Host/common/ZipFileResolver.cpp

+//===-- ZipFileResolver.cpp -----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/common/ZipFileResolver.h"
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Utility/DataBuffer.h"
+#include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/ZipFile.h"
+
+using namespace lldb_private;
+using namespace llvm::support;
+
+bool ZipFileResolver::ResolveSharedLibraryPath(const FileSpec &file_spec,
+                                               FileKind &file_kind,
+                                               std::string &file_path,
+                                               lldb::offset_t &so_file_offset,
+                                               lldb::offset_t &so_file_size) {
+  // When bionic loads .so file from APK or zip file, this file_spec will be
+  // "zip_path!/so_path". Otherwise it is just a normal file path.
+  static constexpr llvm::StringLiteral k_zip_separator("!/");
+  std::string path(file_spec.GetPath());
+  size_t pos = path.find(k_zip_separator);
+  if (pos == std::string::npos) {
+    // This file_spec does not contain the zip separator.
+    // Treat this file_spec as a normal file.
+    // so_file_offset and so_file_size should be 0.
+    file_kind = FileKind::eFileKindNormal;
+    file_path = path;
+    so_file_offset = 0;
+    so_file_size = 0;
+    return true;
+  }
+
+  // This file_spec is a zip .so path. Extract the zip path and the .so path.
+  std::string zip_path(path.substr(0, pos));
+  std::string so_path(path.substr(pos + k_zip_separator.size()));
+
+  // Try to find the .so file from the zip file.
+  FileSpec zip_file_spec(zip_path);
+  uint64_t zip_file_size = FileSystem::Instance().GetByteSize(zip_file_spec);
+  lldb::DataBufferSP zip_data =
+      FileSystem::Instance().CreateDataBuffer(zip_file_spec, zip_file_size);
+  if (ZipFile::Find(zip_data, so_path, so_file_offset, so_file_size)) {
+    // Found the .so file from the zip file and got the file offset and size.
+    // Return the zip path. so_file_offset and so_file_size are already set.
+    file_kind = FileKind::eFileKindZip;
+    file_path = zip_path;
+    return true;
+  }
+
+  return false;
+}

lldb/source/Plugins/Platform/Android/PlatformAndroid.cpp

 }
 
 const char *PlatformAndroid::GetCacheHostname() { return m_device_id.c_str(); }
 
 Status PlatformAndroid::DownloadModuleSlice(const FileSpec &src_file_spec,
                                             const uint64_t src_offset,
                                             const uint64_t src_size,
                                             const FileSpec &dst_file_spec) {
-  if (src_offset != 0)
-    return Status("Invalid offset - %" PRIu64, src_offset);
-
+  // In Android API level 23 and above, dynamic loader is able to load .so
+  // file directly from APK. In that case, src_offset will be an non-zero.
+  if (src_offset == 0) // Use GetFile for a normal file.
     return GetFile(src_file_spec, dst_file_spec);
+
+  std::string source_file = src_file_spec.GetPath(false);
+  if (source_file.find('\'') != std::string::npos)
+    return Status("Doesn't support single-quotes in filenames");
+
+  // For zip .so file, src_file_spec will be "zip_path!/so_path".
+  // Extract "zip_path" from the source_file.
+  static constexpr llvm::StringLiteral k_zip_separator("!/");
+  size_t pos = source_file.find(k_zip_separator);
+  if (pos != std::string::npos)
+    source_file = source_file.substr(0, pos);
+
+  AdbClient adb(m_device_id);
+
+  // Use 'shell dd' to download the file slice with the offset and size.
+  char cmd[PATH_MAX];
+  snprintf(cmd, sizeof(cmd),
+           "dd if='%s' iflag=skip_bytes,count_bytes "
+           "skip=%" PRIu64 " count=%" PRIu64 " status=none",
+           source_file.c_str(), src_offset, src_size);
+
+  return adb.ShellToFile(cmd, minutes(1), dst_file_spec);
 }
 
 Status PlatformAndroid::DisconnectRemote() {
   Status error = PlatformLinux::DisconnectRemote();
   if (error.Success()) {
     m_device_id.clear();
     m_sdk_version = 0;
   }
Status error = adb.Shell("mktemp --directory --tmpdir /data/local/tmp",
                            seconds(5), &tmpdir);
   if (error.Fail() || tmpdir.empty())
     return Status("Failed to generate temporary directory on the device (%s)",
                   error.AsCString());
   tmpdir = llvm::StringRef(tmpdir).trim().str();
 
   // Create file remover for the temporary directory created on the device
   std::unique_ptr<std::string, std::function<void(std::string *)>>
       tmpdir_remover(&tmpdir, [&adb](std::string *s) {
         StreamString command;
         command.Printf("rm -rf %s", s->c_str());
         Status error = adb.Shell(command.GetData(), seconds(5), nullptr);
 
         Log *log = GetLog(LLDBLog::Platform);
         if (log && error.Fail())
-      LLDB_LOGF(log, "Failed to remove temp directory: %s", error.AsCString());
+          LLDB_LOGF(log, "Failed to remove temp directory: %s",
+                    error.AsCString());
       });
 
   FileSpec symfile_platform_filespec(tmpdir);
   symfile_platform_filespec.AppendPathComponent("symbolized.oat");
 
   // Execute oatdump on the remote device to generate a file with symtab
   StreamString command;
   command.Printf("oatdump --symbolize=%s --output=%s",
                  module_sp->GetPlatformFileSpec().GetPath(false).c_str(),

 bool PlatformAndroid::GetRemoteOSVersion() {
   m_os_version = llvm::VersionTuple(GetSdkVersion());
   return !m_os_version.empty();
 }
 
 llvm::StringRef
 PlatformAndroid::GetLibdlFunctionDeclarations(lldb_private::Process *process) {
   SymbolContextList matching_symbols;
-  std::vector<const char *> dl_open_names = { "__dl_dlopen", "dlopen" };
+  std::vector<const char *> dl_open_names = {"__dl_dlopen", "dlopen"};
   const char *dl_open_name = nullptr;
   Target &target = process->GetTarget();
-  for (auto name: dl_open_names) {
+  for (auto name : dl_open_names) {
     target.GetImages().FindFunctionSymbols(
         ConstString(name), eFunctionNameTypeFull, matching_symbols);
     if (matching_symbols.GetSize()) {
-       dl_open_name = name;
-       break;
     }
   }
   // Older platform versions have the dl function symbols mangled
   if (dl_open_name == dl_open_names[0])
     return R"(
               extern "C" void* dlopen(const char*, int) asm("__dl_dlopen");
               extern "C" void* dlsym(void*, const char*) asm("__dl_dlsym");
               extern "C" int   dlclose(void*) asm("__dl_dlclose");

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

 #include "llvm/Support/JSON.h"
 #include "llvm/TargetParser/Triple.h"
 
 #include "ProcessGDBRemoteLog.h"
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 
 #ifdef __ANDROID__
 #include "lldb/Host/android/HostInfoAndroid.h"
+#include "lldb/Host/common/ZipFileResolver.h"
 #endif
 
-
 using namespace lldb;
 using namespace lldb_private::process_gdb_remote;
 using namespace lldb_private;
 
 #ifdef __ANDROID__
 const static uint32_t g_default_packet_timeout_sec = 20; // seconds
 #else
 const static uint32_t g_default_packet_timeout_sec = 0; // not specified
GDBRemoteCommunicationServerCommon::Handle_qModuleInfo(
 
   const auto &module_arch = matched_module_spec.GetArchitecture();
   response.PutCString("triple:");
   response.PutStringAsRawHex8(module_arch.GetTriple().getTriple());
   response.PutChar(';');
 
   response.PutCString("file_path:");
   response.PutStringAsRawHex8(
-        matched_module_spec.GetFileSpec().GetPath().c_str());
   response.PutChar(';');
   response.PutCString("file_offset:");
   response.PutHex64(file_offset);
   response.PutChar(';');
   response.PutCString("file_size:");
   response.PutHex64(file_size);
   response.PutChar(';');
 
GDBRemoteCommunicationServerCommon::GetModuleInfo(llvm::StringRef module_path,
                                                   llvm::StringRef triple) {
   ArchSpec arch(triple);
 
   FileSpec req_module_path_spec(module_path);
   FileSystem::Instance().Resolve(req_module_path_spec);
 
   const FileSpec module_path_spec =
       FindModuleFile(req_module_path_spec.GetPath(), arch);
-  const ModuleSpec module_spec(module_path_spec, arch);
+
+  lldb::offset_t file_offset = 0;
+  lldb::offset_t file_size = 0;
+#ifdef __ANDROID__
+  // In Android API level 23 and above, dynamic loader is able to load .so file
+  // directly from zip file. In that case, module_path will be
+  // "zip_path!/so_path". Resolve the zip file path, .so file offset and size.
+  ZipFileResolver::FileKind file_kind = ZipFileResolver::eFileKindInvalid;
+  std::string file_path;
+  if (!ZipFileResolver::ResolveSharedLibraryPath(
+          module_path_spec, file_kind, file_path, file_offset, file_size)) {
+    return ModuleSpec();
+  }
+  lldbassert(file_kind != ZipFileResolver::eFileKindInvalid);
+  // For zip .so file, this file_path will contain only the actual zip file
+  // path for the object file processing. Otherwise it is the same as
+  // module_path.
+  const FileSpec actual_module_path_spec(file_path);
+#else
+  // It is just module_path_spec reference for other platforms.
+  const FileSpec &actual_module_path_spec = module_path_spec;
+#endif
+
+  const ModuleSpec module_spec(actual_module_path_spec, arch);
 
   ModuleSpecList module_specs;
-  if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0,
-                                           module_specs))
+  if (!ObjectFile::GetModuleSpecifications(actual_module_path_spec, file_offset,
+                                           file_size, module_specs))
     return ModuleSpec();
 
   ModuleSpec matched_module_spec;
   if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
     return ModuleSpec();
 
+#ifdef __ANDROID__
+  if (file_kind == ZipFileResolver::eFileKindZip) {
+    // For zip .so file, matched_module_spec contains only the actual zip file
+    // path for the object file processing. Overwrite the matched_module_spec
+    // file spec with the original module_path_spec to pass "zip_path!/so_path"
+    // through to PlatformAndroid::DownloadModuleSlice.
+    *matched_module_spec.GetFileSpecPtr() = module_path_spec;
+  }
+#endif
+
   return matched_module_spec;
 }
 
 std::vector<std::string> GDBRemoteCommunicationServerCommon::HandleFeatures(
     const llvm::ArrayRef<llvm::StringRef> client_features) {
   // 128KBytes is a reasonable max packet size--debugger can always use less.
   constexpr uint32_t max_packet_size = 128 * 1024;
 
   // Features common to platform server and llgs.
   return {
       llvm::formatv("PacketSize={0}", max_packet_size),
       "QStartNoAckMode+",
       "qEcho+",
       "native-signals+",
   };
 }

lldb/source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility NO_INTERNAL_DEPENDENCIES
   UnimplementedError.cpp
   UUID.cpp
   UriParser.cpp
   UserID.cpp
   UserIDResolver.cpp
   VASprintf.cpp
   VMRange.cpp
   XcodeSDK.cpp
+  ZipFile.cpp
 
   LINK_LIBS
     ${LLDB_SYSTEM_LIBS}
     # lldbUtility does not depend on other LLDB libraries
 
   LINK_COMPONENTS
     BinaryFormat
     Support
     TargetParser
   )

lldb/source/Utility/ZipFile.cpp

+//===-- ZipFile.cpp -------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/ZipFile.h"
+#include "lldb/Utility/DataBuffer.h"
+#include "lldb/Utility/FileSpec.h"
+#include "llvm/Support/Endian.h"
+
+using namespace lldb_private;
+using namespace llvm::support;
+
+namespace {
+
+// Zip headers.
+// https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+
+// The end of central directory record.
+struct EocdRecord {
+  static constexpr char kSignature[] = {0x50, 0x4b, 0x05, 0x06};
+  char signature[sizeof(kSignature)];
+  unaligned_uint16_t disks;
+  unaligned_uint16_t cd_start_disk;
+  unaligned_uint16_t cds_on_this_disk;
+  unaligned_uint16_t cd_records;
+  unaligned_uint32_t cd_size;
+  unaligned_uint32_t cd_offset;
+  unaligned_uint16_t comment_length;
+};
+
+// Logical find limit for the end of central directory record.
+const size_t kEocdRecordFindLimit =
+    sizeof(EocdRecord) +
+    std::numeric_limits<decltype(EocdRecord::comment_length)>::max();
+
+// Central directory record.
+struct CdRecord {
+  static constexpr char kSignature[] = {0x50, 0x4b, 0x01, 0x02};
+  char signature[sizeof(kSignature)];
+  unaligned_uint16_t version_made_by;
+  unaligned_uint16_t version_needed_to_extract;
+  unaligned_uint16_t general_purpose_bit_flag;
+  unaligned_uint16_t compression_method;
+  unaligned_uint16_t last_modification_time;
+  unaligned_uint16_t last_modification_date;
+  unaligned_uint32_t crc32;
+  unaligned_uint32_t compressed_size;
+  unaligned_uint32_t uncompressed_size;
+  unaligned_uint16_t file_name_length;
+  unaligned_uint16_t extra_field_length;
+  unaligned_uint16_t comment_length;
+  unaligned_uint16_t file_start_disk;
+  unaligned_uint16_t internal_file_attributes;
+  unaligned_uint32_t external_file_attributes;
+  unaligned_uint32_t local_file_header_offset;
+};
+// Immediately after CdRecord,
+// - file name (file_name_length)
+// - extra field (extra_field_length)
+// - comment (comment_length)
+
+// Local file header.
+struct LocalFileHeader {
+  static constexpr char kSignature[] = {0x50, 0x4b, 0x03, 0x04};
+  char signature[sizeof(kSignature)];
+  unaligned_uint16_t version_needed_to_extract;
+  unaligned_uint16_t general_purpose_bit_flag;
+  unaligned_uint16_t compression_method;
+  unaligned_uint16_t last_modification_time;
+  unaligned_uint16_t last_modification_date;
+  unaligned_uint32_t crc32;
+  unaligned_uint32_t compressed_size;
+  unaligned_uint32_t uncompressed_size;
+  unaligned_uint16_t file_name_length;
+  unaligned_uint16_t extra_field_length;
+};
+// Immediately after LocalFileHeader,
+// - file name (file_name_length)
+// - extra field (extra_field_length)
+// - file data (should be compressed_size == uncompressed_size, page aligned)
+
+const EocdRecord *FindEocdRecord(lldb::DataBufferSP zip_data) {
+  // Find backward the end of central directory record from the end of the zip
+  // file to the find limit.
+  const uint8_t *zip_data_end = zip_data->GetBytes() + zip_data->GetByteSize();
+  const uint8_t *find_limit = zip_data_end - kEocdRecordFindLimit;
+  const uint8_t *p = zip_data_end - sizeof(EocdRecord);
+  for (; p >= zip_data->GetBytes() && p >= find_limit; p--) {
+    auto eocd = reinterpret_cast<const EocdRecord *>(p);
+    if (::memcmp(eocd->signature, EocdRecord::kSignature,
+                 sizeof(EocdRecord::kSignature)) == 0) {
+      // Found the end of central directory. Sanity check the values.
+      if (eocd->cd_records * sizeof(CdRecord) > eocd->cd_size ||
+          zip_data->GetBytes() + eocd->cd_offset + eocd->cd_size > p)
+        return nullptr;
+
+      // This is a valid end of central directory record.
+      return eocd;
+    }
+  }
+  return nullptr;
+}
+
+bool GetFile(lldb::DataBufferSP zip_data, uint32_t local_file_header_offset,
+             lldb::offset_t &file_offset, lldb::offset_t &file_size) {
+  auto local_file_header = reinterpret_cast<const LocalFileHeader *>(
+      zip_data->GetBytes() + local_file_header_offset);
+  // The signature should match.
+  if (::memcmp(local_file_header->signature, LocalFileHeader::kSignature,
+               sizeof(LocalFileHeader::kSignature)) != 0)
+    return false;
+
+  auto file_data = reinterpret_cast<const uint8_t *>(local_file_header + 1) +
+                   local_file_header->file_name_length +
+                   local_file_header->extra_field_length;
+  // File should be uncompressed.
+  if (local_file_header->compressed_size !=
+      local_file_header->uncompressed_size)
+    return false;
+
+  // This file is valid. Return the file offset and size.
+  file_offset = file_data - zip_data->GetBytes();
+  file_size = local_file_header->uncompressed_size;
+  return true;
+}
+
+bool FindFile(lldb::DataBufferSP zip_data, const EocdRecord *eocd,
+              const llvm::StringRef file_path, lldb::offset_t &file_offset,
+              lldb::offset_t &file_size) {
+  // Find the file from the central directory records.
+  auto cd = reinterpret_cast<const CdRecord *>(zip_data->GetBytes() +
+                                               eocd->cd_offset);
+  size_t cd_records = eocd->cd_records;
+  for (size_t i = 0; i < cd_records; i++) {
+    // The signature should match.
+    if (::memcmp(cd->signature, CdRecord::kSignature,
+                 sizeof(CdRecord::kSignature)) != 0)
+      return false;
+
+    // Sanity check the file name values.
+    auto file_name = reinterpret_cast<const char *>(cd + 1);
+    size_t file_name_length = cd->file_name_length;
+    if (file_name + file_name_length >= reinterpret_cast<const char *>(eocd) ||
+        file_name_length == 0)
+      return false;
+
+    // Compare the file name.
+    if (file_path == llvm::StringRef(file_name, file_name_length)) {
+      // Found the file.
+      return GetFile(zip_data, cd->local_file_header_offset, file_offset,
+                     file_size);
+    } else {
+      // Skip to the next central directory record.
+      cd = reinterpret_cast<const CdRecord *>(
+          reinterpret_cast<const char *>(cd) + sizeof(CdRecord) +
+          cd->file_name_length + cd->extra_field_length + cd->comment_length);
+      // Sanity check the pointer.
+      if (reinterpret_cast<const char *>(cd) >=
+          reinterpret_cast<const char *>(eocd))
+        return false;
+    }
+  }
+
+  return false;
+}
+
+} // end anonymous namespace
+
+bool ZipFile::Find(lldb::DataBufferSP zip_data, const llvm::StringRef file_path,
+                   lldb::offset_t &file_offset, lldb::offset_t &file_size) {
+  const EocdRecord *eocd = FindEocdRecord(zip_data);
+  if (!eocd)
+    return false;
+
+  return FindFile(zip_data, eocd, file_path, file_offset, file_size);
+}

lldb/unittests/Host/CMakeLists.txt

add_lldb_unittest(HostTests
   LINK_LIBS
     lldbHost
     lldbCore
     lldbUtilityHelpers
     lldbHostHelpers
     LLVMTestingSupport
     LLVMTargetParser
   )
+
+add_subdirectory(common)

lldb/unittests/Host/common/CMakeLists.txt

+set (FILES
+  ZipFileResolverTest.cpp
+)
+
+add_lldb_unittest(HostCommonTests
+  ${FILES}
+  LINK_LIBS
+    lldbHost
+    lldbUtilityHelpers
+  )
+
+set(test_inputs
+  zip-test.zip
+  )
+add_unittest_inputs(HostCommonTests "${test_inputs}")

lldb/unittests/Host/common/ZipFileResolverTest.cpp

+//===-- ZipFileResolverTest.cpp -------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/common/ZipFileResolver.h"
+#include "TestingSupport/SubsystemRAII.h"
+#include "TestingSupport/TestUtilities.h"
+#include "gtest/gtest.h"
+
+using namespace lldb_private;
+using namespace llvm;
+
+namespace {
+class ZipFileResolverTest : public ::testing::Test {
+  SubsystemRAII<FileSystem> subsystems;
+};
+
+std::string TestZipPath() {
+  FileSpec zip_spec(GetInputFilePath("zip-test.zip"));
+  FileSystem::Instance().Resolve(zip_spec);
+  return zip_spec.GetPath();
+}
+} // namespace
+
+TEST_F(ZipFileResolverTest, ResolveSharedLibraryPathWithNormalFile) {
+  const FileSpec file_spec("/system/lib64/libtest.so");
+
+  ZipFileResolver::FileKind file_kind;
+  std::string file_path;
+  lldb::offset_t file_offset;
+  lldb::offset_t file_size;
+  ASSERT_TRUE(ZipFileResolver::ResolveSharedLibraryPath(
+      file_spec, file_kind, file_path, file_offset, file_size));
+
+  EXPECT_EQ(file_kind, ZipFileResolver::FileKind::eFileKindNormal);
+  EXPECT_EQ(file_path, file_spec.GetPath());
+  EXPECT_EQ(file_offset, 0UL);
+  EXPECT_EQ(file_size, 0UL);
+}
+
+TEST_F(ZipFileResolverTest, ResolveSharedLibraryPathWithZipMissing) {
+  const std::string zip_path = TestZipPath();
+  const FileSpec file_spec(zip_path + "!/lib/arm64-v8a/libmissing.so");
+
+  ZipFileResolver::FileKind file_kind;
+  std::string file_path;
+  lldb::offset_t file_offset;
+  lldb::offset_t file_size;
+  ASSERT_FALSE(ZipFileResolver::ResolveSharedLibraryPath(
+      file_spec, file_kind, file_path, file_offset, file_size));
+}
+
+TEST_F(ZipFileResolverTest, ResolveSharedLibraryPathWithZipExisting) {
+  const std::string zip_path = TestZipPath();
+  const FileSpec file_spec(zip_path + "!/lib/arm64-v8a/libzip-test.so");
+
+  ZipFileResolver::FileKind file_kind;
+  std::string file_path;
+  lldb::offset_t file_offset;
+  lldb::offset_t file_size;
+  ASSERT_TRUE(ZipFileResolver::ResolveSharedLibraryPath(
+      file_spec, file_kind, file_path, file_offset, file_size));
+
+  EXPECT_EQ(file_kind, ZipFileResolver::FileKind::eFileKindZip);
+  EXPECT_EQ(file_path, zip_path);
+  EXPECT_EQ(file_offset, 4096UL);
+  EXPECT_EQ(file_size, 3600UL);
+}