[lldb] Add support to load object files from thin archives

[PRESIDENT810]

Summary

This fixes https://github.com/llvm/llvm-project/issues/50114 where lldb/mac can't load object files from thin archives.
This patch allows lldb to identify thin archives, and load object files contained in them.

I'm a novice at llvm and I'm not sure whether I'm fixing this right, so please tell me if anything wrong with this fix, thank you guys!

[clayborg]

A few things to fix but nothing serious. Nice patch! We also need a test for this. I would add a test to lldb/test/API/functionalities/archives/TestBSDArchives.py

lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

279–280

304

No need to make a copy of this data, just make a string ref to it:

309

431

Add "archive_type" as a constructor argument for ObjectContainerBSDArchive instead of setting this afterward.

455

This shouldn't be needed right? If we already had the container cached, it should have the archive type set correctly already.

466–468

Now that we are checking two things, we can clean up this code with an early return if "armag" is null:

478–480

[PRESIDENT810]

I have refactored my code so it should looks cleaner now, but I'm not sure how to add a test. It seems that adding a test for thin archive on macOS platforms can be not so straightforward. I see that in lldb/test/API/functionalities/archives/Makefile, the test suite is using libtool instead of ar to create archives on macOS platforms, and I don't know whether I can produce a thin archive with that. Also, ld on macOS platforms seems to be unable to identify thin archives (I'm using ld64.lld when testing my code locally).

I would really appreciate it if someone can provide some advice about how to implement such a test case here, thank you!

[clayborg]

In D126464#3545142, @PRESIDENT810 wrote:

I have refactored my code so it should looks cleaner now, but I'm not sure how to add a test. It seems that adding a test for thin archive on macOS platforms can be not so straightforward. I see that in lldb/test/API/functionalities/archives/Makefile, the test suite is using libtool instead of ar to create archives on macOS platforms, and I don't know whether I can produce a thin archive with that. Also, ld on macOS platforms seems to be unable to identify thin archives (I'm using ld64.lld when testing my code locally).

I would really appreciate it if someone can provide some advice about how to implement such a test case here, thank you!

Does LLVM have the ability to generate a "llvm-ar" tool that can do the packaging? If so, an easy test would be to create a thin archive and then run the following API from within python:

static SBModuleSpecList SBModuleSpecList::GetModuleSpecifications(const char *path);

If you run this API on a thin archive without your modifications, then you will probably get an empty SBModuleSpecList object. So the flow would be:

• make sure "llvm-ar" is built if it already isn't with the "check-lldb" target (might need to add it as a depedency
• use the build "llvm-ar" to make an archive that points to two .o files that you build from sources
• then run some python in your test case like:

# Make the Makefile that uses the built "llvm-ar"  one two source files that have .o created for them, and then it runs "llvm-ar" and will produce the "thin.a" in the output directory

# This line will point to the "thin.a" that was just built
archive_path = self.getBuildArtifact("thin.a")

# Get the module specs from the thin archive
module_specs = lldb.SBModuleSpecList.GetModuleSpecifications(archive_path)
num_specs = module_specs.GetSize()
self.assertEqual(num_specs, 2)

# For extra credit you can verify that you get the right file path from each file spec
obj_path_1 = self.getBuildArtifact("foo.o")
obj_path_2 = self.getBuildArtifact("bar.o")
self.assertEqual(module_specs.GetSpecAtIndex(0).GetObjectName(), obj_path_1)
self.assertEqual(module_specs.GetSpecAtIndex(1).GetObjectName(), obj_path_2)

[PRESIDENT810]

Add tests by introducing llvm-ar to produce thin archives

[PRESIDENT810]

ping

[clayborg]

Sorry for the delay, looks good with the test

[PRESIDENT810]

Hi, sorry to interrupt but I just forgot to mention that I didn't have access to commit. Anyone can please help me land this one if it looks ok?

[PRESIDENT810]

ping

[thakis]

What --author flag should I use for you when landing this?

[PRESIDENT810]

In D126464#3628819, @thakis wrote:

What --author flag should I use for you when landing this?

Hi! Could you please use --author="Kaining Zhong <[e-mail]>"? Thanks!

[thakis]

Done.

Thanks for the fix! :)

lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h

 #define LLDB_SOURCE_PLUGINS_OBJECTCONTAINER_BSD_ARCHIVE_OBJECTCONTAINERBSDARCHIVE_H
 
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Symbol/ObjectContainer.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 
+#include "llvm/Object/Archive.h"
 #include "llvm/Support/Chrono.h"
+#include "llvm/Support/Path.h"
 
 #include <map>
 #include <memory>
 #include <mutex>
 
+enum class ArchiveType { Invalid, Archive, ThinArchive };
+
 class ObjectContainerBSDArchive : public lldb_private::ObjectContainer {
 public:
   ObjectContainerBSDArchive(const lldb::ModuleSP &module_sp,
                             lldb::DataBufferSP &data_sp,
                             lldb::offset_t data_offset,
                             const lldb_private::FileSpec *file,
-                            lldb::offset_t offset, lldb::offset_t length);
+                            lldb::offset_t offset, lldb::offset_t length,
+                            ArchiveType archive_type);
 
   ~ObjectContainerBSDArchive() override;
 
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
public:
 
   static size_t GetModuleSpecifications(const lldb_private::FileSpec &file,
                                         lldb::DataBufferSP &data_sp,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
                                         lldb_private::ModuleSpecList &specs);
 
-  static bool MagicBytesMatch(const lldb_private::DataExtractor &data);
+  static ArchiveType MagicBytesMatch(const lldb_private::DataExtractor &data);
 
   // Member Functions
   bool ParseHeader() override;
 
   size_t GetNumObjects() const override {
     if (m_archive_sp)
       return m_archive_sp->GetNumObjects();
     return 0;
   }
 
   void Dump(lldb_private::Stream *s) const override;
 
   lldb::ObjectFileSP GetObjectFile(const lldb_private::FileSpec *file) override;
 
   // PluginInterface protocol
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
 protected:
   struct Object {
     Object();
 
     void Clear();
 
+    lldb::offset_t ExtractFromThin(const lldb_private::DataExtractor &data,
+                                   lldb::offset_t offset,
+                                   llvm::StringRef stringTable);
+
     lldb::offset_t Extract(const lldb_private::DataExtractor &data,
                            lldb::offset_t offset);
     /// Object name in the archive.
     lldb_private::ConstString ar_name;
 
     /// Object modification time in the archive.
     uint32_t modification_time = 0;
 
protected:
 
   class Archive {
   public:
     typedef std::shared_ptr<Archive> shared_ptr;
     typedef std::multimap<lldb_private::FileSpec, shared_ptr> Map;
 
     Archive(const lldb_private::ArchSpec &arch,
             const llvm::sys::TimePoint<> &mod_time, lldb::offset_t file_offset,
-            lldb_private::DataExtractor &data);
+            lldb_private::DataExtractor &data, ArchiveType archive_type);
 
     ~Archive();
 
     static Map &GetArchiveCache();
 
     static std::recursive_mutex &GetArchiveCacheMutex();
 
     static Archive::shared_ptr FindCachedArchive(
         const lldb_private::FileSpec &file, const lldb_private::ArchSpec &arch,
         const llvm::sys::TimePoint<> &mod_time, lldb::offset_t file_offset);
 
     static Archive::shared_ptr ParseAndCacheArchiveForFile(
         const lldb_private::FileSpec &file, const lldb_private::ArchSpec &arch,
         const llvm::sys::TimePoint<> &mod_time, lldb::offset_t file_offset,
-        lldb_private::DataExtractor &data);
+        lldb_private::DataExtractor &data, ArchiveType archive_type);
 
     size_t GetNumObjects() const { return m_objects.size(); }
 
     const Object *GetObjectAtIndex(size_t idx) {
       if (idx < m_objects.size())
         return &m_objects[idx];
       return nullptr;
     }
public:
     const lldb_private::ArchSpec &GetArchitecture() const { return m_arch; }
 
     void SetArchitecture(const lldb_private::ArchSpec &arch) { m_arch = arch; }
 
     bool HasNoExternalReferences() const;
 
     lldb_private::DataExtractor &GetData() { return m_data; }
 
+    ArchiveType GetArchiveType() { return m_archive_type; }
+
   protected:
     typedef lldb_private::UniqueCStringMap<uint32_t> ObjectNameToIndexMap;
     // Member Variables
     lldb_private::ArchSpec m_arch;
     llvm::sys::TimePoint<> m_modification_time;
     lldb::offset_t m_file_offset;
     std::vector<Object> m_objects;
     ObjectNameToIndexMap m_object_name_to_index_map;
     lldb_private::DataExtractor m_data; ///< The data for this object container
                                         ///so we don't lose data if the .a files
                                         ///gets modified
+    ArchiveType m_archive_type;
   };
 
   void SetArchive(Archive::shared_ptr &archive_sp);
 
   Archive::shared_ptr m_archive_sp;
