[Lldb-commits] [lldb] r178315 - <rdar://problem/11730263>

Greg Clayton gclayton at apple.com
Thu Mar 28 16:42:54 PDT 2013


Author: gclayton
Date: Thu Mar 28 18:42:53 2013
New Revision: 178315

URL: http://llvm.org/viewvc/llvm-project?rev=178315&view=rev
Log:
<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.


Modified:
    lldb/trunk/include/lldb/Core/DataExtractor.h
    lldb/trunk/include/lldb/Core/Disassembler.h
    lldb/trunk/source/API/SBTarget.cpp
    lldb/trunk/source/Core/DataExtractor.cpp
    lldb/trunk/source/Core/Disassembler.cpp
    lldb/trunk/source/Expression/IRExecutionUnit.cpp
    lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
    lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h
    lldb/trunk/source/Target/ThreadPlanTracer.cpp

Modified: lldb/trunk/include/lldb/Core/DataExtractor.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/DataExtractor.h?rev=178315&r1=178314&r2=178315&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Core/DataExtractor.h (original)
+++ lldb/trunk/include/lldb/Core/DataExtractor.h Thu Mar 28 18:42:53 2013
@@ -1245,9 +1245,7 @@ public:
     
     bool
     Append (void* bytes, lldb::offset_t length);
-    
-protected:
-    
+
     lldb::offset_t
     BytesLeft (lldb::offset_t offset) const
     {
@@ -1256,6 +1254,8 @@ protected:
             return size - offset;
         return 0;
     }
+
+protected:
     
     //------------------------------------------------------------------
     // Member variables

Modified: lldb/trunk/include/lldb/Core/Disassembler.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/Disassembler.h?rev=178315&r1=178314&r2=178315&view=diff
==============================================================================
--- lldb/trunk/include/lldb/Core/Disassembler.h (original)
+++ lldb/trunk/include/lldb/Core/Disassembler.h Thu Mar 28 18:42:53 2013
@@ -273,7 +273,8 @@ public:
                       const Address &start,
                       const void *bytes,
                       size_t length,
-                      uint32_t num_instructions = UINT32_MAX);
+                      uint32_t max_num_instructions,
+                      bool data_from_file);
 
     static bool
     Disassemble (Debugger &debugger,
@@ -356,19 +357,22 @@ public:
     size_t
     ParseInstructions (const ExecutionContext *exe_ctx,
                        const AddressRange &range,
-                       Stream *error_strm_ptr);
+                       Stream *error_strm_ptr,
+                       bool prefer_file_cache);
 
     size_t
     ParseInstructions (const ExecutionContext *exe_ctx,
                        const Address &range,
-                       uint32_t num_instructions);
+                       uint32_t num_instructions,
+                       bool prefer_file_cache);
 
     virtual size_t
     DecodeInstructions (const Address &base_addr,
                         const DataExtractor& data,
                         lldb::offset_t data_offset,
                         size_t num_instructions,
-                        bool append) = 0;
+                        bool append,
+                        bool data_from_file) = 0;
     
     InstructionList &
     GetInstructionList ();

Modified: lldb/trunk/source/API/SBTarget.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBTarget.cpp?rev=178315&r1=178314&r2=178315&view=diff
==============================================================================
--- lldb/trunk/source/API/SBTarget.cpp (original)
+++ lldb/trunk/source/API/SBTarget.cpp Thu Mar 28 18:42:53 2013
@@ -2288,14 +2288,22 @@ SBTarget::ReadInstructions (lldb::SBAddr
             DataBufferHeap data (target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0);
             bool prefer_file_cache = false;
             lldb_private::Error error;
-            const size_t bytes_read = target_sp->ReadMemory(*addr_ptr, prefer_file_cache, data.GetBytes(), data.GetByteSize(), error);
+            lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
+            const size_t bytes_read = target_sp->ReadMemory(*addr_ptr,
+                                                            prefer_file_cache,
+                                                            data.GetBytes(),
+                                                            data.GetByteSize(),
+                                                            error,
+                                                            &load_addr);
+            const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
             sb_instructions.SetDisassembler (Disassembler::DisassembleBytes (target_sp->GetArchitecture(),
                                                                              NULL,
                                                                              flavor_string,
                                                                              *addr_ptr,
                                                                              data.GetBytes(),
                                                                              bytes_read,
-                                                                             count));
+                                                                             count,
+                                                                             data_from_file));
         }
     }
     
