Added performance test

CMakeLists.txt

@@ -145,4 +145,9 @@ if (ZYDIS_BUILD_TOOLS)
     target_link_libraries("ZydisFuzzIn" "Zydis")
     set_target_properties("ZydisFuzzIn" PROPERTIES FOLDER "Tools")
     target_compile_definitions("ZydisFuzzIn" PRIVATE "_CRT_SECURE_NO_WARNINGS")
+
+    add_executable("PerfTest" "tools/PerfTest.c")
+    target_link_libraries("PerfTest" "Zydis")
+    set_target_properties("PerfTest" PROPERTIES FOLDER "Tools")
+    target_compile_definitions("PerfTest" PRIVATE "_CRT_SECURE_NO_WARNINGS")
 endif ()

include/Zydis/Decoder.h

@@ -52,10 +52,20 @@ enum ZydisDecodeGranularities
 {
     ZYDIS_DECODE_GRANULARITY_DEFAULT,
     /**
-     * @brief   Minimal instruction decoding without semantic operand analysis.
+     * @brief   Minimal instruction decoding without semantic analysis.
+     * 
+     * This mode should be sufficient, if you plan to analyse code for pure relocation purposes, 
+     * as it gives you access to the mnemonic, the instruction-length, displacements, immediates 
+     * and even the `ZYDIS_ATTRIB_IS_RELATIVE`.
+     * 
+     * Operands, most attributes and other specific information (like AVX info) are not 
+     * accessible in this mode.
      */
-    ZYDIS_DECODE_GRANULARITY_MINIMAL,
+    ZYDIS_DECODE_GRANULARITY_PHYSICAL,
-    ZYDIS_DECODE_GRANULARITY_FULL
+    /**
+     * @brief   Full physical and semantical instruction-decoding.
+     */
+    ZYDIS_DECODE_GRANULARITY_SEMANTIC
 };
 
 /**

src/Decoder.c

@@ -214,9 +214,6 @@ enum ZydisRegisterEncodings
  *
  * @return  A zydis status code.
  * 
- * If not empty, the internal buffer of the @c ZydisDecoderContext instance is used as temporary
- * data-source, instead of reading the byte from the actual input data-source.
- * 
  * This function may fail, if the @c ZYDIS_MAX_INSTRUCTION_LENGTH limit got exceeded, or no more   
  * data is available.
  */
