<rdar://problem/11330621>

Fixed the DisassemblerLLVMC disassembler to parse more efficiently instead of parsing opcodes over and over. The InstructionLLVMC class now only reads the opcode in the InstructionLLVMC::Decode function. This can be done very efficiently for ARM and architectures that have fixed opcode sizes. For x64 it still calls the disassembler to get the byte size.

Moved the lldb_private::Instruction::Dump(...) function up into the lldb_private::Instruction class and it now uses the function that gets the mnemonic, operandes and comments so that all disassembly is using the same code.

Added StreamString::FillLastLineToColumn() to allow filling a line up to a column with a character (which is used by the lldb_private::Instruction::Dump(...) function).

Modified the Opcode::GetData() fucntion to "do the right thing" for thumb instructions.



git-svn-id: https://llvm.org/svn/llvm-project/lldb/trunk@156532 91177308-0d34-0410-b5e6-96231b3b80d8

Author: Greg Clayton

include/lldb/Core/Disassembler.h

@@ -42,27 +42,27 @@ class Instruction
     }
 
     const char *
-    GetMnemonic (ExecutionContextScope *exe_scope)
+    GetMnemonic (const ExecutionContext* exe_ctx)
     {
-        CalculateMnemonicOperandsAndCommentIfNeeded (exe_scope);
+        CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
         return m_opcode_name.c_str();
     }
     const char *
-    GetOperands (ExecutionContextScope *exe_scope)
+    GetOperands (const ExecutionContext* exe_ctx)
     {
-        CalculateMnemonicOperandsAndCommentIfNeeded (exe_scope);
+        CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
         return m_mnemocics.c_str();
     }
 
     const char *
-    GetComment (ExecutionContextScope *exe_scope)
+    GetComment (const ExecutionContext* exe_ctx)
     {
-        CalculateMnemonicOperandsAndCommentIfNeeded (exe_scope);
+        CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
         return m_comment.c_str();
     }
 
     virtual void
-    CalculateMnemonicOperandsAndComment (ExecutionContextScope *exe_scope) = 0;
+    CalculateMnemonicOperandsAndComment (const ExecutionContext* exe_ctx) = 0;
 
     lldb::AddressClass
     GetAddressClass ();
@@ -81,8 +81,7 @@ class Instruction
           uint32_t max_opcode_byte_size,
           bool show_address,
           bool show_bytes,
-          const ExecutionContext *exe_ctx, 
-          bool raw) = 0;
+          const ExecutionContext* exe_ctx);
 
     virtual bool
     DoesBranch () const = 0;
@@ -121,6 +120,9 @@ class Instruction
     {
         return m_opcode;
     }
+    
+    uint32_t
+    GetData (DataExtractor &data);
 
 protected:
     Address m_address; // The section offset address of this instruction
@@ -130,20 +132,22 @@ class Instruction
     // The usual value will be eAddressClassCode, but often when
     // disassembling memory, you might run into data. This can
     // help us to disassemble appropriately.
-    lldb::AddressClass m_address_class;
+private:
+    lldb::AddressClass m_address_class; // Use GetAddressClass () accessor function!
+protected:
     Opcode m_opcode; // The opcode for this instruction
     std::string m_opcode_name;
     std::string m_mnemocics;
     std::string m_comment;
     bool m_calculated_strings;
 
     void
-    CalculateMnemonicOperandsAndCommentIfNeeded (ExecutionContextScope *exe_scope)
+    CalculateMnemonicOperandsAndCommentIfNeeded (const ExecutionContext* exe_ctx)
     {
         if (!m_calculated_strings)
         {
             m_calculated_strings = true;
-            CalculateMnemonicOperandsAndComment(exe_scope);
+            CalculateMnemonicOperandsAndComment(exe_ctx);
         }
     }
 };
@@ -200,19 +204,11 @@ class PseudoInstruction :
      virtual
      ~PseudoInstruction ();
 
-    virtual void
-    Dump (Stream *s,
-          uint32_t max_opcode_byte_size,
-          bool show_address,
-          bool show_bytes,
-          const ExecutionContext* exe_ctx,
-          bool raw);
-    
     virtual bool
     DoesBranch () const;
 
     virtual void