@@ -2322,12 +2330,16 @@ SBTarget::GetInstructionsWithFlavor (lld
         if (base_addr.get())
             addr = *base_addr.get();
         
+        const bool data_from_file = true;
+
         sb_instructions.SetDisassembler (Disassembler::DisassembleBytes (target_sp->GetArchitecture(),
                                                                          NULL,
                                                                          flavor_string,
                                                                          addr,
                                                                          buf,
-                                                                         size));
+                                                                         size,
+                                                                         UINT32_MAX,
+                                                                         data_from_file));
     }
 
     return sb_instructions;

Modified: lldb/trunk/source/Core/DataExtractor.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/DataExtractor.cpp?rev=178315&r1=178314&r2=178315&view=diff
==============================================================================
--- lldb/trunk/source/Core/DataExtractor.cpp (original)
+++ lldb/trunk/source/Core/DataExtractor.cpp Thu Mar 28 18:42:53 2013
@@ -1328,13 +1328,18 @@ DataExtractor::Dump (Stream *s,
             {
                 lldb::addr_t addr = base_addr + start_offset;
                 lldb_private::Address so_addr;
-                if (!target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr))
+				bool data_from_file = true;
+                if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr))
+                {
+                    data_from_file = false;
+                }
+                else
                 {
                     if (target_sp->GetSectionLoadList().IsEmpty() || !target_sp->GetImages().ResolveFileAddress(addr, so_addr))
                         so_addr.SetRawAddress(addr);
                 }
 
-                size_t bytes_consumed = disassembler_sp->DecodeInstructions (so_addr, *this, start_offset, item_count, false);
+                size_t bytes_consumed = disassembler_sp->DecodeInstructions (so_addr, *this, start_offset, item_count, false, data_from_file);
                 
                 if (bytes_consumed)
                 {

Modified: lldb/trunk/source/Core/Disassembler.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/Disassembler.cpp?rev=178315&r1=178314&r2=178315&view=diff
==============================================================================
--- lldb/trunk/source/Core/Disassembler.cpp (original)
+++ lldb/trunk/source/Core/Disassembler.cpp Thu Mar 28 18:42:53 2013
@@ -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::GetIndexOfInstructionAt
 }
 
 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();
 }

Modified: lldb/trunk/source/Expression/IRExecutionUnit.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Expression/IRExecutionUnit.cpp?rev=178315&r1=178314&r2=178315&view=diff
==============================================================================
--- lldb/trunk/source/Expression/IRExecutionUnit.cpp (original)
+++ lldb/trunk/source/Expression/IRExecutionUnit.cpp Thu Mar 28 18:42:53 2013
@@ -234,7 +234,7 @@ IRExecutionUnit::DisassembleFunction (St
                             DataExtractor::TypeUInt8);
     }
     
-    disassembler->DecodeInstructions (Address (func_remote_addr), extractor, 0, UINT32_MAX, false);
+    disassembler->DecodeInstructions (Address (func_remote_addr), extractor, 0, UINT32_MAX, false, false);
     
     InstructionList &instruction_list = disassembler->GetInstructionList();
     const uint32_t max_opcode_byte_size = instruction_list.GetMaxOpcocdeByteSize();

Modified: lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp?rev=178315&r1=178314&r2=178315&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp (original)
+++ lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.cpp Thu Mar 28 18:42:53 2013
@@ -47,11 +47,11 @@ public:
     InstructionLLVMC (DisassemblerLLVMC &disasm,
                       const lldb_private::Address &address, 
                       AddressClass addr_class) :
-        Instruction(address, addr_class),
-        m_is_valid(false),
-        m_disasm(disasm),
-        m_disasm_sp(disasm.shared_from_this()),
-        m_does_branch(eLazyBoolCalculate)
+        Instruction (address, addr_class),
+        m_disasm_sp (disasm.shared_from_this()),
+        m_does_branch (eLazyBoolCalculate),
+        m_is_valid (false),
+        m_using_file_addr (false)
     {
     }
     
@@ -60,24 +60,12 @@ public:
     {
     }
     
