[lldb/gdb-remote] Add support for the qOffsets packet

[labath]

Summary

This packet is necessary to make lldb work with the remote-gdb stub in
user mode qemu when running position-independent binaries. It reports
the relative position (load bias) of the loaded executable wrt. the
addresses in the file itself.

Lldb needs to know this information in order to correctly set the load
address of the executable. Normally, lldb would be able to find this out
on its own by following the breadcrumbs in the process auxiliary vector,
but we can't do this here because qemu does not support the
qXfer:auxv:read packet.

This patch does not implement full scope of the qOffsets packet (which
supports having different biases for code, data and bss sections). This
is because the relevant lldb interfaces (e.g., Module::SetLoadAddress)
do not support passing different values for different sections, and it's
not clear how would such a thing apply to typicall object files. And
qemu will always
(https://github.com/qemu/qemu/blob/master/linux-user/elfload.c#L2436)
return the same value for code and data offsets. In fact, even gdb
ignores the offset for the bss sections, and uses the "data" offset
instead. So, until the we need more of this packet, I think it's best
to stick to the simplest solution possible. This patch simply rejects
replies with non-uniform offsets.

[clayborg]

This patch does not implement full scope of the qOffsets packet (which supports having different biases for code, data and bss sections). This is because the relevant lldb interfaces (e.g., Module::SetLoadAddress) do not support passing different values for different sections, and it's not clear how would such a thing apply to typical object files.

While Module::SetLoadAddress doesn't, the Target interfaces do in fact support this fully. You specify the section and the section load address. Look at the macOS dynamic loader, it does this. All shared libraries in the macOS dyld shared cache have all the the TEXT segments put next to each other so that the OS can load one large read + execute mapping, all the modifiable data sections in DATA are relocated as well along with other segments. The Module::SetLoadAddress() interface was put in Module to make it easy to slide full binaries.

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

3559

Too a bit to understand what this was doing. Might be worth a comment here or in the header that says something like:

We only handle offsets where all sections in a file are offset by the same amount. If any sections is slid by a different amount, we return no value.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

444

Might be nice to document that we only handle when a binary has all its sections slid by the same amount somewhere.

445

It would be nice to have two functions here:
1 - "llvm::SmallVector<llvm::StringRef> GetQOffsets();" which will return raw qOffsets calls results
2 - "llvm::Optional<lldb::addr_t> GetExecutableOffset();" which calls above function and then does it thing where it tries to get a single rigid slide for the entire executable binary or fails.

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

1116

We could fall back eventually to try and parse the full results of qOffsets directly here and try to slide. Doesn't need to be done now, but a TODO comment might be nice.

[labath]

Add some comments and documentation.

[labath]

Thanks for the quick response, and sorry it took me a while to get back to this.

In D74598#1877316, @clayborg wrote:

While Module::SetLoadAddress doesn't, the Target interfaces do in fact support this fully. You specify the section and the section load address. Look at the macOS dynamic loader, it does this. All shared libraries in the macOS dyld shared cache have all the the TEXT segments put next to each other so that the OS can load one large read + execute mapping, all the modifiable data sections in DATA are relocated as well along with other segments. The Module::SetLoadAddress() interface was put in Module to make it easy to slide full binaries.

Ah, thanks for explaing that. My understanding was that Module::SetLoadAddress was the "main" interface, and that the other functions were just there to support it. Having Module::SetLoadAddress be a utility function on top of those makes perfect sense now.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

445

I don't think that is really worth it -- supporting the full qOffsets packet is is somewhat tricky, and if anyone sets out to do that, the lack of a preexisting query function will be the least of his concerns.

The main thing I found tricky is knowing what exactly should the individual offset fields apply to. The packet response doesn't just list sections or anything. It specifically prescribes three fields: "Text", "Data", and "Bss". Looking at gdb sources, I got the impression that it maps "Text" to the ".text" section, but that seems too narrow to me -- I would expect that it should apply to all executable sections, but as I don't know of any system which would make use of this option, I cannot validate my hypothesis.

The second complication comes from the supposed difference in handling of "Text" vs "TextSeg" field. To implement that absolutely correctly, I'd need to know whether the object file uses segments or not. But knowing that is again tricky because our ObjectFile interface abstracts those differences away. I could again make some guesses at what would be a reasonable behavior, but I also could not check that this is right.

So I think it's better to leave this to someone who actually needs this behavior.

[clayborg]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

445

So I am not advocating supporting the full QOffsets packet at all. Just splitting up the contents of GetExecutableOffset so that GetQOffsets() grabs the exact output and chops it up. No need to implement any true functionality. So the code would be identical to what you have, but the GetQOffsets() will just return the array of strings that contains the chopped up return value. Since this class is GDBRemoteCommunicationClient, and if someone new comes in and wants the results of QOffsets to do something, the code is already there. Right now is implemented, but hidden inside GetExecutableOffset. So no functionality, just have GetQOffsets() return the data from the packet. Let me know what you think. Not a blocker, I would just prefer that any packet that GDB remote protocol handles has a raw access function.

[labath]

Fully parse the qOffsets response

[labath]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

445

Ok, I see what you mean. The new patch now has a function which extracts all the data from the qOffsets response. I was trying to avoid doing that (I could take some shortcuts if I assumed all offsets have to be same), but overall difference is not that big..

[labath]

Update the unit test for the function rename (GetExecutableOffset->GetQOffsets)

[clayborg]

Thanks for doing the changes, looks good.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

 #endif
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 namespace process_gdb_remote {
 
+/// The offsets used by the target when relocating the executable. Decoded from
+/// qOffsets packet response.
+struct QOffsets {
+  /// If true, the offsets field describes segments. Otherwise, it describes
+  /// sections.
+  bool segments;
+
+  /// The individual offsets. Section offsets have two or three members.
+  /// Segment offsets have either one of two.
+  std::vector<uint64_t> offsets;
+};
+inline bool operator==(const QOffsets &a, const QOffsets &b) {
+  return a.segments == b.segments && a.offsets == b.offsets;
+}
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const QOffsets &offsets);
+
 class GDBRemoteCommunicationClient : public GDBRemoteClientBase {
 public:
   GDBRemoteCommunicationClient();
 
   ~GDBRemoteCommunicationClient() override;
 
   // After connecting, send the handshake to the server to make sure
   // we are communicating with it.
public:
   StructuredData::ObjectSP GetThreadsInfo();
 
   bool GetThreadExtendedInfoSupported();
 
   bool GetLoadedDynamicLibrariesInfosSupported();
 
   bool GetSharedCacheInfoSupported();
 
+  /// Use qOffsets to query the offset used when relocating the target
+  /// executable. If successful, the returned structure will contain at least
+  /// one value in the offsets field.
+  llvm::Optional<QOffsets> GetQOffsets();
+
   bool GetModuleInfo(const FileSpec &module_file_spec,
                      const ArchSpec &arch_spec, ModuleSpec &module_spec);
 
   llvm::Optional<std::vector<ModuleSpec>>
   GetModulesInfo(llvm::ArrayRef<FileSpec> module_file_specs,
                  const llvm::Triple &triple);
 
   bool ReadExtFeature(const lldb_private::ConstString object,

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

 #include <compression.h>
 #endif
 
 using namespace lldb;
 using namespace lldb_private::process_gdb_remote;
 using namespace lldb_private;
 using namespace std::chrono;
 
+llvm::raw_ostream &process_gdb_remote::operator<<(llvm::raw_ostream &os,
+                                                  const QOffsets &offsets) {
+  return os << llvm::formatv(
+             "QOffsets({0}, [{1:@[x]}])", offsets.segments,
+             llvm::make_range(offsets.offsets.begin(), offsets.offsets.end()));
+}
+
 // GDBRemoteCommunicationClient constructor
 GDBRemoteCommunicationClient::GDBRemoteCommunicationClient()
     : GDBRemoteClientBase("gdb-remote.client", "gdb-remote.client.rx_packet"),
       m_supports_not_sending_acks(eLazyBoolCalculate),
       m_supports_thread_suffix(eLazyBoolCalculate),
       m_supports_threads_in_stop_reply(eLazyBoolCalculate),
       m_supports_vCont_all(eLazyBoolCalculate),
       m_supports_vCont_any(eLazyBoolCalculate),
if (SendPacketAndWaitForResponse(packet.GetString(), response, true) ==
     LLDB_LOG(log, "failed to send packet");
     error.SetErrorStringWithFormat("failed to send packet: '%s'",
                                    packet.GetData());
     buffer = buffer.slice(buffer.size());
   }
   return error;
 }
 
+llvm::Optional<QOffsets> GDBRemoteCommunicationClient::GetQOffsets() {
+  StringExtractorGDBRemote response;
+  if (SendPacketAndWaitForResponse(
+          "qOffsets", response, /*send_async=*/false) != PacketResult::Success)
+    return llvm::None;
+  if (!response.IsNormalResponse())
+    return llvm::None;
+
+  QOffsets result;
+  llvm::StringRef ref = response.GetStringRef();
+  const auto &GetOffset = [&] {
+    addr_t offset;
+    if (ref.consumeInteger(16, offset))
+      return false;
+    result.offsets.push_back(offset);
+    return true;
+  };
+
+  if (ref.consume_front("Text=")) {
+    result.segments = false;
+    if (!GetOffset())
+      return llvm::None;
+    if (!ref.consume_front(";Data=") || !GetOffset())
+      return llvm::None;
+    if (ref.empty())
+      return result;
+    if (ref.consume_front(";Bss=") && GetOffset() && ref.empty())
+      return result;
+  } else if (ref.consume_front("TextSeg=")) {
+    result.segments = true;
+    if (!GetOffset())
+      return llvm::None;
+    if (ref.empty())
+      return result;
+    if (ref.consume_front(";DataSeg=") && GetOffset() && ref.empty())
+      return result;
+  }
+  return llvm::None;
+}
+
 bool GDBRemoteCommunicationClient::GetModuleInfo(
     const FileSpec &module_file_spec, const lldb_private::ArchSpec &arch_spec,
     ModuleSpec &module_spec) {
   if (!m_supports_qModuleInfo)
     return false;
 
   std::string module_path = module_file_spec.GetPath(false);
   if (module_path.empty())

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

protected:
 
   void HandleStopReplySequence();
 
   void ClearThreadIDList();
 
   bool UpdateThreadIDList();
 
   void DidLaunchOrAttach(ArchSpec &process_arch);
+  void MaybeLoadExecutableModule();
 
   Status ConnectToDebugserver(llvm::StringRef host_port);
 
   const char *GetDispatchQueueNameForThread(lldb::addr_t thread_dispatch_qaddr,
                                             std::string &dispatch_queue_name);
 
   DynamicLoader *GetDynamicLoader() override;
 

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

if (target_arch.IsValid()) {
                target_arch.GetTriple().getTriple());
     } else {
       // The target doesn't have a valid architecture yet, set it from the
       // architecture we got from the remote GDB server
       GetTarget().SetArchitecture(process_arch);
     }
   }
 
+  MaybeLoadExecutableModule();
+
   // Find out which StructuredDataPlugins are supported by the debug monitor.
   // These plugins transmit data over async $J packets.
   if (StructuredData::Array *supported_packets =
           m_gdb_comm.GetSupportedStructuredDataPlugins())
     MapSupportedStructuredDataPlugins(*supported_packets);
 }
 