-    CalculateMnemonicOperandsAndComment (ExecutionContextScope *exe_scope)
+    CalculateMnemonicOperandsAndComment (const ExecutionContext* exe_ctx)
     {
         // TODO: fill this in and put opcode name into Instruction::m_opcode_name,
         // mnemonic into Instruction::m_mnemonics, and any comment into 

include/lldb/Core/Opcode.h

@@ -67,6 +67,11 @@ namespace lldb_private {
             SetOpcodeBytes (bytes, length);
         }
 
+        void
+        Clear()
+        {
+            m_type = Opcode::eTypeInvalid;
+        }
         Opcode::Type
         GetType () const
         {
@@ -205,9 +210,10 @@ namespace lldb_private {
             return 0;
         }
 
+        // Get the opcode exactly as it would be laid out in memory.
         uint32_t
-        GetData (DataExtractor &data) const;
-
+        GetData (DataExtractor &data,
+                 lldb::AddressClass address_class) const;
 
     protected:
 
@@ -240,8 +246,8 @@ namespace lldb_private {
             uint64_t inst64;
             struct 
             {
-                uint8_t length;
                 uint8_t bytes[16]; // This must be big enough to handle any opcode for any supported target.
+                uint8_t length;
             } inst;
         } m_data;
     };

include/lldb/Core/StreamString.h

@@ -49,6 +49,9 @@ class StreamString : public Stream
     const std::string &
     GetString() const;
 
+    void
+    FillLastLineToColumn (uint32_t column, char fill_char);
+
 protected:
     std::string m_packet;
 

lldb.xcodeproj/xcshareddata/xcschemes/lldb-tool.xcscheme

@@ -106,8 +106,8 @@
             isEnabled = "NO">
          </CommandLineArgument>
          <CommandLineArgument
-            argument = "/Volumes/work/gclayton/Documents/devb/attach/a.out"
-            isEnabled = "NO">
+            argument = "~/Documents/src/args/a.out"
+            isEnabled = "YES">
          </CommandLineArgument>
          <CommandLineArgument
             argument = "/bin/cat"

source/API/SBInstruction.cpp

@@ -82,7 +82,7 @@ SBInstruction::GetMnemonic(SBTarget target)
             target_sp->CalculateExecutionContext (exe_ctx);
             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
         }
-        return m_opaque_sp->GetMnemonic(exe_ctx.GetBestExecutionContextScope());
+        return m_opaque_sp->GetMnemonic(&exe_ctx);
     }
     return NULL;
 }
@@ -101,7 +101,7 @@ SBInstruction::GetOperands(SBTarget target)
             target_sp->CalculateExecutionContext (exe_ctx);
             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
         }
-        return m_opaque_sp->GetOperands(exe_ctx.GetBestExecutionContextScope());
+        return m_opaque_sp->GetOperands(&exe_ctx);
     }
     return NULL;
 }
@@ -120,7 +120,7 @@ SBInstruction::GetComment(SBTarget target)
             target_sp->CalculateExecutionContext (exe_ctx);
             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
         }
-        return m_opaque_sp->GetComment(exe_ctx.GetBestExecutionContextScope());
+        return m_opaque_sp->GetComment(&exe_ctx);
     }
     return NULL;
 }
@@ -140,7 +140,7 @@ SBInstruction::GetData (SBTarget target)
     if (m_opaque_sp)
     {
         DataExtractorSP data_extractor_sp (new DataExtractor());
-        if (m_opaque_sp->GetOpcode().GetData (*data_extractor_sp))
+        if (m_opaque_sp->GetData (*data_extractor_sp))
         {
             sb_data.SetOpaque (data_extractor_sp);
         }
@@ -171,7 +171,7 @@ SBInstruction::GetDescription (lldb::SBStream &s)
     {
         // Use the "ref()" instead of the "get()" accessor in case the SBStream 
         // didn't have a stream already created, one will get created...
-        m_opaque_sp->Dump (&s.ref(), 0, true, false, NULL, false);
+        m_opaque_sp->Dump (&s.ref(), 0, true, false, NULL);
         return true;
     }
     return false;
@@ -186,7 +186,7 @@ SBInstruction::Print (FILE *out)
     if (m_opaque_sp)
     {
         StreamFile out_stream (out, false);
-        m_opaque_sp->Dump (&out_stream, 0, true, false, NULL, false);
+        m_opaque_sp->Dump (&out_stream, 0, true, false, NULL);
     }
 }
 

source/API/SBInstructionList.cpp

@@ -105,7 +105,7 @@ SBInstructionList::GetDescription (lldb::SBStream &description)
                 Instruction *inst = m_opaque_sp->GetInstructionList().GetInstructionAtIndex (i).get();
                 if (inst == NULL)
                     break;