-    static void
-    PadToWidth (lldb_private::StreamString &ss,
-                int new_width)
-    {
-        int old_width = ss.GetSize();
-        
-        if (old_width < new_width)
-        {
-            ss.Printf("%*s", new_width - old_width, "");
-        }
-    }
-        
     virtual bool
     DoesBranch ()
     {
         if (m_does_branch == eLazyBoolCalculate)
         {
-            m_disasm.Lock(this, NULL);
+            GetDisassemblerLLVMC().Lock(this, NULL);
             DataExtractor data;
             if (m_opcode.GetData(data))
             {
@@ -85,26 +73,26 @@ public:
                 lldb::addr_t pc = m_address.GetFileAddress();
 
                 DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr = GetDisasmToUse (is_alternate_isa);
-                uint8_t *opcode_data = const_cast<uint8_t *>(data.PeekData (0, 1));
+                const uint8_t *opcode_data = data.GetDataStart();
                 const size_t opcode_data_len = data.GetByteSize();
                 llvm::MCInst inst;
-                size_t inst_size = mc_disasm_ptr->GetMCInst(opcode_data,
-                                                            opcode_data_len,
-                                                            pc,
-                                                            inst);
+                const size_t inst_size = mc_disasm_ptr->GetMCInst (opcode_data,
+                                                                   opcode_data_len,
+                                                                   pc,
+                                                                   inst);
                 // Be conservative, if we didn't understand the instruction, say it might branch...
                 if (inst_size == 0)
                     m_does_branch = eLazyBoolYes;
                 else
                 {
-                    bool can_branch = mc_disasm_ptr->CanBranch(inst);
+                    const bool can_branch = mc_disasm_ptr->CanBranch(inst);
                     if (can_branch)
                         m_does_branch = eLazyBoolYes;
                     else
                         m_does_branch = eLazyBoolNo;
                 }
             }
-            m_disasm.Unlock();
+            GetDisassemblerLLVMC().Unlock();
         }
         return m_does_branch == eLazyBoolYes;
     }
@@ -112,20 +100,19 @@ public:
     DisassemblerLLVMC::LLVMCDisassembler *
     GetDisasmToUse (bool &is_alternate_isa)
     {
-        DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr = m_disasm.m_disasm_ap.get();
-        
         is_alternate_isa = false;
-        if (m_disasm.m_alternate_disasm_ap.get() != NULL)
+        DisassemblerLLVMC &llvm_disasm = GetDisassemblerLLVMC();
+        if (llvm_disasm.m_alternate_disasm_ap.get() != NULL)
         {
             const AddressClass address_class = GetAddressClass ();
         
             if (address_class == eAddressClassCodeAlternateISA)
             {
-                mc_disasm_ptr = m_disasm.m_alternate_disasm_ap.get();
                 is_alternate_isa = true;
+                return llvm_disasm.m_alternate_disasm_ap.get();
             }
         }
-         return mc_disasm_ptr;
+        return llvm_disasm.m_disasm_ap.get();
     }
     
     virtual size_t
@@ -136,7 +123,8 @@ public:
         // All we have to do is read the opcode which can be easy for some
         // architetures
         bool got_op = false;
-        const ArchSpec &arch = m_disasm.GetArchitecture();
+        DisassemblerLLVMC &llvm_disasm = GetDisassemblerLLVMC();
+        const ArchSpec &arch = llvm_disasm.GetArchitecture();
         
         const uint32_t min_op_byte_size = arch.GetMinimumOpcodeByteSize();
         const uint32_t max_op_byte_size = arch.GetMaximumOpcodeByteSize();
@@ -179,17 +167,6 @@ public:
             bool is_alternate_isa = false;
             DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr = GetDisasmToUse (is_alternate_isa);
             