+
+  ArchiveType m_archive_type;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_OBJECTCONTAINER_BSD_ARCHIVE_OBJECTCONTAINERBSDARCHIVE_H

lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+using namespace llvm::object;
+
 LLDB_PLUGIN_DEFINE(ObjectContainerBSDArchive)
 
 ObjectContainerBSDArchive::Object::Object() : ar_name() {}
 
 void ObjectContainerBSDArchive::Object::Clear() {
   ar_name.Clear();
   modification_time = 0;
   uid = 0;
   gid = 0;
   mode = 0;
   size = 0;
   file_offset = 0;
   file_size = 0;
 }
 
+lldb::offset_t ObjectContainerBSDArchive::Object::ExtractFromThin(
+    const DataExtractor &data, lldb::offset_t offset,
+    llvm::StringRef stringTable) {
+  size_t ar_name_len = 0;
+  std::string str;
+  char *err;
+
+  // File header
+  //
+  // The common format is as follows.
+  //
+  //  Offset  Length  Name            Format
+  //  0       16      File name       ASCII right padded with spaces (no spaces
+  //  allowed in file name)
+  //  16      12      File mod        Decimal as cstring right padded with
+  //  spaces
+  //  28      6       Owner ID        Decimal as cstring right padded with
+  //  spaces
+  //  34      6       Group ID        Decimal as cstring right padded with
+  //  spaces
+  //  40      8       File mode       Octal   as cstring right padded with
+  //  spaces
+  //  48      10      File byte size  Decimal as cstring right padded with
+  //  spaces
+  //  58      2       File magic      0x60 0x0A
+
+  // Make sure there is enough data for the file header and bail if not
+  if (!data.ValidOffsetForDataOfSize(offset, 60))
+    return LLDB_INVALID_OFFSET;
+
+  str.assign((const char *)data.GetData(&offset, 16), 16);
+  if (!(llvm::StringRef(str).startswith("//") || stringTable.empty())) {
+    // Strip off any trailing spaces.
+    const size_t last_pos = str.find_last_not_of(' ');
+    if (last_pos != std::string::npos) {
+      if (last_pos + 1 < 16)
+        str.erase(last_pos + 1);
+    }
+    int start = strtoul(str.c_str() + 1, &err, 10);
+    int end = stringTable.find('\n', start);
+    str.assign(stringTable.data() + start, end - start - 1);
+    ar_name.SetCString(str.c_str());
+  }
+
+  str.assign((const char *)data.GetData(&offset, 12), 12);
+  modification_time = strtoul(str.c_str(), &err, 10);
+
+  str.assign((const char *)data.GetData(&offset, 6), 6);
+  uid = strtoul(str.c_str(), &err, 10);
+
+  str.assign((const char *)data.GetData(&offset, 6), 6);
+  gid = strtoul(str.c_str(), &err, 10);
+
+  str.assign((const char *)data.GetData(&offset, 8), 8);
+  mode = strtoul(str.c_str(), &err, 8);
+
+  str.assign((const char *)data.GetData(&offset, 10), 10);
+  size = strtoul(str.c_str(), &err, 10);
+
+  str.assign((const char *)data.GetData(&offset, 2), 2);
+  if (str == ARFMAG) {
+    file_offset = offset;
+    file_size = size - ar_name_len;
+    return offset;
+  }
+  return LLDB_INVALID_OFFSET;
+}
+
 lldb::offset_t
 ObjectContainerBSDArchive::Object::Extract(const DataExtractor &data,
                                            lldb::offset_t offset) {
   size_t ar_name_len = 0;
   std::string str;
   char *err;
 
   // File header
if (str == ARFMAG) {
     return offset;
   }
   return LLDB_INVALID_OFFSET;
 }
 
 ObjectContainerBSDArchive::Archive::Archive(const lldb_private::ArchSpec &arch,
                                             const llvm::sys::TimePoint<> &time,
                                             lldb::offset_t file_offset,
-                                            lldb_private::DataExtractor &data)
+                                            lldb_private::DataExtractor &data,
+                                            ArchiveType archive_type)
     : m_arch(arch), m_modification_time(time), m_file_offset(file_offset),