+void ProcessGDBRemote::MaybeLoadExecutableModule() {
+  ModuleSP module_sp = GetTarget().GetExecutableModule();
+  if (!module_sp)
+    return;
+
+  llvm::Optional<QOffsets> offsets = m_gdb_comm.GetQOffsets();
+  if (!offsets)
+    return;
+
+  bool is_uniform =
+      size_t(llvm::count(offsets->offsets, offsets->offsets[0])) ==
+      offsets->offsets.size();
+  if (!is_uniform)
+    return; // TODO: Handle non-uniform responses.
+
+  bool changed = false;
+  module_sp->SetLoadAddress(GetTarget(), offsets->offsets[0],
+                            /*value_is_offset=*/true, changed);
+  if (changed) {
+    ModuleList list;
+    list.Append(module_sp);
+    m_process->GetTarget().ModulesDidLoad(list);
+  }
+}
+
 void ProcessGDBRemote::DidLaunch() {
   ArchSpec process_arch;
   DidLaunchOrAttach(process_arch);
 }
 
 Status ProcessGDBRemote::DoAttachToProcessWithID(
     lldb::pid_t attach_pid, const ProcessAttachInfo &attach_info) {
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));

lldb/test/API/functionalities/gdb_remote_client/TestqOffsets.py

+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+from gdbclientutils import *
+
+
+class TestqOffsets(GDBRemoteTestBase):
+
+    class Responder(MockGDBServerResponder):
+        def qOffsets(self):
+            return 'Text=470000;Data=470000'
+
+    def setUp(self):
+        super(TestqOffsets, self).setUp()
+        self._initial_platform = lldb.DBG.GetSelectedPlatform()
+
+    def tearDown(self):
+        lldb.DBG.SetSelectedPlatform(self._initial_platform)
+        super(TestqOffsets, self).tearDown()
+
+    def test(self):
+        self.server.responder = TestqOffsets.Responder()
+        target = self.createTarget("qOffsets.yaml")
+        text = target.modules[0].FindSection(".text")
+        self.assertEquals(text.GetLoadAddress(target), lldb.LLDB_INVALID_ADDRESS)
+
+        process = self.connect(target)
+        self.assertEquals(text.GetLoadAddress(target), 0x471000)