-                inst->Dump (&sref, max_opcode_byte_size, true, false, NULL, false);
+                inst->Dump (&sref, max_opcode_byte_size, true, false, NULL);
                 sref.EOL();
             }
             return true;

source/Core/Disassembler.cpp

@@ -448,8 +448,7 @@ Disassembler::PrintInstructions
                 strm.PutCString(inst_is_at_pc ? "-> " : "   ");
             }
             const bool show_bytes = (options & eOptionShowBytes) != 0;
-            const bool raw = (options & eOptionRawOuput) != 0;
-            inst->Dump(&strm, max_opcode_byte_size, true, show_bytes, &exe_ctx, raw);
+            inst->Dump(&strm, max_opcode_byte_size, true, show_bytes, &exe_ctx);
             strm.EOL();            
         }
         else
@@ -529,6 +528,69 @@ Instruction::GetAddressClass ()
     return m_address_class;
 }
 
+void
+Instruction::Dump (lldb_private::Stream *s,
+                   uint32_t max_opcode_byte_size,
+                   bool show_address,
+                   bool show_bytes,
+                   const ExecutionContext* exe_ctx)
+{
+    const size_t opcode_column_width = 7;
+    const size_t operand_column_width = 25;
+    
+    CalculateMnemonicOperandsAndCommentIfNeeded (exe_ctx);
+
+    StreamString ss;
+    
+    if (show_address)
+    {
+        m_address.Dump(&ss,
+                       exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL,
+                       Address::DumpStyleLoadAddress,
+                       Address::DumpStyleModuleWithFileAddress,
+                       0);
+        
+        ss.PutCString(":  ");
+    }
+    
+    if (show_bytes)
+    {
+        if (m_opcode.GetType() == Opcode::eTypeBytes)
+        {
+            // x86_64 and i386 are the only ones that use bytes right now so
+            // pad out the byte dump to be able to always show 15 bytes (3 chars each) 
+            // plus a space
+            if (max_opcode_byte_size > 0)
+                m_opcode.Dump (&ss, max_opcode_byte_size * 3 + 1);
+            else
+                m_opcode.Dump (&ss, 15 * 3 + 1);
+        }
+        else
+        {
+            // Else, we have ARM which can show up to a uint32_t 0x00000000 (10 spaces)
+            // plus two for padding...
+            if (max_opcode_byte_size > 0)
+                m_opcode.Dump (&ss, max_opcode_byte_size * 3 + 1);
+            else
+                m_opcode.Dump (&ss, 12);
+        }        
+    }
+    
+    const size_t opcode_pos = ss.GetSize();
+    
+    ss.PutCString (m_opcode_name.c_str());
+    ss.FillLastLineToColumn (opcode_pos + opcode_column_width, ' ');
+    ss.PutCString (m_mnemocics.c_str());
+    
+    if (!m_comment.empty())
+    {
+        ss.FillLastLineToColumn (opcode_pos + opcode_column_width + operand_column_width, ' ');        
+        ss.PutCString (" ; ");
+        ss.PutCString (m_comment.c_str());
+    }
+    s->Write (ss.GetData(), ss.GetSize());
+}
+
 bool
 Instruction::DumpEmulation (const ArchSpec &arch)
 {
@@ -828,6 +890,13 @@ Instruction::Emulate (const ArchSpec &arch,
     return false;
 }
 
+
+uint32_t
+Instruction::GetData (DataExtractor &data)
+{
+    return m_opcode.GetData(data, GetAddressClass ());
+}
+
 InstructionList::InstructionList() :
     m_instructions()
 {
@@ -884,7 +953,7 @@ InstructionList::Dump (Stream *s,
     {
         if (pos != begin)
             s->EOL();
-        (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, exe_ctx, false);
+        (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, exe_ctx);
     }
 }
 
@@ -1065,27 +1134,6 @@ PseudoInstruction::~PseudoInstruction ()
 {
 }
 
-void
-PseudoInstruction::Dump (lldb_private::Stream *s,
-                        uint32_t max_opcode_byte_size,
-                        bool show_address,
-                        bool show_bytes,
-                        const lldb_private::ExecutionContext* exe_ctx,
-                        bool raw)
-{
-    if (!s)
-        return;
-        
-    if (show_bytes)
-        m_opcode.Dump (s, max_opcode_byte_size);
-    
-    if (m_description.size() > 0)
-        s->Printf ("%s", m_description.c_str());
-    else
-        s->Printf ("<unknown>");
-        
-}
-    
 bool
 PseudoInstruction::DoesBranch () const
 {