summaryrefslogtreecommitdiffstats
path: root/js/src/zydis/Zydis/Encoder.c
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/zydis/Zydis/Encoder.c')
-rw-r--r--js/src/zydis/Zydis/Encoder.c4742
1 files changed, 4742 insertions, 0 deletions
diff --git a/js/src/zydis/Zydis/Encoder.c b/js/src/zydis/Zydis/Encoder.c
new file mode 100644
index 0000000000..6f7256fe34
--- /dev/null
+++ b/js/src/zydis/Zydis/Encoder.c
@@ -0,0 +1,4742 @@
+/***************************************************************************************************
+
+ 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.
+
+***************************************************************************************************/
+
+// ReSharper disable CppClangTidyClangDiagnosticSwitchEnum
+// ReSharper disable CppClangTidyClangDiagnosticCoveredSwitchDefault
+// ReSharper disable CppClangTidyClangDiagnosticImplicitFallthrough
+
+#include "zydis/Zycore/LibC.h"
+#include "zydis/Zydis/Encoder.h"
+#include "zydis/Zydis/Utils.h"
+#include "zydis/Zydis/Internal/EncoderData.h"
+#include "zydis/Zydis/Internal/SharedData.h"
+
+/* ============================================================================================== */
+/* Macros */
+/* ============================================================================================== */
+
+/* ---------------------------------------------------------------------------------------------- */
+/* Constants */
+/* ---------------------------------------------------------------------------------------------- */
+
+#define ZYDIS_OPSIZE_MAP_BYTEOP 1
+#define ZYDIS_OPSIZE_MAP_DEFAULT64 4
+#define ZYDIS_OPSIZE_MAP_FORCE64 5
+#define ZYDIS_ADSIZE_MAP_IGNORED 1
+#define ZYDIS_LEGACY_SEGMENTS (ZYDIS_ATTRIB_HAS_SEGMENT_CS | \
+ ZYDIS_ATTRIB_HAS_SEGMENT_SS | \
+ ZYDIS_ATTRIB_HAS_SEGMENT_DS | \
+ ZYDIS_ATTRIB_HAS_SEGMENT_ES)
+#define ZYDIS_ENCODABLE_PREFIXES_NO_SEGMENTS (ZYDIS_ENCODABLE_PREFIXES ^ \
+ ZYDIS_ATTRIB_HAS_SEGMENT)
+
+/* ---------------------------------------------------------------------------------------------- */
+
+/* ============================================================================================== */
+/* Internal enums and types */
+/* ============================================================================================== */
+
+/**
+ * Usage of `REX.W` prefix makes it impossible to use some byte-sized registers. Values of this
+ * enum are used to track and facilitate enforcement of these restrictions.
+ */
+typedef enum ZydisEncoderRexType_
+{
+ ZYDIS_REX_TYPE_UNKNOWN,
+ ZYDIS_REX_TYPE_REQUIRED,
+ ZYDIS_REX_TYPE_FORBIDDEN,
+
+ /**
+ * Maximum value of this enum.
+ */
+ ZYDIS_REX_TYPE_MAX_VALUE = ZYDIS_REX_TYPE_FORBIDDEN,
+ /**
+ * The minimum number of bits required to represent all values of this enum.
+ */
+ ZYDIS_REX_TYPE_REQUIRED_BITS = ZYAN_BITS_TO_REPRESENT(ZYDIS_REX_TYPE_MAX_VALUE)
+} ZydisEncoderRexType;
+
+/**
+ * Primary structure used during instruction matching phase. Once filled it contains information
+ * about matched instruction definition and some values deduced from encoder request. It gets
+ * converted to `ZydisEncoderInstruction` during instruction building phase.
+ */
+typedef struct ZydisEncoderInstructionMatch_
+{
+ /**
+ * A pointer to the `ZydisEncoderRequest` instance.
+ */
+ const ZydisEncoderRequest *request;
+ /**
+ * A pointer to the `ZydisEncodableInstruction` instance.
+ */
+ const ZydisEncodableInstruction *definition;
+ /**
+ * A pointer to the `ZydisInstructionDefinition` instance.
+ */
+ const ZydisInstructionDefinition *base_definition;
+ /**
+ * A pointer to the `ZydisOperandDefinition` array.
+ */
+ const ZydisOperandDefinition *operands;
+ /**
+ * Encodable attributes for this instruction.
+ */
+ ZydisInstructionAttributes attributes;
+ /**
+ * Effective operand size attribute.
+ */
+ ZyanU8 eosz;
+ /**
+ * Effective address size attribute.
+ */
+ ZyanU8 easz;
+ /**
+ * Effective displacement size.
+ */
+ ZyanU8 disp_size;
+ /**
+ * Effective immediate size.
+ */
+ ZyanU8 imm_size;
+ /**
+ * Exponent of compressed displacement scale factor (2^cd8_scale)
+ */
+ ZyanU8 cd8_scale;
+ /**
+ * `REX` prefix constraints.
+ */
+ ZydisEncoderRexType rex_type;
+ /**
+ * True for special cases where operand size attribute must be lower than 64 bits.
+ */
+ ZyanBool eosz64_forbidden;
+ /**
+ * True when instruction definition has relative operand (used for branching instructions).
+ */
+ ZyanBool has_rel_operand;
+} ZydisEncoderInstructionMatch;
+
+/**
+ * Encapsulates information about writable buffer.
+ */
+typedef struct ZydisEncoderBuffer_
+{
+ /**
+ * A pointer to actual data buffer.
+ */
+ ZyanU8 *buffer;
+ /**
+ * Size of this buffer.
+ */
+ ZyanUSize size;
+ /**
+ * Current write offset.
+ */
+ ZyanUSize offset;
+} ZydisEncoderBuffer;
+
+/**
+ * Low-level instruction representation. Once filled this structure contains all information
+ * required for final instruction emission phase.
+ */
+typedef struct ZydisEncoderInstruction_
+{
+ /**
+ * Encodable attributes for this instruction.
+ */
+ ZydisInstructionAttributes attributes;
+ /**
+ * The instruction encoding.
+ */
+ ZydisInstructionEncoding encoding;
+ /**
+ * The opcode map.
+ */
+ ZydisOpcodeMap opcode_map;
+ /**
+ * The opcode.
+ */
+ ZyanU8 opcode;
+ /**
+ * The `vvvv` field (`VEX`, `EVEX`, `MVEX`, `XOP`).
+ */
+ ZyanU8 vvvv;
+ /**
+ * The `sss` field (`MVEX`).
+ */
+ ZyanU8 sss;
+ /**
+ * The mask register ID.
+ */
+ ZyanU8 mask;
+ /**
+ * The vector length.
+ */
+ ZyanU8 vector_length;
+ /**
+ * The `mod` component of Mod/RM byte.
+ */
+ ZyanU8 mod;
+ /**
+ * The `reg` component of Mod/RM byte.
+ */
+ ZyanU8 reg;
+ /**
+ * The `rm` component of Mod/RM byte.
+ */
+ ZyanU8 rm;
+ /**
+ * The scale component of SIB byte.
+ */
+ ZyanU8 scale;
+ /**
+ * The index component of SIB byte.
+ */
+ ZyanU8 index;
+ /**
+ * The base component of SIB byte.
+ */
+ ZyanU8 base;
+ /**
+ * The `REX.W` bit.
+ */
+ ZyanBool rex_w;
+ /**
+ * True if using zeroing mask (`EVEX`).
+ */
+ ZyanBool zeroing;
+ /**
+ * True if using eviction hint (`MVEX`).
+ */
+ ZyanBool eviction_hint;
+ /**
+ * Size of displacement value.
+ */
+ ZyanU8 disp_size;
+ /**
+ * Size of immediate value.
+ */
+ ZyanU8 imm_size;
+ /**
+ * The displacement value.
+ */
+ ZyanU64 disp;
+ /**
+ * The immediate value.
+ */
+ ZyanU64 imm;
+} ZydisEncoderInstruction;
+
+/* ============================================================================================== */
+/* Internal functions */
+/* ============================================================================================== */
+
+/**
+ * Converts `ZydisInstructionEncoding` to `ZydisEncodableEncoding`.
+ *
+ * @param encoding `ZydisInstructionEncoding` value to convert.
+ *
+ * @return Equivalent `ZydisEncodableEncoding` value.
+ */
+static ZydisEncodableEncoding ZydisGetEncodableEncoding(ZydisInstructionEncoding encoding)
+{
+ static const ZydisEncodableEncoding encoding_lookup[6] =
+ {
+ ZYDIS_ENCODABLE_ENCODING_LEGACY,
+ ZYDIS_ENCODABLE_ENCODING_3DNOW,
+ ZYDIS_ENCODABLE_ENCODING_XOP,
+ ZYDIS_ENCODABLE_ENCODING_VEX,
+ ZYDIS_ENCODABLE_ENCODING_EVEX,
+ ZYDIS_ENCODABLE_ENCODING_MVEX,
+ };
+ ZYAN_ASSERT((ZyanUSize)encoding <= ZYDIS_INSTRUCTION_ENCODING_MAX_VALUE);
+ return encoding_lookup[encoding];
+}
+
+/**
+ * Converts `ZydisMachineMode` to default stack width value expressed in bits.
+ *
+ * @param machine_mode `ZydisMachineMode` value to convert.
+ *
+ * @return Stack width for requested machine mode.
+ */
+static ZyanU8 ZydisGetMachineModeWidth(ZydisMachineMode machine_mode)
+{
+ switch (machine_mode)
+ {
+ case ZYDIS_MACHINE_MODE_REAL_16:
+ case ZYDIS_MACHINE_MODE_LEGACY_16:
+ case ZYDIS_MACHINE_MODE_LONG_COMPAT_16:
+ return 16;
+ case ZYDIS_MACHINE_MODE_LEGACY_32:
+ case ZYDIS_MACHINE_MODE_LONG_COMPAT_32:
+ return 32;
+ case ZYDIS_MACHINE_MODE_LONG_64:
+ return 64;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+}
+
+/**
+ * Converts `ZydisAddressSizeHint` to address size expressed in bits.
+ *
+ * @param hint Address size hint.
+ *
+ * @return Address size in bits.
+ */
+static ZyanU8 ZydisGetAszFromHint(ZydisAddressSizeHint hint)
+{
+ ZYAN_ASSERT((ZyanUSize)hint <= ZYDIS_ADDRESS_SIZE_HINT_MAX_VALUE);
+ static const ZyanU8 lookup[ZYDIS_ADDRESS_SIZE_HINT_MAX_VALUE + 1] = { 0, 16, 32, 64 };
+ return lookup[hint];
+}
+
+/**
+ * Converts `ZydisOperandSizeHint` to operand size expressed in bits.
+ *
+ * @param hint Operand size hint.
+ *
+ * @return Operand size in bits.
+ */
+static ZyanU8 ZydisGetOszFromHint(ZydisOperandSizeHint hint)
+{
+ ZYAN_ASSERT((ZyanUSize)hint <= ZYDIS_OPERAND_SIZE_HINT_MAX_VALUE);
+ static const ZyanU8 lookup[ZYDIS_OPERAND_SIZE_HINT_MAX_VALUE + 1] = { 0, 8, 16, 32, 64 };
+ return lookup[hint];
+}
+
+/**
+ * Calculates effective operand size.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param size_table Array of possible size values for different operand sizes.
+ * @param desired_size Operand size requested by caller.
+ * @param exact_match_mode True if desired_size must be matched exactly, false when
+ * "not lower than" matching is desired.
+ *
+ * @return Effective operand size in bits.
+ */
+static ZyanU8 ZydisGetOperandSizeFromElementSize(ZydisEncoderInstructionMatch *match,
+ const ZyanU16 *size_table, ZyanU16 desired_size, ZyanBool exact_match_mode)
+{
+ if ((match->base_definition->operand_size_map == ZYDIS_OPSIZE_MAP_DEFAULT64) &&
+ (match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64))
+ {
+ if ((exact_match_mode && (size_table[2] == desired_size)) ||
+ (!exact_match_mode && (size_table[2] >= desired_size)))
+ {
+ return 64;
+ }
+ else if (size_table[0] == desired_size)
+ {
+ return 16;
+ }
+ }
+ else if ((match->base_definition->operand_size_map == ZYDIS_OPSIZE_MAP_FORCE64) &&
+ (match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64))
+ {
+ if (size_table[2] == desired_size)
+ {
+ return 64;
+ }
+ }
+ else
+ {
+ static const ZyanI8 eosz_priority_lookup[4][3] =
+ {
+ { 0, 1, -1 },
+ { 1, 0, -1 },
+ { 1, 2, 0 },
+ };
+ const ZyanU8 eosz_index = ZydisGetMachineModeWidth(match->request->machine_mode) >> 5;
+ for (int i = 0; i < 3; ++i)
+ {
+ const ZyanI8 eosz_candidate = eosz_priority_lookup[eosz_index][i];
+ if ((eosz_candidate == -1) ||
+ !(match->definition->operand_sizes & (1 << eosz_candidate)))
+ {
+ continue;
+ }
+ if ((exact_match_mode && (size_table[eosz_candidate] == desired_size)) ||
+ (!exact_match_mode && (size_table[eosz_candidate] >= desired_size)))
+ {
+ return 16 << eosz_candidate;
+ }
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * Calculates effective immediate size.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param size_table Array of possible size values for different operand sizes.
+ * @param min_imm_size Minimum immediate size.
+ *
+ * @return Effective operand size in bits.
+ */
+static ZyanU8 ZydisGetScaledImmSize(ZydisEncoderInstructionMatch *match, const ZyanU16 *size_table,
+ ZyanU8 min_imm_size)
+{
+ if (match->eosz == 0)
+ {
+ match->eosz = ZydisGetOperandSizeFromElementSize(match, size_table, min_imm_size,
+ ZYAN_FALSE);
+ return match->eosz != 0 ? (ZyanU8)size_table[match->eosz >> 5] : 0;
+ }
+
+ const ZyanU8 index = match->eosz >> 5;
+ return size_table[index] >= min_imm_size ? (ZyanU8)size_table[index] : 0;
+}
+
+/**
+ * Calculates size of smallest integral type able to represent provided signed value.
+ *
+ * @param imm Immediate to be represented.
+ *
+ * @return Size of smallest integral type able to represent provided signed value.
+ */
+static ZyanU8 ZydisGetSignedImmSize(ZyanI64 imm)
+{
+ if (imm >= ZYAN_INT8_MIN && imm <= ZYAN_INT8_MAX)
+ {
+ return 8;
+ }
+ if (imm >= ZYAN_INT16_MIN && imm <= ZYAN_INT16_MAX)
+ {
+ return 16;
+ }
+ if (imm >= ZYAN_INT32_MIN && imm <= ZYAN_INT32_MAX)
+ {
+ return 32;
+ }
+
+ return 64;
+}
+
+/**
+ * Calculates size of smallest integral type able to represent provided unsigned value.
+ *
+ * @param imm Immediate to be represented.
+ *
+ * @return Size of smallest integral type able to represent provided unsigned value.
+ */
+static ZyanU8 ZydisGetUnsignedImmSize(ZyanU64 imm)
+{
+ if (imm <= ZYAN_UINT8_MAX)
+ {
+ return 8;
+ }
+ if (imm <= ZYAN_UINT16_MAX)
+ {
+ return 16;
+ }
+ if (imm <= ZYAN_UINT32_MAX)
+ {
+ return 32;
+ }
+
+ return 64;
+}
+
+/**
+ * Checks if operand encoding encodes a signed immediate value.
+ *
+ * @param encoding Operand encoding for immediate value.
+ *
+ * @return True for encodings that represent signed values, false otherwise.
+ */
+static ZyanBool ZydisIsImmSigned(ZydisOperandEncoding encoding)
+{
+ switch (encoding)
+ {
+ case ZYDIS_OPERAND_ENCODING_SIMM8:
+ case ZYDIS_OPERAND_ENCODING_SIMM16:
+ case ZYDIS_OPERAND_ENCODING_SIMM32:
+ case ZYDIS_OPERAND_ENCODING_SIMM64:
+ case ZYDIS_OPERAND_ENCODING_SIMM16_32_64:
+ case ZYDIS_OPERAND_ENCODING_SIMM32_32_64:
+ case ZYDIS_OPERAND_ENCODING_SIMM16_32_32:
+ case ZYDIS_OPERAND_ENCODING_JIMM8:
+ case ZYDIS_OPERAND_ENCODING_JIMM16:
+ case ZYDIS_OPERAND_ENCODING_JIMM32:
+ case ZYDIS_OPERAND_ENCODING_JIMM64:
+ case ZYDIS_OPERAND_ENCODING_JIMM16_32_64:
+ case ZYDIS_OPERAND_ENCODING_JIMM32_32_64:
+ case ZYDIS_OPERAND_ENCODING_JIMM16_32_32:
+ return ZYAN_TRUE;
+ case ZYDIS_OPERAND_ENCODING_DISP8:
+ case ZYDIS_OPERAND_ENCODING_DISP16:
+ case ZYDIS_OPERAND_ENCODING_DISP32:
+ case ZYDIS_OPERAND_ENCODING_DISP64:
+ case ZYDIS_OPERAND_ENCODING_DISP16_32_64:
+ case ZYDIS_OPERAND_ENCODING_DISP32_32_64:
+ case ZYDIS_OPERAND_ENCODING_DISP16_32_32:
+ case ZYDIS_OPERAND_ENCODING_UIMM8:
+ case ZYDIS_OPERAND_ENCODING_UIMM16:
+ case ZYDIS_OPERAND_ENCODING_UIMM32:
+ case ZYDIS_OPERAND_ENCODING_UIMM64:
+ case ZYDIS_OPERAND_ENCODING_UIMM16_32_64:
+ case ZYDIS_OPERAND_ENCODING_UIMM32_32_64:
+ case ZYDIS_OPERAND_ENCODING_UIMM16_32_32:
+ case ZYDIS_OPERAND_ENCODING_IS4:
+ return ZYAN_FALSE;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+}
+
+/**
+ * Calculates effective immediate size.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param imm Immediate value to encode.
+ * @param def_op Operand definition for immediate operand.
+ *
+ * @return Effective operand size in bits (0 if function failed).
+ */
+static ZyanU8 ZydisGetEffectiveImmSize(ZydisEncoderInstructionMatch *match, ZyanI64 imm,
+ const ZydisOperandDefinition *def_op)
+{
+ ZyanU8 eisz = 0;
+ ZyanU8 min_size = ZydisIsImmSigned((ZydisOperandEncoding)def_op->op.encoding)
+ ? ZydisGetSignedImmSize(imm)
+ : ZydisGetUnsignedImmSize((ZyanU64)imm);
+
+ switch (def_op->op.encoding)
+ {
+ case ZYDIS_OPERAND_ENCODING_UIMM8:
+ case ZYDIS_OPERAND_ENCODING_SIMM8:
+ eisz = 8;
+ break;
+ case ZYDIS_OPERAND_ENCODING_IS4:
+ ZYAN_ASSERT(def_op->element_type == ZYDIS_IELEMENT_TYPE_UINT8);
+ eisz = ((ZyanU64)imm <= 15) ? 8 : 0;
+ break;
+ case ZYDIS_OPERAND_ENCODING_UIMM16:
+ case ZYDIS_OPERAND_ENCODING_SIMM16:
+ eisz = 16;
+ break;
+ case ZYDIS_OPERAND_ENCODING_UIMM32:
+ case ZYDIS_OPERAND_ENCODING_SIMM32:
+ eisz = 32;
+ break;
+ case ZYDIS_OPERAND_ENCODING_UIMM64:
+ case ZYDIS_OPERAND_ENCODING_SIMM64:
+ eisz = 64;
+ break;
+ case ZYDIS_OPERAND_ENCODING_UIMM16_32_64:
+ case ZYDIS_OPERAND_ENCODING_SIMM16_32_64:
+ {
+ static const ZyanU16 simm16_32_64_sizes[3] = { 16, 32, 64 };
+ return ZydisGetScaledImmSize(match, simm16_32_64_sizes, min_size);
+ }
+ case ZYDIS_OPERAND_ENCODING_UIMM32_32_64:
+ case ZYDIS_OPERAND_ENCODING_SIMM32_32_64:
+ {
+ static const ZyanU16 simm32_32_64_sizes[3] = { 32, 32, 64 };
+ return ZydisGetScaledImmSize(match, simm32_32_64_sizes, min_size);
+ }
+ case ZYDIS_OPERAND_ENCODING_UIMM16_32_32:
+ case ZYDIS_OPERAND_ENCODING_SIMM16_32_32:
+ {
+ static const ZyanU16 simm16_32_32_sizes[3] = { 16, 32, 32 };
+ return ZydisGetScaledImmSize(match, simm16_32_32_sizes, min_size);
+ }
+ case ZYDIS_OPERAND_ENCODING_DISP16_32_64:
+ ZYAN_ASSERT(match->easz == 0);
+ if (match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
+ {
+ if (min_size < 32)
+ {
+ min_size = 32;
+ }
+ if (min_size == 32 || min_size == 64)
+ {
+ match->easz = eisz = min_size;
+ }
+ }
+ else
+ {
+ if (min_size < 16)
+ {
+ min_size = 16;
+ }
+ if (min_size == 16 || min_size == 32)
+ {
+ match->easz = eisz = min_size;
+ }
+ }
+ break;
+ case ZYDIS_OPERAND_ENCODING_JIMM8:
+ case ZYDIS_OPERAND_ENCODING_JIMM16:
+ case ZYDIS_OPERAND_ENCODING_JIMM32:
+ case ZYDIS_OPERAND_ENCODING_JIMM64:
+ {
+ ZyanU8 jimm_index = def_op->op.encoding - ZYDIS_OPERAND_ENCODING_JIMM8;
+ if ((match->request->branch_width != ZYDIS_BRANCH_WIDTH_NONE) &&
+ (match->request->branch_width != (ZydisBranchWidth)(ZYDIS_BRANCH_WIDTH_8 + jimm_index)))
+ {
+ return 0;
+ }
+ eisz = 8 << jimm_index;
+ break;
+ }
+ case ZYDIS_OPERAND_ENCODING_JIMM16_32_32:
+ switch (match->request->branch_width)
+ {
+ case ZYDIS_BRANCH_WIDTH_NONE:
+ {
+ static const ZyanU16 jimm16_32_32_sizes[3] = { 16, 32, 32 };
+ return ZydisGetScaledImmSize(match, jimm16_32_32_sizes, min_size);
+ }
+ case ZYDIS_BRANCH_WIDTH_16:
+ eisz = 16;
+ break;
+ case ZYDIS_BRANCH_WIDTH_32:
+ eisz = 32;
+ break;
+ case ZYDIS_BRANCH_WIDTH_8:
+ case ZYDIS_BRANCH_WIDTH_64:
+ return 0;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ return eisz >= min_size ? eisz : 0;
+}
+
+/**
+ * Checks if register width is compatible with effective operand size.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param reg_width Register width in bits.
+ *
+ * @return True if width is compatible, false otherwise.
+ */
+static ZyanBool ZydisCheckOsz(ZydisEncoderInstructionMatch *match, ZydisRegisterWidth reg_width)
+{
+ ZYAN_ASSERT(reg_width <= ZYAN_UINT8_MAX);
+ if (match->eosz == 0)
+ {
+ if (reg_width == 8)
+ {
+ return ZYAN_FALSE;
+ }
+ match->eosz = (ZyanU8)reg_width;
+ return ZYAN_TRUE;
+ }
+
+ return match->eosz == (ZyanU8)reg_width ? ZYAN_TRUE : ZYAN_FALSE;
+}
+
+/**
+ * Checks if register width is compatible with effective address size.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param reg_width Register width in bits.
+ *
+ * @return True if width is compatible, false otherwise.
+ */
+static ZyanBool ZydisCheckAsz(ZydisEncoderInstructionMatch *match, ZydisRegisterWidth reg_width)
+{
+ ZYAN_ASSERT(reg_width <= ZYAN_UINT8_MAX);
+ if (match->easz == 0)
+ {
+ if ((match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64) &&
+ (reg_width == 16))
+ {
+ return ZYAN_FALSE;
+ }
+ match->easz = (ZyanU8)reg_width;
+ return ZYAN_TRUE;
+ }
+
+ return match->easz == (ZyanU8)reg_width ? ZYAN_TRUE : ZYAN_FALSE;
+}
+
+/**
+ * Checks if specified register is valid for provided register class, encoding and machine mode.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param reg `ZydisRegister` value.
+ * @param reg_class Register class.
+ *
+ * @return True if register value is allowed, false otherwise.
+ */
+static ZyanBool ZydisIsRegisterAllowed(ZydisEncoderInstructionMatch *match, ZydisRegister reg,
+ ZydisRegisterClass reg_class)
+{
+ const ZyanI8 reg_id = ZydisRegisterGetId(reg);
+ ZYAN_ASSERT(reg_id >= 0 && reg_id <= 31);
+ if (match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
+ {
+ if ((match->definition->encoding != ZYDIS_INSTRUCTION_ENCODING_EVEX) &&
+ (match->definition->encoding != ZYDIS_INSTRUCTION_ENCODING_MVEX) &&
+ (reg_class != ZYDIS_REGCLASS_GPR8) &&
+ (reg_id >= 16))
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ else
+ {
+ if (reg_class == ZYDIS_REGCLASS_GPR64)
+ {
+ return ZYAN_FALSE;
+ }
+ if (reg_id >= 8)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+
+ return ZYAN_TRUE;
+}
+
+/**
+ * Checks if specified scale value is valid for use with SIB addressing.
+ *
+ * @param scale Scale value.
+ *
+ * @return True if value is valid, false otherwise.
+ */
+static ZyanBool ZydisIsScaleValid(ZyanU8 scale)
+{
+ switch (scale)
+ {
+ case 0:
+ case 1:
+ case 2:
+ case 4:
+ case 8:
+ return ZYAN_TRUE;
+ default:
+ return ZYAN_FALSE;
+ }
+}
+
+/**
+ * Enforces register usage constraints associated with usage of `REX` prefix.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param reg `ZydisRegister` value.
+ * @param addressing_mode True if checked address is used for address calculations. This
+ * implies more permissive checks.
+ *
+ * @return True if register usage is allowed, false otherwise.
+ */
+static ZyanBool ZydisValidateRexType(ZydisEncoderInstructionMatch *match, ZydisRegister reg,
+ ZyanBool addressing_mode)
+{
+ switch (reg)
+ {
+ case ZYDIS_REGISTER_AL:
+ case ZYDIS_REGISTER_CL:
+ case ZYDIS_REGISTER_DL:
+ case ZYDIS_REGISTER_BL:
+ return ZYAN_TRUE;
+ case ZYDIS_REGISTER_AH:
+ case ZYDIS_REGISTER_CH:
+ case ZYDIS_REGISTER_DH:
+ case ZYDIS_REGISTER_BH:
+ if (match->rex_type == ZYDIS_REX_TYPE_UNKNOWN)
+ {
+ match->rex_type = ZYDIS_REX_TYPE_FORBIDDEN;
+ }
+ else if (match->rex_type == ZYDIS_REX_TYPE_REQUIRED)
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_REGISTER_SPL:
+ case ZYDIS_REGISTER_BPL:
+ case ZYDIS_REGISTER_SIL:
+ case ZYDIS_REGISTER_DIL:
+ case ZYDIS_REGISTER_R8B:
+ case ZYDIS_REGISTER_R9B:
+ case ZYDIS_REGISTER_R10B:
+ case ZYDIS_REGISTER_R11B:
+ case ZYDIS_REGISTER_R12B:
+ case ZYDIS_REGISTER_R13B:
+ case ZYDIS_REGISTER_R14B:
+ case ZYDIS_REGISTER_R15B:
+ if (match->rex_type == ZYDIS_REX_TYPE_UNKNOWN)
+ {
+ match->rex_type = ZYDIS_REX_TYPE_REQUIRED;
+ }
+ else if (match->rex_type == ZYDIS_REX_TYPE_FORBIDDEN)
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ default:
+ if ((ZydisRegisterGetId(reg) > 7) ||
+ (!addressing_mode && (ZydisRegisterGetClass(reg) == ZYDIS_REGCLASS_GPR64)))
+ {
+ if (match->rex_type == ZYDIS_REX_TYPE_UNKNOWN)
+ {
+ match->rex_type = ZYDIS_REX_TYPE_REQUIRED;
+ }
+ else if (match->rex_type == ZYDIS_REX_TYPE_FORBIDDEN)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ break;
+ }
+
+ return ZYAN_TRUE;
+}
+
+/**
+ * Checks if specified register is valid for use with SIB addressing.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param reg_class Register class.
+ * @param reg `ZydisRegister` value.
+ *
+ * @return True if register value is allowed, false otherwise.
+ */
+static ZyanBool ZydisIsValidAddressingClass(ZydisEncoderInstructionMatch *match,
+ ZydisRegisterClass reg_class, ZydisRegister reg)
+{
+ ZyanBool result;
+ const ZyanBool is_64 = (match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64);
+ switch (reg_class)
+ {
+ case ZYDIS_REGCLASS_INVALID:
+ return ZYAN_TRUE;
+ case ZYDIS_REGCLASS_GPR16:
+ result = !is_64;
+ break;
+ case ZYDIS_REGCLASS_GPR32:
+ result = is_64 || ZydisRegisterGetId(reg) < 8;
+ break;
+ case ZYDIS_REGCLASS_GPR64:
+ result = is_64;
+ break;
+ default:
+ return ZYAN_FALSE;
+ }
+
+ return result && ZydisValidateRexType(match, reg, ZYAN_TRUE);
+}
+
+/**
+ * Helper function that determines correct `ModR/M.RM` value for 16-bit addressing mode.
+ *
+ * @param base `ZydisRegister` used as `SIB.base`.
+ * @param index `ZydisRegister` used as `SIB.index`.
+ *
+ * @return `ModR/M.RM` value (-1 if function failed).
+ */
+static ZyanI8 ZydisGetRm16(ZydisRegister base, ZydisRegister index)
+{
+ static const ZydisRegister modrm16_lookup[8][2] =
+ {
+ { ZYDIS_REGISTER_BX, ZYDIS_REGISTER_SI },
+ { ZYDIS_REGISTER_BX, ZYDIS_REGISTER_DI },
+ { ZYDIS_REGISTER_BP, ZYDIS_REGISTER_SI },
+ { ZYDIS_REGISTER_BP, ZYDIS_REGISTER_DI },
+ { ZYDIS_REGISTER_SI, ZYDIS_REGISTER_NONE },
+ { ZYDIS_REGISTER_DI, ZYDIS_REGISTER_NONE },
+ { ZYDIS_REGISTER_BP, ZYDIS_REGISTER_NONE },
+ { ZYDIS_REGISTER_BX, ZYDIS_REGISTER_NONE },
+ };
+ for (ZyanI8 i = 0; i < (ZyanI8)ZYAN_ARRAY_LENGTH(modrm16_lookup); ++i)
+ {
+ if ((modrm16_lookup[i][0] == base) &&
+ (modrm16_lookup[i][1] == index))
+ {
+ return i;
+ }
+ }
+
+ return -1;
+}
+
+/**
+ * Encodes `MVEX.sss` field for specified broadcast mode.
+ *
+ * @param broadcast Broadcast mode.
+ *
+ * @return Corresponding `MVEX.sss` value.
+ */
+static ZyanU8 ZydisEncodeMvexBroadcastMode(ZydisBroadcastMode broadcast)
+{
+ switch (broadcast)
+ {
+ case ZYDIS_BROADCAST_MODE_INVALID:
+ return 0;
+ case ZYDIS_BROADCAST_MODE_1_TO_16:
+ case ZYDIS_BROADCAST_MODE_1_TO_8:
+ return 1;
+ case ZYDIS_BROADCAST_MODE_4_TO_16:
+ case ZYDIS_BROADCAST_MODE_4_TO_8:
+ return 2;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+}
+
+/**
+ * Encodes `MVEX.sss` field for specified conversion mode.
+ *
+ * @param conversion Conversion mode.
+ *
+ * @return Corresponding `MVEX.sss` value.
+ */
+static ZyanU8 ZydisEncodeMvexConversionMode(ZydisConversionMode conversion)
+{
+ switch (conversion)
+ {
+ case ZYDIS_CONVERSION_MODE_INVALID:
+ return 0;
+ case ZYDIS_CONVERSION_MODE_FLOAT16:
+ return 3;
+ case ZYDIS_CONVERSION_MODE_UINT8:
+ return 4;
+ case ZYDIS_CONVERSION_MODE_SINT8:
+ return 5;
+ case ZYDIS_CONVERSION_MODE_UINT16:
+ return 6;
+ case ZYDIS_CONVERSION_MODE_SINT16:
+ return 7;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+}
+
+/**
+ * Determines scale factor for compressed 8-bit displacement (`EVEX` instructions only).
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ *
+ * @return log2(scale factor)
+ */
+static ZyanU8 ZydisGetCompDispScaleEvex(const ZydisEncoderInstructionMatch *match)
+{
+ const ZydisInstructionDefinitionEVEX *evex_def =
+ (const ZydisInstructionDefinitionEVEX *)match->base_definition;
+
+ ZYAN_ASSERT(match->definition->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX);
+ ZYAN_ASSERT(evex_def->tuple_type);
+ ZYAN_ASSERT(evex_def->element_size);
+ const ZyanU8 vector_length = match->definition->vector_length - ZYDIS_VECTOR_LENGTH_128;
+ static const ZyanU8 size_indexes[ZYDIS_IELEMENT_SIZE_MAX_VALUE + 1] =
+ {
+ 0, 0, 0, 1, 2, 4
+ };
+ ZYAN_ASSERT(evex_def->element_size < ZYAN_ARRAY_LENGTH(size_indexes));
+ const ZyanU8 size_index = size_indexes[evex_def->element_size];
+ switch (evex_def->tuple_type)
+ {
+ case ZYDIS_TUPLETYPE_FV:
+ {
+ static const ZyanU8 scales[2][3][3] =
+ {
+ /*B0*/ { /*16*/ { 4, 5, 6 }, /*32*/ { 4, 5, 6 }, /*64*/ { 4, 5, 6 } },
+ /*B1*/ { /*16*/ { 1, 1, 1 }, /*32*/ { 2, 2, 2 }, /*64*/ { 3, 3, 3 } }
+ };
+ const ZyanU8 broadcast = match->request->evex.broadcast ? 1 : 0;
+ ZYAN_ASSERT(size_index < 3);
+ return scales[broadcast][size_index][vector_length];
+ }
+ case ZYDIS_TUPLETYPE_HV:
+ {
+ static const ZyanU8 scales[2][2][3] =
+ {
+ /*B0*/ { /*16*/ { 3, 4, 5 }, /*32*/ { 3, 4, 5 } },
+ /*B1*/ { /*16*/ { 1, 1, 1 }, /*32*/ { 2, 2, 2 } }
+ };
+ const ZyanU8 broadcast = match->request->evex.broadcast ? 1 : 0;
+ ZYAN_ASSERT(size_index < 3);
+ return scales[broadcast][size_index][vector_length];
+ }
+ case ZYDIS_TUPLETYPE_FVM:
+ {
+ static const ZyanU8 scales[3] =
+ {
+ 4, 5, 6
+ };
+ return scales[vector_length];
+ }
+ case ZYDIS_TUPLETYPE_GSCAT:
+ case ZYDIS_TUPLETYPE_T1S:
+ {
+ static const ZyanU8 scales[6] =
+ {
+ /* */ 0,
+ /* 8*/ 0,
+ /* 16*/ 1,
+ /* 32*/ 2,
+ /* 64*/ 3,
+ /*128*/ 4
+ };
+ ZYAN_ASSERT(evex_def->element_size < ZYAN_ARRAY_LENGTH(scales));
+ return scales[evex_def->element_size];
+ }
+ case ZYDIS_TUPLETYPE_T1F:
+ {
+ static const ZyanU8 scales[3] =
+ {
+ /* 16*/ 1,
+ /* 32*/ 2,
+ /* 64*/ 3
+ };
+ ZYAN_ASSERT(size_index < 3);
+ return scales[size_index];
+ }
+ case ZYDIS_TUPLETYPE_T1_4X:
+ return 4;
+ case ZYDIS_TUPLETYPE_T2:
+ return match->definition->rex_w ? 4 : 3;
+ case ZYDIS_TUPLETYPE_T4:
+ return match->definition->rex_w ? 5 : 4;
+ case ZYDIS_TUPLETYPE_T8:
+ return 5;
+ case ZYDIS_TUPLETYPE_HVM:
+ {
+ static const ZyanU8 scales[3] =
+ {
+ 3, 4, 5
+ };
+ return scales[vector_length];
+ }
+ case ZYDIS_TUPLETYPE_QVM:
+ {
+ static const ZyanU8 scales[3] =
+ {
+ 2, 3, 4
+ };
+ return scales[vector_length];
+ }
+ case ZYDIS_TUPLETYPE_OVM:
+ {
+ static const ZyanU8 scales[3] =
+ {
+ 1, 2, 3
+ };
+ return scales[vector_length];
+ }
+ case ZYDIS_TUPLETYPE_M128:
+ return 4;
+ case ZYDIS_TUPLETYPE_DUP:
+ {
+ static const ZyanU8 scales[3] =
+ {
+ 3, 5, 6
+ };
+ return scales[vector_length];
+ }
+ case ZYDIS_TUPLETYPE_QUARTER:
+ {
+ static const ZyanU8 scales[2][3] =
+ {
+ /*B0*/ { 2, 3, 4 },
+ /*B1*/ { 1, 1, 1 }
+ };
+ const ZyanU8 broadcast = match->request->evex.broadcast ? 1 : 0;
+ return scales[broadcast][vector_length];
+ }
+ default:
+ ZYAN_UNREACHABLE;
+ }
+}
+
+/**
+ * Determines scale factor for compressed 8-bit displacement (`MVEX` instructions only).
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ *
+ * @return log2(scale factor)
+ */
+static ZyanU8 ZydisGetCompDispScaleMvex(const ZydisEncoderInstructionMatch *match)
+{
+ const ZydisInstructionDefinitionMVEX *mvex_def =
+ (const ZydisInstructionDefinitionMVEX *)match->base_definition;
+
+ ZyanU8 index = mvex_def->has_element_granularity;
+ ZYAN_ASSERT(!index || !mvex_def->broadcast);
+ if (!index && mvex_def->broadcast)
+ {
+ switch (mvex_def->broadcast)
+ {
+ case ZYDIS_MVEX_STATIC_BROADCAST_1_TO_8:
+ case ZYDIS_MVEX_STATIC_BROADCAST_1_TO_16:
+ index = 1;
+ break;
+ case ZYDIS_MVEX_STATIC_BROADCAST_4_TO_8:
+ case ZYDIS_MVEX_STATIC_BROADCAST_4_TO_16:
+ index = 2;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ }
+
+ const ZyanU8 sss = ZydisEncodeMvexBroadcastMode(match->request->mvex.broadcast) |
+ ZydisEncodeMvexConversionMode(match->request->mvex.conversion);
+ switch (mvex_def->functionality)
+ {
+ case ZYDIS_MVEX_FUNC_IGNORED:
+ case ZYDIS_MVEX_FUNC_INVALID:
+ case ZYDIS_MVEX_FUNC_RC:
+ case ZYDIS_MVEX_FUNC_SAE:
+ case ZYDIS_MVEX_FUNC_SWIZZLE_32:
+ case ZYDIS_MVEX_FUNC_SWIZZLE_64:
+ return 0;
+ case ZYDIS_MVEX_FUNC_F_32:
+ case ZYDIS_MVEX_FUNC_I_32:
+ case ZYDIS_MVEX_FUNC_F_64:
+ case ZYDIS_MVEX_FUNC_I_64:
+ return 6;
+ case ZYDIS_MVEX_FUNC_SF_32:
+ case ZYDIS_MVEX_FUNC_SF_32_BCST:
+ case ZYDIS_MVEX_FUNC_SF_32_BCST_4TO16:
+ case ZYDIS_MVEX_FUNC_UF_32:
+ {
+ static const ZyanU8 lookup[3][8] =
+ {
+ { 6, 2, 4, 5, 4, 4, 5, 5 },
+ { 2, 0, 0, 1, 0, 0, 1, 1 },
+ { 4, 0, 0, 3, 2, 2, 3, 3 }
+ };
+ ZYAN_ASSERT(sss < ZYAN_ARRAY_LENGTH(lookup[index]));
+ return lookup[index][sss];
+ }
+ case ZYDIS_MVEX_FUNC_SI_32:
+ case ZYDIS_MVEX_FUNC_UI_32:
+ case ZYDIS_MVEX_FUNC_SI_32_BCST:
+ case ZYDIS_MVEX_FUNC_SI_32_BCST_4TO16:
+ {
+ static const ZyanU8 lookup[3][8] =
+ {
+ { 6, 2, 4, 0, 4, 4, 5, 5 },
+ { 2, 0, 0, 0, 0, 0, 1, 1 },
+ { 4, 0, 0, 0, 2, 2, 3, 3 }
+ };
+ ZYAN_ASSERT(sss < ZYAN_ARRAY_LENGTH(lookup[index]));
+ return lookup[index][sss];
+ }
+ case ZYDIS_MVEX_FUNC_SF_64:
+ case ZYDIS_MVEX_FUNC_UF_64:
+ case ZYDIS_MVEX_FUNC_SI_64:
+ case ZYDIS_MVEX_FUNC_UI_64:
+ {
+ static const ZyanU8 lookup[3][3] =
+ {
+ { 6, 3, 5 },
+ { 3, 0, 0 },
+ { 5, 0, 0 }
+ };
+ ZYAN_ASSERT(sss < ZYAN_ARRAY_LENGTH(lookup[index]));
+ return lookup[index][sss];
+ }
+ case ZYDIS_MVEX_FUNC_DF_32:
+ case ZYDIS_MVEX_FUNC_DI_32:
+ {
+ static const ZyanU8 lookup[2][8] =
+ {
+ { 6, 0, 0, 5, 4, 4, 5, 5 },
+ { 2, 0, 0, 1, 0, 0, 1, 1 }
+ };
+ ZYAN_ASSERT(index < 2);
+ ZYAN_ASSERT(sss < ZYAN_ARRAY_LENGTH(lookup[index]));
+ return lookup[index][sss];
+ }
+ case ZYDIS_MVEX_FUNC_DF_64:
+ case ZYDIS_MVEX_FUNC_DI_64:
+ ZYAN_ASSERT(index < 2);
+ return index == 0 ? 6 : 3;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+}
+
+/**
+ * Determines scale factor for compressed 8-bit displacement.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ *
+ * @return log2(scale factor)
+ */
+static ZyanU8 ZydisGetCompDispScale(const ZydisEncoderInstructionMatch *match)
+{
+ switch (match->definition->encoding)
+ {
+ case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
+ case ZYDIS_INSTRUCTION_ENCODING_3DNOW:
+ case ZYDIS_INSTRUCTION_ENCODING_XOP:
+ case ZYDIS_INSTRUCTION_ENCODING_VEX:
+ return 0;
+ case ZYDIS_INSTRUCTION_ENCODING_EVEX:
+ return ZydisGetCompDispScaleEvex(match);
+ case ZYDIS_INSTRUCTION_ENCODING_MVEX:
+ return ZydisGetCompDispScaleMvex(match);
+ default:
+ ZYAN_UNREACHABLE;
+ }
+}
+
+/**
+ * Checks if requested operand matches register operand from instruction definition.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param user_op Operand definition from `ZydisEncoderRequest` structure.
+ * @param def_op Decoder's operand definition from current instruction definition.
+ *
+ * @return True if operands match, false otherwise.
+ */
+static ZyanBool ZydisIsRegisterOperandCompatible(ZydisEncoderInstructionMatch *match,
+ const ZydisEncoderOperand *user_op, const ZydisOperandDefinition *def_op)
+{
+ const ZydisRegisterClass reg_class = ZydisRegisterGetClass(user_op->reg.value);
+ const ZydisRegisterWidth reg_width = ZydisRegisterClassGetWidth(match->request->machine_mode,
+ reg_class);
+ if (reg_width == 0)
+ {
+ return ZYAN_FALSE;
+ }
+
+ ZyanBool is4_expected_value = ZYAN_FALSE;
+ switch (def_op->type)
+ {
+ case ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG:
+ switch (def_op->op.reg.type)
+ {
+ case ZYDIS_IMPLREG_TYPE_STATIC:
+ if (def_op->op.reg.reg.reg != user_op->reg.value)
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_IMPLREG_TYPE_GPR_OSZ:
+ if ((reg_class != ZYDIS_REGCLASS_GPR8) &&
+ (reg_class != ZYDIS_REGCLASS_GPR16) &&
+ (reg_class != ZYDIS_REGCLASS_GPR32) &&
+ (reg_class != ZYDIS_REGCLASS_GPR64))
+ {
+ return ZYAN_FALSE;
+ }
+ if (def_op->op.reg.reg.id != ZydisRegisterGetId(user_op->reg.value))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisCheckOsz(match, reg_width))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_IMPLREG_TYPE_GPR_ASZ:
+ if ((reg_class != ZYDIS_REGCLASS_GPR8) &&
+ (reg_class != ZYDIS_REGCLASS_GPR16) &&
+ (reg_class != ZYDIS_REGCLASS_GPR32) &&
+ (reg_class != ZYDIS_REGCLASS_GPR64))
+ {
+ return ZYAN_FALSE;
+ }
+ if (def_op->op.reg.reg.id != ZydisRegisterGetId(user_op->reg.value))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisCheckAsz(match, reg_width))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_GPR8:
+ if (reg_class != ZYDIS_REGCLASS_GPR8)
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisIsRegisterAllowed(match, user_op->reg.value, reg_class))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisValidateRexType(match, user_op->reg.value, ZYAN_FALSE))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_GPR16:
+ if (reg_class != ZYDIS_REGCLASS_GPR16)
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisIsRegisterAllowed(match, user_op->reg.value, reg_class))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_GPR32:
+ if (reg_class != ZYDIS_REGCLASS_GPR32)
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisIsRegisterAllowed(match, user_op->reg.value, reg_class))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_GPR64:
+ if (reg_class != ZYDIS_REGCLASS_GPR64)
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_GPR16_32_64:
+ if ((reg_class != ZYDIS_REGCLASS_GPR16) &&
+ (reg_class != ZYDIS_REGCLASS_GPR32) &&
+ (reg_class != ZYDIS_REGCLASS_GPR64))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisCheckOsz(match, reg_width))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisIsRegisterAllowed(match, user_op->reg.value, reg_class))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisValidateRexType(match, user_op->reg.value, ZYAN_FALSE))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_GPR32_32_64:
+ if ((reg_class != ZYDIS_REGCLASS_GPR32) &&
+ (reg_class != ZYDIS_REGCLASS_GPR64))
+ {
+ return ZYAN_FALSE;
+ }
+ if (match->eosz == 0)
+ {
+ if (reg_class == ZYDIS_REGCLASS_GPR64)
+ {
+ match->eosz = 64;
+ }
+ else
+ {
+ match->eosz64_forbidden = ZYAN_TRUE;
+ }
+ }
+ else if (match->eosz != (ZyanU8)reg_width)
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisIsRegisterAllowed(match, user_op->reg.value, reg_class))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisValidateRexType(match, user_op->reg.value, ZYAN_FALSE))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_GPR16_32_32:
+ if ((reg_class != ZYDIS_REGCLASS_GPR16) &&
+ (reg_class != ZYDIS_REGCLASS_GPR32))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisCheckOsz(match, reg_width))
+ {
+ if (match->eosz != 64 || reg_class != ZYDIS_REGCLASS_GPR32)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ if (!ZydisIsRegisterAllowed(match, user_op->reg.value, reg_class))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_GPR_ASZ:
+ if ((reg_class != ZYDIS_REGCLASS_GPR16) &&
+ (reg_class != ZYDIS_REGCLASS_GPR32) &&
+ (reg_class != ZYDIS_REGCLASS_GPR64))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisCheckAsz(match, reg_width))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisIsRegisterAllowed(match, user_op->reg.value, reg_class))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_FPR:
+ if (reg_class != ZYDIS_REGCLASS_X87)
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_MMX:
+ if (reg_class != ZYDIS_REGCLASS_MMX)
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_XMM:
+ if (reg_class != ZYDIS_REGCLASS_XMM)
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisIsRegisterAllowed(match, user_op->reg.value, reg_class))
+ {
+ return ZYAN_FALSE;
+ }
+ is4_expected_value = def_op->op.encoding == ZYDIS_OPERAND_ENCODING_IS4;
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_YMM:
+ if (reg_class != ZYDIS_REGCLASS_YMM)
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisIsRegisterAllowed(match, user_op->reg.value, reg_class))
+ {
+ return ZYAN_FALSE;
+ }
+ is4_expected_value = def_op->op.encoding == ZYDIS_OPERAND_ENCODING_IS4;
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_ZMM:
+ if (reg_class != ZYDIS_REGCLASS_ZMM)
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisIsRegisterAllowed(match, user_op->reg.value, reg_class))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_TMM:
+ if (reg_class != ZYDIS_REGCLASS_TMM)
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_BND:
+ if (reg_class != ZYDIS_REGCLASS_BOUND)
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_SREG:
+ if (reg_class != ZYDIS_REGCLASS_SEGMENT)
+ {
+ return ZYAN_FALSE;
+ }
+ if ((def_op->actions & ZYDIS_OPERAND_ACTION_MASK_WRITE) &&
+ (user_op->reg.value == ZYDIS_REGISTER_CS))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_CR:
+ {
+ if (reg_class != ZYDIS_REGCLASS_CONTROL)
+ {
+ return ZYAN_FALSE;
+ }
+ static const ZyanU8 cr_lookup[16] =
+ {
+ 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0
+ };
+ const ZyanI8 reg_id = ZydisRegisterGetId(user_op->reg.value);
+ if ((match->request->machine_mode != ZYDIS_MACHINE_MODE_LONG_64) &&
+ (reg_id == 8))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!cr_lookup[reg_id])
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ }
+ case ZYDIS_SEMANTIC_OPTYPE_DR:
+ if (reg_class != ZYDIS_REGCLASS_DEBUG)
+ {
+ return ZYAN_FALSE;
+ }
+ if (user_op->reg.value >= ZYDIS_REGISTER_DR8)
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_MASK:
+ if (reg_class != ZYDIS_REGCLASS_MASK)
+ {
+ return ZYAN_FALSE;
+ }
+
+ // MVEX does not require similar policy check
+ if ((match->definition->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX) &&
+ (def_op->op.encoding == ZYDIS_OPERAND_ENCODING_MASK))
+ {
+ const ZydisInstructionDefinitionEVEX *evex_def =
+ (const ZydisInstructionDefinitionEVEX *)match->base_definition;
+ ZYAN_ASSERT((evex_def->mask_policy != ZYDIS_MASK_POLICY_INVALID) &&
+ (evex_def->mask_policy != ZYDIS_MASK_POLICY_FORBIDDEN));
+ if ((evex_def->mask_policy == ZYDIS_MASK_POLICY_REQUIRED) &&
+ (user_op->reg.value == ZYDIS_REGISTER_K0))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((evex_def->mask_policy == ZYDIS_MASK_POLICY_ALLOWED) &&
+ (match->request->evex.zeroing_mask) &&
+ (user_op->reg.value == ZYDIS_REGISTER_K0))
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ if (user_op->reg.is4 != is4_expected_value)
+ {
+ return ZYAN_FALSE;
+ }
+
+ return ZYAN_TRUE;
+}
+
+/**
+ * Checks if requested operand matches memory operand from instruction definition.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param user_op Operand definition from `ZydisEncoderRequest` structure.
+ * @param def_op Decoder's operand definition from current instruction definition.
+ *
+ * @return True if operands match, false otherwise.
+ */
+static ZyanBool ZydisIsMemoryOperandCompatible(ZydisEncoderInstructionMatch *match,
+ const ZydisEncoderOperand *user_op, const ZydisOperandDefinition *def_op)
+{
+ switch (def_op->type)
+ {
+ case ZYDIS_SEMANTIC_OPTYPE_MEM:
+ case ZYDIS_SEMANTIC_OPTYPE_AGEN:
+ case ZYDIS_SEMANTIC_OPTYPE_MIB:
+ case ZYDIS_SEMANTIC_OPTYPE_MEM_VSIBX:
+ case ZYDIS_SEMANTIC_OPTYPE_MEM_VSIBY:
+ case ZYDIS_SEMANTIC_OPTYPE_MEM_VSIBZ:
+ {
+ if ((def_op->type == ZYDIS_SEMANTIC_OPTYPE_MIB) &&
+ (user_op->mem.scale != 0))
+ {
+ return ZYAN_FALSE;
+ }
+ ZyanI64 displacement = user_op->mem.displacement;
+ ZyanU8 disp_size = 0;
+ if (displacement)
+ {
+ disp_size = ZydisGetSignedImmSize(displacement);
+ if (disp_size > 32)
+ {
+ return ZYAN_FALSE;
+ }
+ if (ZydisGetMachineModeWidth(match->request->machine_mode) == 16)
+ {
+ if ((ZyanI16)displacement == 0)
+ {
+ disp_size = 0;
+ }
+ else
+ {
+ disp_size = ZydisGetSignedImmSize((ZyanI16)displacement);
+ }
+ }
+
+ match->cd8_scale = ZydisGetCompDispScale(match);
+ if (match->cd8_scale)
+ {
+ const ZyanI64 mask = (1 << match->cd8_scale) - 1;
+ if (!(displacement & mask))
+ {
+ disp_size = ZydisGetSignedImmSize(displacement >> match->cd8_scale);
+ }
+ else if (disp_size == 8)
+ {
+ disp_size = 16;
+ }
+ }
+ }
+
+ if (def_op->type != ZYDIS_SEMANTIC_OPTYPE_AGEN)
+ {
+ if (match->eosz != 0)
+ {
+ const ZyanU8 eosz_index = match->eosz >> 5;
+ if (def_op->size[eosz_index] != user_op->mem.size)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ else if ((match->definition->vector_length != ZYDIS_VECTOR_LENGTH_INVALID) ||
+ (match->definition->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX))
+ {
+ ZyanU8 eosz_index = ZydisGetMachineModeWidth(match->request->machine_mode) >> 5;
+ if (match->eosz64_forbidden && (eosz_index == 2))
+ {
+ eosz_index = 1;
+ }
+ ZyanU16 allowed_mem_size = def_op->size[eosz_index];
+ if ((!allowed_mem_size) &&
+ (match->definition->encoding != ZYDIS_INSTRUCTION_ENCODING_VEX))
+ {
+ ZYAN_ASSERT((match->definition->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX) ||
+ (match->definition->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX));
+ switch (match->definition->vector_length)
+ {
+ case ZYDIS_VECTOR_LENGTH_128:
+ allowed_mem_size = 16;
+ break;
+ case ZYDIS_VECTOR_LENGTH_256:
+ allowed_mem_size = 32;
+ break;
+ case ZYDIS_VECTOR_LENGTH_INVALID:
+ ZYAN_ASSERT(match->definition->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX);
+ ZYAN_FALLTHROUGH;
+ case ZYDIS_VECTOR_LENGTH_512:
+ allowed_mem_size = 64;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ if (match->definition->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX)
+ {
+ const ZydisInstructionDefinitionEVEX *evex_def =
+ (const ZydisInstructionDefinitionEVEX *)match->base_definition;
+ static const ZyanU8 element_sizes[ZYDIS_IELEMENT_SIZE_MAX_VALUE + 1] =
+ {
+ 0, 1, 2, 4, 8, 16
+ };
+ ZYAN_ASSERT(evex_def->element_size < ZYAN_ARRAY_LENGTH(element_sizes));
+ const ZyanU8 element_size = element_sizes[evex_def->element_size];
+ if (match->request->evex.broadcast || evex_def->broadcast)
+ {
+ allowed_mem_size = element_size;
+ }
+ else
+ {
+ switch (evex_def->tuple_type)
+ {
+ case ZYDIS_TUPLETYPE_FV:
+ break;
+ case ZYDIS_TUPLETYPE_HV:
+ allowed_mem_size /= 2;
+ break;
+ case ZYDIS_TUPLETYPE_QUARTER:
+ allowed_mem_size /= 4;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ }
+ }
+ else
+ {
+ const ZydisInstructionDefinitionMVEX *mvex_def =
+ (const ZydisInstructionDefinitionMVEX *)match->base_definition;
+ ZyanU16 element_size;
+ switch (match->request->mvex.conversion)
+ {
+ case ZYDIS_CONVERSION_MODE_INVALID:
+
+ switch (mvex_def->functionality)
+ {
+ case ZYDIS_MVEX_FUNC_SF_32:
+ case ZYDIS_MVEX_FUNC_SF_32_BCST_4TO16:
+ case ZYDIS_MVEX_FUNC_UF_32:
+ case ZYDIS_MVEX_FUNC_DF_32:
+ case ZYDIS_MVEX_FUNC_SI_32:
+ case ZYDIS_MVEX_FUNC_SI_32_BCST_4TO16:
+ case ZYDIS_MVEX_FUNC_UI_32:
+ case ZYDIS_MVEX_FUNC_DI_32:
+ allowed_mem_size = 64;
+ element_size = 4;
+ break;
+ case ZYDIS_MVEX_FUNC_SF_64:
+ case ZYDIS_MVEX_FUNC_UF_64:
+ case ZYDIS_MVEX_FUNC_DF_64:
+ case ZYDIS_MVEX_FUNC_SI_64:
+ case ZYDIS_MVEX_FUNC_UI_64:
+ case ZYDIS_MVEX_FUNC_DI_64:
+ allowed_mem_size = 64;
+ element_size = 8;
+ break;
+ case ZYDIS_MVEX_FUNC_SF_32_BCST:
+ case ZYDIS_MVEX_FUNC_SI_32_BCST:
+ allowed_mem_size = 32;
+ element_size = 4;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ break;
+ case ZYDIS_CONVERSION_MODE_FLOAT16:
+ case ZYDIS_CONVERSION_MODE_SINT16:
+ case ZYDIS_CONVERSION_MODE_UINT16:
+ allowed_mem_size = 32;
+ element_size = 2;
+ break;
+ case ZYDIS_CONVERSION_MODE_SINT8:
+ case ZYDIS_CONVERSION_MODE_UINT8:
+ allowed_mem_size = 16;
+ element_size = 1;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ ZYAN_ASSERT(!mvex_def->broadcast || !match->request->mvex.broadcast);
+ switch (mvex_def->broadcast)
+ {
+ case ZYDIS_MVEX_STATIC_BROADCAST_NONE:
+ break;
+ case ZYDIS_MVEX_STATIC_BROADCAST_1_TO_8:
+ case ZYDIS_MVEX_STATIC_BROADCAST_1_TO_16:
+ allowed_mem_size = element_size;
+ break;
+ case ZYDIS_MVEX_STATIC_BROADCAST_4_TO_8:
+ case ZYDIS_MVEX_STATIC_BROADCAST_4_TO_16:
+ allowed_mem_size = element_size * 4;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ switch (match->request->mvex.broadcast)
+ {
+ case ZYDIS_BROADCAST_MODE_INVALID:
+ break;
+ case ZYDIS_BROADCAST_MODE_1_TO_8:
+ case ZYDIS_BROADCAST_MODE_1_TO_16:
+ allowed_mem_size = element_size;
+ break;
+ case ZYDIS_BROADCAST_MODE_4_TO_8:
+ case ZYDIS_BROADCAST_MODE_4_TO_16:
+ allowed_mem_size = element_size * 4;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ }
+ }
+ if (user_op->mem.size != allowed_mem_size)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ else if (match->definition->rex_w)
+ {
+ match->eosz = 64;
+ }
+ else if (match->definition->vector_length == ZYDIS_VECTOR_LENGTH_INVALID)
+ {
+ match->eosz = ZydisGetOperandSizeFromElementSize(match, def_op->size,
+ user_op->mem.size, ZYAN_TRUE);
+ if (match->eosz == 0)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ else
+ {
+ ZYAN_UNREACHABLE;
+ }
+ }
+ else
+ {
+ if (match->easz != 0)
+ {
+ if (match->easz != user_op->mem.size)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ else
+ {
+ switch (user_op->mem.size)
+ {
+ case 2:
+ case 4:
+ case 8:
+ match->easz = (ZyanU8)user_op->mem.size << 3;
+ break;
+ default:
+ return ZYAN_FALSE;
+ }
+ }
+ }
+
+ ZydisRegisterClass vsib_index_class = ZYDIS_REGCLASS_INVALID;
+ ZyanBool is_vsib = ZYAN_TRUE;
+ switch (def_op->type)
+ {
+ case ZYDIS_SEMANTIC_OPTYPE_MEM_VSIBX:
+ vsib_index_class = ZYDIS_REGCLASS_XMM;
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_MEM_VSIBY:
+ vsib_index_class = ZYDIS_REGCLASS_YMM;
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_MEM_VSIBZ:
+ vsib_index_class = ZYDIS_REGCLASS_ZMM;
+ break;
+ default:
+ is_vsib = ZYAN_FALSE;
+ break;
+ }
+ const ZyanBool is_rip_relative = (user_op->mem.base == ZYDIS_REGISTER_RIP) ||
+ (user_op->mem.base == ZYDIS_REGISTER_EIP);
+ if (is_rip_relative)
+ {
+ const ZyanBool no_rip_rel = ZYDIS_OPDEF_GET_MEM_HIGH_BIT(match->base_definition->op_rm);
+ if (no_rip_rel || ((match->definition->modrm & 7) == 4))
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ const ZydisRegisterClass reg_base_class = ZydisRegisterGetClass(user_op->mem.base);
+ if ((reg_base_class == ZYDIS_REGCLASS_INVALID) &&
+ (user_op->mem.base != ZYDIS_REGISTER_NONE))
+ {
+ return ZYAN_FALSE;
+ }
+ const ZydisRegisterClass reg_index_class = ZydisRegisterGetClass(user_op->mem.index);
+ if ((reg_index_class == ZYDIS_REGCLASS_INVALID) &&
+ (user_op->mem.index != ZYDIS_REGISTER_NONE))
+ {
+ return ZYAN_FALSE;
+ }
+ if (is_vsib)
+ {
+ const ZyanU8 mode_width = ZydisGetMachineModeWidth(match->request->machine_mode);
+ const ZyanI8 reg_index_id = ZydisRegisterGetId(user_op->mem.index);
+ if (((match->request->machine_mode != ZYDIS_MACHINE_MODE_LONG_64) ||
+ (reg_base_class != ZYDIS_REGCLASS_GPR64)) &&
+ (reg_base_class != ZYDIS_REGCLASS_GPR32) &&
+ (reg_base_class != ZYDIS_REGCLASS_INVALID))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((reg_base_class == ZYDIS_REGCLASS_GPR32) &&
+ (mode_width != 64) &&
+ (ZydisRegisterGetId(user_op->mem.base) > 7))
+ {
+ return ZYAN_FALSE;
+ }
+ ZyanU8 max_reg_id = 7;
+ if (mode_width == 64)
+ {
+ max_reg_id = match->definition->encoding != ZYDIS_INSTRUCTION_ENCODING_VEX ?
+ 31 : 15;
+ }
+ if ((reg_index_class != vsib_index_class) ||
+ (reg_index_id > max_reg_id))
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ else
+ {
+ if (!ZydisIsValidAddressingClass(match, reg_base_class, user_op->mem.base))
+ {
+ if (!is_rip_relative || match->request->machine_mode != ZYDIS_MACHINE_MODE_LONG_64)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ if (!ZydisIsValidAddressingClass(match, reg_index_class, user_op->mem.index))
+ {
+ return ZYAN_FALSE;
+ }
+ if (reg_base_class != ZYDIS_REGCLASS_INVALID &&
+ reg_index_class != ZYDIS_REGCLASS_INVALID &&
+ reg_base_class != reg_index_class)
+ {
+ return ZYAN_FALSE;
+ }
+ if (user_op->mem.index == ZYDIS_REGISTER_ESP ||
+ user_op->mem.index == ZYDIS_REGISTER_RSP)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ if (reg_index_class != ZYDIS_REGCLASS_INVALID &&
+ user_op->mem.scale == 0 &&
+ def_op->type != ZYDIS_SEMANTIC_OPTYPE_MIB)
+ {
+ return ZYAN_FALSE;
+ }
+ if (reg_index_class == ZYDIS_REGCLASS_INVALID &&
+ user_op->mem.scale != 0)
+ {
+ return ZYAN_FALSE;
+ }
+ ZyanU8 candidate_easz = 0;
+ ZyanBool disp_only = ZYAN_FALSE;
+ if (reg_base_class != ZYDIS_REGCLASS_INVALID)
+ {
+ if (is_rip_relative)
+ {
+ candidate_easz = user_op->mem.base == ZYDIS_REGISTER_RIP ? 64 : 32;
+ }
+ else
+ {
+ candidate_easz = (ZyanU8)ZydisRegisterClassGetWidth(match->request->machine_mode,
+ reg_base_class);
+ }
+ }
+ else if (reg_index_class != ZYDIS_REGCLASS_INVALID)
+ {
+ if (is_vsib)
+ {
+ candidate_easz = ZydisGetMachineModeWidth(match->request->machine_mode);
+ }
+ else
+ {
+ candidate_easz = (ZyanU8)ZydisRegisterClassGetWidth(match->request->machine_mode,
+ reg_index_class);
+ }
+ }
+ else
+ {
+ ZyanU8 min_disp_size = match->easz ? match->easz : 16;
+ if (((min_disp_size == 16) && !(match->definition->address_sizes & ZYDIS_WIDTH_16)) ||
+ (min_disp_size == 64))
+ {
+ min_disp_size = 32;
+ }
+ if (ZydisGetUnsignedImmSize(displacement) == 16)
+ {
+ disp_size = 16;
+ }
+ if (disp_size < min_disp_size)
+ {
+ disp_size = min_disp_size;
+ }
+ if (match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
+ {
+ candidate_easz = match->easz == 32 ? 32 : 64;
+ }
+ else
+ {
+ candidate_easz = disp_size;
+ }
+ disp_only = ZYAN_TRUE;
+ }
+ if (match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
+ {
+ if (is_rip_relative && reg_index_class != ZYDIS_REGCLASS_INVALID)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ else
+ {
+ if (candidate_easz == 16 && !disp_only)
+ {
+ if (disp_size > 16)
+ {
+ return ZYAN_FALSE;
+ }
+ const ZyanI8 rm16 = ZydisGetRm16(user_op->mem.base, user_op->mem.index);
+ if (rm16 == -1)
+ {
+ return ZYAN_FALSE;
+ }
+ const ZyanU8 allowed_scale = rm16 < 4 ? 1 : 0;
+ if (user_op->mem.scale != allowed_scale)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ }
+ if (match->easz != 0)
+ {
+ if (match->easz != candidate_easz)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ else
+ {
+ match->easz = candidate_easz;
+ }
+ if ((match->base_definition->address_size_map == ZYDIS_ADSIZE_MAP_IGNORED) &&
+ (match->easz != ZydisGetMachineModeWidth(match->request->machine_mode)))
+ {
+ return ZYAN_FALSE;
+ }
+ match->disp_size = disp_size;
+ break;
+ }
+ case ZYDIS_SEMANTIC_OPTYPE_MOFFS:
+ if (user_op->mem.base != ZYDIS_REGISTER_NONE ||
+ user_op->mem.index != ZYDIS_REGISTER_NONE ||
+ user_op->mem.scale != 0)
+ {
+ return ZYAN_FALSE;
+ }
+ if (match->eosz != 0)
+ {
+ const ZyanU8 eosz_index = match->eosz >> 5;
+ if (def_op->size[eosz_index] != user_op->mem.size)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ else
+ {
+ match->eosz = ZydisGetOperandSizeFromElementSize(match, def_op->size,
+ user_op->mem.size, ZYAN_TRUE);
+ if (match->eosz == 0)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ match->disp_size = ZydisGetEffectiveImmSize(match, user_op->mem.displacement, def_op);
+ if (match->disp_size == 0)
+ {
+ return ZYAN_FALSE;
+ }
+ // This is not a standard rejection. It's a special case for `mov` instructions (only ones
+ // to use `moffs` operands). Size of `moffs` is tied to address size attribute, so its
+ // signedness doesn't matter. However if displacement can be represented as a signed
+ // integer of smaller size we reject `moffs` variant because it's guaranteed that better
+ // alternative exists (in terms of size).
+ ZyanU8 alternative_size = ZydisGetSignedImmSize(user_op->mem.displacement);
+ const ZyanU8 min_disp_size =
+ (match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64) ? 32 : 16;
+ if (alternative_size < min_disp_size)
+ {
+ alternative_size = min_disp_size;
+ }
+ if (alternative_size < match->disp_size)
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ return ZYAN_TRUE;
+}
+
+/**
+ * Checks if requested operand matches pointer operand from instruction definition.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param user_op Operand definition from `ZydisEncoderRequest` structure.
+ *
+ * @return True if operands match, false otherwise.
+ */
+static ZyanBool ZydisIsPointerOperandCompatible(ZydisEncoderInstructionMatch *match,
+ const ZydisEncoderOperand *user_op)
+{
+ ZYAN_ASSERT(match->eosz == 0);
+ ZYAN_ASSERT(match->request->machine_mode != ZYDIS_MACHINE_MODE_LONG_64);
+ ZYAN_ASSERT((match->request->branch_type == ZYDIS_BRANCH_TYPE_NONE) ||
+ (match->request->branch_type == ZYDIS_BRANCH_TYPE_FAR));
+ const ZyanU8 min_disp_size = ZydisGetUnsignedImmSize(user_op->ptr.offset);
+ const ZyanU8 desired_disp_size = (match->request->branch_width == ZYDIS_BRANCH_WIDTH_NONE)
+ ? ZydisGetMachineModeWidth(match->request->machine_mode)
+ : (4 << match->request->branch_width);
+ if (min_disp_size > desired_disp_size)
+ {
+ return ZYAN_FALSE;
+ }
+ match->eosz = match->disp_size = desired_disp_size;
+ match->imm_size = 16;
+ return ZYAN_TRUE;
+}
+
+/**
+ * Checks if requested operand matches immediate operand from instruction definition.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param user_op Operand definition from `ZydisEncoderRequest` structure.
+ * @param def_op Decoder's operand definition from current instruction definition.
+ *
+ * @return True if operands match, false otherwise.
+ */
+static ZyanBool ZydisIsImmediateOperandCompabile(ZydisEncoderInstructionMatch *match,
+ const ZydisEncoderOperand *user_op, const ZydisOperandDefinition *def_op)
+{
+ switch (def_op->type)
+ {
+ case ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_IMM1:
+ if (user_op->imm.u != 1)
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_SEMANTIC_OPTYPE_IMM:
+ case ZYDIS_SEMANTIC_OPTYPE_REL:
+ {
+ const ZyanU8 imm_size = ZydisGetEffectiveImmSize(match, user_op->imm.s, def_op);
+ if (def_op->op.encoding != ZYDIS_OPERAND_ENCODING_IS4)
+ {
+ if (imm_size == 0)
+ {
+ return ZYAN_FALSE;
+ }
+ if (match->imm_size)
+ {
+ ZYAN_ASSERT(match->disp_size == 0);
+ match->disp_size = match->imm_size;
+ }
+ }
+ else
+ {
+ ZYAN_ASSERT(match->imm_size == 0);
+ if (imm_size != 8)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ match->imm_size = imm_size;
+ match->has_rel_operand = (def_op->type == ZYDIS_SEMANTIC_OPTYPE_REL);
+ break;
+ }
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ return ZYAN_TRUE;
+}
+
+/**
+ * Checks if requested boardcast mode is compatible with instruction definition.
+ *
+ * @param evex_def Definition for `EVEX`-encoded instruction.
+ * @param vector_length Vector length.
+ * @param broadcast Requested broadcast mode.
+ *
+ * @return True if broadcast mode is compatible, false otherwise.
+ */
+static ZyanBool ZydisIsBroadcastModeCompatible(const ZydisInstructionDefinitionEVEX *evex_def,
+ ZydisVectorLength vector_length, ZydisBroadcastMode broadcast)
+{
+ if (broadcast == ZYDIS_BROADCAST_MODE_INVALID)
+ {
+ return ZYAN_TRUE;
+ }
+
+ ZyanU8 vector_size = 0;
+ ZYAN_ASSERT(vector_length != ZYDIS_VECTOR_LENGTH_INVALID);
+ switch (vector_length)
+ {
+ case ZYDIS_VECTOR_LENGTH_128:
+ vector_size = 16;
+ break;
+ case ZYDIS_VECTOR_LENGTH_256:
+ vector_size = 32;
+ break;
+ case ZYDIS_VECTOR_LENGTH_512:
+ vector_size = 64;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ switch (evex_def->tuple_type)
+ {
+ case ZYDIS_TUPLETYPE_FV:
+ break;
+ case ZYDIS_TUPLETYPE_HV:
+ vector_size /= 2;
+ break;
+ case ZYDIS_TUPLETYPE_QUARTER:
+ vector_size /= 4;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ ZyanU8 element_size;
+ switch (evex_def->element_size)
+ {
+ case ZYDIS_IELEMENT_SIZE_16:
+ element_size = 2;
+ break;
+ case ZYDIS_IELEMENT_SIZE_32:
+ element_size = 4;
+ break;
+ case ZYDIS_IELEMENT_SIZE_64:
+ element_size = 8;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ ZydisBroadcastMode allowed_mode;
+ const ZyanU8 element_count = vector_size / element_size;
+ switch (element_count)
+ {
+ case 2:
+ allowed_mode = ZYDIS_BROADCAST_MODE_1_TO_2;
+ break;
+ case 4:
+ allowed_mode = ZYDIS_BROADCAST_MODE_1_TO_4;
+ break;
+ case 8:
+ allowed_mode = ZYDIS_BROADCAST_MODE_1_TO_8;
+ break;
+ case 16:
+ allowed_mode = ZYDIS_BROADCAST_MODE_1_TO_16;
+ break;
+ case 32:
+ allowed_mode = ZYDIS_BROADCAST_MODE_1_TO_32;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ if (broadcast != allowed_mode)
+ {
+ return ZYAN_FALSE;
+ }
+
+ return ZYAN_TRUE;
+}
+
+/**
+ * Checks if requested `EVEX`-specific features are compatible with instruction definition.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param request A pointer to `ZydisEncoderRequest` struct.
+ *
+ * @return True if features are compatible, false otherwise.
+ */
+static ZyanBool ZydisAreEvexFeaturesCompatible(const ZydisEncoderInstructionMatch *match,
+ const ZydisEncoderRequest *request)
+{
+ if (match->definition->encoding != ZYDIS_INSTRUCTION_ENCODING_EVEX)
+ {
+ return ZYAN_TRUE;
+ }
+
+ const ZydisInstructionDefinitionEVEX *evex_def =
+ (const ZydisInstructionDefinitionEVEX *)match->base_definition;
+ if ((!evex_def->accepts_zero_mask) &&
+ (evex_def->mask_override != ZYDIS_MASK_OVERRIDE_ZEROING) &&
+ (request->evex.zeroing_mask))
+ {
+ return ZYAN_FALSE;
+ }
+
+ switch (evex_def->functionality)
+ {
+ case ZYDIS_EVEX_FUNC_INVALID:
+ if ((request->evex.sae) ||
+ (request->evex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) ||
+ (request->evex.rounding != ZYDIS_ROUNDING_MODE_INVALID))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_EVEX_FUNC_BC:
+ if ((request->evex.sae) ||
+ (request->evex.rounding != ZYDIS_ROUNDING_MODE_INVALID))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisIsBroadcastModeCompatible(evex_def, match->definition->vector_length,
+ request->evex.broadcast))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_EVEX_FUNC_RC:
+ if (request->evex.broadcast != ZYDIS_BROADCAST_MODE_INVALID)
+ {
+ return ZYAN_FALSE;
+ }
+ if (request->evex.rounding == ZYDIS_ROUNDING_MODE_INVALID)
+ {
+ if (request->evex.sae)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ else
+ {
+ if (!request->evex.sae)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ break;
+ case ZYDIS_EVEX_FUNC_SAE:
+ if ((request->evex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) ||
+ (request->evex.rounding != ZYDIS_ROUNDING_MODE_INVALID))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ return ZYAN_TRUE;
+}
+
+/**
+ * Checks if requested `MVEX`-specific features are compatible with instruction definition.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param request A pointer to `ZydisEncoderRequest` struct.
+ *
+ * @return True if features are compatible, false otherwise.
+ */
+static ZyanBool ZydisAreMvexFeaturesCompatible(const ZydisEncoderInstructionMatch *match,
+ const ZydisEncoderRequest *request)
+{
+ if (match->definition->encoding != ZYDIS_INSTRUCTION_ENCODING_MVEX)
+ {
+ return ZYAN_TRUE;
+ }
+ if (((match->definition->modrm >> 6) == 3) &&
+ (request->mvex.eviction_hint))
+ {
+ return ZYAN_FALSE;
+ }
+
+ const ZydisInstructionDefinitionMVEX *mvex_def =
+ (const ZydisInstructionDefinitionMVEX *)match->base_definition;
+ switch (mvex_def->functionality)
+ {
+ case ZYDIS_MVEX_FUNC_IGNORED:
+ case ZYDIS_MVEX_FUNC_INVALID:
+ case ZYDIS_MVEX_FUNC_F_32:
+ case ZYDIS_MVEX_FUNC_I_32:
+ case ZYDIS_MVEX_FUNC_F_64:
+ case ZYDIS_MVEX_FUNC_I_64:
+ case ZYDIS_MVEX_FUNC_UF_64:
+ case ZYDIS_MVEX_FUNC_UI_64:
+ case ZYDIS_MVEX_FUNC_DF_64:
+ case ZYDIS_MVEX_FUNC_DI_64:
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) ||
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID) ||
+ (request->mvex.rounding != ZYDIS_ROUNDING_MODE_INVALID) ||
+ (request->mvex.swizzle != ZYDIS_SWIZZLE_MODE_INVALID) ||
+ (request->mvex.sae))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_MVEX_FUNC_RC:
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) ||
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID) ||
+ (request->mvex.swizzle != ZYDIS_SWIZZLE_MODE_INVALID) ||
+ (request->mvex.eviction_hint))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_MVEX_FUNC_SAE:
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) ||
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID) ||
+ (request->mvex.rounding != ZYDIS_ROUNDING_MODE_INVALID) ||
+ (request->mvex.swizzle != ZYDIS_SWIZZLE_MODE_INVALID) ||
+ (request->mvex.eviction_hint))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_MVEX_FUNC_SWIZZLE_32:
+ case ZYDIS_MVEX_FUNC_SWIZZLE_64:
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) ||
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID) ||
+ (request->mvex.rounding != ZYDIS_ROUNDING_MODE_INVALID) ||
+ (request->mvex.sae))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_MVEX_FUNC_SF_32:
+ if ((request->mvex.rounding != ZYDIS_ROUNDING_MODE_INVALID) ||
+ (request->mvex.swizzle != ZYDIS_SWIZZLE_MODE_INVALID) ||
+ (request->mvex.sae))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) &&
+ (request->mvex.broadcast != ZYDIS_BROADCAST_MODE_1_TO_16) &&
+ (request->mvex.broadcast != ZYDIS_BROADCAST_MODE_4_TO_16))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_FLOAT16) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_UINT8) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_UINT16) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_SINT16))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_MVEX_FUNC_SI_32:
+ if ((request->mvex.rounding != ZYDIS_ROUNDING_MODE_INVALID) ||
+ (request->mvex.swizzle != ZYDIS_SWIZZLE_MODE_INVALID) ||
+ (request->mvex.sae))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) &&
+ (request->mvex.broadcast != ZYDIS_BROADCAST_MODE_1_TO_16) &&
+ (request->mvex.broadcast != ZYDIS_BROADCAST_MODE_4_TO_16))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_UINT8) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_SINT8) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_UINT16) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_SINT16))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_MVEX_FUNC_SF_32_BCST:
+ case ZYDIS_MVEX_FUNC_SI_32_BCST:
+ if ((request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID) ||
+ (request->mvex.rounding != ZYDIS_ROUNDING_MODE_INVALID) ||
+ (request->mvex.swizzle != ZYDIS_SWIZZLE_MODE_INVALID) ||
+ (request->mvex.sae))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) &&
+ (request->mvex.broadcast != ZYDIS_BROADCAST_MODE_1_TO_16) &&
+ (request->mvex.broadcast != ZYDIS_BROADCAST_MODE_4_TO_16))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_MVEX_FUNC_SF_32_BCST_4TO16:
+ case ZYDIS_MVEX_FUNC_SI_32_BCST_4TO16:
+ if ((request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID) ||
+ (request->mvex.rounding != ZYDIS_ROUNDING_MODE_INVALID) ||
+ (request->mvex.swizzle != ZYDIS_SWIZZLE_MODE_INVALID) ||
+ (request->mvex.sae))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) &&
+ (request->mvex.broadcast != ZYDIS_BROADCAST_MODE_4_TO_16))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_MVEX_FUNC_SF_64:
+ case ZYDIS_MVEX_FUNC_SI_64:
+ if ((request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID) ||
+ (request->mvex.rounding != ZYDIS_ROUNDING_MODE_INVALID) ||
+ (request->mvex.swizzle != ZYDIS_SWIZZLE_MODE_INVALID) ||
+ (request->mvex.sae))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) &&
+ (request->mvex.broadcast != ZYDIS_BROADCAST_MODE_1_TO_8) &&
+ (request->mvex.broadcast != ZYDIS_BROADCAST_MODE_4_TO_8))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_MVEX_FUNC_UF_32:
+ case ZYDIS_MVEX_FUNC_DF_32:
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) ||
+ (request->mvex.rounding != ZYDIS_ROUNDING_MODE_INVALID) ||
+ (request->mvex.swizzle != ZYDIS_SWIZZLE_MODE_INVALID) ||
+ (request->mvex.sae))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_MVEX_FUNC_UI_32:
+ case ZYDIS_MVEX_FUNC_DI_32:
+ if ((request->mvex.broadcast != ZYDIS_BROADCAST_MODE_INVALID) ||
+ (request->mvex.rounding != ZYDIS_ROUNDING_MODE_INVALID) ||
+ (request->mvex.swizzle != ZYDIS_SWIZZLE_MODE_INVALID) ||
+ (request->mvex.sae))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((request->mvex.conversion != ZYDIS_CONVERSION_MODE_INVALID) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_UINT8) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_SINT8) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_UINT16) &&
+ (request->mvex.conversion != ZYDIS_CONVERSION_MODE_SINT16))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ return ZYAN_TRUE;
+}
+
+/**
+ * Checks if operands specified in encoder request satisfy additional constraints mandated by
+ * matched instruction definition.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ *
+ * @return True if operands passed the checks, false otherwise.
+ */
+static ZyanBool ZydisCheckConstraints(const ZydisEncoderInstructionMatch *match)
+{
+ const ZydisEncoderOperand *operands = match->request->operands;
+ ZyanBool is_gather = ZYAN_FALSE;
+ switch (match->definition->encoding)
+ {
+ case ZYDIS_INSTRUCTION_ENCODING_VEX:
+ {
+ const ZydisInstructionDefinitionVEX *vex_def =
+ (const ZydisInstructionDefinitionVEX *)match->base_definition;
+ if (vex_def->is_gather)
+ {
+ ZYAN_ASSERT(match->request->operand_count == 3);
+ ZYAN_ASSERT(operands[0].type == ZYDIS_OPERAND_TYPE_REGISTER);
+ ZYAN_ASSERT(operands[1].type == ZYDIS_OPERAND_TYPE_MEMORY);
+ ZYAN_ASSERT(operands[2].type == ZYDIS_OPERAND_TYPE_REGISTER);
+ const ZyanI8 dest = ZydisRegisterGetId(operands[0].reg.value);
+ const ZyanI8 index = ZydisRegisterGetId(operands[1].mem.index);
+ const ZyanI8 mask = ZydisRegisterGetId(operands[2].reg.value);
+ // If any pair of the index, mask, or destination registers are the same, the
+ // instruction results a UD fault.
+ if ((dest == index) || (dest == mask) || (index == mask))
+ {
+ return ZYAN_FALSE;
+ }
+ }
+
+ if (vex_def->no_source_source_match)
+ {
+ ZYAN_ASSERT(match->request->operand_count == 3);
+ ZYAN_ASSERT(operands[0].type == ZYDIS_OPERAND_TYPE_REGISTER);
+ ZYAN_ASSERT(operands[1].type == ZYDIS_OPERAND_TYPE_REGISTER);
+ ZYAN_ASSERT(operands[2].type == ZYDIS_OPERAND_TYPE_REGISTER);
+ const ZydisRegister dest = operands[0].reg.value;
+ const ZydisRegister source1 = operands[1].reg.value;
+ const ZydisRegister source2 = operands[2].reg.value;
+ // AMX-E4: #UD if srcdest == src1 OR src1 == src2 OR srcdest == src2.
+ if ((dest == source1) || (source1 == source2) || (dest == source2))
+ {
+ return ZYAN_FALSE;
+ }
+ }
+
+ return ZYAN_TRUE;
+ }
+ case ZYDIS_INSTRUCTION_ENCODING_EVEX:
+ {
+ const ZydisInstructionDefinitionEVEX *evex_def =
+ (const ZydisInstructionDefinitionEVEX *)match->base_definition;
+ is_gather = evex_def->is_gather;
+ if (evex_def->no_source_dest_match)
+ {
+ ZYAN_ASSERT(operands[0].type == ZYDIS_OPERAND_TYPE_REGISTER);
+ ZYAN_ASSERT(operands[2].type == ZYDIS_OPERAND_TYPE_REGISTER);
+ ZYAN_ASSERT((operands[3].type == ZYDIS_OPERAND_TYPE_REGISTER) ||
+ (operands[3].type == ZYDIS_OPERAND_TYPE_MEMORY));
+ const ZydisRegister dest = operands[0].reg.value;
+ const ZydisRegister source1 = operands[2].reg.value;
+ const ZydisRegister source2 = (operands[3].type == ZYDIS_OPERAND_TYPE_REGISTER)
+ ? operands[3].reg.value
+ : ZYDIS_REGISTER_NONE;
+
+ if ((dest == source1) || (dest == source2))
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ break;
+ }
+ case ZYDIS_INSTRUCTION_ENCODING_MVEX:
+ {
+ const ZydisInstructionDefinitionMVEX *mvex_def =
+ (const ZydisInstructionDefinitionMVEX *)match->base_definition;
+ is_gather = mvex_def->is_gather;
+ break;
+ }
+ default:
+ return ZYAN_TRUE;
+ }
+
+ if ((is_gather) && (operands[0].type == ZYDIS_OPERAND_TYPE_REGISTER))
+ {
+ ZYAN_ASSERT(match->request->operand_count == 3);
+ ZYAN_ASSERT(operands[0].type == ZYDIS_OPERAND_TYPE_REGISTER);
+ ZYAN_ASSERT(operands[2].type == ZYDIS_OPERAND_TYPE_MEMORY);
+ const ZyanI8 dest = ZydisRegisterGetId(operands[0].reg.value);
+ const ZyanI8 index = ZydisRegisterGetId(operands[2].mem.index);
+ // EVEX: The instruction will #UD fault if the destination vector zmm1 is the same as
+ // index vector VINDEX.
+ // MVEX: The KNC GATHER instructions forbid using the same vector register for destination
+ // and for the index. (https://github.com/intelxed/xed/issues/281#issuecomment-970074554)
+ if (dest == index)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+
+ return ZYAN_TRUE;
+}
+
+/**
+ * Checks if operands and encoding-specific features from `ZydisEncoderRequest` match
+ * encoder's instruction definition.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param request A pointer to `ZydisEncoderRequest` struct.
+ *
+ * @return True if definition is compatible, false otherwise.
+ */
+static ZyanBool ZydisIsDefinitionCompatible(ZydisEncoderInstructionMatch *match,
+ const ZydisEncoderRequest *request)
+{
+ ZYAN_ASSERT(request->operand_count == match->base_definition->operand_count_visible);
+ match->operands = ZydisGetOperandDefinitions(match->base_definition);
+
+ if (!ZydisAreEvexFeaturesCompatible(match, request))
+ {
+ return ZYAN_FALSE;
+ }
+ if (!ZydisAreMvexFeaturesCompatible(match, request))
+ {
+ return ZYAN_FALSE;
+ }
+
+ for (ZyanU8 i = 0; i < request->operand_count; ++i)
+ {
+ const ZydisEncoderOperand *user_op = &request->operands[i];
+ const ZydisOperandDefinition *def_op = &match->operands[i];
+ ZYAN_ASSERT(def_op->visibility != ZYDIS_OPERAND_VISIBILITY_HIDDEN);
+ ZyanBool is_compatible = ZYAN_FALSE;
+ switch (user_op->type)
+ {
+ case ZYDIS_OPERAND_TYPE_REGISTER:
+ is_compatible = ZydisIsRegisterOperandCompatible(match, user_op, def_op);
+ break;
+ case ZYDIS_OPERAND_TYPE_MEMORY:
+ is_compatible = ZydisIsMemoryOperandCompatible(match, user_op, def_op);
+ break;
+ case ZYDIS_OPERAND_TYPE_POINTER:
+ is_compatible = ZydisIsPointerOperandCompatible(match, user_op);
+ break;
+ case ZYDIS_OPERAND_TYPE_IMMEDIATE:
+ is_compatible = ZydisIsImmediateOperandCompabile(match, user_op, def_op);
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ if (!is_compatible)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+
+ ZyanU8 eosz = 0;
+ if (match->base_definition->branch_type != ZYDIS_BRANCH_TYPE_NONE)
+ {
+ switch (request->branch_width)
+ {
+ case ZYDIS_BRANCH_WIDTH_NONE:
+ break;
+ case ZYDIS_BRANCH_WIDTH_8:
+ if ((!match->has_rel_operand) ||
+ (match->base_definition->branch_type != ZYDIS_BRANCH_TYPE_SHORT))
+ {
+ return ZYAN_FALSE;
+ }
+ break;
+ case ZYDIS_BRANCH_WIDTH_16:
+ eosz = 16;
+ break;
+ case ZYDIS_BRANCH_WIDTH_32:
+ eosz = ((match->has_rel_operand) &&
+ (match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64) &&
+ (match->base_definition->operand_size_map == ZYDIS_OPSIZE_MAP_FORCE64))
+ ? 64
+ : 32;
+ break;
+ case ZYDIS_BRANCH_WIDTH_64:
+ if (match->has_rel_operand)
+ {
+ return ZYAN_FALSE;
+ }
+ eosz = 64;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ }
+ if (eosz)
+ {
+ if (match->eosz != 0)
+ {
+ if (match->eosz != eosz)
+ {
+ return ZYAN_FALSE;
+ }
+ }
+ else
+ {
+ match->eosz = eosz;
+ }
+ }
+
+ if (!ZydisCheckConstraints(match))
+ {
+ return ZYAN_FALSE;
+ }
+
+ return ZYAN_TRUE;
+}
+
+/**
+ * Checks if requested set of prefixes is compatible with instruction definition.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanBool ZydisArePrefixesCompatible(const ZydisEncoderInstructionMatch *match)
+{
+ // Early-exit optimization for when no prefixes are requested at all.
+ if (!(match->attributes & ZYDIS_ENCODABLE_PREFIXES))
+ {
+ return ZYAN_TRUE;
+ }
+
+ if ((!match->base_definition->accepts_segment) &&
+ (match->attributes & ZYDIS_ATTRIB_HAS_SEGMENT))
+ {
+ return ZYAN_FALSE;
+ }
+ if (match->definition->encoding != ZYDIS_INSTRUCTION_ENCODING_LEGACY)
+ {
+ return !(match->attributes & ZYDIS_ENCODABLE_PREFIXES_NO_SEGMENTS);
+ }
+
+ const ZydisInstructionDefinitionLEGACY *legacy_def =
+ (const ZydisInstructionDefinitionLEGACY *)match->base_definition;
+ if ((!legacy_def->accepts_LOCK) &&
+ (match->attributes & ZYDIS_ATTRIB_HAS_LOCK))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((!legacy_def->accepts_REP) &&
+ (match->attributes & ZYDIS_ATTRIB_HAS_REP))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((!legacy_def->accepts_REPEREPZ) &&
+ (match->attributes & ZYDIS_ATTRIB_HAS_REPE))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((!legacy_def->accepts_REPNEREPNZ) &&
+ (match->attributes & ZYDIS_ATTRIB_HAS_REPNE))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((!legacy_def->accepts_BOUND) &&
+ (match->attributes & ZYDIS_ATTRIB_HAS_BND))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((!legacy_def->accepts_XACQUIRE) &&
+ (match->attributes & ZYDIS_ATTRIB_HAS_XACQUIRE))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((!legacy_def->accepts_XRELEASE) &&
+ (match->attributes & ZYDIS_ATTRIB_HAS_XRELEASE))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((!legacy_def->accepts_branch_hints) &&
+ (match->attributes & (ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN |
+ ZYDIS_ATTRIB_HAS_BRANCH_TAKEN)))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((!legacy_def->accepts_NOTRACK) &&
+ (match->attributes & ZYDIS_ATTRIB_HAS_NOTRACK))
+ {
+ return ZYAN_FALSE;
+ }
+ if ((!legacy_def->accepts_hle_without_lock) &&
+ (match->attributes & (ZYDIS_ATTRIB_HAS_XACQUIRE |
+ ZYDIS_ATTRIB_HAS_XRELEASE)) &&
+ !(match->attributes & ZYDIS_ATTRIB_HAS_LOCK))
+ {
+ return ZYAN_FALSE;
+ }
+
+ return ZYAN_TRUE;
+}
+
+/**
+ * Returns operand mask containing information about operand count and types in a compressed form.
+ *
+ * @param request A pointer to `ZydisEncoderRequest` struct.
+ *
+ * @return Operand mask.
+ */
+static ZyanU16 ZydisGetOperandMask(const ZydisEncoderRequest *request)
+{
+ ZyanU16 operand_mask = request->operand_count;
+ ZyanU8 bit_offset = ZYAN_BITS_TO_REPRESENT(ZYDIS_ENCODER_MAX_OPERANDS);
+ for (ZyanU8 i = 0; i < request->operand_count; ++i)
+ {
+ operand_mask |= (request->operands[i].type - ZYDIS_OPERAND_TYPE_REGISTER) << bit_offset;
+ bit_offset += ZYAN_BITS_TO_REPRESENT(
+ ZYDIS_OPERAND_TYPE_MAX_VALUE - ZYDIS_OPERAND_TYPE_REGISTER);
+ }
+
+ return operand_mask;
+}
+
+/**
+ * Handles optimization opportunities indicated by `swappable` field in instruction definition
+ * structure. See `ZydisEncodableInstruction` for more information.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ *
+ * @return True if definition has been swapped, false otherwise.
+ */
+static ZyanBool ZydisHandleSwappableDefinition(ZydisEncoderInstructionMatch *match)
+{
+ if (!match->definition->swappable)
+ {
+ return ZYAN_FALSE;
+ }
+
+ // Special case for ISA-wide unique conflict between two `mov` variants
+ // mov gpr16_32_64(encoding=opcode), imm(encoding=simm16_32_64,scale_factor=osz)
+ // mov gpr16_32_64(encoding=modrm_rm), imm(encoding=simm16_32_32,scale_factor=osz)
+ if (match->request->mnemonic == ZYDIS_MNEMONIC_MOV)
+ {
+ const ZyanU8 imm_size = ZydisGetSignedImmSize(match->request->operands[1].imm.s);
+ if ((match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64) &&
+ (match->eosz == 64) &&
+ (imm_size < 64))
+ {
+ return ZYAN_TRUE;
+ }
+ }
+
+ ZYAN_ASSERT((match->request->operand_count == 2) || (match->request->operand_count == 3));
+ const ZyanU8 src_index = (match->request->operand_count == 3) ? 2 : 1;
+ const ZyanI8 dest_id = ZydisRegisterGetId(match->request->operands[0].reg.value);
+ const ZyanI8 src_id = ZydisRegisterGetId(match->request->operands[src_index].reg.value);
+ if ((dest_id <= 7) && (src_id > 7))
+ {
+ ++match->definition;
+ ZydisGetInstructionDefinition(match->definition->encoding,
+ match->definition->instruction_reference, &match->base_definition);
+ match->operands = ZydisGetOperandDefinitions(match->base_definition);
+ return ZYAN_TRUE;
+ }
+
+ return ZYAN_FALSE;
+}
+
+/**
+ * This function attempts to find a matching instruction definition for provided encoder request.
+ *
+ * @param request A pointer to `ZydisEncoderRequest` struct.
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisFindMatchingDefinition(const ZydisEncoderRequest *request,
+ ZydisEncoderInstructionMatch *match)
+{
+ ZYAN_MEMSET(match, 0, sizeof(ZydisEncoderInstructionMatch));
+ match->request = request;
+ match->attributes = request->prefixes;
+
+ const ZydisEncodableInstruction *definition = ZYAN_NULL;
+ const ZyanU8 definition_count = ZydisGetEncodableInstructions(request->mnemonic, &definition);
+ ZYAN_ASSERT(definition && definition_count);
+ const ZydisWidthFlag mode_width = ZydisGetMachineModeWidth(request->machine_mode) >> 4;
+ const ZyanBool is_compat =
+ (request->machine_mode == ZYDIS_MACHINE_MODE_LONG_COMPAT_16) ||
+ (request->machine_mode == ZYDIS_MACHINE_MODE_LONG_COMPAT_32);
+ const ZyanU8 default_asz = ZydisGetAszFromHint(request->address_size_hint);
+ const ZyanU8 default_osz = ZydisGetOszFromHint(request->operand_size_hint);
+ const ZyanU16 operand_mask = ZydisGetOperandMask(request);
+
+ for (ZyanU8 i = 0; i < definition_count; ++i, ++definition)
+ {
+ if (definition->operand_mask != operand_mask)
+ {
+ continue;
+ }
+ const ZydisInstructionDefinition *base_definition = ZYAN_NULL;
+ ZydisGetInstructionDefinition(definition->encoding, definition->instruction_reference,
+ &base_definition);
+ if (!(definition->modes & mode_width))
+ {
+ continue;
+ }
+ if ((request->allowed_encodings != ZYDIS_ENCODABLE_ENCODING_DEFAULT) &&
+ !(ZydisGetEncodableEncoding(definition->encoding) & request->allowed_encodings))
+ {
+ continue;
+ }
+ if (request->machine_mode == ZYDIS_MACHINE_MODE_REAL_16)
+ {
+ if (base_definition->requires_protected_mode)
+ {
+ continue;
+ }
+ switch (definition->encoding)
+ {
+ case ZYDIS_INSTRUCTION_ENCODING_XOP:
+ case ZYDIS_INSTRUCTION_ENCODING_VEX:
+ case ZYDIS_INSTRUCTION_ENCODING_EVEX:
+ case ZYDIS_INSTRUCTION_ENCODING_MVEX:
+ continue;
+ default:
+ break;
+ }
+ }
+ else if ((request->machine_mode != ZYDIS_MACHINE_MODE_LONG_64) &&
+ (definition->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX))
+ {
+ continue;
+ }
+ if (is_compat && base_definition->no_compat_mode)
+ {
+ continue;
+ }
+ if ((request->branch_type != ZYDIS_BRANCH_TYPE_NONE) &&
+ (request->branch_type != base_definition->branch_type))
+ {
+ continue;
+ }
+ if ((base_definition->branch_type == ZYDIS_BRANCH_TYPE_NONE) &&
+ (request->branch_width != ZYDIS_BRANCH_WIDTH_NONE))
+ {
+ continue;
+ }
+
+ match->definition = definition;
+ match->base_definition = base_definition;
+ match->operands = ZYAN_NULL;
+ match->easz = definition->accepts_hint == ZYDIS_SIZE_HINT_ASZ ? default_asz : 0;
+ match->eosz = definition->accepts_hint == ZYDIS_SIZE_HINT_OSZ ? default_osz : 0;
+ match->disp_size = match->imm_size = match->cd8_scale = 0;
+ match->rex_type = ZYDIS_REX_TYPE_UNKNOWN;
+ match->eosz64_forbidden = ZYAN_FALSE;
+ match->has_rel_operand = ZYAN_FALSE;
+ if ((base_definition->operand_size_map != ZYDIS_OPSIZE_MAP_BYTEOP) &&
+ (match->eosz == 8))
+ {
+ continue;
+ }
+ if (!ZydisArePrefixesCompatible(match))
+ {
+ continue;
+ }
+ if (!ZydisIsDefinitionCompatible(match, request))
+ {
+ continue;
+ }
+ if (ZydisHandleSwappableDefinition(match))
+ {
+ if (definition == match->definition)
+ {
+ continue;
+ }
+ ++i;
+ definition = match->definition;
+ base_definition = match->base_definition;
+ }
+
+ if (match->easz == 0)
+ {
+ if (definition->address_sizes & mode_width)
+ {
+ match->easz = (ZyanU8)(mode_width << 4);
+ }
+ else if (mode_width == ZYDIS_WIDTH_16)
+ {
+ match->easz = 32;
+ }
+ else if (mode_width == ZYDIS_WIDTH_32)
+ {
+ match->easz = 16;
+ }
+ else
+ {
+ match->easz = 32;
+ }
+ ZYAN_ASSERT(definition->address_sizes & (match->easz >> 4));
+ }
+ else if (!(definition->address_sizes & (match->easz >> 4)))
+ {
+ continue;
+ }
+
+ if (mode_width == ZYDIS_WIDTH_64)
+ {
+ if (base_definition->operand_size_map == ZYDIS_OPSIZE_MAP_DEFAULT64)
+ {
+ if (match->eosz == 0)
+ {
+ ZYAN_ASSERT(definition->operand_sizes & (ZYDIS_WIDTH_16 | ZYDIS_WIDTH_64));
+ if (definition->operand_sizes & ZYDIS_WIDTH_64)
+ {
+ match->eosz = 64;
+ }
+ else
+ {
+ match->eosz = 16;
+ }
+ }
+ else if (match->eosz == 32)
+ {
+ continue;
+ }
+ }
+ else if (base_definition->operand_size_map == ZYDIS_OPSIZE_MAP_FORCE64)
+ {
+ if (match->eosz == 0)
+ {
+ match->eosz = 64;
+ }
+ else if (match->eosz != 64)
+ {
+ continue;
+ }
+ }
+ }
+ if (match->eosz == 0)
+ {
+ const ZydisWidthFlag default_width = (mode_width == ZYDIS_WIDTH_64)
+ ? ZYDIS_WIDTH_32
+ : mode_width;
+ if (definition->operand_sizes & default_width)
+ {
+ match->eosz = (ZyanU8)(default_width << 4);
+ }
+ else if (definition->operand_sizes & ZYDIS_WIDTH_16)
+ {
+ match->eosz = 16;
+ }
+ else if (definition->operand_sizes & ZYDIS_WIDTH_32)
+ {
+ match->eosz = 32;
+ }
+ else
+ {
+ match->eosz = 64;
+ }
+ }
+ else if (match->eosz64_forbidden && match->eosz == 64)
+ {
+ continue;
+ }
+ else if (!(definition->operand_sizes & (match->eosz >> 4)))
+ {
+ continue;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+ }
+
+ return ZYDIS_STATUS_IMPOSSIBLE_INSTRUCTION;
+}
+
+/**
+ * Emits unsigned integer value.
+ *
+ * @param data Value to emit.
+ * @param size Value size in bytes.
+ * @param buffer A pointer to `ZydisEncoderBuffer` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisEmitUInt(ZyanU64 data, ZyanU8 size, ZydisEncoderBuffer *buffer)
+{
+ ZYAN_ASSERT(size == 1 || size == 2 || size == 4 || size == 8);
+
+ const ZyanUSize new_offset = buffer->offset + size;
+ if (new_offset > buffer->size)
+ {
+ return ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ // TODO: fix for big-endian systems
+ // The size variable is not passed on purpose to allow the compiler
+ // to generate better code with a known size at compile time.
+ if (size == 1)
+ {
+ ZYAN_MEMCPY(buffer->buffer + buffer->offset, &data, 1);
+ }
+ else if (size == 2)
+ {
+ ZYAN_MEMCPY(buffer->buffer + buffer->offset, &data, 2);
+ }
+ else if (size == 4)
+ {
+ ZYAN_MEMCPY(buffer->buffer + buffer->offset, &data, 4);
+ }
+ else if (size == 8)
+ {
+ ZYAN_MEMCPY(buffer->buffer + buffer->offset, &data, 8);
+ }
+ else
+ {
+ ZYAN_UNREACHABLE;
+ }
+
+ buffer->offset = new_offset;
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * Emits a single byte.
+ *
+ * @param byte Value to emit.
+ * @param buffer A pointer to `ZydisEncoderBuffer` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisEmitByte(ZyanU8 byte, ZydisEncoderBuffer *buffer)
+{
+ return ZydisEmitUInt(byte, 1, buffer);
+}
+
+/**
+ * Emits legact prefixes.
+ *
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ * @param buffer A pointer to `ZydisEncoderBuffer` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisEmitLegacyPrefixes(const ZydisEncoderInstruction *instruction,
+ ZydisEncoderBuffer *buffer)
+{
+ ZyanBool compressed_prefixes = ZYAN_FALSE;
+ switch (instruction->encoding)
+ {
+ case ZYDIS_INSTRUCTION_ENCODING_XOP:
+ case ZYDIS_INSTRUCTION_ENCODING_VEX:
+ case ZYDIS_INSTRUCTION_ENCODING_EVEX:
+ case ZYDIS_INSTRUCTION_ENCODING_MVEX:
+ compressed_prefixes = ZYAN_TRUE;
+ break;
+ default:
+ break;
+ }
+
+ // Group 1
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_LOCK)
+ {
+ ZYAN_CHECK(ZydisEmitByte(0xF0, buffer));
+ }
+ if (!compressed_prefixes)
+ {
+ if (instruction->attributes & (ZYDIS_ATTRIB_HAS_REPNE |
+ ZYDIS_ATTRIB_HAS_BND |
+ ZYDIS_ATTRIB_HAS_XACQUIRE))
+ {
+ ZYAN_CHECK(ZydisEmitByte(0xF2, buffer));
+ }
+ if (instruction->attributes & (ZYDIS_ATTRIB_HAS_REP |
+ ZYDIS_ATTRIB_HAS_REPE |
+ ZYDIS_ATTRIB_HAS_XRELEASE))
+ {
+ ZYAN_CHECK(ZydisEmitByte(0xF3, buffer));
+ }
+ }
+
+ // Group 2
+ if (instruction->attributes & (ZYDIS_ATTRIB_HAS_SEGMENT_CS |
+ ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN))
+ {
+ ZYAN_CHECK(ZydisEmitByte(0x2E, buffer));
+ }
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_SS)
+ {
+ ZYAN_CHECK(ZydisEmitByte(0x36, buffer));
+ }
+ if (instruction->attributes & (ZYDIS_ATTRIB_HAS_SEGMENT_DS |
+ ZYDIS_ATTRIB_HAS_BRANCH_TAKEN))
+ {
+ ZYAN_CHECK(ZydisEmitByte(0x3E, buffer));
+ }
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_ES)
+ {
+ ZYAN_CHECK(ZydisEmitByte(0x26, buffer));
+ }
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_FS)
+ {
+ ZYAN_CHECK(ZydisEmitByte(0x64, buffer));
+ }
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_SEGMENT_GS)
+ {
+ ZYAN_CHECK(ZydisEmitByte(0x65, buffer));
+ }
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_NOTRACK)
+ {
+ ZYAN_CHECK(ZydisEmitByte(0x3E, buffer));
+ }
+
+ // Group 3
+ if (!compressed_prefixes)
+ {
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_OPERANDSIZE)
+ {
+ ZYAN_CHECK(ZydisEmitByte(0x66, buffer));
+ }
+ }
+
+ // Group 4
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_ADDRESSSIZE)
+ {
+ ZYAN_CHECK(ZydisEmitByte(0x67, buffer));
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * Encodes low nibble of `REX` prefix.
+ *
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ * @param high_r A pointer to `ZyanBool` variable that will be set to true when the
+ * highest `ModR/M.reg` bit cannot be encoded using `REX` prefix.
+ *
+ * @return A zyan status code.
+ */
+static ZyanU8 ZydisEncodeRexLowNibble(const ZydisEncoderInstruction *instruction, ZyanBool *high_r)
+{
+ if (high_r)
+ {
+ *high_r = ZYAN_FALSE;
+ }
+
+ ZyanU8 rex = 0;
+ if ((instruction->attributes & ZYDIS_ATTRIB_HAS_MODRM) &&
+ (instruction->attributes & ZYDIS_ATTRIB_HAS_SIB))
+ {
+ if (instruction->base & 0x08)
+ {
+ rex |= 1;
+ }
+ if (instruction->index & 0x08)
+ {
+ rex |= 2;
+ }
+ if (instruction->reg & 0x08)
+ {
+ rex |= 4;
+ }
+ if (high_r && (instruction->reg & 0x10))
+ {
+ *high_r = ZYAN_TRUE;
+ }
+ }
+ else if (instruction->attributes & ZYDIS_ATTRIB_HAS_MODRM)
+ {
+ if (instruction->rm & 0x08)
+ {
+ rex |= 1;
+ }
+ if (instruction->rm & 0x10)
+ {
+ rex |= 2;
+ }
+ if (instruction->reg & 0x08)
+ {
+ rex |= 4;
+ }
+ if (high_r && (instruction->reg & 0x10))
+ {
+ *high_r = ZYAN_TRUE;
+ }
+ }
+ else
+ {
+ if (instruction->rm & 0x08)
+ {
+ rex |= 1;
+ }
+ }
+
+ if (instruction->rex_w)
+ {
+ rex |= 8;
+ }
+
+ return rex;
+}
+
+/**
+ * Emits `REX` prefix.
+ *
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ * @param buffer A pointer to `ZydisEncoderBuffer` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisEmitRex(const ZydisEncoderInstruction *instruction,
+ ZydisEncoderBuffer *buffer)
+{
+ const ZyanU8 rex = ZydisEncodeRexLowNibble(instruction, ZYAN_NULL);
+ if (rex || (instruction->attributes & ZYDIS_ATTRIB_HAS_REX))
+ {
+ ZYAN_CHECK(ZydisEmitByte(0x40 | rex, buffer));
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * Encodes common parts of `VEX` prefix.
+ *
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ * @param mmmmm A pointer to `ZyanU8` variable that will receive `VEX.mmmmm`
+ * @param pp A pointer to `ZyanU8` variable that will receive `VEX.pp`
+ * @param vvvv A pointer to `ZyanU8` variable that will receive `VEX.vvvv`
+ * @param rex A pointer to `ZyanU8` variable that will receive 'REX`
+ * @param high_r A pointer to `ZyanBool` variable that will be set to true when the
+ * highest `ModR/M.reg` bit cannot be encoded using `REX` prefix.
+ */
+static void ZydisEncodeVexCommons(ZydisEncoderInstruction *instruction, ZyanU8 *mmmmm, ZyanU8 *pp,
+ ZyanU8 *vvvv, ZyanU8 *rex, ZyanBool *high_r)
+{
+ switch (instruction->opcode_map)
+ {
+ case ZYDIS_OPCODE_MAP_DEFAULT:
+ case ZYDIS_OPCODE_MAP_0F:
+ case ZYDIS_OPCODE_MAP_0F38:
+ case ZYDIS_OPCODE_MAP_0F3A:
+ case ZYDIS_OPCODE_MAP_MAP5:
+ case ZYDIS_OPCODE_MAP_MAP6:
+ *mmmmm = (ZyanU8)instruction->opcode_map;
+ break;
+ case ZYDIS_OPCODE_MAP_XOP8:
+ case ZYDIS_OPCODE_MAP_XOP9:
+ case ZYDIS_OPCODE_MAP_XOPA:
+ *mmmmm = 8 + ((ZyanU8)instruction->opcode_map - ZYDIS_OPCODE_MAP_XOP8);
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ instruction->opcode_map = ZYDIS_OPCODE_MAP_DEFAULT;
+
+ *pp = 0;
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_OPERANDSIZE)
+ {
+ *pp = 1;
+ }
+ else if (instruction->attributes & ZYDIS_ATTRIB_HAS_REP)
+ {
+ *pp = 2;
+ }
+ else if (instruction->attributes & ZYDIS_ATTRIB_HAS_REPNE)
+ {
+ *pp = 3;
+ }
+
+ *vvvv = ~instruction->vvvv;
+ *rex = ZydisEncodeRexLowNibble(instruction, high_r);
+}
+
+/**
+ * Emits `XOP` prefix.
+ *
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ * @param buffer A pointer to `ZydisEncoderBuffer` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisEmitXop(ZydisEncoderInstruction *instruction, ZydisEncoderBuffer *buffer)
+{
+ ZyanU8 mmmmm, pp, vvvv, rex;
+ ZydisEncodeVexCommons(instruction, &mmmmm, &pp, &vvvv, &rex, ZYAN_NULL);
+ ZYAN_ASSERT(instruction->vector_length <= 1);
+ const ZyanU8 b1 = (((~rex) & 0x07) << 5) | mmmmm;
+ const ZyanU8 b2 = ((rex & 0x08) << 4) | ((vvvv & 0xF) << 3) | (instruction->vector_length << 2) | pp;
+ ZYAN_CHECK(ZydisEmitByte(0x8F, buffer));
+ ZYAN_CHECK(ZydisEmitByte(b1, buffer));
+ ZYAN_CHECK(ZydisEmitByte(b2, buffer));
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * Emits `VEX` prefix.
+ *
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ * @param buffer A pointer to `ZydisEncoderBuffer` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisEmitVex(ZydisEncoderInstruction *instruction, ZydisEncoderBuffer *buffer)
+{
+ ZyanU8 mmmmm, pp, vvvv, rex;
+ ZydisEncodeVexCommons(instruction, &mmmmm, &pp, &vvvv, &rex, ZYAN_NULL);
+ ZYAN_ASSERT(instruction->vector_length <= 1);
+ if (mmmmm != 1 || (rex & 0x0B))
+ {
+ const ZyanU8 b1 = (((~rex) & 0x07) << 5) | mmmmm;
+ const ZyanU8 b2 = ((rex & 0x08) << 4) |
+ ((vvvv & 0xF) << 3) |
+ (instruction->vector_length << 2) |
+ pp;
+ ZYAN_CHECK(ZydisEmitByte(0xC4, buffer));
+ ZYAN_CHECK(ZydisEmitByte(b1, buffer));
+ ZYAN_CHECK(ZydisEmitByte(b2, buffer));
+ }
+ else
+ {
+ const ZyanU8 b1 = (((~rex) & 0x04) << 5) |
+ ((vvvv & 0xF) << 3) |
+ (instruction->vector_length << 2) |
+ pp;
+ ZYAN_CHECK(ZydisEmitByte(0xC5, buffer));
+ ZYAN_CHECK(ZydisEmitByte(b1, buffer));
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * Encodes common parts of `EVEX` prefix.
+ *
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ * @param p0 A pointer to `ZyanU8` variable that will receive 2nd byte of `EVEX` prefix.
+ * @param p1 A pointer to `ZyanU8` variable that will receive 3rd byte of `EVEX` prefix.
+ * @param vvvvv A pointer to `ZyanU8` variable that will receive `EVEX.vvvvv`.
+ */
+static void ZydisEncodeEvexCommons(ZydisEncoderInstruction *instruction, ZyanU8 *p0, ZyanU8 *p1,
+ ZyanU8 *vvvvv)
+{
+ ZyanBool high_r;
+ ZyanU8 mmmmm, pp, rex;
+ ZydisEncodeVexCommons(instruction, &mmmmm, &pp, vvvvv, &rex, &high_r);
+ *p0 = (((~rex) & 0x07) << 5) | mmmmm;
+ if (!high_r)
+ {
+ *p0 |= 0x10;
+ }
+ *p1 = ((rex & 0x08) << 4) | ((*vvvvv & 0x0F) << 3) | 0x04 | pp;
+}
+
+/**
+ * Emits `EVEX` prefix.
+ *
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ * @param buffer A pointer to `ZydisEncoderBuffer` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisEmitEvex(ZydisEncoderInstruction *instruction, ZydisEncoderBuffer *buffer)
+{
+ ZyanU8 p0, p1, vvvvv;
+ ZydisEncodeEvexCommons(instruction, &p0, &p1, &vvvvv);
+ ZyanU8 p2 = (instruction->vector_length << 5) | ((vvvvv & 0x10) >> 1) | instruction->mask;
+ if (instruction->zeroing)
+ {
+ p2 |= 0x80;
+ }
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_EVEX_B)
+ {
+ p2 |= 0x10;
+ }
+ if (instruction->index & 0x10)
+ {
+ p2 &= 0xF7;
+ }
+
+ ZYAN_CHECK(ZydisEmitByte(0x62, buffer));
+ ZYAN_CHECK(ZydisEmitByte(p0, buffer));
+ ZYAN_CHECK(ZydisEmitByte(p1, buffer));
+ ZYAN_CHECK(ZydisEmitByte(p2, buffer));
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * Emits `MVEX` prefix.
+ *
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ * @param buffer A pointer to `ZydisEncoderBuffer` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisEmitMvex(ZydisEncoderInstruction *instruction, ZydisEncoderBuffer *buffer)
+{
+ ZyanU8 p0, p1, vvvvv;
+ ZydisEncodeEvexCommons(instruction, &p0, &p1, &vvvvv);
+ ZyanU8 p2 = (instruction->sss << 4) | ((vvvvv & 0x10) >> 1) | instruction->mask;
+ if (instruction->eviction_hint)
+ {
+ p2 |= 0x80;
+ }
+ if (instruction->index & 0x10)
+ {
+ p2 &= 0xF7;
+ }
+
+ ZYAN_CHECK(ZydisEmitByte(0x62, buffer));
+ ZYAN_CHECK(ZydisEmitByte(p0, buffer));
+ ZYAN_CHECK(ZydisEmitByte(p1 & 0xFB, buffer));
+ ZYAN_CHECK(ZydisEmitByte(p2, buffer));
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * Emits instruction as stream of bytes.
+ *
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ * @param buffer A pointer to `ZydisEncoderBuffer` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisEmitInstruction(ZydisEncoderInstruction *instruction,
+ ZydisEncoderBuffer *buffer)
+{
+ ZYAN_CHECK(ZydisEmitLegacyPrefixes(instruction, buffer));
+
+ switch (instruction->encoding)
+ {
+ case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
+ case ZYDIS_INSTRUCTION_ENCODING_3DNOW:
+ ZYAN_CHECK(ZydisEmitRex(instruction, buffer));
+ break;
+ case ZYDIS_INSTRUCTION_ENCODING_XOP:
+ ZYAN_CHECK(ZydisEmitXop(instruction, buffer));
+ break;
+ case ZYDIS_INSTRUCTION_ENCODING_VEX:
+ ZYAN_CHECK(ZydisEmitVex(instruction, buffer));
+ break;
+ case ZYDIS_INSTRUCTION_ENCODING_EVEX:
+ ZYAN_CHECK(ZydisEmitEvex(instruction, buffer));
+ break;
+ case ZYDIS_INSTRUCTION_ENCODING_MVEX:
+ ZYAN_CHECK(ZydisEmitMvex(instruction, buffer));
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ switch (instruction->opcode_map)
+ {
+ case ZYDIS_OPCODE_MAP_DEFAULT:
+ break;
+ case ZYDIS_OPCODE_MAP_0F:
+ ZYAN_CHECK(ZydisEmitByte(0x0F, buffer));
+ break;
+ case ZYDIS_OPCODE_MAP_0F38:
+ ZYAN_CHECK(ZydisEmitByte(0x0F, buffer));
+ ZYAN_CHECK(ZydisEmitByte(0x38, buffer));
+ break;
+ case ZYDIS_OPCODE_MAP_0F3A:
+ ZYAN_CHECK(ZydisEmitByte(0x0F, buffer));
+ ZYAN_CHECK(ZydisEmitByte(0x3A, buffer));
+ break;
+ case ZYDIS_OPCODE_MAP_0F0F:
+ ZYAN_CHECK(ZydisEmitByte(0x0F, buffer));
+ ZYAN_CHECK(ZydisEmitByte(0x0F, buffer));
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ if (instruction->encoding != ZYDIS_INSTRUCTION_ENCODING_3DNOW)
+ {
+ ZYAN_CHECK(ZydisEmitByte(instruction->opcode, buffer));
+ }
+
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_MODRM)
+ {
+ const ZyanU8 modrm = (instruction->mod << 6) |
+ ((instruction->reg & 7) << 3) |
+ (instruction->rm & 7);
+ ZYAN_CHECK(ZydisEmitByte(modrm, buffer));
+ }
+ if (instruction->attributes & ZYDIS_ATTRIB_HAS_SIB)
+ {
+ const ZyanU8 sib = (instruction->scale << 6) |
+ ((instruction->index & 7) << 3) |
+ (instruction->base & 7);
+ ZYAN_CHECK(ZydisEmitByte(sib, buffer));
+ }
+ if (instruction->disp_size)
+ {
+ ZYAN_CHECK(ZydisEmitUInt(instruction->disp, instruction->disp_size / 8, buffer));
+ }
+ if (instruction->imm_size)
+ {
+ ZYAN_CHECK(ZydisEmitUInt(instruction->imm, instruction->imm_size / 8, buffer));
+ }
+ if (instruction->encoding == ZYDIS_INSTRUCTION_ENCODING_3DNOW)
+ {
+ ZYAN_CHECK(ZydisEmitByte(instruction->opcode, buffer));
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * Encodes register operand as fields inside `ZydisEncoderInstruction` structure.
+ *
+ * @param user_op Validated operand definition from `ZydisEncoderRequest` structure.
+ * @param def_op Decoder's operand definition from instruction definition.
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ */
+void ZydisBuildRegisterOperand(const ZydisEncoderOperand *user_op,
+ const ZydisOperandDefinition *def_op, ZydisEncoderInstruction *instruction)
+{
+ if (def_op->type == ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_REG)
+ {
+ return;
+ }
+
+ ZyanU8 reg_id = 0;
+ if (ZydisRegisterGetClass(user_op->reg.value) != ZYDIS_REGCLASS_GPR8)
+ {
+ reg_id = (ZyanU8)ZydisRegisterGetId(user_op->reg.value);
+ }
+ else
+ {
+ static const ZyanU8 reg8_lookup[] = {
+ 0, 1, 2, 3, // AL, CL, DL, BL
+ 4, 5, 6, 7, // AH, CH, DH, BH
+ 4, 5, 6, 7, // SPL, BPL, SIL, DIL
+ 8, 9, 10, 11, 12, 13, 14, 15, // R8B-R15B
+ };
+ ZYAN_ASSERT(
+ ((ZyanUSize)user_op->reg.value - ZYDIS_REGISTER_AL) < ZYAN_ARRAY_LENGTH(reg8_lookup));
+ reg_id = reg8_lookup[user_op->reg.value - ZYDIS_REGISTER_AL];
+ if (user_op->reg.value >= ZYDIS_REGISTER_SPL && user_op->reg.value <= ZYDIS_REGISTER_DIL)
+ {
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_REX;
+ }
+ }
+
+ switch (def_op->op.encoding)
+ {
+ case ZYDIS_OPERAND_ENCODING_MODRM_REG:
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_MODRM;
+ instruction->reg = reg_id;
+ break;
+ case ZYDIS_OPERAND_ENCODING_MODRM_RM:
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_MODRM;
+ instruction->rm = reg_id;
+ break;
+ case ZYDIS_OPERAND_ENCODING_OPCODE:
+ instruction->opcode += reg_id & 7;
+ instruction->rm = reg_id;
+ break;
+ case ZYDIS_OPERAND_ENCODING_NDSNDD:
+ instruction->vvvv = reg_id;
+ break;
+ case ZYDIS_OPERAND_ENCODING_IS4:
+ instruction->imm_size = 8;
+ instruction->imm = reg_id << 4;
+ break;
+ case ZYDIS_OPERAND_ENCODING_MASK:
+ instruction->mask = reg_id;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+}
+
+/**
+ * Encodes memory operand as fields inside `ZydisEncoderInstruction` structure.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param user_op Decoder's operand definition from instruction definition.
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ */
+static void ZydisBuildMemoryOperand(ZydisEncoderInstructionMatch *match,
+ const ZydisEncoderOperand *user_op, ZydisEncoderInstruction *instruction)
+{
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_MODRM;
+ instruction->disp = (ZyanU64)user_op->mem.displacement;
+ if (match->easz == 16)
+ {
+ const ZyanI8 rm = ZydisGetRm16(user_op->mem.base, user_op->mem.index);
+ if (rm != -1)
+ {
+ instruction->rm = (ZyanU8)rm;
+ instruction->disp_size = match->disp_size;
+ switch (instruction->disp_size)
+ {
+ case 0:
+ if (rm == 6)
+ {
+ instruction->disp_size = 8;
+ instruction->mod = 1;
+ }
+ break;
+ case 8:
+ instruction->mod = 1;
+ break;
+ case 16:
+ instruction->mod = 2;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ }
+ else
+ {
+ instruction->rm = 6;
+ instruction->disp_size = 16;
+ }
+ return;
+ }
+
+ if (user_op->mem.index == ZYDIS_REGISTER_NONE)
+ {
+ if (user_op->mem.base == ZYDIS_REGISTER_NONE)
+ {
+ if (match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
+ {
+ instruction->rm = 4;
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_SIB;
+ instruction->base = 5;
+ instruction->index = 4;
+ }
+ else
+ {
+ instruction->rm = 5;
+ }
+ instruction->disp_size = 32;
+ return;
+ }
+ else if ((user_op->mem.base == ZYDIS_REGISTER_RIP) ||
+ (user_op->mem.base == ZYDIS_REGISTER_EIP))
+ {
+ instruction->rm = 5;
+ instruction->disp_size = 32;
+ return;
+ }
+ }
+
+ const ZyanU8 reg_base_id = (ZyanU8)ZydisRegisterGetId(user_op->mem.base);
+ const ZyanU8 reg_index_id = (ZyanU8)ZydisRegisterGetId(user_op->mem.index);
+ instruction->disp_size = match->disp_size;
+ switch (instruction->disp_size)
+ {
+ case 0:
+ if (reg_base_id == 5 || reg_base_id == 13)
+ {
+ instruction->disp_size = 8;
+ instruction->disp = 0;
+ instruction->mod = 1;
+ }
+ break;
+ case 8:
+ instruction->mod = 1;
+ break;
+ case 16:
+ instruction->disp_size = 32;
+ ZYAN_FALLTHROUGH;
+ case 32:
+ instruction->mod = 2;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ if ((user_op->mem.index == ZYDIS_REGISTER_NONE) &&
+ (reg_base_id != 4) &&
+ (reg_base_id != 12) &&
+ ((match->definition->modrm & 7) != 4))
+ {
+ instruction->rm = reg_base_id;
+ return;
+ }
+ instruction->rm = 4;
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_SIB;
+ if (reg_base_id != 0xFF)
+ {
+ instruction->base = reg_base_id;
+ }
+ else
+ {
+ instruction->base = 5;
+ instruction->mod = 0;
+ instruction->disp_size = 32;
+ }
+ if (reg_index_id != 0xFF)
+ {
+ instruction->index = reg_index_id;
+ }
+ else
+ {
+ instruction->index = 4;
+ }
+ switch (user_op->mem.scale)
+ {
+ case 0:
+ case 1:
+ break;
+ case 2:
+ instruction->scale = 1;
+ break;
+ case 4:
+ instruction->scale = 2;
+ break;
+ case 8:
+ instruction->scale = 3;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+}
+
+/**
+ * Encodes instruction as emittable `ZydisEncoderInstruction` struct.
+ *
+ * @param match A pointer to `ZydisEncoderInstructionMatch` struct.
+ * @param instruction A pointer to `ZydisEncoderInstruction` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisBuildInstruction(ZydisEncoderInstructionMatch *match,
+ ZydisEncoderInstruction *instruction)
+{
+ ZYAN_MEMSET(instruction, 0, sizeof(ZydisEncoderInstruction));
+ instruction->attributes = match->attributes;
+ instruction->encoding = match->definition->encoding;
+ instruction->opcode_map = match->definition->opcode_map;
+ instruction->opcode = match->definition->opcode;
+ instruction->rex_w = match->definition->rex_w;
+ instruction->mod = (match->definition->modrm >> 6) & 3;
+ instruction->reg = (match->definition->modrm >> 3) & 7;
+ instruction->rm = match->definition->modrm & 7;
+ if (match->definition->modrm)
+ {
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_MODRM;
+ }
+
+ switch (match->definition->vector_length)
+ {
+ case ZYDIS_VECTOR_LENGTH_INVALID:
+ case ZYDIS_VECTOR_LENGTH_128:
+ instruction->vector_length = 0;
+ break;
+ case ZYDIS_VECTOR_LENGTH_256:
+ instruction->vector_length = 1;
+ break;
+ case ZYDIS_VECTOR_LENGTH_512:
+ instruction->vector_length = 2;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ if (match->definition->encoding == ZYDIS_INSTRUCTION_ENCODING_EVEX)
+ {
+ const ZydisInstructionDefinitionEVEX *evex_def =
+ (const ZydisInstructionDefinitionEVEX *)match->base_definition;
+ if (evex_def->mask_override != ZYDIS_MASK_OVERRIDE_ZEROING)
+ {
+ instruction->zeroing = match->request->evex.zeroing_mask;
+ }
+ if ((match->request->evex.sae) ||
+ (match->request->evex.broadcast != ZYDIS_BROADCAST_MODE_INVALID))
+ {
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_EVEX_B;
+ }
+ if (match->request->evex.rounding != ZYDIS_ROUNDING_MODE_INVALID)
+ {
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_EVEX_B;
+ switch (match->request->evex.rounding)
+ {
+ case ZYDIS_ROUNDING_MODE_RN:
+ instruction->vector_length = 0;
+ break;
+ case ZYDIS_ROUNDING_MODE_RD:
+ instruction->vector_length = 1;
+ break;
+ case ZYDIS_ROUNDING_MODE_RU:
+ instruction->vector_length = 2;
+ break;
+ case ZYDIS_ROUNDING_MODE_RZ:
+ instruction->vector_length = 3;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ }
+ }
+ else if (match->definition->encoding == ZYDIS_INSTRUCTION_ENCODING_MVEX)
+ {
+ instruction->sss |= ZydisEncodeMvexBroadcastMode(match->request->mvex.broadcast);
+ instruction->sss |= ZydisEncodeMvexConversionMode(match->request->mvex.conversion);
+
+ switch (match->request->mvex.rounding)
+ {
+ case ZYDIS_ROUNDING_MODE_INVALID:
+ break;
+ case ZYDIS_ROUNDING_MODE_RN:
+ case ZYDIS_ROUNDING_MODE_RD:
+ case ZYDIS_ROUNDING_MODE_RU:
+ case ZYDIS_ROUNDING_MODE_RZ:
+ instruction->sss |= match->request->mvex.rounding - ZYDIS_ROUNDING_MODE_RN;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ switch (match->request->mvex.swizzle)
+ {
+ case ZYDIS_SWIZZLE_MODE_INVALID:
+ break;
+ case ZYDIS_SWIZZLE_MODE_DCBA:
+ case ZYDIS_SWIZZLE_MODE_CDAB:
+ case ZYDIS_SWIZZLE_MODE_BADC:
+ case ZYDIS_SWIZZLE_MODE_DACB:
+ case ZYDIS_SWIZZLE_MODE_AAAA:
+ case ZYDIS_SWIZZLE_MODE_BBBB:
+ case ZYDIS_SWIZZLE_MODE_CCCC:
+ case ZYDIS_SWIZZLE_MODE_DDDD:
+ instruction->sss |= match->request->mvex.swizzle - ZYDIS_SWIZZLE_MODE_DCBA;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ if ((match->request->mvex.sae) ||
+ (match->request->mvex.eviction_hint) ||
+ (match->request->mvex.rounding != ZYDIS_ROUNDING_MODE_INVALID))
+ {
+ instruction->eviction_hint = ZYAN_TRUE;
+ }
+ if (match->request->mvex.sae)
+ {
+ instruction->sss |= 4;
+ }
+
+ // Following instructions violate general `MVEX.EH` handling rules. In all other cases this
+ // bit is used either as eviction hint (memory operands present) or to encode MVEX-specific
+ // functionality (register forms). Instructions listed below use `MVEX.EH` to identify
+ // different instructions with memory operands and don't treat it as eviction hint.
+ switch (match->request->mnemonic)
+ {
+ case ZYDIS_MNEMONIC_VMOVNRAPD:
+ case ZYDIS_MNEMONIC_VMOVNRAPS:
+ instruction->eviction_hint = ZYAN_FALSE;
+ break;
+ case ZYDIS_MNEMONIC_VMOVNRNGOAPD:
+ case ZYDIS_MNEMONIC_VMOVNRNGOAPS:
+ instruction->eviction_hint = ZYAN_TRUE;
+ break;
+ default:
+ break;
+ }
+ }
+
+ switch (match->definition->mandatory_prefix)
+ {
+ case ZYDIS_MANDATORY_PREFIX_NONE:
+ break;
+ case ZYDIS_MANDATORY_PREFIX_66:
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_OPERANDSIZE;
+ break;
+ case ZYDIS_MANDATORY_PREFIX_F2:
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_REPNE;
+ break;
+ case ZYDIS_MANDATORY_PREFIX_F3:
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_REP;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+
+ const ZyanU8 mode_width = ZydisGetMachineModeWidth(match->request->machine_mode);
+ if (match->easz != mode_width)
+ {
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_ADDRESSSIZE;
+ }
+ if ((match->request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64) &&
+ (match->base_definition->operand_size_map != ZYDIS_OPSIZE_MAP_FORCE64))
+ {
+ switch (match->eosz)
+ {
+ case 16:
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_OPERANDSIZE;
+ break;
+ case 32:
+ break;
+ case 64:
+ instruction->rex_w =
+ match->base_definition->operand_size_map != ZYDIS_OPSIZE_MAP_DEFAULT64;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ }
+ else
+ {
+ if (match->eosz != mode_width)
+ {
+ instruction->attributes |= ZYDIS_ATTRIB_HAS_OPERANDSIZE;
+ }
+ }
+
+ for (ZyanU8 i = 0; i < match->request->operand_count; ++i)
+ {
+ const ZydisEncoderOperand *user_op = &match->request->operands[i];
+ const ZydisOperandDefinition *def_op = &match->operands[i];
+ switch (user_op->type)
+ {
+ case ZYDIS_OPERAND_TYPE_REGISTER:
+ ZydisBuildRegisterOperand(user_op, def_op, instruction);
+ break;
+ case ZYDIS_OPERAND_TYPE_MEMORY:
+ if (def_op->type != ZYDIS_SEMANTIC_OPTYPE_MOFFS)
+ {
+ ZydisBuildMemoryOperand(match, user_op, instruction);
+ if ((match->cd8_scale) &&
+ (instruction->disp_size == 8))
+ {
+ instruction->disp >>= match->cd8_scale;
+ }
+ }
+ else
+ {
+ instruction->disp_size = match->disp_size;
+ instruction->disp = (ZyanU64)user_op->mem.displacement;
+ }
+ break;
+ case ZYDIS_OPERAND_TYPE_POINTER:
+ instruction->disp_size = match->disp_size;
+ instruction->disp = user_op->ptr.offset;
+ instruction->imm_size = match->imm_size;
+ instruction->imm = user_op->ptr.segment;
+ break;
+ case ZYDIS_OPERAND_TYPE_IMMEDIATE:
+ if (def_op->type == ZYDIS_SEMANTIC_OPTYPE_IMPLICIT_IMM1)
+ {
+ break;
+ }
+ if (def_op->op.encoding != ZYDIS_OPERAND_ENCODING_IS4)
+ {
+ if (instruction->imm_size)
+ {
+ ZYAN_ASSERT(instruction->disp_size == 0);
+ instruction->disp_size = match->disp_size;
+ instruction->disp = instruction->imm;
+ }
+ instruction->imm_size = match->imm_size;
+ instruction->imm = user_op->imm.u;
+ }
+ else
+ {
+ ZYAN_ASSERT(instruction->imm_size == 8);
+ instruction->imm |= user_op->imm.u;
+ }
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * Performs a set of sanity checks that must be satisfied for every valid encoder request.
+ *
+ * @param request A pointer to `ZydisEncoderRequest` struct.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisEncoderCheckRequestSanity(const ZydisEncoderRequest *request)
+{
+ if (((ZyanUSize)request->machine_mode > ZYDIS_MACHINE_MODE_MAX_VALUE) ||
+ ((ZyanUSize)request->allowed_encodings > ZYDIS_ENCODABLE_ENCODING_MAX_VALUE) ||
+ ((ZyanUSize)request->mnemonic > ZYDIS_MNEMONIC_MAX_VALUE) ||
+ ((ZyanUSize)request->branch_type > ZYDIS_BRANCH_TYPE_MAX_VALUE) ||
+ ((ZyanUSize)request->branch_width > ZYDIS_BRANCH_WIDTH_MAX_VALUE) ||
+ ((ZyanUSize)request->address_size_hint > ZYDIS_ADDRESS_SIZE_HINT_MAX_VALUE) ||
+ ((ZyanUSize)request->operand_size_hint > ZYDIS_OPERAND_SIZE_HINT_MAX_VALUE) ||
+ ((ZyanUSize)request->evex.broadcast > ZYDIS_BROADCAST_MODE_MAX_VALUE) ||
+ ((ZyanUSize)request->evex.rounding > ZYDIS_ROUNDING_MODE_MAX_VALUE) ||
+ ((ZyanUSize)request->mvex.broadcast > ZYDIS_BROADCAST_MODE_MAX_VALUE) ||
+ ((ZyanUSize)request->mvex.conversion > ZYDIS_CONVERSION_MODE_MAX_VALUE) ||
+ ((ZyanUSize)request->mvex.rounding > ZYDIS_ROUNDING_MODE_MAX_VALUE) ||
+ ((ZyanUSize)request->mvex.swizzle > ZYDIS_SWIZZLE_MODE_MAX_VALUE) ||
+ (request->operand_count > ZYDIS_ENCODER_MAX_OPERANDS) ||
+ (request->mnemonic == ZYDIS_MNEMONIC_INVALID) ||
+ (request->prefixes & ~ZYDIS_ENCODABLE_PREFIXES))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (request->prefixes & ZYDIS_ATTRIB_HAS_SEGMENT)
+ {
+ if ((request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64) &&
+ (request->prefixes & ZYDIS_LEGACY_SEGMENTS))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZyanU8 seg_override_count = 0;
+ if (request->prefixes & ZYDIS_ATTRIB_HAS_SEGMENT_CS)
+ {
+ ++seg_override_count;
+ }
+ if (request->prefixes & ZYDIS_ATTRIB_HAS_SEGMENT_SS)
+ {
+ ++seg_override_count;
+ }
+ if (request->prefixes & ZYDIS_ATTRIB_HAS_SEGMENT_DS)
+ {
+ ++seg_override_count;
+ }
+ if (request->prefixes & ZYDIS_ATTRIB_HAS_SEGMENT_ES)
+ {
+ ++seg_override_count;
+ }
+ if (request->prefixes & ZYDIS_ATTRIB_HAS_SEGMENT_FS)
+ {
+ ++seg_override_count;
+ }
+ if (request->prefixes & ZYDIS_ATTRIB_HAS_SEGMENT_GS)
+ {
+ ++seg_override_count;
+ }
+ if (seg_override_count != 1)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ }
+ ZyanU8 rep_family_count = 0;
+ if (request->prefixes & ZYDIS_ATTRIB_HAS_REP)
+ {
+ ++rep_family_count;
+ }
+ if (request->prefixes & ZYDIS_ATTRIB_HAS_REPE)
+ {
+ ++rep_family_count;
+ }
+ if (request->prefixes & ZYDIS_ATTRIB_HAS_REPNE)
+ {
+ ++rep_family_count;
+ }
+ if (rep_family_count > 1)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if ((request->prefixes & ZYDIS_ATTRIB_HAS_XACQUIRE) &&
+ (request->prefixes & ZYDIS_ATTRIB_HAS_XRELEASE))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if ((request->prefixes & ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN) &&
+ (request->prefixes & ZYDIS_ATTRIB_HAS_BRANCH_TAKEN))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if ((request->prefixes & ZYDIS_ATTRIB_HAS_NOTRACK) &&
+ (request->prefixes & ZYDIS_ATTRIB_HAS_SEGMENT))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ static const ZyanBool branch_lookup
+ [ZYDIS_BRANCH_WIDTH_MAX_VALUE + 1][ZYDIS_BRANCH_TYPE_MAX_VALUE + 1] =
+ {
+ /* NONE */ { ZYAN_TRUE, ZYAN_TRUE, ZYAN_TRUE, ZYAN_TRUE },
+ /* 8 */ { ZYAN_TRUE, ZYAN_TRUE, ZYAN_FALSE, ZYAN_FALSE },
+ /* 16 */ { ZYAN_TRUE, ZYAN_FALSE, ZYAN_TRUE, ZYAN_TRUE },
+ /* 32 */ { ZYAN_TRUE, ZYAN_FALSE, ZYAN_TRUE, ZYAN_TRUE },
+ /* 64 */ { ZYAN_TRUE, ZYAN_FALSE, ZYAN_TRUE, ZYAN_TRUE },
+ };
+ if (!branch_lookup[request->branch_width][request->branch_type])
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (request->machine_mode == ZYDIS_MACHINE_MODE_LONG_64)
+ {
+ if (request->address_size_hint == ZYDIS_ADDRESS_SIZE_HINT_16)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ }
+ else
+ {
+ if ((request->branch_width == ZYDIS_BRANCH_WIDTH_64) ||
+ (request->address_size_hint == ZYDIS_ADDRESS_SIZE_HINT_64) ||
+ (request->operand_size_hint == ZYDIS_OPERAND_SIZE_HINT_64))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ }
+
+ for (ZyanU8 i = 0; i < request->operand_count; ++i)
+ {
+ const ZydisEncoderOperand *op = &request->operands[i];
+ if ((op->type == ZYDIS_OPERAND_TYPE_UNUSED) ||
+ ((ZyanUSize)op->type > ZYDIS_OPERAND_TYPE_MAX_VALUE))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ switch (op->type)
+ {
+ case ZYDIS_OPERAND_TYPE_REGISTER:
+ if (op->reg.value > ZYDIS_REGISTER_MAX_VALUE)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ break;
+ case ZYDIS_OPERAND_TYPE_MEMORY:
+ if (((ZyanUSize)op->mem.base > ZYDIS_REGISTER_MAX_VALUE) ||
+ ((ZyanUSize)op->mem.index > ZYDIS_REGISTER_MAX_VALUE) ||
+ !ZydisIsScaleValid(op->mem.scale))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ break;
+ case ZYDIS_OPERAND_TYPE_POINTER:
+ case ZYDIS_OPERAND_TYPE_IMMEDIATE:
+ break;
+ default:
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/**
+ * Encodes instruction with semantics specified in encoder request structure.
+ *
+ * @param request A pointer to the `ZydisEncoderRequest` struct. Must be validated before
+ * calling this function.
+ * @param buffer A pointer to the output buffer receiving encoded instruction.
+ * @param length A pointer to the variable containing length of the output buffer. Upon
+ * successful return this variable receives length of the encoded instruction.
+ * @param instruction Internal state of the encoder.
+ *
+ * @return A zyan status code.
+ */
+static ZyanStatus ZydisEncoderEncodeInstructionInternal(const ZydisEncoderRequest *request,
+ void *buffer, ZyanUSize *length, ZydisEncoderInstruction *instruction)
+{
+ ZydisEncoderInstructionMatch match;
+ ZYAN_CHECK(ZydisFindMatchingDefinition(request, &match));
+ ZydisEncoderBuffer output;
+ output.buffer = (ZyanU8 *)buffer;
+ output.size = *length;
+ output.offset = 0;
+ ZYAN_CHECK(ZydisBuildInstruction(&match, instruction));
+ ZYAN_CHECK(ZydisEmitInstruction(instruction, &output));
+ *length = output.offset;
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ============================================================================================== */
+/* Exported functions */
+/* ============================================================================================== */
+
+ZYDIS_EXPORT ZyanStatus ZydisEncoderEncodeInstruction(const ZydisEncoderRequest *request,
+ void *buffer, ZyanUSize *length)
+{
+ if (!request || !buffer || !length)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ ZYAN_CHECK(ZydisEncoderCheckRequestSanity(request));
+
+ ZydisEncoderInstruction instruction;
+ return ZydisEncoderEncodeInstructionInternal(request, buffer, length, &instruction);
+}
+
+ZYDIS_EXPORT ZyanStatus ZydisEncoderEncodeInstructionAbsolute(ZydisEncoderRequest *request,
+ void *buffer, ZyanUSize *length, ZyanU64 runtime_address)
+{
+ if (!request || !buffer || !length)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ ZYAN_CHECK(ZydisEncoderCheckRequestSanity(request));
+
+ const ZydisEncoderRelInfo *rel_info = ZydisGetRelInfo(request->mnemonic);
+ ZydisEncoderOperand *op_rip_rel = ZYAN_NULL;
+ ZyanBool adjusted_rel = ZYAN_FALSE;
+ ZyanU64 absolute_address = 0;
+ ZyanU8 mode_index = ZydisGetMachineModeWidth(request->machine_mode) >> 5;
+ for (ZyanU8 i = 0; i < request->operand_count; ++i)
+ {
+ ZydisEncoderOperand *op = &request->operands[i];
+ if ((op->type == ZYDIS_OPERAND_TYPE_IMMEDIATE) && rel_info)
+ {
+ if (adjusted_rel)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ switch (rel_info->accepts_scaling_hints)
+ {
+ case ZYDIS_SIZE_HINT_NONE:
+ case ZYDIS_SIZE_HINT_OSZ:
+ {
+ static const ZyanI8 asz_priority[3][3] =
+ {
+ { 0, 1, 2 },
+ { 0, 2, 1 },
+ { 0, 2, -1 },
+ };
+ static const ZyanI8 osz_priority[3][3] =
+ {
+ { 0, 1, 2 },
+ { 0, 2, 1 },
+ { 0, 2, 1 },
+ };
+ ZyanI8 forced_priority_row[3] = { -1, -1, -1 };
+ ZyanI8 *priority_row = ZYAN_NULL;
+ ZyanU8 extra_length = 0;
+ ZyanU8 start_offset = 0;
+ if (rel_info->accepts_scaling_hints == ZYDIS_SIZE_HINT_NONE)
+ {
+ if ((request->branch_type == ZYDIS_BRANCH_TYPE_FAR) ||
+ (request->branch_width == ZYDIS_BRANCH_WIDTH_64))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ if ((rel_info->accepts_branch_hints) &&
+ (request->prefixes & (ZYDIS_ATTRIB_HAS_BRANCH_NOT_TAKEN |
+ ZYDIS_ATTRIB_HAS_BRANCH_TAKEN)))
+ {
+ extra_length = 1;
+ }
+ if (request->branch_width == ZYDIS_BRANCH_WIDTH_NONE)
+ {
+ if (request->branch_type == ZYDIS_BRANCH_TYPE_NEAR)
+ {
+ start_offset = 1;
+ }
+ priority_row = (ZyanI8 *)&asz_priority[mode_index];
+ }
+ else
+ {
+ forced_priority_row[0] = (ZyanI8)(request->branch_width - 1);
+ priority_row = (ZyanI8 *)&forced_priority_row;
+ }
+ }
+ else
+ {
+ if (request->operand_size_hint == ZYDIS_OPERAND_SIZE_HINT_NONE)
+ {
+ priority_row = (ZyanI8 *)&osz_priority[mode_index];
+ }
+ else
+ {
+ if (request->operand_size_hint == ZYDIS_OPERAND_SIZE_HINT_64)
+ {
+ extra_length = 1;
+ forced_priority_row[0] = 2;
+ }
+ else
+ {
+ forced_priority_row[0] = (ZyanI8)(request->operand_size_hint - 1);
+ }
+ priority_row = (ZyanI8 *)&forced_priority_row;
+ }
+ }
+ ZYAN_ASSERT(ZYAN_ARRAY_LENGTH(asz_priority[0]) ==
+ ZYAN_ARRAY_LENGTH(osz_priority[0]));
+ for (ZyanU8 j = start_offset; j < ZYAN_ARRAY_LENGTH(asz_priority[0]); ++j)
+ {
+ ZyanI8 size_index = priority_row[j];
+ if (size_index < 0)
+ {
+ break;
+ }
+ ZyanU8 base_size = rel_info->size[mode_index][size_index];
+ if (base_size == 0)
+ {
+ continue;
+ }
+ ZyanU8 predicted_size = base_size + extra_length;
+ if (runtime_address > ZYAN_UINT64_MAX - predicted_size + 1)
+ {
+ continue;
+ }
+ ZyanI64 rel = (ZyanI64)(op->imm.u - (runtime_address + predicted_size));
+ ZyanU8 rel_size = ZydisGetSignedImmSize(rel);
+ if (rel_size > (8 << size_index))
+ {
+ continue;
+ }
+ op->imm.s = rel;
+ adjusted_rel = ZYAN_TRUE;
+ break;
+ }
+ break;
+ }
+ case ZYDIS_SIZE_HINT_ASZ:
+ {
+ static const ZyanI8 asz_prefix_lookup[3][ZYDIS_ADDRESS_SIZE_HINT_MAX_VALUE + 1] =
+ {
+ { 0, 0, 1, -1 },
+ { 0, 1, 0, -1 },
+ { 0, -1, 1, 0 },
+ };
+ ZyanI8 extra_length = asz_prefix_lookup[mode_index][request->address_size_hint];
+ if (extra_length < 0)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ ZyanU8 asz_index = (request->address_size_hint == ZYDIS_ADDRESS_SIZE_HINT_NONE)
+ ? mode_index
+ : ZydisGetAszFromHint(request->address_size_hint) >> 5;
+ ZYAN_ASSERT((rel_info->size[asz_index][0] != 0) &&
+ (rel_info->size[asz_index][1] == 0) &&
+ (rel_info->size[asz_index][2] == 0) &&
+ !rel_info->accepts_branch_hints);
+ ZyanU8 predicted_size = rel_info->size[asz_index][0] + extra_length;
+ if (runtime_address > ZYAN_UINT64_MAX - predicted_size + 1)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ ZyanI64 rel = (ZyanI64)(op->imm.u - (runtime_address + predicted_size));
+ ZyanU8 rel_size = ZydisGetSignedImmSize(rel);
+ if (rel_size > 8)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ op->imm.s = rel;
+ adjusted_rel = ZYAN_TRUE;
+ break;
+ }
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ if (!adjusted_rel)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ }
+ else if ((op->type == ZYDIS_OPERAND_TYPE_MEMORY) &&
+ ((op->mem.base == ZYDIS_REGISTER_EIP) ||
+ (op->mem.base == ZYDIS_REGISTER_RIP)))
+ {
+ if (op_rip_rel)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ absolute_address = op->mem.displacement;
+ op->mem.displacement = 0;
+ op_rip_rel = op;
+ }
+ }
+
+ ZydisEncoderInstruction instruction;
+ ZYAN_CHECK(ZydisEncoderEncodeInstructionInternal(request, buffer, length, &instruction));
+ if (op_rip_rel)
+ {
+ ZyanUSize instruction_size = *length;
+ if (runtime_address > ZYAN_UINT64_MAX - instruction_size + 1)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ ZyanI64 rip_rel = (ZyanI64)(absolute_address - (runtime_address + instruction_size));
+ if (ZydisGetSignedImmSize(rip_rel) > 32)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ ZYAN_ASSERT(instruction.disp_size != 0);
+ ZyanU8 disp_offset = (instruction.disp_size >> 3) + (instruction.imm_size >> 3);
+ ZYAN_ASSERT(instruction_size > disp_offset);
+ ZYAN_MEMCPY((ZyanU8 *)buffer + instruction_size - disp_offset, &rip_rel, sizeof(ZyanI32));
+ op_rip_rel->mem.displacement = rip_rel;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZYDIS_EXPORT ZyanStatus ZydisEncoderDecodedInstructionToEncoderRequest(
+ const ZydisDecodedInstruction *instruction, const ZydisDecodedOperand* operands,
+ ZyanU8 operand_count, ZydisEncoderRequest *request)
+{
+ if (!instruction || !request || (operand_count && !operands))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ ZYAN_MEMSET(request, 0, sizeof(ZydisEncoderRequest));
+ request->machine_mode = instruction->machine_mode;
+ request->mnemonic = instruction->mnemonic;
+ request->prefixes = instruction->attributes & ZYDIS_ENCODABLE_PREFIXES;
+ request->branch_type = instruction->meta.branch_type;
+ if (!(instruction->attributes & ZYDIS_ATTRIB_ACCEPTS_SEGMENT))
+ {
+ request->prefixes &= ~ZYDIS_ATTRIB_HAS_SEGMENT;
+ }
+
+ switch (instruction->address_width)
+ {
+ case 16:
+ request->address_size_hint = ZYDIS_ADDRESS_SIZE_HINT_16;
+ break;
+ case 32:
+ request->address_size_hint = ZYDIS_ADDRESS_SIZE_HINT_32;
+ break;
+ case 64:
+ request->address_size_hint = ZYDIS_ADDRESS_SIZE_HINT_64;
+ break;
+ default:
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ switch (instruction->operand_width)
+ {
+ case 8:
+ request->operand_size_hint = ZYDIS_OPERAND_SIZE_HINT_8;
+ break;
+ case 16:
+ request->operand_size_hint = ZYDIS_OPERAND_SIZE_HINT_16;
+ break;
+ case 32:
+ request->operand_size_hint = ZYDIS_OPERAND_SIZE_HINT_32;
+ break;
+ case 64:
+ request->operand_size_hint = ZYDIS_OPERAND_SIZE_HINT_64;
+ break;
+ default:
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ switch (request->branch_type)
+ {
+ case ZYDIS_BRANCH_TYPE_NONE:
+ request->branch_width = ZYDIS_BRANCH_WIDTH_NONE;
+ break;
+ case ZYDIS_BRANCH_TYPE_SHORT:
+ request->branch_width = ZYDIS_BRANCH_WIDTH_8;
+ break;
+ case ZYDIS_BRANCH_TYPE_NEAR:
+ case ZYDIS_BRANCH_TYPE_FAR:
+ switch (instruction->operand_width)
+ {
+ case 16:
+ request->branch_width = ZYDIS_BRANCH_WIDTH_16;
+ break;
+ case 32:
+ request->branch_width = ZYDIS_BRANCH_WIDTH_32;
+ break;
+ case 64:
+ request->branch_width = ZYDIS_BRANCH_WIDTH_64;
+ break;
+ default:
+ ZYAN_UNREACHABLE;
+ }
+ break;
+ default:
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ switch (instruction->encoding)
+ {
+ case ZYDIS_INSTRUCTION_ENCODING_LEGACY:
+ case ZYDIS_INSTRUCTION_ENCODING_3DNOW:
+ case ZYDIS_INSTRUCTION_ENCODING_XOP:
+ case ZYDIS_INSTRUCTION_ENCODING_VEX:
+ break;
+ case ZYDIS_INSTRUCTION_ENCODING_EVEX:
+ request->evex.broadcast = !instruction->avx.broadcast.is_static ?
+ instruction->avx.broadcast.mode : ZYDIS_BROADCAST_MODE_INVALID;
+ request->evex.rounding = instruction->avx.rounding.mode;
+ request->evex.sae = instruction->avx.has_sae;
+ request->evex.zeroing_mask = (instruction->avx.mask.mode == ZYDIS_MASK_MODE_ZEROING ||
+ instruction->avx.mask.mode == ZYDIS_MASK_MODE_CONTROL_ZEROING) &&
+ (instruction->raw.evex.z) ? ZYAN_TRUE : ZYAN_FALSE;
+ break;
+ case ZYDIS_INSTRUCTION_ENCODING_MVEX:
+ request->mvex.broadcast = !instruction->avx.broadcast.is_static ?
+ instruction->avx.broadcast.mode : ZYDIS_BROADCAST_MODE_INVALID;
+ request->mvex.conversion = instruction->avx.conversion.mode;
+ request->mvex.rounding = instruction->avx.rounding.mode;
+ request->mvex.swizzle = instruction->avx.swizzle.mode;
+ request->mvex.sae = instruction->avx.has_sae;
+ request->mvex.eviction_hint = instruction->avx.has_eviction_hint;
+ break;
+ default:
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ request->allowed_encodings = 1 << instruction->encoding;
+
+ if ((operand_count > ZYDIS_ENCODER_MAX_OPERANDS) ||
+ (operand_count > instruction->operand_count_visible))
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ request->operand_count = operand_count;
+ for (ZyanU8 i = 0; i < operand_count; ++i)
+ {
+ const ZydisDecodedOperand *dec_op = &operands[i];
+ ZydisEncoderOperand *enc_op = &request->operands[i];
+
+ enc_op->type = dec_op->type;
+ switch (dec_op->type)
+ {
+ case ZYDIS_OPERAND_TYPE_REGISTER:
+ enc_op->reg.value = dec_op->reg.value;
+ enc_op->reg.is4 = dec_op->encoding == ZYDIS_OPERAND_ENCODING_IS4;
+ break;
+ case ZYDIS_OPERAND_TYPE_MEMORY:
+ enc_op->mem.base = dec_op->mem.base;
+ enc_op->mem.index = dec_op->mem.index;
+ enc_op->mem.scale = dec_op->mem.type != ZYDIS_MEMOP_TYPE_MIB ? dec_op->mem.scale : 0;
+ if (dec_op->encoding == ZYDIS_OPERAND_ENCODING_DISP16_32_64)
+ {
+ ZydisCalcAbsoluteAddress(instruction, dec_op, 0,
+ (ZyanU64 *)&enc_op->mem.displacement);
+ }
+ else
+ {
+ enc_op->mem.displacement = dec_op->mem.disp.has_displacement ?
+ dec_op->mem.disp.value : 0;
+ }
+ enc_op->mem.size = dec_op->size / 8;
+ break;
+ case ZYDIS_OPERAND_TYPE_POINTER:
+ enc_op->ptr.segment = dec_op->ptr.segment;
+ enc_op->ptr.offset = dec_op->ptr.offset;
+ break;
+ case ZYDIS_OPERAND_TYPE_IMMEDIATE:
+ enc_op->imm.u = dec_op->imm.value.u;
+ // `XBEGIN` is an ISA-wide unique instruction because it's not a branching instruction
+ // but it has a relative operand which behaves differently from all other relatives
+ // (no truncating behavior in 16-bit mode). Encoder treats it as non-branching
+ // instruction that scales with hidden operand size.
+ if ((dec_op->imm.is_relative) &&
+ (instruction->mnemonic != ZYDIS_MNEMONIC_XBEGIN))
+ {
+ switch (instruction->raw.imm->size)
+ {
+ case 8:
+ request->branch_width = ZYDIS_BRANCH_WIDTH_8;
+ break;
+ case 16:
+ request->branch_width = ZYDIS_BRANCH_WIDTH_16;
+ break;
+ case 32:
+ request->branch_width = ZYDIS_BRANCH_WIDTH_32;
+ break;
+ default:
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ }
+ break;
+ default:
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+ZYDIS_EXPORT ZyanStatus ZydisEncoderNopFill(void *buffer, ZyanUSize length)
+{
+ if (!buffer)
+ {
+ return ZYAN_STATUS_INVALID_ARGUMENT;
+ }
+
+ // Intel SDM Vol. 2B "Recommended Multi-Byte Sequence of NOP Instruction"
+ static const ZyanU8 nops[9][9] =
+ {
+ { 0x90 },
+ { 0x66, 0x90 },
+ { 0x0F, 0x1F, 0x00 },
+ { 0x0F, 0x1F, 0x40, 0x00 },
+ { 0x0F, 0x1F, 0x44, 0x00, 0x00 },
+ { 0x66, 0x0F, 0x1F, 0x44, 0x00, 0x00 },
+ { 0x0F, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00 },
+ { 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ { 0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ };
+
+ ZyanU8 *output = (ZyanU8 *)buffer;
+ while (length)
+ {
+ ZyanUSize nop_size = (length > 9) ? 9 : length;
+ ZYAN_MEMCPY(output, nops[nop_size - 1], nop_size);
+ output += nop_size;
+ length -= nop_size;
+ }
+
+ return ZYAN_STATUS_SUCCESS;
+}
+
+/* ============================================================================================== */