mirror of
https://github.com/open-goal/jak-project
synced 2026-07-09 14:55:51 -04:00
Tyler Wilding
9fb8a1dc27
Zydis has been complaining about cmake deprecation, and json.hpp has been causing tons of warnings to be spewed in the builds. Update both.
652 lines
21 KiB
C
Vendored
Generated
652 lines
21 KiB
C
Vendored
Generated
/***************************************************************************************************
|
|
|
|
Zyan Disassembler Library (Zydis)
|
|
|
|
Original Author : Mappa
|
|
|
|
* 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.
|
|
|
|
***************************************************************************************************/
|
|
|
|
/**
|
|
* @file
|
|
*
|
|
* Test set for `ZydisEncoderEncodeInstructionAbsolute`.
|
|
*/
|
|
|
|
#include <inttypes.h>
|
|
#include <Zycore/LibC.h>
|
|
#include <Zydis/Zydis.h>
|
|
#include <Zydis/Internal/EncoderData.h>
|
|
|
|
/* ============================================================================================== */
|
|
/* Enums and Types */
|
|
/* ============================================================================================== */
|
|
|
|
#define TEST_RUNTIME_ADDRESS 0x00004000ULL
|
|
|
|
typedef struct Iterator_
|
|
{
|
|
ZyanU32 value;
|
|
ZyanU32 limit;
|
|
} Iterator;
|
|
|
|
typedef struct DecodedInstruction_
|
|
{
|
|
ZydisDecodedInstruction insn;
|
|
ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT];
|
|
} DecodedInstruction;
|
|
|
|
/* ============================================================================================== */
|
|
/* Helper functions */
|
|
/* ============================================================================================== */
|
|
|
|
static ZyanBool AdvanceIterators(Iterator *iterators, ZyanUSize count)
|
|
{
|
|
if (!iterators || !count)
|
|
{
|
|
return ZYAN_FALSE;
|
|
}
|
|
|
|
for (ZyanUSize i = 0; i < count; ++i)
|
|
{
|
|
Iterator *iterator = &iterators[count - 1 - i];
|
|
iterator->value++;
|
|
if (iterator->value < iterator->limit)
|
|
{
|
|
return ZYAN_TRUE;
|
|
}
|
|
iterator->value = 0;
|
|
}
|
|
|
|
return ZYAN_FALSE;
|
|
}
|
|
|
|
static void PrintBytes(ZyanU8 *bytes, ZyanUSize count)
|
|
{
|
|
for (ZyanUSize i = 0; i < count; ++i)
|
|
{
|
|
ZYAN_PRINTF("%02X ", bytes[i]);
|
|
}
|
|
}
|
|
|
|
static ZyanI8 GetRelativeOperandIndex(const ZydisEncoderRequest *req)
|
|
{
|
|
for (ZyanU8 i = 0; i < req->operand_count; ++i)
|
|
{
|
|
const ZyanBool is_rip_rel = (req->operands[i].type == ZYDIS_OPERAND_TYPE_MEMORY) &&
|
|
((req->operands[i].mem.base == ZYDIS_REGISTER_EIP) ||
|
|
(req->operands[i].mem.base == ZYDIS_REGISTER_RIP));
|
|
if (is_rip_rel || (req->operands[i].type == ZYDIS_OPERAND_TYPE_IMMEDIATE))
|
|
{
|
|
return (ZyanI8)i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static ZyanBool Disassemble(DecodedInstruction *decoded, ZyanU8 *bytes, ZyanUSize size,
|
|
ZydisMachineMode machine_mode)
|
|
{
|
|
ZydisDecoder decoder;
|
|
ZydisStackWidth stack_width;
|
|
switch (machine_mode)
|
|
{
|
|
case ZYDIS_MACHINE_MODE_LONG_COMPAT_16:
|
|
stack_width = ZYDIS_STACK_WIDTH_16;
|
|
break;
|
|
case ZYDIS_MACHINE_MODE_LONG_COMPAT_32:
|
|
stack_width = ZYDIS_STACK_WIDTH_32;
|
|
break;
|
|
case ZYDIS_MACHINE_MODE_LONG_64:
|
|
stack_width = ZYDIS_STACK_WIDTH_64;
|
|
break;
|
|
default:
|
|
ZYAN_UNREACHABLE;
|
|
}
|
|
if (ZYAN_FAILED(ZydisDecoderInit(&decoder, machine_mode, stack_width)))
|
|
{
|
|
return ZYAN_FALSE;
|
|
}
|
|
if (ZYAN_FAILED(ZydisDecoderDecodeFull(&decoder, bytes, size, &decoded->insn,
|
|
decoded->operands)))
|
|
{
|
|
return ZYAN_FALSE;
|
|
}
|
|
return ZYAN_TRUE;
|
|
}
|
|
|
|
/* ============================================================================================== */
|
|
/* Tests */
|
|
/* ============================================================================================== */
|
|
|
|
static ZyanBool RunTest(ZydisEncoderRequest *req, const char *test_name, ZyanBool is_rip_rel_test)
|
|
{
|
|
ZyanU8 instruction1[ZYDIS_MAX_INSTRUCTION_LENGTH];
|
|
ZyanUSize length1 = sizeof(instruction1);
|
|
if (ZYAN_FAILED(ZydisEncoderEncodeInstruction(req, instruction1, &length1)))
|
|
{
|
|
ZYAN_PRINTF("%s: NOT ENCODABLE\n", test_name);
|
|
return ZYAN_TRUE;
|
|
}
|
|
ZyanI8 rel_op_index = GetRelativeOperandIndex(req);
|
|
if (rel_op_index < 0)
|
|
{
|
|
ZYAN_PRINTF("%s: NO RELATIVE OPERAND FOUND\n", test_name);
|
|
return ZYAN_FALSE;
|
|
}
|
|
DecodedInstruction decoded;
|
|
if (!Disassemble(&decoded, instruction1, length1, req->machine_mode))
|
|
{
|
|
ZYAN_PRINTF("%s: FAILED TO DISASSEMBLE\n", test_name);
|
|
return ZYAN_FALSE;
|
|
}
|
|
ZyanU64 absolute_address = 0;
|
|
if (ZYAN_FAILED(ZydisCalcAbsoluteAddress(&decoded.insn, &decoded.operands[rel_op_index],
|
|
TEST_RUNTIME_ADDRESS, &absolute_address)))
|
|
{
|
|
ZYAN_PRINTF("%s: FAILED TO COMPUTE ABSOLUTE ADDRESS\n", test_name);
|
|
return ZYAN_FALSE;
|
|
}
|
|
if (is_rip_rel_test)
|
|
{
|
|
ZYAN_ASSERT(req->operands[rel_op_index].type == ZYDIS_OPERAND_TYPE_MEMORY);
|
|
req->operands[rel_op_index].mem.displacement = absolute_address;
|
|
}
|
|
else
|
|
{
|
|
ZYAN_ASSERT(req->operands[rel_op_index].type == ZYDIS_OPERAND_TYPE_IMMEDIATE);
|
|
req->operands[rel_op_index].imm.u = absolute_address;
|
|
}
|
|
|
|
ZyanU8 instruction2[ZYDIS_MAX_INSTRUCTION_LENGTH];
|
|
ZyanUSize length2 = sizeof(instruction2);
|
|
if (ZYAN_FAILED(ZydisEncoderEncodeInstructionAbsolute(req, instruction2, &length2,
|
|
TEST_RUNTIME_ADDRESS)))
|
|
{
|
|
ZYAN_PRINTF("%s: FAILED TO ENCODE INSTRUCTION\n", test_name);
|
|
return ZYAN_FALSE;
|
|
}
|
|
ZYAN_PRINTF("%s: ", test_name);
|
|
PrintBytes(instruction1, length1);
|
|
if ((length1 != length2) || ZYAN_MEMCMP(instruction1, instruction2, length1))
|
|
{
|
|
ZYAN_PRINTF("!= ");
|
|
PrintBytes(instruction2, length2);
|
|
ZYAN_PRINTF("\n");
|
|
return ZYAN_FALSE;
|
|
}
|
|
ZYAN_PRINTF("\n");
|
|
return ZYAN_TRUE;
|
|
}
|
|
|
|
static ZyanBool RunTestAbsolute(ZydisEncoderRequest *req, const char *test_name,
|
|
ZyanU64 runtime_address)
|
|
{
|
|
ZyanI8 rel_op_index = GetRelativeOperandIndex(req);
|
|
if (rel_op_index < 0)
|
|
{
|
|
ZYAN_PRINTF("%s: NO RELATIVE OPERAND FOUND\n", test_name);
|
|
return ZYAN_FALSE;
|
|
}
|
|
ZyanU64 desired_address;
|
|
const ZydisEncoderOperand *rel_op = &req->operands[rel_op_index];
|
|
if (rel_op->type == ZYDIS_OPERAND_TYPE_IMMEDIATE)
|
|
{
|
|
desired_address = rel_op->imm.u;
|
|
}
|
|
else if (rel_op->type == ZYDIS_OPERAND_TYPE_MEMORY)
|
|
{
|
|
desired_address = rel_op->mem.displacement;
|
|
}
|
|
else
|
|
{
|
|
return ZYAN_FALSE;
|
|
}
|
|
ZyanU8 instruction[ZYDIS_MAX_INSTRUCTION_LENGTH];
|
|
ZyanUSize length = sizeof(instruction);
|
|
if (ZYAN_FAILED(ZydisEncoderEncodeInstructionAbsolute(req, instruction, &length,
|
|
runtime_address)))
|
|
{
|
|
ZYAN_PRINTF("%s: FAILED TO ENCODE INSTRUCTION\n", test_name);
|
|
return ZYAN_FALSE;
|
|
}
|
|
DecodedInstruction decoded;
|
|
if (!Disassemble(&decoded, instruction, length, req->machine_mode))
|
|
{
|
|
ZYAN_PRINTF("%s: FAILED TO DISASSEMBLE\n", test_name);
|
|
return ZYAN_FALSE;
|
|
}
|
|
ZyanU64 absolute_address = 0;
|
|
if (ZYAN_FAILED(ZydisCalcAbsoluteAddress(&decoded.insn, &decoded.operands[rel_op_index],
|
|
runtime_address, &absolute_address)))
|
|
{
|
|
ZYAN_PRINTF("%s: FAILED TO COMPUTE ABSOLUTE ADDRESS\n", test_name);
|
|
return ZYAN_FALSE;
|
|
}
|
|
if (absolute_address != desired_address)
|
|
{
|
|
ZYAN_PRINTF("%s: %016" PRIX64 " != %016" PRIX64 "\n", test_name, absolute_address,
|
|
desired_address);
|
|
return ZYAN_FALSE;
|
|
}
|
|
return ZYAN_TRUE;
|
|
}
|
|
|
|
static ZyanBool RunBranchingTests(void)
|
|
{
|
|
static const ZydisMnemonic instructions[] =
|
|
{
|
|
ZYDIS_MNEMONIC_CALL,
|
|
ZYDIS_MNEMONIC_JZ,
|
|
ZYDIS_MNEMONIC_JCXZ,
|
|
ZYDIS_MNEMONIC_JECXZ,
|
|
ZYDIS_MNEMONIC_JRCXZ,
|
|
ZYDIS_MNEMONIC_JKZD,
|
|
ZYDIS_MNEMONIC_JMP,
|
|
};
|
|
static const ZydisMachineMode modes[] =
|
|
{
|
|
ZYDIS_MACHINE_MODE_LONG_COMPAT_16,
|
|
ZYDIS_MACHINE_MODE_LONG_COMPAT_32,
|
|
ZYDIS_MACHINE_MODE_LONG_64,
|
|
};
|
|
static const char *str_modes[] =
|
|
{
|
|
"M16",
|
|
"M32",
|
|
"M64",
|
|
};
|
|
static const ZyanU64 rels[] =
|
|
{
|
|
0x11,
|
|
0x2222,
|
|
0x44444444,
|
|
};
|
|
static const ZydisBranchType branch_types[] =
|
|
{
|
|
ZYDIS_BRANCH_TYPE_NONE,
|
|
ZYDIS_BRANCH_TYPE_SHORT,
|
|
ZYDIS_BRANCH_TYPE_NEAR,
|
|
};
|
|
static const char *str_branch_types[] =
|
|
{
|
|
"T0",
|
|
"TS",
|
|
"TN",
|
|
};
|
|
static const ZydisBranchWidth branch_widths[] =
|
|
{
|
|
ZYDIS_BRANCH_WIDTH_NONE,
|
|
ZYDIS_BRANCH_WIDTH_8,
|
|
ZYDIS_BRANCH_WIDTH_16,
|
|
ZYDIS_BRANCH_WIDTH_32,
|
|
ZYDIS_BRANCH_WIDTH_64,
|
|
};
|
|
static const char *str_branch_widths[] =
|
|
{
|
|
"W00",
|
|
"W08",
|
|
"W16",
|
|
"W32",
|
|
"W64",
|
|
};
|
|
static const ZydisInstructionAttributes prefixes[] = {
|
|
0,
|
|
ZYDIS_ATTRIB_HAS_BRANCH_TAKEN,
|
|
ZYDIS_ATTRIB_HAS_BND,
|
|
ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN | ZYDIS_ATTRIB_HAS_BND,
|
|
};
|
|
static const char *str_prefixes[] =
|
|
{
|
|
"P00",
|
|
"PBT",
|
|
"PBD",
|
|
"PBN+PBD",
|
|
};
|
|
static const ZydisAddressSizeHint address_hints[] =
|
|
{
|
|
ZYDIS_ADDRESS_SIZE_HINT_NONE,
|
|
ZYDIS_ADDRESS_SIZE_HINT_16,
|
|
ZYDIS_ADDRESS_SIZE_HINT_32,
|
|
ZYDIS_ADDRESS_SIZE_HINT_64,
|
|
};
|
|
static const char *str_address_hints[] =
|
|
{
|
|
"AH00",
|
|
"AH16",
|
|
"AH32",
|
|
"AH64",
|
|
};
|
|
static const ZydisOperandSizeHint operand_hints[] =
|
|
{
|
|
ZYDIS_OPERAND_SIZE_HINT_NONE,
|
|
ZYDIS_OPERAND_SIZE_HINT_8,
|
|
ZYDIS_OPERAND_SIZE_HINT_16,
|
|
ZYDIS_OPERAND_SIZE_HINT_32,
|
|
ZYDIS_OPERAND_SIZE_HINT_64,
|
|
};
|
|
static const char *str_operand_hints[] =
|
|
{
|
|
"OH00",
|
|
"OH08",
|
|
"OH16",
|
|
"OH32",
|
|
"OH64",
|
|
};
|
|
|
|
ZydisEncoderRequest req;
|
|
ZyanBool all_passed = ZYAN_TRUE;
|
|
Iterator iter_branches[6] =
|
|
{
|
|
{ 0, ZYAN_ARRAY_LENGTH(instructions) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(modes) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(rels) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(branch_types) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(branch_widths) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(prefixes) },
|
|
};
|
|
do
|
|
{
|
|
ZydisMnemonic mnemonic = instructions[iter_branches[0].value];
|
|
ZydisMachineMode mode = modes[iter_branches[1].value];
|
|
ZyanU64 rel = rels[iter_branches[2].value];
|
|
ZydisBranchType branch_type = branch_types[iter_branches[3].value];
|
|
ZydisBranchWidth branch_width = branch_widths[iter_branches[4].value];
|
|
ZydisInstructionAttributes prefix = prefixes[iter_branches[5].value];
|
|
|
|
const ZydisEncoderRelInfo *rel_info = ZydisGetRelInfo(mnemonic);
|
|
ZYAN_ASSERT(rel_info);
|
|
if ((!rel_info->accepts_branch_hints) && (prefix & (ZYDIS_ATTRIB_HAS_BRANCH_TAKEN |
|
|
ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN)))
|
|
{
|
|
continue;
|
|
}
|
|
if ((!rel_info->accepts_bound) && (prefix & ZYDIS_ATTRIB_HAS_BND))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ZYAN_MEMSET(&req, 0, sizeof(req));
|
|
req.machine_mode = mode;
|
|
req.mnemonic = mnemonic;
|
|
req.prefixes = prefix;
|
|
req.branch_type = branch_type;
|
|
req.branch_width = branch_width;
|
|
if (mnemonic != ZYDIS_MNEMONIC_JKZD)
|
|
{
|
|
req.operand_count = 1;
|
|
req.operands[0].type = ZYDIS_OPERAND_TYPE_IMMEDIATE;
|
|
req.operands[0].imm.u = rel;
|
|
}
|
|
else
|
|
{
|
|
req.operand_count = 2;
|
|
req.operands[0].type = ZYDIS_OPERAND_TYPE_REGISTER;
|
|
req.operands[0].reg.value = ZYDIS_REGISTER_K1;
|
|
req.operands[1].type = ZYDIS_OPERAND_TYPE_IMMEDIATE;
|
|
req.operands[1].imm.u = rel;
|
|
}
|
|
|
|
char test_name[256];
|
|
snprintf(test_name, sizeof(test_name), "%s:%s:%08" PRIX64 ":%s:%s:%s",
|
|
ZydisMnemonicGetString(mnemonic),
|
|
str_modes[iter_branches[1].value],
|
|
rel,
|
|
str_branch_types[iter_branches[3].value],
|
|
str_branch_widths[iter_branches[4].value],
|
|
str_prefixes[iter_branches[5].value]);
|
|
all_passed &= RunTest(&req, test_name, ZYAN_FALSE);
|
|
} while (AdvanceIterators(iter_branches, ZYAN_ARRAY_LENGTH(iter_branches)));
|
|
|
|
Iterator iter_asz_branches[4] =
|
|
{
|
|
{ 0, ZYAN_ARRAY_LENGTH(modes) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(branch_types) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(branch_widths) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(address_hints) },
|
|
};
|
|
do
|
|
{
|
|
ZydisMachineMode mode = modes[iter_asz_branches[0].value];
|
|
ZydisBranchType branch_type = branch_types[iter_asz_branches[1].value];
|
|
ZydisBranchWidth branch_width = branch_widths[iter_asz_branches[2].value];
|
|
ZydisAddressSizeHint address_hint = address_hints[iter_asz_branches[3].value];
|
|
|
|
ZYAN_MEMSET(&req, 0, sizeof(req));
|
|
req.machine_mode = mode;
|
|
req.mnemonic = ZYDIS_MNEMONIC_LOOP;
|
|
req.branch_type = branch_type;
|
|
req.branch_width = branch_width;
|
|
req.address_size_hint = address_hint;
|
|
req.operand_count = 1;
|
|
req.operands[0].type = ZYDIS_OPERAND_TYPE_IMMEDIATE;
|
|
req.operands[0].imm.u = 0x55;
|
|
|
|
char test_name[256];
|
|
snprintf(test_name, sizeof(test_name), "%s:%s:%s:%s:%s",
|
|
ZydisMnemonicGetString(req.mnemonic),
|
|
str_modes[iter_asz_branches[0].value],
|
|
str_branch_types[iter_asz_branches[1].value],
|
|
str_branch_widths[iter_asz_branches[2].value],
|
|
str_address_hints[iter_asz_branches[3].value]);
|
|
all_passed &= RunTest(&req, test_name, ZYAN_FALSE);
|
|
} while (AdvanceIterators(iter_asz_branches, ZYAN_ARRAY_LENGTH(iter_asz_branches)));
|
|
|
|
Iterator iter_osz_branches[3] =
|
|
{
|
|
{ 0, ZYAN_ARRAY_LENGTH(modes) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(rels) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(operand_hints) },
|
|
};
|
|
do
|
|
{
|
|
ZydisMachineMode mode = modes[iter_osz_branches[0].value];
|
|
ZyanU64 rel = rels[iter_osz_branches[1].value];
|
|
ZydisOperandSizeHint operand_hint = operand_hints[iter_osz_branches[2].value];
|
|
|
|
ZYAN_MEMSET(&req, 0, sizeof(req));
|
|
req.machine_mode = mode;
|
|
req.mnemonic = ZYDIS_MNEMONIC_XBEGIN;
|
|
req.operand_size_hint = operand_hint;
|
|
req.operand_count = 1;
|
|
req.operands[0].type = ZYDIS_OPERAND_TYPE_IMMEDIATE;
|
|
req.operands[0].imm.u = rel;
|
|
|
|
char test_name[256];
|
|
snprintf(test_name, sizeof(test_name), "%s:%s:%08" PRIX64 ":%s",
|
|
ZydisMnemonicGetString(req.mnemonic),
|
|
str_modes[iter_osz_branches[0].value],
|
|
rel,
|
|
str_operand_hints[iter_osz_branches[2].value]);
|
|
all_passed &= RunTest(&req, test_name, ZYAN_FALSE);
|
|
} while (AdvanceIterators(iter_osz_branches, ZYAN_ARRAY_LENGTH(iter_osz_branches)));
|
|
|
|
return all_passed;
|
|
}
|
|
|
|
static ZyanBool RunRipRelativeTests(void)
|
|
{
|
|
ZydisEncoderRequest req;
|
|
ZyanBool all_passed = ZYAN_TRUE;
|
|
|
|
// Basic test
|
|
ZYAN_MEMSET(&req, 0, sizeof(req));
|
|
req.machine_mode = ZYDIS_MACHINE_MODE_LONG_64;
|
|
req.mnemonic = ZYDIS_MNEMONIC_XOR;
|
|
req.operand_count = 2;
|
|
req.operands[0].type = ZYDIS_OPERAND_TYPE_REGISTER;
|
|
req.operands[0].reg.value = ZYDIS_REGISTER_RAX;
|
|
req.operands[1].type = ZYDIS_OPERAND_TYPE_MEMORY;
|
|
req.operands[1].mem.base = ZYDIS_REGISTER_RIP;
|
|
req.operands[1].mem.displacement = 0x66666666;
|
|
req.operands[1].mem.size = 8;
|
|
all_passed &= RunTest(&req, ZydisMnemonicGetString(req.mnemonic), ZYAN_TRUE);
|
|
|
|
// Displacement + immediate
|
|
ZYAN_MEMSET(&req, 0, sizeof(req));
|
|
req.machine_mode = ZYDIS_MACHINE_MODE_LONG_64;
|
|
req.mnemonic = ZYDIS_MNEMONIC_CMP;
|
|
req.operand_count = 2;
|
|
req.operands[0].type = ZYDIS_OPERAND_TYPE_MEMORY;
|
|
req.operands[0].mem.base = ZYDIS_REGISTER_RIP;
|
|
req.operands[0].mem.displacement = 0x66666666;
|
|
req.operands[0].mem.size = 4;
|
|
req.operands[1].type = ZYDIS_OPERAND_TYPE_IMMEDIATE;
|
|
req.operands[1].imm.u = 0x11223344;
|
|
all_passed &= RunTest(&req, ZydisMnemonicGetString(req.mnemonic), ZYAN_TRUE);
|
|
|
|
// EIP-relative
|
|
ZYAN_MEMSET(&req, 0, sizeof(req));
|
|
req.machine_mode = ZYDIS_MACHINE_MODE_LONG_64;
|
|
req.mnemonic = ZYDIS_MNEMONIC_SUB;
|
|
req.operand_count = 2;
|
|
req.operands[0].type = ZYDIS_OPERAND_TYPE_MEMORY;
|
|
req.operands[0].mem.base = ZYDIS_REGISTER_EIP;
|
|
req.operands[0].mem.displacement = 0x66666666;
|
|
req.operands[0].mem.size = 4;
|
|
req.operands[1].type = ZYDIS_OPERAND_TYPE_REGISTER;
|
|
req.operands[1].reg.value = ZYDIS_REGISTER_EBX;
|
|
all_passed &= RunTest(&req, ZydisMnemonicGetString(req.mnemonic), ZYAN_TRUE);
|
|
|
|
// AMD 3DNow!
|
|
ZYAN_MEMSET(&req, 0, sizeof(req));
|
|
req.machine_mode = ZYDIS_MACHINE_MODE_LONG_64;
|
|
req.mnemonic = ZYDIS_MNEMONIC_PI2FD;
|
|
req.operand_count = 2;
|
|
req.operands[0].type = ZYDIS_OPERAND_TYPE_REGISTER;
|
|
req.operands[0].reg.value = ZYDIS_REGISTER_MM1;
|
|
req.operands[1].type = ZYDIS_OPERAND_TYPE_MEMORY;
|
|
req.operands[1].mem.base = ZYDIS_REGISTER_RIP;
|
|
req.operands[1].mem.displacement = 0x66666666;
|
|
req.operands[1].mem.size = 8;
|
|
all_passed &= RunTest(&req, ZydisMnemonicGetString(req.mnemonic), ZYAN_TRUE);
|
|
|
|
return all_passed;
|
|
}
|
|
|
|
static ZyanBool RunRangeTests(void)
|
|
{
|
|
static const ZydisMnemonic instructions[] =
|
|
{
|
|
ZYDIS_MNEMONIC_CALL,
|
|
ZYDIS_MNEMONIC_JZ,
|
|
ZYDIS_MNEMONIC_JKZD,
|
|
ZYDIS_MNEMONIC_JMP,
|
|
ZYDIS_MNEMONIC_XBEGIN,
|
|
};
|
|
static const ZydisMachineMode modes[] =
|
|
{
|
|
ZYDIS_MACHINE_MODE_LONG_COMPAT_16,
|
|
ZYDIS_MACHINE_MODE_LONG_COMPAT_32,
|
|
ZYDIS_MACHINE_MODE_LONG_64,
|
|
};
|
|
static const ZyanU8 mode_widths[] =
|
|
{
|
|
16,
|
|
32,
|
|
64,
|
|
};
|
|
static const ZyanU64 offsets[] =
|
|
{
|
|
0x80,
|
|
0x8000,
|
|
};
|
|
|
|
ZydisEncoderRequest req;
|
|
ZyanBool all_passed = ZYAN_TRUE;
|
|
Iterator iterators[3] =
|
|
{
|
|
{ 0, ZYAN_ARRAY_LENGTH(instructions) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(modes) },
|
|
{ 0, ZYAN_ARRAY_LENGTH(offsets) },
|
|
};
|
|
do
|
|
{
|
|
ZydisMnemonic mnemonic = instructions[iterators[0].value];
|
|
ZydisMachineMode mode = modes[iterators[1].value];
|
|
ZyanU64 offset = offsets[iterators[2].value];
|
|
const ZydisEncoderRelInfo *rel_info = ZydisGetRelInfo(mnemonic);
|
|
static const ZyanU8 empty_row[3] = { 0, 0, 0 };
|
|
if (!memcmp(rel_info->size[iterators[1].value], empty_row, sizeof(empty_row)))
|
|
{
|
|
continue;
|
|
}
|
|
for (int i = 0; i < 8; ++i)
|
|
{
|
|
ZyanU64 target_address = TEST_RUNTIME_ADDRESS + offset + i;
|
|
ZYAN_MEMSET(&req, 0, sizeof(req));
|
|
req.machine_mode = mode;
|
|
req.mnemonic = mnemonic;
|
|
if (mnemonic != ZYDIS_MNEMONIC_JKZD)
|
|
{
|
|
req.operand_count = 1;
|
|
req.operands[0].type = ZYDIS_OPERAND_TYPE_IMMEDIATE;
|
|
req.operands[0].imm.u = target_address;
|
|
}
|
|
else
|
|
{
|
|
req.operand_count = 2;
|
|
req.operands[0].type = ZYDIS_OPERAND_TYPE_REGISTER;
|
|
req.operands[0].reg.value = ZYDIS_REGISTER_K1;
|
|
req.operands[1].type = ZYDIS_OPERAND_TYPE_IMMEDIATE;
|
|
req.operands[1].imm.u = target_address;
|
|
}
|
|
char test_name[256];
|
|
snprintf(test_name, sizeof(test_name), "M%02u:%016" PRIX64 ":%s",
|
|
mode_widths[mode],
|
|
target_address,
|
|
ZydisMnemonicGetString(mnemonic));
|
|
all_passed &= RunTestAbsolute(&req, test_name, TEST_RUNTIME_ADDRESS);
|
|
}
|
|
} while (AdvanceIterators(iterators, ZYAN_ARRAY_LENGTH(iterators)));
|
|
|
|
if (all_passed)
|
|
{
|
|
ZYAN_PRINTF("All range tests passed\n");
|
|
}
|
|
return all_passed;
|
|
}
|
|
|
|
/* ============================================================================================== */
|
|
/* Entry point */
|
|
/* ============================================================================================== */
|
|
|
|
int main(void)
|
|
{
|
|
ZyanBool all_passed = ZYAN_TRUE;
|
|
ZYAN_PRINTF("Branching tests:\n");
|
|
all_passed &= RunBranchingTests();
|
|
ZYAN_PRINTF("\nEIP/RIP-relative tests:\n");
|
|
all_passed &= RunRipRelativeTests();
|
|
ZYAN_PRINTF("\nRange tests:\n");
|
|
all_passed &= RunRangeTests();
|
|
ZYAN_PRINTF("\n");
|
|
if (!all_passed)
|
|
{
|
|
ZYAN_PRINTF("SOME TESTS FAILED\n");
|
|
return 1;
|
|
}
|
|
|
|
ZYAN_PRINTF("ALL TESTS PASSED\n");
|
|
return 0;
|
|
}
|
|
|
|
/* ============================================================================================== */
|