DBG: added fast disassembly (1million instructions per second with analysis)

x64_dbg_dbg/debugger.cpp

@@ -13,6 +13,7 @@
 #include "disasm_helper.h"
 #include "symbolinfo.h"
 #include "thread.h"
+#include "disasm_fast.h"
 
 #include "BeaEngine\BeaEngine.h"
 
@@ -1783,17 +1784,31 @@ CMDRESULT cbBenchmark(int argc, char* argv[])
     }
     dprintf("memread:%"fext"X:%ums\n", size, GetTickCount()-ticks);
     ticks=GetTickCount();
+    DISASM disasm;
+    memset(&disasm, 0, sizeof(disasm));
+#ifdef _WIN64
+    disasm.Archi=64;
+#endif // _WIN64
+    disasm.EIP=(UIntPtr)data;
+    disasm.VirtualAddr=(UInt64)data;
     uint i=0;
+    BASIC_INSTRUCTION_INFO basicinfo;
     while(i<size)
     {
-        DISASM_INSTR instr;
-        memset(&instr, 0, sizeof(instr));
-        disasmget((unsigned char*)(data+i), base+i, &instr);
-        i+=instr.instr_size;
-        count++;
+        int len=Disasm(&disasm);
+        if(len!=UNKNOWN_OPCODE)
+        {
+            //fillbasicinfo(&disasm, &basicinfo);
+            count++;
+        }
+        else
+            len=1;
+        disasm.EIP+=len;
+        disasm.VirtualAddr+=len;
+        i+=len;
     }
     efree(data);
-    dprintf("disasmget:%d:%ums\n", count, GetTickCount()-ticks);
+    dprintf("disasmget:%u:%ums\n", count, GetTickCount()-ticks);
     return STATUS_CONTINUE;
 }
 

x64_dbg_dbg/disasm_fast.cpp

@@ -0,0 +1,83 @@
+#include "disasm_fast.h"
+
+static MEMORY_SIZE argsize2memsize(int argsize)
+{
+    switch(argsize)
+    {
+    case 8:
+        return size_byte;
+    case 16:
+        return size_word;
+    case 32:
+        return size_dword;
+    case 64:
+        return size_qword;
+    }
+    return size_byte;
+}
+
+void fillbasicinfo(DISASM* disasm, BASIC_INSTRUCTION_INFO* basicinfo)
+{
+    //set type to zero
+    basicinfo->type=0;
+    //find immidiat
+    if(disasm->Instruction.BranchType==0) //no branch
+    {
+        if((disasm->Argument1.ArgType&CONSTANT_TYPE)==CONSTANT_TYPE)
+        {
+            basicinfo->type|=TYPE_VALUE;
+            basicinfo->value.value=(ULONG_PTR)disasm->Instruction.Immediat;
+            basicinfo->value.size=argsize2memsize(disasm->Argument1.ArgSize);
+        }
+        else if((disasm->Argument2.ArgType&CONSTANT_TYPE)==CONSTANT_TYPE)
+        {
+            basicinfo->type|=TYPE_VALUE;
+            basicinfo->value.value=(ULONG_PTR)disasm->Instruction.Immediat;
+            basicinfo->value.size=argsize2memsize(disasm->Argument2.ArgSize);
+        }
+    }
+    else //branch
+        basicinfo->branch=true;
+    //find memory displacement
+    if((disasm->Argument1.ArgType&MEMORY_TYPE)==MEMORY_TYPE || (disasm->Argument2.ArgType&MEMORY_TYPE)==MEMORY_TYPE)
+    {
+        if(disasm->Argument1.Memory.Displacement)
+        {
+            basicinfo->type|=TYPE_MEMORY;
+            basicinfo->memory.value=(ULONG_PTR)disasm->Argument1.Memory.Displacement;
+            strcpy(basicinfo->memory.mnemonic, disasm->Argument1.ArgMnemonic);
+            basicinfo->memory.size=argsize2memsize(disasm->Argument1.ArgSize);
+        }
+        else if(disasm->Argument2.Memory.Displacement)
+        {
+            basicinfo->type|=TYPE_MEMORY;
+            basicinfo->memory.value=(ULONG_PTR)disasm->Argument2.Memory.Displacement;
+            strcpy(basicinfo->memory.mnemonic, disasm->Argument2.ArgMnemonic);
+            basicinfo->memory.size=argsize2memsize(disasm->Argument2.ArgSize);
+        }
+    }
+    //find address value
+    if(disasm->Instruction.BranchType && disasm->Instruction.AddrValue)
+    {
+        basicinfo->type|=TYPE_ADDR;
+        basicinfo->addr=(ULONG_PTR)disasm->Instruction.AddrValue;
+    }
+    //rip-relative (non-branch)
+    if(disasm->Instruction.BranchType==0)
+    {
+        if((disasm->Argument1.ArgType&RELATIVE_)==RELATIVE_)
+        {
+            basicinfo->type|=TYPE_MEMORY;
+            basicinfo->memory.value=(ULONG_PTR)disasm->Instruction.AddrValue;
+            strcpy(basicinfo->memory.mnemonic, disasm->Argument1.ArgMnemonic);
+            basicinfo->memory.size=argsize2memsize(disasm->Argument1.ArgSize);
+        }
+        else if((disasm->Argument2.ArgType&RELATIVE_)==RELATIVE_)
+        {
+            basicinfo->type|=TYPE_MEMORY;
+            basicinfo->memory.value=(ULONG_PTR)disasm->Instruction.AddrValue;
+            strcpy(basicinfo->memory.mnemonic, disasm->Argument2.ArgMnemonic);
+            basicinfo->memory.size=argsize2memsize(disasm->Argument2.ArgSize);
+        }
+    }
+}