-      m_objects(), m_data(data) {}
+      m_objects(), m_data(data), m_archive_type(archive_type) {}
 
 ObjectContainerBSDArchive::Archive::~Archive() = default;
 
 size_t ObjectContainerBSDArchive::Archive::ParseObjects() {
   DataExtractor &data = m_data;
   std::string str;
   lldb::offset_t offset = 0;
   str.assign((const char *)data.GetData(&offset, SARMAG), SARMAG);
   if (str == ARMAG) {
     Object obj;
     do {
       offset = obj.Extract(data, offset);
       if (offset == LLDB_INVALID_OFFSET)
         break;
       size_t obj_idx = m_objects.size();
       m_objects.push_back(obj);
       // Insert all of the C strings out of order for now...
       m_object_name_to_index_map.Append(obj.ar_name, obj_idx);
       offset += obj.file_size;
       obj.Clear();
     } while (data.ValidOffset(offset));
 
     // Now sort all of the object name pointers
     m_object_name_to_index_map.Sort();
+  } else if (str == ThinArchiveMagic) {
+    Object obj;
+    size_t obj_idx;
+
+    // Retrieve symbol table
+    offset = obj.ExtractFromThin(data, offset, "");
+    if (offset == LLDB_INVALID_OFFSET)
+      return m_objects.size();
+    obj_idx = m_objects.size();
+    m_objects.push_back(obj);
+    // Insert all of the C strings out of order for now...
+    m_object_name_to_index_map.Append(obj.ar_name, obj_idx);
+    offset += obj.file_size;
+    obj.Clear();
+
+    // Retrieve string table
+    offset = obj.ExtractFromThin(data, offset, "");
+    if (offset == LLDB_INVALID_OFFSET)
+      return m_objects.size();
+    obj_idx = m_objects.size();
+    m_objects.push_back(obj);
+    // Insert all of the C strings out of order for now...
+    m_object_name_to_index_map.Append(obj.ar_name, obj_idx);
+    // Extract string table
+    llvm::StringRef strtab((const char *)data.GetData(&offset, obj.size),
+                           obj.size);
+    obj.Clear();
+
+    // Retrieve object files
+    do {
+      offset = obj.ExtractFromThin(data, offset, strtab);
+      if (offset == LLDB_INVALID_OFFSET)
+        break;
+      obj_idx = m_objects.size();
+      m_objects.push_back(obj);
+      // Insert all of the C strings out of order for now...
+      m_object_name_to_index_map.Append(obj.ar_name, obj_idx);
+      obj.Clear();
+    } while (data.ValidOffset(offset));
+
+    // Now sort all of the object name pointers
+    m_object_name_to_index_map.Sort();
   }
   return m_objects.size();
 }
 
 ObjectContainerBSDArchive::Object *
 ObjectContainerBSDArchive::Archive::FindObject(
     ConstString object_name, const llvm::sys::TimePoint<> &object_mod_time) {
   const ObjectNameToIndexMap::Entry *match =
       m_object_name_to_index_map.FindFirstValueForName(object_name);
   if (!match)
     return nullptr;
   if (object_mod_time == llvm::sys::TimePoint<>())
     return &m_objects[match->value];
 
   const uint64_t object_modification_date = llvm::sys::toTimeT(object_mod_time);
   if (m_objects[match->value].modification_time == object_modification_date)
     return &m_objects[match->value];
 
   const ObjectNameToIndexMap::Entry *next_match =
       m_object_name_to_index_map.FindNextValueForName(match);
   while (next_match) {
     if (m_objects[next_match->value].modification_time ==
         object_modification_date)
       return &m_objects[next_match->value];
     next_match = m_object_name_to_index_map.FindNextValueForName(next_match);
   }
 
   return nullptr;
 }
 
 ObjectContainerBSDArchive::Archive::shared_ptr
 ObjectContainerBSDArchive::Archive::FindCachedArchive(
     const FileSpec &file, const ArchSpec &arch,
     const llvm::sys::TimePoint<> &time, lldb::offset_t file_offset) {
   std::lock_guard<std::recursive_mutex> guard(Archive::GetArchiveCacheMutex());
   shared_ptr archive_sp;
   Archive::Map &archive_map = Archive::GetArchiveCache();
   Archive::Map::iterator pos = archive_map.find(file);
   // Don't cache a value for "archive_map.end()" below since we might delete an
ObjectContainerBSDArchive::Archive::FindCachedArchive(
   }
   return archive_sp;
 }
 
 ObjectContainerBSDArchive::Archive::shared_ptr
 ObjectContainerBSDArchive::Archive::ParseAndCacheArchiveForFile(
     const FileSpec &file, const ArchSpec &arch,
     const llvm::sys::TimePoint<> &time, lldb::offset_t file_offset,
-    DataExtractor &data) {
-  shared_ptr archive_sp(new Archive(arch, time, file_offset, data));
+    DataExtractor &data, ArchiveType archive_type) {
+  shared_ptr archive_sp(
+      new Archive(arch, time, file_offset, data, archive_type));
   if (archive_sp) {
     const size_t num_objects = archive_sp->ParseObjects();
     if (num_objects > 0) {
       std::lock_guard<std::recursive_mutex> guard(
           Archive::GetArchiveCacheMutex());
       Archive::GetArchiveCache().insert(std::make_pair(file, archive_sp));
     } else {
       archive_sp.reset();
if (!object_name)
     return nullptr;
 
   if (data_sp) {
     // We have data, which means this is the first 512 bytes of the file Check
     // to see if the magic bytes match and if they do, read the entire table of
     // contents for the archive and cache it
     DataExtractor data;
     data.SetData(data_sp, data_offset, length);
-    if (file && data_sp && ObjectContainerBSDArchive::MagicBytesMatch(data)) {
+    ArchiveType archive_type = ObjectContainerBSDArchive::MagicBytesMatch(data);
+    if (file && data_sp && archive_type != ArchiveType::Invalid) {
       LLDB_SCOPED_TIMERF(
           "ObjectContainerBSDArchive::CreateInstance (module = %s, file = "
           "%p, file_offset = 0x%8.8" PRIx64 ", file_size = 0x%8.8" PRIx64 ")",
           module_sp->GetFileSpec().GetPath().c_str(),
           static_cast<const void *>(file), static_cast<uint64_t>(file_offset),
           static_cast<uint64_t>(length));
 
       // Map the entire .a file to be sure that we don't lose any data if the
       // file gets updated by a new build while this .a file is being used for
       // debugging
       DataBufferSP archive_data_sp =
           FileSystem::Instance().CreateDataBuffer(*file, length, file_offset);
       if (!archive_data_sp)
         return nullptr;
 
       lldb::offset_t archive_data_offset = 0;
 
       Archive::shared_ptr archive_sp(Archive::FindCachedArchive(
           *file, module_sp->GetArchitecture(), module_sp->GetModificationTime(),
           file_offset));
       std::unique_ptr<ObjectContainerBSDArchive> container_up(
           new ObjectContainerBSDArchive(module_sp, archive_data_sp,
                                         archive_data_offset, file, file_offset,
-                                        length));
+                                        length, archive_type));
 
       if (container_up) {
         if (archive_sp) {
           // We already have this archive in our cache, use it
           container_up->SetArchive(archive_sp);
           return container_up.release();
         } else if (container_up->ParseHeader())
           return container_up.release();
       }
     }
   } else {
     // No data, just check for a cached archive
     Archive::shared_ptr archive_sp(Archive::FindCachedArchive(
         *file, module_sp->GetArchitecture(), module_sp->GetModificationTime(),
         file_offset));
     if (archive_sp) {
       std::unique_ptr<ObjectContainerBSDArchive> container_up(
           new ObjectContainerBSDArchive(module_sp, data_sp, data_offset, file,
-                                        file_offset, length));
+                                        file_offset, length,
+                                        archive_sp->GetArchiveType()));
 
       if (container_up) {
         // We already have this archive in our cache, use it
         container_up->SetArchive(archive_sp);
         return container_up.release();
       }
     }
   }
   return nullptr;
 }
 