-            if (m_disasm.m_alternate_disasm_ap.get() != NULL)
-            {
-                const AddressClass address_class = GetAddressClass ();
-            
-                if (address_class == eAddressClassCodeAlternateISA)
-                {
-                    mc_disasm_ptr = m_disasm.m_alternate_disasm_ap.get();
-                    is_alternate_isa = true;
-                }
-            }
-            
             const llvm::Triple::ArchType machine = arch.GetMachine();
             if (machine == llvm::Triple::arm || machine == llvm::Triple::thumb)
             {
@@ -219,17 +196,17 @@ public:
             {
                 // The opcode isn't evenly sized, so we need to actually use the llvm
                 // disassembler to parse it and get the size.
-                m_disasm.Lock(this, NULL);
                 uint8_t *opcode_data = const_cast<uint8_t *>(data.PeekData (data_offset, 1));
-                const size_t opcode_data_len = data.GetByteSize() - data_offset;
+                const size_t opcode_data_len = data.BytesLeft(data_offset);
                 const addr_t pc = m_address.GetFileAddress();
                 llvm::MCInst inst;
                 
+                llvm_disasm.Lock(this, NULL);
                 const size_t inst_size = mc_disasm_ptr->GetMCInst(opcode_data,
-                                                                    opcode_data_len,
-                                                                    pc,
-                                                                    inst);
-                m_disasm.Unlock();
+                                                                  opcode_data_len,
+                                                                  pc,
+                                                                  inst);
+                llvm_disasm.Unlock();
                 if (inst_size == 0)
                     m_opcode.Clear();
                 else
@@ -264,39 +241,50 @@ public:
         {
             char out_string[512];
             
+            DisassemblerLLVMC &llvm_disasm = GetDisassemblerLLVMC();
+
             DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr;
             
             if (address_class == eAddressClassCodeAlternateISA)
-                mc_disasm_ptr = m_disasm.m_alternate_disasm_ap.get();
+                mc_disasm_ptr = llvm_disasm.m_alternate_disasm_ap.get();
             else
-                mc_disasm_ptr = m_disasm.m_disasm_ap.get();
+                mc_disasm_ptr = llvm_disasm.m_disasm_ap.get();
             
-            lldb::addr_t pc = LLDB_INVALID_ADDRESS;
+            lldb::addr_t pc = m_address.GetFileAddress();
+            m_using_file_addr = true;
             
-            if (exe_ctx)
+            const bool data_from_file = GetDisassemblerLLVMC().m_data_from_file;
+            if (!data_from_file)
             {
-                Target *target = exe_ctx->GetTargetPtr();
-                if (target)
-                    pc = m_address.GetLoadAddress(target);
+                if (exe_ctx)
+                {
+                    Target *target = exe_ctx->GetTargetPtr();
+                    if (target)
+                    {
+                        const lldb::addr_t load_addr = m_address.GetLoadAddress(target);
+                        if (load_addr != LLDB_INVALID_ADDRESS)
+                        {
+                            pc = load_addr;
+                            m_using_file_addr = false;
+                        }
+                    }
+                }
             }
             
-            if (pc == LLDB_INVALID_ADDRESS)
-                pc = m_address.GetFileAddress();
-            
-            m_disasm.Lock(this, exe_ctx);
+            llvm_disasm.Lock(this, exe_ctx);
             
-            uint8_t *opcode_data = const_cast<uint8_t *>(data.PeekData (0, 1));
+            const uint8_t *opcode_data = data.GetDataStart();
             const size_t opcode_data_len = data.GetByteSize();
             llvm::MCInst inst;
-            size_t inst_size = mc_disasm_ptr->GetMCInst(opcode_data,
-                                                        opcode_data_len,
-                                                        pc,
-                                                        inst);
+            size_t inst_size = mc_disasm_ptr->GetMCInst (opcode_data,
+                                                         opcode_data_len,
+                                                         pc,
+                                                         inst);
                 
             if (inst_size > 0)
                 mc_disasm_ptr->PrintMCInst(inst, out_string, sizeof(out_string));
             
-            m_disasm.Unlock();
+            llvm_disasm.Unlock();
             
             if (inst_size == 0)
             {
@@ -361,7 +349,7 @@ public:
             {
                 if (m_does_branch == eLazyBoolCalculate)
                 {
-                    bool can_branch = mc_disasm_ptr->CanBranch(inst);
+                    const bool can_branch = mc_disasm_ptr->CanBranch(inst);
                     if (can_branch)
                         m_does_branch = eLazyBoolYes;
                     else
@@ -389,22 +377,33 @@ public:
     }
     
     bool
-    IsValid ()
+    IsValid () const
     {
         return m_is_valid;
     }
     
+    bool
+    UsingFileAddress() const
+    {
+        return m_using_file_addr;
+    }
     size_t
-    GetByteSize ()
+    GetByteSize () const
     {
         return m_opcode.GetByteSize();
     }
+    
+    DisassemblerLLVMC &
+    GetDisassemblerLLVMC ()
+    {
+        return *(DisassemblerLLVMC *)m_disasm_sp.get();
+    }
 protected:
     
-    bool                    m_is_valid;
-    DisassemblerLLVMC      &m_disasm;
     DisassemblerSP          m_disasm_sp; // for ownership
     LazyBool                m_does_branch;
+    bool                    m_is_valid;
+    bool                    m_using_file_addr;
     
     static bool             s_regex_compiled;
     static ::regex_t        s_regex;
@@ -476,11 +475,11 @@ DisassemblerLLVMC::LLVMCDisassembler::LL
 namespace {
     // This is the memory object we use in GetInstruction.
     class LLDBDisasmMemoryObject : public llvm::MemoryObject {
-      uint8_t *m_bytes;
+      const uint8_t *m_bytes;
       uint64_t m_size;
       uint64_t m_base_PC;
     public:
-      LLDBDisasmMemoryObject(uint8_t *bytes, uint64_t size, uint64_t basePC) :
+      LLDBDisasmMemoryObject(const uint8_t *bytes, uint64_t size, uint64_t basePC) :
                          m_bytes(bytes), m_size(size), m_base_PC(basePC) {}
      
       uint64_t getBase() const { return m_base_PC; }
@@ -496,14 +495,12 @@ namespace {
 } // End Anonymous Namespace
 
 uint64_t
-DisassemblerLLVMC::LLVMCDisassembler::GetMCInst (
-    uint8_t *opcode_data,
-    size_t opcode_data_len,
-    lldb::addr_t pc,
-    llvm::MCInst &mc_inst)
+DisassemblerLLVMC::LLVMCDisassembler::GetMCInst (const uint8_t *opcode_data,
+                                                 size_t opcode_data_len,
+                                                 lldb::addr_t pc,
+                                                 llvm::MCInst &mc_inst)
 {
     LLDBDisasmMemoryObject memory_object (opcode_data, opcode_data_len, pc);
-    llvm::MCInst inst;
     llvm::MCDisassembler::DecodeStatus status;
 
     uint64_t new_inst_size;
@@ -520,17 +517,18 @@ DisassemblerLLVMC::LLVMCDisassembler::Ge
 }
 
 uint64_t
-DisassemblerLLVMC::LLVMCDisassembler::PrintMCInst (llvm::MCInst &mc_inst, char *output_buffer, size_t out_buffer_len)
+DisassemblerLLVMC::LLVMCDisassembler::PrintMCInst (llvm::MCInst &mc_inst,
+                                                   char *dst,
+                                                   size_t dst_len)
 {
     llvm::StringRef unused_annotations;
     llvm::SmallString<64> inst_string;
     llvm::raw_svector_ostream inst_stream(inst_string);
     m_instr_printer_ap->printInst (&mc_inst, inst_stream, unused_annotations);
     inst_stream.flush();
-    
-    size_t output_size = std::min(out_buffer_len -1, inst_string.size());
-    std::memcpy(output_buffer, inst_string.data(), output_size);
-    output_buffer[output_size] = '\0';
+    const size_t output_size = std::min(dst_len - 1, inst_string.size());
+    std::memcpy(dst, inst_string.data(), output_size);
+    dst[output_size] = '\0';
     
     return output_size;
 }
@@ -576,7 +574,8 @@ DisassemblerLLVMC::CreateInstance (const
 DisassemblerLLVMC::DisassemblerLLVMC (const ArchSpec &arch, const char *flavor_string) :
     Disassembler(arch, flavor_string),
     m_exe_ctx (NULL),
-    m_inst (NULL)
+    m_inst (NULL),
+    m_data_from_file (false)
 {
     if (!FlavorValidForArchSpec (arch, m_flavor.c_str()))
     {
@@ -633,7 +632,8 @@ DisassemblerLLVMC::DecodeInstructions (c
                                        const DataExtractor& data,
                                        lldb::offset_t data_offset,
                                        size_t num_instructions,
-                                       bool append)
+                                       bool append,
+                                       bool data_from_file)
 {
     if (!append)
         m_instruction_list.Clear();
@@ -641,6 +641,7 @@ DisassemblerLLVMC::DecodeInstructions (c
     if (!IsValid())
         return 0;
     
+    m_data_from_file = data_from_file;
     uint32_t data_cursor = data_offset;
     const size_t data_byte_size = data.GetByteSize();
     uint32_t instructions_parsed = 0;
@@ -760,36 +761,33 @@ const char *DisassemblerLLVMC::SymbolLoo
         if (m_exe_ctx && m_inst)
         {        
             //std::string remove_this_prior_to_checkin;
-            Address reference_address;
-            
             Target *target = m_exe_ctx ? m_exe_ctx->GetTargetPtr() : NULL;
-            
-            if (target && !target->GetSectionLoadList().IsEmpty())
-                target->GetSectionLoadList().ResolveLoadAddress(value, reference_address);
-            else
+            Address value_so_addr;
+            if (m_inst->UsingFileAddress())
             {
                 ModuleSP module_sp(m_inst->GetAddress().GetModule());
                 if (module_sp)
-                    module_sp->ResolveFileAddress(value, reference_address);
+                    module_sp->ResolveFileAddress(value, value_so_addr);
             }
-                
-            if (reference_address.IsValid() && reference_address.GetSection())
+            else if (target && !target->GetSectionLoadList().IsEmpty())
+            {
+                target->GetSectionLoadList().ResolveLoadAddress(value, value_so_addr);
+            }
+            
+            if (value_so_addr.IsValid() && value_so_addr.GetSection())
             {
                 StreamString ss;
                 
-                reference_address.Dump (&ss, 
-                                        target, 
-                                        Address::DumpStyleResolvedDescriptionNoModule, 
-                                        Address::DumpStyleSectionNameOffset);
+                value_so_addr.Dump (&ss,
+                                    target,
+                                    Address::DumpStyleResolvedDescriptionNoModule,
+                                    Address::DumpStyleSectionNameOffset);
                 
                 if (!ss.GetString().empty())
                 {
-                    //remove_this_prior_to_checkin = ss.GetString();
-                    //if (*type_ptr)
                     m_inst->AppendComment(ss.GetString());
                 }
             }
-            //printf ("DisassemblerLLVMC::SymbolLookup (value=0x%16.16" PRIx64 ", type=%" PRIu64 ", pc=0x%16.16" PRIx64 ", name=\"%s\") m_exe_ctx=%p, m_inst=%p\n", value, *type_ptr, pc, remove_this_prior_to_checkin.c_str(), m_exe_ctx, m_inst);
         }
     }
 

Modified: lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h?rev=178315&r1=178314&r2=178315&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h (original)
+++ lldb/trunk/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h Thu Mar 28 18:42:53 2013
@@ -45,7 +45,7 @@ class DisassemblerLLVMC : public lldb_pr
         
         ~LLVMCDisassembler() {};
         
-        uint64_t GetMCInst (uint8_t *opcode_data, size_t opcode_data_len, lldb::addr_t pc, llvm::MCInst &mc_inst);
+        uint64_t GetMCInst (const uint8_t *opcode_data, size_t opcode_data_len, lldb::addr_t pc, llvm::MCInst &mc_inst);
         uint64_t PrintMCInst (llvm::MCInst &mc_inst, char *output_buffer, size_t out_buffer_len);
         bool     CanBranch (llvm::MCInst &mc_inst);
         bool     IsValid()
@@ -88,12 +88,13 @@ public:
     virtual
     ~DisassemblerLLVMC();
     
-    size_t
+    virtual size_t
     DecodeInstructions (const lldb_private::Address &base_addr,
                         const lldb_private::DataExtractor& data,
                         lldb::offset_t data_offset,
                         size_t num_instructions,
-                        bool append);
+                        bool append,
+                        bool data_from_file);
     
     //------------------------------------------------------------------
     // PluginInterface protocol
@@ -161,6 +162,7 @@ protected:
     const lldb_private::ExecutionContext *m_exe_ctx;
     InstructionLLVMC *m_inst;
     lldb_private::Mutex m_mutex;
+    bool m_data_from_file;
     
     std::auto_ptr<LLVMCDisassembler> m_disasm_ap;
     std::auto_ptr<LLVMCDisassembler> m_alternate_disasm_ap;

Modified: lldb/trunk/source/Target/ThreadPlanTracer.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/ThreadPlanTracer.cpp?rev=178315&r1=178314&r2=178315&view=diff
==============================================================================
--- lldb/trunk/source/Target/ThreadPlanTracer.cpp (original)
+++ lldb/trunk/source/Target/ThreadPlanTracer.cpp Thu Mar 28 18:42:53 2013
@@ -208,10 +208,11 @@ ThreadPlanAssemblyTracer::Log ()
                                     process_sp->GetByteOrder(), 
                                     process_sp->GetAddressByteSize());
             
+			bool data_from_file = false;
             if (addr_valid)
-                disassembler->DecodeInstructions (pc_addr, extractor, 0, 1, false);
+                disassembler->DecodeInstructions (pc_addr, extractor, 0, 1, false, data_from_file);
             else
-                disassembler->DecodeInstructions (Address (pc), extractor, 0, 1, false);
+                disassembler->DecodeInstructions (Address (pc), extractor, 0, 1, false, data_from_file);
             
             InstructionList &instruction_list = disassembler->GetInstructionList();
             const uint32_t max_opcode_byte_size = instruction_list.GetMaxOpcocdeByteSize();





More information about the lldb-commits mailing list