<rdar://problem/11730263>

PC relative loads are missing disassembly comments when disassembled in a live process.

This issue was because some sections, like __TEXT and __DATA in libobjc.A.dylib, were being moved when they were put into the dyld shared cache. This could also affect any other system that slides sections individually.

The solution is to keep track of wether the bytes we will disassemble are from an executable file (file address), or from a live process (load address). We now do the right thing based off of this input in all cases.

llvm-svn: 178315

1 files changed, 47 insertions, 39 deletions

diff --git a/lldb/source/Core/Disassembler.cpp b/lldb/source/Core/Disassembler.cpp
index 3c8210bd972..3d4b7ffd19b 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -250,7 +250,8 @@ Disassembler::DisassembleRange
 
         if (disasm_sp)
         {
-            size_t bytes_disassembled = disasm_sp->ParseInstructions (&exe_ctx, range, NULL);
+            const bool prefer_file_cache = false;
+            size_t bytes_disassembled = disasm_sp->ParseInstructions (&exe_ctx, range, NULL, prefer_file_cache);
             if (bytes_disassembled == 0)
                 disasm_sp.reset();
         }
@@ -259,32 +260,31 @@ Disassembler::DisassembleRange
 }
 
 lldb::DisassemblerSP 
-Disassembler::DisassembleBytes 
-(
-    const ArchSpec &arch,
-    const char *plugin_name,
-    const char *flavor,
-    const Address &start,
-    const void *bytes,
-    size_t length,
-    uint32_t num_instructions
-)
+Disassembler::DisassembleBytes (const ArchSpec &arch,
+                                const char *plugin_name,
+                                const char *flavor,
+                                const Address &start,
+                                const void *src,
+                                size_t src_len,
+                                uint32_t num_instructions,
+                                bool data_from_file)
 {
     lldb::DisassemblerSP disasm_sp;
     
-    if (bytes)
+    if (src)
     {
         disasm_sp = Disassembler::FindPlugin(arch, flavor, plugin_name);
         
         if (disasm_sp)
         {
-            DataExtractor data(bytes, length, arch.GetByteOrder(), arch.GetAddressByteSize());
+            DataExtractor data(src, src_len, arch.GetByteOrder(), arch.GetAddressByteSize());
             
             (void)disasm_sp->DecodeInstructions (start,
                                                  data,
                                                  0,
                                                  num_instructions,
-                                                 false);
+                                                 false,
+                                                 data_from_file);
         }
     }
     
@@ -316,8 +316,8 @@ Disassembler::Disassemble
             AddressRange range;
             ResolveAddress (exe_ctx, disasm_range.GetBaseAddress(), range.GetBaseAddress());
             range.SetByteSize (disasm_range.GetByteSize());
-            
-            size_t bytes_disassembled = disasm_sp->ParseInstructions (&exe_ctx, range, &strm);
+            const bool prefer_file_cache = false;
+            size_t bytes_disassembled = disasm_sp->ParseInstructions (&exe_ctx, range, &strm, prefer_file_cache);
             if (bytes_disassembled == 0)
                 return false;
 
@@ -351,13 +351,19 @@ Disassembler::Disassemble
 {
     if (num_instructions > 0)
     {
-        lldb::DisassemblerSP disasm_sp (Disassembler::FindPluginForTarget(exe_ctx.GetTargetSP(), arch, flavor, plugin_name));
+        lldb::DisassemblerSP disasm_sp (Disassembler::FindPluginForTarget(exe_ctx.GetTargetSP(),
+                                                                          arch,
+                                                                          flavor,
+                                                                          plugin_name));
         if (disasm_sp.get())
         {
             Address addr;
             ResolveAddress (exe_ctx, start_address, addr);
-
-            size_t bytes_disassembled = disasm_sp->ParseInstructions (&exe_ctx, addr, num_instructions);
+            const bool prefer_file_cache = false;
+            size_t bytes_disassembled = disasm_sp->ParseInstructions (&exe_ctx,
+                                                                      addr,
+                                                                      num_instructions,
+                                                                      prefer_file_cache);
             if (bytes_disassembled == 0)
                 return false;
             return PrintInstructions (disasm_sp.get(),
@@ -1045,12 +1051,10 @@ InstructionList::GetIndexOfInstructionAtLoadAddress (lldb::addr_t load_addr, Tar
 }
 
 size_t
-Disassembler::ParseInstructions
-(
-    const ExecutionContext *exe_ctx,
-    const AddressRange &range,
-    Stream *error_strm_ptr
-)
+Disassembler::ParseInstructions (const ExecutionContext *exe_ctx,
+                                 const AddressRange &range,
+                                 Stream *error_strm_ptr,
+                                 bool prefer_file_cache)
 {
     if (exe_ctx)
     {
@@ -1063,12 +1067,13 @@ Disassembler::ParseInstructions
         DataBufferSP data_sp(heap_buffer);
 
         Error error;
-        const bool prefer_file_cache = true;
-        const size_t bytes_read = target->ReadMemory (range.GetBaseAddress(), 
+        lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
+        const size_t bytes_read = target->ReadMemory (range.GetBaseAddress(),
                                                       prefer_file_cache, 
                                                       heap_buffer->GetBytes(), 
                                                       heap_buffer->GetByteSize(), 
-                                                      error);
+                                                      error,
+                                                      &load_addr);
         
         if (bytes_read > 0)
         {
@@ -1077,7 +1082,8 @@ Disassembler::ParseInstructions
             DataExtractor data (data_sp, 
                                 m_arch.GetByteOrder(),
                                 m_arch.GetAddressByteSize());
-            return DecodeInstructions (range.GetBaseAddress(), data, 0, UINT32_MAX, false);
+            const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
+            return DecodeInstructions (range.GetBaseAddress(), data, 0, UINT32_MAX, false, data_from_file);
         }
         else if (error_strm_ptr)
         {
@@ -1096,12 +1102,10 @@ Disassembler::ParseInstructions
 }
 
 size_t
-Disassembler::ParseInstructions
-(
-    const ExecutionContext *exe_ctx,
-    const Address &start,
-    uint32_t num_instructions
-)
+Disassembler::ParseInstructions (const ExecutionContext *exe_ctx,
+                                 const Address &start,
+                                 uint32_t num_instructions,
+                                 bool prefer_file_cache)
 {
     m_instruction_list.Clear();
 
@@ -1119,12 +1123,15 @@ Disassembler::ParseInstructions
     DataBufferSP data_sp (heap_buffer);
 
     Error error;
-    bool prefer_file_cache = true;
-    const size_t bytes_read = target->ReadMemory (start, 
+    lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
+    const size_t bytes_read = target->ReadMemory (start,
                                                   prefer_file_cache, 
                                                   heap_buffer->GetBytes(), 
                                                   byte_size, 
-                                                  error);
+                                                  error,
+                                                  &load_addr);
+
+    const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
 
     if (bytes_read == 0)
         return 0;
@@ -1137,7 +1144,8 @@ Disassembler::ParseInstructions
                         data, 
                         0, 
                         num_instructions, 
-                        append_instructions);
+                        append_instructions,
+                        data_from_file);
 
     return m_instruction_list.GetSize();
 }