x64_dbg_dbg/disasm_fast.h

@@ -0,0 +1,46 @@
+#ifndef _DISASM_FAST_H
+
+#include "_global.h"
+#include "BeaEngine\BeaEngine.h"
+
+#define TYPE_VALUE 1
+#define TYPE_MEMORY 2
+#define TYPE_ADDR 4
+
+#define MAX_MNEMONIC_SIZE 64
+
+enum MEMORY_SIZE
+{
+    size_byte,
+    size_word,
+    size_dword,
+    size_qword
+};
+
+typedef MEMORY_SIZE VALUE_SIZE;
+
+struct MEMORY_INFO
+{
+    ULONG_PTR value; //displacement / addrvalue (rip-relative)
+    MEMORY_SIZE size; //byte/word/dword/qword
+    char mnemonic[MAX_MNEMONIC_SIZE];
+};
+
+struct VALUE_INFO
+{
+    ULONG_PTR value;
+    VALUE_SIZE size;
+};
+
+struct BASIC_INSTRUCTION_INFO
+{
+    DWORD type; //value|memory|addr
+    VALUE_INFO value; //immediat
+    MEMORY_INFO memory;
+    ULONG_PTR addr; //addrvalue (jumps + calls)
+    bool branch; //jumps/calls
+};
+
+void fillbasicinfo(DISASM* disasm, BASIC_INSTRUCTION_INFO* basicinfo);
+
+#endif //_DISASM_FAST_H

x64_dbg_dbg/x64_dbg_dbg.cbp

@@ -95,6 +95,8 @@
 		<Unit filename="dbghelp/dbghelp.h" />
 		<Unit filename="debugger.cpp" />
 		<Unit filename="debugger.h" />
+		<Unit filename="disasm_fast.cpp" />
+		<Unit filename="disasm_fast.h" />
 		<Unit filename="disasm_helper.cpp" />
 		<Unit filename="disasm_helper.h" />
 		<Unit filename="instruction.cpp" />
@@ -121,6 +123,7 @@
 		<Unit filename="thread.h" />
 		<Unit filename="threading.cpp" />
 		<Unit filename="threading.h" />
+		<Unit filename="undocumented.h" />
 		<Unit filename="value.cpp" />
 		<Unit filename="value.h" />
 		<Unit filename="variable.cpp" />

x64_dbg_dbg/x64_dbg_dbg.vcxproj

@@ -18,6 +18,7 @@
     <ClCompile Include="command.cpp" />
     <ClCompile Include="console.cpp" />
     <ClCompile Include="debugger.cpp" />
+    <ClCompile Include="disasm_fast.cpp" />
     <ClCompile Include="disasm_helper.cpp" />
     <ClCompile Include="instruction.cpp" />
     <ClCompile Include="main.cpp" />
@@ -48,6 +49,7 @@
     <ClInclude Include="data.h" />
     <ClInclude Include="dbg.h" />
     <ClInclude Include="debugger.h" />
+    <ClInclude Include="disasm_fast.h" />
     <ClInclude Include="disasm_helper.h" />
     <ClInclude Include="instruction.h" />
     <ClInclude Include="math.h" />

x64_dbg_dbg/x64_dbg_dbg.vcxproj.filters

@@ -93,6 +93,9 @@
     <ClCompile Include="thread.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="disasm_fast.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="_exports.h">
@@ -182,5 +185,8 @@
     <ClInclude Include="undocumented.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="disasm_fast.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>