-bool ObjectContainerBSDArchive::MagicBytesMatch(const DataExtractor &data) {
+ArchiveType
+ObjectContainerBSDArchive::MagicBytesMatch(const DataExtractor &data) {
   uint32_t offset = 0;
   const char *armag = (const char *)data.PeekData(offset, sizeof(ar_hdr));
-  if (armag && ::strncmp(armag, ARMAG, SARMAG) == 0) {
+  if (armag == nullptr)
+    return ArchiveType::Invalid;
+  if (::strncmp(armag, ARMAG, SARMAG) == 0) {
     armag += offsetof(struct ar_hdr, ar_fmag) + SARMAG;
     if (strncmp(armag, ARFMAG, 2) == 0)
-      return true;
+      return ArchiveType::Archive;
+  } else if (::strncmp(armag, ThinArchiveMagic, strlen(ThinArchiveMagic)) ==
+             0) {
+    armag += offsetof(struct ar_hdr, ar_fmag) + strlen(ThinArchiveMagic);
+    if (strncmp(armag, ARFMAG, 2) == 0) {
+      return ArchiveType::ThinArchive;
+    }
   }
-  return false;
+  return ArchiveType::Invalid;
 }
 
 ObjectContainerBSDArchive::ObjectContainerBSDArchive(
     const lldb::ModuleSP &module_sp, DataBufferSP &data_sp,
     lldb::offset_t data_offset, const lldb_private::FileSpec *file,
-    lldb::offset_t file_offset, lldb::offset_t size)
+    lldb::offset_t file_offset, lldb::offset_t size, ArchiveType archive_type)
     : ObjectContainer(module_sp, file, file_offset, size, data_sp, data_offset),
-      m_archive_sp() {}
+      m_archive_sp() {
+  m_archive_type = archive_type;
+}
+
 void ObjectContainerBSDArchive::SetArchive(Archive::shared_ptr &archive_sp) {
   m_archive_sp = archive_sp;
 }
 
 ObjectContainerBSDArchive::~ObjectContainerBSDArchive() = default;
 
 bool ObjectContainerBSDArchive::ParseHeader() {
   if (m_archive_sp.get() == nullptr) {
     if (m_data.GetByteSize() > 0) {
       ModuleSP module_sp(GetModule());
       if (module_sp) {
         m_archive_sp = Archive::ParseAndCacheArchiveForFile(
             m_file, module_sp->GetArchitecture(),
-            module_sp->GetModificationTime(), m_offset, m_data);
+            module_sp->GetModificationTime(), m_offset, m_data, m_archive_type);
       }
       // Clear the m_data that contains the entire archive data and let our
       // m_archive_sp hold onto the data.
       m_data.Clear();
     }
   }
   return m_archive_sp.get() != nullptr;
 }