@@ -249,10 +246,7 @@ static ZydisStatus ZydisInputPeek(ZydisDecoderContext* context,
  *                  
  * This function is supposed to get called ONLY after a successfull call of @c ZydisInputPeek.
  * 
- * If not empty, the read-position of the @c ZydisDecoderContext instances internal buffer is
+ * This function increases the @c length field of the @c ZydisDecodedInstruction struct by one and
- * increased, instead of the actual input data-sources read-position.
- * 
- * This function increases the @c length field of the @c ZydisInstructionInfo struct by one and
  * adds the current byte to the @c data array.
  */
 static void ZydisInputSkip(ZydisDecoderContext* context, ZydisDecodedInstruction* instruction)
@@ -3140,7 +3134,7 @@ static ZydisStatus ZydisCollectOptionalPrefixes(ZydisDecoderContext* context,
  * 
  * @return  A zydis status code.
  */
-static ZydisStatus ZydisDecodeOptionalInstructionParts(ZydisDecoderContext* context, 
+static ZydisStatus ZydisDecodeInstructionPhysical(ZydisDecoderContext* context, 
     ZydisDecodedInstruction* instruction, const ZydisInstructionParts* optionalParts)
 {
     ZYDIS_ASSERT(context);
@@ -4266,8 +4260,7 @@ static ZydisStatus ZydisDecodeInstruction(ZydisDecoderContext* context,
 
                 const ZydisInstructionParts* optionalParts;
                 ZydisGetOptionalInstructionParts(node, &optionalParts);
-                ZYDIS_CHECK(
+                ZYDIS_CHECK(ZydisDecodeInstructionPhysical(context, instruction, optionalParts));
-                    ZydisDecodeOptionalInstructionParts(context, instruction, optionalParts));
 
                 if (instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_3DNOW)
                 {
@@ -4291,7 +4284,7 @@ static ZydisStatus ZydisDecodeInstruction(ZydisDecoderContext* context,
 
                 instruction->mnemonic = definition->mnemonic;
 
-                if (context->decoder->decodeGranularity == ZYDIS_DECODE_GRANULARITY_FULL)
+                if (context->decoder->decodeGranularity == ZYDIS_DECODE_GRANULARITY_SEMANTIC)
                 {
                     ZydisSetPrefixRelatedAttributes(context, instruction, definition);
                     switch (instruction->encoding)
@@ -4335,14 +4328,17 @@ ZydisStatus ZydisDecoderInitEx(ZydisDecoder* decoder, ZydisMachineMode machineMo
 {
     if (!decoder || ((machineMode != 16) && (machineMode != 32) && (machineMode != 64)) ||
         ((decodeGranularity != ZYDIS_DECODE_GRANULARITY_DEFAULT) && 
-         (decodeGranularity != ZYDIS_DECODE_GRANULARITY_FULL) && 
+         (decodeGranularity != ZYDIS_DECODE_GRANULARITY_PHYSICAL) &&
-         (decodeGranularity != ZYDIS_DECODE_GRANULARITY_MINIMAL)))
+         (decodeGranularity != ZYDIS_DECODE_GRANULARITY_SEMANTIC)))
     {
         return ZYDIS_STATUS_INVALID_PARAMETER;
     }
     if (machineMode == 64)
     {
-        addressWidth = ZYDIS_ADDRESS_WIDTH_64;
+        if (addressWidth != 64)
+        {
+            return ZYDIS_STATUS_INVALID_PARAMETER;
+        }
     } else
     {
         if ((addressWidth != 16) && (addressWidth != 32))
@@ -4352,7 +4348,7 @@ ZydisStatus ZydisDecoderInitEx(ZydisDecoder* decoder, ZydisMachineMode machineMo
     }
     if (decodeGranularity == ZYDIS_DECODE_GRANULARITY_DEFAULT)
     {
-        decodeGranularity = ZYDIS_DECODE_GRANULARITY_FULL;
+        decodeGranularity = ZYDIS_DECODE_GRANULARITY_SEMANTIC;
     }
 
     decoder->machineMode = machineMode;

tools/PerfTest.c

@@ -0,0 +1,303 @@
+/***************************************************************************************************
+
+  Zyan Disassembler Engine (Zydis)
+
+  Original Author : Florian Bernd
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+
+***************************************************************************************************/
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <time.h>
+#include <Zydis/Zydis.h>
+
+#ifdef ZYDIS_WINDOWS
+#   include <Windows.h>
+#endif
+
+/* ============================================================================================== */
+/* Helper functions                                                                               */
+/* ============================================================================================== */
+
+double   CounterFreq  = 0.0;
+uint64_t CounterStart = 0;
+
+void StartCounter()
+{
+    LARGE_INTEGER li;
+    if (!QueryPerformanceFrequency(&li))
+    {
+        fputs("QueryPerformanceFrequency failed!\n", stderr);
+    }
+    CounterFreq = (double)li.QuadPart / 1000.0;
+    QueryPerformanceCounter(&li);
+    CounterStart = li.QuadPart;
+}
+
+double GetCounter()
+{
+    LARGE_INTEGER li;
+    QueryPerformanceCounter(&li);
+    return (double)(li.QuadPart - CounterStart) / CounterFreq;
+}
+
+/* ============================================================================================== */
+/* Internal functions                                                                             */
+/* ============================================================================================== */
+
+void processBuffer(const char* buffer, size_t length, ZydisDecodeGranularity granularity, 
+    ZydisBool format)
+{
+    ZydisDecoder decoder;
+    if (!ZYDIS_SUCCESS(ZydisDecoderInitEx(&decoder, 
+        ZYDIS_MACHINE_MODE_LONG_64, ZYDIS_ADDRESS_WIDTH_64, granularity)))
+    {
+        fputs("Failed to initialize decoder\n", stderr);
+        exit(EXIT_FAILURE);
+    }
+
+    ZydisFormatter formatter;
+    if (format)
+    {
+        if (!ZYDIS_SUCCESS(ZydisFormatterInitEx(&formatter, ZYDIS_FORMATTER_STYLE_INTEL, 
+            ZYDIS_FMTFLAG_FORCE_SEGMENTS | ZYDIS_FMTFLAG_FORCE_OPERANDSIZE,
+            ZYDIS_FORMATTER_ADDR_ABSOLUTE, ZYDIS_FORMATTER_DISP_DEFAULT, 
+            ZYDIS_FORMATTER_IMM_DEFAULT)))
+        {
+            fputs("Failed to initialized instruction-formatter\n", stderr);
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    size_t offset = 0;
+    ZydisStatus status;
+    ZydisDecodedInstruction instruction;
+    char formatBuffer[256];
+    while ((status = ZydisDecoderDecodeBuffer(&decoder, buffer + offset, length - offset, offset, 
+        &instruction)) != ZYDIS_STATUS_NO_MORE_DATA)
+    {
+        ZYDIS_ASSERT(ZYDIS_SUCCESS(status));
+        if (!ZYDIS_SUCCESS(status))
+        {
+            puts("Unexpected decoding error");
+            exit(EXIT_FAILURE);
+        }
+        if (format)
+        {
+            ZydisFormatterFormatInstruction(
+                &formatter, &instruction, formatBuffer, sizeof(formatBuffer));
+        }            
+        offset += instruction.length;
+    }    
+}
+
+void testPerformance(const char* buffer, size_t length, ZydisDecodeGranularity granularity, 
+    ZydisBool format)
+{
+    StartCounter();
+    for (uint8_t j = 0; j < 100; ++j)
+    {
+        processBuffer(buffer, length, granularity, format);
+    }
+    printf("Granularity %d, Formatting %d: %8.2f msec\n", granularity, format, GetCounter());  
+}
+
+void generateTestData(FILE* file, uint8_t encoding)
+{
+    ZydisDecoder decoder;
+    if (!ZYDIS_SUCCESS(
+        ZydisDecoderInit(&decoder, ZYDIS_MACHINE_MODE_LONG_64, ZYDIS_ADDRESS_WIDTH_64)))
+    {
+        fputs("Failed to initialize decoder\n", stderr);
+        exit(EXIT_FAILURE);
+    }
+    
+    uint8_t last = 0;
+    double size = 0;
+    ZydisDecodedInstruction instruction;
+    while (size < 1024 * 1024)
+    {
+        uint8_t data[ZYDIS_MAX_INSTRUCTION_LENGTH];
+        for (int i = 0; i < ZYDIS_MAX_INSTRUCTION_LENGTH; ++i)
+        {
+            data[i] = rand() % 256;
+        }
+        uint8_t offset = rand() % (ZYDIS_MAX_INSTRUCTION_LENGTH - 2);
+        switch (encoding)
+        {
+        case 0:
+            break;
+        case 1:
+            data[offset    ] = 0x0F;
+            data[offset + 1] = 0x0F;
+            break;
+        case 2:
+            data[offset    ] = 0x8F;
+            break;
+        case 3:
+            data[offset    ] = 0xC4;
+            break;
+        case 4:
+            data[offset    ] = 0xC5;
+            break;
+        case 5:
+        case 6:
+            data[offset    ] = 0x62;
+            break;
+        default:
+            ZYDIS_UNREACHABLE;
+        }
+        if (ZYDIS_SUCCESS(ZydisDecoderDecodeBuffer(&decoder, data, sizeof(data), 0, &instruction)))
+        {
+            ZydisBool b = ZYDIS_FALSE;
+            switch (encoding)
+            {
+            case 0:
+                b = (instruction.encoding == ZYDIS_INSTRUCTION_ENCODING_DEFAULT);
+                break;
+            case 1:
+                b = (instruction.encoding == ZYDIS_INSTRUCTION_ENCODING_3DNOW);
+                break;
+            case 2:
+                b = (instruction.encoding == ZYDIS_INSTRUCTION_ENCODING_XOP);
+                break;
+            case 3:
+            case 4:
+                b = (instruction.encoding == ZYDIS_INSTRUCTION_ENCODING_VEX);
+                break;
+            case 5:
+                b = (instruction.encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX);
+                break;
+            case 6:
+                b = (instruction.encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX);
+                break;
+            default:
+                ZYDIS_UNREACHABLE;
+            }
+            if (b)
+            {
+                fwrite(&instruction.data[0], 1, instruction.length, file);
+                size += instruction.length;
+
+                double p = (size / (1024 * 1024) * 100);
+                if (last < (uint8_t)p)
+                {
+                    last = (uint8_t)p;
+                    printf("%3.0f%%\n", p);
+                }
+                
+            }
+        }
+    }
+}
+
+/* ============================================================================================== */
+/* Entry point                                                                                    */
+/* ============================================================================================== */
+
+int main(int argc, char** argv)
+{
+    if (argc < 3 || (!strcmp(argv[1], "-test") && !strcmp(argv[1], "-generate")))
+    {
+        fputs("Usage: PerfTest -[test|generate] [directory]", stderr);
+        return EXIT_FAILURE;
+    }
+
+    ZydisBool generate = ZYDIS_FALSE;
+    if (!strcmp(argv[1], "-generate"))
+    {
+        generate = ZYDIS_TRUE;
+    }
+    const char* directory = argv[2]; 
+
+    static const struct
+    {
+        const char* encoding;
+        const char* filename;
+    } tests[7] =
+    {
+        { "DEFAULT", "enc_default.dat" },
+        { "3DNOW"  , "enc_3dnow.dat"   },
+        { "XOP"    , "enc_xop.dat"     },
+        { "VEX_C4" , "enc_vex_c4.dat"  },
+        { "VEX_C5" , "enc_vex_c5.dat"  },
+        { "EVEX"   , "enc_evex.dat"    },
+        { "MVEX"   , "enc_mvex.dat"    }
+    };
+    
+    if (generate)
+    {
+        time_t t;
+        srand((unsigned) time(&t));
+    }
+
+    for (uint8_t i = 0; i < ZYDIS_ARRAY_SIZE(tests); ++i)
+    {
+        FILE* file;
+
+        char buf[256];
+        strcpy(&buf[0], directory);
+        if (generate)
+        {
+            file = fopen(strcat(buf, tests[i].filename), "wb");   
+        } else
+        {
+            file = fopen(strcat(buf, tests[i].filename), "rb");
+        }
+        if (!file)
+        {
+            fprintf(stderr, "Can not open file \"%s\": %s\n", &buf[0], strerror(errno));
+            continue;
+        }
+
+        if (generate)
+        {
+            printf("Generating %s ...\n", tests[i].encoding);
+            generateTestData(file, i);
+        } else
+        {
+            fseek(file, 0L, SEEK_END);
+            long length = ftell(file);
+            void* buffer = malloc(length);
+            rewind(file);
+            fread(buffer, 1, length, file);
+
+            printf("Testing %s ...\n", tests[i].encoding);
+            testPerformance(buffer, length, ZYDIS_DECODE_GRANULARITY_PHYSICAL, ZYDIS_FALSE);
+            testPerformance(buffer, length, ZYDIS_DECODE_GRANULARITY_SEMANTIC, ZYDIS_FALSE);
+            // testPerformance(buffer, length, ZYDIS_DECODE_GRANULARITY_SEMANTIC, ZYDIS_TRUE );
+
+            puts("");
+            free(buffer);
+            fclose(file);
+        }
+    }
+
+    getchar();
+
+    return 0;
+}
+
+/* ============================================================================================== */