returning error from Target::ReadInstructions

Author: eronnen

lldb/include/lldb/Target/Target.h

@@ -1335,9 +1335,9 @@ class Target : public std::enable_shared_from_this<Target>,
                                const lldb_private::RegisterFlags &flags,
                                uint32_t byte_size);
 
-  lldb::DisassemblerSP ReadInstructions(const Address &start_addr,
-                                        uint32_t count,
-                                        const char *flavor_string = nullptr);
+  llvm::Expected<lldb::DisassemblerSP>
+  ReadInstructions(const Address &start_addr, uint32_t count,
+                   const char *flavor_string = nullptr);
 
   // Target Stop Hooks
   class StopHook : public UserID {

lldb/source/API/SBTarget.cpp

@@ -1970,8 +1970,10 @@ lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
 
   if (TargetSP target_sp = GetSP()) {
     if (Address *addr_ptr = base_addr.get()) {
-      sb_instructions.SetDisassembler(
-          target_sp->ReadInstructions(*addr_ptr, count, flavor_string));
+      if (llvm::Expected<DisassemblerSP> disassembler =
+              target_sp->ReadInstructions(*addr_ptr, count, flavor_string)) {
+        sb_instructions.SetDisassembler(*disassembler);
+      }
     }
   }
 

lldb/source/Breakpoint/BreakpointResolver.cpp

@@ -368,15 +368,23 @@ BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr,
                                                      bool *new_location) {
   if (m_offset_is_insn_count) {
     Target &target = GetBreakpoint()->GetTarget();
-    const DisassemblerSP instructions =
+    llvm::Expected<DisassemblerSP> expected_instructions =
         target.ReadInstructions(loc_addr, m_offset);
+    if (!expected_instructions) {
+      LLDB_LOG_ERROR(GetLog(LLDBLog::Breakpoints),
+                     expected_instructions.takeError(),
+                     "error: Unable to read instructions at address 0x{0:x}",
+                     loc_addr.GetLoadAddress(&target));
+      return BreakpointLocationSP();
+    }
+
+    const DisassemblerSP instructions = *expected_instructions;
     if (!instructions ||
         instructions->GetInstructionList().GetSize() != m_offset) {
-      Log *log = GetLog(LLDBLog::Breakpoints);
-      LLDB_LOGF(log,
+      LLDB_LOGF(GetLog(LLDBLog::Breakpoints),
                 "error: Unable to read %lu instructions at address 0x%" PRIx64
                 "\n",
-                m_offset, loc_addr.GetFileAddress());
+                m_offset, loc_addr.GetLoadAddress(&target));
       return BreakpointLocationSP();
     }
 

lldb/source/Target/Target.cpp

@@ -3000,9 +3000,9 @@ lldb::addr_t Target::GetBreakableLoadAddress(lldb::addr_t addr) {
   return arch_plugin ? arch_plugin->GetBreakableLoadAddress(addr, *this) : addr;
 }
 
-lldb::DisassemblerSP Target::ReadInstructions(const Address &start_addr,
-                                              uint32_t count,
-                                              const char *flavor_string) {
+llvm::Expected<lldb::DisassemblerSP>
+Target::ReadInstructions(const Address &start_addr, uint32_t count,
+                         const char *flavor_string) {
   DataBufferHeap data(GetArchitecture().GetMaximumOpcodeByteSize() * count, 0);
   bool force_live_memory = true;
   lldb_private::Status error;
@@ -3011,6 +3011,11 @@ lldb::DisassemblerSP Target::ReadInstructions(const Address &start_addr,
       ReadMemory(start_addr, data.GetBytes(), data.GetByteSize(), error,
                  force_live_memory, &load_addr);
 
+  if (error.Fail())
+    return llvm::createStringError(
+        error.AsCString("Target::ReadInstructions failed to read memory at %s"),
+        start_addr.GetLoadAddress(this));
+
   const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
   if (!flavor_string || flavor_string[0] == '\0') {
     // FIXME - we don't have the mechanism in place to do per-architecture