Fixed size register & mnemonic copying

Author: gdabah

disOps/disOps.py

@@ -1,7 +1,7 @@
 #
 # disOps.py v 1.0.0
 #
-# Copyright (C) 2003-2018 Gil Dabah, http://ragestorm.net/distorm/
+# Copyright (C) 2003-2020 Gil Dabah, http://ragestorm.net/distorm/
 #
 # disOps is a part of the diStorm project, but can be used for anything.
 # The generated output is tightly coupled with diStorm data structures which can be found at instructions.h.
@@ -80,7 +80,8 @@ def CreateMnemonicsC(mnemonicsIds):
 		s += "\"\\\\x%02x\" \"%s\\\\0\" " % (len(i[0]), i[0])
 		if len(s) - s.rfind("\n") >= 76:
 			s += "\\\\\n"
-	s = s[:-1] + ";" # Ignore last space.
+	s = s[:-1] # Ignore last space.
+	s += " \\\\\\n\"" + "\\\\x00" * 20 + "\"; /* Sentinel mnemonic. */"
 	# Return enum & mnemonics.
 	return (opsEnum, s)
 
@@ -133,7 +134,7 @@ def WriteMnemonicsC(mnemonicsIds):
 	path = os.path.join("..", "src", "mnemonics.c")
 	print("- Try rewriting mnemonics for %s." % path)
 	old = open(path, "r").read()
-	rePattern = "const unsigned char _MNEMONICS\[\] =.*?;"
+	rePattern = "const unsigned char _MNEMONICS\[\] =.*?\*/"
 	if re.compile(rePattern, reFlags).search(old) == None:
 		raise Exception("Couldn't find matching mnemonics text block for substitution in " + path)
 	new = re.sub(rePattern, m, old, 1, reFlags)

disOps/registers.py

@@ -36,7 +36,7 @@
 				regsText += " "
 				regsEnum += " "
 	old = i
-regsText += "{%d, \"%s\"}\n};\n" % (len(old), old)
+regsText += "{%d, \"%s\"},\n\t{0, \"\"} /* There must be an empty last reg see, strcat_WSR. */\n};\n" % (len(old), old)
 regsEnum += "R_" + old + "\n} _RegisterType;\n"
 
 print(regsEnum)

include/mnemonics.h

