With firmware debug sess, if gdb stub knows the UUID/address of binary, try to load it

[jasonmolenda]

Summary

We have a gdb stub that can get the UUID and address/slide of the firmware running on a device, and I'm adding support for sending that information up to lldb, so lldb can try to find & load the binary at the correct address/offset.

I'd discussed this once in the past, long ago, trying to decide how we would handle this - a new packet? - and I think it was Greg who suggested qHostInfo could get a couple of new key-value pairs to do it. I think that idea is the right one, but it makes more sense in qProcessInfo to me, so that's where I've implemented it.

I haven't thought up a way to test this artificially yet. While writing the patch, I hardcoded the new fields in debugserver's qProcessInfo reply, and I removed the darwin dynamic loader plugins in lldb, so they wouldn't get control and wipe the image list I manually loaded, hah.

[JDevlieghere]

LGMT

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

584

The .get() is redundant.

613–617

Use LLDB_LOG which has the if(log) inlined in the macro.

LLDB_LOG(log, "Loading binary UUID %s at %s 0x%" PRIx64,
                              standalone_uuid.GetAsString().c_str(),
                              standalone_value_is_offset ? "offset" : "address",
                              standalone_value);

Same below.

626–627

Same comment as in D116094, but since you didn't change it there, let's keep it consistent.

[jasonmolenda]

Update patch to incorporate Jonas' feedback.

[labath]

What happened to the test case?

[jasonmolenda]

In D116211#3211319, @labath wrote:

What happened to the test case?

I didn't think of a way of constructing one very easily with what we have r.n. :/ The closest would be a gdb_remote_client test, but we need a binary that the gdb server can reply with the UUID of.

[labath]

In D116211#3218911, @jasonmolenda wrote:

In D116211#3211319, @labath wrote:

What happened to the test case?

I didn't think of a way of constructing one very easily with what we have r.n. :/ The closest would be a gdb_remote_client test, but we need a binary that the gdb server can reply with the UUID of.

Yes, that's pretty much what I had in mind. You can use yaml2obj to construct a binary with a well-known uuid. We already have a couple of gdb-client tests using yaml2obj. The easiest way to create one is to use obj2yaml on an existing (small) binary and then (possibly) delete the uninteresting stuff in an editor.

lldb/docs/lldb-gdb-remote.txt

 effective-gid: the effective group id of the process
 cputype: the Mach-O CPU type of the process  (base 16)
 cpusubtype: the Mach-O CPU subtype of the process  (base 16)
 ostype: is a string the represents the OS being debugged (darwin, linux, freebsd)
 vendor: is a string that represents the vendor (apple)
 endian: is one of "little", "big", or "pdp"
 ptrsize: is a number that represents how big pointers are in bytes
 
+main-binary-uuid: is the UUID of a firmware type binary that the gdb stub knows about
+main-binary-address: is the load address of the firmware type binary
+main-binary-slide: is the slide of the firmware type binary, if address isn't known
 
 //----------------------------------------------------------------------
 // "qShlibInfoAddr"
 //
 // BRIEF
 //  Get an address where the dynamic linker stores information about
 //  where shared libraries are loaded.
 //

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

Status GetWatchpointsTriggerAfterInstruction(bool &after,
                                                const ArchSpec &arch);
 
   const ArchSpec &GetHostArchitecture();
 
   std::chrono::seconds GetHostDefaultPacketTimeout();
 
   const ArchSpec &GetProcessArchitecture();
 
+  bool GetProcessStandaloneBinary(UUID &uuid, lldb::addr_t &value,
+                                  bool &value_is_offset);
+
   void GetRemoteQSupported();
 
   bool GetVContSupported(char flavor);
 
   bool GetpPacketSupported(lldb::tid_t tid);
 
   bool GetxPacketSupported();
 