void ObjectContainerBSDArchive::Dump(Stream *s) const {
   for (i = 0; i < num_objects; i++) {
     s->Indent();
     s->Printf("object[%u] = %s\n", i, GetObjectNameAtIndex(i));
   }
   s->IndentLess();
   s->EOL();
 }
 
+FileSpec GetChildFileSpecificationsFromThin(llvm::StringRef childPath,
+                                            const FileSpec &parentFileSpec) {
+  llvm::SmallString<128> FullPath;
+  if (llvm::sys::path::is_absolute(childPath)) {
+    FullPath = childPath;
+  } else {
+    FullPath = parentFileSpec.GetDirectory().GetStringRef();
+    llvm::sys::path::append(FullPath, childPath);
+  }
+  FileSpec child = FileSpec(FullPath.str(), llvm::sys::path::Style::posix);
+  return child;
+}
+
 ObjectFileSP ObjectContainerBSDArchive::GetObjectFile(const FileSpec *file) {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     if (module_sp->GetObjectName() && m_archive_sp) {
       Object *object = m_archive_sp->FindObject(
           module_sp->GetObjectName(), module_sp->GetObjectModificationTime());
       if (object) {
+        if (m_archive_type == ArchiveType::ThinArchive) {
+          // Set file to child object file
+          FileSpec child = GetChildFileSpecificationsFromThin(
+              object->ar_name.GetStringRef(), m_file);
+          lldb::offset_t file_offset = 0;
+          lldb::offset_t file_size = object->size;
+          std::shared_ptr<DataBuffer> child_data_sp =
+              FileSystem::Instance().CreateDataBuffer(child, file_size,
+                                                      file_offset);
+          if (child_data_sp->GetByteSize() != object->file_size)
+            return ObjectFileSP();
+          lldb::offset_t data_offset = 0;
+          return ObjectFile::FindPlugin(
+              module_sp, &child, m_offset + object->file_offset,
+              object->file_size, child_data_sp, data_offset);
+        }
         lldb::offset_t data_offset = object->file_offset;
         return ObjectFile::FindPlugin(
             module_sp, file, m_offset + object->file_offset, object->file_size,
             m_archive_sp->GetData().GetSharedDataBuffer(), data_offset);
       }
     }
   }
   return ObjectFileSP();
 }
 
 size_t ObjectContainerBSDArchive::GetModuleSpecifications(
     const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
     lldb::offset_t data_offset, lldb::offset_t file_offset,
     lldb::offset_t file_size, lldb_private::ModuleSpecList &specs) {
 
   // We have data, which means this is the first 512 bytes of the file Check to
   // see if the magic bytes match and if they do, read the entire table of
   // contents for the archive and cache it
   DataExtractor data;
   data.SetData(data_sp, data_offset, data_sp->GetByteSize());
-  if (!file || !data_sp || !ObjectContainerBSDArchive::MagicBytesMatch(data))
+  ArchiveType archive_type = ObjectContainerBSDArchive::MagicBytesMatch(data);
+  if (!file || !data_sp || archive_type == ArchiveType::Invalid)
     return 0;
 
   const size_t initial_count = specs.GetSize();
   llvm::sys::TimePoint<> file_mod_time = FileSystem::Instance().GetModificationTime(file);
   Archive::shared_ptr archive_sp(
       Archive::FindCachedArchive(file, ArchSpec(), file_mod_time, file_offset));
   bool set_archive_arch = false;
   if (!archive_sp) {
     set_archive_arch = true;
     data_sp =
         FileSystem::Instance().CreateDataBuffer(file, file_size, file_offset);
     if (data_sp) {
       data.SetData(data_sp, 0, data_sp->GetByteSize());
       archive_sp = Archive::ParseAndCacheArchiveForFile(
-          file, ArchSpec(), file_mod_time, file_offset, data);
+          file, ArchSpec(), file_mod_time, file_offset, data, archive_type);
     }
   }
 
   if (archive_sp) {
     const size_t num_objects = archive_sp->GetNumObjects();
     for (size_t idx = 0; idx < num_objects; ++idx) {
       const Object *object = archive_sp->GetObjectAtIndex(idx);
       if (object) {
+        if (archive_sp->GetArchiveType() == ArchiveType::ThinArchive) {
+          if (object->ar_name.IsEmpty())
+            continue;
+          FileSpec child = GetChildFileSpecificationsFromThin(
+              object->ar_name.GetStringRef(), file);
+          if (ObjectFile::GetModuleSpecifications(child, 0, object->file_size,
+                                                  specs)) {
+            ModuleSpec &spec =
+                specs.GetModuleSpecRefAtIndex(specs.GetSize() - 1);
+            llvm::sys::TimePoint<> object_mod_time(
+                std::chrono::seconds(object->modification_time));
+            spec.GetObjectName() = object->ar_name;
+            spec.SetObjectOffset(0);
+            spec.SetObjectSize(object->file_size);
+            spec.GetObjectModificationTime() = object_mod_time;
+          }
+          continue;
+        }
         const lldb::offset_t object_file_offset =
             file_offset + object->file_offset;
         if (object->file_offset < file_size && file_size > object_file_offset) {
           if (ObjectFile::GetModuleSpecifications(
                   file, object_file_offset, file_size - object_file_offset,
                   specs)) {
             ModuleSpec &spec =
                 specs.GetModuleSpecRefAtIndex(specs.GetSize() - 1);

lldb/test/API/functionalities/archives/Makefile

-C_SOURCES := main.c a.c b.c
+C_SOURCES := main.c a.c b.c c.c
 EXE :=  # Define a.out explicitly
 MAKE_DSYM := NO
 
-all: a.out
+all: a.out libbar.a
 
 a.out: main.o libfoo.a
   $(LD) $(LDFLAGS) $^ -o $@
 
 libfoo.a: a.o b.o
   $(AR) $(ARFLAGS) $@ $^
   $(RM) $^
 
+# This tests whether lldb can load a thin archive
+libbar.a: c.o
+  $(eval LLVM_AR := $(LLVM_TOOLS_DIR)/llvm-ar)
+  $(eval LLVM_ARFLAGS := -rcsDT)
+  $(LLVM_AR) $(LLVM_ARFLAGS) $@ $^
+  # Note for thin archive case, we cannot remove c.o
+
 include Makefile.rules

lldb/test/API/functionalities/archives/TestBSDArchives.py

def test(self):
         # Continue the program, we should break at b(int) next.
         self.runCmd("continue")
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
         self.expect("frame variable", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['(int) arg = 2'])
         self.expect_var_path("__b_global", type="int", value="2")
+
+        # Test loading thin archives
+        archive_path = self.getBuildArtifact("libbar.a")
+        module_specs = lldb.SBModuleSpecList.GetModuleSpecifications(archive_path)
+        num_specs = module_specs.GetSize()
+        self.assertEqual(num_specs, 1)
+        self.assertEqual(module_specs.GetSpecAtIndex(0).GetObjectName(), "c.o")

lldb/test/API/functionalities/archives/c.c

+static int __c_global = 3;
+
+int c(int arg) {
+  int result = arg + __c_global;
+  return result;
+}
+
+int cc(int arg1) {
+  int result3 = arg1 - __c_global;
+  return result3;
+}

lldb/test/API/lit.cfg.py

 
 if is_configured('dotest_args_str'):
   dotest_cmd.extend(config.dotest_args_str.split(';'))
 
 # Library path may be needed to locate just-built clang.
 if is_configured('llvm_libs_dir'):
   dotest_cmd += ['--env', 'LLVM_LIBS_DIR=' + config.llvm_libs_dir]
 
+# This path may be needed to locate required llvm tools
+if is_configured('llvm_tools_dir'):
+  dotest_cmd += ['--env', 'LLVM_TOOLS_DIR=' + config.llvm_tools_dir]
+
 # Forward ASan-specific environment variables to tests, as a test may load an
 # ASan-ified dylib.
 for env_var in ('ASAN_OPTIONS', 'DYLD_INSERT_LIBRARIES'):
   if env_var in config.environment:
     dotest_cmd += ['--inferior-env', env_var + '=' + config.environment[env_var]]
 
 if is_configured('test_arch'):
   dotest_cmd += ['--arch', config.test_arch]

lldb/test/CMakeLists.txt

add_lldb_test_dependency(
   llvm-config
   llvm-dwarfdump
   llvm-dwp
   llvm-nm
   llvm-mc
   llvm-objcopy
   llvm-pdbutil
   llvm-readobj
+  llvm-ar
   )
 
 if(TARGET lld)
   add_lldb_test_dependency(lld)
 else()
   # LLD is required to link test executables on Windows.
   if (CMAKE_SYSTEM_NAME MATCHES "Windows")
     message(WARNING "lld required to test LLDB on Windows")