lldb/test/API/functionalities/gdb_remote_client/gdbclientutils.py

def respond(self, packet):
         if packet.startswith("qMemoryRegionInfo:"):
             return self.qMemoryRegionInfo()
         if packet == "qQueryGDBServer":
             return self.qQueryGDBServer()
         if packet == "qHostInfo":
             return self.qHostInfo()
         if packet == "qGetWorkingDir":
             return self.qGetWorkingDir()
+        if packet == "qOffsets":
+            return self.qOffsets();
         if packet == "qsProcessInfo":
             return self.qsProcessInfo()
         if packet.startswith("qfProcessInfo"):
             return self.qfProcessInfo(packet)
 
         return self.other(packet)
 
     def qsProcessInfo(self):
         return "E04"
 
     def qfProcessInfo(self, packet):
         return "E04"
 
     def qGetWorkingDir(self):
         return "2f"
 
+    def qOffsets(self):
+        return ""
+
     def qHostInfo(self):
         return "ptrsize:8;endian:little;"
 
     def qQueryGDBServer(self):
         return "E04"
 
     def interrupt(self):
         raise self.UnexpectedPacketException()

lldb/test/API/functionalities/gdb_remote_client/qOffsets.yaml

+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_AARCH64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x4
+    Content:         "c3c3c3c3"
+  - Name:            .note.ABI-tag
+    Type:            SHT_NOTE
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x1004
+    AddressAlign:    0x4
+    Content:         040000001000000001000000474e550000000000030000000700000000000000

lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

TEST_F(GDBRemoteCommunicationClientTest, SendGetTraceConfigPacket) {
   std::string incorrect_custom_params1 =
       R"({"buffersize" : 8192,"params" : "psb" : 1,"tracetech" : "intel-pt"})";
   std::string incorrect_custom_params2 =
       R"(],"metabuffersize" : 8192,"threadid" : 35,"type" : 1}])";
   HandlePacket(server, expected_packet, incorrect_custom_params1+
       incorrect_custom_params2);
   ASSERT_FALSE(result4.get().Success());
 }
+
+TEST_F(GDBRemoteCommunicationClientTest, GetQOffsets) {
+  const auto &GetQOffsets = [&](llvm::StringRef response) {
+    std::future<Optional<QOffsets>> result = std::async(
+        std::launch::async, [&] { return client.GetQOffsets(); });
+
+    HandlePacket(server, "qOffsets", response);
+    return result.get();
+  };
+  EXPECT_EQ((QOffsets{false, {0x1234, 0x1234}}),
+            GetQOffsets("Text=1234;Data=1234"));
+  EXPECT_EQ((QOffsets{false, {0x1234, 0x1234, 0x1234}}),
+            GetQOffsets("Text=1234;Data=1234;Bss=1234"));
+  EXPECT_EQ((QOffsets{true, {0x1234}}), GetQOffsets("TextSeg=1234"));
+  EXPECT_EQ((QOffsets{true, {0x1234, 0x2345}}),
+            GetQOffsets("TextSeg=1234;DataSeg=2345"));
+
+  EXPECT_EQ(llvm::None, GetQOffsets("E05"));
+  EXPECT_EQ(llvm::None, GetQOffsets("Text=bogus"));
+  EXPECT_EQ(llvm::None, GetQOffsets("Text=1234"));
+  EXPECT_EQ(llvm::None, GetQOffsets("Text=1234;Data=1234;"));
+  EXPECT_EQ(llvm::None, GetQOffsets("Text=1234;Data=1234;Bss=1234;"));
+  EXPECT_EQ(llvm::None, GetQOffsets("TEXTSEG=1234"));
+  EXPECT_EQ(llvm::None, GetQOffsets("TextSeg=0x1234"));
+  EXPECT_EQ(llvm::None, GetQOffsets("TextSeg=12345678123456789"));
+}