protected:
   /// Current gdb remote protocol thread identifier for continue, step, etc
   lldb::tid_t m_curr_tid_run = LLDB_INVALID_THREAD_ID;
 
   uint32_t m_num_supported_hardware_watchpoints = 0;
   uint32_t m_addressing_bits = 0;
 
   ArchSpec m_host_arch;
   ArchSpec m_process_arch;
+  UUID m_process_standalone_uuid;
+  lldb::addr_t m_process_standalone_value = LLDB_INVALID_ADDRESS;
+  bool m_process_standalone_value_is_offset = false;
   llvm::VersionTuple m_os_version;
   llvm::VersionTuple m_maccatalyst_version;
   std::string m_os_build;
   std::string m_os_kernel;
   std::string m_hostname;
   std::string m_gdb_server_name; // from reply to qGDBServerVersion, empty if
                                  // qGDBServerVersion is not supported
   uint32_t m_gdb_server_version =

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

 
 const lldb_private::ArchSpec &
 GDBRemoteCommunicationClient::GetProcessArchitecture() {
   if (m_qProcessInfo_is_valid == eLazyBoolCalculate)
     GetCurrentProcessInfo();
   return m_process_arch;
 }
 
+bool GDBRemoteCommunicationClient::GetProcessStandaloneBinary(
+    UUID &uuid, addr_t &value, bool &value_is_offset) {
+  if (m_qProcessInfo_is_valid == eLazyBoolCalculate)
+    GetCurrentProcessInfo();
+
+  // Return true if we have a UUID or an address/offset of the
+  // main standalone / firmware binary being used.
+  if (!m_process_standalone_uuid.IsValid() &&
+      m_process_standalone_value == LLDB_INVALID_ADDRESS)
+    return false;
+
+  uuid = m_process_standalone_uuid;
+  value = m_process_standalone_value;
+  value_is_offset = m_process_standalone_value_is_offset;
+  return true;
+}
+
 bool GDBRemoteCommunicationClient::GetGDBServerVersion() {
   if (m_qGDBServerVersion_is_valid == eLazyBoolCalculate) {
     m_gdb_server_name.clear();
     m_gdb_server_version = 0;
     m_qGDBServerVersion_is_valid = eLazyBoolNo;
 
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse("qGDBServerVersion", response) ==

           if (!value.getAsInteger(16, pointer_byte_size))
             ++num_keys_decoded;
         } else if (name.equals("pid")) {
           if (!value.getAsInteger(16, pid))
             ++num_keys_decoded;
         } else if (name.equals("elf_abi")) {
           elf_abi = std::string(value);
           ++num_keys_decoded;
+        } else if (name.equals("main-binary-uuid")) {
+          m_process_standalone_uuid.SetFromStringRef(value);
+          ++num_keys_decoded;
+        } else if (name.equals("main-binary-slide")) {
+          StringExtractor extractor(value);
+          m_process_standalone_value =
+              extractor.GetU64(LLDB_INVALID_ADDRESS, 16);
+          if (m_process_standalone_value != LLDB_INVALID_ADDRESS) {
+            m_process_standalone_value_is_offset = true;
+            ++num_keys_decoded;
+          }
+        } else if (name.equals("main-binary-address")) {
+          StringExtractor extractor(value);
+          m_process_standalone_value =
+              extractor.GetU64(LLDB_INVALID_ADDRESS, 16);
+          if (m_process_standalone_value != LLDB_INVALID_ADDRESS) {
+            m_process_standalone_value_is_offset = false;
+            ++num_keys_decoded;
+          }
         }
       }
       if (num_keys_decoded > 0)
         m_qProcessInfo_is_valid = eLazyBoolYes;
       if (pid != LLDB_INVALID_PROCESS_ID) {
         m_curr_pid_is_valid = eLazyBoolYes;
         m_curr_pid_run = m_curr_pid = pid;
       }

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

           target.SetArchitecture(m_gdb_comm.GetProcessArchitecture());
         } else {
           if (m_gdb_comm.GetHostArchitecture().IsValid()) {
             target.SetArchitecture(m_gdb_comm.GetHostArchitecture());
           }
         }
       }
 