@@ -25,7 +25,7 @@ typedef struct WMnemonic {
 
 typedef struct WRegister {
 	unsigned int length;
-	unsigned char p[6]; /* p is a null terminated string. */
+	unsigned char p[12]; /* p is a null terminated string. */
 } _WRegister;
 
 extern const unsigned char _MNEMONICS[];

src/distorm.c

@@ -192,7 +192,7 @@ static void distorm_format_signed_disp(_WString* str, const _DInst* di, uint64_t
 		switch (di->ops[i].type)
 		{
 			case O_REG:
-				strcat_WS(str, (const _WString*)&_REGISTERS[di->ops[i].index]);
+				strcat_WSR(str, &_REGISTERS[di->ops[i].index]);
 			break;
 			case O_IMM:
 				/* If the instruction is 'push', show explicit size (except byte imm). */
@@ -218,7 +218,7 @@ static void distorm_format_signed_disp(_WString* str, const _DInst* di, uint64_t
 				distorm_format_size(str, di, i);
 				chrcat_WS(str, OPEN_CHR);
 				if ((SEGMENT_GET(di->segment) != R_NONE) && !SEGMENT_IS_DEFAULT(di->segment)) {
-					strcat_WS(str, (const _WString*)&_REGISTERS[SEGMENT_GET(di->segment)]);
+					strcat_WSR(str, &_REGISTERS[SEGMENT_GET(di->segment)]);
 					chrcat_WS(str, SEG_OFF_CHR);
 				}
 				tmpDisp64 = di->disp & addrMask;
@@ -254,11 +254,11 @@ static void distorm_format_signed_disp(_WString* str, const _DInst* di, uint64_t
 					case I_SCAS: isDefault = FALSE; break;
 				}
 				if (!isDefault && (segment != R_NONE)) {
-					strcat_WS(str, (const _WString*)&_REGISTERS[segment]);
+					strcat_WSR(str, &_REGISTERS[segment]);
 					chrcat_WS(str, SEG_OFF_CHR);
 				}
 
-				strcat_WS(str, (const _WString*)&_REGISTERS[di->ops[i].index]);
+				strcat_WSR(str, &_REGISTERS[di->ops[i].index]);
 
 				distorm_format_signed_disp(str, di, addrMask);
 				chrcat_WS(str, CLOSE_CHR);
@@ -267,14 +267,14 @@ static void distorm_format_signed_disp(_WString* str, const _DInst* di, uint64_t
 				distorm_format_size(str, di, i);
 				chrcat_WS(str, OPEN_CHR);
 				if ((SEGMENT_GET(di->segment) != R_NONE) && !SEGMENT_IS_DEFAULT(di->segment)) {
-					strcat_WS(str, (const _WString*)&_REGISTERS[SEGMENT_GET(di->segment)]);
+					strcat_WSR(str, &_REGISTERS[SEGMENT_GET(di->segment)]);
 					chrcat_WS(str, SEG_OFF_CHR);
 				}
 				if (di->base != R_NONE) {
-					strcat_WS(str, (const _WString*)&_REGISTERS[di->base]);
+					strcat_WSR(str, &_REGISTERS[di->base]);
 					chrcat_WS(str, PLUS_DISP_CHR);
 				}
-				strcat_WS(str, (const _WString*)&_REGISTERS[di->ops[i].index]);
+				strcat_WSR(str, &_REGISTERS[di->ops[i].index]);
 				if (di->scale != 0) {
 					chrcat_WS(str, '*');
 					if (di->scale == 2) chrcat_WS(str, '2');
@@ -334,7 +334,12 @@ static void distorm_format_signed_disp(_WString* str, const _DInst* di, uint64_t
 			str->length = 0;
 		}
 
-		memcpy((int8_t*)&str->p[str->length], mnemonic->p, mnemonic->length + 1);
+		/*
+		 * Always copy 16 bytes from the mnemonic, we have a sentinel padding so we can read past.
+		 * This helps the compiler to remove the call to memcpy and therefore makes this copying much faster.
+		 * The longest instruction is exactly 16 chars long, but we null terminate the string below.
+		 */
+		memcpy((int8_t*)&str->p[str->length], mnemonic->p, 16);
 		str->length += mnemonic->length;
 
 		if (suffixSize) {
@@ -347,6 +352,8 @@ static void distorm_format_signed_disp(_WString* str, const _DInst* di, uint64_t
 			}
 		}
 
+		str->p[str->length] = 0;
+
 		result->offset = offset;
 		result->size = size;
 	}

src/insts.c

@@ -15,7 +15,7 @@ This library is licensed under the BSD license. See the file COPYING.
 
 
 /*
- * GENERATED BY disOps at Tue Apr 21 19:11:41 2020
+ * GENERATED BY disOps at Tue Apr 21 23:47:49 2020
  */
 
 _InstInfo II_MOVSXD =	/*II*/ {0x1d4, 10027};

src/mnemonics.c

@@ -291,22 +291,24 @@ const unsigned char _MNEMONICS[] =
 "\x08" "RDGSBASE\0" "\x07" "LDMXCSR\0" "\x08" "WRFSBASE\0" "\x08" "VLDMXCSR\0" \
 "\x07" "STMXCSR\0" "\x08" "WRGSBASE\0" "\x08" "VSTMXCSR\0" "\x07" "VMPTRLD\0" \
 "\x07" "VMCLEAR\0" "\x05" "VMXON\0" "\x06" "MOVSXD\0" "\x05" "PAUSE\0" \
-"\x04" "WAIT\0" "\x06" "RDRAND\0" "\x06" "_3DNOW\0";
+"\x04" "WAIT\0" "\x06" "RDRAND\0" "\x06" "_3DNOW\0" \
+"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"; /* Sentinel mnemonic. */
 
 const _WRegister _REGISTERS[] = {
-	{ 3, "RAX" }, { 3, "RCX" }, { 3, "RDX" }, { 3, "RBX" }, { 3, "RSP" }, { 3, "RBP" }, { 3, "RSI" }, { 3, "RDI" }, { 2, "R8" }, { 2, "R9" }, { 3, "R10" }, { 3, "R11" }, { 3, "R12" }, { 3, "R13" }, { 3, "R14" }, { 3, "R15" },
-	{ 3, "EAX" }, { 3, "ECX" }, { 3, "EDX" }, { 3, "EBX" }, { 3, "ESP" }, { 3, "EBP" }, { 3, "ESI" }, { 3, "EDI" }, { 3, "R8D" }, { 3, "R9D" }, { 4, "R10D" }, { 4, "R11D" }, { 4, "R12D" }, { 4, "R13D" }, { 4, "R14D" }, { 4, "R15D" },
-	{ 2, "AX" }, { 2, "CX" }, { 2, "DX" }, { 2, "BX" }, { 2, "SP" }, { 2, "BP" }, { 2, "SI" }, { 2, "DI" }, { 3, "R8W" }, { 3, "R9W" }, { 4, "R10W" }, { 4, "R11W" }, { 4, "R12W" }, { 4, "R13W" }, { 4, "R14W" }, { 4, "R15W" },
-	{ 2, "AL" }, { 2, "CL" }, { 2, "DL" }, { 2, "BL" }, { 2, "AH" }, { 2, "CH" }, { 2, "DH" }, { 2, "BH" }, { 3, "R8B" }, { 3, "R9B" }, { 4, "R10B" }, { 4, "R11B" }, { 4, "R12B" }, { 4, "R13B" }, { 4, "R14B" }, { 4, "R15B" },
-	{ 3, "SPL" }, { 3, "BPL" }, { 3, "SIL" }, { 3, "DIL" },
-	{ 2, "ES" }, { 2, "CS" }, { 2, "SS" }, { 2, "DS" }, { 2, "FS" }, { 2, "GS" },
-	{ 3, "RIP" },
-	{ 3, "ST0" }, { 3, "ST1" }, { 3, "ST2" }, { 3, "ST3" }, { 3, "ST4" }, { 3, "ST5" }, { 3, "ST6" }, { 3, "ST7" },
-	{ 3, "MM0" }, { 3, "MM1" }, { 3, "MM2" }, { 3, "MM3" }, { 3, "MM4" }, { 3, "MM5" }, { 3, "MM6" }, { 3, "MM7" },
-	{ 4, "XMM0" }, { 4, "XMM1" }, { 4, "XMM2" }, { 4, "XMM3" }, { 4, "XMM4" }, { 4, "XMM5" }, { 4, "XMM6" }, { 4, "XMM7" }, { 4, "XMM8" }, { 4, "XMM9" }, { 5, "XMM10" }, { 5, "XMM11" }, { 5, "XMM12" }, { 5, "XMM13" }, { 5, "XMM14" }, { 5, "XMM15" },
-	{ 4, "YMM0" }, { 4, "YMM1" }, { 4, "YMM2" }, { 4, "YMM3" }, { 4, "YMM4" }, { 4, "YMM5" }, { 4, "YMM6" }, { 4, "YMM7" }, { 4, "YMM8" }, { 4, "YMM9" }, { 5, "YMM10" }, { 5, "YMM11" }, { 5, "YMM12" }, { 5, "YMM13" }, { 5, "YMM14" }, { 5, "YMM15" },
-	{ 3, "CR0" }, { 0, "" }, { 3, "CR2" }, { 3, "CR3" }, { 3, "CR4" }, { 0, "" }, { 0, "" }, { 0, "" }, { 3, "CR8" },
-	{ 3, "DR0" }, { 3, "DR1" }, { 3, "DR2" }, { 3, "DR3" }, { 0, "" }, { 0, "" }, { 3, "DR6" }, { 3, "DR7" }
+	{3, "RAX"}, {3, "RCX"}, {3, "RDX"}, {3, "RBX"}, {3, "RSP"}, {3, "RBP"}, {3, "RSI"}, {3, "RDI"}, {2, "R8"}, {2, "R9"}, {3, "R10"}, {3, "R11"}, {3, "R12"}, {3, "R13"}, {3, "R14"}, {3, "R15"},
+	{3, "EAX"}, {3, "ECX"}, {3, "EDX"}, {3, "EBX"}, {3, "ESP"}, {3, "EBP"}, {3, "ESI"}, {3, "EDI"}, {3, "R8D"}, {3, "R9D"}, {4, "R10D"}, {4, "R11D"}, {4, "R12D"}, {4, "R13D"}, {4, "R14D"}, {4, "R15D"},
+	{2, "AX"}, {2, "CX"}, {2, "DX"}, {2, "BX"}, {2, "SP"}, {2, "BP"}, {2, "SI"}, {2, "DI"}, {3, "R8W"}, {3, "R9W"}, {4, "R10W"}, {4, "R11W"}, {4, "R12W"}, {4, "R13W"}, {4, "R14W"}, {4, "R15W"},
+	{2, "AL"}, {2, "CL"}, {2, "DL"}, {2, "BL"}, {2, "AH"}, {2, "CH"}, {2, "DH"}, {2, "BH"}, {3, "R8B"}, {3, "R9B"}, {4, "R10B"}, {4, "R11B"}, {4, "R12B"}, {4, "R13B"}, {4, "R14B"}, {4, "R15B"},
+	{3, "SPL"}, {3, "BPL"}, {3, "SIL"}, {3, "DIL"},
+	{2, "ES"}, {2, "CS"}, {2, "SS"}, {2, "DS"}, {2, "FS"}, {2, "GS"},
+	{3, "RIP"},
+	{3, "ST0"}, {3, "ST1"}, {3, "ST2"}, {3, "ST3"}, {3, "ST4"}, {3, "ST5"}, {3, "ST6"}, {3, "ST7"},
+	{3, "MM0"}, {3, "MM1"}, {3, "MM2"}, {3, "MM3"}, {3, "MM4"}, {3, "MM5"}, {3, "MM6"}, {3, "MM7"},
+	{4, "XMM0"}, {4, "XMM1"}, {4, "XMM2"}, {4, "XMM3"}, {4, "XMM4"}, {4, "XMM5"}, {4, "XMM6"}, {4, "XMM7"}, {4, "XMM8"}, {4, "XMM9"}, {5, "XMM10"}, {5, "XMM11"}, {5, "XMM12"}, {5, "XMM13"}, {5, "XMM14"}, {5, "XMM15"},
+	{4, "YMM0"}, {4, "YMM1"}, {4, "YMM2"}, {4, "YMM3"}, {4, "YMM4"}, {4, "YMM5"}, {4, "YMM6"}, {4, "YMM7"}, {4, "YMM8"}, {4, "YMM9"}, {5, "YMM10"}, {5, "YMM11"}, {5, "YMM12"}, {5, "YMM13"}, {5, "YMM14"}, {5, "YMM15"},
+	{3, "CR0"}, {0, ""}, {3, "CR2"}, {3, "CR3"}, {3, "CR4"}, {0, ""}, {0, ""}, {0, ""}, {3, "CR8"},
+	{3, "DR0"}, {3, "DR1"}, {3, "DR2"}, {3, "DR3"}, {0, ""}, {0, ""}, {3, "DR6"}, {3, "DR7"},
+	{0, ""} /* There must be an empty last reg see, strcat_WSR. */
 };
 
 #endif /* DISTORM_LIGHT */

src/wstring.h

@@ -13,6 +13,7 @@ This library is licensed under the BSD license. See the file COPYING.
 #define WSTRING_H
 
 #include "config.h"
+#include "../include/mnemonics.h"
 
 #ifndef DISTORM_LIGHT
 
@@ -22,6 +23,18 @@ void strcpylen_WS(_WString* s, const int8_t* buf, unsigned int len);
 void strcatlen_WS(_WString* s, const int8_t* buf, unsigned int len);
 void strcat_WS(_WString* s, const _WString* s2);
 
+_INLINE_ void strcat_WSR(_WString* str, const _WRegister* reg)
+{
+	/*
+	 * Longest register name is YMM15 - 5 characters,
+	 * copy 8 so compiler can do a QWORD move.
+	 * We copy nul termination and fix the length, so it's okay to copy more to the output buffer.
+	 * There's a sentinel register to make sure we don't read past the end of the registers table.
+	 */
+	memcpy((int8_t*)&str->p[str->length], (const int8_t*)reg->p, 8);
+	str->length += reg->length;
+}
+
 /*
 * Warning, this macro should be used only when the compiler knows the size of string in advance!
 * This macro is used in order to spare the call to strlen when the strings are known already.