+      // The remote stub may know about the "main binary" in
+      // the context of a firmware debug session, and can
+      // give us a UUID and an address/slide of where the
+      // binary is loaded in memory.
+      UUID standalone_uuid;
+      addr_t standalone_value;
+      bool standalone_value_is_offset;
+      if (m_gdb_comm.GetProcessStandaloneBinary(
+              standalone_uuid, standalone_value, standalone_value_is_offset)) {
+        ModuleSP module_sp;
+
+        if (standalone_uuid.IsValid()) {
+          ModuleSpec module_spec;
+          module_spec.GetUUID() = standalone_uuid;
+
+          // Look up UUID in global module cache before attempting
+          // a more expensive search.
+          Status error = ModuleList::GetSharedModule(module_spec, module_sp,
+                                                     nullptr, nullptr, nullptr);
+
+          if (!module_sp) {
+            // Force a an external lookup, if that tool is available.
+            if (!module_spec.GetSymbolFileSpec())
+              Symbols::DownloadObjectAndSymbolFile(module_spec, true);
+
+            if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
+              module_sp = std::make_shared<Module>(module_spec);
+            }
+          }
+
+          // If we couldn't find the binary anywhere else, as a last resort,
+          // read it out of memory.
+          if (!module_sp.get() && standalone_value != LLDB_INVALID_ADDRESS &&
+              !standalone_value_is_offset) {
+            char namebuf[80];
+            snprintf(namebuf, sizeof(namebuf), "mem-image-0x%" PRIx64,
+                     standalone_value);
+            module_sp =
+                ReadModuleFromMemory(FileSpec(namebuf), standalone_value);
+          }
+
+          Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(
+              LIBLLDB_LOG_DYNAMIC_LOADER));
+          if (module_sp.get()) {
+            target.GetImages().AppendIfNeeded(module_sp, false);
+
+            bool changed = false;
+            if (module_sp->GetObjectFile()) {
+              if (standalone_value != LLDB_INVALID_ADDRESS) {
+                if (log)
+                  log->Printf("Loading binary UUID %s at %s 0x%" PRIx64,
+                              standalone_uuid.GetAsString().c_str(),
+                              standalone_value_is_offset ? "offset" : "address",
+                              standalone_value);
+                module_sp->SetLoadAddress(target, standalone_value,
+                                          standalone_value_is_offset, changed);
+              } else {
+                // No address/offset/slide, load the binary at file address,
+                // offset 0.
+                if (log)
+                  log->Printf("Loading binary UUID %s at file address",
+                              standalone_uuid.GetAsString().c_str());
+                const bool value_is_slide = true;
+                module_sp->SetLoadAddress(target, 0, value_is_slide, changed);
+              }
+            } else {
+              // In-memory image, load at its true address, offset 0.
+              if (log)
+                log->Printf("Loading binary UUID %s from memory",
+                            standalone_uuid.GetAsString().c_str());
+              const bool value_is_slide = true;
+              module_sp->SetLoadAddress(target, 0, value_is_slide, changed);
+            }
+
+            ModuleList added_module;
+            added_module.Append(module_sp, false);
+            target.ModulesDidLoad(added_module);
+          } else {
+            if (log)
+              log->Printf("Unable to find binary with UUID %s and load it at "
+                          "%s 0x%" PRIx64,
+                          standalone_uuid.GetAsString().c_str(),
+                          standalone_value_is_offset ? "offset" : "address",
+                          standalone_value);
+          }
+        }
+      }
+
       const StateType state = SetThreadStopInfo(response);
       if (state != eStateInvalid) {
         SetPrivateState(state);
       } else
         error.SetErrorStringWithFormat(
             "Process %" PRIu64 " was reported after connecting to "
             "'%s', but state was not stopped: %s",
             pid, remote_url.str().c_str(), StateAsCString(state));