diff --git a/MAINTAINERS b/MAINTAINERS index b7a91f331cd..638b6380f75 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1480,8 +1480,6 @@ Sun4v M: Artyom Tarasenko S: Maintained F: hw/sparc64/niagara.c -F: hw/rtc/sun4v-rtc.c -F: include/hw/rtc/sun4v-rtc.h Leon3 M: Fabien Chouteau diff --git a/NOTICE b/NOTICE new file mode 100644 index 00000000000..2ff41ca8ae3 --- /dev/null +++ b/NOTICE @@ -0,0 +1,113 @@ +Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ +Upstream-Name: LATX (LoongArch Architecture Translator for x86) +Source: https://github.com/lat-opensource/lat + +This file summarizes notable third-party open source code used by or +referenced in LATX. Source files may contain more specific copyright or +license notices; those file-level notices remain authoritative. + +Files: * +Source: https://www.qemu.org/ +Copyright: + Copyright (c) 2003-2008 Fabrice Bellard + Copyright (c) QEMU Project developers and contributors +License: GPL-2.0-only +Comment: + LATX is developed based on QEMU 6. The QEMU emulator as a whole is + released under the GNU General Public License, version 2. Some QEMU + files carry compatible file-level license notices. See LICENSE, COPYING, + COPYING.LIB, and individual source file headers for the original QEMU + license notices and file-specific terms. This stanza does not override + more specific file-level or third-party notices. + +Files: target/i386/latx/capstone_git/* +Source: https://www.capstone-engine.org/ +Copyright: + Copyright (c) 2013, COSEINC. + Copyright (c) Capstone contributors +License: BSD-3-Clause +Comment: + The bundled Capstone source includes its own license text in + target/i386/latx/capstone_git/LICENSE.TXT. Some bundled files also + refer to LLVM-derived license terms in LICENSE_LLVM.TXT. + +Files: target/i386/latx/include/zydisdir/* + target/i386/latx/exlib/libZydis.a + target/i386/latx/exlib/libZycore.a +Source: https://github.com/zyantific/zydis +Copyright: + Copyright (c) Zyan Disassembler Library authors + Copyright (c) Zycore authors +License: MIT +Comment: + The bundled Zydis headers carry MIT-style permission notices. The + prebuilt static libraries are listed here because they are linked by + LATX debug disassembly support; their exact source and license + obligations should be verified against the matching upstream Zydis and + Zycore releases. + +Files: target/i386/latx/include/khash.h +Source: https://github.com/attractivechaos/klib +Copyright: + Copyright (c) 2008, 2009, 2011 Attractive Chaos +License: MIT + +Files: target/i386/latx/exlib/libmimalloc.a +Source: https://github.com/microsoft/mimalloc +Copyright: + Copyright (c) Microsoft Corporation +License: MIT +Comment: + This prebuilt static library is listed because it is distributed in the + source tree. Its exact source and license obligations should be verified + against the matching upstream mimalloc release. + +Files: target/i386/latx/context/* + target/i386/latx/include/box64context.h + target/i386/latx/include/bridge*.h + target/i386/latx/include/callback.h + target/i386/latx/include/dictionnary.h + target/i386/latx/include/elfload_dump.h + target/i386/latx/include/elfloader*.h + target/i386/latx/include/fileutils.h + target/i386/latx/include/globalsymbols.h + target/i386/latx/include/gltools.h + target/i386/latx/include/gtkclass.h + target/i386/latx/include/librarian*.h + target/i386/latx/include/library*.h + target/i386/latx/include/myalign.h + target/i386/latx/include/pathcoll.h + target/i386/latx/include/sdl2rwops.h + target/i386/latx/include/symbols.h + target/i386/latx/include/wrapped* + target/i386/latx/include/wrapper*.h + target/i386/latx/include/generated/wrapped* +Source: https://github.com/ptitSeb/box64 +Copyright: + Copyright (c) 2020 ptitSeb + Copyright (c) Box64 contributors +License: MIT +Comment: + The LATX library pass-through implementation borrows ideas from and + references portions of the box64 project. Local files may contain LATX + modifications while retaining third-party attribution and the MIT + license notice in this NOTICE file. + +License: MIT + 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. diff --git a/README.en.rst b/README.en.rst index 62c9a7ed298..eb4384c0fb5 100644 --- a/README.en.rst +++ b/README.en.rst @@ -190,6 +190,11 @@ STEP2: oma install -y gcc nettle pcre2 libffi gnutls glib zlib glib-static libgcrypt-static libgpg-error-static libnfs-static pcre-static zlib-static zstd-static openssl-static pkg-config ninja +- Fedora + +.. code-block:: bash + + dnf install gcc g++ make git ninja-build meson openssl-devel glib2-devel STEP3: diff --git a/README.rst b/README.rst index 5b152f8f8bf..99e42c87343 100644 --- a/README.rst +++ b/README.rst @@ -179,6 +179,12 @@ STEP2: oma install -y gcc nettle pcre2 libffi gnutls glib zlib glib-static libgcrypt-static libgpg-error-static libnfs-static pcre-static zlib-static zstd-static openssl-static pkg-config ninja +- Fedora + +.. code-block:: bash + + dnf install gcc g++ make git ninja-build meson openssl-devel glib2-devel + STEP3: diff --git a/docs/devel/index.rst b/docs/devel/index.rst index 6cf7e2d2330..3e449280e51 100644 --- a/docs/devel/index.rst +++ b/docs/devel/index.rst @@ -30,6 +30,8 @@ Contents: qtest decodetree secure-coding-practices + kzt-loader-refactor + kzt-loader-refactor-zh tcg tcg-icount tracing diff --git a/docs/devel/kzt-loader-refactor-zh.rst b/docs/devel/kzt-loader-refactor-zh.rst new file mode 100644 index 00000000000..47cf783bdd9 --- /dev/null +++ b/docs/devel/kzt-loader-refactor-zh.rst @@ -0,0 +1,195 @@ +KZT Loader 重构计划 +=================== + +目标 +---- + +KZT loader 重构是一组分阶段设计调整，目标是重新划分 LATX 如何观察 guest +ELF 对象，以及如何决定 guest GOT 槽位是否应重定向到 native wrapper +bridge。 + +现有 loader 路径可以工作，但多个职责混在少数路径里： + +* 观察 guest loader 事件； +* 从宿主侧状态重建 guest 对象身份； +* 加载 wrapper 依赖； +* 通过 ``maplib`` 解析符号； +* 决定 GOT 槽位是否需要 patch； +* 立即写 GOT 或通过 lazy binding 写 GOT。 + +这种结构使代码难以推理，也让正确性依赖于宿主侧对 guest loader 决策的 +重新构造。尤其是在 wrapper 选择上，宿主侧全局符号搜索可能与当前 guest +GOT 值所代表的最终 owner 不一致。 + +重构的方向是把这些职责拆开，并逐步落实一个原则：guest loader 状态应作为 +guest 对象身份的权威来源；宿主侧 wrapper 状态只用于寻找 native bridge +目标。 + +为什么需要重构 +-------------- + +旧路径存在几个结构性问题。 + +Guest 对象身份是隐式的 +~~~~~~~~~~~~~~~~~~~~~~ + +很多决策都依赖“某个地址属于哪个 guest 对象”，但旧路径经常通过 +``elfheader_t``、``maplib`` 结果或重复的全局符号查找间接推断这个身份。 +这样很难判断 GOT 当前值是否真的指向 guest loader 最终选择的对象。 + +符号解析重复发生在错误层次 +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +guest loader 已经完成依赖和符号绑定。LATX 再通过全局 ``maplib`` 搜索重复 +这件事，可能会选到另一个 owner。对于库直通和 wrapper 选择来说，这会带来 +跨对象 mismatch 风险。 + +Patch 决策不是一等数据 +~~~~~~~~~~~~~~~~~~~~~~ + +历史上 relocation 代码解析到目标后直接写 GOT。这样很难观察为什么写了某个 +槽位、旧目标属于谁、选择了哪个 wrapper、为什么某个槽位没有 patch。 + +Loader 同步过度集中 +~~~~~~~~~~~~~~~~~~~ + +glibc 私有 hook 当前承担了太多职责。即使最终仍需要一个小 hook，它也应该只 +发布 loader 事件；对象跟踪、dynamic 解析、符号对比和 patch planning 应该 +由独立模块承担。 + +可行性 +------ + +这个重构可行，是因为 guest 进程运行时已经暴露了足够的信息来建立更清晰的 +边界： + +* ``link_map`` 提供对象名、加载地址和 Dynamic Table 指针； +* ``l_ld`` 指向内存中的 Dynamic Table，可以不依赖 Section Header 解析 + symbol、relocation 和 version 信息； +* 已有 GOT 值可以通过 guest 对象加载范围反查所属对象； +* wrapper library 仍可用于查询 native bridge 地址； +* 旧 ``maplib`` 路径可以在每个新边界验证稳定前继续作为 fallback。 + +工程上的关键选择是避免一次性重写。每个阶段只引入一个明确边界，并保留旧 +行为作为 fallback，直到替代路径具备足够的可观察性。 + +设计原则 +-------- + +分阶段设计遵循以下原则： + +* guest 对象身份只记录一次，并通过显式 API 传递； +* 从 guest 内存解析 loader 数据，而不是重新打开 guest ELF 文件； +* 每次 GOT patch 先形成决策，再写槽位； +* wrapper 选择优先参考 guest loader 已经选出的最终 owner； +* 新路径稳定前保留 ``maplib`` fallback； +* lazy binding 与普通 relocation 清理分开处理； +* 模块边界稳定后，将 glibc hook 降级为事件源。 + +阶段划分 +-------- + +阶段 1：Guest object registry +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +引入 ``GuestObjectRegistry``，记录 loader callback 观察到的 guest 对象。 +Registry 负责对象身份：名称、基址、加载范围和 Dynamic Table 地址。 + +callback 只注册对象信息，然后进入旧兼容路径。这样可以先建立对象身份层， +而不改变 loader 对外行为。 + +阶段 2：内存 Dynamic Parser +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +从 ``l_ld`` 解析 guest Dynamic Table。parser 需要构建 symbol、relocation、 +version index、version need、version definition 和 string table 的视图。 + +初期内存 parser 与旧文件 parser 并行运行。差异应在测试中断言，或在运行时 +比较路径中记录。只有比较稳定后，才删除旧的 ``fopen()`` 和 Section Header +依赖。 + +阶段 3：Patch Planner +~~~~~~~~~~~~~~~~~~~~~ + +为每一次 GOT 修改引入 planner record。一个 patch decision 应包含： + +* guest object； +* relocation 地址和类型； +* symbol 名称和 version； +* 旧 GOT target； +* old owner 和 old guest object； +* ``maplib`` bridge 和 owner； +* 可用时的 guest-owner bridge 和 owner； +* 最终选择的 target source； +* decision reason。 + +这个阶段不必改变 target 选择。它的主要价值是让现有行为可观察、可测试。 + +阶段 4：Guest-owner target selection +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +使用当前 guest GOT 值识别已解析目标所属的 guest 对象，再通过该对象的 +wrapper library 解析同一 symbol。 + +安全规则是： + +* guest-owner probe 成功时，可以替代该槽位的重复全局 ``maplib`` 解析； +* guest-owner probe 失败时，继续使用原有 ``maplib`` fallback。 + +这个阶段先覆盖普通 relocation 路径。lazy binding 单独放到后续阶段。 + +阶段 5：移除普通 guest 依赖旁路加载 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +停止通过 wrapper 路径递归 ``LoadNeededLibs()`` 普通 x86 guest 依赖。宿主侧 +加载应只保留 native wrapper 自身依赖，或者在适合时交给宿主 ``dlopen()``。 + +这个阶段依赖前四个阶段，因为在删除旁路加载前，guest 对象身份和 patch 目标 +决策必须已经显式化。 + +阶段 6：简化 lazy binding +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +尽量让 guest loader 先完成 lazy binding，然后在 guest 绑定结果可见后再 +patch 槽位。 + +如果仍必须支持首次调用即时替换，也应放在独立模块中，而不是继续往通用 +relocation 代码里塞策略。 + +阶段 7：重构 dlopen/dlsym/dlclose +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +让 guest loader handle 成为权威结果。删除合成 handle、重复引用计数和绕过 +guest loader 状态的 reload 路径。 + +阶段 8：替换 glibc 私有 hook 的职责 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +前面模块边界稳定后，再减少或替换 glibc 私有 hook。可选事件来源包括 +``r_debug`` 通知、RELRO ``mprotect``、QEMU mmap/loader 事件，或极小且版本 +隔离的 fallback hook。 + +即使最终仍保留 hook，它也只应发布事件，不应承担 guest 对象解析、依赖加载 +或 GOT patch planning。 + +补丁组织建议 +------------ + +可审阅的实现补丁应按设计边界分组，而不是按机械 helper 拆分。建议组织为： + +1. 文档和路线图； +2. Guest object registry； +3. 内存 Dynamic Parser 与双轨比较； +4. Patch planner records 与 GOT 写入路由； +5. Guest-owner target comparison； +6. Guest-owner target selection。 + +每个补丁的 commit body 应说明： + +* 属于哪个阶段； +* 保留了哪个旧行为作为 fallback； +* 引入了什么新的边界或数据模型； +* 该阶段预期如何验证。 + +进度报告、最新 CTS 数字和临时 rollout 说明不应放进这份设计文档，因为它们会 +随着补丁推进而变化。 diff --git a/docs/devel/kzt-loader-refactor.rst b/docs/devel/kzt-loader-refactor.rst new file mode 100644 index 00000000000..d2bbe83c937 --- /dev/null +++ b/docs/devel/kzt-loader-refactor.rst @@ -0,0 +1,221 @@ +KZT Loader Refactor Plan +======================== + +Purpose +------- + +The KZT loader refactor is a staged redesign of how LATX observes guest ELF +objects and decides whether guest GOT entries should be redirected to native +wrapper bridges. + +The existing loader path works, but it mixes several responsibilities in a +small number of places: + +* observing guest loader events; +* rebuilding object identity from host-side state; +* loading wrapper dependencies; +* resolving symbols through ``maplib``; +* deciding whether a GOT slot should be patched; +* applying the GOT write immediately or through lazy binding. + +That makes the code hard to reason about. It also makes correctness depend on +host-side reconstruction of guest loader decisions, including global symbol +searches and dependency expansion that may not match the guest loader's final +result. + +The refactor separates those responsibilities and moves the design toward one +rule: guest loader state should be the authoritative source for guest object +identity, while host-side wrapper state should only be used to find native +bridge targets. + +Why This Refactor Is Needed +--------------------------- + +The old path has several structural problems. + +Guest object identity is implicit +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Many decisions depend on knowing which guest object owns an address, but the +old loader path often derives that identity indirectly from ``elfheader_t``, +``maplib`` results, or repeated global symbol lookups. This makes it hard to +tell whether a GOT value points into the object the guest loader actually +selected. + +Symbol resolution is repeated in the wrong layer +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The guest loader already resolves dependencies and symbol bindings. Repeating +that work through LATX global ``maplib`` search can select a different owner +from the one represented by the current guest GOT value. The result is a +cross-object mismatch risk that is especially visible for wrapper selection. + +Patch decisions are not first-class data +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Historically, relocation code directly wrote GOT slots after resolving a +target. That makes it difficult to inspect why a slot was patched, which +object owned the old target, which wrapper was selected, or why a patch was +skipped. + +Loader synchronization is too centralized +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The private glibc hook currently carries too much responsibility. Even if a +small hook remains necessary, it should only publish loader events. Object +tracking, dynamic parsing, symbol comparison, and patch planning should live in +separate modules. + +Feasibility +----------- + +The redesign is feasible because the guest process already exposes enough +runtime information to build safer boundaries: + +* ``link_map`` records provide object names, load addresses, and dynamic table + pointers. +* ``l_ld`` points to the in-memory Dynamic Table, so symbol, relocation, and + version information can be parsed without relying on ELF section headers. +* Existing GOT values can be mapped back to guest object load ranges. +* Wrapper libraries can still be queried for native bridge addresses. +* The old ``maplib`` path can remain as a fallback while each new boundary is + validated. + +The key engineering choice is to avoid a flag-day rewrite. Each stage adds a +new explicit boundary while preserving the old behavior until the replacement +has enough observability. + +Design Principles +----------------- + +The staged design follows these principles: + +* Record guest object identity once and pass it through explicit APIs. +* Parse guest loader data from memory instead of reopening guest ELF files. +* Represent every GOT patch as a decision before writing the slot. +* Prefer the guest-selected final owner when choosing a wrapper target. +* Keep ``maplib`` fallback paths until the new path has been compared in + realistic workloads. +* Keep lazy binding separate from normal relocation cleanup. +* Reduce the glibc hook to an event source after module boundaries are stable. + +Stages +------ + +Stage 1: Guest object registry +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Introduce a ``GuestObjectRegistry`` that records guest objects observed from +loader callbacks. The registry owns object identity: name, base address, load +range, and dynamic table address. + +The callback should only register object information and then call the legacy +compatibility path. This establishes a clean identity layer without changing +the loader's external behavior. + +Stage 2: In-memory dynamic parser +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Parse the guest Dynamic Table from ``l_ld``. The parser should build a view +of symbols, relocations, version indices, version needs, version definitions, +and string-table entries. + +Initially, the in-memory parser should run in parallel with the legacy +file-based parser. Differences should be asserted in tests or logged in +runtime comparison paths. Only after the comparison is stable should the old +``fopen()`` and section-header dependency be removed. + +Stage 3: Patch planner +~~~~~~~~~~~~~~~~~~~~~~ + +Introduce a planner record for every GOT modification. A patch decision should +include: + +* the guest object; +* relocation address and relocation type; +* symbol name and version; +* old GOT target; +* old owner and old guest object; +* ``maplib`` bridge and owner; +* guest-owner bridge and owner, if available; +* selected target source; +* decision reason. + +At this stage, the planner does not need to change target selection. Its main +job is to make the existing behavior observable and testable. + +Stage 4: Guest-owner target selection +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Use the current guest GOT value to identify the guest object that owns the +resolved target. Then resolve the same symbol through that object's wrapper +library. + +The safe rule is: + +* if the guest-owner probe succeeds, it may replace repeated global + ``maplib`` resolution for that slot; +* if the probe fails, the existing ``maplib`` fallback remains authoritative. + +This stage should cover normal relocation paths first. Lazy binding remains a +separate stage. + +Stage 5: Remove ordinary guest dependency side loading +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Stop using ``LoadNeededLibs()`` to recursively load ordinary x86 guest +dependencies through the wrapper path. Host-side loading should be limited to +native wrapper dependencies, or delegated to host ``dlopen()`` when suitable. + +This stage depends on stages 1 through 4 because guest object identity and +patch target decisions must already be explicit before removing the side path. + +Stage 6: Simplify lazy binding +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Let the guest loader perform lazy binding first where possible, then patch the +slot after the guest binding result is visible. + +If a first-call immediate replacement path is still required, it should be a +dedicated module rather than extra policy inside generic relocation code. + +Stage 7: Refactor dlopen/dlsym/dlclose +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Make guest loader handles authoritative. Remove synthetic handle behavior, +duplicate reference counting, and reload paths that bypass the guest loader's +state. + +Stage 8: Replace private glibc hook responsibilities +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +After the previous boundaries are stable, reduce or replace the private glibc +hook. Possible event sources include ``r_debug`` notifications, RELRO +``mprotect`` transitions, QEMU mmap/loader events, or a small version-isolated +fallback hook. + +Even if a hook remains, it should publish events only. It should not own guest +object parsing, dependency loading, or GOT patch planning. + +Patch Series Organization +------------------------- + +A reviewable implementation series should be grouped by design boundary rather +than by mechanical helper extraction. The recommended grouping is: + +1. Documentation and roadmap. +2. Guest object registry. +3. In-memory dynamic parser and dual-track comparison. +4. Patch planner records and GOT write routing. +5. Guest-owner target comparison. +6. Guest-owner target selection. + +Each patch should contain a commit body explaining: + +* which stage it belongs to; +* which old behavior is preserved as fallback; +* what new boundary or data model is introduced; +* what validation is expected for that stage. + +Progress reports, latest CTS numbers, and temporary rollout notes should be +kept outside this design document because they change as the series evolves. diff --git a/include/exec/fasttb.h b/include/exec/fasttb.h index 1fef20fbe2f..b10e2717659 100644 --- a/include/exec/fasttb.h +++ b/include/exec/fasttb.h @@ -1,5 +1,8 @@ #ifndef FASTTB_H #define FASTTB_H + +#define FASTTB_INVALID_PC ((unsigned long)-1) + struct FastTB { unsigned long pc; const void *ptr; /* pointer to the translated code */ diff --git a/include/hw/rtc/sun4v-rtc.h b/include/hw/rtc/sun4v-rtc.h deleted file mode 100644 index fd868f6ed2f..00000000000 --- a/include/hw/rtc/sun4v-rtc.h +++ /dev/null @@ -1,19 +0,0 @@ -/* - * QEMU sun4v Real Time Clock device - * - * The sun4v_rtc device (sun4v tod clock) - * - * Copyright (c) 2016 Artyom Tarasenko - * - * This code is licensed under the GNU GPL v3 or (at your option) any later - * version. - */ - -#ifndef HW_RTC_SUN4V -#define HW_RTC_SUN4V - -#include "exec/hwaddr.h" - -void sun4v_rtc_init(hwaddr addr); - -#endif diff --git a/linux-user/main.c b/linux-user/main.c index e397b76516d..e3543c509a3 100644 --- a/linux-user/main.c +++ b/linux-user/main.c @@ -635,6 +635,16 @@ static void handle_arg_latx_kzt(const char *arg) { option_kzt = strtol(arg, NULL, 0); } + +static void handle_arg_latx_kzt_patch_guest_owner(const char *arg) +{ + option_kzt_patch_guest_owner = strtol(arg, NULL, 0); +} + +static void handle_arg_latx_kzt_patch_shadow(const char *arg) +{ + option_kzt_patch_shadow = strtol(arg, NULL, 0); +} #endif static void handle_arg_latx_fputag(const char *arg) @@ -818,6 +828,10 @@ static const struct qemu_argument arg_table[] = { #if defined(CONFIG_LATX_KZT) {"latx-kzt", "LATX_KZT", true, handle_arg_latx_kzt, "", "enable kuzhitong"}, + {"latx-kzt-patch-guest-owner", "LATX_KZT_PATCH_GUEST_OWNER", true, handle_arg_latx_kzt_patch_guest_owner, + "", "enable kzt guest owner patch target selection"}, + {"latx-kzt-patch-shadow", "LATX_KZT_PATCH_SHADOW", true, handle_arg_latx_kzt_patch_shadow, + "", "enable kzt patch planner shadow comparison"}, #endif {"latx-fputag", "LATX_FPUTAG", true, handle_arg_latx_fputag, "", "enable fputag"}, diff --git a/target/i386/latx/context/box64context.c b/target/i386/latx/context/box64context.c index bd80cc0b4cc..9da64987279 100755 --- a/target/i386/latx/context/box64context.c +++ b/target/i386/latx/context/box64context.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include @@ -8,6 +16,7 @@ #include "debug.h" #include "elfloader.h" #include "bridge.h" +#include "guestobject.h" #include "librarian.h" #include "library.h" #include "wrapper.h" @@ -26,6 +35,9 @@ box64context_t *NewBox64Context(int argc) context->versym = NewDictionnary(); context->system = NewBridge(); context->dlprivate = NewDLPrivate(); + context->guest_objects = NewGuestObjectRegistry(); + if (!context->guest_objects) + printf_log(LOG_INFO, "Warning: guest object registry is unavailable\n"); context->box64lib = dlopen(NULL, RTLD_NOW|RTLD_GLOBAL); context->argc = argc; context->argv = (char**)box_calloc(context->argc+1, sizeof(char*)); @@ -55,6 +67,7 @@ void FreeBox64Context(box64context_t** context) FreeElfHeader(&ctx->elfs[i]); } box_free(ctx->elfs); + FreeGuestObjectRegistry(&ctx->guest_objects); FreeCollection(&ctx->box64_path); FreeCollection(&ctx->box64_ld_lib); diff --git a/target/i386/latx/context/bridge.c b/target/i386/latx/context/bridge.c index 7948d7a018d..6083f9d3575 100755 --- a/target/i386/latx/context/bridge.c +++ b/target/i386/latx/context/bridge.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/callback.c b/target/i386/latx/context/callback.c index ba6422852ba..8363846a844 100644 --- a/target/i386/latx/context/callback.c +++ b/target/i386/latx/context/callback.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include "callback.h" #include "lsenv.h" diff --git a/target/i386/latx/context/dictionnary.c b/target/i386/latx/context/dictionnary.c index e6bb38577a5..d52723016c7 100755 --- a/target/i386/latx/context/dictionnary.c +++ b/target/i386/latx/context/dictionnary.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include diff --git a/target/i386/latx/context/elfload_dump.c b/target/i386/latx/context/elfload_dump.c index b8cd91a5e81..e86c4aa58ac 100755 --- a/target/i386/latx/context/elfload_dump.c +++ b/target/i386/latx/context/elfload_dump.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/elfloader.c b/target/i386/latx/context/elfloader.c index 1e63d665f46..94010d345c6 100755 --- a/target/i386/latx/context/elfloader.c +++ b/target/i386/latx/context/elfloader.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include @@ -16,12 +24,15 @@ #include "elfloader_private.h" #include "librarian.h" #include "bridge.h" -#include "wrapper.h" #include "box64context.h" #include "library.h" #include "library_private.h" #include "dictionnary.h" #include "symbols.h" +#include "guestlazy.h" +#include "guestobject.h" +#include "guestpatch.h" +#include "latx-options.h" #include "lsenv.h" void* my__IO_2_1_stderr_ = NULL; @@ -152,8 +163,10 @@ uintptr_t loadSoaddrFromMap(char * real_path) void ElfHeadReFix (elfheader_t* head, uintptr_t delta) { head->latx_hasfix = 1; - lsassert(delta); head->delta = delta; + if (!delta) { + return; + } #define GO(a) if ((uintptr_t)head->a > 0) { \ if ((uintptr_t)head->a > (uintptr_t)head->delta) { \ head->delta = 0; \ @@ -626,6 +639,702 @@ static int FindR64COPYRel(elfheader_t* h, const char* name, uintptr_t *offs, uin } */ +static void kzt_patch_fill_owner(lib_t *maplib, uintptr_t target, + const char **owner, + uintptr_t *owner_base) +{ + const char *name = NULL; + void *base = NULL; + + *owner = NULL; + *owner_base = 0; + + if (!maplib || !target) + return; + + FindSymbolName(maplib, (void *)target, NULL, NULL, &name, &base, NULL); + *owner = name; + *owner_base = (uintptr_t)base; +} + +static void kzt_patch_fill_guest_object(uintptr_t target, + const char **guest_object, + uintptr_t *guest_object_base) +{ + elfheader_t *owner = NULL; + + *guest_object = NULL; + *guest_object_base = 0; + + if (!my_context || !target) + return; + + guest_object_lookup_t lookup; + if (!LookupGuestObjectByAddress(my_context->guest_objects, target, + &lookup)) { + *guest_object = lookup.name; + *guest_object_base = lookup.load_bias; + return; + } + + owner = FindElfAddress(my_context, target); + if (!owner) + return; + + *guest_object = ElfName(owner); + *guest_object_base = owner->delta; +} + +static const char *kzt_patch_basename(const char *name) +{ + const char *base; + + if (!name) + return NULL; + + base = strrchr(name, '/'); + return base ? base + 1 : name; +} + +static int kzt_patch_same_basename(const char *left, const char *right) +{ + const char *left_name = kzt_patch_basename(left); + const char *right_name = kzt_patch_basename(right); + + return left_name && right_name && strcmp(left_name, right_name) == 0; +} + +static int kzt_patch_is_self_plt_target(const KztPatchDecision *decision) +{ + return decision->relocation_type == R_X86_64_JUMP_SLOT + && kzt_patch_same_basename(decision->old_guest_object, + decision->object); +} + +typedef struct KztPatchGuestOwnerCandidate { + int valid; + uintptr_t bridge; + const char *library; + const char *owner; + uintptr_t owner_base; +} KztPatchGuestOwnerCandidate; + +static KztPatchGuestOwnerCandidate kzt_patch_guest_owner_candidate_init(void) +{ + KztPatchGuestOwnerCandidate candidate = { + .valid = 0, + .bridge = 0, + .library = NULL, + .owner = NULL, + .owner_base = 0, + }; + + return candidate; +} + +typedef struct KztPatchGuestOwnerProbe { + int probed; + KztPatchShadowResult failure; + KztPatchGuestOwnerCandidate candidate; +} KztPatchGuestOwnerProbe; + +static KztPatchGuestOwnerProbe kzt_patch_guest_owner_probe_init(void) +{ + KztPatchGuestOwnerProbe probe = { + .probed = 0, + .failure = KZT_PATCH_SHADOW_DISABLED, + .candidate = kzt_patch_guest_owner_candidate_init(), + }; + + return probe; +} + +static int kzt_patch_guest_owner_probe_has_target( + const KztPatchGuestOwnerProbe *probe) +{ + return probe->candidate.valid; +} + +typedef struct KztPatchTargetResolution { + lib_t *owner; + uintptr_t start; + uintptr_t end; + KztPatchDecisionReason unresolved_reason; + KztPatchGuestOwnerProbe guest_owner_probe; +} KztPatchTargetResolution; + +static KztPatchTargetResolution kzt_patch_target_resolution_init( + lib_t *owner) +{ + KztPatchTargetResolution resolution = { + .owner = owner, + .start = 0, + .end = 0, + .unresolved_reason = KZT_PATCH_REASON_SYMBOL_MISSING, + .guest_owner_probe = kzt_patch_guest_owner_probe_init(), + }; + + return resolution; +} + +static int kzt_patch_target_resolution_has_target( + const KztPatchTargetResolution *resolution) +{ + return resolution->start || resolution->end; +} + +static int kzt_patch_target_resolution_has_bridge( + const KztPatchTargetResolution *resolution) +{ + return resolution->start != 0; +} + +static uintptr_t kzt_patch_target_resolution_bridge( + const KztPatchTargetResolution *resolution, + uintptr_t addend) +{ + return resolution->start + addend; +} + +static KztPatchGuestOwnerProbe kzt_patch_probe_guest_owner_target( + const KztPatchDecision *decision) +{ + const char *guest_owner_name; + KztPatchTargetResolution target = + kzt_patch_target_resolution_init(my_context ? my_context->maplib + : NULL); + KztPatchGuestOwnerProbe probe = kzt_patch_guest_owner_probe_init(); + + probe.probed = 1; + + if (!decision->old_guest_object) { + probe.failure = KZT_PATCH_SHADOW_NO_GUEST_OWNER; + return probe; + } + if (!decision->symbol || !decision->symbol[0]) { + probe.failure = KZT_PATCH_SHADOW_SYMBOL_MISSING; + return probe; + } + if (kzt_patch_is_self_plt_target(decision)) { + probe.failure = KZT_PATCH_SHADOW_SELF_PLT; + return probe; + } + + guest_owner_name = kzt_patch_basename(decision->old_guest_object); + library_t *guest_owner = GetLibInternal(decision->old_guest_object); + if (!guest_owner) { + if (guest_owner_name != decision->old_guest_object) + guest_owner = GetLibInternal(guest_owner_name); + } + if (!guest_owner) { + probe.failure = FindLibIsWrapped((char *)guest_owner_name) + ? KZT_PATCH_SHADOW_NO_LIBRARY + : KZT_PATCH_SHADOW_NO_WRAPPER; + return probe; + } + + if (!GetLibSymbolStartEnd(guest_owner, decision->symbol, 0, + &target.start, + &target.end, + decision->symbol_version, + decision->symbol_version_name, 0)) { + probe.failure = KZT_PATCH_SHADOW_SYMBOL_MISSING; + return probe; + } + + probe.candidate.valid = 1; + probe.candidate.bridge = kzt_patch_target_resolution_bridge(&target, 0); + probe.candidate.library = GetNameLib(guest_owner); + kzt_patch_fill_owner(my_context->maplib, target.start, + &probe.candidate.owner, + &probe.candidate.owner_base); + + return probe; +} + +/* + * Guest-owner data is applied as an optional overlay on top of maplib + * resolution. A successful probe may replace the selected bridge; a failed + * probe is still useful because the planner can log why maplib fallback was + * kept. + */ +static void kzt_patch_decision_set_guest_owner_candidate( + KztPatchDecision *decision, + const KztPatchGuestOwnerCandidate *candidate, + int select_target) +{ + KztPatchDecisionSetGuestOwnerTarget( + decision, candidate->bridge, candidate->library, candidate->owner, + candidate->owner_base, select_target); +} + +static void kzt_patch_target_resolution_set_guest_owner_probe( + KztPatchTargetResolution *target, + const KztPatchGuestOwnerProbe *probe) +{ + target->guest_owner_probe = *probe; +} + +static int kzt_patch_should_plan_guest_owner_target(void) +{ + return option_kzt_patch_shadow || option_kzt_patch_guest_owner; +} + +static int kzt_patch_should_select_guest_owner_target( + const KztPatchDecision *decision, + const char *guest_owner) +{ + (void)decision; + (void)guest_owner; + return option_kzt_patch_guest_owner; +} + +static int kzt_patch_decision_apply_guest_owner_probe( + KztPatchDecision *decision, + const KztPatchGuestOwnerProbe *probe) +{ + if (kzt_patch_guest_owner_probe_has_target(probe)) { + kzt_patch_decision_set_guest_owner_candidate( + decision, &probe->candidate, + kzt_patch_should_select_guest_owner_target( + decision, probe->candidate.owner)); + return 1; + } + + if (probe->probed) { + KztPatchDecisionSetGuestOwnerFailure(decision, probe->failure); + return 1; + } + + return 0; +} + +static int kzt_patch_should_try_guest_owner_without_maplib( + int bind, + int relocation_type) +{ + if (bind == STB_LOCAL) + return 0; + if (!option_kzt_patch_guest_owner) + return 0; + + switch (relocation_type) { + case R_X86_64_GLOB_DAT: + case R_X86_64_JUMP_SLOT: + return 1; + } + return 0; +} + +static void kzt_patch_plan_guest_owner_target(KztPatchDecision *decision) +{ + KztPatchGuestOwnerProbe probe; + + if (!kzt_patch_should_plan_guest_owner_target()) + return; + + probe = kzt_patch_probe_guest_owner_target(decision); + kzt_patch_decision_apply_guest_owner_probe(decision, &probe); +} + +static KztPatchTargetResolution kzt_resolve_global_symbol_for_patch( + lib_t *maplib, lib_t *local_maplib, const char *symbol, + elfheader_t *self, int version, const char *version_name) +{ + KztPatchTargetResolution resolution = + kzt_patch_target_resolution_init(maplib); + + GetGlobalSymbolStartEnd(maplib, symbol, &resolution.start, + &resolution.end, self, version, version_name); + if (kzt_patch_target_resolution_has_target(&resolution) || !local_maplib) + return resolution; + + GetGlobalSymbolStartEnd(local_maplib, symbol, &resolution.start, + &resolution.end, self, version, version_name); + if (kzt_patch_target_resolution_has_target(&resolution)) + resolution.owner = local_maplib; + + return resolution; +} + +static KztPatchDecision kzt_make_guest_owner_probe_decision( + elfheader_t *head, int relocation_type, const char *symbol, int version, + const char *version_name, uintptr_t old_target) +{ + KztPatchDecision decision; + + KztPatchDecisionInit(&decision); + decision.object = head ? ElfName(head) : NULL; + decision.relocation_type = relocation_type; + decision.symbol = symbol; + decision.symbol_version = version; + decision.symbol_version_name = version_name; + kzt_patch_fill_guest_object(old_target, &decision.old_guest_object, + &decision.old_guest_object_base); + + return decision; +} + +/* + * This is the Phase 4 fast path: use the current GOT value to find the guest + * object that the guest loader already selected, then ask that object's wrapper + * for the native bridge. maplib is skipped only when the probe returns a + * concrete target. + */ +static KztPatchTargetResolution kzt_resolve_relocation_symbol_for_patch( + lib_t *maplib, lib_t *local_maplib, elfheader_t *head, + const Elf64_Sym *sym, const char *symbol, int bind, int relocation_type, + uintptr_t old_target, int version, const char *version_name) +{ + KztPatchTargetResolution resolution = + kzt_patch_target_resolution_init(maplib); + KztPatchTargetResolution maplib_resolution; + + if (bind == STB_LOCAL) { + resolution.start = sym->st_value + head->delta; + resolution.end = resolution.start + sym->st_size; + return resolution; + } + + if (kzt_patch_should_try_guest_owner_without_maplib(bind, + relocation_type)) { + KztPatchDecision decision; + KztPatchGuestOwnerProbe guest_probe; + + decision = kzt_make_guest_owner_probe_decision( + head, relocation_type, symbol, version, version_name, old_target); + guest_probe = kzt_patch_probe_guest_owner_target(&decision); + kzt_patch_target_resolution_set_guest_owner_probe( + &resolution, &guest_probe); + if (kzt_patch_guest_owner_probe_has_target(&guest_probe)) { + resolution.unresolved_reason = + KZT_PATCH_REASON_GUEST_OWNER_TARGET; + return resolution; + } + } + + maplib_resolution = kzt_resolve_global_symbol_for_patch( + maplib, local_maplib, symbol, head, version, version_name); + + if (resolution.guest_owner_probe.probed) + kzt_patch_target_resolution_set_guest_owner_probe( + &maplib_resolution, &resolution.guest_owner_probe); + + return maplib_resolution; +} + +static KztPatchTargetResolution kzt_resolve_plt_symbol_for_patch( + lib_t *maplib, lib_t *local_maplib, elfheader_t *head, + const char *symbol, int version, const char *version_name) +{ + KztPatchTargetResolution resolution = + kzt_resolve_global_symbol_for_patch( + maplib, local_maplib, symbol, head, version, version_name); + + if (!kzt_patch_target_resolution_has_target(&resolution) && !version) { + resolution = kzt_resolve_global_symbol_for_patch( + maplib, NULL, symbol, head, -1, NULL); + } + + return resolution; +} + +static KztPatchDecision kzt_make_base_patch_decision(lib_t *old_owner_maplib, + elfheader_t *head, + const Elf64_Rela *rela, + size_t relocation_index, + int relocation_type, + const char *symbol, + int version, + const char *version_name, + uintptr_t slot, + uintptr_t old_target, + KztPatchDecisionReason reason) +{ + KztPatchDecision decision; + + KztPatchDecisionInit(&decision); + decision.object = head ? ElfName(head) : NULL; + decision.object_base = head ? head->delta : 0; + decision.relocation = rela; + decision.relocation_index = relocation_index; + decision.relocation_type = relocation_type; + decision.symbol = symbol; + decision.symbol_version = version; + decision.symbol_version_name = version_name; + decision.slot = slot; + decision.old_target = old_target; + decision.reason = reason; + + kzt_patch_fill_owner(old_owner_maplib, old_target, &decision.old_owner, + &decision.old_owner_base); + kzt_patch_fill_guest_object(old_target, &decision.old_guest_object, + &decision.old_guest_object_base); + + return decision; +} + +static void kzt_patch_decision_set_maplib_resolution( + KztPatchDecision *decision, + KztPatchTargetResolution resolution, + uintptr_t maplib_bridge) +{ + const char *maplib_owner = NULL; + uintptr_t maplib_owner_base = 0; + + kzt_patch_fill_owner(resolution.owner, maplib_bridge, &maplib_owner, + &maplib_owner_base); + KztPatchDecisionSetMaplibTarget(decision, maplib_bridge, maplib_owner, + maplib_owner_base); + if (!kzt_patch_decision_apply_guest_owner_probe( + decision, &resolution.guest_owner_probe)) + kzt_patch_plan_guest_owner_target(decision); +} + +static KztPatchDecision kzt_make_patch_decision(lib_t *old_owner_maplib, + lib_t *new_owner_maplib, + elfheader_t *head, + const Elf64_Rela *rela, + size_t relocation_index, + int relocation_type, + const char *symbol, + int version, + const char *version_name, + uintptr_t slot, + uintptr_t old_target, + uintptr_t new_target, + KztPatchDecisionReason reason) +{ + KztPatchDecision decision = kzt_make_base_patch_decision( + old_owner_maplib, head, rela, relocation_index, relocation_type, + symbol, version, version_name, slot, old_target, reason); + KztPatchTargetResolution resolution = + kzt_patch_target_resolution_init(new_owner_maplib); + + kzt_patch_decision_set_maplib_resolution(&decision, resolution, + new_target); + + return decision; +} + +static KztPatchDecision kzt_make_patch_decision_from_resolution( + lib_t *old_owner_maplib, + KztPatchTargetResolution resolution, + elfheader_t *head, + const Elf64_Rela *rela, + size_t relocation_index, + int relocation_type, + const char *symbol, + int version, + const char *version_name, + uintptr_t slot, + uintptr_t old_target, + uintptr_t maplib_bridge, + KztPatchDecisionReason reason) +{ + KztPatchDecision decision = kzt_make_base_patch_decision( + old_owner_maplib, head, rela, relocation_index, relocation_type, + symbol, version, version_name, slot, old_target, reason); + + kzt_patch_decision_set_maplib_resolution(&decision, resolution, + maplib_bridge); + + return decision; +} + +static void kzt_emit_patch_decision(const KztPatchDecision *decision) +{ + char buffer[2048]; + + if (!decision) + return; + + KztFormatPatchDecision(buffer, sizeof(buffer), decision); + printf_log((option_kzt_patch_shadow || option_kzt_patch_guest_owner) + ? LOG_NONE + : LOG_DEBUG, + "KZT patch planner: %s\n", buffer); +} + +static void kzt_apply_patch_decision(const KztPatchDecision *decision) +{ + kzt_emit_patch_decision(decision); + *(uintptr_t *)decision->slot = decision->new_bridge; +} + +static void kzt_apply_or_log_patch_resolution( + lib_t *old_owner_maplib, + KztPatchTargetResolution resolution, + elfheader_t *head, + const Elf64_Rela *rela, + size_t relocation_index, + int relocation_type, + const char *symbol, + int version, + const char *version_name, + uintptr_t slot, + uintptr_t old_target, + uintptr_t maplib_bridge, + KztPatchDecisionReason reason) +{ + KztPatchDecision decision = kzt_make_patch_decision_from_resolution( + old_owner_maplib, resolution, head, rela, relocation_index, + relocation_type, symbol, version, version_name, slot, old_target, + maplib_bridge, reason); + + if (KztPatchDecisionHasTarget(&decision)) + kzt_apply_patch_decision(&decision); + else + kzt_emit_patch_decision(&decision); +} + +/* + * Stage 6 keeps lazy binding behind explicit helpers. The current behavior is + * still the old first-call KZT resolver path, but generic relocation code no + * longer owns the policy decision directly. + */ +static KztLazyResolveResult kzt_lazy_patch_current_target( + KztLazyBinding *binding); + +static KztPatchDecision kzt_make_lazy_patch_decision( + lib_t *old_owner_maplib, + lib_t *new_owner_maplib, + KztLazyPatchArgs args, + uintptr_t new_target, + KztPatchDecisionReason reason) +{ + return kzt_make_patch_decision( + old_owner_maplib, new_owner_maplib, args.head, args.relocation, + args.relocation_index, args.relocation_type, args.symbol, + args.version, args.version_name, args.slot, args.old_target, + new_target, reason); +} + +static KztPatchDecision kzt_make_lazy_patch_decision_from_resolution( + lib_t *old_owner_maplib, + KztPatchTargetResolution resolution, + KztLazyPatchArgs args, + uintptr_t maplib_bridge, + KztPatchDecisionReason reason) +{ + return kzt_make_patch_decision_from_resolution( + old_owner_maplib, resolution, args.head, args.relocation, + args.relocation_index, args.relocation_type, args.symbol, + args.version, args.version_name, args.slot, args.old_target, + maplib_bridge, reason); +} + +static void kzt_apply_or_log_lazy_patch_resolution( + lib_t *old_owner_maplib, + KztPatchTargetResolution resolution, + KztLazyPatchArgs args, + uintptr_t maplib_bridge, + KztPatchDecisionReason reason) +{ + kzt_apply_or_log_patch_resolution( + old_owner_maplib, resolution, args.head, args.relocation, + args.relocation_index, args.relocation_type, args.symbol, + args.version, args.version_name, args.slot, args.old_target, + maplib_bridge, reason); +} + +static void kzt_defer_jump_slot_binding( + lib_t *maplib, const KztLazyBinding *binding) +{ + KztLazyTargetPatchPlan patch_plan; + + if (!KztLazyPrepareDeferredPatch(binding, &patch_plan)) + return; + KztLazyLogDeferredRelocation(binding); + KztPatchDecision decision = kzt_make_lazy_patch_decision( + maplib, maplib, patch_plan.args, patch_plan.target, + patch_plan.reason); + kzt_apply_patch_decision(&decision); +} + +static void kzt_install_plt_resolver( + lib_t *maplib, elfheader_t *head) +{ + KztLazyResolverInstallPlan plan; + + if (!KztLazyPrepareResolverInstall(head, &plan)) + return; + KztPatchDecision resolver_decision = kzt_make_lazy_patch_decision( + maplib, maplib, plan.resolver_args, plan.resolver_bridge, + KZT_PATCH_REASON_PLT_RESOLVER); + kzt_apply_patch_decision(&resolver_decision); + + head->self_link_map = plan.link_map; + KztPatchDecision link_map_decision = kzt_make_lazy_patch_decision( + maplib, maplib, plan.link_map_args, (uintptr_t)head, + KZT_PATCH_REASON_PLT_RESOLVER); + kzt_apply_patch_decision(&link_map_decision); + printf_log(LOG_INFO, "PLT Resolver injected in %s at %p\n", + plan.table_name, (void *)plan.resolver_slot); +} + +static void kzt_install_lazy_plt_resolver(lib_t *maplib, elfheader_t *head) +{ + KztLazyEnsureResolverBridge( + my_context->system, kzt_lazy_patch_current_target); + + kzt_install_plt_resolver(maplib, head); +} + +static void kzt_handle_jump_slot_relocation( + lib_t *maplib, + KztPatchTargetResolution resolution, + const KztLazyBinding *binding, + int *need_resolv) +{ + if (KztLazyBindingShouldDefer(binding)) { + kzt_defer_jump_slot_binding(maplib, binding); + *need_resolv = 1; + return; + } + + if (kzt_patch_target_resolution_has_bridge(&resolution)) { + KztLazyRelocationPatchPlan patch_plan; + + if (KztLazyPrepareRelocationPatch(binding, &patch_plan)) { + uintptr_t bridge = + kzt_patch_target_resolution_bridge( + &resolution, patch_plan.addend); + KztLazyLogRelocationPatch(&patch_plan, bridge); + KztPatchDecision decision = + kzt_make_lazy_patch_decision_from_resolution( + maplib, resolution, patch_plan.args, bridge, + patch_plan.reason); + kzt_apply_patch_decision(&decision); + } else { + KztLazyLogMissingRelocationSlot(binding); + } + } else { + KztLazyTargetPatchPlan patch_plan; + + KztLazyPrepareUnresolvedPatch( + binding, resolution.unresolved_reason, &patch_plan); + kzt_apply_or_log_lazy_patch_resolution( + maplib, resolution, patch_plan.args, patch_plan.target, + patch_plan.reason); + } +} + +typedef struct KztLazyRelocationContext { + lib_t *maplib; + KztPatchTargetResolution resolution; + int *need_resolv; +} KztLazyRelocationContext; + +static void kzt_handle_jump_slot_relocation_callback( + void *opaque, const KztLazyBinding *binding) +{ + KztLazyRelocationContext *context = opaque; + + kzt_handle_jump_slot_relocation( + context->maplib, context->resolution, binding, context->need_resolv); +} + int RelocateElfRELA(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t* head, int cnt, Elf64_Rela *rela, int* need_resolv) { // int ret_ok = 0; @@ -639,32 +1348,15 @@ int RelocateElfRELA(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t int bind = ELF64_ST_BIND(sym->st_info); const char* symname = SymName(head, sym); uint64_t *p = (uint64_t*)(rela[i].r_offset + head->delta); - uintptr_t offs = 0; - uintptr_t end = 0; int version = head->VerSym?((Elf64_Half*)((uintptr_t)head->VerSym+head->delta))[ELF64_R_SYM(rela[i].r_info)]:-1; if(version!=-1) version &=0x7fff; const char* vername = GetSymbolVersion(head, version); - if(bind==STB_LOCAL) { - offs = sym->st_value + head->delta; - end = offs + sym->st_size; - } else { - // this is probably very very wrong. A proprer way to get reloc need to be writen, but this hack seems ok for now - // at least it work for half-life, unreal, ut99, zsnes, Undertale, ColinMcRae Remake, FTL, ShovelKnight... - /*if(bind==STB_GLOBAL && (ndx==10 || ndx==19) && t!=R_X86_64_GLOB_DAT) { - offs = sym->st_value + head->delta; - end = offs + sym->st_size; - }*/ - // so weak symbol are the one left - if(!offs && !end) { - GetGlobalSymbolStartEnd(maplib, symname, &offs, &end, head, version, vername); - if(!offs && !end && local_maplib) { - GetGlobalSymbolStartEnd(local_maplib, symname, &offs, &end, head, version, vername); - } - } - } + KztPatchTargetResolution resolution = + kzt_resolve_relocation_symbol_for_patch( + maplib, local_maplib, head, sym, symname, bind, t, + p ? *p : 0, version, vername); //uintptr_t globoffs=0, globend=0; - uintptr_t tmp = 0; switch(t) { case R_X86_64_GLOB_DAT: // Look for same symbol already loaded but not in self (so no need for local_maplib here) @@ -672,35 +1364,39 @@ int RelocateElfRELA(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t // offs = globoffs; // end = globend; // } - if (offs) { - printf_log(LOG_INFO, "Apply %s R_X86_64_GLOB_DAT @%p (%p -> %p) on sym=%s (ver=%d/%s)\n", (bind==STB_LOCAL)?"Local":"Global", p, (void*)(p?(*p):0), (void*)offs, symname, version, vername?vername:"(none)"); - *p = offs/* + rela[i].r_addend*/; // not addend it seems + if (kzt_patch_target_resolution_has_bridge(&resolution)) { + uintptr_t bridge = + kzt_patch_target_resolution_bridge(&resolution, 0); + printf_log(LOG_INFO, "Apply %s R_X86_64_GLOB_DAT @%p (%p -> %p) on sym=%s (ver=%d/%s)\n", (bind==STB_LOCAL)?"Local":"Global", p, (void*)(p?(*p):0), (void*)bridge, symname, version, vername?vername:"(none)"); + KztPatchDecision decision = + kzt_make_patch_decision_from_resolution( + maplib, resolution, head, &rela[i], i, t, + symname, version, vername, (uintptr_t)p, *p, + bridge, + bind == STB_LOCAL + ? KZT_PATCH_REASON_LOCAL_SYMBOL + : KZT_PATCH_REASON_GLOBAL_SYMBOL); + kzt_apply_patch_decision(&decision); + } else { + kzt_apply_or_log_patch_resolution( + maplib, resolution, head, &rela[i], i, t, + symname, version, vername, (uintptr_t)p, + p ? *p : 0, 0, resolution.unresolved_reason); } break; case R_X86_64_JUMP_SLOT: - // apply immediatly for gobject closure marshal or for LOCAL binding. Also, apply immediatly if it doesn't jump in the got - tmp = (uintptr_t)(*p); - if (bind==STB_LOCAL - || !tmp - || !((tmp>=head->plt && tmpplt_end) || (tmp>=head->gotplt && tmpgotplt_end)) - || !need_resolv - || bindnow - ) { - if (offs){ - if(p) { - printf_log(LOG_INFO, "RelocateElfRELA : Apply %s R_X86_64_JUMP_SLOT @%p with sym=%s (%p -> %p)\n", (bind==STB_LOCAL)?"Local":"Global", p, symname, *(void**)p, (void*)(offs+rela[i].r_addend)); - *p =(uint64_t) (offs + rela[i].r_addend); - } else { - printf_log(LOG_INFO, "Warning, Symbol %s found, but Jump Slot Offset is NULL \n", symname); - } - } - } else { - printf_log(LOG_INFO, "Preparing (if needed) %s R_X86_64_JUMP_SLOT @%p (0x%lx->0x%0lx) with sym=%s to be apply later (addend=%ld)\n", - (bind==STB_LOCAL)?"Local":"Global", p, *p, *p+head->delta, symname, rela[i].r_addend); - *p += head->delta; - *need_resolv = 1; - } + { + KztLazyRelocationContext context = { + .maplib = maplib, + .resolution = resolution, + .need_resolv = need_resolv, + }; + KztLazyHandleRelocation( + head, &rela[i], i, bind, symname, version, vername, p, + bindnow, need_resolv, + kzt_handle_jump_slot_relocation_callback, &context); break; + } /* case R_X86_64_NONE: break; @@ -741,28 +1437,8 @@ int RelocateElfPlt(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t* //return -1; printf_log(LOG_INFO, "RelocateElfRELA run ERROR!"); } - if(need_resolver) { - if(pltResolver==~0LL) { - pltResolver = AddBridge(my_context->system, vFE, PltResolver, 0, "PltResolver"); - } - if(head->pltgot) { - if(dl_runtime_resolver ==~0LL){ - dl_runtime_resolver = *(uintptr_t*)(head->pltgot+head->delta+16); - } - *(uintptr_t*)(head->pltgot+head->delta+16) = pltResolver; - head->self_link_map = *(uintptr_t*)(head->pltgot+head->delta+8); - *(uintptr_t*)(head->pltgot+head->delta+8) = (uintptr_t)head; - printf_log(LOG_INFO, "PLT Resolver injected in plt.got at %p\n", (void*)(head->pltgot+head->delta+16)); - } else if(head->got) { - if(dl_runtime_resolver ==~0LL){ - dl_runtime_resolver = *(uintptr_t*)(head->got+head->delta+16); - } - *(uintptr_t*)(head->got+head->delta+16) = pltResolver; - head->self_link_map = *(uintptr_t*)(head->got+head->delta+8); - *(uintptr_t*)(head->got+head->delta+8) = (uintptr_t)head; - printf_log(LOG_INFO, "PLT Resolver injected in got at %p\n", (void*)(head->got+head->delta+16)); - } - } + if(need_resolver) + kzt_install_lazy_plt_resolver(maplib, head); } return 0; @@ -940,112 +1616,6 @@ void AddSymbols(lib_t *maplib, kh_mapsymbols_t* mapsymbols, kh_mapsymbols_t* wea } -/* -$ORIGIN – Provides the directory the object was loaded from. This token is typical -used for locating dependencies in unbundled packages. For more details of this -token expansion, see “Locating Associated Dependencies” -$OSNAME – Expands to the name of the operating system (see the uname(1) man -page description of the -s option). For more details of this token expansion, see -“System Specific Shared Objects” -$OSREL – Expands to the operating system release level (see the uname(1) man -page description of the -r option). For more details of this token expansion, see -“System Specific Shared Objects” -$PLATFORM – Expands to the processor type of the current machine (see the -uname(1) man page description of the -i option). For more details of this token -expansion, see “System Specific Shared Objects” -*/ -extern const char *interp_prefix; -int LoadNeededLibs(elfheader_t* h, lib_t *maplib, needed_libs_t* neededlibs, library_t *deplib, int local, int bindnow, box64context_t *box64) -{ - if (!h->latx_hasfix) return 1; - if(relocation_dump) DumpDynamicRPath(h); - // update RPATH first - for (size_t i=0; inumDynamic; ++i) - if(h->Dynamic[i].d_tag==DT_RPATH || h->Dynamic[i].d_tag==DT_RUNPATH) { - char *rpathref = h->DynStrTab+h->delta+h->Dynamic[i].d_un.d_val; - char* rpath = rpathref; - while(strstr(rpath, "$ORIGIN")) { - char* origin = box_strdup(h->path); - char* p = strrchr(origin, '/'); - if(p) *p = '\0'; // remove file name to have only full path, without last '/' - char* tmp = (char*)box_calloc(1, strlen(rpath)-strlen("$ORIGIN")+strlen(origin)+1); - p = strstr(rpath, "$ORIGIN"); - memcpy(tmp, rpath, p-rpath); - strcat(tmp, origin); - strcat(tmp, p+strlen("$ORIGIN")); - if(rpath!=rpathref) - box_free(rpath); - rpath = tmp; - box_free(origin); - } - while(strstr(rpath, "${ORIGIN}")) { - char* origin = box_strdup(h->path); - char* p = strrchr(origin, '/'); - if(p) *p = '\0'; // remove file name to have only full path, without last '/' - char* tmp = (char*)box_calloc(1, strlen(rpath)-strlen("${ORIGIN}")+strlen(origin)+1); - p = strstr(rpath, "${ORIGIN}"); - memcpy(tmp, rpath, p-rpath); - strcat(tmp, origin); - strcat(tmp, p+strlen("${ORIGIN}")); - if(rpath!=rpathref) - box_free(rpath); - rpath = tmp; - box_free(origin); - } - while(strstr(rpath, "${PLATFORM}")) { - char* platform = box_strdup("x86_64"); - char* p = strrchr(platform, '/'); - if(p) *p = '\0'; // remove file name to have only full path, without last '/' - char* tmp = (char*)box_calloc(1, strlen(rpath)-strlen("${PLATFORM}")+strlen(platform)+1); - p = strstr(rpath, "${PLATFORM}"); - memcpy(tmp, rpath, p-rpath); - strcat(tmp, platform); - strcat(tmp, p+strlen("${PLATFORM}")); - if(rpath!=rpathref) - box_free(rpath); - rpath = tmp; - box_free(platform); - } - if(strchr(rpath, '$')) { - printf_log(LOG_INFO, "BOX64: Warning, RPATH with $ variable not supported yet (%s)\n", rpath); - } else { - char latxpath [PATH_MAX] = {0}; - snprintf(latxpath , PATH_MAX, "%s%s:%s", strlen(interp_prefix)?interp_prefix:"/usr/gnemul/latx-x86_64", rpath,rpath); - printf_log(LOG_INFO, "Prepending path \"%s\" to BOX64_LD_LIBRARY_PATH\n", latxpath); - PrependList(&box64->box64_ld_lib, latxpath, 1); - } - if(rpath!=rpathref) - box_free(rpath); - } - - if(!h->neededlibs && neededlibs) - h->neededlibs = neededlibs; - - DumpDynamicNeeded(h); - int cnt = 0; - for (int i=0; inumDynamic; ++i) - if(h->Dynamic[i].d_tag==DT_NEEDED) - ++cnt; - const char* nlibs[cnt]; - int j=0; - for (int i=0; inumDynamic; ++i) - if(h->Dynamic[i].d_tag==DT_NEEDED) { - if (strstr(h->DynStrTab+h->delta+h->Dynamic[i].d_un.d_val, "ld-linux-x86-64.so.2")) { - cnt--; - continue; - } - nlibs[j++] = h->DynStrTab+h->delta+h->Dynamic[i].d_un.d_val; - } - - // TODO: Add LD_LIBRARY_PATH and RPATH handling - if(AddNeededLib(maplib, neededlibs, deplib, local, bindnow, nlibs, cnt, box64)) { - printf_log(LOG_INFO, "Error loading one of needed lib\n"); - if(!allow_missing_libs) - return 1; //error... - } - return 0; -} - void RunElfInit(elfheader_t* h) { } @@ -1267,68 +1837,88 @@ void* GetNativeSymbolUnversionned(void* lib, const char* name) return s.addr; } -static int64_t Pop64(CPUX86State *cpu) +static KztPatchTargetResolution kzt_resolve_lazy_current_target( + const KztLazyBinding *binding) { - uint64_t* st = ((uint64_t*)(cpu->regs[R_ESP])); - cpu->regs[R_ESP] += 8; + KztLazySymbolLookupPlan lookup = + KztLazyPrepareSymbolLookup(binding); + KztLazyPltSymbolArgs plt_args = lookup.plt_args; + library_t *lib = plt_args.head->lib; + lib_t *local_maplib = GetMaplib(lib); + + if (lookup.has_relocation_symbol) { + KztLazyRelocationSymbolArgs rela_args = lookup.relocation_args; + return kzt_resolve_relocation_symbol_for_patch( + my_context->maplib, local_maplib, rela_args.head, + rela_args.symbol_entry, rela_args.symbol, rela_args.bind, + rela_args.relocation_type, rela_args.current_target, + rela_args.version, rela_args.version_name); + } - return *st; + return kzt_resolve_plt_symbol_for_patch( + my_context->maplib, local_maplib, plt_args.head, + plt_args.symbol, plt_args.version, plt_args.version_name); } -static void Push64(CPUX86State *cpu, uint64_t v) + +static uintptr_t kzt_lazy_binding_bridge_from_resolution( + KztPatchTargetResolution resolution) { - cpu->regs[R_ESP] -= 8; - *((uint64_t*)cpu->regs[R_ESP]) = v; + return kzt_patch_target_resolution_bridge(&resolution, 0); +} +static void kzt_apply_lazy_binding_target( + const KztLazyBinding *binding, + KztPatchTargetResolution resolution, + const KztLazyResolvePlan *plan, + const KztLazyTargetPatchPlan *patch_plan) +{ + if (patch_plan && patch_plan->has_target_slot) { + KztLazyLogResolvePatch( + binding, patch_plan->target, + ElfName(FindElfAddress(my_context, patch_plan->target)), + plan); + KztPatchDecision decision = + kzt_make_lazy_patch_decision_from_resolution( + my_context->maplib, resolution, patch_plan->args, + patch_plan->target, patch_plan->reason); + kzt_apply_patch_decision(&decision); + } else { + KztLazyLogResolveMissingSlot(binding, plan); + } } -uintptr_t pltResolver = ~0LL; -uintptr_t dl_runtime_resolver = ~0LL; -uintptr_t link_map_obj=0; -void PltResolver(void) + +static KztLazyResolveResult kzt_apply_lazy_resolve_plan( + const KztLazyBinding *binding, + KztPatchTargetResolution resolution, + const KztLazyResolvePlan *plan) { - CPUX86State *cpu = (CPUX86State*)lsenv->cpu_state; - uintptr_t addr = Pop64(cpu); - int slot = (int)Pop64(cpu); - elfheader_t *h = (elfheader_t*)addr; - printf_log(LOG_INFO, "PltResolver: Addr=%p, Slot=%d Return=%p: elf is %s (VerSym=%p)\n", (void*)addr, slot, *(void**)(cpu->regs[R_ESP]), h->name, h->VerSym); + if (KztLazyResolvePlanUsesGuestFallback(plan)) { + KztLazyLogResolveGuestFallback(binding, plan); + return KztLazyResolveResultFromPlan(plan); + } - Elf64_Rela * rel = (Elf64_Rela *)(h->jmprel + h->delta) + slot; - Elf64_Sym *sym = &h->DynSym[ELF64_R_SYM(rel->r_info)]; - #if defined(CONFIG_LATX_KZT) && defined(CONFIG_LATX_DEBUG) - int bind = ELF64_ST_BIND(sym->st_info); - #endif - const char* symname = SymName(h, sym); - int version = h->VerSym?((Elf64_Half*)((uintptr_t)h->VerSym+h->delta))[ELF64_R_SYM(rel->r_info)]:-1; - if(version!=-1) version &= 0x7fff; - const char* vername = GetSymbolVersion(h, version); - uint64_t *p = (uint64_t*)(rel->r_offset + h->delta); - uintptr_t offs = 0; - uintptr_t end = 0; + uintptr_t bridge = + kzt_lazy_binding_bridge_from_resolution(resolution); + KztLazyTargetPatchPlan patch_plan; + KztLazyResolveResult result = + KztLazyResolveResultFromBridgePatch( + binding, plan, bridge, &patch_plan); + kzt_apply_lazy_binding_target( + binding, resolution, plan, &patch_plan); + + /* The target is the onebridge that the guest should call next. */ + return result; +} - library_t* lib = h->lib; - lib_t* local_maplib = GetMaplib(lib); - GetGlobalSymbolStartEnd(my_context->maplib, symname, &offs, &end, h, version, vername); - if(!offs && !end && local_maplib) { - GetGlobalSymbolStartEnd(local_maplib, symname, &offs, &end, h, version, vername); - } - if(!offs && !end && !version) - GetGlobalSymbolStartEnd(my_context->maplib, symname, &offs, &end, h, -1, NULL); - - if (!offs) { -// printf_log(LOG_INFO, "Error: PltResolver: Symbol %s(ver %d: %s%s%s) not found, cannot apply R_X86_64_JUMP_SLOT %p (%p) in %s\n", symname, version, symname, vername?"@":"", vername?vername:"", p, *(void**)p, h->name); - //return to __dl_runtime_resolver - Push64(cpu, slot); - Push64(cpu, h->self_link_map); - Push64(cpu, dl_runtime_resolver); - return; - } else { - offs = (uintptr_t)getAlternate((void*)offs); - if(p) { - printf_log(LOG_INFO, " Apply %s R_X86_64_JUMP_SLOT %p with sym=%s(ver %d: %s%s%s) (%p -> %p / %s)\n", (bind==STB_LOCAL)?"Local":"Global", p, symname, version, symname, vername?"@":"", vername?vername:"",*(void**)p, (void*)offs, ElfName(FindElfAddress(my_context, offs))); - *p = offs; - } else { - printf_log(LOG_INFO, "PltResolver: Warning, Symbol %s(ver %d: %s%s%s) found, but Jump Slot Offset is NULL \n", symname, version, symname, vername?"@":"", vername?vername:""); - } - //next_tb is the onebridge of the function - Push64(cpu, offs); - } +static KztLazyResolveResult kzt_lazy_patch_current_target( + KztLazyBinding *binding) +{ + KztLazyRefreshCurrentBinding(binding); + + KztPatchTargetResolution resolution = + kzt_resolve_lazy_current_target(binding); + KztLazyResolvePlan plan = KztLazySelectResolvePlan( + binding, kzt_patch_target_resolution_has_bridge(&resolution)); + + return kzt_apply_lazy_resolve_plan(binding, resolution, &plan); } diff --git a/target/i386/latx/context/elfmap.c b/target/i386/latx/context/elfmap.c new file mode 100644 index 00000000000..606598d249e --- /dev/null +++ b/target/i386/latx/context/elfmap.c @@ -0,0 +1,73 @@ +#include + +#include "elfmap.h" + +static int AddToAddress(uintptr_t base, uint64_t offset, uintptr_t *result) +{ + if (offset > UINTPTR_MAX || base > UINTPTR_MAX - (uintptr_t)offset) { + return -1; + } + *result = base + (uintptr_t)offset; + return 0; +} + +int GetElfLoadRange( + const Elf64_Phdr *program_headers, + size_t program_header_count, + uintptr_t load_bias, + uintptr_t page_size, + uintptr_t *map_start, + uintptr_t *map_end) +{ + if (!program_headers || !program_header_count || !map_start || !map_end + || !page_size || (page_size & (page_size - 1))) { + return -1; + } + + uintptr_t first = UINTPTR_MAX; + uintptr_t last = 0; + uintptr_t page_mask = page_size - 1; + int found_load_segment = 0; + + for (size_t i = 0; i < program_header_count; ++i) { + const Elf64_Phdr *header = &program_headers[i]; + if (header->p_type != PT_LOAD || !header->p_memsz) { + continue; + } + + if (header->p_vaddr > UINT64_MAX - header->p_memsz) { + return -1; + } + uint64_t segment_end = header->p_vaddr + header->p_memsz; + if (header->p_vaddr > UINTPTR_MAX || segment_end > UINTPTR_MAX + || segment_end > UINTPTR_MAX - page_mask) { + return -1; + } + + uintptr_t aligned_start = (uintptr_t)header->p_vaddr & ~page_mask; + uintptr_t aligned_end = + ((uintptr_t)segment_end + page_mask) & ~page_mask; + uintptr_t runtime_start; + uintptr_t runtime_end; + if (AddToAddress(load_bias, aligned_start, &runtime_start) + || AddToAddress(load_bias, aligned_end, &runtime_end)) { + return -1; + } + + if (runtime_start < first) { + first = runtime_start; + } + if (runtime_end > last) { + last = runtime_end; + } + found_load_segment = 1; + } + + if (!found_load_segment || first >= last) { + return -1; + } + + *map_start = first; + *map_end = last; + return 0; +} diff --git a/target/i386/latx/context/elfparser.c b/target/i386/latx/context/elfparser.c index cf07885a87e..1090105ce5a 100755 --- a/target/i386/latx/context/elfparser.c +++ b/target/i386/latx/context/elfparser.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + //#define _GNU_SOURCE #include #include diff --git a/target/i386/latx/context/fileutils.c b/target/i386/latx/context/fileutils.c index 87e7d56985e..839d5b4febd 100755 --- a/target/i386/latx/context/fileutils.c +++ b/target/i386/latx/context/fileutils.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #define _FILE_OFFSET_BITS 64 #include #include diff --git a/target/i386/latx/context/globalsymbols.c b/target/i386/latx/context/globalsymbols.c index 5ace60a37b3..7410219ea30 100644 --- a/target/i386/latx/context/globalsymbols.c +++ b/target/i386/latx/context/globalsymbols.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/gtkclass.c b/target/i386/latx/context/gtkclass.c index 86e68327391..165d8f81176 100644 --- a/target/i386/latx/context/gtkclass.c +++ b/target/i386/latx/context/gtkclass.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/guestdynamic.c b/target/i386/latx/context/guestdynamic.c new file mode 100644 index 00000000000..6c0f776264d --- /dev/null +++ b/target/i386/latx/context/guestdynamic.c @@ -0,0 +1,828 @@ +#include "guestdynamic.h" + +#include + +#ifndef DT_GNU_HASH +#define DT_GNU_HASH 0x6ffffef5 +#endif + +#define KZT_GNU_HASH_CHAIN_WALK_MAX (1024 * 1024) + +static int KztDynamicRangeIsReadable(const KztDynamicInfo *info, + const void *addr, size_t size) +{ + uintptr_t start = (uintptr_t)addr; + + if (!addr) + return 0; + if (!size) + return 1; + if (size > UINTPTR_MAX - start) + return 0; + if (!info || !info->range_is_readable) + return 1; + return info->range_is_readable(addr, size, info->range_opaque); +} + +static int KztDynamicTableRangeIsReadable(const KztDynamicInfo *info, + const void *addr, size_t count, + size_t entry_size) +{ + if (!addr || !count || !entry_size) + return 0; + if (count > SIZE_MAX / entry_size) + return 0; + return KztDynamicRangeIsReadable(info, addr, count * entry_size); +} + +static int KztDynamicOffsetPtr(uintptr_t base, size_t count, + size_t entry_size, uintptr_t *result) +{ + size_t offset; + + if (count > SIZE_MAX / entry_size) + return 0; + + offset = count * entry_size; + if (offset > UINTPTR_MAX - base) + return 0; + + *result = base + offset; + return 1; +} + +/* + * The in-memory parser builds a compact view from l_ld. It deliberately + * records only dynamic-loader facts that can be compared with the legacy + * file parser or consumed by later loader code. + */ +static void KztDynamicSummaryAdd(KztDynamicSummary *summary, + const Elf64_Dyn *entry) +{ + Elf64_Word val = entry->d_un.d_val; + Elf64_Addr ptr = entry->d_un.d_ptr; + + switch (entry->d_tag) { + case DT_NEEDED: + ++summary->needed_count; + break; + case DT_RPATH: + ++summary->rpath_count; + break; + case DT_RUNPATH: + ++summary->runpath_count; + break; + case DT_STRTAB: + summary->strtab = ptr; + break; + case DT_STRSZ: + summary->strsz = val; + break; + case DT_SYMTAB: + summary->symtab = ptr; + break; + case DT_SYMENT: + summary->syment = val; + break; + case DT_HASH: + summary->hash = ptr; + break; + case DT_GNU_HASH: + summary->gnu_hash = ptr; + break; + case DT_REL: + summary->rel = ptr; + break; + case DT_RELSZ: + summary->relsz = val; + break; + case DT_RELENT: + summary->relent = val; + break; + case DT_RELA: + summary->rela = ptr; + break; + case DT_RELASZ: + summary->relasz = val; + break; + case DT_RELAENT: + summary->relaent = val; + break; + case DT_JMPREL: + summary->jmprel = ptr; + break; + case DT_PLTRELSZ: + summary->pltrelsz = val; + break; + case DT_PLTREL: + summary->pltrel = val; + break; + case DT_PLTGOT: + summary->pltgot = ptr; + break; + case DT_INIT: + summary->init = ptr; + break; + case DT_INIT_ARRAY: + summary->init_array = ptr; + break; + case DT_INIT_ARRAYSZ: + summary->init_arraysz = val; + break; + case DT_FINI: + summary->fini = ptr; + break; + case DT_FINI_ARRAY: + summary->fini_array = ptr; + break; + case DT_FINI_ARRAYSZ: + summary->fini_arraysz = val; + break; + case DT_VERSYM: + summary->versym = ptr; + break; + case DT_VERNEED: + summary->verneed = ptr; + break; + case DT_VERNEEDNUM: + summary->verneednum = val; + break; + case DT_VERDEF: + summary->verdef = ptr; + break; + case DT_VERDEFNUM: + summary->verdefnum = val; + break; + } +} + +void KztParseDynamicView(KztDynamicView *view, const Elf64_Dyn *dynamic, + size_t max_entries) +{ + memset(view, 0, sizeof(*view)); + + if (!dynamic || !max_entries) { + view->status = KZT_DYNAMIC_VIEW_EMPTY; + return; + } + + view->entries = dynamic; + + for (size_t i = 0; i < max_entries; ++i) { + if (dynamic[i].d_tag == DT_NULL) { + view->summary.has_null = 1; + view->entry_count = view->summary.entries; + view->status = KZT_DYNAMIC_VIEW_READY; + return; + } + ++view->summary.entries; + KztDynamicSummaryAdd(&view->summary, dynamic + i); + } + + view->summary.truncated = 1; + view->entry_count = view->summary.entries; + view->status = KZT_DYNAMIC_VIEW_TRUNCATED; +} + +/* + * KztDynamicInfo is the compatibility shape used by old loader code. Keeping + * the conversion explicit lets the memory parser run in parallel with the + * file parser until their views are proven equivalent. + */ +void KztBuildDynamicInfo(KztDynamicInfo *info, const KztDynamicView *view) +{ + const KztDynamicSummary *summary = &view->summary; + + memset(info, 0, sizeof(*info)); + + info->strtab = summary->strtab; + info->strsz = summary->strsz; + info->symtab = summary->symtab; + info->syment = summary->syment; + info->hash = summary->hash; + info->gnu_hash = summary->gnu_hash; + info->rel = summary->rel; + info->relsz = summary->relsz; + info->relent = summary->relent; + info->rela = summary->rela; + info->relasz = summary->relasz; + info->relaent = summary->relaent; + info->jmprel = summary->jmprel; + info->pltsz = summary->pltrelsz; + info->pltrel = summary->pltrel; + info->pltgot = summary->pltgot; + info->initentry = summary->init; + info->initarray = summary->init_array; + info->initarray_count = summary->init_arraysz / sizeof(Elf64_Addr); + info->finientry = summary->fini; + info->finiarray = summary->fini_array; + info->finiarray_count = summary->fini_arraysz / sizeof(Elf64_Addr); + info->versym = summary->versym; + info->verneed = summary->verneed; + info->verneed_count = summary->verneednum; + info->verdef = summary->verdef; + info->verdef_count = summary->verdefnum; + + if (info->rel && info->relent != sizeof(Elf64_Rel)) + info->errors |= KZT_DYNAMIC_ERROR_RELENT; + if (info->rel && info->relent) { + info->rel_count = info->relsz / info->relent; + info->has_rel_count = 1; + } + if (info->rela && info->relaent != sizeof(Elf64_Rela)) + info->errors |= KZT_DYNAMIC_ERROR_RELAENT; + if (info->rela && info->relaent) { + info->rela_count = info->relasz / info->relaent; + info->has_rela_count = 1; + } + if (info->jmprel) { + if (info->pltrel == DT_REL) { + info->pltent = sizeof(Elf64_Rel); + } else if (info->pltrel == DT_RELA) { + info->pltent = sizeof(Elf64_Rela); + } else { + info->errors |= KZT_DYNAMIC_ERROR_PLTREL; + } + if (info->pltent && (info->pltsz / info->pltent) * info->pltent + != info->pltsz) { + info->errors |= KZT_DYNAMIC_ERROR_PLTSZ; + } + if (info->pltent) { + info->plt_count = info->pltsz / info->pltent; + info->has_plt_count = 1; + } + } +} + +void KztDynamicInfoSetRangeValidator(KztDynamicInfo *info, + KztDynamicRangeValidator validator, + void *opaque) +{ + info->range_is_readable = validator; + info->range_opaque = opaque; +} + +uintptr_t KztDynamicApplyLoadBias(uintptr_t value, uintptr_t load_bias) +{ + if (!value) + return 0; + + if (load_bias && value < load_bias) { + if (value > UINTPTR_MAX - load_bias) + return 0; + value += load_bias; + } + + return value; +} + +const char *KztDynamicStrtabFromPtr(uintptr_t strtab, uintptr_t load_bias) +{ + strtab = KztDynamicApplyLoadBias(strtab, load_bias); + if (!strtab) + return NULL; + + return (const char *)strtab; +} + +int KztDynamicStringTableFromInfo(const KztDynamicInfo *info, + uintptr_t load_bias, + KztDynamicStringTable *table) +{ + table->data = KztDynamicStrtabFromPtr(info->strtab, load_bias); + table->size = info->strsz; + if (!KztDynamicTableRangeIsReadable(info, table->data, table->size, 1)) { + table->data = NULL; + table->size = 0; + return 0; + } + return table->data && table->size; +} + +const char *KztDynamicStringAt(const KztDynamicStringTable *strtab, + size_t offset) +{ + uintptr_t value_addr; + const char *value; + + if (!strtab->data || offset >= strtab->size) + return NULL; + + if (!KztDynamicOffsetPtr((uintptr_t)strtab->data, offset, 1, + &value_addr)) + return NULL; + + value = (const char *)value_addr; + if (!memchr(value, '\0', strtab->size - offset)) + return NULL; + + return value; +} + +int KztNextDynamicString(const KztDynamicView *view, int tag, + size_t *index, + const KztDynamicStringTable *strtab, + KztDynamicStringEntry *entry) +{ + while (*index < view->entry_count) { + const Elf64_Dyn *dynamic = view->entries + (*index)++; + + if (dynamic->d_tag != tag) + continue; + + entry->dynamic = dynamic; + entry->offset = dynamic->d_un.d_val; + entry->value = KztDynamicStringAt(strtab, entry->offset); + return 1; + } + + memset(entry, 0, sizeof(*entry)); + return 0; +} + +static int KztResolveSysvHashSymbolCount(KztDynamicInfo *info, + uintptr_t load_bias) +{ + const uint32_t *hash = + (const uint32_t *)KztDynamicApplyLoadBias(info->hash, load_bias); + + if (!KztDynamicRangeIsReadable(info, hash, 2 * sizeof(*hash))) + return 0; + + info->dynsym_count = hash[1]; + info->has_dynsym_count = 1; + return 1; +} + +static int KztResolveGnuHashSymbolCount(KztDynamicInfo *info, + uintptr_t load_bias) +{ + uintptr_t header_addr = KztDynamicApplyLoadBias(info->gnu_hash, + load_bias); + const uint32_t *header = (const uint32_t *)header_addr; + uint32_t nbuckets; + uint32_t symoffset; + uint32_t bloom_size; + uintptr_t bloom_addr; + uintptr_t buckets_addr; + uintptr_t chains_addr; + const uint32_t *buckets; + size_t count = 0; + + if (!header) + return 0; + if (!KztDynamicRangeIsReadable(info, header, 4 * sizeof(*header))) + return 0; + + nbuckets = header[0]; + symoffset = header[1]; + bloom_size = header[2]; + count = symoffset; + + if (!KztDynamicOffsetPtr(header_addr, 4, sizeof(*header), &bloom_addr) + || !KztDynamicOffsetPtr(bloom_addr, bloom_size, sizeof(Elf64_Addr), + &buckets_addr) + || !KztDynamicOffsetPtr(buckets_addr, nbuckets, sizeof(*buckets), + &chains_addr)) { + info->errors |= KZT_DYNAMIC_ERROR_GNU_HASH; + return 0; + } + + buckets = (const uint32_t *)buckets_addr; + if (!KztDynamicTableRangeIsReadable(info, (const void *)bloom_addr, + bloom_size, sizeof(Elf64_Addr)) + || !KztDynamicTableRangeIsReadable(info, buckets, nbuckets, + sizeof(*buckets))) { + info->errors |= KZT_DYNAMIC_ERROR_GNU_HASH; + return 0; + } + + for (uint32_t i = 0; i < nbuckets; ++i) { + uint32_t sym = buckets[i]; + size_t guard = 0; + + if (!sym) + continue; + if (sym < symoffset) { + info->errors |= KZT_DYNAMIC_ERROR_GNU_HASH; + return 0; + } + + for (;;) { + uintptr_t chain_addr; + uint32_t chain; + size_t next_count; + + if (!KztDynamicOffsetPtr(chains_addr, sym - symoffset, + sizeof(chain), &chain_addr) + || !KztDynamicRangeIsReadable(info, (const void *)chain_addr, + sizeof(chain))) { + info->errors |= KZT_DYNAMIC_ERROR_GNU_HASH; + return 0; + } + chain = *(const uint32_t *)chain_addr; + next_count = (size_t)sym + 1; + if (next_count > count) + count = next_count; + if (chain & 1) + break; + if (++guard > KZT_GNU_HASH_CHAIN_WALK_MAX + || sym == UINT32_MAX) { + info->errors |= KZT_DYNAMIC_ERROR_GNU_HASH; + return 0; + } + ++sym; + } + } + + info->dynsym_count = count; + info->has_dynsym_count = 1; + return 1; +} + +int KztResolveDynamicSymbolCount(KztDynamicInfo *info, uintptr_t load_bias) +{ + if (KztResolveSysvHashSymbolCount(info, load_bias)) + return 1; + + return KztResolveGnuHashSymbolCount(info, load_bias); +} + +void KztBuildDynamicInfoForObject(KztDynamicInfo *info, + const KztDynamicView *view, + uintptr_t load_bias) +{ + KztBuildDynamicInfo(info, view); + KztResolveDynamicSymbolCount(info, load_bias); +} + +const Elf64_Sym *KztDynamicSymtabFromPtr(uintptr_t symtab, + uintptr_t load_bias) +{ + symtab = KztDynamicApplyLoadBias(symtab, load_bias); + if (!symtab) + return NULL; + + return (const Elf64_Sym *)symtab; +} + +int KztDynamicSymbolTableFromInfo(const KztDynamicInfo *info, + uintptr_t load_bias, + KztDynamicSymbolTable *table) +{ + int has_strings; + + table->symbols = KztDynamicSymtabFromPtr(info->symtab, load_bias); + table->count = info->dynsym_count; + has_strings = KztDynamicStringTableFromInfo(info, load_bias, + &table->strings); + if (!table->symbols || !info->has_dynsym_count || !has_strings) + return 0; + if (!KztDynamicTableRangeIsReadable(info, table->symbols, table->count, + sizeof(*table->symbols))) { + table->symbols = NULL; + table->count = 0; + return 0; + } + return 1; +} + +int KztDynamicSymbolAt(const KztDynamicSymbolTable *symtab, size_t index, + KztDynamicSymbolEntry *entry) +{ + const Elf64_Sym *symbol; + + if (!symtab->symbols || index >= symtab->count) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + + symbol = symtab->symbols + index; + entry->symbol = symbol; + entry->name = KztDynamicStringAt(&symtab->strings, symbol->st_name); + return 1; +} + +const Elf64_Half *KztDynamicVersymFromPtr(uintptr_t versym, + uintptr_t load_bias) +{ + versym = KztDynamicApplyLoadBias(versym, load_bias); + if (!versym) + return NULL; + + return (const Elf64_Half *)versym; +} + +const Elf64_Half *KztDynamicVersymFromInfo(const KztDynamicInfo *info, + uintptr_t load_bias) +{ + const Elf64_Half *versym = KztDynamicVersymFromPtr(info->versym, + load_bias); + + if (!KztDynamicTableRangeIsReadable(info, versym, info->dynsym_count, + sizeof(*versym))) + return NULL; + return versym; +} + +const Elf64_Verneed *KztDynamicVerneedFromPtr(uintptr_t verneed, + uintptr_t load_bias) +{ + verneed = KztDynamicApplyLoadBias(verneed, load_bias); + if (!verneed) + return NULL; + + return (const Elf64_Verneed *)verneed; +} + +const Elf64_Verneed *KztDynamicVerneedFromInfo(const KztDynamicInfo *info, + uintptr_t load_bias) +{ + const Elf64_Verneed *verneed = + KztDynamicVerneedFromPtr(info->verneed, load_bias); + + if (!KztDynamicRangeIsReadable(info, verneed, sizeof(*verneed))) + return NULL; + return verneed; +} + +int KztDynamicVerneedAt(const Elf64_Verneed *base, size_t index, + const KztDynamicStringTable *strtab, + KztDynamicVerneedEntry *entry) +{ + return KztDynamicVerneedAtFromInfo(NULL, base, index, strtab, entry); +} + +int KztDynamicVerneedAtFromInfo(const KztDynamicInfo *info, + const Elf64_Verneed *base, size_t index, + const KztDynamicStringTable *strtab, + KztDynamicVerneedEntry *entry) +{ + const Elf64_Verneed *need = base; + + if (!KztDynamicRangeIsReadable(info, need, sizeof(*need)) + || index >= KZT_DYNAMIC_VERSION_WALK_MAX) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + + for (size_t i = 0; need && i < index; ++i) { + uintptr_t next_addr; + + if (!need->vn_next) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + if (!KztDynamicOffsetPtr((uintptr_t)need, need->vn_next, 1, + &next_addr)) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + need = (const Elf64_Verneed *)next_addr; + if (!KztDynamicRangeIsReadable(info, need, sizeof(*need))) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + } + + if (!KztDynamicRangeIsReadable(info, need, sizeof(*need))) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + + entry->info = info; + entry->record = need; + entry->file = KztDynamicStringAt(strtab, need->vn_file); + return 1; +} + +int KztDynamicVernauxAt(const KztDynamicVerneedEntry *verneed, size_t index, + const KztDynamicStringTable *strtab, + KztDynamicVernauxEntry *entry) +{ + const Elf64_Vernaux *aux; + uintptr_t aux_addr; + + const KztDynamicInfo *info = verneed->info; + + if (!verneed->record || !verneed->record->vn_aux + || index >= verneed->record->vn_cnt + || index >= KZT_DYNAMIC_VERSION_WALK_MAX) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + + if (!KztDynamicOffsetPtr((uintptr_t)verneed->record, + verneed->record->vn_aux, 1, &aux_addr)) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + aux = (const Elf64_Vernaux *)aux_addr; + if (!KztDynamicRangeIsReadable(info, aux, sizeof(*aux))) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + for (size_t i = 0; i < index; ++i) { + uintptr_t next_addr; + + if (!aux->vna_next) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + if (!KztDynamicOffsetPtr((uintptr_t)aux, aux->vna_next, 1, + &next_addr)) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + aux = (const Elf64_Vernaux *)next_addr; + if (!KztDynamicRangeIsReadable(info, aux, sizeof(*aux))) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + } + + entry->record = aux; + entry->name = KztDynamicStringAt(strtab, aux->vna_name); + return 1; +} + +const Elf64_Verdef *KztDynamicVerdefFromPtr(uintptr_t verdef, + uintptr_t load_bias) +{ + verdef = KztDynamicApplyLoadBias(verdef, load_bias); + if (!verdef) + return NULL; + + return (const Elf64_Verdef *)verdef; +} + +const Elf64_Verdef *KztDynamicVerdefFromInfo(const KztDynamicInfo *info, + uintptr_t load_bias) +{ + const Elf64_Verdef *verdef = KztDynamicVerdefFromPtr(info->verdef, + load_bias); + + if (!KztDynamicRangeIsReadable(info, verdef, sizeof(*verdef))) + return NULL; + return verdef; +} + +int KztDynamicVerdefAt(const Elf64_Verdef *base, size_t index, + KztDynamicVerdefEntry *entry) +{ + return KztDynamicVerdefAtFromInfo(NULL, base, index, entry); +} + +int KztDynamicVerdefAtFromInfo(const KztDynamicInfo *info, + const Elf64_Verdef *base, size_t index, + KztDynamicVerdefEntry *entry) +{ + const Elf64_Verdef *def = base; + + if (!KztDynamicRangeIsReadable(info, def, sizeof(*def)) + || index >= KZT_DYNAMIC_VERSION_WALK_MAX) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + + for (size_t i = 0; def && i < index; ++i) { + uintptr_t next_addr; + + if (!def->vd_next) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + if (!KztDynamicOffsetPtr((uintptr_t)def, def->vd_next, 1, + &next_addr)) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + def = (const Elf64_Verdef *)next_addr; + if (!KztDynamicRangeIsReadable(info, def, sizeof(*def))) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + } + + if (!KztDynamicRangeIsReadable(info, def, sizeof(*def))) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + + entry->info = info; + entry->record = def; + return 1; +} + +int KztDynamicVerdauxAt(const KztDynamicVerdefEntry *verdef, size_t index, + const KztDynamicStringTable *strtab, + KztDynamicVerdauxEntry *entry) +{ + const Elf64_Verdaux *aux; + uintptr_t aux_addr; + + const KztDynamicInfo *info = verdef->info; + + if (!verdef->record || !verdef->record->vd_aux + || index >= verdef->record->vd_cnt + || index >= KZT_DYNAMIC_VERSION_WALK_MAX) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + + if (!KztDynamicOffsetPtr((uintptr_t)verdef->record, + verdef->record->vd_aux, 1, &aux_addr)) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + aux = (const Elf64_Verdaux *)aux_addr; + if (!KztDynamicRangeIsReadable(info, aux, sizeof(*aux))) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + for (size_t i = 0; i < index; ++i) { + uintptr_t next_addr; + + if (!aux->vda_next) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + if (!KztDynamicOffsetPtr((uintptr_t)aux, aux->vda_next, 1, + &next_addr)) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + aux = (const Elf64_Verdaux *)next_addr; + if (!KztDynamicRangeIsReadable(info, aux, sizeof(*aux))) { + memset(entry, 0, sizeof(*entry)); + return 0; + } + } + + entry->record = aux; + entry->name = KztDynamicStringAt(strtab, aux->vda_name); + return 1; +} + +const void *KztDynamicRelocationsFromPtr(uintptr_t relocations, + uintptr_t load_bias) +{ + relocations = KztDynamicApplyLoadBias(relocations, load_bias); + if (!relocations) + return NULL; + + return (const void *)relocations; +} + +const void *KztDynamicRelocationsFromInfo(const KztDynamicInfo *info, + uintptr_t relocations, + uintptr_t load_bias, + size_t count, int entry_size) +{ + const void *entries = KztDynamicRelocationsFromPtr(relocations, + load_bias); + + if (!KztDynamicTableRangeIsReadable(info, entries, count, entry_size)) + return NULL; + return entries; +} + +int KztDynamicRelocationAt(const KztDynamicRelocationTable *table, + size_t index, + KztDynamicRelocationEntry *entry) +{ + memset(entry, 0, sizeof(*entry)); + + if (!table->entries || index >= table->count) + return 0; + + if (table->entry_size == sizeof(Elf64_Rel)) { + uintptr_t entry_addr; + const Elf64_Rel *rel; + + if (!KztDynamicOffsetPtr((uintptr_t)table->entries, index, + sizeof(*rel), &entry_addr)) + return 0; + rel = (const Elf64_Rel *)entry_addr; + entry->offset = rel->r_offset; + entry->info = rel->r_info; + return 1; + } + + if (table->entry_size == sizeof(Elf64_Rela)) { + uintptr_t entry_addr; + const Elf64_Rela *rela; + + if (!KztDynamicOffsetPtr((uintptr_t)table->entries, index, + sizeof(*rela), &entry_addr)) + return 0; + rela = (const Elf64_Rela *)entry_addr; + entry->offset = rela->r_offset; + entry->info = rela->r_info; + entry->addend = rela->r_addend; + entry->has_addend = 1; + return 1; + } + + return 0; +} diff --git a/target/i386/latx/context/guestlazy.c b/target/i386/latx/context/guestlazy.c new file mode 100644 index 00000000000..55505c95af3 --- /dev/null +++ b/target/i386/latx/context/guestlazy.c @@ -0,0 +1,1256 @@ +#include "qemu/osdep.h" +#include "cpu.h" + +#include "guestlazy.h" + +#include "bridge.h" +#include "debug.h" +#include "elfload_dump.h" +#include "elfloader.h" +#include "elfloader_private.h" +#include "lsenv.h" +#include "wrapper.h" + +static uintptr_t pltResolver = ~0LL; +static uintptr_t dl_runtime_resolver = ~0LL; +static KztLazyPatchCurrentTargetFn kzt_lazy_patch_current_target; + +typedef enum KztLazySlotState { + KZT_LAZY_SLOT_BOUND, + KZT_LAZY_SLOT_UNBOUND, +} KztLazySlotState; + +typedef enum KztLazyResolvePolicy { + KZT_LAZY_RESOLVE_POLICY_GUEST_FALLBACK, + KZT_LAZY_RESOLVE_POLICY_DIRECT_BRIDGE, +} KztLazyResolvePolicy; + +typedef enum KztLazyResolveReason { + KZT_LAZY_RESOLVE_REASON_NO_BRIDGE, + KZT_LAZY_RESOLVE_REASON_RESOLVED_BRIDGE, + KZT_LAZY_RESOLVE_REASON_CURRENT_TARGET_BRIDGE, +} KztLazyResolveReason; + +typedef enum KztLazyRelocationLog { + KZT_LAZY_RELOCATION_LOG_DEFERRED, + KZT_LAZY_RELOCATION_LOG_PATCH, + KZT_LAZY_RELOCATION_LOG_MISSING_SLOT, +} KztLazyRelocationLog; + +typedef enum KztLazyResolveLog { + KZT_LAZY_RESOLVE_LOG_PATCH, + KZT_LAZY_RESOLVE_LOG_MISSING_SLOT, + KZT_LAZY_RESOLVE_LOG_GUEST_FALLBACK, +} KztLazyResolveLog; + +typedef enum KztLazyRelocationAction { + KZT_LAZY_RELOCATION_ACTION_PATCH, + KZT_LAZY_RELOCATION_ACTION_DEFER, +} KztLazyRelocationAction; + +typedef enum KztLazyResolveAction { + KZT_LAZY_RESOLVE_ACTION_GUEST_FALLBACK, + KZT_LAZY_RESOLVE_ACTION_PATCH_BRIDGE, +} KztLazyResolveAction; + +typedef struct KztLazyPatchSite_s { + elfheader_t *head; + Elf64_Rela *relocation; + Elf64_Sym *symbol_entry; + size_t relocation_index; + int relocation_type; + const char *symbol; + int bind; + int version; + const char *version_name; + uintptr_t slot; + uintptr_t old_target; + uintptr_t current_target; + uintptr_t relocated_target; + long addend; + int has_target_slot; + const char *scope_name; +} KztLazyPatchSite; + +typedef struct KztLazyResolverTable_s { + uintptr_t table; + const char *table_name; + uintptr_t resolver_slot; + uintptr_t link_map_slot; + uintptr_t resolver; + uintptr_t link_map; +} KztLazyResolverTable; + +struct KztLazyBinding_s { + elfheader_t *head; + Elf64_Rela *relocation; + int slot; + int bind; + const char *symbol; + int version; + const char *version_name; + uint64_t *target_slot; + uintptr_t current_target; + KztLazySlotState slot_state; +}; + +typedef struct KztLazyResolverFrame_s { + elfheader_t *head; + int slot; + uintptr_t return_address; +} KztLazyResolverFrame; + +typedef struct KztLazySymbolLookup_s { + elfheader_t *head; + Elf64_Sym *symbol_entry; + const char *symbol; + int bind; + int relocation_type; + uintptr_t current_target; + int version; + const char *version_name; +} KztLazySymbolLookup; + +static void PltResolver(void); +static int kzt_lazy_refresh_binding(KztLazyBinding *binding, + int bindnow, + const int *need_resolv); +static KztLazySlotState kzt_lazy_classify_jump_slot( + const elfheader_t *head, + const uint64_t *slot, + int bind, + int bindnow, + const int *need_resolv); +static const char *kzt_lazy_resolve_plan_policy_name( + const KztLazyResolvePlan *plan); +static const char *kzt_lazy_resolve_plan_reason_name( + const KztLazyResolvePlan *plan); +static uintptr_t kzt_lazy_patch_site_prepare_deferred( + KztLazyPatchSite *site); +static KztPatchDecisionReason kzt_lazy_resolve_plan_patch_reason( + const KztLazyResolvePlan *plan); +static int kzt_lazy_patch_site_has_target_slot( + const KztLazyPatchSite *site); +static long kzt_lazy_patch_site_addend(const KztLazyPatchSite *site); +static KztPatchDecisionReason kzt_lazy_symbol_patch_reason( + const KztLazyBinding *binding); + +/* + * Stage 6 keeps the current first-call KZT PLT resolver behavior, but moves + * guest lazy-binding frame handling out of the generic relocation code. The + * remaining policy switch can now be changed here without reworking + * RelocateElfRELA(). + */ +static KztLazySlotState kzt_lazy_classify_jump_slot( + const elfheader_t *head, + const uint64_t *slot, + int bind, + int bindnow, + const int *need_resolv) +{ + uintptr_t target = slot ? (uintptr_t)*slot : 0; + + if (bind == STB_LOCAL || !target || !need_resolv || bindnow) + return KZT_LAZY_SLOT_BOUND; + if ((target >= head->plt && target < head->plt_end) + || (target >= head->gotplt && target < head->gotplt_end)) { + return KZT_LAZY_SLOT_UNBOUND; + } + return KZT_LAZY_SLOT_BOUND; +} + +static KztLazyBinding kzt_lazy_binding_from_relocation( + elfheader_t *head, + const Elf64_Rela *relocation, + int slot, + int bind, + const char *symbol, + int version, + const char *version_name, + uint64_t *target_slot, + int bindnow, + const int *need_resolv) +{ + KztLazyBinding binding = { + .head = head, + .relocation = (Elf64_Rela *)relocation, + .slot = slot, + .bind = bind, + .symbol = symbol, + .version = version, + .version_name = version_name, + .target_slot = target_slot, + }; + + kzt_lazy_refresh_binding(&binding, bindnow, need_resolv); + return binding; +} + +void KztLazyHandleRelocation(elfheader_t *head, + const Elf64_Rela *relocation, + int slot, + int bind, + const char *symbol, + int version, + const char *version_name, + uint64_t *target_slot, + int bindnow, + const int *need_resolv, + KztLazyRelocationHandlerFn handler, + void *opaque) +{ + if (!handler) + return; + + KztLazyBinding binding = kzt_lazy_binding_from_relocation( + head, relocation, slot, bind, symbol, version, version_name, + target_slot, bindnow, need_resolv); + handler(opaque, &binding); +} + +static KztLazyBinding kzt_lazy_binding_from_slot(elfheader_t *head, int slot) +{ + KztLazyBinding binding = { + .head = head, + .slot = slot, + .version = -1, + }; + + binding.relocation = (Elf64_Rela *)(head->jmprel + head->delta) + slot; + Elf64_Sym *sym = &head->DynSym[ELF64_R_SYM(binding.relocation->r_info)]; + binding.bind = ELF64_ST_BIND(sym->st_info); + binding.symbol = SymName(head, sym); + binding.version = head->VerSym + ? ((Elf64_Half *)((uintptr_t)head->VerSym + head->delta))[ + ELF64_R_SYM(binding.relocation->r_info)] + : -1; + if (binding.version != -1) + binding.version &= 0x7fff; + binding.version_name = GetSymbolVersion(head, binding.version); + binding.target_slot = + (uint64_t *)(binding.relocation->r_offset + head->delta); + kzt_lazy_refresh_binding(&binding, 0, &binding.slot); + return binding; +} + +static const char *kzt_lazy_symbol_name(const KztLazyBinding *binding); + +static int kzt_lazy_has_target_slot(const KztLazyBinding *binding) +{ + return binding && binding->target_slot; +} + +static uintptr_t kzt_lazy_target_slot_address(const KztLazyBinding *binding) +{ + if (!kzt_lazy_has_target_slot(binding)) + return 0; + + return (uintptr_t)binding->target_slot; +} + +static uintptr_t kzt_lazy_read_target_slot(const KztLazyBinding *binding) +{ + if (!kzt_lazy_has_target_slot(binding)) + return 0; + + return *binding->target_slot; +} + +static uintptr_t kzt_lazy_current_target(const KztLazyBinding *binding) +{ + if (!binding) + return 0; + + return binding->current_target; +} + +static uintptr_t kzt_lazy_current_target_with_delta( + const KztLazyBinding *binding) +{ + if (!binding || !binding->head) + return 0; + + return kzt_lazy_current_target(binding) + binding->head->delta; +} + +static KztLazyPatchSite kzt_lazy_patch_site_from_binding( + const KztLazyBinding *binding) +{ + KztLazyPatchSite site = { + .head = binding ? binding->head : NULL, + .relocation = binding ? binding->relocation : NULL, + .symbol_entry = NULL, + .relocation_index = binding ? binding->slot : 0, + .relocation_type = R_X86_64_JUMP_SLOT, + .symbol = kzt_lazy_symbol_name(binding), + .bind = binding ? binding->bind : STB_GLOBAL, + .version = binding ? binding->version : -1, + .version_name = binding ? binding->version_name : NULL, + .slot = kzt_lazy_target_slot_address(binding), + .old_target = kzt_lazy_read_target_slot(binding), + .current_target = kzt_lazy_current_target(binding), + .relocated_target = kzt_lazy_current_target_with_delta(binding), + .addend = binding && binding->relocation + ? binding->relocation->r_addend + : 0, + .has_target_slot = kzt_lazy_has_target_slot(binding), + .scope_name = binding && binding->bind == STB_LOCAL + ? "Local" + : "Global", + }; + + if (site.head && site.relocation) { + site.symbol_entry = + &site.head->DynSym[ELF64_R_SYM(site.relocation->r_info)]; + } + + return site; +} + +static KztLazyPatchSite kzt_lazy_deferred_patch_site_from_binding( + const KztLazyBinding *binding) +{ + KztLazyPatchSite site = kzt_lazy_patch_site_from_binding(binding); + + kzt_lazy_patch_site_prepare_deferred(&site); + return site; +} + +static int kzt_lazy_patch_site_has_target_slot( + const KztLazyPatchSite *site) +{ + return site && site->has_target_slot; +} + +static uintptr_t kzt_lazy_patch_site_prepare_deferred( + KztLazyPatchSite *site) +{ + if (!site) + return 0; + + site->old_target = site->current_target; + return site->relocated_target; +} + +static uintptr_t kzt_lazy_patch_site_deferred_target( + const KztLazyPatchSite *site) +{ + return site ? site->relocated_target : 0; +} + +static long kzt_lazy_patch_site_addend(const KztLazyPatchSite *site) +{ + return site ? site->addend : 0; +} + +static KztLazyPatchArgs kzt_lazy_patch_args_from_site( + const KztLazyPatchSite *site) +{ + KztLazyPatchArgs args = { + .head = site ? site->head : NULL, + .relocation = site ? site->relocation : NULL, + .relocation_index = site ? site->relocation_index : 0, + .relocation_type = site + ? site->relocation_type + : R_X86_64_JUMP_SLOT, + .symbol = site ? site->symbol : NULL, + .version = site ? site->version : -1, + .version_name = site ? site->version_name : NULL, + .slot = site ? site->slot : 0, + .old_target = site ? site->old_target : 0, + }; + + return args; +} + +static KztLazySymbolLookup kzt_lazy_symbol_lookup_from_binding( + const KztLazyBinding *binding) +{ + KztLazyPatchSite site = kzt_lazy_patch_site_from_binding(binding); + KztLazySymbolLookup lookup = { + .head = site.head, + .symbol_entry = site.symbol_entry, + .symbol = site.symbol, + .bind = site.bind, + .relocation_type = site.relocation_type, + .current_target = site.current_target, + .version = site.version, + .version_name = site.version_name, + }; + + return lookup; +} + +static int kzt_lazy_symbol_lookup_has_relocation_symbol( + const KztLazySymbolLookup *lookup) +{ + return lookup && lookup->symbol_entry; +} + +static KztLazyRelocationSymbolArgs kzt_lazy_symbol_lookup_relocation_args( + const KztLazySymbolLookup *lookup) +{ + KztLazyRelocationSymbolArgs args = { + .head = lookup ? lookup->head : NULL, + .symbol_entry = lookup ? lookup->symbol_entry : NULL, + .symbol = lookup ? lookup->symbol : NULL, + .bind = lookup ? lookup->bind : STB_GLOBAL, + .relocation_type = lookup + ? lookup->relocation_type + : R_X86_64_JUMP_SLOT, + .current_target = lookup ? lookup->current_target : 0, + .version = lookup ? lookup->version : -1, + .version_name = lookup ? lookup->version_name : NULL, + }; + + return args; +} + +static KztLazyPltSymbolArgs kzt_lazy_symbol_lookup_plt_args( + const KztLazySymbolLookup *lookup) +{ + KztLazyPltSymbolArgs args = { + .head = lookup ? lookup->head : NULL, + .symbol = lookup ? lookup->symbol : NULL, + .version = lookup ? lookup->version : -1, + .version_name = lookup ? lookup->version_name : NULL, + }; + + return args; +} + +static int kzt_lazy_binding_has_relocation_symbol( + const KztLazyBinding *binding) +{ + KztLazySymbolLookup lookup = + kzt_lazy_symbol_lookup_from_binding(binding); + + return kzt_lazy_symbol_lookup_has_relocation_symbol(&lookup); +} + +static KztLazyRelocationSymbolArgs kzt_lazy_relocation_symbol_args_from_binding( + const KztLazyBinding *binding) +{ + KztLazySymbolLookup lookup = + kzt_lazy_symbol_lookup_from_binding(binding); + + return kzt_lazy_symbol_lookup_relocation_args(&lookup); +} + +static KztLazyPltSymbolArgs kzt_lazy_plt_symbol_args_from_binding( + const KztLazyBinding *binding) +{ + KztLazySymbolLookup lookup = + kzt_lazy_symbol_lookup_from_binding(binding); + + return kzt_lazy_symbol_lookup_plt_args(&lookup); +} + +KztLazySymbolLookupPlan KztLazyPrepareSymbolLookup( + const KztLazyBinding *binding) +{ + KztLazySymbolLookupPlan plan = { + .has_relocation_symbol = + kzt_lazy_binding_has_relocation_symbol(binding), + .relocation_args = + kzt_lazy_relocation_symbol_args_from_binding(binding), + .plt_args = kzt_lazy_plt_symbol_args_from_binding(binding), + }; + + return plan; +} + +static void kzt_lazy_log_deferred_binding(const KztLazyPatchSite *site) +{ + printf_log(LOG_INFO, + "Preparing (if needed) %s R_X86_64_JUMP_SLOT @%p " + "(0x%lx->0x%0lx) with sym=%s to be apply later " + "(addend=%ld)\n", + site->scope_name, + (void *)site->slot, site->current_target, + site->relocated_target, site->symbol, site->addend); +} + +static void kzt_lazy_log_relocation_patch(const KztLazyPatchSite *site, + uintptr_t bridge) +{ + printf_log(LOG_INFO, + "RelocateElfRELA : Apply %s R_X86_64_JUMP_SLOT " + "@%p with sym=%s (%p -> %p)\n", + site->scope_name, + (void *)site->slot, site->symbol, + (void *)site->old_target, (void *)bridge); +} + +static void kzt_lazy_log_missing_relocation_slot( + const KztLazyPatchSite *site) +{ + printf_log(LOG_INFO, + "Warning, Symbol %s found, but Jump Slot Offset is " + "NULL \n", + site->symbol); +} + +static void kzt_lazy_log_resolved_target(const KztLazyPatchSite *site, + uintptr_t target, + const char *owner, + const KztLazyResolvePlan *plan) +{ + printf_log(LOG_INFO, + " Apply %s R_X86_64_JUMP_SLOT %p with " + "sym=%s(ver %d: %s%s%s) (%p -> %p / %s, reason=%s)\n", + site->scope_name, (void *)site->slot, + site->symbol, site->version, site->symbol, + site->version_name ? "@" : "", + site->version_name ? site->version_name : "", + (void *)site->old_target, (void *)target, owner, + kzt_lazy_resolve_plan_reason_name(plan)); +} + +static void kzt_lazy_log_missing_resolved_slot( + const KztLazyPatchSite *site) +{ + printf_log(LOG_INFO, + "PltResolver: Warning, Symbol %s(ver %d: %s%s%s) found, " + "but Jump Slot Offset is NULL \n", + site->symbol, site->version, site->symbol, + site->version_name ? "@" : "", + site->version_name ? site->version_name : ""); +} + +static void kzt_lazy_log_guest_fallback(const KztLazyPatchSite *site, + const KztLazyResolvePlan *plan) +{ + printf_log(LOG_INFO, + "PltResolver: keep guest resolver for %s " + "(policy=%s reason=%s)\n", + site->symbol, + kzt_lazy_resolve_plan_policy_name(plan), + kzt_lazy_resolve_plan_reason_name(plan)); +} + +static void kzt_lazy_log_relocation(const KztLazyPatchSite *site, + KztLazyRelocationLog type, + uintptr_t bridge) +{ + switch (type) { + case KZT_LAZY_RELOCATION_LOG_DEFERRED: + kzt_lazy_log_deferred_binding(site); + return; + case KZT_LAZY_RELOCATION_LOG_PATCH: + kzt_lazy_log_relocation_patch(site, bridge); + return; + case KZT_LAZY_RELOCATION_LOG_MISSING_SLOT: + kzt_lazy_log_missing_relocation_slot(site); + return; + } +} + +static void kzt_lazy_log_binding_relocation( + const KztLazyBinding *binding, + KztLazyRelocationLog type, + uintptr_t bridge) +{ + KztLazyPatchSite site = kzt_lazy_patch_site_from_binding(binding); + + kzt_lazy_log_relocation(&site, type, bridge); +} + +void KztLazyLogDeferredRelocation(const KztLazyBinding *binding) +{ + kzt_lazy_log_binding_relocation( + binding, KZT_LAZY_RELOCATION_LOG_DEFERRED, 0); +} + +void KztLazyLogMissingRelocationSlot(const KztLazyBinding *binding) +{ + kzt_lazy_log_binding_relocation( + binding, KZT_LAZY_RELOCATION_LOG_MISSING_SLOT, 0); +} + +void KztLazyLogRelocationPatch( + const KztLazyRelocationPatchPlan *patch_plan, + uintptr_t bridge) +{ + if (!patch_plan) + return; + + KztLazyPatchSite site = { + .symbol = patch_plan->args.symbol, + .slot = patch_plan->args.slot, + .old_target = patch_plan->args.old_target, + .scope_name = patch_plan->scope_name, + }; + + kzt_lazy_log_relocation( + &site, KZT_LAZY_RELOCATION_LOG_PATCH, bridge); +} + +static void kzt_lazy_log_resolve(const KztLazyPatchSite *site, + KztLazyResolveLog type, + uintptr_t target, + const char *owner, + const KztLazyResolvePlan *plan) +{ + switch (type) { + case KZT_LAZY_RESOLVE_LOG_PATCH: + kzt_lazy_log_resolved_target(site, target, owner, plan); + return; + case KZT_LAZY_RESOLVE_LOG_MISSING_SLOT: + kzt_lazy_log_missing_resolved_slot(site); + return; + case KZT_LAZY_RESOLVE_LOG_GUEST_FALLBACK: + kzt_lazy_log_guest_fallback(site, plan); + return; + } +} + +static void kzt_lazy_log_binding_resolve( + const KztLazyBinding *binding, + KztLazyResolveLog type, + uintptr_t target, + const char *owner, + const KztLazyResolvePlan *plan) +{ + KztLazyPatchSite site = kzt_lazy_patch_site_from_binding(binding); + + kzt_lazy_log_resolve(&site, type, target, owner, plan); +} + +void KztLazyLogResolvePatch(const KztLazyBinding *binding, + uintptr_t target, + const char *owner, + const KztLazyResolvePlan *plan) +{ + kzt_lazy_log_binding_resolve( + binding, KZT_LAZY_RESOLVE_LOG_PATCH, target, owner, plan); +} + +void KztLazyLogResolveMissingSlot(const KztLazyBinding *binding, + const KztLazyResolvePlan *plan) +{ + kzt_lazy_log_binding_resolve( + binding, KZT_LAZY_RESOLVE_LOG_MISSING_SLOT, 0, NULL, plan); +} + +void KztLazyLogResolveGuestFallback(const KztLazyBinding *binding, + const KztLazyResolvePlan *plan) +{ + kzt_lazy_log_binding_resolve( + binding, KZT_LAZY_RESOLVE_LOG_GUEST_FALLBACK, 0, NULL, plan); +} + +static const char *kzt_lazy_symbol_name(const KztLazyBinding *binding) +{ + return binding && binding->symbol ? binding->symbol : ""; +} + +static KztPatchDecisionReason kzt_lazy_symbol_patch_reason( + const KztLazyBinding *binding) +{ + return binding && binding->bind == STB_LOCAL + ? KZT_PATCH_REASON_LOCAL_SYMBOL + : KZT_PATCH_REASON_GLOBAL_SYMBOL; +} + +static int kzt_lazy_refresh_binding(KztLazyBinding *binding, + int bindnow, + const int *need_resolv) +{ + uintptr_t previous_target; + + if (!binding) + return 0; + + previous_target = binding->current_target; + binding->current_target = kzt_lazy_read_target_slot(binding); + binding->slot_state = kzt_lazy_classify_jump_slot( + binding->head, binding->target_slot, binding->bind, bindnow, + need_resolv); + + return previous_target != binding->current_target; +} + +int KztLazyRefreshCurrentBinding(KztLazyBinding *binding) +{ + if (!binding) + return 0; + + return kzt_lazy_refresh_binding(binding, 0, &binding->slot); +} + +static int kzt_lazy_binding_needs_guest_resolver( + const KztLazyBinding *binding) +{ + return binding && binding->slot_state == KZT_LAZY_SLOT_UNBOUND; +} + +static int kzt_lazy_binding_has_bound_target(const KztLazyBinding *binding) +{ + return binding && binding->slot_state == KZT_LAZY_SLOT_BOUND + && binding->current_target; +} + +static KztLazyRelocationAction kzt_lazy_select_relocation_action( + const KztLazyBinding *binding) +{ + return kzt_lazy_binding_needs_guest_resolver(binding) + ? KZT_LAZY_RELOCATION_ACTION_DEFER + : KZT_LAZY_RELOCATION_ACTION_PATCH; +} + +int KztLazyBindingShouldDefer(const KztLazyBinding *binding) +{ + return kzt_lazy_select_relocation_action(binding) + == KZT_LAZY_RELOCATION_ACTION_DEFER; +} + +static uintptr_t kzt_lazy_bridge_target(uintptr_t bridge) +{ + return (uintptr_t)getAlternate((void *)bridge); +} + +static void kzt_lazy_observe_bound_target(const KztLazyBinding *binding, + uintptr_t target) +{ + uintptr_t current_target; + + if (!kzt_lazy_binding_has_bound_target(binding)) + return; + + current_target = kzt_lazy_current_target(binding); + if (current_target == target) + return; + + addAlternate((void *)current_target, (void *)target); +} + +static uintptr_t kzt_lazy_target_from_bridge( + const KztLazyBinding *binding, uintptr_t bridge) +{ + uintptr_t target = kzt_lazy_bridge_target(bridge); + + kzt_lazy_observe_bound_target(binding, target); + return target; +} + +static uint64_t kzt_lazy_pop64(CPUX86State *cpu) +{ + uint64_t *stack = (uint64_t *)cpu->regs[R_ESP]; + cpu->regs[R_ESP] += 8; + + return *stack; +} + +static void kzt_lazy_push64(CPUX86State *cpu, uint64_t value) +{ + cpu->regs[R_ESP] -= 8; + *(uint64_t *)cpu->regs[R_ESP] = value; +} + +static KztLazyResolverFrame kzt_lazy_read_resolver_frame(CPUX86State *cpu) +{ + uintptr_t addr = kzt_lazy_pop64(cpu); + KztLazyResolverFrame frame = { + .head = (elfheader_t *)addr, + .slot = (int)kzt_lazy_pop64(cpu), + .return_address = *(uintptr_t *)cpu->regs[R_ESP], + }; + + return frame; +} + +static KztLazyResolverTable kzt_lazy_read_resolver_table( + uintptr_t table, const char *table_name) +{ + KztLazyResolverTable resolver_table = { + .table = table, + .table_name = table_name, + .resolver_slot = table + 16, + .link_map_slot = table + 8, + }; + + resolver_table.resolver = *(uintptr_t *)resolver_table.resolver_slot; + resolver_table.link_map = *(uintptr_t *)resolver_table.link_map_slot; + return resolver_table; +} + +static int kzt_lazy_find_resolver_table( + elfheader_t *head, KztLazyResolverTable *resolver_table) +{ + if (!head || !resolver_table) + return 0; + + if (head->pltgot) { + *resolver_table = kzt_lazy_read_resolver_table( + head->pltgot + head->delta, "plt.got"); + return 1; + } + if (head->got) { + *resolver_table = kzt_lazy_read_resolver_table( + head->got + head->delta, "got"); + return 1; + } + + return 0; +} + +static uintptr_t kzt_lazy_get_resolver_bridge(void) +{ + return pltResolver; +} + +static int kzt_lazy_has_resolver_bridge(void) +{ + return pltResolver != ~0LL; +} + +static void kzt_lazy_set_resolver_bridge(uintptr_t bridge) +{ + pltResolver = bridge; +} + +static void kzt_lazy_set_patch_current_target_callback( + KztLazyPatchCurrentTargetFn callback) +{ + kzt_lazy_patch_current_target = callback; +} + +uintptr_t KztLazyEnsureResolverBridge( + bridge_t *bridge, KztLazyPatchCurrentTargetFn callback) +{ + kzt_lazy_set_patch_current_target_callback(callback); + + if (!kzt_lazy_has_resolver_bridge()) { + kzt_lazy_set_resolver_bridge( + AddBridge(bridge, vFE, PltResolver, 0, "PltResolver")); + } + + return kzt_lazy_get_resolver_bridge(); +} + +static uintptr_t kzt_lazy_remember_guest_resolver(uintptr_t resolver) +{ + if (dl_runtime_resolver == ~0LL) + dl_runtime_resolver = resolver; + + return dl_runtime_resolver; +} + +static uintptr_t kzt_lazy_activate_resolver_table( + const KztLazyResolverTable *resolver_table) +{ + if (!resolver_table) + return 0; + + kzt_lazy_remember_guest_resolver(resolver_table->resolver); + return kzt_lazy_get_resolver_bridge(); +} + +static KztLazyPatchSite kzt_lazy_resolver_table_resolver_site( + elfheader_t *head, const KztLazyResolverTable *resolver_table) +{ + KztLazyPatchSite site = { + .head = head, + .symbol = "plt-resolver", + .version = -1, + .slot = resolver_table ? resolver_table->resolver_slot : 0, + .old_target = resolver_table ? resolver_table->resolver : 0, + .has_target_slot = resolver_table != NULL, + .scope_name = "Global", + }; + + return site; +} + +static KztLazyPatchSite kzt_lazy_resolver_table_link_map_site( + elfheader_t *head, const KztLazyResolverTable *resolver_table) +{ + KztLazyPatchSite site = { + .head = head, + .symbol = "plt-link-map", + .version = -1, + .slot = resolver_table ? resolver_table->link_map_slot : 0, + .old_target = resolver_table ? resolver_table->link_map : 0, + .has_target_slot = resolver_table != NULL, + .scope_name = "Global", + }; + + return site; +} + +static const char *kzt_lazy_resolver_table_name( + const KztLazyResolverTable *resolver_table) +{ + return resolver_table ? resolver_table->table_name : ""; +} + +static uintptr_t kzt_lazy_resolver_table_link_map( + const KztLazyResolverTable *resolver_table) +{ + return resolver_table ? resolver_table->link_map : 0; +} + +static uintptr_t kzt_lazy_resolver_table_resolver_slot( + const KztLazyResolverTable *resolver_table) +{ + return resolver_table ? resolver_table->resolver_slot : 0; +} + +int KztLazyPrepareResolverInstall( + elfheader_t *head, + KztLazyResolverInstallPlan *plan) +{ + KztLazyResolverTable resolver_table; + + if (!plan) + return 0; + if (!kzt_lazy_find_resolver_table(head, &resolver_table)) + return 0; + + plan->resolver_bridge = kzt_lazy_activate_resolver_table(&resolver_table); + KztLazyPatchSite resolver_site = + kzt_lazy_resolver_table_resolver_site(head, &resolver_table); + KztLazyPatchSite link_map_site = + kzt_lazy_resolver_table_link_map_site(head, &resolver_table); + plan->resolver_args = kzt_lazy_patch_args_from_site(&resolver_site); + plan->link_map_args = kzt_lazy_patch_args_from_site(&link_map_site); + plan->link_map = kzt_lazy_resolver_table_link_map(&resolver_table); + plan->table_name = kzt_lazy_resolver_table_name(&resolver_table); + plan->resolver_slot = + kzt_lazy_resolver_table_resolver_slot(&resolver_table); + return 1; +} + +static void kzt_lazy_return_to_guest_resolver( + CPUX86State *cpu, + const KztLazyBinding *binding, + uintptr_t dl_runtime_resolver) +{ + kzt_lazy_push64(cpu, binding->slot); + kzt_lazy_push64(cpu, binding->head->self_link_map); + kzt_lazy_push64(cpu, dl_runtime_resolver); +} + +static KztLazyResolveResult kzt_lazy_resolve_result_return_to_guest( + KztLazyResolveReason reason) +{ + KztLazyResolveResult result = { + .opaque_policy = KZT_LAZY_RESOLVE_POLICY_GUEST_FALLBACK, + .opaque_reason = reason, + .opaque_target = 0, + }; + + return result; +} + +static KztLazyResolveResult kzt_lazy_resolve_result_call_bridge( + uintptr_t target, KztLazyResolveReason reason) +{ + KztLazyResolveResult result = { + .opaque_policy = KZT_LAZY_RESOLVE_POLICY_DIRECT_BRIDGE, + .opaque_reason = reason, + .opaque_target = target, + }; + + return result; +} + +static KztLazyResolveReason kzt_lazy_select_bridge_reason( + const KztLazyBinding *binding) +{ + if (kzt_lazy_binding_has_bound_target(binding)) + return KZT_LAZY_RESOLVE_REASON_CURRENT_TARGET_BRIDGE; + + return KZT_LAZY_RESOLVE_REASON_RESOLVED_BRIDGE; +} + +static KztPatchDecisionReason kzt_lazy_patch_reason_for_resolve_reason( + KztLazyResolveReason reason) +{ + if (reason == KZT_LAZY_RESOLVE_REASON_CURRENT_TARGET_BRIDGE) + return KZT_PATCH_REASON_LAZY_BINDING_CURRENT_TARGET; + + return KZT_PATCH_REASON_LAZY_BINDING_RESOLVED; +} + +KztLazyResolvePlan KztLazySelectResolvePlan( + const KztLazyBinding *binding, int has_bridge) +{ + if (!has_bridge) { + KztLazyResolvePlan plan = { + .opaque_policy = KZT_LAZY_RESOLVE_POLICY_GUEST_FALLBACK, + .opaque_reason = KZT_LAZY_RESOLVE_REASON_NO_BRIDGE, + }; + return plan; + } + + KztLazyResolvePlan plan = { + .opaque_policy = KZT_LAZY_RESOLVE_POLICY_DIRECT_BRIDGE, + .opaque_reason = kzt_lazy_select_bridge_reason(binding), + }; + return plan; +} + +static KztLazyResolveAction kzt_lazy_resolve_plan_action( + const KztLazyResolvePlan *plan) +{ + return plan + && plan->opaque_policy == KZT_LAZY_RESOLVE_POLICY_DIRECT_BRIDGE + ? KZT_LAZY_RESOLVE_ACTION_PATCH_BRIDGE + : KZT_LAZY_RESOLVE_ACTION_GUEST_FALLBACK; +} + +int KztLazyResolvePlanUsesGuestFallback( + const KztLazyResolvePlan *plan) +{ + return kzt_lazy_resolve_plan_action(plan) + == KZT_LAZY_RESOLVE_ACTION_GUEST_FALLBACK; +} + +static KztLazyResolvePolicy kzt_lazy_resolve_plan_policy( + const KztLazyResolvePlan *plan) +{ + return plan + ? plan->opaque_policy + : KZT_LAZY_RESOLVE_POLICY_GUEST_FALLBACK; +} + +static KztLazyResolveReason kzt_lazy_resolve_plan_reason( + const KztLazyResolvePlan *plan) +{ + return plan ? plan->opaque_reason : KZT_LAZY_RESOLVE_REASON_NO_BRIDGE; +} + +static KztLazyResolveResult kzt_lazy_resolve_result_from_bridge( + const KztLazyBinding *binding, + const KztLazyResolvePlan *plan, + uintptr_t bridge) +{ + uintptr_t target = kzt_lazy_target_from_bridge(binding, bridge); + + return kzt_lazy_resolve_result_call_bridge( + target, kzt_lazy_resolve_plan_reason(plan)); +} + +KztLazyResolveResult KztLazyResolveResultFromPlan( + const KztLazyResolvePlan *plan) +{ + return kzt_lazy_resolve_result_return_to_guest( + kzt_lazy_resolve_plan_reason(plan)); +} + +static uintptr_t kzt_lazy_resolve_result_target( + const KztLazyResolveResult *result) +{ + return result ? result->opaque_target : 0; +} + +static KztLazyResolvePolicy kzt_lazy_resolve_result_policy( + const KztLazyResolveResult *result) +{ + return result + ? result->opaque_policy + : KZT_LAZY_RESOLVE_POLICY_GUEST_FALLBACK; +} + +static KztLazyResolveReason kzt_lazy_resolve_result_reason( + const KztLazyResolveResult *result) +{ + return result + ? result->opaque_reason + : KZT_LAZY_RESOLVE_REASON_NO_BRIDGE; +} + +static KztPatchDecisionReason kzt_lazy_resolve_plan_patch_reason( + const KztLazyResolvePlan *plan) +{ + return kzt_lazy_patch_reason_for_resolve_reason( + kzt_lazy_resolve_plan_reason(plan)); +} + +static int kzt_lazy_prepare_resolve_patch( + const KztLazyBinding *binding, + const KztLazyResolvePlan *resolve_plan, + uintptr_t target, + KztLazyTargetPatchPlan *patch_plan) +{ + if (!patch_plan) + return 0; + + KztLazyPatchSite site = kzt_lazy_patch_site_from_binding(binding); + + patch_plan->args = kzt_lazy_patch_args_from_site(&site); + patch_plan->target = target; + patch_plan->reason = + kzt_lazy_resolve_plan_patch_reason(resolve_plan); + patch_plan->has_target_slot = + kzt_lazy_patch_site_has_target_slot(&site); + return patch_plan->has_target_slot; +} + +KztLazyResolveResult KztLazyResolveResultFromBridgePatch( + const KztLazyBinding *binding, + const KztLazyResolvePlan *plan, + uintptr_t bridge, + KztLazyTargetPatchPlan *patch_plan) +{ + KztLazyResolveResult result = + kzt_lazy_resolve_result_from_bridge(binding, plan, bridge); + + kzt_lazy_prepare_resolve_patch( + binding, plan, kzt_lazy_resolve_result_target(&result), + patch_plan); + return result; +} + +int KztLazyPrepareDeferredPatch( + const KztLazyBinding *binding, + KztLazyTargetPatchPlan *patch_plan) +{ + if (!patch_plan) + return 0; + + KztLazyPatchSite site = kzt_lazy_deferred_patch_site_from_binding(binding); + + patch_plan->args = kzt_lazy_patch_args_from_site(&site); + patch_plan->target = + kzt_lazy_patch_site_deferred_target(&site); + patch_plan->reason = KZT_PATCH_REASON_LAZY_BINDING_DEFERRED; + patch_plan->has_target_slot = + kzt_lazy_patch_site_has_target_slot(&site); + return 1; +} + +int KztLazyPrepareUnresolvedPatch( + const KztLazyBinding *binding, + KztPatchDecisionReason reason, + KztLazyTargetPatchPlan *patch_plan) +{ + if (!patch_plan) + return 0; + + KztLazyPatchSite site = kzt_lazy_patch_site_from_binding(binding); + + patch_plan->args = kzt_lazy_patch_args_from_site(&site); + patch_plan->target = 0; + patch_plan->reason = reason; + patch_plan->has_target_slot = + kzt_lazy_patch_site_has_target_slot(&site); + return 1; +} + +int KztLazyPrepareRelocationPatch( + const KztLazyBinding *binding, + KztLazyRelocationPatchPlan *patch_plan) +{ + if (!patch_plan) + return 0; + + KztLazyPatchSite site = kzt_lazy_patch_site_from_binding(binding); + + patch_plan->args = kzt_lazy_patch_args_from_site(&site); + patch_plan->addend = kzt_lazy_patch_site_addend(&site); + patch_plan->reason = kzt_lazy_symbol_patch_reason(binding); + patch_plan->scope_name = site.scope_name; + return kzt_lazy_patch_site_has_target_slot(&site); +} + +static const char *kzt_lazy_resolve_policy_name( + KztLazyResolvePolicy policy) +{ + switch (policy) { + case KZT_LAZY_RESOLVE_POLICY_GUEST_FALLBACK: + return "guest-fallback"; + case KZT_LAZY_RESOLVE_POLICY_DIRECT_BRIDGE: + return "direct-bridge"; + } + return "unknown"; +} + +static const char *kzt_lazy_resolve_reason_name( + KztLazyResolveReason reason) +{ + switch (reason) { + case KZT_LAZY_RESOLVE_REASON_NO_BRIDGE: + return "no-bridge"; + case KZT_LAZY_RESOLVE_REASON_RESOLVED_BRIDGE: + return "resolved-bridge"; + case KZT_LAZY_RESOLVE_REASON_CURRENT_TARGET_BRIDGE: + return "current-target-bridge"; + } + return "unknown"; +} + +static const char *kzt_lazy_resolve_plan_policy_name( + const KztLazyResolvePlan *plan) +{ + return kzt_lazy_resolve_policy_name(kzt_lazy_resolve_plan_policy(plan)); +} + +static const char *kzt_lazy_resolve_plan_reason_name( + const KztLazyResolvePlan *plan) +{ + return kzt_lazy_resolve_reason_name(kzt_lazy_resolve_plan_reason(plan)); +} + +static KztLazyResolveResult kzt_lazy_patch_current_target_binding( + KztLazyBinding *binding) +{ + if (!kzt_lazy_patch_current_target) { + printf_log(LOG_INFO, + "PltResolver: no lazy patch callback for %s\n", + kzt_lazy_symbol_name(binding)); + return kzt_lazy_resolve_result_return_to_guest( + KZT_LAZY_RESOLVE_REASON_NO_BRIDGE); + } + + return kzt_lazy_patch_current_target(binding); +} + +static void kzt_lazy_apply_resolve_result( + CPUX86State *cpu, + const KztLazyBinding *binding, + const KztLazyResolveResult *result, + uintptr_t dl_runtime_resolver) +{ + switch (kzt_lazy_resolve_result_policy(result)) { + case KZT_LAZY_RESOLVE_POLICY_GUEST_FALLBACK: + printf_log(LOG_INFO, + "PltResolver: return to guest resolver " + "(reason=%s)\n", + kzt_lazy_resolve_reason_name( + kzt_lazy_resolve_result_reason(result))); + kzt_lazy_return_to_guest_resolver( + cpu, binding, dl_runtime_resolver); + return; + case KZT_LAZY_RESOLVE_POLICY_DIRECT_BRIDGE: + printf_log(LOG_INFO, + "PltResolver: call bridge %p " + "(reason=%s)\n", + (void *)kzt_lazy_resolve_result_target(result), + kzt_lazy_resolve_reason_name( + kzt_lazy_resolve_result_reason(result))); + kzt_lazy_push64(cpu, kzt_lazy_resolve_result_target(result)); + return; + } +} + +static void PltResolver(void) +{ + CPUX86State *cpu = (CPUX86State *)lsenv->cpu_state; + KztLazyResolverFrame frame = kzt_lazy_read_resolver_frame(cpu); + printf_log(LOG_INFO, + "PltResolver: Addr=%p, Slot=%d Return=%p: elf is %s " + "(VerSym=%p)\n", + (void *)frame.head, frame.slot, + (void *)frame.return_address, frame.head->name, + frame.head->VerSym); + + KztLazyBinding binding = kzt_lazy_binding_from_slot(frame.head, frame.slot); + KztLazyResolveResult result = + kzt_lazy_patch_current_target_binding(&binding); + + kzt_lazy_apply_resolve_result( + cpu, &binding, &result, dl_runtime_resolver); +} diff --git a/target/i386/latx/context/guestobject.c b/target/i386/latx/context/guestobject.c new file mode 100644 index 00000000000..61ac304dafd --- /dev/null +++ b/target/i386/latx/context/guestobject.c @@ -0,0 +1,312 @@ +#include +#include +#include + +#include "debug.h" +#include "guestobject.h" + +typedef struct guest_object_s { + uintptr_t link_map_addr; + uintptr_t load_bias; + uintptr_t dynamic_addr; + uintptr_t map_start; + uintptr_t map_end; + char *name; + guest_object_state_t state; + unsigned int observations; + unsigned long generation; +} guest_object_t; + +struct guest_object_registry_s { + guest_object_t *objects; + size_t size; + size_t capacity; + unsigned long next_generation; + pthread_mutex_t lock; +}; + +/* + * The registry is the identity layer between loader notifications and later + * patch planning. It is keyed by link_map address because names can be empty + * or reused, while a live link_map entry is the stable object handle observed + * from the guest loader. + */ +static guest_object_t *FindGuestObjectByLinkMap( + guest_object_registry_t *registry, + uintptr_t link_map_addr) +{ + for (size_t i = 0; i < registry->size; ++i) { + if (registry->objects[i].link_map_addr == link_map_addr) { + return ®istry->objects[i]; + } + } + return NULL; +} + +static void FillGuestObjectLookup( + const guest_object_t *object, + guest_object_lookup_t *lookup) +{ + lookup->link_map_addr = object->link_map_addr; + lookup->load_bias = object->load_bias; + lookup->dynamic_addr = object->dynamic_addr; + lookup->map_start = object->map_start; + lookup->map_end = object->map_end; + lookup->name = object->name; + lookup->state = object->state; + lookup->generation = object->generation; +} + +static int GuestObjectChanged( + const guest_object_t *object, + uintptr_t load_bias, + uintptr_t dynamic_addr, + const char *name) +{ + return object->load_bias != load_bias + || object->dynamic_addr != dynamic_addr + || strcmp(object->name, name); +} + +static int GrowGuestObjectRegistry(guest_object_registry_t *registry) +{ + if (registry->size < registry->capacity) { + return 0; + } + + size_t new_capacity = registry->capacity ? registry->capacity * 2 : 16; + guest_object_t *objects = box_realloc( + registry->objects, new_capacity * sizeof(guest_object_t)); + if (!objects) { + return -1; + } + + memset(objects + registry->capacity, 0, + (new_capacity - registry->capacity) * sizeof(guest_object_t)); + registry->objects = objects; + registry->capacity = new_capacity; + return 0; +} + +guest_object_registry_t *NewGuestObjectRegistry(void) +{ + guest_object_registry_t *registry = + box_calloc(1, sizeof(guest_object_registry_t)); + if (!registry) { + return NULL; + } + + if (pthread_mutex_init(®istry->lock, NULL)) { + box_free(registry); + return NULL; + } + + registry->next_generation = 1; + return registry; +} + +void FreeGuestObjectRegistry(guest_object_registry_t **registry) +{ + if (!registry || !*registry) { + return; + } + + guest_object_registry_t *current = *registry; + for (size_t i = 0; i < current->size; ++i) { + box_free(current->objects[i].name); + } + box_free(current->objects); + pthread_mutex_destroy(¤t->lock); + box_free(current); + *registry = NULL; +} + +guest_object_observation_t ObserveGuestObject( + guest_object_registry_t *registry, + uintptr_t link_map_addr, + uintptr_t load_bias, + uintptr_t dynamic_addr, + const char *name) +{ + if (!registry || !link_map_addr) { + return GUEST_OBJECT_OBSERVE_INVALID; + } + + const char *object_name = name ? name : ""; + pthread_mutex_lock(®istry->lock); + + guest_object_t *object = FindGuestObjectByLinkMap(registry, link_map_addr); + if (object) { + ++object->observations; + if (!GuestObjectChanged(object, load_bias, dynamic_addr, object_name)) { + pthread_mutex_unlock(®istry->lock); + return GUEST_OBJECT_OBSERVE_UNCHANGED; + } + + char *new_name = box_strdup(object_name); + if (!new_name) { + pthread_mutex_unlock(®istry->lock); + return GUEST_OBJECT_OBSERVE_INVALID; + } + + box_free(object->name); + object->name = new_name; + object->load_bias = load_bias; + object->dynamic_addr = dynamic_addr; + object->map_start = 0; + object->map_end = 0; + object->state = GUEST_OBJECT_DISCOVERED; + object->generation = registry->next_generation++; + pthread_mutex_unlock(®istry->lock); + return GUEST_OBJECT_OBSERVE_CHANGED; + } + + if (GrowGuestObjectRegistry(registry)) { + pthread_mutex_unlock(®istry->lock); + return GUEST_OBJECT_OBSERVE_INVALID; + } + + char *new_name = box_strdup(object_name); + if (!new_name) { + pthread_mutex_unlock(®istry->lock); + return GUEST_OBJECT_OBSERVE_INVALID; + } + + object = ®istry->objects[registry->size++]; + object->link_map_addr = link_map_addr; + object->load_bias = load_bias; + object->dynamic_addr = dynamic_addr; + object->name = new_name; + object->state = GUEST_OBJECT_DISCOVERED; + object->observations = 1; + object->generation = registry->next_generation++; + pthread_mutex_unlock(®istry->lock); + return GUEST_OBJECT_OBSERVE_NEW; +} + +/* + * Address lookup is intentionally range based. Later GOT patch decisions see + * only the current guest address stored in a slot, so they need a way to map + * that address back to the guest object chosen by the guest loader. + */ +int SetGuestObjectMapRange( + guest_object_registry_t *registry, + uintptr_t link_map_addr, + uintptr_t map_start, + uintptr_t map_end) +{ + if (!registry || !link_map_addr || map_start >= map_end) { + return -1; + } + + pthread_mutex_lock(®istry->lock); + guest_object_t *object = FindGuestObjectByLinkMap(registry, link_map_addr); + if (!object) { + pthread_mutex_unlock(®istry->lock); + return -1; + } + + object->map_start = map_start; + object->map_end = map_end; + pthread_mutex_unlock(®istry->lock); + return 0; +} + +int LookupGuestObjectByAddress( + guest_object_registry_t *registry, + uintptr_t addr, + guest_object_lookup_t *lookup) +{ + if (!registry || !addr || !lookup) { + return -1; + } + + pthread_mutex_lock(®istry->lock); + for (size_t i = 0; i < registry->size; ++i) { + const guest_object_t *object = ®istry->objects[i]; + if (object->map_start && addr >= object->map_start + && addr < object->map_end) { + FillGuestObjectLookup(object, lookup); + pthread_mutex_unlock(®istry->lock); + return 0; + } + } + pthread_mutex_unlock(®istry->lock); + return -1; +} + +guest_object_process_result_t BeginGuestObjectProcessing( + guest_object_registry_t *registry, + uintptr_t link_map_addr) +{ + if (!registry || !link_map_addr) { + return GUEST_OBJECT_PROCESS_INVALID; + } + + pthread_mutex_lock(®istry->lock); + guest_object_t *object = FindGuestObjectByLinkMap(registry, link_map_addr); + if (!object) { + pthread_mutex_unlock(®istry->lock); + return GUEST_OBJECT_PROCESS_INVALID; + } + + guest_object_process_result_t result; + switch (object->state) { + case GUEST_OBJECT_DISCOVERED: + case GUEST_OBJECT_FAILED: + object->state = GUEST_OBJECT_PROCESSING; + result = GUEST_OBJECT_PROCESS_STARTED; + break; + case GUEST_OBJECT_PROCESSING: + result = GUEST_OBJECT_PROCESS_IN_PROGRESS; + break; + case GUEST_OBJECT_WRAPPED: + case GUEST_OBJECT_EMULATED: + result = GUEST_OBJECT_PROCESS_DONE; + break; + default: + result = GUEST_OBJECT_PROCESS_INVALID; + break; + } + + pthread_mutex_unlock(®istry->lock); + return result; +} + +int SetGuestObjectState( + guest_object_registry_t *registry, + uintptr_t link_map_addr, + guest_object_state_t state) +{ + if (!registry || !link_map_addr) { + return -1; + } + + pthread_mutex_lock(®istry->lock); + guest_object_t *object = FindGuestObjectByLinkMap(registry, link_map_addr); + if (!object) { + pthread_mutex_unlock(®istry->lock); + return -1; + } + + object->state = state; + pthread_mutex_unlock(®istry->lock); + return 0; +} + +const char *GuestObjectStateName(guest_object_state_t state) +{ + switch (state) { + case GUEST_OBJECT_DISCOVERED: + return "discovered"; + case GUEST_OBJECT_PROCESSING: + return "processing"; + case GUEST_OBJECT_WRAPPED: + return "wrapped"; + case GUEST_OBJECT_EMULATED: + return "emulated"; + case GUEST_OBJECT_FAILED: + return "failed"; + } + return "unknown"; +} diff --git a/target/i386/latx/context/guestpatch.c b/target/i386/latx/context/guestpatch.c new file mode 100644 index 00000000000..5eb49510ee5 --- /dev/null +++ b/target/i386/latx/context/guestpatch.c @@ -0,0 +1,262 @@ +#include "guestpatch.h" + +#include +#include + +static const char *KztPatchStringOrNone(const char *value) +{ + return value ? value : "(none)"; +} + +static const char *KztPatchBasename(const char *name) +{ + const char *base; + + if (!name) + return NULL; + + base = strrchr(name, '/'); + return base ? base + 1 : name; +} + +/* + * A patch decision is the audit record for a GOT write. Defaults keep maplib + * as the selected target so new guest-owner data can first be attached and + * compared without changing behavior. + */ +void KztPatchDecisionInit(KztPatchDecision *decision) +{ + memset(decision, 0, sizeof(*decision)); + decision->symbol_version = -1; + decision->reason = KZT_PATCH_REASON_NONE; + decision->maplib_owner_relation = KZT_PATCH_OWNER_RELATION_UNKNOWN; + decision->guest_owner_relation = KZT_PATCH_OWNER_RELATION_UNKNOWN; + decision->owner_relation = KZT_PATCH_OWNER_RELATION_UNKNOWN; + decision->shadow_result = KZT_PATCH_SHADOW_DISABLED; + decision->target_source = KZT_PATCH_TARGET_MAPLIB; +} + +KztPatchOwnerRelation KztPatchOwnerRelationForNames(const char *guest_object, + const char *owner) +{ + const char *guest_name = KztPatchBasename(guest_object); + const char *owner_name = KztPatchBasename(owner); + + if (!guest_name && !owner_name) + return KZT_PATCH_OWNER_RELATION_UNKNOWN; + if (guest_name && !owner_name) + return KZT_PATCH_OWNER_RELATION_GUEST_ONLY; + if (!guest_name && owner_name) + return KZT_PATCH_OWNER_RELATION_MAPLIB_ONLY; + return strcmp(guest_name, owner_name) == 0 + ? KZT_PATCH_OWNER_RELATION_MATCH + : KZT_PATCH_OWNER_RELATION_MISMATCH; +} + +int KztPatchDecisionHasTarget(const KztPatchDecision *decision) +{ + return decision->new_bridge != 0; +} + +void KztPatchDecisionSetMaplibTarget(KztPatchDecision *decision, + uintptr_t bridge, + const char *owner, + uintptr_t owner_base) +{ + decision->maplib_bridge = bridge; + decision->maplib_owner = owner; + decision->maplib_owner_base = owner_base; + decision->maplib_owner_relation = KztPatchOwnerRelationForNames( + decision->old_guest_object, owner); + decision->new_bridge = bridge; + decision->new_owner = owner; + decision->new_owner_base = owner_base; + decision->owner_relation = decision->maplib_owner_relation; + decision->target_source = KZT_PATCH_TARGET_MAPLIB; +} + +void KztPatchDecisionSetGuestOwnerFailure(KztPatchDecision *decision, + KztPatchShadowResult failure) +{ + decision->shadow_result = failure; +} + +void KztPatchDecisionSetGuestOwnerTarget(KztPatchDecision *decision, + uintptr_t bridge, + const char *library, + const char *owner, + uintptr_t owner_base, + int select_target) +{ + decision->guest_owner_bridge = bridge; + decision->guest_owner_library = library; + decision->guest_owner = owner; + decision->guest_owner_base = owner_base; + decision->guest_owner_relation = KztPatchOwnerRelationForNames( + decision->old_guest_object, owner); + if (!decision->maplib_bridge) { + decision->shadow_result = KZT_PATCH_SHADOW_NO_MAPLIB_TARGET; + } else { + decision->shadow_result = bridge == decision->maplib_bridge + ? KZT_PATCH_SHADOW_MATCH + : KZT_PATCH_SHADOW_MISMATCH; + } + if (select_target) + KztPatchDecisionSelectGuestOwnerTarget(decision); +} + +/* + * Selecting a guest-owner target is the only point where the planner changes + * the bridge that will be written. Callers must decide that the guest-owner + * probe is authoritative before using this helper. + */ +void KztPatchDecisionSelectGuestOwnerTarget(KztPatchDecision *decision) +{ + decision->new_bridge = decision->guest_owner_bridge; + decision->new_owner = decision->guest_owner; + decision->new_owner_base = decision->guest_owner_base; + decision->owner_relation = KztPatchOwnerRelationForNames( + decision->old_guest_object, decision->new_owner); + decision->target_source = KZT_PATCH_TARGET_GUEST_OWNER; +} + +const char *KztPatchDecisionReasonName(KztPatchDecisionReason reason) +{ + switch (reason) { + case KZT_PATCH_REASON_NONE: + return "none"; + case KZT_PATCH_REASON_LOCAL_SYMBOL: + return "local-symbol"; + case KZT_PATCH_REASON_GLOBAL_SYMBOL: + return "global-symbol"; + case KZT_PATCH_REASON_LAZY_BINDING_DEFERRED: + return "lazy-binding-deferred"; + case KZT_PATCH_REASON_LAZY_BINDING_RESOLVED: + return "lazy-binding-resolved"; + case KZT_PATCH_REASON_LAZY_BINDING_CURRENT_TARGET: + return "lazy-binding-current-target"; + case KZT_PATCH_REASON_PLT_RESOLVER: + return "plt-resolver"; + case KZT_PATCH_REASON_GUEST_OWNER_TARGET: + return "guest-owner-target"; + case KZT_PATCH_REASON_SYMBOL_MISSING: + return "symbol-missing"; + case KZT_PATCH_REASON_UNSUPPORTED_RELOCATION: + return "unsupported-relocation"; + } + return "unknown"; +} + +const char *KztPatchOwnerRelationName(KztPatchOwnerRelation relation) +{ + switch (relation) { + case KZT_PATCH_OWNER_RELATION_UNKNOWN: + return "unknown"; + case KZT_PATCH_OWNER_RELATION_GUEST_ONLY: + return "guest-only"; + case KZT_PATCH_OWNER_RELATION_MAPLIB_ONLY: + return "maplib-only"; + case KZT_PATCH_OWNER_RELATION_MATCH: + return "match"; + case KZT_PATCH_OWNER_RELATION_MISMATCH: + return "mismatch"; + } + return "unknown"; +} + +const char *KztPatchShadowResultName(KztPatchShadowResult result) +{ + switch (result) { + case KZT_PATCH_SHADOW_DISABLED: + return "disabled"; + case KZT_PATCH_SHADOW_NO_MAPLIB_TARGET: + return "no-maplib-target"; + case KZT_PATCH_SHADOW_NO_GUEST_OWNER: + return "no-guest-owner"; + case KZT_PATCH_SHADOW_SELF_PLT: + return "self-plt"; + case KZT_PATCH_SHADOW_NO_WRAPPER: + return "no-wrapper"; + case KZT_PATCH_SHADOW_NO_LIBRARY: + return "no-library"; + case KZT_PATCH_SHADOW_SYMBOL_MISSING: + return "symbol-missing"; + case KZT_PATCH_SHADOW_MATCH: + return "match"; + case KZT_PATCH_SHADOW_MISMATCH: + return "mismatch"; + } + return "unknown"; +} + +const char *KztPatchTargetSourceName(KztPatchTargetSource source) +{ + switch (source) { + case KZT_PATCH_TARGET_MAPLIB: + return "maplib"; + case KZT_PATCH_TARGET_GUEST_OWNER: + return "guest-owner"; + } + return "unknown"; +} + +const char *KztPatchRelocationTypeName(int relocation_type) +{ + switch (relocation_type) { + case R_X86_64_GLOB_DAT: + return "R_X86_64_GLOB_DAT"; + case R_X86_64_JUMP_SLOT: + return "R_X86_64_JUMP_SLOT"; + } + return "unknown"; +} + +size_t KztFormatPatchDecision(char *buffer, size_t buffer_size, + const KztPatchDecision *decision) +{ + int written = snprintf( + buffer, buffer_size, + "object=%s base=0x%lx relocation=%p index=%zu type=%s symbol=%s " + "version=%d/%s slot=0x%lx old=0x%lx old_owner=%s old_owner_base=0x%lx " + "old_guest_object=%s old_guest_object_base=0x%lx " + "maplib_bridge=0x%lx maplib_owner=%s maplib_owner_base=0x%lx " + "maplib_owner_relation=%s new_bridge=0x%lx new_owner=%s " + "new_owner_base=0x%lx reason=%s " + "owner_relation=%s guest_owner_bridge=0x%lx " + "guest_owner_library=%s guest_owner=%s guest_owner_base=0x%lx " + "guest_owner_relation=%s shadow_result=%s target_source=%s", + KztPatchStringOrNone(decision->object), + decision->object_base, + decision->relocation, + decision->relocation_index, + KztPatchRelocationTypeName(decision->relocation_type), + KztPatchStringOrNone(decision->symbol), + decision->symbol_version, + KztPatchStringOrNone(decision->symbol_version_name), + decision->slot, + decision->old_target, + KztPatchStringOrNone(decision->old_owner), + decision->old_owner_base, + KztPatchStringOrNone(decision->old_guest_object), + decision->old_guest_object_base, + decision->maplib_bridge, + KztPatchStringOrNone(decision->maplib_owner), + decision->maplib_owner_base, + KztPatchOwnerRelationName(decision->maplib_owner_relation), + decision->new_bridge, + KztPatchStringOrNone(decision->new_owner), + decision->new_owner_base, + KztPatchDecisionReasonName(decision->reason), + KztPatchOwnerRelationName(decision->owner_relation), + decision->guest_owner_bridge, + KztPatchStringOrNone(decision->guest_owner_library), + KztPatchStringOrNone(decision->guest_owner), + decision->guest_owner_base, + KztPatchOwnerRelationName(decision->guest_owner_relation), + KztPatchShadowResultName(decision->shadow_result), + KztPatchTargetSourceName(decision->target_source)); + + if (written < 0) + return 0; + return (size_t)written; +} diff --git a/target/i386/latx/context/librarian.c b/target/i386/latx/context/librarian.c index ba9e1d9aadd..b6fdba0ea61 100755 --- a/target/i386/latx/context/librarian.c +++ b/target/i386/latx/context/librarian.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/library.c b/target/i386/latx/context/library.c index 95e13a69634..6b9785214dc 100755 --- a/target/i386/latx/context/library.c +++ b/target/i386/latx/context/library.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/mallochook.c b/target/i386/latx/context/mallochook.c index 2efc7cb9966..5bd210d8c19 100644 --- a/target/i386/latx/context/mallochook.c +++ b/target/i386/latx/context/mallochook.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/meson.build b/target/i386/latx/context/meson.build index f07cf9b44a0..6a22c1f9c9a 100644 --- a/target/i386/latx/context/meson.build +++ b/target/i386/latx/context/meson.build @@ -55,12 +55,17 @@ my_file = files( 'wrappedlibxfixes.c', 'wrappedlibegl.c', 'box64context.c', + 'guestobject.c', 'librarian.c', 'dictionnary.c', 'symbols.c', 'library.c', 'pathcoll.c', 'fileutils.c', + 'elfmap.c', + 'guestdynamic.c', + 'guestlazy.c', + 'guestpatch.c', 'elfparser.c', 'elfloader.c', 'elfload_dump.c', diff --git a/target/i386/latx/context/myalign.c b/target/i386/latx/context/myalign.c index d5ee1482f4c..18cacc5ecdd 100644 --- a/target/i386/latx/context/myalign.c +++ b/target/i386/latx/context/myalign.c @@ -1,8 +1,19 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include "config-host.h" #include "lsenv.h" #include "myalign.h" +#include "elfmap.h" #include "elfloader.h" #include "elfloader_private.h" +#include "guestdynamic.h" +#include "guestobject.h" #include #include #include @@ -2050,6 +2061,19 @@ static int CalcLoadAddrNative(elfheader_t* head, size_t align) head->stackalign = 16; // default align for stack return 0; } + +/* + * Stage 5 lets the guest loader own ordinary guest dependencies. KZT still + * registers wrappers for objects after the guest loader maps them, but it no + * longer expands a guest object's DT_NEEDED list or RPATH/RUNPATH itself. + */ +static void kzt_skip_guest_needed_side_load(const char *scope, + const char *path) +{ + printf_log(LOG_DEBUG, "%s Skip guest DT_NEEDED side loading for \"%s\"\n", + scope, path ? path : "(unknown)"); +} + static void init_main_elf(elfheader_t* elf_header,int fd, uintptr_t load_addr, size_t align) { @@ -2070,9 +2094,7 @@ static void init_main_elf(elfheader_t* elf_header,int fd, uintptr_t load_addr, AddMainElfToLinkmap(elf_header); - if (LoadNeededLibs(elf_header, my_context->maplib, &my_context->neededlibs, NULL, 0, 0, my_context)) { - printf_log(LOG_INFO, "Error: loading needed libs in elf %s\n", my_context->argv[0]); - } + kzt_skip_guest_needed_side_load("kzt_init", my_context->argv[0]); ResetSpecialCaseMainElf(elf_header); } int wine_option_kzt; @@ -2109,11 +2131,159 @@ int kzt_init(char** argv, int argc,char** target_argv, int target_argc, return 0; } -struct x86_ld_info { +typedef struct KztGlibcLoaderHook { int reg; - intptr_t addr; + uintptr_t addr; +} KztGlibcLoaderHook; + +typedef void (*KztTbCallback)(CPUX86State *); +typedef KztGlibcLoaderHook *(*KztGlibcLoaderHookResolver)(void *); + +typedef struct KztGlibcLoaderEventSource { + const char *name; + KztGlibcLoaderHook *hook; + int hook_resolved; + const char *loader_path; + abi_ulong loader_load_bias; + KztTbCallback callback; + KztGlibcLoaderHookResolver resolve_hook; +} KztGlibcLoaderEventSource; + +typedef struct KztRDebug { + int r_version; + struct link_map_x64 *r_map; + Elf64_Addr r_brk; + int r_state; + Elf64_Addr r_ldbase; +} KztRDebug; + +typedef struct KztRDebugEventSource { + const char *name; + uintptr_t addr; +} KztRDebugEventSource; + +#define KZT_R_DEBUG_VERSION 1 +#define KZT_RT_CONSISTENT 0 +#define KZT_RT_ADD 1 +#define KZT_RT_DELETE 2 + +typedef struct KztTbCallbackBridge { + uintptr_t addr; + KztTbCallback callback; +} KztTbCallbackBridge; + +typedef struct KztGlibcLoaderHookCandidate { + uintptr_t offset; + uint64_t value; + const char *glibc_version; +} KztGlibcLoaderHookCandidate; + +typedef struct KztGlibcLoaderImage { + uint8_t *start; + size_t file_len; + char path[PATH_MAX]; + char glibc_version[16]; +} KztGlibcLoaderImage; + +#define KZT_GLIBC_LOADER_EVENT_SOURCE_NAME "glibc_loader_fallback" +#define KZT_R_DEBUG_EVENT_SOURCE_NAME "r_debug" + +static void kzt_glibc_loader_callback(CPUX86State *env); +static KztGlibcLoaderHook *kzt_find_glibc_loader_event_source_hook(void *info); +static void kzt_prepare_r_debug_event_source(char *file_name, + abi_ulong start); + +static KztGlibcLoaderEventSource kzt_glibc_loader_event_source = { + .name = KZT_GLIBC_LOADER_EVENT_SOURCE_NAME, + .callback = kzt_glibc_loader_callback, + .resolve_hook = kzt_find_glibc_loader_event_source_hook, +}; +static KztRDebugEventSource kzt_r_debug_event_source = { + .name = KZT_R_DEBUG_EVENT_SOURCE_NAME, }; -static struct x86_ld_info * ld_info = NULL; + +static KztGlibcLoaderEventSource *kzt_glibc_loader_event_source_default(void) +{ + return &kzt_glibc_loader_event_source; +} + +static KztRDebugEventSource *kzt_r_debug_event_source_default(void) +{ + return &kzt_r_debug_event_source; +} + +static const char *kzt_glibc_loader_event_source_name( + KztGlibcLoaderEventSource *source) +{ + if (!source || !source->name) + return KZT_GLIBC_LOADER_EVENT_SOURCE_NAME; + return source->name; +} + +static KztGlibcLoaderHook *kzt_glibc_loader_event_source_hook( + KztGlibcLoaderEventSource *source) +{ + return source ? source->hook : NULL; +} + +static void kzt_glibc_loader_event_source_set_hook( + KztGlibcLoaderEventSource *source, + KztGlibcLoaderHook *hook) +{ + lsassert(source); + source->hook = hook; +} + +static void kzt_glibc_loader_event_source_prepare( + KztGlibcLoaderEventSource *source, + struct image_info *execinfo) +{ + if (!source || !execinfo) + return; + + if (source->loader_path == execinfo->interpreter_path + && source->loader_load_bias == execinfo->load_bias) { + return; + } + + free(source->hook); + source->hook = NULL; + source->hook_resolved = 0; + source->loader_path = execinfo->interpreter_path; + source->loader_load_bias = execinfo->load_bias; +} + +static KztTbCallback kzt_glibc_loader_event_source_callback( + KztGlibcLoaderEventSource *source) +{ + if (!source) + return NULL; + + KztTbCallback callback = source->callback; + + return callback; +} + +static KztGlibcLoaderHookResolver +kzt_glibc_loader_event_source_hook_resolver( + KztGlibcLoaderEventSource *source) +{ + if (!source) + return NULL; + + KztGlibcLoaderHookResolver resolver = source->resolve_hook; + + return resolver; +} + +static uintptr_t kzt_glibc_loader_event_source_hook_addr( + KztGlibcLoaderEventSource *source) +{ + KztGlibcLoaderHook *hook = kzt_glibc_loader_event_source_hook(source); + + return hook ? hook->addr : 0; +} + extern void* x86free; extern void* x86realloc; extern void* x86pthread_setcanceltype; @@ -2161,7 +2331,7 @@ int collectX86free(elfheader_t* h) /* * If the plt of this elf file has free, __libc_free, __free jump_slot, this jump_slot will be rewrited by kzt bridge, a moment later. * So this file should be skiped. If do not do this, when x86free be called, Target exe will fall into dead loop. - */ + */ cnt = h->pltsz / h->pltent; rela = (Elf64_Rela *)(h->jmprel + h->delta); for (int i=0; iregs[R_EAX + ld_info->reg]; - elfheader_t *h = NULL; - if ((!my_lm ||!my_lm->l_name ||!strlen(my_lm->l_name) || ! my_lm->l_addr)&& my_lm->l_addr != info1.load_addr) { - printf_log(LOG_DEBUG, "error %d debug %s link_map = %p{0x%lx, %s}\n", getpid(), __func__, my_lm, my_lm->l_addr, my_lm->l_name); - return; - } - printf_log(LOG_DEBUG, "%d debug %s link_map = %p{0x%lx, %s}\n", getpid(), __func__, my_lm, my_lm->l_addr, my_lm->l_name); - char * rfilename = my_lm->l_name; - if (strstr(basename(rfilename), "ld-linux-x86-64.so.2")) { - AddDebugInfo(LIB_EMULATED, my_lm->l_name, my_lm->l_map_start, my_lm->l_map_end); - return; + const char *basename = strrchr(path, '/'); + return basename ? basename + 1 : path; +} + +typedef struct KztGuestObject { + struct link_map_x64 *link_map; + const char *event_source; + uintptr_t load_bias; + uintptr_t dynamic_addr; + char *object_name; + char *filename; + const char *basename; + char filetmp[PATH_MAX]; + int is_loader; + uintptr_t map_start; + uintptr_t map_end; + KztDynamicView dynamic_view; + KztDynamicInfo dynamic_info; + int has_dynamic_info; + guest_object_observation_t observation; +} KztGuestObject; + +/* + * Stage 8 keeps the private glibc hook as an event source first. Everything + * below this structure should be reusable when the source becomes r_debug, + * mmap/RELRO observation, or another loader notification path. + */ +typedef struct KztLoaderEvent { + const char *source; + struct link_map_x64 *link_map; + uintptr_t load_bias; + uintptr_t dynamic_addr; + char *object_name; + char object_name_snapshot[PATH_MAX]; +} KztLoaderEvent; + +static const char *kzt_loader_event_name(const char *source) +{ + return source ? source : KZT_GLIBC_LOADER_EVENT_SOURCE_NAME; +} + +static int kzt_guest_range_is_readable(const void *addr, size_t size) +{ + if (!addr) + return 0; + + return access_ok_untagged(VERIFY_READ, (abi_ulong)(uintptr_t)addr, size); +} + +static int kzt_guest_dynamic_range_is_readable(const void *addr, size_t size, + void *opaque) +{ + (void)opaque; + return kzt_guest_range_is_readable(addr, size); +} + +static int kzt_guest_cstring_start_is_readable(const char *addr) +{ + return kzt_guest_range_is_readable(addr, 1); +} + +static int kzt_guest_cstring_snapshot(const char *addr, char *snapshot, + size_t snapshot_size, + const char *source) +{ + if (!addr || !snapshot_size) + return 0; + + ssize_t len = target_strlen((abi_ulong)(uintptr_t)addr); + if (len < 0 || (size_t)len >= snapshot_size) { + printf_log(LOG_DEBUG, + "error %d debug %s string %p is not readable\n", + getpid(), kzt_loader_event_name(source), addr); + return 0; } - char filetmp[PATH_MAX] = {0}; - if (rfilename[0] == '/') { - rfilename = kzt_find_realsofilepath(rfilename, filetmp); + + memcpy(snapshot, addr, (size_t)len + 1); + return 1; +} + +static int kzt_host_cstring_snapshot(const char *addr, char *snapshot, + size_t snapshot_size) +{ + if (!addr || !snapshot_size) + return 0; + + size_t len = strnlen(addr, snapshot_size); + if (len >= snapshot_size) + return 0; + + memcpy(snapshot, addr, len + 1); + return 1; +} + +static int kzt_guest_link_map_is_readable(struct link_map_x64 *link_map, + const char *source) +{ + if (kzt_guest_range_is_readable(link_map, sizeof(*link_map))) + return 1; + + printf_log(LOG_DEBUG, + "error %d debug %s link_map = %p is not readable\n", + getpid(), kzt_loader_event_name(source), link_map); + return 0; +} + +static int kzt_loader_link_map_is_valid(struct link_map_x64 *link_map, + const char *source) +{ + if (!link_map) { + printf_log(LOG_DEBUG, "error %d debug %s link_map = NULL\n", + getpid(), kzt_loader_event_name(source)); + return 0; } - char * rbasename = basename(rfilename); - library_t* lib = NewLibrary(rbasename, my_context); - if (lib) { - const char* libs[] = {rbasename}; - AddNeededLib(my_context->maplib, &my_context->neededlibs, NULL, 0, 1, libs, 1, my_context); + if (!kzt_guest_link_map_is_readable(link_map, source)) + return 0; + if (!link_map->l_addr && link_map->l_addr != info1.load_addr) { + printf_log(LOG_DEBUG, + "error %d debug %s link_map = %p{0x%lx, %s}\n", + getpid(), kzt_loader_event_name(source), link_map, + link_map->l_addr, + link_map->l_name ? link_map->l_name : ""); + return 0; } - if (!lib && (!strncmp(rbasename, "libSDL", 6)||!strncmp(rbasename, "libCgGL.so", strlen("libCgGL.so")))) { - printf_log(LOG_DEBUG, "%s libSDL need libGL.so.1\n", __func__); - const char* libs[] = {"libGL.so.1"}; - AddNeededLib(my_context->maplib, &my_context->neededlibs, NULL, 0, 1, libs, 1, my_context); + return 1; +} + +static struct link_map_x64 *kzt_get_glibc_loader_link_map( + KztGlibcLoaderEventSource *source, + CPUX86State *env) +{ + if (!source || !env) { + printf_log(LOG_DEBUG, + "%s skip loader event: source=%p env=%p\n", + kzt_glibc_loader_event_source_name(source), source, env); + return NULL; } - FILE *f = fopen(rfilename, "rb"); - if(!f) { - printf_log(LOG_INFO, "%s Error: Cannot open \"%s\"\n", __func__, rfilename); - return; + + KztGlibcLoaderHook *hook = kzt_glibc_loader_event_source_hook(source); + int reg = hook ? R_EAX + hook->reg : -1; + + if (!hook || hook->reg < 0 || reg < 0 || reg >= CPU_NB_REGS) { + printf_log(LOG_DEBUG, + "%s skip loader event: env=%p hook=%p reg=%d index=%d\n", + kzt_glibc_loader_event_source_name(source), env, hook, + hook ? hook->reg : -1, reg); + return NULL; } - h = LoadAndCheckElfHeader(f, rfilename, 0); - ElfHeadReFix(h, my_lm->l_addr); - fclose(f); - collectX86free(h); - if(!x86free &&!strcmp(rbasename, libcName)) { - struct malloc_map * m = SearchMallocMap(my_context, (char *)libcName); - lsassert(m); - x86free = m->freep; - x86realloc = m->reallocp; + + return (struct link_map_x64 *)env->regs[reg]; +} + +static char *kzt_get_object_name(struct link_map_x64 *my_lm, + const char *source, + char *snapshot, size_t snapshot_size) +{ + char *object_name = my_lm->l_name; + + if (object_name && !kzt_guest_cstring_start_is_readable(object_name)) { + printf_log(LOG_DEBUG, + "error %d debug %s link_map = %p name %p is not readable\n", + getpid(), kzt_loader_event_name(source), my_lm, + object_name); + return NULL; } - if(!x86pthread_setcanceltype &&!strcmp(rbasename, libcName)) { - findx86pthread_setcanceltype(h); + + if (!object_name || !object_name[0]) { + if (my_lm->l_addr != info1.load_addr) { + printf_log(LOG_DEBUG, + "error %d debug %s link_map = %p has no name\n", + getpid(), kzt_loader_event_name(source), my_lm); + return NULL; + } + object_name = my_context->fullpath; + if ((!object_name || !object_name[0]) && my_context->argv) + object_name = my_context->argv[0]; + if (!object_name || !object_name[0]) { + printf_log(LOG_DEBUG, + "error %d debug %s main object has no filename\n", + getpid(), kzt_loader_event_name(source)); + return NULL; + } + if (!kzt_host_cstring_snapshot(object_name, snapshot, snapshot_size)) { + printf_log(LOG_DEBUG, + "error %d debug %s main object filename is too long\n", + getpid(), kzt_loader_event_name(source)); + return NULL; + } + return snapshot; } - AddElfHeader(my_context, h); - LoadNeededLibs(h, my_context->maplib, &my_context->neededlibs, NULL, 0, 0, my_context); - RelocateElf(my_context->maplib, NULL, 0, h); - RelocateElfPlt(my_context->maplib, NULL, 0, h); - if (lib) { - AddDebugInfo(LIB_WRAPPED, my_lm->l_name, my_lm->l_map_start, my_lm->l_map_end); - } else { - AddDebugInfo(LIB_EMULATED, my_lm->l_name, my_lm->l_map_start, my_lm->l_map_end); + if (!kzt_guest_cstring_snapshot(object_name, snapshot, snapshot_size, + source)) { + return NULL; } + return snapshot; } -static TranslationBlock* test_tb; -static void test_x86free(CPUX86State *env) + +static int kzt_capture_loader_event_from_link_map(const char *source, + struct link_map_x64 *link_map, + KztLoaderEvent *event) { - static int cnt; - static uintptr_t ptr; - static int has_found; - if (has_found) { - return; - } - if (!ptr) { - ptr = env->regs[R_EDI]; - } else if (ptr != env->regs[R_EDI]) { - //destroy callback - mmap_lock(); -#ifdef CONFIG_USER_ONLY - tb_phys_invalidate(test_tb, test_tb->itree.start); -#else - tb_phys_invalidate(test_tb, test_tb->page_addr[0]); -#endif - mmap_unlock(); - has_found = 1; - printf_log(LOG_DEBUG, "%s latx final find free=%p, realloc=%p\n", __func__, x86free, x86realloc); - return; - } + if (!kzt_loader_link_map_is_valid(link_map, source)) + return 0; - if (cnt > 0) { - for (int i = 0; i < my_context->mallocmapsize;i++) { - if (x86free == my_context->mallocmaps[i]->freep && i mallocmapsize -1) { - struct malloc_map * m = my_context->mallocmaps[i + 1]; - static uint32 test_ld [2] = {0}; - x86free = m->freep; - x86realloc = m->reallocp; - target_ulong eip = env->eip; - CPUState *cpu = env_cpu(env); - memset(&test_ld, 0, sizeof(test_ld)); - mmap_lock(); -#ifdef CONFIG_USER_ONLY - tb_phys_invalidate(test_tb, test_tb->itree.start); -#else - tb_phys_invalidate(test_tb, test_tb->page_addr[0]); -#endif + event->source = kzt_loader_event_name(source); + event->link_map = link_map; + event->object_name = kzt_get_object_name( + link_map, source, event->object_name_snapshot, + sizeof(event->object_name_snapshot)); + if (!event->object_name) + return 0; - mmap_unlock(); - printf_log(LOG_DEBUG, "%s latx try find free=%p, realloc=%p from %s\n", __func__, x86free, x86realloc, ((elfheader_t*)m->h)->path); - test_tb = kzt_add_fucn_by_addr((uint32 *)&test_ld, cpu, (uintptr_t)x86free, target_latx_ld_callback, test_x86free); - env->eip = eip; - cnt = 0; - return; - } + event->load_bias = link_map->l_addr; + event->dynamic_addr = (uintptr_t)link_map->l_ld; + return 1; +} + +static size_t kzt_guest_dynamic_readable_entries(KztGuestObject *object) +{ + if (!object->dynamic_addr) + return 0; + + Elf64_Dyn *dynamic = (Elf64_Dyn *)object->dynamic_addr; + for (size_t i = 0; i < KZT_DYNAMIC_SCAN_MAX; ++i) { + if (!kzt_guest_range_is_readable(dynamic + i, sizeof(*dynamic))) { + printf_log(LOG_DEBUG, + "%s Dynamic scan stopped for %s: entry %zu is not readable\n", + object->event_source, object->object_name, i); + return i; } + if (dynamic[i].d_tag == DT_NULL) + return i + 1; } - cnt++; + return KZT_DYNAMIC_SCAN_MAX; } -static inline gint tb_sort_cmp(const void *ap, const void *bp) + +static void kzt_parse_guest_object_dynamic(KztGuestObject *object) { - const struct malloc_map *a = *(const struct malloc_map **)ap; - const struct malloc_map *b = *(const struct malloc_map **)bp; - if (a->freep < b->freep) { - return 1; - } - return -1; + size_t readable_entries = kzt_guest_dynamic_readable_entries(object); + + KztParseDynamicView(&object->dynamic_view, + (Elf64_Dyn *)object->dynamic_addr, + readable_entries); + + if (object->dynamic_view.status != KZT_DYNAMIC_VIEW_READY) + return; + + KztBuildDynamicInfo(&object->dynamic_info, &object->dynamic_view); + KztDynamicInfoSetRangeValidator(&object->dynamic_info, + kzt_guest_dynamic_range_is_readable, + NULL); + KztResolveDynamicSymbolCount(&object->dynamic_info, + object->load_bias); + object->has_dynamic_info = 1; } -static void finiReFlesh(elfheader_t* exech) + +static uintptr_t kzt_guest_object_link_map_addr(KztGuestObject *object) { - CPUState *cpu; - static uint32 test_ld [2] = {0}; - lsassert(my_context->mallocmapsize); - struct malloc_map * m; + return (uintptr_t)object->link_map; +} - if (my_context->mallocmapsize == 1) { - m = my_context->mallocmaps[0]; - x86free = m->freep; - x86realloc = m->reallocp; +static guest_object_observation_t kzt_observe_guest_object( + KztGuestObject *object) +{ + return ObserveGuestObject(my_context->guest_objects, + kzt_guest_object_link_map_addr(object), + object->load_bias, + object->dynamic_addr, + object->object_name); +} + +static void kzt_log_guest_object_observation( + KztGuestObject *object, + guest_object_observation_t observation) +{ + if (observation != GUEST_OBJECT_OBSERVE_NEW + && observation != GUEST_OBJECT_OBSERVE_CHANGED) { return; } - /* For select x86free, x86realloc from my_context->mallocmaps - * Sort in descending order for freep. - * Because: - * When an executable program depends on multiple libraries and - * all of them provide symbols with the same name (such as free functions), - * the dynamic linker will parse the symbols according to the loading order of the libraries. - * The symbols defined in the first loaded library have higher priority. - */ - if (my_context->mallocmaps[0]->h == my_context->elfs[0]) {//elf[0] is exe file - if (my_context->mallocmapsize > 2) { - qsort(my_context->mallocmaps[1], my_context->mallocmapsize - 1, sizeof(struct malloc_map *), tb_sort_cmp); - } - } else { - qsort(my_context->mallocmaps, my_context->mallocmapsize, sizeof(struct malloc_map *), tb_sort_cmp); - } - m = my_context->mallocmaps[0]; - x86free = m->freep; - x86realloc = m->reallocp; - CPU_FOREACH(cpu) { - if (cpu) { - break; - } + + printf_log(LOG_DEBUG, + "%s guest object %s: map=%p bias=0x%lx dynamic=%p name=%s\n", + object->event_source, + observation == GUEST_OBJECT_OBSERVE_NEW ? "discovered" + : "changed", + object->link_map, object->load_bias, + (void *)object->dynamic_addr, object->object_name); +} + +static int kzt_register_guest_object(KztGuestObject *object) +{ + printf_log(LOG_DEBUG, "%d debug %s link_map = %p{0x%lx, %s}\n", + getpid(), object->event_source, object->link_map, + object->load_bias, object->object_name); + + object->observation = kzt_observe_guest_object(object); + kzt_log_guest_object_observation(object, object->observation); + if (object->observation == GUEST_OBJECT_OBSERVE_INVALID) { + printf_log(LOG_DEBUG, + "%s skip guest object map=%p name=%s reason=registry\n", + object->event_source, object->link_map, + object->object_name); + return 0; } - CPUArchState *env = cpu->env_ptr; - target_ulong eip = env->eip; - test_tb = kzt_add_fucn_by_addr((uint32 *)&test_ld, cpu, (uintptr_t)x86free, target_latx_ld_callback, test_x86free); - env->eip = eip; - printf_log(LOG_DEBUG, "%s latx try find free=%p, realloc=%p from %s\n", __func__, x86free, x86realloc, ((elfheader_t*)m->h)->path); + + kzt_parse_guest_object_dynamic(object); + return 1; } -static void kzt_exectb_callback(CPUX86State *env) + +static void kzt_guest_object_from_loader_event(const KztLoaderEvent *event, + KztGuestObject *object) { + object->event_source = event->source; + object->link_map = event->link_map; + object->load_bias = event->load_bias; + object->dynamic_addr = event->dynamic_addr; + object->object_name = event->object_name; +} + +static int kzt_begin_legacy_guest_object_processing(KztGuestObject *object) +{ + guest_object_process_result_t processing = BeginGuestObjectProcessing( + my_context->guest_objects, kzt_guest_object_link_map_addr(object)); + if (processing == GUEST_OBJECT_PROCESS_IN_PROGRESS) { + printf_log(LOG_DEBUG, + "%s skip guest object map=%p name=%s reason=processing\n", + object->event_source, object->link_map, + object->object_name); + return 0; + } + if (processing == GUEST_OBJECT_PROCESS_DONE) { + printf_log(LOG_DEBUG, + "%s skip guest object map=%p name=%s reason=done\n", + object->event_source, object->link_map, + object->object_name); + return 0; + } + if (processing == GUEST_OBJECT_PROCESS_INVALID) + printf_log(LOG_DEBUG, "%s guest object registry unavailable\n", + object->event_source); + return 1; +} + +static int kzt_set_guest_object_state(KztGuestObject *object, + guest_object_state_t state) +{ + return SetGuestObjectState(my_context->guest_objects, + kzt_guest_object_link_map_addr(object), state); +} + +static void kzt_mark_guest_elf_unavailable(KztGuestObject *object) +{ + kzt_set_guest_object_state(object, + object->is_loader ? GUEST_OBJECT_EMULATED + : GUEST_OBJECT_FAILED); +} + +static void kzt_resolve_guest_object_path(KztGuestObject *object) +{ + object->filename = object->object_name; + if (object->filename[0] == '/') { + object->filename = + kzt_find_realsofilepath(object->filename, object->filetmp); + } + object->basename = kzt_object_basename(object->filename); + object->is_loader = + strstr(object->basename, "ld-linux-x86-64.so.2") != NULL; +} + +static elfheader_t *kzt_open_guest_elf(KztGuestObject *object) +{ + FILE *f = fopen(object->filename, "rb"); + if (!f) { + printf_log(LOG_INFO, "%s Error: Cannot open \"%s\"\n", + object->event_source, object->filename); + kzt_mark_guest_elf_unavailable(object); + return NULL; + } + + elfheader_t *h = LoadAndCheckElfHeader(f, object->filename, 0); + if (!h) { + printf_log(LOG_INFO, "%s Error: Cannot parse ELF header for \"%s\"\n", + object->event_source, object->filename); + fclose(f); + kzt_mark_guest_elf_unavailable(object); + return NULL; + } + fclose(f); + return h; +} + +static int kzt_dynamic_ptr_matches(uintptr_t old_value, uintptr_t new_value, + uintptr_t load_bias) +{ + if (old_value == new_value) + return 1; + if (load_bias && old_value && old_value <= UINTPTR_MAX - load_bias + && old_value + load_bias == new_value) + return 1; + if (load_bias && new_value >= load_bias + && new_value - load_bias == old_value) + return 1; + return 0; +} + +static __thread const char *kzt_dynamic_compare_source; + +static const char *kzt_dynamic_compare_log_source(void) +{ + return kzt_dynamic_compare_source + ? kzt_dynamic_compare_source + : KZT_GLIBC_LOADER_EVENT_SOURCE_NAME; +} + +static const char *kzt_dynamic_compare_push_source(const char *source) +{ + const char *previous = kzt_dynamic_compare_source; + + kzt_dynamic_compare_source = source ? source + : KZT_GLIBC_LOADER_EVENT_SOURCE_NAME; + return previous; +} + +static void kzt_dynamic_compare_pop_source(const char *previous) +{ + kzt_dynamic_compare_source = previous; +} + +static int kzt_dynamic_note_size_mismatch(const char *name, size_t old_value, + size_t new_value) +{ + if (old_value == new_value) + return 0; + + printf_log(LOG_INFO, + "%s Dynamic mismatch %s: old=0x%zx new=0x%zx\n", + kzt_dynamic_compare_log_source(), name, old_value, new_value); + return 1; +} + +static int kzt_dynamic_note_ptr_mismatch(const char *name, uintptr_t old_value, + uintptr_t new_value, + uintptr_t load_bias) +{ + if (kzt_dynamic_ptr_matches(old_value, new_value, load_bias)) + return 0; + + printf_log(LOG_INFO, + "%s Dynamic mismatch %s: old=0x%lx new=0x%lx bias=0x%lx\n", + kzt_dynamic_compare_log_source(), name, old_value, new_value, + load_bias); + return 1; +} + +static int kzt_dynamic_note_error_mismatch(const char *name, + unsigned old_errors, + unsigned new_errors) +{ + if (old_errors == new_errors) + return 0; + + printf_log(LOG_INFO, + "%s Dynamic mismatch %s: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), name, old_errors, new_errors); + return 1; +} + +#define KZT_DYNAMIC_SYMBOL_MISMATCH_LOG_LIMIT 32 + +static int kzt_compare_dynamic_string_tag(const char *name, int tag, + KztDynamicView *old_view, + KztDynamicStringTable *old_strtab, + KztDynamicView *new_view, + KztDynamicStringTable *new_strtab) +{ + size_t new_index = 0; + int mismatches = 0; + + for (size_t old_index = 0; old_index < old_view->entry_count;) { + KztDynamicStringEntry old_entry; + KztDynamicStringEntry new_entry; + + if (!KztNextDynamicString(old_view, tag, &old_index, old_strtab, + &old_entry)) + break; + + if (!KztNextDynamicString(new_view, tag, &new_index, new_strtab, + &new_entry)) { + printf_log(LOG_INFO, + "%s Dynamic mismatch %s: missing new entry for old offset=0x%lx\n", + kzt_dynamic_compare_log_source(), name, old_entry.offset); + ++mismatches; + continue; + } + + if (!old_entry.value || !new_entry.value) { + printf_log(LOG_INFO, + "%s Dynamic mismatch %s: invalid string offset old=0x%lx new=0x%lx\n", + kzt_dynamic_compare_log_source(), name, old_entry.offset, + new_entry.offset); + ++mismatches; + continue; + } + if (strcmp(old_entry.value, new_entry.value)) { + printf_log(LOG_INFO, + "%s Dynamic mismatch %s: old=\"%s\" new=\"%s\"\n", + kzt_dynamic_compare_log_source(), name, old_entry.value, + new_entry.value); + ++mismatches; + } + } + + return mismatches; +} + +static int kzt_note_dynamic_symbol_mismatch(const char *name, size_t index, + int *mismatches) +{ + ++*mismatches; + if (*mismatches == KZT_DYNAMIC_SYMBOL_MISMATCH_LOG_LIMIT) { + printf_log(LOG_INFO, + "%s Dynamic symbol compare reached mismatch log limit at %s[%zu]\n", + kzt_dynamic_compare_log_source(), name, index); + } + return *mismatches >= KZT_DYNAMIC_SYMBOL_MISMATCH_LOG_LIMIT; +} + +static int kzt_compare_dynamic_symbols(elfheader_t *h, + KztDynamicInfo *old_info, + KztDynamicInfo *new_info, + uintptr_t load_bias) +{ + KztDynamicSymbolTable old_symbols = { + .symbols = h->DynSym, + .count = old_info->dynsym_count, + .strings = { + .data = h->DynStr, + .size = h->szDynStrTab, + }, + }; + KztDynamicSymbolTable new_symbols; + int has_new_symbols = + KztDynamicSymbolTableFromInfo(new_info, load_bias, &new_symbols); + size_t count = old_symbols.count < new_symbols.count + ? old_symbols.count + : new_symbols.count; + int mismatches = 0; + + if (!old_info->has_dynsym_count || !new_info->has_dynsym_count + || !old_symbols.symbols || !has_new_symbols + || !old_symbols.strings.data || !new_symbols.strings.data) { + printf_log(LOG_INFO, + "%s Dynamic symbol compare skipped: old_symbols=%p old_count=%zu new_symbols=%p new_count=%zu\n", + kzt_dynamic_compare_log_source(), + old_symbols.symbols, old_symbols.count, + new_symbols.symbols, new_symbols.count); + return 0; + } + + for (size_t i = 0; i < count; ++i) { + KztDynamicSymbolEntry old_entry; + KztDynamicSymbolEntry new_entry; + + if (!KztDynamicSymbolAt(&old_symbols, i, &old_entry) + || !KztDynamicSymbolAt(&new_symbols, i, &new_entry)) { + printf_log(LOG_INFO, + "%s Dynamic symbol mismatch entry[%zu]: missing symbol\n", + kzt_dynamic_compare_log_source(), i); + if (kzt_note_dynamic_symbol_mismatch("entry", i, &mismatches)) + break; + continue; + } + + if (!old_entry.name || !new_entry.name) { + printf_log(LOG_INFO, + "%s Dynamic symbol mismatch name[%zu]: old_off=0x%x new_off=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_entry.symbol->st_name, + new_entry.symbol->st_name); + if (kzt_note_dynamic_symbol_mismatch("name", i, &mismatches)) + break; + continue; + } + + if (strcmp(old_entry.name, new_entry.name)) { + printf_log(LOG_INFO, + "%s Dynamic symbol mismatch name[%zu]: old=\"%s\" new=\"%s\"\n", + kzt_dynamic_compare_log_source(), i, old_entry.name, + new_entry.name); + if (kzt_note_dynamic_symbol_mismatch("name", i, &mismatches)) + break; + } + if (old_entry.symbol->st_info != new_entry.symbol->st_info) { + printf_log(LOG_INFO, + "%s Dynamic symbol mismatch info[%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_entry.symbol->st_info, + new_entry.symbol->st_info); + if (kzt_note_dynamic_symbol_mismatch("info", i, &mismatches)) + break; + } + if (old_entry.symbol->st_other != new_entry.symbol->st_other) { + printf_log(LOG_INFO, + "%s Dynamic symbol mismatch other[%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_entry.symbol->st_other, + new_entry.symbol->st_other); + if (kzt_note_dynamic_symbol_mismatch("other", i, &mismatches)) + break; + } + if (old_entry.symbol->st_shndx != new_entry.symbol->st_shndx) { + printf_log(LOG_INFO, + "%s Dynamic symbol mismatch shndx[%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_entry.symbol->st_shndx, + new_entry.symbol->st_shndx); + if (kzt_note_dynamic_symbol_mismatch("shndx", i, &mismatches)) + break; + } + if (!kzt_dynamic_ptr_matches(old_entry.symbol->st_value, + new_entry.symbol->st_value, + load_bias)) { + printf_log(LOG_INFO, + "%s Dynamic symbol mismatch value[%zu]: old=0x%lx new=0x%lx bias=0x%lx\n", + kzt_dynamic_compare_log_source(), i, old_entry.symbol->st_value, + new_entry.symbol->st_value, load_bias); + if (kzt_note_dynamic_symbol_mismatch("value", i, &mismatches)) + break; + } + if (old_entry.symbol->st_size != new_entry.symbol->st_size) { + printf_log(LOG_INFO, + "%s Dynamic symbol mismatch size[%zu]: old=0x%lx new=0x%lx\n", + kzt_dynamic_compare_log_source(), i, old_entry.symbol->st_size, + new_entry.symbol->st_size); + if (kzt_note_dynamic_symbol_mismatch("size", i, &mismatches)) + break; + } + } + + return mismatches; +} + +static int kzt_note_dynamic_relocation_mismatch(const char *name, + size_t index, + int *mismatches) +{ + ++*mismatches; + if (*mismatches == KZT_DYNAMIC_SYMBOL_MISMATCH_LOG_LIMIT) { + printf_log(LOG_INFO, + "%s Dynamic relocation compare reached mismatch log limit at %s[%zu]\n", + kzt_dynamic_compare_log_source(), name, index); + } + return *mismatches >= KZT_DYNAMIC_SYMBOL_MISMATCH_LOG_LIMIT; +} + +static int kzt_compare_dynamic_relocation_table(const char *name, + KztDynamicInfo *new_info, + uintptr_t old_ptr, + int old_entry_size, + size_t old_count, + uintptr_t new_ptr, + int new_entry_size, + size_t new_count, + uintptr_t load_bias) +{ + KztDynamicRelocationTable old_table = { + .entries = KztDynamicRelocationsFromPtr(old_ptr, load_bias), + .count = old_count, + .entry_size = old_entry_size, + }; + KztDynamicRelocationTable new_table = { + .entries = KztDynamicRelocationsFromInfo( + new_info, new_ptr, load_bias, new_count, new_entry_size), + .count = new_count, + .entry_size = new_entry_size, + }; + size_t count = old_count < new_count ? old_count : new_count; + int mismatches = 0; + + if (!count) + return 0; + + if (old_entry_size != new_entry_size) { + printf_log(LOG_INFO, + "%s Dynamic relocation compare skipped %s: old_entry=0x%x new_entry=0x%x\n", + kzt_dynamic_compare_log_source(), name, old_entry_size, + new_entry_size); + return 0; + } + + if (!old_table.entries || !new_table.entries) { + printf_log(LOG_INFO, + "%s Dynamic relocation compare skipped %s: old=%p new=%p old_count=%zu new_count=%zu\n", + kzt_dynamic_compare_log_source(), name, old_table.entries, + new_table.entries, old_count, new_count); + return 0; + } + + for (size_t i = 0; i < count; ++i) { + KztDynamicRelocationEntry old_entry; + KztDynamicRelocationEntry new_entry; + + if (!KztDynamicRelocationAt(&old_table, i, &old_entry) + || !KztDynamicRelocationAt(&new_table, i, &new_entry)) { + printf_log(LOG_INFO, + "%s Dynamic relocation mismatch %s[%zu]: missing entry\n", + kzt_dynamic_compare_log_source(), name, i); + if (kzt_note_dynamic_relocation_mismatch(name, i, + &mismatches)) + break; + continue; + } + + if (!kzt_dynamic_ptr_matches(old_entry.offset, new_entry.offset, + load_bias)) { + printf_log(LOG_INFO, + "%s Dynamic relocation mismatch %s[%zu].offset: old=0x%lx new=0x%lx bias=0x%lx\n", + kzt_dynamic_compare_log_source(), name, i, old_entry.offset, + new_entry.offset, load_bias); + if (kzt_note_dynamic_relocation_mismatch(name, i, + &mismatches)) + break; + } + if (old_entry.info != new_entry.info) { + printf_log(LOG_INFO, + "%s Dynamic relocation mismatch %s[%zu].info: old=0x%lx new=0x%lx\n", + kzt_dynamic_compare_log_source(), name, i, + (unsigned long)old_entry.info, + (unsigned long)new_entry.info); + if (kzt_note_dynamic_relocation_mismatch(name, i, + &mismatches)) + break; + } + if (old_entry.has_addend != new_entry.has_addend) { + printf_log(LOG_INFO, + "%s Dynamic relocation mismatch %s[%zu].addend-kind: old=%d new=%d\n", + kzt_dynamic_compare_log_source(), name, i, old_entry.has_addend, + new_entry.has_addend); + if (kzt_note_dynamic_relocation_mismatch(name, i, + &mismatches)) + break; + } + if (old_entry.has_addend && new_entry.has_addend + && old_entry.addend != new_entry.addend) { + printf_log(LOG_INFO, + "%s Dynamic relocation mismatch %s[%zu].addend: old=0x%lx new=0x%lx\n", + kzt_dynamic_compare_log_source(), name, i, + (unsigned long)old_entry.addend, + (unsigned long)new_entry.addend); + if (kzt_note_dynamic_relocation_mismatch(name, i, + &mismatches)) + break; + } + } + + return mismatches; +} + +static int kzt_compare_dynamic_relocations(KztDynamicInfo *old_info, + KztDynamicInfo *new_info, + uintptr_t load_bias) +{ + int mismatches = 0; + + if (old_info->has_rel_count && new_info->has_rel_count) { + mismatches += kzt_compare_dynamic_relocation_table( + "DT_REL", new_info, old_info->rel, old_info->relent, + old_info->rel_count, new_info->rel, new_info->relent, + new_info->rel_count, load_bias); + } + + if (old_info->has_rela_count && new_info->has_rela_count) { + mismatches += kzt_compare_dynamic_relocation_table( + "DT_RELA", new_info, old_info->rela, old_info->relaent, + old_info->rela_count, new_info->rela, new_info->relaent, + new_info->rela_count, load_bias); + } + + if (old_info->has_plt_count && new_info->has_plt_count) { + mismatches += kzt_compare_dynamic_relocation_table( + "DT_JMPREL", new_info, old_info->jmprel, old_info->pltent, + old_info->plt_count, new_info->jmprel, new_info->pltent, + new_info->plt_count, load_bias); + } + + return mismatches; +} + +static int kzt_compare_dynamic_versym(elfheader_t *h, + KztDynamicInfo *old_info, + KztDynamicInfo *new_info, + uintptr_t load_bias) +{ + const Elf64_Half *old_versym = + KztDynamicVersymFromPtr((uintptr_t)h->VerSym, load_bias); + const Elf64_Half *new_versym = + KztDynamicVersymFromInfo(new_info, load_bias); + size_t count = old_info->dynsym_count < new_info->dynsym_count + ? old_info->dynsym_count + : new_info->dynsym_count; + int mismatches = 0; + + if (!old_info->has_dynsym_count || !new_info->has_dynsym_count + || !old_versym || !new_versym) { + printf_log(LOG_INFO, + "%s Dynamic versym compare skipped: old=%p new=%p old_count=%zu new_count=%zu\n", + kzt_dynamic_compare_log_source(), old_versym, new_versym, + old_info->dynsym_count, new_info->dynsym_count); + return 0; + } + + for (size_t i = 0; i < count; ++i) { + if (old_versym[i] == new_versym[i]) + continue; + + printf_log(LOG_INFO, + "%s Dynamic versym mismatch[%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_versym[i], + new_versym[i]); + if (kzt_note_dynamic_symbol_mismatch("versym", i, &mismatches)) + break; + } + + return mismatches; +} + +static int kzt_compare_dynamic_verneed(elfheader_t *h, + KztDynamicInfo *old_info, + KztDynamicInfo *new_info, + uintptr_t load_bias) +{ + const Elf64_Verneed *old_base = + KztDynamicVerneedFromPtr((uintptr_t)h->VerNeed, load_bias); + const Elf64_Verneed *new_base = + KztDynamicVerneedFromInfo(new_info, load_bias); + KztDynamicStringTable old_strtab = { + .data = h->DynStr, + .size = h->szDynStrTab, + }; + KztDynamicStringTable new_strtab; + size_t old_count = old_info->verneed_count > 0 + ? (size_t)old_info->verneed_count + : 0; + size_t new_count = new_info->verneed_count > 0 + ? (size_t)new_info->verneed_count + : 0; + size_t count = old_count < new_count ? old_count : new_count; + int mismatches = 0; + + KztDynamicStringTableFromInfo(new_info, load_bias, &new_strtab); + + if (!old_base || !new_base || !old_strtab.data || !new_strtab.data) { + printf_log(LOG_INFO, + "%s Dynamic verneed compare skipped: old=%p new=%p old_count=%zu new_count=%zu\n", + kzt_dynamic_compare_log_source(), old_base, new_base, old_count, + new_count); + return 0; + } + + for (size_t i = 0; i < count; ++i) { + KztDynamicVerneedEntry old_need; + KztDynamicVerneedEntry new_need; + size_t aux_count; + + if (!KztDynamicVerneedAt(old_base, i, &old_strtab, &old_need) + || !KztDynamicVerneedAtFromInfo(new_info, new_base, i, + &new_strtab, &new_need)) { + printf_log(LOG_INFO, + "%s Dynamic verneed mismatch entry[%zu]: missing record\n", + kzt_dynamic_compare_log_source(), i); + if (kzt_note_dynamic_symbol_mismatch("verneed", i, + &mismatches)) + break; + continue; + } + + if (!old_need.file || !new_need.file + || strcmp(old_need.file, new_need.file)) { + printf_log(LOG_INFO, + "%s Dynamic verneed mismatch file[%zu]: old=\"%s\" new=\"%s\"\n", + kzt_dynamic_compare_log_source(), i, + old_need.file ? old_need.file : "", + new_need.file ? new_need.file : ""); + if (kzt_note_dynamic_symbol_mismatch("verneed-file", i, + &mismatches)) + break; + } + if (old_need.record->vn_version != new_need.record->vn_version) { + printf_log(LOG_INFO, + "%s Dynamic verneed mismatch version[%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_need.record->vn_version, + new_need.record->vn_version); + if (kzt_note_dynamic_symbol_mismatch("verneed-version", i, + &mismatches)) + break; + } + if (old_need.record->vn_cnt != new_need.record->vn_cnt) { + printf_log(LOG_INFO, + "%s Dynamic verneed mismatch aux-count[%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_need.record->vn_cnt, + new_need.record->vn_cnt); + if (kzt_note_dynamic_symbol_mismatch("verneed-count", i, + &mismatches)) + break; + } + + aux_count = old_need.record->vn_cnt < new_need.record->vn_cnt + ? old_need.record->vn_cnt + : new_need.record->vn_cnt; + for (size_t j = 0; j < aux_count; ++j) { + KztDynamicVernauxEntry old_aux; + KztDynamicVernauxEntry new_aux; + + if (!KztDynamicVernauxAt(&old_need, j, &old_strtab, &old_aux) + || !KztDynamicVernauxAt(&new_need, j, &new_strtab, + &new_aux)) { + printf_log(LOG_INFO, + "%s Dynamic verneed mismatch aux[%zu:%zu]: missing record\n", + kzt_dynamic_compare_log_source(), i, j); + if (kzt_note_dynamic_symbol_mismatch("vernaux", i, + &mismatches)) + return mismatches; + continue; + } + + if (!old_aux.name || !new_aux.name + || strcmp(old_aux.name, new_aux.name)) { + printf_log(LOG_INFO, + "%s Dynamic verneed mismatch aux-name[%zu:%zu]: old=\"%s\" new=\"%s\"\n", + kzt_dynamic_compare_log_source(), i, j, + old_aux.name ? old_aux.name : "", + new_aux.name ? new_aux.name : ""); + if (kzt_note_dynamic_symbol_mismatch("vernaux-name", i, + &mismatches)) + return mismatches; + } + if (old_aux.record->vna_hash != new_aux.record->vna_hash) { + printf_log(LOG_INFO, + "%s Dynamic verneed mismatch aux-hash[%zu:%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, j, + old_aux.record->vna_hash, + new_aux.record->vna_hash); + if (kzt_note_dynamic_symbol_mismatch("vernaux-hash", i, + &mismatches)) + return mismatches; + } + if (old_aux.record->vna_flags != new_aux.record->vna_flags) { + printf_log(LOG_INFO, + "%s Dynamic verneed mismatch aux-flags[%zu:%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, j, + old_aux.record->vna_flags, + new_aux.record->vna_flags); + if (kzt_note_dynamic_symbol_mismatch("vernaux-flags", i, + &mismatches)) + return mismatches; + } + if (old_aux.record->vna_other != new_aux.record->vna_other) { + printf_log(LOG_INFO, + "%s Dynamic verneed mismatch aux-other[%zu:%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, j, + old_aux.record->vna_other, + new_aux.record->vna_other); + if (kzt_note_dynamic_symbol_mismatch("vernaux-other", i, + &mismatches)) + return mismatches; + } + } + } + + return mismatches; +} + +static int kzt_compare_dynamic_verdef(elfheader_t *h, + KztDynamicInfo *old_info, + KztDynamicInfo *new_info, + uintptr_t load_bias) +{ + const Elf64_Verdef *old_base = + KztDynamicVerdefFromPtr((uintptr_t)h->VerDef, load_bias); + const Elf64_Verdef *new_base = + KztDynamicVerdefFromInfo(new_info, load_bias); + KztDynamicStringTable old_strtab = { + .data = h->DynStr, + .size = h->szDynStrTab, + }; + KztDynamicStringTable new_strtab; + size_t old_count = old_info->verdef_count > 0 + ? (size_t)old_info->verdef_count + : 0; + size_t new_count = new_info->verdef_count > 0 + ? (size_t)new_info->verdef_count + : 0; + size_t count = old_count < new_count ? old_count : new_count; + int mismatches = 0; + + KztDynamicStringTableFromInfo(new_info, load_bias, &new_strtab); + + if (!old_base || !new_base || !old_strtab.data || !new_strtab.data) { + printf_log(LOG_INFO, + "%s Dynamic verdef compare skipped: old=%p new=%p old_count=%zu new_count=%zu\n", + kzt_dynamic_compare_log_source(), old_base, new_base, old_count, + new_count); + return 0; + } + + for (size_t i = 0; i < count; ++i) { + KztDynamicVerdefEntry old_def; + KztDynamicVerdefEntry new_def; + size_t aux_count; + + if (!KztDynamicVerdefAt(old_base, i, &old_def) + || !KztDynamicVerdefAtFromInfo(new_info, new_base, i, + &new_def)) { + printf_log(LOG_INFO, + "%s Dynamic verdef mismatch entry[%zu]: missing record\n", + kzt_dynamic_compare_log_source(), i); + if (kzt_note_dynamic_symbol_mismatch("verdef", i, + &mismatches)) + break; + continue; + } + + if (old_def.record->vd_version != new_def.record->vd_version) { + printf_log(LOG_INFO, + "%s Dynamic verdef mismatch version[%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_def.record->vd_version, + new_def.record->vd_version); + if (kzt_note_dynamic_symbol_mismatch("verdef-version", i, + &mismatches)) + break; + } + if (old_def.record->vd_flags != new_def.record->vd_flags) { + printf_log(LOG_INFO, + "%s Dynamic verdef mismatch flags[%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_def.record->vd_flags, + new_def.record->vd_flags); + if (kzt_note_dynamic_symbol_mismatch("verdef-flags", i, + &mismatches)) + break; + } + if (old_def.record->vd_ndx != new_def.record->vd_ndx) { + printf_log(LOG_INFO, + "%s Dynamic verdef mismatch index[%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_def.record->vd_ndx, + new_def.record->vd_ndx); + if (kzt_note_dynamic_symbol_mismatch("verdef-index", i, + &mismatches)) + break; + } + if (old_def.record->vd_cnt != new_def.record->vd_cnt) { + printf_log(LOG_INFO, + "%s Dynamic verdef mismatch aux-count[%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_def.record->vd_cnt, + new_def.record->vd_cnt); + if (kzt_note_dynamic_symbol_mismatch("verdef-count", i, + &mismatches)) + break; + } + if (old_def.record->vd_hash != new_def.record->vd_hash) { + printf_log(LOG_INFO, + "%s Dynamic verdef mismatch hash[%zu]: old=0x%x new=0x%x\n", + kzt_dynamic_compare_log_source(), i, old_def.record->vd_hash, + new_def.record->vd_hash); + if (kzt_note_dynamic_symbol_mismatch("verdef-hash", i, + &mismatches)) + break; + } + + aux_count = old_def.record->vd_cnt < new_def.record->vd_cnt + ? old_def.record->vd_cnt + : new_def.record->vd_cnt; + for (size_t j = 0; j < aux_count; ++j) { + KztDynamicVerdauxEntry old_aux; + KztDynamicVerdauxEntry new_aux; + + if (!KztDynamicVerdauxAt(&old_def, j, &old_strtab, &old_aux) + || !KztDynamicVerdauxAt(&new_def, j, &new_strtab, + &new_aux)) { + printf_log(LOG_INFO, + "%s Dynamic verdef mismatch aux[%zu:%zu]: missing record\n", + kzt_dynamic_compare_log_source(), i, j); + if (kzt_note_dynamic_symbol_mismatch("verdaux", i, + &mismatches)) + return mismatches; + continue; + } + + if (!old_aux.name || !new_aux.name + || strcmp(old_aux.name, new_aux.name)) { + printf_log(LOG_INFO, + "%s Dynamic verdef mismatch aux-name[%zu:%zu]: old=\"%s\" new=\"%s\"\n", + kzt_dynamic_compare_log_source(), i, j, + old_aux.name ? old_aux.name : "", + new_aux.name ? new_aux.name : ""); + if (kzt_note_dynamic_symbol_mismatch("verdaux-name", i, + &mismatches)) + return mismatches; + } + } + } + + return mismatches; +} + +static int kzt_compare_dynamic_strings(elfheader_t *h, + KztDynamicView *old_view, + KztDynamicInfo *new_info, + KztDynamicView *new_view, + uintptr_t load_bias) +{ + KztDynamicStringTable old_strtab = { + .data = h->DynStr, + .size = h->szDynStrTab, + }; + KztDynamicStringTable new_strtab; + int mismatches = 0; + + KztDynamicStringTableFromInfo(new_info, load_bias, &new_strtab); + + if (!old_strtab.data || !old_strtab.size || !new_strtab.data + || !new_strtab.size) { + printf_log(LOG_INFO, + "%s Dynamic string compare skipped: old_strtab=%p old_size=0x%zx new_strtab=%p new_size=0x%zx\n", + kzt_dynamic_compare_log_source(), old_strtab.data, old_strtab.size, + new_strtab.data, new_strtab.size); + return 0; + } + + mismatches += kzt_compare_dynamic_string_tag( + "DT_NEEDED", DT_NEEDED, old_view, &old_strtab, new_view, + &new_strtab); + mismatches += kzt_compare_dynamic_string_tag( + "DT_RPATH", DT_RPATH, old_view, &old_strtab, new_view, &new_strtab); + mismatches += kzt_compare_dynamic_string_tag( + "DT_RUNPATH", DT_RUNPATH, old_view, &old_strtab, new_view, + &new_strtab); + + return mismatches; +} + +static void kzt_build_legacy_dynamic_info(KztDynamicInfo *info, + const KztDynamicView *view, + elfheader_t *h) +{ + KztBuildDynamicInfo(info, view); + info->dynsym_count = h->numDynSym; + info->has_dynsym_count = h->DynSym && h->numDynSym; +} + +static int kzt_compare_guest_dynamic_info(KztDynamicInfo *old_info, + KztDynamicInfo *new_info, + uintptr_t load_bias) +{ + int mismatches = 0; + + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_STRTAB", old_info->strtab, new_info->strtab, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "info.DT_STRSZ", old_info->strsz, new_info->strsz); + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_SYMTAB", old_info->symtab, new_info->symtab, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "info.dynsym_count_available", old_info->has_dynsym_count, + new_info->has_dynsym_count); + if (old_info->has_dynsym_count && new_info->has_dynsym_count) { + mismatches += kzt_dynamic_note_size_mismatch( + "info.dynsym_count", old_info->dynsym_count, + new_info->dynsym_count); + } + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_REL", old_info->rel, new_info->rel, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "info.DT_RELSZ", old_info->relsz, new_info->relsz); + mismatches += kzt_dynamic_note_size_mismatch( + "info.DT_RELENT", old_info->relent, new_info->relent); + mismatches += kzt_dynamic_note_size_mismatch( + "info.rel_count_available", old_info->has_rel_count, + new_info->has_rel_count); + if (old_info->has_rel_count && new_info->has_rel_count) { + mismatches += kzt_dynamic_note_size_mismatch( + "info.rel_count", old_info->rel_count, new_info->rel_count); + } + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_RELA", old_info->rela, new_info->rela, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "info.DT_RELASZ", old_info->relasz, new_info->relasz); + mismatches += kzt_dynamic_note_size_mismatch( + "info.DT_RELAENT", old_info->relaent, new_info->relaent); + mismatches += kzt_dynamic_note_size_mismatch( + "info.rela_count_available", old_info->has_rela_count, + new_info->has_rela_count); + if (old_info->has_rela_count && new_info->has_rela_count) { + mismatches += kzt_dynamic_note_size_mismatch( + "info.rela_count", old_info->rela_count, new_info->rela_count); + } + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_JMPREL", old_info->jmprel, new_info->jmprel, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "info.DT_PLTRELSZ", old_info->pltsz, new_info->pltsz); + mismatches += kzt_dynamic_note_size_mismatch( + "info.plt_entry", old_info->pltent, new_info->pltent); + mismatches += kzt_dynamic_note_size_mismatch( + "info.plt_count_available", old_info->has_plt_count, + new_info->has_plt_count); + if (old_info->has_plt_count && new_info->has_plt_count) { + mismatches += kzt_dynamic_note_size_mismatch( + "info.plt_count", old_info->plt_count, new_info->plt_count); + } + mismatches += kzt_dynamic_note_size_mismatch( + "info.DT_PLTREL", old_info->pltrel, new_info->pltrel); + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_PLTGOT", old_info->pltgot, new_info->pltgot, load_bias); + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_INIT", old_info->initentry, new_info->initentry, load_bias); + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_INIT_ARRAY", old_info->initarray, new_info->initarray, + load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "info.DT_INIT_ARRAYSZ", old_info->initarray_count, + new_info->initarray_count); + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_FINI", old_info->finientry, new_info->finientry, load_bias); + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_FINI_ARRAY", old_info->finiarray, new_info->finiarray, + load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "info.DT_FINI_ARRAYSZ", old_info->finiarray_count, + new_info->finiarray_count); + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_VERSYM", old_info->versym, new_info->versym, load_bias); + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_VERNEED", old_info->verneed, new_info->verneed, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "info.DT_VERNEEDNUM", old_info->verneed_count, + new_info->verneed_count); + mismatches += kzt_dynamic_note_ptr_mismatch( + "info.DT_VERDEF", old_info->verdef, new_info->verdef, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "info.DT_VERDEFNUM", old_info->verdef_count, + new_info->verdef_count); + mismatches += kzt_dynamic_note_error_mismatch( + "info.errors", old_info->errors, new_info->errors); + + return mismatches; +} + +static void kzt_compare_guest_dynamic(KztGuestObject *object, elfheader_t *h) +{ + KztDynamicView old_view; + KztDynamicInfo old_info; + KztDynamicSummary *old_dynamic = &old_view.summary; + KztDynamicView *new_view = &object->dynamic_view; + KztDynamicInfo *new_info = &object->dynamic_info; + KztDynamicSummary *new_dynamic = &new_view->summary; + uintptr_t load_bias = object->load_bias; + int mismatches = 0; + const char *previous_source = + kzt_dynamic_compare_push_source(object->event_source); + + KztParseDynamicView(&old_view, h->Dynamic, h->numDynamic); + + if (old_view.status == KZT_DYNAMIC_VIEW_EMPTY) { + printf_log(LOG_INFO, + "%s Dynamic compare skipped for \"%s\": old parser has no dynamic table\n", + kzt_dynamic_compare_log_source(), object->filename); + goto out; + } + if (new_view->status == KZT_DYNAMIC_VIEW_EMPTY) { + printf_log(LOG_INFO, + "%s Dynamic compare skipped for \"%s\": link_map has no l_ld\n", + kzt_dynamic_compare_log_source(), object->filename); + goto out; + } + if (new_view->status == KZT_DYNAMIC_VIEW_TRUNCATED) { + printf_log(LOG_INFO, + "%s Dynamic compare skipped for \"%s\": no DT_NULL within %d entries\n", + kzt_dynamic_compare_log_source(), object->filename, + KZT_DYNAMIC_SCAN_MAX); + goto out; + } + if (!object->has_dynamic_info) { + printf_log(LOG_INFO, + "%s Dynamic compare skipped for \"%s\": parser info is unavailable\n", + kzt_dynamic_compare_log_source(), object->filename); + goto out; + } + + mismatches += kzt_dynamic_note_size_mismatch( + "entries", old_dynamic->entries, new_dynamic->entries); + mismatches += kzt_dynamic_note_size_mismatch( + "needed_count", old_dynamic->needed_count, new_dynamic->needed_count); + mismatches += kzt_dynamic_note_size_mismatch( + "rpath_count", old_dynamic->rpath_count, new_dynamic->rpath_count); + mismatches += kzt_dynamic_note_size_mismatch( + "runpath_count", old_dynamic->runpath_count, new_dynamic->runpath_count); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_STRTAB", old_dynamic->strtab, new_dynamic->strtab, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_STRSZ", old_dynamic->strsz, new_dynamic->strsz); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_SYMTAB", old_dynamic->symtab, new_dynamic->symtab, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_SYMENT", old_dynamic->syment, new_dynamic->syment); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_HASH", old_dynamic->hash, new_dynamic->hash, load_bias); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_GNU_HASH", old_dynamic->gnu_hash, new_dynamic->gnu_hash, load_bias); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_REL", old_dynamic->rel, new_dynamic->rel, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_RELSZ", old_dynamic->relsz, new_dynamic->relsz); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_RELENT", old_dynamic->relent, new_dynamic->relent); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_RELA", old_dynamic->rela, new_dynamic->rela, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_RELASZ", old_dynamic->relasz, new_dynamic->relasz); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_RELAENT", old_dynamic->relaent, new_dynamic->relaent); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_JMPREL", old_dynamic->jmprel, new_dynamic->jmprel, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_PLTRELSZ", old_dynamic->pltrelsz, new_dynamic->pltrelsz); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_PLTREL", old_dynamic->pltrel, new_dynamic->pltrel); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_PLTGOT", old_dynamic->pltgot, new_dynamic->pltgot, load_bias); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_INIT", old_dynamic->init, new_dynamic->init, load_bias); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_INIT_ARRAY", old_dynamic->init_array, new_dynamic->init_array, + load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_INIT_ARRAYSZ", old_dynamic->init_arraysz, + new_dynamic->init_arraysz); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_FINI", old_dynamic->fini, new_dynamic->fini, load_bias); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_FINI_ARRAY", old_dynamic->fini_array, new_dynamic->fini_array, + load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_FINI_ARRAYSZ", old_dynamic->fini_arraysz, + new_dynamic->fini_arraysz); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_VERSYM", old_dynamic->versym, new_dynamic->versym, load_bias); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_VERNEED", old_dynamic->verneed, new_dynamic->verneed, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_VERNEEDNUM", old_dynamic->verneednum, new_dynamic->verneednum); + mismatches += kzt_dynamic_note_ptr_mismatch( + "DT_VERDEF", old_dynamic->verdef, new_dynamic->verdef, load_bias); + mismatches += kzt_dynamic_note_size_mismatch( + "DT_VERDEFNUM", old_dynamic->verdefnum, new_dynamic->verdefnum); + + kzt_build_legacy_dynamic_info(&old_info, &old_view, h); + mismatches += kzt_compare_guest_dynamic_info(&old_info, new_info, + load_bias); + mismatches += kzt_compare_dynamic_strings(h, &old_view, new_info, + new_view, load_bias); + mismatches += kzt_compare_dynamic_symbols(h, &old_info, new_info, + load_bias); + mismatches += kzt_compare_dynamic_relocations(&old_info, new_info, + load_bias); + mismatches += kzt_compare_dynamic_versym(h, &old_info, new_info, + load_bias); + mismatches += kzt_compare_dynamic_verneed(h, &old_info, new_info, + load_bias); + mismatches += kzt_compare_dynamic_verdef(h, &old_info, new_info, + load_bias); + + if (mismatches) { + printf_log(LOG_INFO, + "%s Dynamic compare found %d mismatches for \"%s\"\n", + kzt_dynamic_compare_log_source(), mismatches, + object->filename); + goto out; + } + + printf_log(LOG_DEBUG, + "%s Dynamic compare matched for \"%s\": entries=%zu needed=%zu bias=0x%lx\n", + kzt_dynamic_compare_log_source(), object->filename, + new_dynamic->entries, new_dynamic->needed_count, load_bias); + +out: + kzt_dynamic_compare_pop_source(previous_source); +} + +static void kzt_record_guest_load_range(KztGuestObject *object, + elfheader_t *h) +{ + if (!GetElfLoadRange(h->PHEntries, h->numPHEntries, + object->load_bias, TARGET_PAGE_SIZE, + &object->map_start, &object->map_end)) { + SetGuestObjectMapRange(my_context->guest_objects, + kzt_guest_object_link_map_addr(object), + object->map_start, object->map_end); + } else { + printf_log(LOG_INFO, + "%s Warning: Cannot determine load range for \"%s\"\n", + object->event_source, object->filename); + } +} + +static library_t *kzt_register_guest_library_policy(KztGuestObject *object) +{ + if (!object->basename || !FindLibIsWrapped((char *)object->basename)) { + return NULL; + } + + const char *libs[] = {object->basename}; + if (AddNeededLib(my_context->maplib, &my_context->neededlibs, NULL, 0, + 1, libs, 1, my_context)) { + printf_log(LOG_INFO, "%s Error: registering wrapper for \"%s\"\n", + object->event_source, object->basename); + return NULL; + } + return GetLibInternal(object->basename); +} + +static void kzt_add_guest_object_debug_info(KztGuestObject *object, int type) +{ + if (object->map_start < object->map_end) + AddDebugInfo(type, object->object_name, object->map_start, + object->map_end); +} + +static void kzt_finish_guest_loader_object(KztGuestObject *object, + elfheader_t **h) +{ + kzt_add_guest_object_debug_info(object, LIB_EMULATED); + FreeElfHeader(h); + kzt_set_guest_object_state(object, GUEST_OBJECT_EMULATED); +} + +static void kzt_finish_guest_object_success(KztGuestObject *object, + library_t *lib) +{ + if (lib) { + kzt_add_guest_object_debug_info(object, LIB_WRAPPED); + kzt_set_guest_object_state(object, GUEST_OBJECT_WRAPPED); + } else { + kzt_add_guest_object_debug_info(object, LIB_EMULATED); + kzt_set_guest_object_state(object, GUEST_OBJECT_EMULATED); + } +} + +static int kzt_relocate_guest_object_legacy(KztGuestObject *object, + elfheader_t *h) +{ + if (RelocateElf(my_context->maplib, NULL, 0, h)) { + printf_log(LOG_INFO, "%s Error: relocating symbols for \"%s\"\n", + object->event_source, object->filename); + kzt_set_guest_object_state(object, GUEST_OBJECT_FAILED); + return -1; + } + if (RelocateElfPlt(my_context->maplib, NULL, 0, h)) { + printf_log(LOG_INFO, "%s Error: relocating PLT symbols for \"%s\"\n", + object->event_source, object->filename); + kzt_set_guest_object_state(object, GUEST_OBJECT_FAILED); + return -1; + } + return 0; +} + +static void kzt_prepare_guest_object_legacy_elf(KztGuestObject *object, + elfheader_t *h) +{ + ElfHeadReFix(h, object->load_bias); + collectX86free(h); + if(!x86free &&!strcmp(object->basename, libcName)) { + struct malloc_map * m = SearchMallocMap(my_context, (char *)libcName); + lsassert(m); + x86free = m->freep; + x86realloc = m->reallocp; + } + if(!x86pthread_setcanceltype &&!strcmp(object->basename, libcName)) { + findx86pthread_setcanceltype(h); + } + AddElfHeader(my_context, h); + kzt_skip_guest_needed_side_load(object->event_source, object->filename); +} + +static void kzt_process_regular_guest_object_legacy(KztGuestObject *object, + elfheader_t *h) +{ + library_t *lib = kzt_register_guest_library_policy(object); + + kzt_prepare_guest_object_legacy_elf(object, h); + if (kzt_relocate_guest_object_legacy(object, h)) + return; + + kzt_finish_guest_object_success(object, lib); +} + +static elfheader_t *kzt_prepare_guest_object_discovery(KztGuestObject *object) +{ + kzt_resolve_guest_object_path(object); + elfheader_t *h = kzt_open_guest_elf(object); + if (!h) + return NULL; + + kzt_compare_guest_dynamic(object, h); + kzt_record_guest_load_range(object, h); + return h; +} + +static void kzt_finish_discovered_guest_object(KztGuestObject *object, + elfheader_t **h) +{ + if (object->is_loader) { + kzt_finish_guest_loader_object(object, h); + return; + } + + kzt_process_regular_guest_object_legacy(object, *h); +} + +static void kzt_dispatch_guest_object_compat(KztGuestObject *object) +{ + if (!kzt_begin_legacy_guest_object_processing(object)) + return; + + elfheader_t *h = kzt_prepare_guest_object_discovery(object); + if (!h) + return; + + kzt_finish_discovered_guest_object(object, &h); +} + +static void kzt_handle_loader_event(const KztLoaderEvent *event) +{ + KztGuestObject object = {0}; + + kzt_guest_object_from_loader_event(event, &object); + + if (!kzt_register_guest_object(&object)) + return; + + kzt_dispatch_guest_object_compat(&object); +} + +static int kzt_submit_loader_link_map_event(const char *source, + struct link_map_x64 *link_map) +{ + KztLoaderEvent event = {0}; + + if (!kzt_capture_loader_event_from_link_map(source, link_map, &event)) + return 0; + + kzt_handle_loader_event(&event); + return 1; +} + +#define KZT_R_DEBUG_LINK_MAP_LIMIT 512 + +static int kzt_r_debug_is_scannable(KztRDebugEventSource *source, + KztRDebug *r_debug) +{ + const char *source_name = source->name ? source->name + : KZT_R_DEBUG_EVENT_SOURCE_NAME; + + if (r_debug->r_version != KZT_R_DEBUG_VERSION) { + printf_log(LOG_DEBUG, "%s skip r_debug: version=%d\n", + source_name, r_debug->r_version); + return 0; + } + + switch (r_debug->r_state) { + case KZT_RT_CONSISTENT: + return 1; + case KZT_RT_ADD: + case KZT_RT_DELETE: + printf_log(LOG_DEBUG, "%s skip r_debug while state=%d\n", + source_name, r_debug->r_state); + return 0; + default: + printf_log(LOG_DEBUG, "%s skip r_debug: state=%d\n", + source_name, r_debug->r_state); + return 0; + } +} + +static int kzt_submit_r_debug_events(KztRDebugEventSource *source) +{ + if (!source || !source->addr) + return 0; + + KztRDebug *r_debug = (KztRDebug *)source->addr; + const char *source_name = source->name ? source->name + : KZT_R_DEBUG_EVENT_SOURCE_NAME; + if (!kzt_guest_range_is_readable(r_debug, sizeof(*r_debug))) { + printf_log(LOG_DEBUG, "%s skip r_debug: addr=%p is not readable\n", + source_name, r_debug); + return 0; + } + if (!kzt_r_debug_is_scannable(source, r_debug)) + return 0; + + struct link_map_x64 *link_map = r_debug->r_map; + int submitted = 0; + + for (int i = 0; link_map && i < KZT_R_DEBUG_LINK_MAP_LIMIT; ++i) { + if (!kzt_guest_link_map_is_readable(link_map, source_name)) + return submitted; + + struct link_map_x64 *next = link_map->l_next; + submitted |= kzt_submit_loader_link_map_event(source_name, link_map); + if (next == link_map) { + printf_log(LOG_DEBUG, + "%s stop link_map scan: self loop at %p\n", + source_name, link_map); + return submitted; + } + if (next && !kzt_guest_link_map_is_readable(next, source_name)) + return submitted; + if (next && next->l_prev != link_map) { + printf_log(LOG_DEBUG, + "%s stop link_map scan: broken prev link %p -> %p\n", + source_name, link_map, next); + return submitted; + } + link_map = next; + } + if (link_map) { + printf_log(LOG_DEBUG, "%s stop link_map scan: limit=%d\n", + source_name, KZT_R_DEBUG_LINK_MAP_LIMIT); + } + return submitted; +} + +static void kzt_submit_glibc_loader_event_source( + KztGlibcLoaderEventSource *source, + CPUX86State *env) +{ + kzt_submit_r_debug_events(kzt_r_debug_event_source_default()); + + kzt_submit_loader_link_map_event( + kzt_glibc_loader_event_source_name(source), + kzt_get_glibc_loader_link_map(source, env)); +} + +static void kzt_glibc_loader_callback(CPUX86State *env) +{ + kzt_submit_glibc_loader_event_source( + kzt_glibc_loader_event_source_default(), env); +} +static TranslationBlock* test_tb; +static void test_x86free(CPUX86State *env) +{ + static int cnt; + static uintptr_t ptr; + static int has_found; + if (has_found) { + return; + } + if (!ptr) { + ptr = env->regs[R_EDI]; + } else if (ptr != env->regs[R_EDI]) { + //destroy callback + mmap_lock(); +#ifdef CONFIG_USER_ONLY + tb_phys_invalidate(test_tb, test_tb->itree.start); +#else + tb_phys_invalidate(test_tb, test_tb->page_addr[0]); +#endif + mmap_unlock(); + has_found = 1; + printf_log(LOG_DEBUG, "%s latx final find free=%p, realloc=%p\n", __func__, x86free, x86realloc); + return; + } + + if (cnt > 0) { + for (int i = 0; i < my_context->mallocmapsize;i++) { + if (x86free == my_context->mallocmaps[i]->freep && i mallocmapsize -1) { + struct malloc_map * m = my_context->mallocmaps[i + 1]; + static uint32 test_ld [2] = {0}; + x86free = m->freep; + x86realloc = m->reallocp; + target_ulong eip = env->eip; + CPUState *cpu = env_cpu(env); + memset(&test_ld, 0, sizeof(test_ld)); + mmap_lock(); +#ifdef CONFIG_USER_ONLY + tb_phys_invalidate(test_tb, test_tb->itree.start); +#else + tb_phys_invalidate(test_tb, test_tb->page_addr[0]); +#endif + + mmap_unlock(); + printf_log(LOG_DEBUG, "%s latx try find free=%p, realloc=%p from %s\n", __func__, x86free, x86realloc, ((elfheader_t*)m->h)->path); + test_tb = kzt_add_fucn_by_addr((uint32 *)&test_ld, cpu, (uintptr_t)x86free, target_latx_ld_callback, test_x86free); + env->eip = eip; + cnt = 0; + return; + } + } + } + cnt++; +} +static inline gint tb_sort_cmp(const void *ap, const void *bp) +{ + const struct malloc_map *a = *(const struct malloc_map **)ap; + const struct malloc_map *b = *(const struct malloc_map **)bp; + if (a->freep < b->freep) { + return 1; + } + return -1; +} +static void finiReFlesh(elfheader_t* exech) +{ + CPUState *cpu; + static uint32 test_ld [2] = {0}; + if (!my_context->mallocmapsize) { + printf_log(LOG_DEBUG, "%s skip malloc hook setup for %s: no malloc map\n", + __func__, exech ? ElfPath(exech) : ""); + return; + } + struct malloc_map * m; + + if (my_context->mallocmapsize == 1) { + m = my_context->mallocmaps[0]; + x86free = m->freep; + x86realloc = m->reallocp; + return; + } + /* For select x86free, x86realloc from my_context->mallocmaps + * Sort in descending order for freep. + * Because: + * When an executable program depends on multiple libraries and + * all of them provide symbols with the same name (such as free functions), + * the dynamic linker will parse the symbols according to the loading order of the libraries. + * The symbols defined in the first loaded library have higher priority. + */ + if (my_context->mallocmaps[0]->h == my_context->elfs[0]) {//elf[0] is exe file + if (my_context->mallocmapsize > 2) { + qsort(my_context->mallocmaps[1], my_context->mallocmapsize - 1, sizeof(struct malloc_map *), tb_sort_cmp); + } + } else { + qsort(my_context->mallocmaps, my_context->mallocmapsize, sizeof(struct malloc_map *), tb_sort_cmp); + } + m = my_context->mallocmaps[0]; + x86free = m->freep; + x86realloc = m->reallocp; + CPU_FOREACH(cpu) { + if (cpu) { + break; + } + } + CPUArchState *env = cpu->env_ptr; + target_ulong eip = env->eip; + test_tb = kzt_add_fucn_by_addr((uint32 *)&test_ld, cpu, (uintptr_t)x86free, target_latx_ld_callback, test_x86free); + env->eip = eip; + printf_log(LOG_DEBUG, "%s latx try find free=%p, realloc=%p from %s\n", __func__, x86free, x86realloc, ((elfheader_t*)m->h)->path); +} +static void kzt_exectb_callback(CPUX86State *env) +{ + kzt_submit_r_debug_events(kzt_r_debug_event_source_default()); finiReFlesh(elf_header); x64free_fini = 1; RelocateElf(my_context->maplib, NULL, 0, elf_header); RelocateElfPlt(my_context->maplib, NULL, 0, elf_header); AddDebugInfo(LIB_EMULATED, elf_header->name, info1.start_code, info1.end_code); } -static TranslationBlock* kzt_add_fucn_by_addr(uint32* inst_old, CPUState *cpu, uintptr_t addr, int (*latx_ld_callback)(void *, void (*)(CPUX86State *)), void (*kzt_tb_callback)(CPUX86State *)) +static TranslationBlock* kzt_add_fucn_by_addr(uint32* inst_old, CPUState *cpu, uintptr_t addr, int (*latx_ld_callback)(void *, void (*)(CPUX86State *)), void (*kzt_tb_callback)(CPUX86State *)) +{ + uint32 jmpinst [2] = {0}; + uint32 * tmp, *pinsn; + CPUArchState *env = cpu->env_ptr; + int isOverWrite = 0; + int pos = 0; + void * ld_callback_context = tcg_ctx->code_gen_ptr; + int backlen = latx_ld_callback(tcg_ctx->code_gen_ptr, kzt_tb_callback); + backlen *= 4; + tcg_ctx->code_gen_ptr += backlen; + env->eip = addr - env->segs[R_CS].base; + printf_log(LOG_DEBUG, "------------init_tb_callback_bridge--cpu=%p--pid=%d---latx_ld_callback %p to %p----\n", cpu, getpid(), ld_callback_context, tcg_ctx->code_gen_ptr); + TranslationBlock * tb = kzt_tb_find_exp(cpu, NULL, 0, cpu->tcg_cflags); + printf_log(LOG_DEBUG, "%s add pc = %lx jmp blok=%p tb=%p\n", __func__, addr, ld_callback_context, tb); + light_tb_target_set_jmp_target(0, (uintptr_t)tb->tc.ptr, (uintptr_t)&jmpinst, (uintptr_t)ld_callback_context); + tmp = (uint32 *)((uintptr_t)ld_callback_context + backlen - 4*4); + pinsn = (uint32 *)tb->tc.ptr; + if (*pinsn == 0x50000800 && *(pinsn + 1) == 0x03400000) {//skip insts:--> b 8(0x8) ;andi $r0,$r0,0x0 + pos = 2; + pinsn += pos; + } + #if 0 + case: pinsn is direct insn (e.g.: b 8) + #endif + if (((*pinsn) & 0xfc000000) == 0x50000000 ||// b + (((*pinsn) & 0xfe000000) == 0x1e000000 &&/* pcaddu18i */ + (*(pinsn + 1) & 0xfc000000) == 0x4c000000)) { + printf_log(LOG_DEBUG, "------------kzt_add_fucn_by_addr tb has fixed return --cpu=%p--pid=%d------\n", cpu, getpid()); + isOverWrite = 1; + lsassert(jmpinst[0] && jmpinst[1]); + } + if (jmpinst[1]) {//long jmp + if (!isOverWrite) { + *tmp = *((uint32 *)tb->tc.ptr + pos); + *(tmp + 1) = *((uint32 *)tb->tc.ptr + 1 + pos); + if (!inst_old[0]) inst_old[0] = *((uint32 *)tb->tc.ptr + pos); + if (!inst_old[1]) inst_old[1] = *((uint32 *)tb->tc.ptr + 1 + pos); + } else { + *tmp = inst_old[0]; + *(tmp + 1) = inst_old[1]; + } + *((uint32 *)tb->tc.ptr + pos) = jmpinst[0]; + *((uint32 *)tb->tc.ptr + 1 + pos) = jmpinst[1]; + memset(&jmpinst, 0, sizeof(jmpinst)); + light_tb_target_set_jmp_target(0, (uintptr_t)(tmp + 2), (uintptr_t)&jmpinst, (uintptr_t)((uint32 *)tb->tc.ptr + 2 + pos)); + *(tmp + 2) = jmpinst[0]; + *(tmp + 3) = jmpinst[1]; + } else { + if (!isOverWrite) { + lsassert(*((uint32 *)tb->tc.ptr + pos)); + *tmp = *((uint32 *)tb->tc.ptr + pos); + if (!inst_old[0]) inst_old[0] = *((uint32 *)tb->tc.ptr + pos); + } else { + lsassert(inst_old[0]); + *tmp = inst_old[0]; + } + *((uint32 *)tb->tc.ptr + pos) = jmpinst[0]; + memset(&jmpinst, 0, sizeof(jmpinst)); + light_tb_target_set_jmp_target(0, (uintptr_t)(tmp + 1), (uintptr_t)&jmpinst, (uintptr_t)((uint32 *)tb->tc.ptr + 1 + pos)); + *(tmp + 1) = jmpinst[0]; + } + return tb; +} +typedef struct KztGlibcLoaderPatternInsn { + char search[5]; + int search_len; + uint32_t offset; +} KztGlibcLoaderPatternInsn; + +#define KZT_GLIBC_LOADER_PATTERN_INSNS 7 + +typedef struct KztGlibcLoaderPattern { + KztGlibcLoaderPatternInsn ins[KZT_GLIBC_LOADER_PATTERN_INSNS]; + int part_offset; + const char *glibc_version; +} KztGlibcLoaderPattern; + +#define KZT_GLIBC_LOADER_PATTERN_OFFSET_DEBIAN (0x32 - 1) +#define KZT_GLIBC_LOADER_PATTERN_OFFSET_UBUNTU (0x36 - 1) + +#define KZT_GLIBC_LOADER_PATTERN_PROBE_SIZE 8 +#define KZT_GLIBC_LOADER_HOOK_MASK 0xffffffffff00ffff + +static KztGlibcLoaderHook *kzt_new_glibc_loader_hook(uint8_t *addr) +{ + KztGlibcLoaderHook *hook = malloc(sizeof(KztGlibcLoaderHook)); + if (!hook) + return NULL; + + hook->addr = (uintptr_t)addr; + hook->reg = (*(addr + 2)) & 0xf; + if (hook->reg >= CPU_NB_REGS) { + free(hook); + return NULL; + } + + printf_log(LOG_DEBUG, "debug find ld so 0x%lx reg = %d\n", + hook->addr, hook->reg); + return hook; +} + +static int kzt_glibc_loader_hook_matches(uint8_t *addr, uint64_t mask, + uint64_t value) +{ + uint64_t insn; + + memcpy(&insn, addr, sizeof(insn)); + return (insn & mask) == value; +} + +static int kzt_glibc_loader_hook_candidate_in_file( + const KztGlibcLoaderHookCandidate *candidate, + size_t file_len) +{ + return candidate->offset <= file_len + && file_len - candidate->offset >= sizeof(uint64_t); +} + +static int kzt_glibc_loader_scan_range_in_file(char *base, size_t file_len, + char *addr, size_t size) +{ + uintptr_t base_addr = (uintptr_t)base; + uintptr_t addr_value = (uintptr_t)addr; + + if (file_len > UINTPTR_MAX - base_addr) + return 0; + + uintptr_t end_addr = base_addr + file_len; + return addr_value >= base_addr + && addr_value <= end_addr + && size <= end_addr - addr_value; +} + +static int kzt_glibc_loader_scan_remaining(char *base, size_t file_len, + char *scan, size_t *remaining) +{ + uintptr_t base_addr = (uintptr_t)base; + uintptr_t scan_addr = (uintptr_t)scan; + + if (!kzt_glibc_loader_scan_range_in_file(base, file_len, scan, 0)) + return 0; + + *remaining = file_len - (scan_addr - base_addr); + return 1; +} + +static int kzt_is_decimal_digit(char ch) +{ + return ch >= '0' && ch <= '9'; +} + +static int kzt_glibc_loader_copy_version(const char *start, + const char *end, + char *version, + size_t version_size) +{ + const char *cursor = start; + size_t len = 0; + + if (!version_size) + return 0; + while (cursor < end && len + 1 < version_size) { + char ch = *cursor; + if (!kzt_is_decimal_digit(ch) && ch != '.') + break; + version[len++] = ch; + ++cursor; + } + + version[len] = '\0'; + return len >= 3 && strchr(version, '.'); +} + +static int kzt_glibc_loader_read_file(const char *path, char **data, + size_t *size) +{ + FILE *file = fopen(path, "rb"); + if (!file) + return 0; + + if (fseek(file, 0, SEEK_END)) { + fclose(file); + return 0; + } + long file_size = ftell(file); + if (file_size <= 0) { + fclose(file); + return 0; + } + if (fseek(file, 0, SEEK_SET)) { + fclose(file); + return 0; + } + + char *buffer = malloc((size_t)file_size); + if (!buffer) { + fclose(file); + return 0; + } + + size_t read_size = fread(buffer, 1, (size_t)file_size, file); + fclose(file); + if (read_size != (size_t)file_size) { + free(buffer); + return 0; + } + + *data = buffer; + *size = read_size; + return 1; +} + +static int kzt_glibc_loader_find_version(const char *data, size_t size, + char *version, + size_t version_size) +{ + static const char marker[] = "GNU C Library"; + static const char glibc_prefix[] = "glibc-"; + const char *cursor = data; + size_t remaining = size; + + while (remaining) { + char *match = memmem(cursor, remaining, marker, sizeof(marker) - 1); + if (!match) + break; + + const char *end = data + size; + for (const char *scan = match + sizeof(marker) - 1; + scan + 2 < end; ++scan) { + if (!kzt_is_decimal_digit(scan[0]) || scan[1] != '.' + || !kzt_is_decimal_digit(scan[2])) { + continue; + } + if (kzt_glibc_loader_copy_version(scan, end, version, + version_size)) { + return 1; + } + } + + remaining = size - (size_t)(match + 1 - data); + cursor = match + 1; + } + + cursor = data; + remaining = size; + while (remaining) { + char *match = memmem(cursor, remaining, glibc_prefix, + sizeof(glibc_prefix) - 1); + if (!match) + break; + + const char *start = match + sizeof(glibc_prefix) - 1; + if (kzt_glibc_loader_copy_version(start, data + size, version, + version_size)) { + return 1; + } + + remaining = size - (size_t)(match + 1 - data); + cursor = match + 1; + } + + return 0; +} + +static int kzt_glibc_loader_version_from_path(const char *path, + char *version, + size_t version_size) +{ + const char *base = path ? strrchr(path, '/') : NULL; + + base = base ? base + 1 : path; + if (!base || strncmp(base, "ld-", 3)) + return 0; + + const char *start = base + 3; + const char *end = base + strlen(base); + return kzt_glibc_loader_copy_version(start, end, version, version_size); +} + +static int kzt_glibc_loader_read_version(const char *path, char *version, + size_t version_size) +{ + char *data = NULL; + size_t size = 0; + int found = 0; + + if (!kzt_glibc_loader_read_file(path, &data, &size)) + return 0; + + found = kzt_glibc_loader_find_version(data, size, version, version_size); + free(data); + if (found) + return 1; + return kzt_glibc_loader_version_from_path(path, version, version_size); +} + +static int kzt_glibc_loader_version_supported(const char *version) +{ + static const char *supported[] = { + "2.28", + "2.31", + "2.40", + "2.41", + "2.42", + }; + + if (!version || !version[0]) + return 0; + for (size_t i = 0; i < sizeof(supported) / sizeof(supported[0]); ++i) { + if (!strcmp(version, supported[i])) + return 1; + } + return 0; +} + +static int kzt_glibc_loader_version_matches(const char *actual, + const char *expected) +{ + return actual && expected && !strcmp(actual, expected); +} + +static int kzt_glibc_loader_pattern_matches( + char *base, + size_t file_len, + char *candidate, + const KztGlibcLoaderPattern *pattern) +{ + uintptr_t probe_addr = (uintptr_t)candidate; + + for (int i = 0; i < KZT_GLIBC_LOADER_PATTERN_INSNS; i++) { + if (pattern->ins[i].offset > UINTPTR_MAX - probe_addr) + return 0; + + probe_addr += pattern->ins[i].offset; + char *probe = (char *)probe_addr; + if (!kzt_glibc_loader_scan_range_in_file( + base, file_len, probe, + KZT_GLIBC_LOADER_PATTERN_PROBE_SIZE)) { + return 0; + } + + if (pattern->ins[i].offset && + memmem(probe, KZT_GLIBC_LOADER_PATTERN_PROBE_SIZE, + pattern->ins[i].search, + pattern->ins[i].search_len) != probe) { + return 0; + } + } + + return 1; +} + +static int kzt_glibc_loader_pattern_candidate( + char *base, + size_t file_len, + char *anchor, + size_t anchor_len, + const KztGlibcLoaderPattern *pattern, + char **candidate) +{ + uintptr_t base_addr = (uintptr_t)base; + uintptr_t anchor_addr = (uintptr_t)anchor; + + if (pattern->part_offset < 0) + return 0; + if (file_len > UINTPTR_MAX - base_addr) + return 0; + if (anchor_len > UINTPTR_MAX - anchor_addr) + return 0; + + uintptr_t end_addr = base_addr + file_len; + uintptr_t anchor_end = anchor_addr + anchor_len; + if (anchor_addr < base_addr || anchor_end > end_addr) + return 0; + + uintptr_t anchor_end_offset = anchor_end - base_addr; + if ((uintptr_t)pattern->part_offset > anchor_end_offset) + return 0; + + uintptr_t candidate_addr = anchor_end - (uintptr_t)pattern->part_offset; + if (candidate_addr < base_addr || candidate_addr > end_addr) + return 0; + + *candidate = (char *)candidate_addr; + return 1; +} + +static int kzt_resolve_glibc_loader_image(void *info, + KztGlibcLoaderImage *image) { - uint32 jmpinst [2] = {0}; - uint32 * tmp, *pinsn; - CPUArchState *env = cpu->env_ptr; - int isOverWrite = 0; - int pos = 0; - void * ld_callback_context = tcg_ctx->code_gen_ptr; - int backlen = latx_ld_callback(tcg_ctx->code_gen_ptr, kzt_tb_callback); - backlen *= 4; - tcg_ctx->code_gen_ptr += backlen; - env->eip = addr - env->segs[R_CS].base; - printf_log(LOG_DEBUG, "------------init_tb_callback_bridge--cpu=%p--pid=%d---latx_ld_callback %p to %p----\n", cpu, getpid(), ld_callback_context, tcg_ctx->code_gen_ptr); - TranslationBlock * tb = kzt_tb_find_exp(cpu, NULL, 0, cpu->tcg_cflags); - printf_log(LOG_DEBUG, "%s add pc = %lx jmp blok=%p tb=%p\n", __func__, addr, ld_callback_context, tb); - light_tb_target_set_jmp_target(0, (uintptr_t)tb->tc.ptr, (uintptr_t)&jmpinst, (uintptr_t)ld_callback_context); - tmp = (uint32 *)((uintptr_t)ld_callback_context + backlen - 4*4); - pinsn = (uint32 *)tb->tc.ptr; - if (*pinsn == 0x50000800 && *(pinsn + 1) == 0x03400000) {//skip insts:--> b 8(0x8) ;andi $r0,$r0,0x0 - pos = 2; - pinsn += pos; + struct image_info *execinfo = (struct image_info *)info; + struct stat st; + + if (!execinfo || !execinfo->interpreter_path || + !execinfo->interpreter_path[0] || !execinfo->load_bias) { + return 0; } - #if 0 - case: pinsn is direct insn (e.g.: b 8) - #endif - if (((*pinsn) & 0xfc000000) == 0x50000000 ||// b - (((*pinsn) & 0xfe000000) == 0x1e000000 &&/* pcaddu18i */ - (*(pinsn + 1) & 0xfc000000) == 0x4c000000)) { - printf_log(LOG_DEBUG, "------------kzt_add_fucn_by_addr tb has fixed return --cpu=%p--pid=%d------\n", cpu, getpid()); - isOverWrite = 1; - lsassert(jmpinst[0] && jmpinst[1]); + + char *real_dl_file = ResolveFile(kzt_object_basename( + execinfo->interpreter_path), + &my_context->box64_ld_lib); + int image_ok = real_dl_file + && !stat(real_dl_file, &st) + && st.st_size > 0 + && (uintmax_t)st.st_size <= SIZE_MAX; + if (!image_ok) { + if (real_dl_file) + free(real_dl_file); + return 0; } - if (jmpinst[1]) {//long jmp - if (!isOverWrite) { - *tmp = *((uint32 *)tb->tc.ptr + pos); - *(tmp + 1) = *((uint32 *)tb->tc.ptr + 1 + pos); - if (!inst_old[0]) inst_old[0] = *((uint32 *)tb->tc.ptr + pos); - if (!inst_old[1]) inst_old[1] = *((uint32 *)tb->tc.ptr + 1 + pos); - } else { - *tmp = inst_old[0]; - *(tmp + 1) = inst_old[1]; - } - *((uint32 *)tb->tc.ptr + pos) = jmpinst[0]; - *((uint32 *)tb->tc.ptr + 1 + pos) = jmpinst[1]; - memset(&jmpinst, 0, sizeof(jmpinst)); - light_tb_target_set_jmp_target(0, (uintptr_t)(tmp + 2), (uintptr_t)&jmpinst, (uintptr_t)((uint32 *)tb->tc.ptr + 2 + pos)); - *(tmp + 2) = jmpinst[0]; - *(tmp + 3) = jmpinst[1]; - } else { - if (!isOverWrite) { - lsassert(*((uint32 *)tb->tc.ptr + pos)); - *tmp = *((uint32 *)tb->tc.ptr + pos); - if (!inst_old[0]) inst_old[0] = *((uint32 *)tb->tc.ptr + pos); - } else { - lsassert(inst_old[0]); - *tmp = inst_old[0]; - } - *((uint32 *)tb->tc.ptr + pos) = jmpinst[0]; - memset(&jmpinst, 0, sizeof(jmpinst)); - light_tb_target_set_jmp_target(0, (uintptr_t)(tmp + 1), (uintptr_t)&jmpinst, (uintptr_t)((uint32 *)tb->tc.ptr + 1 + pos)); - *(tmp + 1) = jmpinst[0]; + + snprintf(image->path, sizeof(image->path), "%s", real_dl_file); + if (!kzt_glibc_loader_read_version(real_dl_file, image->glibc_version, + sizeof(image->glibc_version))) { + printf_log(LOG_NONE, + "KZT: cannot identify glibc loader version from %s\n", + real_dl_file); + free(real_dl_file); + return 0; } - return tb; + if (!kzt_glibc_loader_version_supported(image->glibc_version)) { + printf_log(LOG_NONE, + "KZT: unsupported glibc loader version %s from %s\n", + image->glibc_version, real_dl_file); + free(real_dl_file); + return 0; + } + printf_log(LOG_DEBUG, "KZT: glibc loader version %s from %s\n", + image->glibc_version, real_dl_file); + free(real_dl_file); + + image->start = (uint8_t *)execinfo->load_bias; + image->file_len = st.st_size; + return 1; } -struct ins_part_s { - char search[5]; - int search_len; - uint32_t offset; -}; -#define MY_PARTY_OFFSET 0x32 - 1 -#define MY_PARTY_OFFSET_UBUNTU 0x36 - 1 -#define MY_PARTY_INS_MAX 8 -static struct x86_ld_info * find_ld_part(char * start, int len) +static const KztGlibcLoaderPattern *kzt_glibc_loader_fallback_patterns( + size_t *count) { - struct x86_ld_info * ret = NULL; - char * old_start = start; - char searchpopret_part[] = { - 0x5b, //pop rbx - 0x41, 0x5c, //pop r12 - 0x41, 0x5d, //pop r13 - 0x41, 0x5e, //pop r14 - 0x41, 0x5f, //pop r15 - 0x5d, //pop rbp - 0xc3 //ret - }; - char *ld_find = NULL; - static char* _dl_relocate_object_end; #define K_OR(offset_s) {.search = {0x41, 0x80}, .search_len = 2, .offset = offset_s} #define K_CMP_48(offset_s) {.search = {0x48, 0x83}, .search_len = 2, .offset = offset_s} #define K_CMP_49(offset_s) {.search = {0x49, 0x83}, .search_len = 2, .offset = offset_s} @@ -2480,15 +4594,7 @@ static struct x86_ld_info * find_ld_part(char * start, int len) #define K_TEST(offset_s) {.search = {0x48, 0x85}, .search_len = 2, .offset = offset_s} #define K_SKIP(offset_s) {.search = {0, 0}, .search_len = 0, .offset = offset_s} -#define K_ISNOT_SKIP(p) (p.offset != 0) -#define MAX_INS_PART_S 7 - - struct ld_part_s { - struct ins_part_s ins [MAX_INS_PART_S]; - int part_offset; - }; - - struct ld_part_s all_part[] = { + static const KztGlibcLoaderPattern patterns[] = { { .ins = { K_OR(0), @@ -2499,7 +4605,8 @@ static struct x86_ld_info * find_ld_part(char * start, int len) K_LEA(6), K_SKIP(0), }, - .part_offset = MY_PARTY_OFFSET//for debian + .glibc_version = "2.28", + .part_offset = KZT_GLIBC_LOADER_PATTERN_OFFSET_DEBIAN//for debian }, { .ins = { @@ -2511,7 +4618,8 @@ static struct x86_ld_info * find_ld_part(char * start, int len) K_JNE(3), K_LEA(6), }, - .part_offset = MY_PARTY_OFFSET_UBUNTU//for Ubuntu 21.04 + .glibc_version = "2.31", + .part_offset = KZT_GLIBC_LOADER_PATTERN_OFFSET_UBUNTU//for Ubuntu 21.04 }, { // AOSC 25.05.16 GNU C Library (GNU libc) stable release version 2.40. .ins = { @@ -2523,6 +4631,7 @@ static struct x86_ld_info * find_ld_part(char * start, int len) K_LEA(6), // 0x48 0x8d 0x65 0xd8 (lea -0x28(%rbp),%rsp) K_SKIP(0), }, + .glibc_version = "2.40", .part_offset = 0x33 }, { // AOSC OS (Core 12.2.2), glibc 2.40 (EmuKit 20250909~pre20250911T080911Z) @@ -2535,6 +4644,7 @@ static struct x86_ld_info * find_ld_part(char * start, int len) K_LEA(6), // 0x48 0x8d 0x65 0xd8 (lea -0x28(%rbp),%rsp) K_SKIP(0), }, + .glibc_version = "2.40", .part_offset = 0x2e }, { // debian sid GNU C Library (Debian GLIBC 2.41-7) stable release version 2.41. @@ -2544,6 +4654,7 @@ static struct x86_ld_info * find_ld_part(char * start, int len) K_JNE(3), // 0x0f 0x85 0xbd 0x14 0x00 0x00 (jne) K_LEA(6), // 0x48 0x8d 0x64 0xd8 (lea -0x28(%rbp),%rsp) }, + .glibc_version = "2.41", .part_offset = 0x20 }, { // glibc 2.42 (Yongbao x86_64_runtime) @@ -2554,122 +4665,315 @@ static struct x86_ld_info * find_ld_part(char * start, int len) K_LEA(6), // 0x48 0x8d 0x65 0xd8 (lea -0x28(%rbp),%rsp) K_SKIP(0), }, + .glibc_version = "2.42", .part_offset = 0x25 } }; - while((_dl_relocate_object_end = memmem(start, len - (start - old_start), searchpopret_part, - sizeof(searchpopret_part)))) { - start = _dl_relocate_object_end + 1; - for (int j = 0; j < sizeof(all_part) / sizeof(struct ld_part_s); j++) { - char *my_start = _dl_relocate_object_end - all_part[j].part_offset + sizeof(searchpopret_part); - int no_match = 0; - for (int i = 0; i < MAX_INS_PART_S; i++) { - my_start += all_part[j].ins[i].offset; - if (K_ISNOT_SKIP(all_part[j].ins[i]) && - memmem(my_start, MY_PARTY_INS_MAX, all_part[j].ins[i].search, all_part[j].ins[i].search_len) != my_start) { - no_match = 1; - break; - } + + *count = sizeof(patterns) / sizeof(patterns[0]); + return patterns; +} + +#undef K_OR +#undef K_CMP_48 +#undef K_CMP_49 +#undef K_JNE +#undef K_LEA +#undef K_MOV +#undef K_TEST +#undef K_SKIP + +static const KztGlibcLoaderHookCandidate *kzt_glibc_loader_fixed_candidates( + size_t *count) +{ + static const KztGlibcLoaderHookCandidate candidates[] = { + {0xbc15, 0x040000031c008041, "2.28"}, + {0xdcc2, 0x040000031c008041, "2.31"}, // Ubuntu 21.04 ld-2.31.so + {0xdb72, 0x0800000354008041, "2.40"}, // AOSC 25.05.16 glibc 2.40 + {0xdffe, 0x0800000354008041, "2.41"}, // Debian sid glibc 2.41-7 + }; + + *count = sizeof(candidates) / sizeof(candidates[0]); + return candidates; +} + +static KztGlibcLoaderHook *kzt_find_glibc_loader_hook_fixed( + const KztGlibcLoaderImage *image) +{ + size_t candidate_count = 0; + const KztGlibcLoaderHookCandidate *candidates = + kzt_glibc_loader_fixed_candidates(&candidate_count); + uint8_t *matched_addr = NULL; + + for (size_t i = 0; i < candidate_count; ++i) { + if (!kzt_glibc_loader_version_matches(image->glibc_version, + candidates[i].glibc_version)) { + continue; + } + if (!kzt_glibc_loader_hook_candidate_in_file(&candidates[i], + image->file_len)) { + continue; + } + + uint8_t *fix_addr = image->start + candidates[i].offset; + if (kzt_glibc_loader_hook_matches(fix_addr, + KZT_GLIBC_LOADER_HOOK_MASK, + candidates[i].value)) { + if (matched_addr) { + printf_log(LOG_NONE, + "KZT: ambiguous glibc fixed hook for %s %s\n", + image->path, image->glibc_version); + return NULL; + } + matched_addr = fix_addr; + } + } + + return matched_addr ? kzt_new_glibc_loader_hook(matched_addr) : NULL; +} + +static KztGlibcLoaderHook *kzt_find_glibc_loader_hook_pattern( + const KztGlibcLoaderImage *image) +{ + char *base = (char *)image->start; + char *scan = base; + static const char popret_anchor[] = { + 0x5b, //pop rbx + 0x41, 0x5c, //pop r12 + 0x41, 0x5d, //pop r13 + 0x41, 0x5e, //pop r14 + 0x41, 0x5f, //pop r15 + 0x5d, //pop rbp + 0xc3 //ret + }; + char *relocate_object_end = NULL; + size_t pattern_count = 0; + const KztGlibcLoaderPattern *patterns = + kzt_glibc_loader_fallback_patterns(&pattern_count); + size_t remaining = 0; + char *matched_addr = NULL; + while (kzt_glibc_loader_scan_remaining(base, image->file_len, scan, + &remaining)) { + if (!remaining) + break; + + relocate_object_end = memmem(scan, remaining, + popret_anchor, + sizeof(popret_anchor)); + if (!relocate_object_end) + break; + + scan = relocate_object_end + 1; + for (size_t j = 0; j < pattern_count; j++) { + char *ld_find = NULL; + if (!kzt_glibc_loader_version_matches( + image->glibc_version, patterns[j].glibc_version)) { + continue; + } + if (!kzt_glibc_loader_pattern_candidate( + base, image->file_len, relocate_object_end, + sizeof(popret_anchor), &patterns[j], &ld_find)) { + continue; } - if (!no_match) { - ld_find = _dl_relocate_object_end - all_part[j].part_offset + sizeof(searchpopret_part); - goto suc; + if (kzt_glibc_loader_pattern_matches(base, image->file_len, + ld_find, &patterns[j])) { + if (matched_addr) { + printf_log(LOG_NONE, + "KZT: ambiguous glibc pattern hook for %s %s\n", + image->path, image->glibc_version); + return NULL; + } + matched_addr = ld_find; } } } - fprintf(stderr, "Lat can't find ldinfo.\n"); - return NULL; -suc: - ret = malloc(sizeof(struct x86_ld_info)); - ret->addr = (uintptr_t) ld_find; - ret->reg = (*(ld_find+ 2)) & 0xf; - printf_log(LOG_DEBUG, "debug find ld so 0x%lx reg = %d\n", ret->addr, ret->reg); - return ret; + if (!matched_addr) { + printf_log(LOG_NONE, "KZT: cannot find glibc hook for %s %s\n", + image->path, image->glibc_version); + return NULL; + } + return kzt_new_glibc_loader_hook((uint8_t *)matched_addr); } -static struct x86_ld_info *find_ld_bridge(void* info) +static KztGlibcLoaderHook *kzt_find_glibc_loader_event_source_hook(void *info) { - struct image_info * execinfo = (struct image_info *)info; - struct x86_ld_info * ret = NULL; - struct stat st; - uint8_t *ld_start = (uint8_t *)execinfo->load_bias; - char *real_dl_file = ResolveFile(basename(execinfo->interpreter_path), &my_context->box64_ld_lib); - if (stat(real_dl_file, &st)) { + KztGlibcLoaderImage image = {0}; + + if (!kzt_resolve_glibc_loader_image(info, &image)) + return NULL; + + KztGlibcLoaderHook *hook = kzt_find_glibc_loader_hook_fixed(&image); + if (hook) + return hook; + + return kzt_find_glibc_loader_hook_pattern(&image); +} + +static int kzt_install_tb_callback_bridge( + CPUState *cpu, + uint32 *saved_inst, + const KztTbCallbackBridge *bridge) +{ + if (!cpu || !saved_inst || !bridge || !bridge->addr || !bridge->callback) + return 0; + + kzt_add_fucn_by_addr(saved_inst, cpu, bridge->addr, + target_latx_ld_callback, bridge->callback); + return 1; +} + +static KztTbCallbackBridge kzt_exec_entry_callback_bridge( + struct image_info *execinfo) +{ + KztTbCallbackBridge bridge = { + .callback = kzt_exectb_callback, + }; + + if (execinfo) + bridge.addr = execinfo->exec_entry; + return bridge; +} + +static int kzt_install_exec_entry_callback(CPUState *cpu, + struct image_info *execinfo, + uint32 *saved_inst) +{ + KztTbCallbackBridge bridge = kzt_exec_entry_callback_bridge(execinfo); + + return kzt_install_tb_callback_bridge(cpu, saved_inst, &bridge); +} + +static KztTbCallbackBridge kzt_glibc_loader_event_source_bridge( + KztGlibcLoaderEventSource *source) +{ + KztTbCallbackBridge bridge = { + .addr = kzt_glibc_loader_event_source_hook_addr(source), + .callback = kzt_glibc_loader_event_source_callback(source), + }; + + return bridge; +} + +static int kzt_install_glibc_loader_event_source( + CPUState *cpu, + uint32 *saved_inst, + KztGlibcLoaderEventSource *source) +{ + KztTbCallbackBridge bridge = + kzt_glibc_loader_event_source_bridge(source); + + /* + * This is the Stage 8 fallback event source. It still patches a private + * glibc location today, but the rest of KZT now consumes only loader + * events, so this function can later be replaced or version-gated. + */ + return kzt_install_tb_callback_bridge(cpu, saved_inst, &bridge); +} + +static KztGlibcLoaderHook *kzt_resolve_glibc_loader_event_source( + KztGlibcLoaderEventSource *source, + void *info) +{ + KztGlibcLoaderHookResolver resolver = + kzt_glibc_loader_event_source_hook_resolver(source); + + if (!source || !resolver) return NULL; + + if (!source->hook_resolved) { + kzt_glibc_loader_event_source_set_hook( + source, resolver(info)); + source->hook_resolved = 1; } - size_t file_len = st.st_size; - - uint8_t* fix_addr = (uint8_t *)(ld_start+0xbc15); - if ((*(uint64_t *)fix_addr & 0xffffffffff00ffff) == 0x040000031c008041) { - ret = malloc(sizeof(struct x86_ld_info)); - ret->addr = (uintptr_t) fix_addr; - ret->reg = (*(fix_addr+ 2)) & 0xf; - printf_log(LOG_DEBUG, "debug find ld so 0x%lx reg = %d\n", ret->addr, ret->reg); - return ret; - } - fix_addr = (uint8_t *)(ld_start+ 0xdcc2); - if ((*(uint64_t *)fix_addr & 0xffffffffff00ffff) == 0x040000031c008041) {//for Ubuntu 21.04 ld-2.31.so - ret = malloc(sizeof(struct x86_ld_info)); - ret->addr = (uintptr_t) fix_addr; - ret->reg = (*(fix_addr+ 2)) & 0xf; - printf_log(LOG_DEBUG, "debug find ld so 0x%lx reg = %d\n", ret->addr, ret->reg); - return ret; - } - fix_addr = (uint8_t *)(ld_start+0xe6d8); - if ((*(uint64_t *)fix_addr & 0xffffffffff00ffff) == 0x0800000334008041) { - ret = malloc(sizeof(struct x86_ld_info)); - ret->addr = (uintptr_t) fix_addr; - ret->reg = (*(fix_addr+ 2)) & 0xf; - printf_log(LOG_DEBUG, "debug find ld so 0x%lx reg = %d\n", ret->addr, ret->reg); - return ret; - } - fix_addr = (uint8_t *)(ld_start+ 0xe7cd); - if ((*(uint64_t *)fix_addr & 0xffffffffff00ffff) == 0x0800000354008041) { - ret = malloc(sizeof(struct x86_ld_info)); - ret->addr = (uintptr_t) fix_addr; - ret->reg = (*(fix_addr+ 2)) & 0xf; - printf_log(LOG_DEBUG, "debug find ld so 0x%lx reg = %d\n", ret->addr, ret->reg); - return ret; - } - // AOSC 25.05.16 GNU C Library ( GLIBC 2.40) - fix_addr = (uint8_t *)(ld_start+ 0xdb72); - if ((*(uint64_t *)fix_addr & 0xffffffffff00ffff) == 0x0800000354008041) { - ret = malloc(sizeof(struct x86_ld_info)); - ret->addr = (uintptr_t) fix_addr; - ret->reg = (*(fix_addr+ 2)) & 0xf; - printf_log(LOG_DEBUG, "debug find ld so 0x%lx reg = %d\n", ret->addr, ret->reg); - return ret; - } - // debian sid GNU C Library (Debian GLIBC 2.41-7) stable release version 2.41. addr 0x4008403ffe - fix_addr = (uint8_t *)(ld_start+ 0xdffe); - if ((*(uint64_t *)fix_addr & 0xffffffffff00ffff) == 0x0800000354008041) { - ret = malloc(sizeof(struct x86_ld_info)); - ret->addr = (uintptr_t) fix_addr; - ret->reg = (*(fix_addr+ 2)) & 0xf; - printf_log(LOG_DEBUG, "debug find ld so 0x%lx reg = %d\n", ret->addr, ret->reg); - return ret; - } - return find_ld_part((char *)ld_start, file_len); - return NULL; + return kzt_glibc_loader_event_source_hook(source); } -void init_tb_callback_bridge(CPUState *cpu, void* info) +static void kzt_handle_missing_glibc_loader_event_source( + KztGlibcLoaderEventSource *source) { - struct image_info * execinfo = (struct image_info *)info; - static uint32 jmpinst_exec [2] = {0}; - static uint32 jmpinst_ld [2] = {0}; - if (!ld_info) { - ld_info = find_ld_bridge(info); + printf_log(LOG_NONE, + "KZT: cannot find %s event source, use r_debug events\n", + kzt_glibc_loader_event_source_name(source)); +} + +static int kzt_prepare_glibc_loader_event_source( + KztGlibcLoaderEventSource *source, + void *info) +{ + if (kzt_resolve_glibc_loader_event_source(source, info)) { + return 1; } - if (!ld_info) { - lsassertm(0,"can't find ld callback tb."); - option_kzt = 0; - return; + + kzt_handle_missing_glibc_loader_event_source(source); + return 0; +} + +static int kzt_install_callback_bridges(CPUState *cpu, + struct image_info *execinfo, + uint32 *exec_saved_inst, + uint32 *loader_saved_inst, + KztGlibcLoaderEventSource *source) +{ + if (!cpu || !execinfo || !exec_saved_inst) + return 0; + + if (!kzt_install_exec_entry_callback(cpu, execinfo, exec_saved_inst)) + return 0; + if (!loader_saved_inst) { + kzt_handle_missing_glibc_loader_event_source(source); + return 1; + } + if (!kzt_prepare_glibc_loader_event_source(source, execinfo)) + return 1; + if (!kzt_install_glibc_loader_event_source(cpu, loader_saved_inst, + source)) { + kzt_handle_missing_glibc_loader_event_source(source); } + return 1; +} + +static int kzt_install_callback_bridges_preserve_eip( + CPUState *cpu, + struct image_info *execinfo, + uint32 *exec_saved_inst, + uint32 *loader_saved_inst, + KztGlibcLoaderEventSource *source) +{ + if (!cpu || !cpu->env_ptr) + return 0; + CPUArchState *env = cpu->env_ptr; target_ulong eip = env->eip; - kzt_add_fucn_by_addr((uint32 *)&jmpinst_exec, cpu, execinfo->exec_entry, target_latx_ld_callback, kzt_exectb_callback); - kzt_add_fucn_by_addr((uint32 *)&jmpinst_ld, cpu, ld_info->addr, target_latx_ld_callback, kzt_tb_callback); + + int installed = kzt_install_callback_bridges( + cpu, execinfo, exec_saved_inst, loader_saved_inst, source); env->eip = eip; + return installed; +} + +static void kzt_init_callback_bridge(CPUState *cpu, + struct image_info *execinfo) +{ + static uint32 jmpinst_exec [2] = {0}; + static uint32 jmpinst_ld [2] = {0}; + KztGlibcLoaderEventSource *source = + kzt_glibc_loader_event_source_default(); + + kzt_glibc_loader_event_source_prepare(source, execinfo); + if (execinfo && execinfo->interpreter_path && execinfo->load_bias) { + kzt_prepare_r_debug_event_source(execinfo->interpreter_path, + execinfo->load_bias); + } + if (!kzt_install_callback_bridges_preserve_eip( + cpu, execinfo, (uint32 *)&jmpinst_exec, + (uint32 *)&jmpinst_ld, source)) { + option_kzt = 0; + wine_option_kzt = 0; + } +} + +void init_tb_callback_bridge(CPUState *cpu, void* info) +{ + kzt_init_callback_bridge(cpu, (struct image_info *)info); } void kzt_bridge_init(void) { @@ -2694,6 +4998,105 @@ static void m_handle_wine64(char * file_name, abi_ulong start) init_main_elf(wine_elf_header, -1, start, info->alignment); fclose(f); } + +static size_t kzt_elf_section_size(elfheader_t *h, const char *name) +{ + if (!h || !h->SHEntries || !h->numSHEntries || !h->SHStrTab || !name) + return 0; + + int index = FindSection(h->SHEntries, h->numSHEntries, h->SHStrTab, name); + + if (index <= 0) + return 0; + if (strcmp(h->SHStrTab + h->SHEntries[index].sh_name, name)) + return 0; + return h->SHEntries[index].sh_size; +} + +static int kzt_elf_symbol_name_is_valid(const Elf64_Sym *sym, + const char *strings, + size_t strings_size) +{ + if (!strings || !strings_size || sym->st_name >= strings_size) + return 0; + + return memchr(strings + sym->st_name, '\0', + strings_size - sym->st_name) != NULL; +} + +static uintptr_t kzt_resolve_elf_symbol(Elf64_Sym *symbols, size_t count, + const char *strings, + size_t strings_size, + abi_ulong start, const char *name) +{ + if (!symbols || !strings || !strings_size || !name) + return 0; + + for (size_t i = 0; i < count; ++i) { + Elf64_Sym *sym = symbols + i; + if (!kzt_elf_symbol_name_is_valid(sym, strings, strings_size)) + continue; + + const char *symname = strings + sym->st_name; + if (sym->st_shndx != SHN_UNDEF && sym->st_value + && !strcmp(symname, name)) { + return (uintptr_t)start + sym->st_value; + } + } + return 0; +} + +static uintptr_t kzt_resolve_loader_symbol(char *file_name, abi_ulong start, + const char *name) +{ + char *real_file = ResolveFile(kzt_object_basename(file_name), + &my_context->box64_ld_lib); + if (!real_file) + return 0; + + FILE *f = fopen(real_file, "rb"); + if (!f) { + printf_log(LOG_INFO, "%s Error: Cannot open \"%s\"\n", + __func__, real_file); + free(real_file); + return 0; + } + + elfheader_t *h = LoadAndCheckElfHeader(f, real_file, 0); + fclose(f); + if (!h) { + free(real_file); + return 0; + } + + uintptr_t addr = kzt_resolve_elf_symbol(h->DynSym, h->numDynSym, + h->DynStr, h->szDynStrTab, + start, name); + if (!addr) { + size_t strtab_size = kzt_elf_section_size(h, ".strtab"); + addr = kzt_resolve_elf_symbol(h->SymTab, h->numSymTab, + h->StrTab, strtab_size, start, name); + } + FreeElfHeader(&h); + free(real_file); + return addr; +} + +static void kzt_prepare_r_debug_event_source(char *file_name, abi_ulong start) +{ + KztRDebugEventSource *source = kzt_r_debug_event_source_default(); + + source->addr = kzt_resolve_loader_symbol(file_name, start, "_r_debug"); + if (!source->addr) { + printf_log(LOG_NONE, + "KZT: cannot find _r_debug in guest loader %s\n", + file_name); + return; + } + printf_log(LOG_DEBUG, "KZT: use _r_debug at %p from %s\n", + (void *)source->addr, file_name); +} + static void m_handle_ld(char * file_name, abi_ulong start) { elf_header = wine_elf_header; diff --git a/target/i386/latx/context/obstack.c b/target/i386/latx/context/obstack.c index 00f37dc0065..0dadaee881e 100644 --- a/target/i386/latx/context/obstack.c +++ b/target/i386/latx/context/obstack.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #define _LARGEFILE_SOURCE 1 #define _FILE_OFFSET_BITS 64 #include diff --git a/target/i386/latx/context/pathcoll.c b/target/i386/latx/context/pathcoll.c index 3fca071c04d..27fd7e8dbc1 100755 --- a/target/i386/latx/context/pathcoll.c +++ b/target/i386/latx/context/pathcoll.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/sdl2rwops.c b/target/i386/latx/context/sdl2rwops.c index 196bbbf1148..9e496315782 100644 --- a/target/i386/latx/context/sdl2rwops.c +++ b/target/i386/latx/context/sdl2rwops.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/symbols.c b/target/i386/latx/context/symbols.c index db95b3109f9..0c12a5419b0 100644 --- a/target/i386/latx/context/symbols.c +++ b/target/i386/latx/context/symbols.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include diff --git a/target/i386/latx/context/wrappedgio2.c b/target/i386/latx/context/wrappedgio2.c index 1ffd432a20e..9627374e77a 100644 --- a/target/i386/latx/context/wrappedgio2.c +++ b/target/i386/latx/context/wrappedgio2.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedgtk3.c b/target/i386/latx/context/wrappedgtk3.c index 39f55891f15..1f41d0b3219 100644 --- a/target/i386/latx/context/wrappedgtk3.c +++ b/target/i386/latx/context/wrappedgtk3.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibc.c b/target/i386/latx/context/wrappedlibc.c index 8f1480dfec6..4a4562bbdee 100644 --- a/target/i386/latx/context/wrappedlibc.c +++ b/target/i386/latx/context/wrappedlibc.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include "config-host.h" #define _LARGEFILE_SOURCE 1 #define _FILE_OFFSET_BITS 64 @@ -3494,13 +3502,17 @@ int box64_isglibc234 = 1; #include "fileutils.h" #include "library.h" -#define FORWORDBACK 0 dlprivate_t *NewDLPrivate(void) { dlprivate_t* dl = (dlprivate_t*)box_calloc(1, sizeof(dlprivate_t)); return dl; } void FreeDLPrivate(dlprivate_t **lib) { + box_free((*lib)->libs); + box_free((*lib)->handles); + box_free((*lib)->count); + box_free((*lib)->dlopened); box_free((*lib)->last_error); + box_free((*lib)->last_error_returned); box_free(*lib); } @@ -3515,8 +3527,12 @@ void* my_dlvsym(void *handle, void *symbol, const char *vername) EXPORT; int my_dlinfo(void* handle, int request, void* info) EXPORT; -#define CLEARERR if(dl->last_error) box_free(dl->last_error); dl->last_error = NULL; -//#define R_RSP cpu->regs[R_ESP] +#define CLEARERR do { \ + box_free(dl->last_error); \ + dl->last_error = NULL; \ + box_free(dl->last_error_returned); \ + dl->last_error_returned = NULL; \ +} while (0); static void Push64(CPUX86State *cpu, uint64_t v) { cpu->regs[R_ESP] -= 8; @@ -3536,26 +3552,331 @@ int init_x86dlfun(void) #endif h = loadElfFromFile("libc.so.6"); lsassert(h); - const char* syms[] = {"dlopen", "dlsym", "dlclose", "dladdr", "dladdr1", "dlinfo"}; - void *rsyms[6] = {0}; + const char* syms[] = { + "dlopen", "dlmopen", "dlsym", "dlclose", "dladdr", "dladdr1", + "dlinfo", "dlvsym", "dlerror" + }; + void *rsyms[9] = {0}; int rrsyms = 0; - ResetSpecialCaseElf(h, syms, 6, rsyms, &rrsyms); - if (rrsyms != 6) { + ResetSpecialCaseElf(h, syms, 9, rsyms, &rrsyms); + if (rrsyms != 9) { h = loadElfFromFile("libdl.so.2"); - ResetSpecialCaseElf(h, syms, 6, rsyms, &rrsyms); + ResetSpecialCaseElf(h, syms, 9, rsyms, &rrsyms); } - lsassert(rrsyms == 6); + lsassert(rrsyms == 9); my_context->dlprivate->x86dlopen = rsyms[0]; - my_context->dlprivate->x86dlsym = rsyms[1]; - my_context->dlprivate->x86dlclose = rsyms[2]; - my_context->dlprivate->x86dladdr = rsyms[3]; - my_context->dlprivate->x86dladdr1 = rsyms[4]; - my_context->dlprivate->x86dlinfo = rsyms[5]; + my_context->dlprivate->x86dlmopen = rsyms[1]; + my_context->dlprivate->x86dlsym = rsyms[2]; + my_context->dlprivate->x86dlclose = rsyms[3]; + my_context->dlprivate->x86dladdr = rsyms[4]; + my_context->dlprivate->x86dladdr1 = rsyms[5]; + my_context->dlprivate->x86dlinfo = rsyms[6]; + my_context->dlprivate->x86dlvsym = rsyms[7]; + my_context->dlprivate->x86dlerror = rsyms[8]; kzt_wine_init_x86(); return 0; } -static int callx86dlopen(void *filename, int flag, elfheader_t * h, int is_local) { - struct link_map* ret = (struct link_map*)(uintptr_t)RunFunctionWithState((uintptr_t)my_context->dlprivate->x86dlopen, 2, filename, flag); + +static uintptr_t kzt_call_guest_dlopen(void *filename, int flag) +{ + return RunFunctionWithState( + (uintptr_t)my_context->dlprivate->x86dlopen, 2, filename, flag); +} + +static uintptr_t kzt_call_guest_dlmopen(void *lmid, void *filename, int flag) +{ + return RunFunctionWithState( + (uintptr_t)my_context->dlprivate->x86dlmopen, 3, lmid, filename, + flag); +} + +static uintptr_t kzt_call_guest_dlsym(void *handle, void *symbol) +{ + return RunFunctionWithState( + (uintptr_t)my_context->dlprivate->x86dlsym, 2, handle, symbol); +} + +static int kzt_call_guest_dlclose(void *handle) +{ + return RunFunctionWithState( + (uintptr_t)my_context->dlprivate->x86dlclose, 1, handle); +} + +static uintptr_t kzt_call_guest_dlerror(void) +{ + return RunFunctionWithState( + (uintptr_t)my_context->dlprivate->x86dlerror, 0); +} + +static char *kzt_dlerror_take_local(dlprivate_t *dl) +{ + box_free(dl->last_error_returned); + dl->last_error_returned = dl->last_error; + dl->last_error = NULL; + return dl->last_error_returned; +} + +static int kzt_call_guest_dladdr(void *addr, void *info) +{ + return RunFunctionWithState( + (uintptr_t)my_context->dlprivate->x86dladdr, 2, addr, info); +} + +static int kzt_call_guest_dladdr1(void *addr, void *info, void **extra_info, + int flags) +{ + return RunFunctionWithState( + (uintptr_t)my_context->dlprivate->x86dladdr1, 4, addr, info, + extra_info, flags); +} + +static int kzt_dladdr1_set_link_map_result(void **extra_info, library_t *lib) +{ + /* + * The local fallback resolves native wrapper addresses that guest dladdr1() + * cannot see. If the wrapper already has a guest identity, keep the + * externally visible link_map in the same guest namespace as dlinfo(). + */ + if (!extra_info) + return 0; + + if (lib && lib->x86linkmap) { + *(struct link_map **)extra_info = lib->x86linkmap; + return 1; + } + + linkmap_t *local_map = getLinkMapLib(lib); + if (!local_map) + return 0; + + *(linkmap_t **)extra_info = local_map; + return 1; +} + +static int kzt_call_guest_dlinfo(void *handle, int request, void *info) +{ + return RunFunctionWithState( + (uintptr_t)my_context->dlprivate->x86dlinfo, 3, handle, request, info); +} + +static uintptr_t kzt_call_guest_dlvsym(void *handle, void *symbol, + const char *vername) +{ + return RunFunctionWithState( + (uintptr_t)my_context->dlprivate->x86dlvsym, 3, handle, symbol, + vername); +} + +static void kzt_forward_guest_dlsym(CPUX86State *cpu) +{ + Push64(cpu, (uint64_t)my_context->dlprivate->x86dlsym); +} + +static void kzt_forward_guest_dlvsym(CPUX86State *cpu) +{ + Push64(cpu, (uint64_t)my_context->dlprivate->x86dlvsym); +} + +static void *kzt_dl_make_handle(library_t *lib, size_t index) +{ + if (lib && lib->x86linkmap) + return lib->x86linkmap; + + return (void *)(index + 1); +} + +static void *kzt_dl_return_handle(dlprivate_t *dl, size_t index) +{ + return dl->handles[index]; +} + +static void kzt_dl_set_return_handle(dlprivate_t *dl, size_t index, + library_t *lib) +{ + dl->handles[index] = kzt_dl_make_handle(lib, index); +} + +static int kzt_dl_is_local_synthetic_handle(library_t *lib, void *handle, + size_t index) +{ + return lib && lib->type != LIB_EMULATED && handle == (void *)(index + 1); +} + +static void kzt_dl_retain_handle(dlprivate_t *dl, size_t index) +{ + dl->count[index]++; +} + +static void kzt_dl_reserve_handle(dlprivate_t *dl) +{ + if (dl->lib_sz != dl->lib_cap) + return; + + dl->lib_cap += 4; + dl->libs = (library_t**)box_realloc( + dl->libs, sizeof(library_t*) * dl->lib_cap); + dl->handles = (void**)box_realloc( + dl->handles, sizeof(void*) * dl->lib_cap); + dl->count = (size_t*)box_realloc( + dl->count, sizeof(size_t) * dl->lib_cap); + dl->dlopened = (size_t*)box_realloc( + dl->dlopened, sizeof(size_t) * dl->lib_cap); + memset(dl->libs + dl->lib_sz, 0, + (dl->lib_cap - dl->lib_sz) * sizeof(library_t*)); + memset(dl->count + dl->lib_sz, 0, + (dl->lib_cap - dl->lib_sz) * sizeof(size_t)); + memset(dl->handles + dl->lib_sz, 0, + (dl->lib_cap - dl->lib_sz) * sizeof(void*)); + memset(dl->dlopened + dl->lib_sz, 0, + (dl->lib_cap - dl->lib_sz) * sizeof(size_t)); +} + +static size_t kzt_dl_add_handle(dlprivate_t *dl, library_t *lib, + size_t local_owner) +{ + kzt_dl_reserve_handle(dl); + + size_t index = dl->lib_sz++; + dl->libs[index] = lib; + dl->count[index]++; + dl->dlopened[index] = local_owner; + kzt_dl_set_return_handle(dl, index, lib); + return index; +} + +static int kzt_dl_handle_is_closed(dlprivate_t *dl, size_t index) +{ + return dl->count[index] == 0; +} + +static int kzt_dl_release_handle(dlprivate_t *dl, size_t index) +{ + if (kzt_dl_handle_is_closed(dl, index)) + return 0; + + dl->count[index]--; + return dl->count[index] == 0; +} + +static library_t *kzt_dl_handle_library(dlprivate_t *dl, size_t index) +{ + return dl->libs[index]; +} + +static size_t kzt_dl_handle_count(dlprivate_t *dl, size_t index) +{ + return dl->count[index]; +} + +static size_t kzt_dl_handle_local_owner(dlprivate_t *dl, size_t index) +{ + return dl->dlopened[index]; +} + +static int kzt_dl_find_handle_by_name(dlprivate_t *dl, const char *name, + size_t *index) +{ + for (size_t i = 0; i < dl->lib_sz; i++) { + if (IsSameLib(kzt_dl_handle_library(dl, i), name)) { + *index = i; + return 1; + } + } + + return 0; +} + +static int kzt_dl_handle_needs_guest_reopen(dlprivate_t *dl, size_t index, + library_t *lib) +{ + return kzt_dl_handle_is_closed(dl, index) + && lib && !lib->x86linkmap; +} + +static void kzt_dl_deactivate_library(library_t *lib) +{ + if (IsEmuLib(lib)) + return; + + InactiveLibrary(lib); +} + +static void kzt_dlopen_set_sync_error(dlprivate_t *dl, void *filename, + int flag) +{ + const char *name = filename ? (char *)filename : "NULL"; + + if(!dl->last_error) + dl->last_error = box_malloc(129); + snprintf(dl->last_error, 129, "filename \"%s\" flag=%x\n", + name, flag); +} + +static void *kzt_dlopen_guest_library(void *filename, int flag) +{ + const char *name = filename ? (char *)filename : "NULL"; + uint64_t ret = kzt_call_guest_dlopen(filename, flag); + printf_dlsym(LOG_DEBUG, "warning call call x86dlopen filename %s %x ret=0x%lx\n", + name, flag, ret); + + if (ret) + return (void *)ret; + + printf_dlsym(LOG_NEVER, "%p return %p\n", (void*)NULL, (void*)NULL); + return NULL; +} + +static int kzt_dlopen_is_noload(int flag) +{ + return flag & 0x4; +} + +static int kzt_dlopen_add_wrapped_library(dlprivate_t *dl, void *filename, + char *rfilename, int flag, + int is_local, int bindnow, + const char **libs) +{ + if(AddNeededLib(NULL, NULL, NULL, is_local, bindnow, libs, 1, my_context)) { + printf_dlsym(strchr(rfilename,'/')?LOG_DEBUG:LOG_INFO, + "Warning: Cannot dlopen(\"%s\"/%p, %X)\n", + rfilename, filename, flag); + if(!dl->last_error) + dl->last_error = box_malloc(129); + snprintf(dl->last_error, 129, "Cannot dlopen(\"%s\"/%p, %X)\n", + rfilename, filename, flag); + return -1; + } + + return 0; +} + +static void kzt_dlopen_set_name_too_long_error(dlprivate_t *dl, + const char *filename) +{ + size_t name_len = filename ? strnlen(filename, MAX_PATH) : 0; + + if(!dl->last_error) + dl->last_error = box_malloc(129); + snprintf(dl->last_error, 129, "filename too long, length >= %zu\n", + name_len); +} + +static int kzt_dlopen_replace_filename(char *rfilename, + size_t rfilename_size, + const char *replacement) +{ + if (strlen(replacement) >= rfilename_size) + return 0; + + strcpy(rfilename, replacement); + return 1; +} + +static int kzt_dlopen_sync_guest_link_map(void *filename, int flag, + elfheader_t *h, int is_local) +{ + struct link_map* ret = + (struct link_map*)(uintptr_t)kzt_call_guest_dlopen(filename, flag); if (ret) { printf_dlsym(LOG_DEBUG, "latx RunFunctionWithState dlopen %s addr %p\n", (char *)filename, (void *)ret->l_addr); h->lib->x86linkmap = ret; @@ -3572,24 +3893,211 @@ static int callx86dlopen(void *filename, int flag, elfheader_t * h, int is_local lib_t *maplib = (is_local)?h->lib->maplib:my_context->maplib; if(AddSymbolsLibrary(maplib, h->lib)) { // also add needed libs printf_dlsym(LOG_INFO, "Failure to Add lib => fail\n"); - lsassert(0); + (void)kzt_call_guest_dlclose(ret); + h->lib->x86linkmap = NULL; + h->latx_hasfix = 0; + return -1; } return 0; } -static void LatxResetElf(elfheader_t * h) + +static int kzt_dlopen_sync_native_guest_link_map(void *filename, int flag, + library_t *lib) +{ + struct link_map *ret = + (struct link_map *)(uintptr_t)kzt_call_guest_dlopen(filename, flag); + if (!ret) + return -1; + + printf_dlsym(LOG_DEBUG, "latx RunFunctionWithState dlopen %s native addr %p\n", + (char *)filename, (void *)ret->l_addr); + lib->x86linkmap = ret; + return 0; +} + +static int kzt_dlopen_retain_guest_link_map(void *filename, int flag, + library_t *lib) +{ + struct link_map *ret = + (struct link_map *)(uintptr_t)kzt_call_guest_dlopen(filename, flag); + if (!ret) + return -1; + + lib->x86linkmap = ret; + return 0; +} + +static int kzt_dlopen_sync_wrapped_guest(library_t *lib, char *rfilename, + int flag, int is_local) +{ + if (lib->type != LIB_EMULATED) + return kzt_dlopen_sync_native_guest_link_map(rfilename, flag, lib); + + int libidx = GetElfIndex(lib); + lsassert(libidx >= 0); + elfheader_t * h = my_context->elfs[libidx]; + lsassert(h); + /* Wrapped emulated libraries still need a guest link_map for dlsym/dlclose. */ + if (!h->latx_hasfix || !lib->x86linkmap) { + return kzt_dlopen_sync_guest_link_map(rfilename, flag, h, is_local); + } + + /* + * The library may already be present as a guest dependency. An explicit + * dlopen still has to retain the guest loader reference because dlclose() + * will release it through the guest handle. + */ + return kzt_dlopen_retain_guest_link_map(rfilename, flag, lib); +} + +static void *kzt_dlopen_existing_handle(dlprivate_t *dl, char *rfilename, + int flag, int is_local, + size_t handle_index) +{ + library_t *handle_lib = kzt_dl_handle_library(dl, handle_index); + if(kzt_dl_handle_needs_guest_reopen(dl, handle_index, handle_lib)) { + int idx = GetElfIndex(handle_lib); + printf_dlsym(LOG_DEBUG, "dlopen: Recycling guest handle for %p (%s)\n", + (void*)(handle_index+1), rfilename); + if (IsEmuLib(handle_lib)) { + lsassert(idx != -1); + elfheader_t * h = my_context->elfs[idx]; + lsassert(h); + if (kzt_dlopen_sync_guest_link_map(rfilename, flag, h, + is_local)) { + kzt_dlopen_set_sync_error(dl, rfilename, flag); + return NULL; + } + } else if (kzt_dlopen_sync_native_guest_link_map( + rfilename, flag, handle_lib)) { + kzt_dlopen_set_sync_error(dl, rfilename, flag); + return NULL; + } + kzt_dl_set_return_handle(dl, handle_index, handle_lib); + } else if (handle_lib && handle_lib->x86linkmap + && kzt_dlopen_retain_guest_link_map(rfilename, flag, + handle_lib)) { + kzt_dlopen_set_sync_error(dl, rfilename, flag); + return NULL; + } + kzt_dl_retain_handle(dl, handle_index); + printf_dlsym(LOG_DEBUG, "dlopen: Recycling %s/%p count=%ld (local_owner=%ld, elf_index=%d)\n", + rfilename, (void*)(handle_index+1), + kzt_dl_handle_count(dl, handle_index), + kzt_dl_handle_local_owner(dl, handle_index), + GetElfIndex(handle_lib)); + return kzt_dl_return_handle(dl, handle_index); +} + +static void *kzt_dlopen_self_handle(dlprivate_t *dl, int flag) +{ + return kzt_dlopen_guest_library(NULL, flag); +} + +static void *kzt_dlopen_new_handle(dlprivate_t *dl, library_t *lib, + void *filename, size_t local_owner) +{ + size_t idx = kzt_dl_add_handle(dl, lib, local_owner); + printf_dlsym(LOG_DEBUG, "dlopen: New handle %p (%s), local_owner=%ld\n", + (void*)(idx+1), (char*)filename, local_owner); + return kzt_dl_return_handle(dl, idx); +} + +static int kzt_dlopen_expand_filename(char *rfilename, size_t rfilename_size) +{ + while(strstr(rfilename, "${ORIGIN}")) { + char* origin = box_strdup(my_context->fullpath); + char* p = strrchr(origin, '/'); + if(p) *p = '\0'; // remove file name to have only full path, without last '/' + char* tmp = (char*)box_calloc(1, strlen(rfilename)-strlen("${ORIGIN}")+strlen(origin)+1); + p = strstr(rfilename, "${ORIGIN}"); + memcpy(tmp, rfilename, p-rfilename); + strcat(tmp, origin); + strcat(tmp, p+strlen("${ORIGIN}")); + if (!kzt_dlopen_replace_filename(rfilename, rfilename_size, tmp)) { + box_free(tmp); + box_free(origin); + return 0; + } + box_free(tmp); + box_free(origin); + } + while(strstr(rfilename, "${PLATFORM}")) { + char* platform = box_strdup("x86_64"); + char* p = strrchr(platform, '/'); + if(p) *p = '\0'; // remove file name to have only full path, without last '/' + char* tmp = (char*)box_calloc(1, strlen(rfilename)-strlen("${PLATFORM}")+strlen(platform)+1); + p = strstr(rfilename, "${PLATFORM}"); + memcpy(tmp, rfilename, p-rfilename); + strcat(tmp, platform); + strcat(tmp, p+strlen("${PLATFORM}")); + if (!kzt_dlopen_replace_filename(rfilename, rfilename_size, tmp)) { + box_free(tmp); + box_free(platform); + return 0; + } + box_free(tmp); + box_free(platform); + } + if (rfilename[0] == '/' && !FileExist(rfilename, IS_FILE)) { + char filetmp[PATH_MAX] = {0}; + snprintf(filetmp , PATH_MAX, "%s%s", interp_prefix, rfilename); + if (!kzt_dlopen_replace_filename(rfilename, rfilename_size, filetmp)) + return 0; + printf_dlsym(LOG_DEBUG, "dlopen filename change to \"%s\"\n", rfilename); + } + return 1; +} + +typedef enum { + KZT_DLOPEN_LOAD_ERROR = -1, + KZT_DLOPEN_LOAD_LIBRARY, + KZT_DLOPEN_LOAD_DIRECT, +} KztDlopenLoadResult; + +static KztDlopenLoadResult kzt_dlopen_load_named_library( + dlprivate_t *dl, void *filename, char *rfilename, int flag, int is_local, + size_t *local_owner, library_t **lib, void **direct_return) { - h->latx_hasfix = 0; - h->had_RelocateElfPlt = 0; - h->had_RelocateElf = 0; - h->latx_type = 0; - h->latx_hasfix = 0; + *lib = NULL; + *direct_return = NULL; + + if(strstr(rfilename, "libGL.so")){ + strcpy(rfilename, "libGL.so.1"); + } + *local_owner = (GetLibInternal(rfilename)==NULL); + // Then open the lib + const char* libs[] = {rfilename}; + my_context->deferedInit = 1; + int bindnow = (flag&0x2)?1:0; + if (!FindLibIsWrapped(basename(rfilename))) { + *direct_return = kzt_dlopen_guest_library(filename, flag); + return KZT_DLOPEN_LOAD_DIRECT; + } + if (kzt_dlopen_is_noload(flag)) { + *direct_return = kzt_dlopen_guest_library(filename, flag); + return KZT_DLOPEN_LOAD_DIRECT; + } + if(kzt_dlopen_add_wrapped_library(dl, filename, rfilename, flag, + is_local, bindnow, libs)) { + return KZT_DLOPEN_LOAD_ERROR; + } + *lib = GetLibInternal(rfilename); + if (!*lib) return KZT_DLOPEN_LOAD_ERROR; + if (kzt_dlopen_sync_wrapped_guest(*lib, rfilename, flag, is_local)) { + kzt_dlopen_set_sync_error(dl, rfilename, flag); + return KZT_DLOPEN_LOAD_ERROR; + } + //TODO:RunDeferedElfInit; + return KZT_DLOPEN_LOAD_LIBRARY; } + void* my_dlopen(void *filename, int flag){ // TODO, handling special values for filename, like RTLD_SELF? // TODO, handling flags? library_t *lib = NULL; dlprivate_t *dl = my_context->dlprivate; - size_t dlopened = 0; + size_t local_owner = 0; int is_local = (flag&0x100)?0:1; // if not global, then local, and that means symbols are not put in the global "pot" for other libs CLEARERR if (!dl->x86dlopen) { @@ -3598,155 +4106,53 @@ void* my_dlopen(void *filename, int flag){ } if(filename) { char* rfilename = (char*)alloca(MAX_PATH); - strcpy(rfilename, (char*)filename); - printf_dlsym(LOG_DEBUG, "Call to dlopen(\"%s\"/%p, %X)\n", rfilename, filename, flag); - while(strstr(rfilename, "${ORIGIN}")) { - char* origin = box_strdup(my_context->fullpath); - char* p = strrchr(origin, '/'); - if(p) *p = '\0'; // remove file name to have only full path, without last '/' - char* tmp = (char*)box_calloc(1, strlen(rfilename)-strlen("${ORIGIN}")+strlen(origin)+1); - p = strstr(rfilename, "${ORIGIN}"); - memcpy(tmp, rfilename, p-rfilename); - strcat(tmp, origin); - strcat(tmp, p+strlen("${ORIGIN}")); - strcpy(rfilename, tmp); - box_free(tmp); - box_free(origin); - } - while(strstr(rfilename, "${PLATFORM}")) { - char* platform = box_strdup("x86_64"); - char* p = strrchr(platform, '/'); - if(p) *p = '\0'; // remove file name to have only full path, without last '/' - char* tmp = (char*)box_calloc(1, strlen(rfilename)-strlen("${PLATFORM}")+strlen(platform)+1); - p = strstr(rfilename, "${PLATFORM}"); - memcpy(tmp, rfilename, p-rfilename); - strcat(tmp, platform); - strcat(tmp, p+strlen("${PLATFORM}")); - strcpy(rfilename, tmp); - box_free(tmp); - box_free(platform); - } - if (rfilename[0] == '/' && !FileExist(rfilename, IS_FILE)) { - char filetmp[PATH_MAX] = {0}; - snprintf(filetmp , PATH_MAX, "%s%s", interp_prefix, rfilename); - strcpy(rfilename, filetmp); - printf_dlsym(LOG_DEBUG, "dlopen filename change to \"%s\"\n", rfilename); - } - // check if alread dlopenned... - for (size_t i=0; ilib_sz; ++i) { - if(IsSameLib(dl->libs[i], rfilename)) { - if(dl->count[i]==0 && dl->dlopened[i]) { // need to lauch init again! - int idx = GetElfIndex(dl->libs[i]); - if(idx!=-1) { - printf_dlsym(LOG_DEBUG, "dlopen: Recycling, calling Init for %p (%s)\n", (void*)(i+1), rfilename); - //TODO - if (IsEmuLib(dl->libs[i])) { - elfheader_t * h = my_context->elfs[idx]; - lsassert(h); - LatxResetElf(h); - callx86dlopen(rfilename, flag, h, is_local); - } - ReloadLibrary(dl->libs[i]); // reset memory image, redo reloc, run inits - } - } - if(!(flag&0x4)) - dl->count[i] = dl->count[i]+1; - printf_dlsym(LOG_DEBUG, "dlopen: Recycling %s/%p count=%ld (dlopened=%ld, elf_index=%d)\n", rfilename, (void*)(i+1), dl->count[i], dl->dlopened[i], GetElfIndex(dl->libs[i])); - return (void*)(i+1); - } - } - if(strstr(rfilename, "libGL.so")){ - strcpy(rfilename, "libGL.so.1"); - } - dlopened = (GetLibInternal(rfilename)==NULL); - // Then open the lib - const char* libs[] = {rfilename}; - my_context->deferedInit = 1; - int bindnow = (flag&0x2)?1:0; - if (!FindLibIsWrapped(basename(rfilename))) { -#if FORWORDBACK - lsassert(dl->x86dlopen); - __MY_CPU; - Push64(cpu, (uint64_t)dl->x86dlopen); - printf_dlsym(LOG_DEBUG, "warning call x86dlopen filename is %s %x\n", (char *)filename, flag); + if (strnlen((char *)filename, MAX_PATH) == MAX_PATH) { + kzt_dlopen_set_name_too_long_error(dl, filename); return NULL; -#else - uint64_t ret = RunFunctionWithState((uintptr_t)my_context->dlprivate->x86dlopen, 2, filename, flag); - printf_dlsym(LOG_DEBUG, "warning call call x86dlopen filename %s %x ret=0x%lx\n", (char *)filename, flag, ret); - //lsassert(0); - if (ret) { - return (void *)ret; - } - if(!dl->last_error) - dl->last_error = box_malloc(129); - snprintf(dl->last_error, 129, "filename \"%s\" flag=%x\n", (char *)filename, flag); - printf_dlsym(LOG_NEVER, "%p return %p\n", dl->last_error, (void*)NULL); - return NULL; -#endif } - if(AddNeededLib(NULL, NULL, NULL, is_local, bindnow, libs, 1, my_context)) { - printf_dlsym(strchr(rfilename,'/')?LOG_DEBUG:LOG_INFO, "Warning: Cannot dlopen(\"%s\"/%p, %X)\n", rfilename, filename, flag); - if(!dl->last_error) - dl->last_error = box_malloc(129); - snprintf(dl->last_error, 129, "Cannot dlopen(\"%s\"/%p, %X)\n", rfilename, filename, flag); + strcpy(rfilename, (char*)filename); + printf_dlsym(LOG_DEBUG, "Call to dlopen(\"%s\"/%p, %X)\n", rfilename, filename, flag); + if (!kzt_dlopen_expand_filename(rfilename, MAX_PATH)) { + kzt_dlopen_set_name_too_long_error(dl, filename); return NULL; } - lib = GetLibInternal(rfilename); - if (!lib) return NULL; - lib->x86dlopenflag = flag; - if (lib && lib->type == LIB_EMULATED) { - // if dlopened = 0 ---> lib added but not loaded - int libidx = GetElfIndex(lib); - lsassert(libidx >= 0); - elfheader_t * h = my_context->elfs[libidx]; - lsassert(h); - if (!h->latx_hasfix || !lib->x86linkmap) {//lib->x86linkmap is null ---- this lib has been needed by other elf and opened - callx86dlopen(rfilename, flag, h, is_local); - } + size_t handle_index = 0; + if (kzt_dl_find_handle_by_name(dl, rfilename, &handle_index)) { + return kzt_dlopen_existing_handle(dl, rfilename, flag, + is_local, handle_index); } - //TODO:RunDeferedElfInit; + void *direct_return = NULL; + KztDlopenLoadResult load_result = + kzt_dlopen_load_named_library(dl, filename, rfilename, flag, + is_local, &local_owner, &lib, + &direct_return); + if (load_result == KZT_DLOPEN_LOAD_DIRECT) + return direct_return; + if (load_result == KZT_DLOPEN_LOAD_ERROR) + return NULL; } else { - // check if already dlopenned... - for (size_t i=0; ilib_sz; ++i) { - if(!dl->libs[i]) { - dl->count[i] = dl->count[i]+1; - return (void*)(i+1); - } - } - printf_dlsym(LOG_DEBUG, "Call to dlopen(NULL, %X) forword call x86dlopen \n", flag); - lsassert(dl->x86dlopen); - __MY_CPU; - Push64(cpu, (uint64_t)dl->x86dlopen); - return NULL; + return kzt_dlopen_self_handle(dl, flag); } //get the lib and add it to the collection - if(dl->lib_sz == dl->lib_cap) { - dl->lib_cap += 4; - dl->libs = (library_t**)box_realloc(dl->libs, sizeof(library_t*)*dl->lib_cap); - dl->count = (size_t*)box_realloc(dl->count, sizeof(size_t)*dl->lib_cap); - dl->dlopened = (size_t*)box_realloc(dl->dlopened, sizeof(size_t)*dl->lib_cap); - // memset count... - memset(dl->count+dl->lib_sz, 0, (dl->lib_cap-dl->lib_sz)*sizeof(size_t)); - } - intptr_t idx = dl->lib_sz++; - dl->libs[idx] = lib; - dl->count[idx] = dl->count[idx]+1; - dl->dlopened[idx] = dlopened; - printf_dlsym(LOG_DEBUG, "dlopen: New handle %p (%s), dlopened=%ld\n", (void*)(idx+1), (char*)filename, dlopened); - if (lib && lib->type == LIB_EMULATED) { - return lib->x86linkmap; - } - return (void*)(idx+1); + return kzt_dlopen_new_handle(dl, lib, filename, local_owner); } void* my_dlmopen(void* lmid, void *filename, int flag) { - if(lmid) { - printf_dlsym(LOG_INFO, "Warning, dlmopen(%p, %p(\"%s\"), 0x%x) called with lmid not LMID_ID_BASE (unsupported)\n", lmid, filename, filename?(char*)filename:"self", flag); + if (!lmid) + return my_dlopen(filename, flag); + + dlprivate_t *dl = my_context->dlprivate; + CLEARERR + if (!dl->x86dlmopen) { + init_x86dlfun(); + lsassert(dl->x86dlmopen); } - // lmid is ignored for now... - return my_dlopen(filename, flag); + + printf_dlsym(LOG_DEBUG, "Call to guest dlmopen(%p, %p(\"%s\"), 0x%x)\n", + lmid, filename, filename?(char*)filename:"self", flag); + return (void *)kzt_call_guest_dlmopen(lmid, filename, flag); } KHASH_SET_INIT_INT(libs); @@ -3784,6 +4190,249 @@ static int my_dlsym_lib(library_t* lib, const char* rsymbol, uintptr_t *start, u return ret; } +#ifdef LATX_RELOCATION_SAVE_SYMBOLS +static int kzt_dlsym_try_global_fallback(const char *rsymbol, + uintptr_t *start, uintptr_t *end) +{ + return GetGlobalSymbolStartEnd( + my_context->maplib, rsymbol, start, end, NULL, -1, NULL); +} +#endif + +static void kzt_dlsym_set_missing_error(dlprivate_t *dl, const char *rsymbol, + void *handle) +{ + if(!dl->last_error) + dl->last_error = box_malloc(129); + snprintf(dl->last_error, 129, "Symbol \"%s\" not found in %p)\n", + rsymbol, handle); +} + +static void *kzt_dlsym_return_or_missing(dlprivate_t *dl, uint64_t ret, + const char *rsymbol, + void *error_handle) +{ + if (ret) + return (void *)ret; + + kzt_dlsym_set_missing_error(dl, rsymbol, error_handle); + printf_dlsym(LOG_NEVER, "%p return %p\n", dl->last_error, (void*)NULL); + return NULL; +} + +static void kzt_dl_set_closed_handle_error(dlprivate_t *dl, void *handle) +{ + if(!dl->last_error) + dl->last_error = box_malloc(129); + snprintf(dl->last_error, 129, "Bad handle %p (already closed))\n", + handle); +} + +static void kzt_dl_set_bad_handle_error(dlprivate_t *dl, void *handle, + int ret) +{ + if(!dl->last_error) + dl->last_error = box_malloc(129); + snprintf(dl->last_error, 129, "Bad handle %p, ret = %d)\n", + handle, ret); +} + +static int kzt_dl_handle_needs_guest_close(dlprivate_t *dl, size_t index, + library_t *lib) +{ + return lib && lib->x86linkmap; +} + +static void *kzt_dlsym_default_handle(dlprivate_t *dl, void *handle, + void *symbol, const char *rsymbol, + uintptr_t *start, uintptr_t *end) +{ + uint64_t ret = kzt_call_guest_dlsym(handle, symbol); + printf_dlsym(LOG_DEBUG, + "warning call x86dlsym filename is NULL ret=0x%lx\n", + ret); + if (ret) + return (void *)ret; + +#ifdef LATX_RELOCATION_SAVE_SYMBOLS + if(kzt_dlsym_try_global_fallback(rsymbol, start, end)) { + printf_dlsym(LOG_NEVER, "%p\n", (void*)*start); + return (void*)*start; + } +#endif + + printf_dlsym(LOG_NEVER, "debug my %d\n", __LINE__); + return kzt_dlsym_return_or_missing(dl, ret, rsymbol, handle); +} + +static void *kzt_dlsym_next_handle(dlprivate_t *dl) +{ + lsassert(dl->x86dlsym); + __MY_CPU; + /* + * RTLD_NEXT is resolved from the guest caller return address. A direct + * RunFunctionWithState() call would make glibc see this wrapper as the + * caller, so keep the guest-stack forward path for this special handle. + */ + kzt_forward_guest_dlsym(cpu); + printf_dlsym(LOG_DEBUG, "warning call x86dlsym filename is RTLD_NEXT\n"); + return NULL; +} + +static void *kzt_dlsym_guest_handle(void *handle, void *symbol) +{ + uint64_t ret = kzt_call_guest_dlsym(handle, symbol); + printf_dlsym(LOG_DEBUG, "warning call x86dlsym handle %p ret=0x%lx\n", + handle, ret); + return (void *)ret; +} + +static void *kzt_dlsym_library_handle(dlprivate_t *dl, void *handle, + void *symbol, const char *rsymbol, + uintptr_t *start, uintptr_t *end, + library_t *lib) +{ + if (!lib) + return kzt_dlsym_return_or_missing(dl, 0, rsymbol, handle); + + if(!lib->x86linkmap) { + printf_dlsym(LOG_NEVER, "missing guest link_map for %s return %p\n", + lib->name, (void *)NULL); + return kzt_dlsym_return_or_missing(dl, 0, rsymbol, handle); + } + lsassert(dl->x86dlsym); + uint64_t ret = kzt_call_guest_dlsym(lib->x86linkmap, symbol); + printf_dlsym(LOG_DEBUG, "call x86dlsym filename is %s %s ret=0x%lx\n", lib->x86linkmap->l_name, (char *)symbol, ret); + if (!ret) + return kzt_dlsym_return_or_missing(dl, ret, rsymbol, handle); + + /* + * The guest loader decides symbol existence. A local wrapper symbol can + * only replace a successful guest result with the native bridge address. + */ + if(my_dlsym_lib(lib, rsymbol, start, end, -1, NULL)!=0) { + printf_dlsym(LOG_NEVER, "%p\n", (void*)*start); + return (void*)*start; + } + + return (void *)ret; +} + +static void *kzt_dlsym_missing_library_handle(dlprivate_t *dl, void *handle, + const char *rsymbol, + uintptr_t *start, + uintptr_t *end) +{ +#ifdef LATX_RELOCATION_SAVE_SYMBOLS + if(kzt_dlsym_try_global_fallback(rsymbol, start, end)) { + printf_dlsym(LOG_NEVER, "%p\n", (void*)*start); + return (void*)*start; + } +#endif + kzt_dlsym_set_missing_error(dl, rsymbol, handle); + printf_dlsym(LOG_NEVER, "%p\n", NULL); + return NULL; +} + +static void *kzt_dlvsym_library_handle(dlprivate_t *dl, void *handle, + void *symbol, const char *rsymbol, + const char *vername, library_t *lib) +{ + uintptr_t start = 0, end = 0; + + if (lib && IsEmuLib(lib) && lib->x86linkmap) + return (void *)kzt_call_guest_dlvsym(lib->x86linkmap, symbol, + vername); + + if (lib && lib->x86linkmap) { + /* + * Native wrapped libraries still return wrapper-aware entry points, but + * the guest loader must decide whether the requested version exists. + */ + uint64_t ret = kzt_call_guest_dlvsym(lib->x86linkmap, symbol, + vername); + if (!ret) + return kzt_dlsym_return_or_missing(dl, 0, rsymbol, handle); + + if(my_dlsym_lib(lib, rsymbol, &start, &end, -1, NULL)!=0) { + printf_dlsym(LOG_NEVER, "%p\n", (void*)start); + return (void*)start; + } + + return (void *)ret; + } + + return kzt_dlsym_return_or_missing(dl, 0, rsymbol, handle); +} + +static int kzt_dlclose_guest_handle(dlprivate_t *dl, void *handle) +{ + int ret = -1; + + if (dl->x86dlclose) { + return kzt_call_guest_dlclose(handle); + } + + kzt_dl_set_bad_handle_error(dl, handle, ret); + printf_dlsym(LOG_DEBUG, "dlclose: %s\n", dl->last_error); + lsassertm(0,"%s",dl->last_error); + return -1; +} + +static int kzt_dlclose_library_handle(dlprivate_t *dl, void *handle, + size_t nlib, library_t *lib) +{ + if (!lib) { + kzt_dl_set_bad_handle_error(dl, handle, -1); + printf_dlsym(LOG_DEBUG, "dlclose: %s\n", dl->last_error); + return -1; + } + + int idx = GetElfIndex(lib); + int local_owner = kzt_dl_handle_local_owner(dl, nlib); + if (kzt_dl_handle_needs_guest_close(dl, nlib, lib)) { + if (!dl->x86dlclose || !lib->x86linkmap) { + kzt_dl_set_bad_handle_error(dl, handle, -1); + printf_dlsym(LOG_DEBUG, "dlclose: %s\n", dl->last_error); + return -1; + } + + /* Guest dlclose is authoritative for the final reference. */ + int ret = kzt_call_guest_dlclose(lib->x86linkmap); + if (ret) { + kzt_dl_set_bad_handle_error(dl, handle, ret); + printf_dlsym(LOG_DEBUG, "dlclose: %s\n", dl->last_error); + return ret; + } + } + + if(!kzt_dl_release_handle(dl, nlib)) + return 0; + + if (lib) + lib->x86linkmap = NULL; + + if(local_owner && idx!=-1) { + printf_dlsym(LOG_DEBUG, "dlclose: Call to Fini for %p\n", handle); + kzt_dl_deactivate_library(lib); + } + + return 0; +} + +static int kzt_dl_find_handle_by_value(dlprivate_t *dl, void *handle, + size_t *index) +{ + for (size_t i = 0; i < dl->lib_sz; i++) { + if (kzt_dl_return_handle(dl, i) == handle) { + *index = i; + return 1; + } + } + + return 0; +} + void* my_dlsym(void *handle, void *symbol){ dlprivate_t *dl = my_context->dlprivate; uintptr_t start = 0, end = 0; @@ -3793,185 +4442,38 @@ void* my_dlsym(void *handle, void *symbol){ init_x86dlfun(); lsassert(dl->x86dlsym); } - printf_dlsym(LOG_DEBUG, "Call to dlsym(%p, \"%s\")%s\n", handle, rsymbol, dlsym_error?"":"\n"); + printf_dlsym(LOG_DEBUG, "Call to dlsym(%p, \"%s\")%s\n", + handle, rsymbol ? rsymbol : "", + dlsym_error ? "" : "\n"); + if (!symbol) + return kzt_dlsym_guest_handle(handle, symbol); //lsassert(!strstr(rsymbol, "XcursorGetDefaultSize")); if(handle==NULL) { // special case, look globably // special case (RTLD_DEFAULT) -#ifdef LATX_RELOCATION_SAVE_SYMBOLS - if(GetGlobalSymbolStartEnd(my_context->maplib, rsymbol, &start, &end, NULL, -1, NULL)) { - printf_dlsym(LOG_NEVER, "%p\n", (void*)start); - return (void*)start; - } -#endif -#if 0 - lsassert(dl->x86dlsym); - __MY_CPU; - Push64(cpu, (uint64_t)dl->x86dlsym); - printf_dlsym(LOG_DEBUG, "warning call x86dlsym filename is NULL\n"); - return NULL; -#else - uint64_t ret = RunFunctionWithState((uintptr_t)my_context->dlprivate->x86dlsym, 2, handle, symbol); - printf_dlsym(LOG_DEBUG, "warning call x86dlsym filename is NULL ret=0x%lx\n", ret); - if (ret) { - return (void *)ret; - } else { - if(GetGlobalSymbolStartEnd(my_context->maplib, rsymbol, &start, &end, NULL, -1, NULL)) { - printf_dlsym(LOG_NEVER, "%p\n", (void*)start); - return (void*)start; - } - printf_dlsym(LOG_NEVER, "debug my %d\n", __LINE__); - } - if(!dl->last_error) - dl->last_error = box_malloc(129); - snprintf(dl->last_error, 129, "Symbol \"%s\" not found in %p)\n", rsymbol, handle); - printf_dlsym(LOG_NEVER, "%p return %p\n", dl->last_error, (void*)NULL); - return NULL; -#endif + return kzt_dlsym_default_handle(dl, handle, symbol, rsymbol, + &start, &end); } if(handle==(void*)~0LL) { // special case (RTLD_NEXT) -- call x86dlsym - lsassert(dl->x86dlsym); - __MY_CPU; - Push64(cpu, (uint64_t)dl->x86dlsym); - printf_dlsym(LOG_DEBUG, "warning call x86dlsym filename is RTLD_NEXT\n"); - return NULL; - } - size_t nlib = (size_t)handle; - if(nlib > dl->lib_sz) { - for (int i = 0; i < dl->lib_sz; i++) { - if (dl->libs[i] && dl->libs[i]->active && dl->libs[i]->type == LIB_EMULATED && ((size_t)dl->libs[i]->x86linkmap) == nlib) { - nlib = i + 1; - break; - } - } + return kzt_dlsym_next_handle(dl); } - --nlib; - // size_t is unsigned - if(nlib>=dl->lib_sz) { -#ifdef LATX_RELOCATION_SAVE_SYMBOLS - if(GetGlobalSymbolStartEnd(my_context->maplib, rsymbol, &start, &end, NULL, -1, NULL)) { - printf_dlsym(LOG_NEVER, "%p\n", (void*)start); - return (void*)start; - } -#endif - const char* lmfile = ((struct link_map *)handle)->l_name; - if (strlen(lmfile)) { - const char* libs[] = {basename(lmfile)}; - //try to wrapper. - int iswrapped = 0.; - if (FindLibIsWrapped((char *)libs[0])) { - //if file is wrapped. - iswrapped = 1; - printf_dlsym(LOG_DEBUG, "find lib \"%s\" shuold be wrapped. init it.\n", libs[0]); - if(AddNeededLib(NULL, NULL, NULL, 0, 1, libs, 1, my_context)) { - printf_dlsym(LOG_DEBUG, "Warning: Cannot AddNeededLib(\"%s\")\n", libs[0]); - } - printf_dlsym(LOG_DEBUG, "info: success AddNeededLib(\"%s\")\n", libs[0]); - if(GetGlobalSymbolStartEnd(my_context->maplib, rsymbol, &start, &end, NULL, -1, NULL)) { - printf_dlsym(LOG_NEVER, "%p\n", (void*)start); - return (void*)start; - } - } - if (iswrapped) { - //Perhaps exe want to test func for earch libs, return nil. - printf_dlsym(LOG_NEVER, "%p\n", (void*)NULL); - return NULL; - } - } -#if !defined(LATX_RELOCATION_SAVE_SYMBOLS) - else {//dlopen(NULL) --- dlopen self maplink filename is "NULL". - if(GetGlobalSymbolStartEnd(my_context->maplib, rsymbol, &start, &end, NULL, -1, NULL)) { - printf_dlsym(LOG_NEVER, "%p\n", (void*)start); - return (void*)start; - } - } -#endif - __MY_CPU; -#if FORWORDBACK - lsassert(dl->x86dlsym); - Push64(cpu, (uint64_t)dl->x86dlsym); - printf_dlsym(LOG_DEBUG, "warning call x86dlsym filename is %s 0x%lx %s\n", strlen(lmfile)?lmfile:"NULL", cpu->regs[R_EDI], (char*)symbol); - return NULL; -#else - uint64_t ret = RunFunctionWithState((uintptr_t)my_context->dlprivate->x86dlsym, 2, cpu->regs[R_EDI], symbol); - printf_dlsym(LOG_DEBUG, "warning call call x86dlsym filename is %s handle 0x%lx ret=0x%lx\n", strlen(lmfile)?lmfile:"NULL", cpu->regs[R_EDI], ret); - if (ret) { - return (void *)ret; - } - if(!dl->last_error) - dl->last_error = box_malloc(129); - snprintf(dl->last_error, 129, "Symbol \"%s\" not found in %p)\n", rsymbol, handle); - printf_dlsym(LOG_NEVER, "%p return %p\n", dl->last_error, (void*)NULL); - return NULL; -#endif + size_t nlib = 0; + if(!kzt_dl_find_handle_by_value(dl, handle, &nlib)) { + return kzt_dlsym_guest_handle(handle, symbol); } - if(dl->count[nlib]==0) { - if(!dl->last_error) - dl->last_error = box_malloc(129); - snprintf(dl->last_error, 129, "Bad handle %p (already closed))\n", handle); + if(kzt_dl_handle_is_closed(dl, nlib)) { + kzt_dl_set_closed_handle_error(dl, handle); printf_dlsym(LOG_NEVER, "%p return %p\n", dl->last_error, (void*)NULL); return NULL; } - if(dl->libs[nlib]) { - if(my_dlsym_lib(dl->libs[nlib], rsymbol, &start, &end, -1, NULL)==0) { - // not found - __MY_CPU; - #if 1 - if(!dl->libs[nlib]->x86linkmap) { - //redlopen - uint64_t ret = RunFunctionWithState((uintptr_t)my_context->dlprivate->x86dlopen, 2, dl->libs[nlib]->name, dl->libs[nlib]->x86dlopenflag); - if (!ret) {//user sometime test for finding a func. - printf_dlsym(LOG_NEVER, "redlopen %p return %p\n", rsymbol, (void*)NULL); - return NULL; - } - lsassert(ret); - dl->libs[nlib]->x86linkmap = (void *)ret; - ret = RunFunctionWithState((uintptr_t)my_context->dlprivate->x86dlsym, 2, dl->libs[nlib]->x86linkmap , cpu->regs[R_ESI]); - printf_dlsym(LOG_DEBUG, "call x86dlsym filename %s is wrapped but not find symbol, dlsym(%p, %s) ret=0x%lx\n", - dl->libs[nlib]->name, dl->libs[nlib]->x86linkmap, (char *)cpu->regs[R_ESI], ret); - return (void *)ret; - } - #endif - lsassert(dl->x86dlsym); - if (dl->libs[nlib]->x86linkmap != handle) { - cpu->regs[R_EDI] = (uintptr_t)dl->libs[nlib]->x86linkmap; - } -#if FORWORDBACK - Push64(cpu, (uint64_t)dl->x86dlsym); - printf_dlsym(LOG_DEBUG, "warning call x86dlsym filename is %s %lx\n", dl->libs[nlib]->x86linkmap->l_name, cpu->regs[R_EDI]); - return NULL; -#else - uint64_t ret = RunFunctionWithState((uintptr_t)my_context->dlprivate->x86dlsym, 2, cpu->regs[R_EDI], cpu->regs[R_ESI]); - printf_dlsym(LOG_DEBUG, "call x86dlsym filename is %s %s ret=0x%lx\n", dl->libs[nlib]->x86linkmap->l_name, (char *)cpu->regs[R_ESI], ret); - if (ret) { - return (void *)ret; - } - if(!dl->last_error) - dl->last_error = box_malloc(129); - snprintf(dl->last_error, 129, "Symbol \"%s\" not found in %p)\n", rsymbol, handle); - printf_dlsym(LOG_NEVER, "%p return %p\n", dl->last_error, (void*)NULL); - return NULL; -#endif - } - } else { - // still usefull? - // => look globably -#ifdef LATX_RELOCATION_SAVE_SYMBOLS - if(GetGlobalSymbolStartEnd(my_context->maplib, rsymbol, &start, &end, NULL, -1, NULL)) { - printf_dlsym(LOG_NEVER, "%p\n", (void*)start); - return (void*)start; - } -#endif - if(!dl->last_error) - dl->last_error = box_malloc(129); - snprintf(dl->last_error, 129, "Symbol \"%s\" not found in %p)\n", rsymbol, handle); - printf_dlsym(LOG_NEVER, "%p\n", NULL); - lsassertm(0,"%s",dl->last_error); - return NULL; + library_t *lib = kzt_dl_handle_library(dl, nlib); + if(lib) { + return kzt_dlsym_library_handle(dl, handle, symbol, rsymbol, + &start, &end, lib); } - printf_dlsym(LOG_NEVER, "%p\n", (void*)start); - return (void*)start; + return kzt_dlsym_missing_library_handle(dl, handle, rsymbol, + &start, &end); } int my_dlclose(void *handle) @@ -3983,61 +4485,36 @@ int my_dlclose(void *handle) init_x86dlfun(); lsassert(dl->x86dlclose); } - size_t nlib = (size_t)handle; - if(nlib > dl->lib_sz) { - for (int i = 0; i < dl->lib_sz; i++) { - if (dl->libs[i] && dl->libs[i]->active && dl->libs[i]->type == LIB_EMULATED && ((size_t)dl->libs[i]->x86linkmap) == nlib) { - nlib = i + 1; - break; - } - } - } - --nlib; - // size_t is unsigned - if(nlib>=dl->lib_sz) { - int ret = -1; - if (dl->x86dlclose) { - __MY_CPU; - Push64(cpu, (uint64_t)dl->x86dlclose); - return 0; - } - if(!dl->last_error) - dl->last_error = box_malloc(129); - snprintf(dl->last_error, 129, "Bad handle %p, ret = %d)\n", handle, ret); - printf_dlsym(LOG_DEBUG, "dlclose: %s\n", dl->last_error); - lsassertm(0,"%s",dl->last_error); - return -1; + size_t nlib = 0; + if(!kzt_dl_find_handle_by_value(dl, handle, &nlib)) { + return kzt_dlclose_guest_handle(dl, handle); } - if(dl->count[nlib]==0) { - if(!dl->last_error) - dl->last_error = box_malloc(129); - snprintf(dl->last_error, 129, "Bad handle %p (already closed))\n", handle); + if(kzt_dl_handle_is_closed(dl, nlib)) { + kzt_dl_set_closed_handle_error(dl, handle); printf_dlsym(LOG_DEBUG, "dlclose: %s\n", dl->last_error); return -1; } - dl->count[nlib] = dl->count[nlib]-1; - if(dl->count[nlib]==0 && dl->dlopened[nlib]) { // need to call Fini... - int idx = GetElfIndex(dl->libs[nlib]); - if(idx!=-1) { - printf_dlsym(LOG_DEBUG, "dlclose: Call to Fini for %p\n", handle); - InactiveLibrary(dl->libs[nlib]); - if (dl->x86dlclose) { - __MY_CPU; - if (dl->libs[nlib]->x86linkmap != handle) { - cpu->regs[R_EDI] = (uintptr_t)dl->libs[nlib]->x86linkmap; - } - Push64(cpu, (uint64_t)dl->x86dlclose); - return 0; - } - } - } - return 0; + library_t *lib = kzt_dl_handle_library(dl, nlib); + return kzt_dlclose_library_handle(dl, handle, nlib, lib); } char* my_dlerror(void) { dlprivate_t *dl = my_context->dlprivate; - return dl->last_error; + if (!dl->x86dlerror) { + init_x86dlfun(); + lsassert(dl->x86dlerror); + } + if (dl->last_error) { + /* + * Local wrapper errors supersede guest loader errors. Consume the + * guest slot now so a second dlerror() observes the cleared state. + */ + (void)kzt_call_guest_dlerror(); + return kzt_dlerror_take_local(dl); + } + + return (char *)kzt_call_guest_dlerror(); } int my_dladdr1(void *addr, void *i, void** extra_info, int flags) @@ -4051,12 +4528,14 @@ int my_dladdr1(void *addr, void *i, void** extra_info, int flags) } Dl_info *info = (Dl_info*)i; printf_dlsym(LOG_DEBUG, "Warning: partially unimplement call to dladdr/dladdr1(%p, %p, %p, %d)\n", addr, info, extra_info, flags); - __MY_CPU; uint64_t ret = 0; + if (!info) + return kzt_call_guest_dladdr1(addr, i, extra_info, flags); + if (extra_info == NULL && flags == 0) { - ret = RunFunctionWithState((uintptr_t)my_context->dlprivate->x86dladdr, 2, cpu->regs[R_EDI], cpu->regs[R_ESI]); + ret = kzt_call_guest_dladdr(addr, i); } else { - ret = RunFunctionWithState((uintptr_t)my_context->dlprivate->x86dladdr1, 4, cpu->regs[R_EDI], cpu->regs[R_ESI], cpu->regs[R_EDX], cpu->regs[R_ECX]); + ret = kzt_call_guest_dladdr1(addr, i, extra_info, flags); } printf_dlsym(LOG_DEBUG, " call to x86dladdr1 return saddr=%p, fname=\"%s\", sname=\"%s\" ret=%ld\n", info->dli_saddr, info->dli_sname?info->dli_sname:"", info->dli_fname?info->dli_fname:"", ret); if (ret == 1) { @@ -4072,7 +4551,8 @@ int my_dladdr1(void *addr, void *i, void** extra_info, int flags) printf_dlsym(LOG_INFO, "Warning, unimplement call to dladdr1 with RTLD_DL_SYMENT flags\n"); } else if (flags==RTLD_DL_LINKMAP) { printf_dlsym(LOG_INFO, "Warning, partially unimplemented call to dladdr1 with RTLD_DL_LINKMAP flags\n"); - *(linkmap_t**)extra_info = getLinkMapLib(lib); + if (!kzt_dladdr1_set_link_map_result(extra_info, lib)) + return 0; } return (info->dli_sname)?1:0; // success is non-null here... } @@ -4084,12 +4564,12 @@ int my_dladdr(void *addr, void *i) init_x86dlfun(); lsassert(dl->x86dladdr); } -#ifdef CONFIG_LATX_DEBUG Dl_info *info = (Dl_info*)i; -#endif printf_dlsym(LOG_DEBUG, "Warning: partially unimplement call to dladdr(%p, %p)\n", addr, info); - __MY_CPU; - uint64_t ret = RunFunctionWithState((uintptr_t)my_context->dlprivate->x86dladdr, 2, cpu->regs[R_EDI], cpu->regs[R_ESI]); + if (!info) + return kzt_call_guest_dladdr(addr, i); + + uint64_t ret = kzt_call_guest_dladdr(addr, i); printf_dlsym(LOG_DEBUG, " call to x86dladdr return saddr=%p, fname=\"%s\", sname=\"%s\" ret=%ld\n", info->dli_saddr, info->dli_sname?info->dli_sname:"", info->dli_fname?info->dli_fname:"", ret); if (ret == 1) { return ret; @@ -4098,8 +4578,40 @@ int my_dladdr(void *addr, void *i) } void* my_dlvsym(void *handle, void *symbol, const char *vername) { - printf_dlsym(LOG_DEBUG, "Call to dlvsym(%p, \"%s\", %s)", handle, (char *)symbol, vername?vername:"(nil)"); - return my_dlsym(handle, symbol); + char* rsymbol = (char*)symbol; + printf_dlsym(LOG_DEBUG, "Call to dlvsym(%p, \"%s\", %s)\n", + handle, rsymbol ? rsymbol : "", + vername ? vername : "(nil)"); + dlprivate_t *dl = my_context->dlprivate; + CLEARERR + if (!dl->x86dlvsym) { + init_x86dlfun(); + lsassert(dl->x86dlvsym); + } + if (!symbol) + return (void *)kzt_call_guest_dlvsym(handle, symbol, vername); + if (handle == (void*)~0LL) { + __MY_CPU; + /* + * Preserve the guest caller for RTLD_NEXT and keep the version + * argument. Falling back to my_dlsym() would silently drop vername. + */ + kzt_forward_guest_dlvsym(cpu); + return NULL; + } + + size_t nlib = 0; + if (handle == NULL || !kzt_dl_find_handle_by_value(dl, handle, &nlib)) + return (void *)kzt_call_guest_dlvsym(handle, symbol, vername); + + if(kzt_dl_handle_is_closed(dl, nlib)) { + kzt_dl_set_closed_handle_error(dl, handle); + printf_dlsym(LOG_NEVER, "%p return %p\n", dl->last_error, (void*)NULL); + return NULL; + } + library_t *lib = kzt_dl_handle_library(dl, nlib); + return kzt_dlvsym_library_handle(dl, handle, symbol, rsymbol, vername, + lib); } int my_dlinfo(void* handle, int request, void* info) @@ -4107,52 +4619,41 @@ int my_dlinfo(void* handle, int request, void* info) printf_dlsym(LOG_DEBUG, "Call to dlinfo(%p, %d, %p)\n", handle, request, info); dlprivate_t *dl = my_context->dlprivate; CLEARERR - lsassert(0);//latx not support yet. - if (!dl->x86dlopen) { + if (!dl->x86dlinfo) { init_x86dlfun(); - lsassert(dl->x86dlopen); + lsassert(dl->x86dlinfo); } - size_t nlib = (size_t)handle; - if(nlib > dl->lib_sz) { - for (int i = 0; i < dl->lib_sz; i++) { - if (dl->libs[i] && dl->libs[i]->active && dl->libs[i]->type == LIB_EMULATED && ((size_t)dl->libs[i]->x86linkmap) == nlib) { - nlib = i + 1; - break; + size_t nlib = 0; + if (kzt_dl_find_handle_by_value(dl, handle, &nlib)) { + if(kzt_dl_handle_is_closed(dl, nlib)) { + kzt_dl_set_closed_handle_error(dl, handle); + printf_dlsym(LOG_DEBUG, "dlinfo: %s\n", dl->last_error); + return -1; + } + library_t *lib = kzt_dl_handle_library(dl, nlib); + if (kzt_dl_is_local_synthetic_handle(lib, handle, nlib) + && request == RTLD_DI_LINKMAP) { + if (!info) { + kzt_dl_set_bad_handle_error(dl, handle, -1); + printf_dlsym(LOG_DEBUG, "dlinfo: %s\n", dl->last_error); + return -1; } + if (lib && lib->x86linkmap) { + *(struct link_map**)info = lib->x86linkmap; + return 0; + } + kzt_dl_set_bad_handle_error(dl, handle, -1); + printf_dlsym(LOG_DEBUG, "dlinfo: %s\n", dl->last_error); + return -1; } - } - --nlib; - // size_t is unsigned - if(nlib>=dl->lib_sz) { - if(!dl->last_error) - dl->last_error = box_calloc(1, 129); - snprintf(dl->last_error, 129, "Bad handle %p)\n", handle); - printf_dlsym(LOG_DEBUG, "dlinfo: %s\n", dl->last_error); - return -1; - } - #if 0 - if(!dl->dllibs[nlib].count || !dl->dllibs[nlib].full) { - if(!dl->last_error) - dl->last_error = box_calloc(1, 129); - snprintf(dl->last_error, 129, "Bad handle %p (already closed))\n", handle); + if (lib && lib->x86linkmap) + return kzt_call_guest_dlinfo(lib->x86linkmap, request, info); + + kzt_dl_set_bad_handle_error(dl, handle, -1); printf_dlsym(LOG_DEBUG, "dlinfo: %s\n", dl->last_error); return -1; } - #endif - library_t *lib = dl->libs[nlib]; - switch(request) { - case 2: // RTLD_DI_LINKMAP - { - *(linkmap_t**)info = getLinkMapLib(lib); - } - return 0; - default: - printf_dlsym(LOG_NONE, "Warning, unsupported call to dlinfo(%p, %d, %p)\n", handle, request, info); - if(!dl->last_error) - dl->last_error = box_calloc(1, 129); - snprintf(dl->last_error, 129, "unsupported call to dlinfo request:%d\n", request); - } - return -1; + return kzt_call_guest_dlinfo(handle, request, info); } #endif diff --git a/target/i386/latx/context/wrappedlibdl.c b/target/i386/latx/context/wrappedlibdl.c index ce6691aeb30..a7d10b63199 100644 --- a/target/i386/latx/context/wrappedlibdl.c +++ b/target/i386/latx/context/wrappedlibdl.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include @@ -26,7 +34,12 @@ dlprivate_t *NewDLPrivate(void) { return dl; } void FreeDLPrivate(dlprivate_t **lib) { + box_free((*lib)->libs); + box_free((*lib)->handles); + box_free((*lib)->count); + box_free((*lib)->dlopened); box_free((*lib)->last_error); + box_free((*lib)->last_error_returned); box_free(*lib); } @@ -43,7 +56,20 @@ int my_dlinfo(void* handle, int request, void* info) EXPORT; #define LIBNAME libdl const char* libdlName = "libdl.so.2"; -#define CLEARERR if(dl->last_error) box_free(dl->last_error); dl->last_error = NULL; +#define CLEARERR do { \ + box_free(dl->last_error); \ + dl->last_error = NULL; \ + box_free(dl->last_error_returned); \ + dl->last_error_returned = NULL; \ +} while (0); + +static char *dlerror_take_local(dlprivate_t *dl) +{ + box_free(dl->last_error_returned); + dl->last_error_returned = dl->last_error; + dl->last_error = NULL; + return dl->last_error_returned; +} //#define R_RSP cpu->regs[R_ESP] static void Push64(CPUX86State *cpu, uint64_t v) { @@ -56,21 +82,22 @@ int init_x86dlfun(void) { elfheader_t* h = loadElfFromFile("libdl.so.2"); lsassert(h); - const char* syms[] = {"dlopen", "dlsym", "dlclose", "dladdr", "dladdr1", "dlinfo"}; - void *rsyms[6] = {0}; + const char* syms[] = {"dlopen", "dlmopen", "dlsym", "dlclose", "dladdr", "dladdr1", "dlinfo"}; + void *rsyms[7] = {0}; int rrsyms = 0; - ResetSpecialCaseElf(h, syms, 6, rsyms, &rrsyms); - if (rrsyms != 6) { + ResetSpecialCaseElf(h, syms, 7, rsyms, &rrsyms); + if (rrsyms != 7) { h = loadElfFromFile("libc.so.6"); - ResetSpecialCaseElf(h, syms, 6, rsyms, &rrsyms); + ResetSpecialCaseElf(h, syms, 7, rsyms, &rrsyms); } - lsassert(rrsyms == 6); + lsassert(rrsyms == 7); my_context->dlprivate->x86dlopen = rsyms[0]; - my_context->dlprivate->x86dlsym = rsyms[1]; - my_context->dlprivate->x86dlclose = rsyms[2]; - my_context->dlprivate->x86dladdr = rsyms[3]; - my_context->dlprivate->x86dladdr1 = rsyms[4]; - my_context->dlprivate->x86dlinfo = rsyms[5]; + my_context->dlprivate->x86dlmopen = rsyms[1]; + my_context->dlprivate->x86dlsym = rsyms[2]; + my_context->dlprivate->x86dlclose = rsyms[3]; + my_context->dlprivate->x86dladdr = rsyms[4]; + my_context->dlprivate->x86dladdr1 = rsyms[5]; + my_context->dlprivate->x86dlinfo = rsyms[6]; return 0; } static int callx86dlopen(void *filename, int flag, elfheader_t * h, int is_local) { @@ -261,11 +288,20 @@ void* my_dlopen(void *filename, int flag){ void* my_dlmopen(void* lmid, void *filename, int flag) { - if(lmid) { - printf_dlsym(LOG_INFO, "Warning, dlmopen(%p, %p(\"%s\"), 0x%x) called with lmid not LMID_ID_BASE (unsupported)\n", lmid, filename, filename?(char*)filename:"self", flag); + if (!lmid) + return my_dlopen(filename, flag); + + dlprivate_t *dl = my_context->dlprivate; + CLEARERR + if (!dl->x86dlmopen) { + init_x86dlfun(); + lsassert(dl->x86dlmopen); } - // lmid is ignored for now... - return my_dlopen(filename, flag); + + printf_dlsym(LOG_DEBUG, "Call to guest dlmopen(%p, %p(\"%s\"), 0x%x)\n", + lmid, filename, filename?(char*)filename:"self", flag); + return (void *)RunFunctionWithState((uintptr_t)dl->x86dlmopen, 3, + lmid, filename, flag); } KHASH_SET_INIT_INT(libs); @@ -555,7 +591,10 @@ int my_dlclose(void *handle) char* my_dlerror(void) { dlprivate_t *dl = my_context->dlprivate; - return dl->last_error; + if (!dl->last_error) + return NULL; + + return dlerror_take_local(dl); } int my_dladdr1(void *addr, void *i, void** extra_info, int flags) @@ -635,4 +674,3 @@ int my_dlinfo(void* handle, int request, void* info) } #include "wrappedlib_init.h" - diff --git a/target/i386/latx/context/wrappedlibegl.c b/target/i386/latx/context/wrappedlibegl.c index 373d4206508..6b16a579519 100644 --- a/target/i386/latx/context/wrappedlibegl.c +++ b/target/i386/latx/context/wrappedlibegl.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibgl.c b/target/i386/latx/context/wrappedlibgl.c index 565b4f74f9a..02e3faad3a9 100644 --- a/target/i386/latx/context/wrappedlibgl.c +++ b/target/i386/latx/context/wrappedlibgl.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibglu.c b/target/i386/latx/context/wrappedlibglu.c index defb61632ad..062f9514e89 100755 --- a/target/i386/latx/context/wrappedlibglu.c +++ b/target/i386/latx/context/wrappedlibglu.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibglx.c b/target/i386/latx/context/wrappedlibglx.c index f5929ea1369..16e58cac21b 100644 --- a/target/i386/latx/context/wrappedlibglx.c +++ b/target/i386/latx/context/wrappedlibglx.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibva.c b/target/i386/latx/context/wrappedlibva.c index b4287f9a9ef..5f6286d85bd 100644 --- a/target/i386/latx/context/wrappedlibva.c +++ b/target/i386/latx/context/wrappedlibva.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibvadrm.c b/target/i386/latx/context/wrappedlibvadrm.c index 8ed5a1f773f..1ea7168de93 100644 --- a/target/i386/latx/context/wrappedlibvadrm.c +++ b/target/i386/latx/context/wrappedlibvadrm.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibvax11.c b/target/i386/latx/context/wrappedlibvax11.c index ed8f2aed12c..f4917072435 100644 --- a/target/i386/latx/context/wrappedlibvax11.c +++ b/target/i386/latx/context/wrappedlibvax11.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibx11.c b/target/i386/latx/context/wrappedlibx11.c index dae763c0b04..4d11b333524 100644 --- a/target/i386/latx/context/wrappedlibx11.c +++ b/target/i386/latx/context/wrappedlibx11.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibx11xcb.c b/target/i386/latx/context/wrappedlibx11xcb.c index feb61713b0d..8b94d74b361 100644 --- a/target/i386/latx/context/wrappedlibx11xcb.c +++ b/target/i386/latx/context/wrappedlibx11xcb.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxau.c b/target/i386/latx/context/wrappedlibxau.c index 204e9029f63..2367eeb5a1f 100644 --- a/target/i386/latx/context/wrappedlibxau.c +++ b/target/i386/latx/context/wrappedlibxau.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcb.c b/target/i386/latx/context/wrappedlibxcb.c index 5ab331dab89..68bfdcaaffa 100644 --- a/target/i386/latx/context/wrappedlibxcb.c +++ b/target/i386/latx/context/wrappedlibxcb.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbcursor.c b/target/i386/latx/context/wrappedlibxcbcursor.c index 3eeb67e69df..e189a40cc51 100644 --- a/target/i386/latx/context/wrappedlibxcbcursor.c +++ b/target/i386/latx/context/wrappedlibxcbcursor.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbdri2.c b/target/i386/latx/context/wrappedlibxcbdri2.c index b21f4dd8cbe..1ef3208678c 100755 --- a/target/i386/latx/context/wrappedlibxcbdri2.c +++ b/target/i386/latx/context/wrappedlibxcbdri2.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbdri3.c b/target/i386/latx/context/wrappedlibxcbdri3.c index 41744943044..82c7d852e0b 100755 --- a/target/i386/latx/context/wrappedlibxcbdri3.c +++ b/target/i386/latx/context/wrappedlibxcbdri3.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbglx.c b/target/i386/latx/context/wrappedlibxcbglx.c index 29dad07bf33..52ddbdaff35 100644 --- a/target/i386/latx/context/wrappedlibxcbglx.c +++ b/target/i386/latx/context/wrappedlibxcbglx.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbicccm.c b/target/i386/latx/context/wrappedlibxcbicccm.c index 7a4e652cc91..11d59fce95d 100644 --- a/target/i386/latx/context/wrappedlibxcbicccm.c +++ b/target/i386/latx/context/wrappedlibxcbicccm.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbimage.c b/target/i386/latx/context/wrappedlibxcbimage.c index f10d7d3a334..761b0813362 100755 --- a/target/i386/latx/context/wrappedlibxcbimage.c +++ b/target/i386/latx/context/wrappedlibxcbimage.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbkeysyms.c b/target/i386/latx/context/wrappedlibxcbkeysyms.c index 04a496db7ef..4e696dacef8 100755 --- a/target/i386/latx/context/wrappedlibxcbkeysyms.c +++ b/target/i386/latx/context/wrappedlibxcbkeysyms.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbpresent.c b/target/i386/latx/context/wrappedlibxcbpresent.c index dde23fe3bed..c95b495b317 100644 --- a/target/i386/latx/context/wrappedlibxcbpresent.c +++ b/target/i386/latx/context/wrappedlibxcbpresent.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbrandr.c b/target/i386/latx/context/wrappedlibxcbrandr.c index ebe34e5d36b..43930c71634 100755 --- a/target/i386/latx/context/wrappedlibxcbrandr.c +++ b/target/i386/latx/context/wrappedlibxcbrandr.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbrender.c b/target/i386/latx/context/wrappedlibxcbrender.c index a8d9f6529ce..86c6cb68e14 100644 --- a/target/i386/latx/context/wrappedlibxcbrender.c +++ b/target/i386/latx/context/wrappedlibxcbrender.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbrenderutil.c b/target/i386/latx/context/wrappedlibxcbrenderutil.c index 6e8a224620f..536111bb304 100644 --- a/target/i386/latx/context/wrappedlibxcbrenderutil.c +++ b/target/i386/latx/context/wrappedlibxcbrenderutil.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbshape.c b/target/i386/latx/context/wrappedlibxcbshape.c index 8042ad358b1..db28e4f776e 100755 --- a/target/i386/latx/context/wrappedlibxcbshape.c +++ b/target/i386/latx/context/wrappedlibxcbshape.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbshm.c b/target/i386/latx/context/wrappedlibxcbshm.c index f71b97f3ef7..06788334adb 100755 --- a/target/i386/latx/context/wrappedlibxcbshm.c +++ b/target/i386/latx/context/wrappedlibxcbshm.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbsync.c b/target/i386/latx/context/wrappedlibxcbsync.c index c421dfbe71a..993bba8c5f3 100644 --- a/target/i386/latx/context/wrappedlibxcbsync.c +++ b/target/i386/latx/context/wrappedlibxcbsync.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbutil.c b/target/i386/latx/context/wrappedlibxcbutil.c index e7cc0feebdd..792e7dcdcc8 100644 --- a/target/i386/latx/context/wrappedlibxcbutil.c +++ b/target/i386/latx/context/wrappedlibxcbutil.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbxfixes.c b/target/i386/latx/context/wrappedlibxcbxfixes.c index f22fed589e3..6ae838e0940 100755 --- a/target/i386/latx/context/wrappedlibxcbxfixes.c +++ b/target/i386/latx/context/wrappedlibxcbxfixes.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbxinerama.c b/target/i386/latx/context/wrappedlibxcbxinerama.c index c3d586aac6d..bf37d8f53a0 100644 --- a/target/i386/latx/context/wrappedlibxcbxinerama.c +++ b/target/i386/latx/context/wrappedlibxcbxinerama.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbxinput.c b/target/i386/latx/context/wrappedlibxcbxinput.c index 04d10c0e101..ceb78101854 100644 --- a/target/i386/latx/context/wrappedlibxcbxinput.c +++ b/target/i386/latx/context/wrappedlibxcbxinput.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbxkb.c b/target/i386/latx/context/wrappedlibxcbxkb.c index 41d79276dc5..7ffe80d1887 100644 --- a/target/i386/latx/context/wrappedlibxcbxkb.c +++ b/target/i386/latx/context/wrappedlibxcbxkb.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcbxtest.c b/target/i386/latx/context/wrappedlibxcbxtest.c index 7a79cd2ae01..795983b798c 100755 --- a/target/i386/latx/context/wrappedlibxcbxtest.c +++ b/target/i386/latx/context/wrappedlibxcbxtest.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcomposite.c b/target/i386/latx/context/wrappedlibxcomposite.c index 2bb92c54462..9f59bdda015 100755 --- a/target/i386/latx/context/wrappedlibxcomposite.c +++ b/target/i386/latx/context/wrappedlibxcomposite.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxcursor.c b/target/i386/latx/context/wrappedlibxcursor.c index 834d00273d0..50151b43401 100644 --- a/target/i386/latx/context/wrappedlibxcursor.c +++ b/target/i386/latx/context/wrappedlibxcursor.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxdamage.c b/target/i386/latx/context/wrappedlibxdamage.c index bb0a47cfd57..e06d573b665 100755 --- a/target/i386/latx/context/wrappedlibxdamage.c +++ b/target/i386/latx/context/wrappedlibxdamage.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxdmcp.c b/target/i386/latx/context/wrappedlibxdmcp.c index 831296b8e47..935fcad95c9 100644 --- a/target/i386/latx/context/wrappedlibxdmcp.c +++ b/target/i386/latx/context/wrappedlibxdmcp.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxext.c b/target/i386/latx/context/wrappedlibxext.c index 193228d981e..a5e349f5aec 100755 --- a/target/i386/latx/context/wrappedlibxext.c +++ b/target/i386/latx/context/wrappedlibxext.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxfixes.c b/target/i386/latx/context/wrappedlibxfixes.c index f5950085ab8..2c310197d36 100755 --- a/target/i386/latx/context/wrappedlibxfixes.c +++ b/target/i386/latx/context/wrappedlibxfixes.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxft.c b/target/i386/latx/context/wrappedlibxft.c index 4cf4ce1c1b0..dbe415128e4 100644 --- a/target/i386/latx/context/wrappedlibxft.c +++ b/target/i386/latx/context/wrappedlibxft.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxi.c b/target/i386/latx/context/wrappedlibxi.c index bea93aafff4..cc49ed66437 100644 --- a/target/i386/latx/context/wrappedlibxi.c +++ b/target/i386/latx/context/wrappedlibxi.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxmu.c b/target/i386/latx/context/wrappedlibxmu.c index 81e962fa7f4..3e150ef63d1 100755 --- a/target/i386/latx/context/wrappedlibxmu.c +++ b/target/i386/latx/context/wrappedlibxmu.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxpm.c b/target/i386/latx/context/wrappedlibxpm.c index a09e783db08..26b70b9d2fb 100755 --- a/target/i386/latx/context/wrappedlibxpm.c +++ b/target/i386/latx/context/wrappedlibxpm.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxrandr.c b/target/i386/latx/context/wrappedlibxrandr.c index 82daa3ecf6b..0c2e350e1ee 100644 --- a/target/i386/latx/context/wrappedlibxrandr.c +++ b/target/i386/latx/context/wrappedlibxrandr.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxrender.c b/target/i386/latx/context/wrappedlibxrender.c index dbc1307f85f..24df44d14f6 100644 --- a/target/i386/latx/context/wrappedlibxrender.c +++ b/target/i386/latx/context/wrappedlibxrender.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxss.c b/target/i386/latx/context/wrappedlibxss.c index a9a8b8dda5b..bfe9df0334f 100644 --- a/target/i386/latx/context/wrappedlibxss.c +++ b/target/i386/latx/context/wrappedlibxss.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxt.c b/target/i386/latx/context/wrappedlibxt.c index 23be94e6202..d96ecce7305 100644 --- a/target/i386/latx/context/wrappedlibxt.c +++ b/target/i386/latx/context/wrappedlibxt.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxtst.c b/target/i386/latx/context/wrappedlibxtst.c index 1552b25c3f4..7462a8874b2 100644 --- a/target/i386/latx/context/wrappedlibxtst.c +++ b/target/i386/latx/context/wrappedlibxtst.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedlibxxf86vm.c b/target/i386/latx/context/wrappedlibxxf86vm.c index 093ddbb5bf5..0f6b9d3bb18 100644 --- a/target/i386/latx/context/wrappedlibxxf86vm.c +++ b/target/i386/latx/context/wrappedlibxxf86vm.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedvulkan.c b/target/i386/latx/context/wrappedvulkan.c index 2ef36d89603..e3b9a4389b0 100644 --- a/target/i386/latx/context/wrappedvulkan.c +++ b/target/i386/latx/context/wrappedvulkan.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedxinerama.c b/target/i386/latx/context/wrappedxinerama.c index 2354e8d8a4e..ecd29b51a25 100644 --- a/target/i386/latx/context/wrappedxinerama.c +++ b/target/i386/latx/context/wrappedxinerama.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedxkbcommon.c b/target/i386/latx/context/wrappedxkbcommon.c index 155467756ff..1ca78bc735e 100644 --- a/target/i386/latx/context/wrappedxkbcommon.c +++ b/target/i386/latx/context/wrappedxkbcommon.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedxkbcommonx11.c b/target/i386/latx/context/wrappedxkbcommonx11.c index b7d53ab1e46..a1a043674a3 100644 --- a/target/i386/latx/context/wrappedxkbcommonx11.c +++ b/target/i386/latx/context/wrappedxkbcommonx11.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrappedxshmfence.c b/target/i386/latx/context/wrappedxshmfence.c index 2e27f8a9f1b..c19b761062a 100644 --- a/target/i386/latx/context/wrappedxshmfence.c +++ b/target/i386/latx/context/wrappedxshmfence.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrapper.c b/target/i386/latx/context/wrapper.c index 9934603d133..5a1c4aca6cb 100644 --- a/target/i386/latx/context/wrapper.c +++ b/target/i386/latx/context/wrapper.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include #include diff --git a/target/i386/latx/context/wrapperdebug.c b/target/i386/latx/context/wrapperdebug.c index 1ab67ff6cc4..041db5d596c 100644 --- a/target/i386/latx/context/wrapperdebug.c +++ b/target/i386/latx/context/wrapperdebug.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include #include "elfloader_private.h" #include "box64context.h" diff --git a/target/i386/latx/context/wrappertbbridge.c b/target/i386/latx/context/wrappertbbridge.c index 1d02fd5fc3e..0693474f1c9 100644 --- a/target/i386/latx/context/wrappertbbridge.c +++ b/target/i386/latx/context/wrappertbbridge.c @@ -1,3 +1,11 @@ +/* + * This file is derived from Box64. + * + * SPDX-FileCopyrightText: 2020 ptitSeb + * + * SPDX-License-Identifier: MIT + */ + #include "wrappertbbridge.h" static GTree * tree; diff --git a/target/i386/latx/diStorm/config.h b/target/i386/latx/diStorm/config.h deleted file mode 100644 index cc3e92a1f5a..00000000000 --- a/target/i386/latx/diStorm/config.h +++ /dev/null @@ -1,243 +0,0 @@ -/* -config.h - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#ifndef CONFIG_H -#define CONFIG_H - -/* diStorm version number. */ -#define __DISTORMV__ 0x030100 - -#include /* memset, memcpy - can be easily self implemented for libc independency. */ - -#include "distorm.h" - -/* - * 64 bit offsets support: - * This macro should be defined from compiler command line flags, e.g: - * -DSUPPORT_64BIT_OFFSET Note: make sure that the caller (library user) defines - * it too! - */ -/* #define SUPPORT_64BIT_OFFSET */ - -/* - * If you compile diStorm as a dynamic library (.dll or .so) file, make sure you - * uncomment the next line. So the interface functions will be exported, - * otherwise they are useable only for static library. For example, this macro - * is being set for compiling diStorm as a .dll for Python with CTypes. - */ -/* #define DISTORM_DYNAMIC */ - -/* - * diStorm now supports little/big endian CPU's. - * It should detect the endianness according to predefined macro's of the - * compiler. If you don't use GCC/MSVC you will have to define it on your own. - */ - -/* These macros are used in order to make the code portable. */ -#ifdef __GNUC__ - -#include - -#define _DLLEXPORT_ -#define _FASTCALL_ -#define _INLINE_ static -/* GCC ignores this directive... */ -/*#define _FASTCALL_ __attribute__((__fastcall__))*/ - -/* Set endianity (supposed to be LE though): */ -#ifdef __BIG_ENDIAN__ -#define BE_SYSTEM -#endif - -/* End of __GCC__ */ - -#else - -#ifdef __WATCOMC__ - -#include - -#define _DLLEXPORT_ -#define _FASTCALL_ -#define _INLINE_ __inline - -/* End of __WATCOMC__ */ - -#else -#ifdef __DMC__ - -#include - -#define _DLLEXPORT_ -#define _FASTCALL_ -#define _INLINE_ __inline - -/* End of __DMC__ */ - -#else -#ifdef __TINYC__ - -#include - -#define _DLLEXPORT_ -#define _FASTCALL_ -#define _INLINE_ - -/* End of __TINYC__ */ - -#else -#ifdef _MSC_VER - -/* stdint alternative is defined in distorm.h */ - -#define _DLLEXPORT_ __declspec(dllexport) -#define _FASTCALL_ __fastcall -#define _INLINE_ __inline - -/* Set endianity (supposed to be LE though): */ -#if !defined(_M_IX86) && !defined(_M_X64) -#define BE_SYSTEM -#endif - -#endif /* _MSC_VER */ -#endif /* __TINYC__ */ -#endif /* __DMC__ */ -#endif /* __WATCOMC__ */ -#endif /* __GCC__ */ - -/* If the library isn't compiled as a dynamic library don't export any - * functions. */ -#ifndef DISTORM_DYNAMIC -#undef _DLLEXPORT_ -#define _DLLEXPORT_ -#endif - -#ifndef FALSE -#define FALSE 0 -#endif -#ifndef TRUE -#define TRUE 1 -#endif - -/* Define stream read functions for big endian systems. */ -#ifdef BE_SYSTEM -/* - * These functions can read from the stream safely! - * Swap endianity of input to little endian. - */ -static _INLINE_ int16_t RSHORT(const uint8_t *s) { return s[0] | (s[1] << 8); } -static _INLINE_ uint16_t RUSHORT(const uint8_t *s) -{ - return s[0] | (s[1] << 8); -} -static _INLINE_ int32_t RLONG(const uint8_t *s) -{ - return s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24); -} -static _INLINE_ uint32_t RULONG(const uint8_t *s) -{ - return s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24); -} -static _INLINE_ int64_t RLLONG(const uint8_t *s) -{ - return s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24) | - ((uint64_t)s[4] << 32) | ((uint64_t)s[5] << 40) | - ((uint64_t)s[6] << 48) | ((uint64_t)s[7] << 56); -} -static _INLINE_ uint64_t RULLONG(const uint8_t *s) -{ - return s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24) | - ((uint64_t)s[4] << 32) | ((uint64_t)s[5] << 40) | - ((uint64_t)s[6] << 48) | ((uint64_t)s[7] << 56); -} -#else -/* Little endian macro's will just make the cast. */ -#if 1 /* wzj: avoid MDA */ -#define RSHORT(x) *(int16_t *)x -#define RUSHORT(x) *(uint16_t *)x -#define RLONG(x) *(int32_t *)x -#define RULONG(x) *(uint32_t *)x -#define RLLONG(x) *(int64_t *)x -#define RULLONG(x) *(uint64_t *)x -#else -static inline int16_t RSHORT(const uint8_t *s) { return s[0] | (s[1] << 8); } -static inline uint16_t RUSHORT(const uint8_t *s) { return s[0] | (s[1] << 8); } -static inline int32_t RLONG(const uint8_t *s) -{ - int32_t value; - __asm__("lwr %0, (%1) \n\t" - "lwl %0, 3(%1) \n\t" - : "=&r"(value) - : "r"(s)); - return value; -} -static inline uint32_t RULONG(const uint8_t *s) -{ - uint32_t value; - __asm__("lwr %0, (%1) \n\t" - "lwl %0, 3(%1) \n\t" - : "=&r"(value) - : "r"(s)); - return value; -} - -static inline int64_t RLLONG(const uint8_t *s) -{ - if (((long)s) & 7 == 0) - return *(int64_t *)s; - - union { - int64_t value; - int32_t value32[2]; - } u; - - __asm__("lwr %0, (%2) \n\t" - "lwl %0, 3(%2) \n\t" - "lwr %1, 4(%2) \n\t" - "lwl %1, 7(%2) \n\t" - : "=&r"(u.value32[0]), "=&r"(u.value32[1]) - : "r"(s)); - return u.value; -} -static inline uint64_t RULLONG(const uint8_t *s) -{ - if (((long)s) & 7 == 0) - return *(uint64_t *)s; - - union { - uint64_t value; - uint32_t value32[2]; - } u; - - __asm__("lwr %0, (%2) \n\t" - "lwl %0, 3(%2) \n\t" - "lwr %1, 4(%2) \n\t" - "lwl %1, 7(%2) \n\t" - : "=&r"(u.value32[0]), "=&r"(u.value32[1]) - : "r"(s)); - return u.value; -} - -#endif /* wzj: avoid MDA */ -#endif - -#endif /* CONFIG_H */ diff --git a/target/i386/latx/diStorm/decoder.c b/target/i386/latx/diStorm/decoder.c deleted file mode 100644 index 1b1ad64eaff..00000000000 --- a/target/i386/latx/diStorm/decoder.c +++ /dev/null @@ -1,773 +0,0 @@ -/* -decoder.c - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#include "decoder.h" -#include "instructions.h" -#include "insts.h" -#include "prefix.h" -#include "x86defs.h" -#include "operands.h" -#include "mnemonics.h" - -/* Instruction Prefixes - Opcode - ModR/M - SIB - Displacement - Immediate */ - -static _DecodeType decode_get_effective_addr_size(_DecodeType dt, - _iflags decodedPrefixes) -{ - /* - * This table is to map from the current decoding mode to an effective - * address size: Decode16 -> Decode32 Decode32 -> Decode16 Decode64 -> - * Decode32 - */ - static _DecodeType AddrSizeTable[] = {Decode32Bits, Decode16Bits, - Decode32Bits}; - - /* Switch to non default mode if prefix exists, only for ADDRESS SIZE. */ - if (decodedPrefixes & INST_PRE_ADDR_SIZE) - dt = AddrSizeTable[dt]; - return dt; -} - -static _DecodeType decode_get_effective_op_size(_DecodeType dt, - _iflags decodedPrefixes, - unsigned int rex, - _iflags instFlags) -{ - /* - * This table is to map from the current decoding mode to an effective - * operand size: Decode16 -> Decode32 Decode32 -> Decode16 Decode64 -> - * Decode16 Not that in 64bits it's a bit more complicated, because of REX - * and promoted instructions. - */ - static _DecodeType OpSizeTable[] = {Decode32Bits, Decode16Bits, - Decode16Bits}; - - if (decodedPrefixes & INST_PRE_OP_SIZE) - return OpSizeTable[dt]; - - if (dt == Decode64Bits) { - /* - * REX Prefix toggles data size to 64 bits. - * Operand size prefix toggles data size to 16. - * Default data size is 32 bits. - * Promoted instructions are 64 bits if they don't require a REX perfix. - * Non promoted instructions are 64 bits if the REX prefix exists. - */ - /* Automatically promoted instructions have only INST_64BITS SET! */ - if (((instFlags & (INST_64BITS | INST_PRE_REX)) == INST_64BITS) || - /* Other instructions in 64 bits can be promoted only with a REX - prefix. */ - ((decodedPrefixes & INST_PRE_REX) && (rex & PREFIX_EX_W))) - dt = Decode64Bits; - else - dt = Decode32Bits; /* Default. */ - } - return dt; -} - -static _DecodeResult decode_inst(_CodeInfo* ci, _PrefixState* ps, _DInst* di) -{ - /* The ModR/M byte of the current instruction. */ - unsigned int modrm = 0; - - /* The REX/VEX prefix byte value. */ - unsigned int vrex = ps->vrex; - - /* - * Backup original input, so we can use it later if a problem occurs - * (like not enough data for decoding, invalid opcode, etc). - */ - const uint8_t* startCode = ci->code; - - /* Holds the info about the current found instruction. */ - _InstInfo* ii = NULL; - - /* Used only for special CMP instructions which have pseudo opcodes suffix. - */ - unsigned char cmpType = 0; - - /* - * Indicates whether it is right to LOCK the instruction by decoding its - * first operand. Only then you know if it's ok to output the LOCK prefix's - * text... Used for first operand only. - */ - int lockable = FALSE; - - /* Calcualte (and cache) effective-operand-size and effective-address-size - * only once. */ - _DecodeType effOpSz, effAdrSz; - _iflags instFlags; - - ii = inst_lookup(ci, ps); - if (ii == NULL) - goto _Undecodable; - instFlags = INST_INFO_FLAGS(ii); - - /* - * If both REX and OpSize are available we will have to disable the OpSize, - * because REX has precedence. However, only if REX.W is set ! We had to - * wait with this test, since the operand size may be a mandatory prefix, - * and we know it only after prefetching. - */ - if ((ps->prefixExtType == PET_REX) && - (ps->decodedPrefixes & INST_PRE_OP_SIZE) && (!ps->isOpSizeMandatory) && - (vrex & PREFIX_EX_W)) { - ps->decodedPrefixes &= ~INST_PRE_OP_SIZE; - prefixes_ignore(ps, PFXIDX_OP_SIZE); - } - - /* - * In this point we know the instruction we are about to decode and its - operands (unless, it's an invalid one!), - * so it makes it the right time for decoding-type suitability testing. - * Which practically means, don't allow 32 bits instructions in 16 bits - decoding mode, but do allow - * 16 bits instructions in 32 bits decoding mode, of course... - - * NOTE: Make sure the instruction set for 32 bits has explicitly this - specfic flag set. - * NOTE2: Make sure the instruction set for 64 bits has explicitly this - specfic flag set. - - * If this is the case, drop what we've got and restart all over after - DB'ing that byte. - - * Though, don't drop an instruction which is also supported in 16 and 32 - bits. - */ - - /* ! ! ! DISABLED UNTIL FURTHER NOTICE ! ! ! Decode16Bits CAN NOW DECODE 32 - * BITS INSTRUCTIONS ! ! !*/ - /* if (ii && (dt == Decode16Bits) && (instFlags & INST_32BITS) && - * (~instFlags & INST_16BITS)) ii = NULL; */ - - /* Drop instructions which are invalid in 64 bits. */ - if ((ci->dt == Decode64Bits) && (instFlags & INST_INVALID_64BITS)) - goto _Undecodable; - - /* If it's only a 64 bits instruction drop it in other decoding modes. */ - if ((ci->dt != Decode64Bits) && (instFlags & INST_64BITS_FETCH)) - goto _Undecodable; - - if (instFlags & INST_MODRM_REQUIRED) { - /* If the ModRM byte is not part of the opcode, skip the last byte code, - * so code points now to ModRM. */ - if (~instFlags & INST_MODRM_INCLUDED) { - ci->code++; - if (--ci->codeLen < 0) - goto _Undecodable; - } - modrm = *ci->code; - - /* Some instructions enforce that reg=000, so validate that. - * (Specifically EXTRQ). */ - if ((instFlags & INST_FORCE_REG0) && (((modrm >> 3) & 7) != 0)) - goto _Undecodable; - /* Some instructions enforce that mod=11, so validate that. */ - if ((instFlags & INST_MODRR) && (modrm < INST_DIVIDED_MODRM)) - goto _Undecodable; - } - - ci->code++; /* Skip the last byte we just read (either last opcode's byte - code or a ModRM). */ - - /* Cache the effective operand-size and address-size. */ - effOpSz = decode_get_effective_op_size(ci->dt, ps->decodedPrefixes, vrex, - instFlags); - effAdrSz = decode_get_effective_addr_size(ci->dt, ps->decodedPrefixes); - - memset(di, 0, sizeof(_DInst)); - di->base = R_NONE; - - /* - * Try to extract the next operand only if the latter exists. - * For example, if there is not first operand, no reason to try to extract - * second operand... I decided that a for-break is better for readability in - * this specific case than goto. Note: do-while with a constant 0 makes the - * compiler warning about it. - */ - for (;;) { - if (ii->d != OT_NONE) { - if (!operands_extract(ci, di, ii, (_OpType)ii->d, ONT_1, modrm, ps, - effOpSz, effAdrSz, &lockable)) - goto _Undecodable; - } else - break; - - if (ii->s != OT_NONE) { - if (!operands_extract(ci, di, ii, (_OpType)ii->s, ONT_2, modrm, ps, - effOpSz, effAdrSz, NULL)) - goto _Undecodable; - } else - break; - - /* Use third operand, only if the flags says this InstInfo requires it. - */ - if (instFlags & INST_USE_OP3) { - if (!operands_extract(ci, di, ii, (_OpType)((_InstInfoEx*)ii)->op3, - ONT_3, modrm, ps, effOpSz, effAdrSz, NULL)) - goto _Undecodable; - } else - break; - - /* Support for a fourth operand is added for (i.e:) INSERTQ instruction. - */ - if (instFlags & INST_USE_OP4) { - if (!operands_extract(ci, di, ii, (_OpType)((_InstInfoEx*)ii)->op4, - ONT_4, modrm, ps, effOpSz, effAdrSz, NULL)) - goto _Undecodable; - } - break; - } /* Continue here after all operands were extracted. */ - - /* If it were a 3DNow! instruction, we will have to find the instruction - * itself now that we got its operands extracted. */ - if (instFlags & INST_3DNOW_FETCH) { - ii = inst_lookup_3dnow(ci); - if (ii == NULL) - goto _Undecodable; - instFlags = INST_INFO_FLAGS(ii); - } - - /* Check whether pseudo opcode is needed, only for CMP instructions: */ - if (instFlags & INST_PSEUDO_OPCODE) { - if (--ci->codeLen < 0) - goto _Undecodable; - cmpType = *ci->code; - ci->code++; - /* Comparison type must be between 0 to 8, otherwise Reserved. */ - if (cmpType >= INST_CMP_MAX_RANGE) - goto _Undecodable; - } - - /* - * There's a limit of 15 bytes on instruction length. The only way to - * violate this limit is by putting redundant prefixes before an - * instruction. start points to first prefix if any, otherwise it points to - * instruction first byte. - */ - if ((ci->code - ps->start) > INST_MAXIMUM_SIZE) - goto _Undecodable; /* Drop instruction. */ - - /* - * If we reached here the instruction was fully decoded, we located the - * instruction in the DB and extracted operands. Use the correct mnemonic - * according to the DT. If we are in 32 bits decoding mode it doesn't - * necessarily mean we will choose mnemonic2, alas, it means that if there - * is a mnemonic2, it will be used. - */ - - /* Start with prefix LOCK. */ - if ((lockable == TRUE) && (instFlags & INST_PRE_LOCK)) { - ps->usedPrefixes |= INST_PRE_LOCK; - di->flags |= FLAG_LOCK; - } else if ((instFlags & INST_PRE_REPNZ) && - (ps->decodedPrefixes & INST_PRE_REPNZ)) { - ps->usedPrefixes |= INST_PRE_REPNZ; - di->flags |= FLAG_REPNZ; - } else if ((instFlags & INST_PRE_REP) && - (ps->decodedPrefixes & INST_PRE_REP)) { - ps->usedPrefixes |= INST_PRE_REP; - di->flags |= FLAG_REP; - } - - /* If it's JeCXZ the ADDR_SIZE prefix affects them. */ - if ((instFlags & (INST_PRE_ADDR_SIZE | INST_USE_EXMNEMONIC)) == - (INST_PRE_ADDR_SIZE | INST_USE_EXMNEMONIC)) { - ps->usedPrefixes |= INST_PRE_ADDR_SIZE; - if (effAdrSz == Decode16Bits) - di->opcode = ii->opcodeId; - else if (effAdrSz == Decode32Bits) - di->opcode = ((_InstInfoEx*)ii)->opcodeId2; - /* Ignore REX.W in 64bits, JECXZ is promoted. */ - else /* Decode64Bits */ - di->opcode = ((_InstInfoEx*)ii)->opcodeId3; - } - - /* LOOPxx instructions are also native instruction, but they are special - case ones, ADDR_SIZE prefix affects them. */ - else if ((instFlags & (INST_PRE_ADDR_SIZE | INST_NATIVE)) == - (INST_PRE_ADDR_SIZE | INST_NATIVE)) { - di->opcode = ii->opcodeId; - - /* If LOOPxx gets here from 64bits, it must be Decode32Bits because - * Address Size perfix is set. */ - ps->usedPrefixes |= INST_PRE_ADDR_SIZE; - } - /* - * Note: - * If the instruction is prefixed by operand size we will format it in the - * non-default decoding mode! So there might be a situation that an - * instruction of 32 bit gets formatted in 16 bits decoding mode. Both ways - * should end up with a correct and expected formatting of the text. - */ - else if (effOpSz == Decode16Bits) { /* Decode16Bits */ - - /* Set operand size. */ - FLAG_SET_OPSIZE(di, Decode16Bits); - - /* - * If it's a special instruction which has two mnemonics, then use the - * 16 bits one + update usedPrefixes. Note: use 16 bits mnemonic if that - * instruction supports 32 bit or 64 bit explicitly. - */ - if ((instFlags & INST_USE_EXMNEMONIC) && - ((instFlags & (INST_32BITS | INST_64BITS)) == 0)) - ps->usedPrefixes |= INST_PRE_OP_SIZE; - di->opcode = ii->opcodeId; - } else if (effOpSz == Decode32Bits) { /* Decode32Bits */ - - /* Set operand size. */ - FLAG_SET_OPSIZE(di, Decode32Bits); - - /* Give a chance for special mnemonic instruction in 32 bits decoding. - */ - if (instFlags & INST_USE_EXMNEMONIC) { - ps->usedPrefixes |= INST_PRE_OP_SIZE; - /* Is it a special instruction which has another mnemonic for mod=11 - * ? */ - if (instFlags & INST_MNEMONIC_MODRM_BASED) { - if (modrm >= INST_DIVIDED_MODRM) - di->opcode = ii->opcodeId; - else - di->opcode = ((_InstInfoEx*)ii)->opcodeId2; - } - /* Or is it a special CMP instruction which needs a pseudo opcode - suffix ? */ - else if (instFlags & INST_PSEUDO_OPCODE) { - /* - * The opcodeId is the base id of the pseudo compare mnemonics, - * thus we can access the next ones from 0 to 7 safely, because - * they are already allocated. - */ -#ifdef _DISTORM_NO_DEBUG - di->opcode = ii->opcodeId + cmpType; -#else - int i; - unsigned int stringOffset = 0; - /* - * The _MNEMONICS string contains pascal-style strings with the - * length of each mnemonic specified. We will sum each mnemonic - * length to arrive at the final mnemonic offset. - */ - for (i = 0; i < cmpType; i++) { - /* +1 is for the null terminator, +1 is for the length byte - * itself */ - stringOffset += _MNEMONICS[ii->opcodeId + stringOffset] + 2; - } - if (stringOffset > 255) - goto _Undecodable; - di->opcode = ii->opcodeId + stringOffset; -#endif - } else - di->opcode = ((_InstInfoEx*)ii)->opcodeId2; - } else - di->opcode = ii->opcodeId; - } else { /* Decode64Bits, note that some instructions might be decoded in - Decode32Bits above. */ - - /* Set operand size. */ - FLAG_SET_OPSIZE(di, Decode64Bits); - - if (instFlags & (INST_USE_EXMNEMONIC | INST_USE_EXMNEMONIC2)) { - /* Use third mnemonic, for 64 bits. */ - if ((instFlags & INST_USE_EXMNEMONIC2) && (vrex & PREFIX_EX_W)) { - ps->usedPrefixes |= INST_PRE_REX; - di->opcode = ((_InstInfoEx*)ii)->opcodeId3; - } else - di->opcode = - ((_InstInfoEx*)ii)->opcodeId2; /* Use second mnemonic. */ - } else - di->opcode = ii->opcodeId; - } - - /* If it's a native instruction use OpSize Prefix. */ - if ((instFlags & INST_NATIVE) && (ps->decodedPrefixes & INST_PRE_OP_SIZE)) - ps->usedPrefixes |= INST_PRE_OP_SIZE; - - /* Check VEX mnemonics: */ - if ((instFlags & INST_PRE_VEX) && - (((((_InstInfoEx*)ii)->flagsEx & INST_MNEMONIC_VEXW_BASED) && - (vrex & PREFIX_EX_W)) || - ((((_InstInfoEx*)ii)->flagsEx & INST_MNEMONIC_VEXL_BASED) && - (vrex & PREFIX_EX_L)))) { - di->opcode = ((_InstInfoEx*)ii)->opcodeId2; - } - - /* - * Store the address size inside the flags. - * This is necessary for the caller to know the size of rSP when using PUSHA - * for example. - */ - FLAG_SET_ADDRSIZE(di, effAdrSz); - - /* Copy DST_WR flag. */ - if (instFlags & INST_DST_WR) - di->flags |= FLAG_DST_WR; - - /* Set the unused prefixes mask. */ - di->unusedPrefixesMask = prefixes_set_unused_mask(ps); - - /* Copy instruction meta. */ - di->meta = ii->meta; - if (di->segment == 0) - di->segment = R_NONE; - - /* Take into account the O_MEM base register for the mask. */ - if (di->base != R_NONE) - di->usedRegistersMask |= _REGISTERTORCLASS[di->base]; - - /* Calculate the size of the instruction we've just decoded. */ - di->size = (uint8_t)((ci->code - startCode) & 0xff); - return DECRES_SUCCESS; - -_Undecodable: /* If the instruction couldn't be decoded for some reason, drop - the first byte. */ - memset(di, 0, sizeof(_DInst)); - di->base = R_NONE; - - di->size = 1; - /* Clean prefixes just in case... */ - ps->usedPrefixes = 0; - - /* Special case for WAIT instruction: If it's dropped, you have to return a - * valid instruction! */ - if (*startCode == INST_WAIT_INDEX) { - di->opcode = I_WAIT; - ci->code--; - ci->codeLen++; - META_SET_ISC(di, ISC_INTEGER); - return DECRES_SUCCESS; - } - - /* Mark that we didn't manage to decode the instruction well, caller will - * drop it. */ - return DECRES_INPUTERR; -} - -#if 0 -/* - * decode_internal - * - * supportOldIntr - Since now we work with new structure instead of the old _DecodedInst, we are still interested in backward compatibility. - * So although, the array is now of type _DInst, we want to read it in jumps of the old array element's size. - * This is in order to save memory allocation for conversion between the new and the old structures. - * It really means we can do the conversion in-place now. - */ -_DecodeResult decode_internal(_CodeInfo* _ci, int supportOldIntr, _DInst result[], unsigned int maxResultCount, unsigned int* usedInstructionsCount) -{ - _PrefixState ps; - unsigned int prefixSize; - _CodeInfo ci; - - _OffsetType codeOffset = _ci->codeOffset; - const uint8_t* code = _ci->code; - int codeLen = _ci->codeLen; - - /* - * This is used for printing only, it is the real offset of where the whole instruction begins. - * We need this variable in addition to codeOffset, because prefixes might change the real offset an instruction begins at. - * So we keep track of both. - */ - _OffsetType startInstOffset = 0; - - const uint8_t* p; - - /* Current working decoded instruction in results. */ - unsigned int nextPos = 0; - _DInst *pdi = NULL; - - _OffsetType addrMask = (_OffsetType)-1; - - _DecodeResult decodeResult; - - if (_ci->features & DF_MAXIMUM_ADDR32) addrMask = 0xffffffff; - else if (_ci->features & DF_MAXIMUM_ADDR16) addrMask = 0xffff; - - /* No entries are used yet. */ - *usedInstructionsCount = 0; - ci.dt = _ci->dt; - _ci->nextOffset = codeOffset; - - /* Decode instructions as long as we have what to decode/enough room in entries. */ - while (codeLen > 0) { - - /* startInstOffset holds the displayed offset of current instruction. */ - startInstOffset = codeOffset; - - memset(&ps, 0, (size_t)((char*)&ps.pfxIndexer[0] - (char*)&ps)); - memset(ps.pfxIndexer, PFXIDX_NONE, sizeof(int) * PFXIDX_MAX); - ps.start = code; - ps.last = code; - prefixSize = 0; - - if (prefixes_is_valid(*code, ci.dt)) { - prefixes_decode(code, codeLen, &ps, ci.dt); - /* Count prefixes, start points to first prefix. */ - prefixSize = (unsigned int)(ps.last - ps.start); - /* - * It might be that we will just notice that we ran out of bytes, or only prefixes - * so we will have to drop everything and halt. - * Also take into consideration of flow control instruction filter. - */ - codeLen -= prefixSize; - if ((codeLen == 0) || (prefixSize == INST_MAXIMUM_SIZE)) { - if (~_ci->features & DF_RETURN_FC_ONLY) { - /* Make sure there is enough room. */ - if (nextPos + (ps.last - code) > maxResultCount) return DECRES_MEMORYERR; - - for (p = code; p < ps.last; p++, startInstOffset++) { - /* Use next entry. */ - if (supportOldIntr) pdi = (_DInst*)((char*)result + nextPos * sizeof(_DecodedInst)); - else pdi = &result[nextPos]; - nextPos++; - memset(pdi, 0, sizeof(_DInst)); - - pdi->flags = FLAG_NOT_DECODABLE; - pdi->imm.byte = *p; - pdi->size = 1; - pdi->addr = startInstOffset & addrMask; - } - *usedInstructionsCount = nextPos; /* Include them all. */ - } - if (codeLen == 0) break; /* Bye bye, out of bytes. */ - } - code += prefixSize; - codeOffset += prefixSize; - - /* If we got only prefixes continue to next instruction. */ - if (prefixSize == INST_MAXIMUM_SIZE) continue; - } - - /* - * Now we decode the instruction and only then we do further prefixes handling. - * This is because the instruction could not be decoded at all, or an instruction requires - * a mandatory prefix, or some of the prefixes were useless, etc... - - * Even if there were a mandatory prefix, we already took into account its size as a normal prefix. - * so prefixSize includes that, and the returned size in pdi is simply the size of the real(=without prefixes) instruction. - */ - if (ci.dt == Decode64Bits) { - if (ps.decodedPrefixes & INST_PRE_REX) { - /* REX prefix must precede first byte of instruction. */ - if (ps.rexPos != (code - 1)) { - ps.decodedPrefixes &= ~INST_PRE_REX; - ps.prefixExtType = PET_NONE; - prefixes_ignore(&ps, PFXIDX_REX); - } - /* - * We will disable operand size prefix, - * if it exists only after decoding the instruction, since it might be a mandatory prefix. - * This will be done after calling inst_lookup in decode_inst. - */ - } - /* In 64 bits, segment overrides of CS, DS, ES and SS are ignored. So don't take'em into account. */ - if (ps.decodedPrefixes & INST_PRE_SEGOVRD_MASK32) { - ps.decodedPrefixes &= ~INST_PRE_SEGOVRD_MASK32; - prefixes_ignore(&ps, PFXIDX_SEG); - } - } - - /* Make sure there is at least one more entry to use, for the upcoming instruction. */ - if (nextPos + 1 > maxResultCount) return DECRES_MEMORYERR; - if (supportOldIntr) pdi = (_DInst*)((char*)result + nextPos * sizeof(_DecodedInst)); - else pdi = &result[nextPos]; - nextPos++; - - /* - * The reason we copy these two again is because we have to keep track on the input ourselves. - * There might be a case when an instruction is invalid, and then it will be counted as one byte only. - * But that instruction already read a byte or two from the stream and only then returned the error. - * Thus, we end up unsynchronized on the stream. - * This way, we are totally safe, because we keep track after the call to decode_inst, using the returned size. - */ - ci.code = code; - ci.codeLen = codeLen; - /* Nobody uses codeOffset in the decoder itself, so spare it. */ - - decodeResult = decode_inst(&ci, &ps, pdi); - - /* See if we need to filter this instruction. */ - if ((_ci->features & DF_RETURN_FC_ONLY) && (META_GET_FC(pdi->meta) == FC_NONE)) decodeResult = DECRES_FILTERED; - - /* Set address to the beginning of the instruction. */ - pdi->addr = startInstOffset & addrMask; - /* pdi->disp &= addrMask; */ - - /* Advance to next instruction. */ - codeLen -= pdi->size; - codeOffset += pdi->size; - code += pdi->size; - - /* Instruction's size should include prefixes. */ - pdi->size += (uint8_t)prefixSize; - - /* Drop all prefixes and the instruction itself, because the instruction wasn't successfully decoded. */ - if ((decodeResult == DECRES_INPUTERR) && (~_ci->features & DF_RETURN_FC_ONLY)) { - nextPos--; /* Undo last result. */ - if ((prefixSize + 1) > 0) { /* 1 for the first instruction's byte. */ - if ((nextPos + prefixSize + 1) > maxResultCount) return DECRES_MEMORYERR; - - for (p = ps.start; p < ps.last + 1; p++, startInstOffset++) { - /* Use next entry. */ - if (supportOldIntr) pdi = (_DInst*)((char*)result + nextPos * sizeof(_DecodedInst)); - else pdi = &result[nextPos]; - nextPos++; - - memset(pdi, 0, sizeof(_DInst)); - pdi->flags = FLAG_NOT_DECODABLE; - pdi->imm.byte = *p; - pdi->size = 1; - pdi->addr = startInstOffset & addrMask; - } - } - } else if (decodeResult == DECRES_FILTERED) nextPos--; /* Return it to pool, since it was filtered. */ - - /* Alright, the caller can read, at least, up to this one. */ - *usedInstructionsCount = nextPos; - /* Fix next offset. */ - _ci->nextOffset = codeOffset; - - /* Check whether we need to stop on any flow control instruction. */ - if ((decodeResult == DECRES_SUCCESS) && (_ci->features & DF_STOP_ON_FLOW_CONTROL)) { - if (((_ci->features & DF_STOP_ON_CALL) && (META_GET_FC(pdi->meta) == FC_CALL)) || - ((_ci->features & DF_STOP_ON_RET) && (META_GET_FC(pdi->meta) == FC_RET)) || - ((_ci->features & DF_STOP_ON_SYS) && (META_GET_FC(pdi->meta) == FC_SYS)) || - ((_ci->features & DF_STOP_ON_UNC_BRANCH) && (META_GET_FC(pdi->meta) == FC_UNC_BRANCH)) || - ((_ci->features & DF_STOP_ON_CND_BRANCH) && (META_GET_FC(pdi->meta) == FC_CND_BRANCH)) || - ((_ci->features & DF_STOP_ON_INT) && (META_GET_FC(pdi->meta) == FC_INT)) || - ((_ci->features & DF_STOP_ON_CMOV) && (META_GET_FC(pdi->meta) == FC_CMOV))) - return DECRES_SUCCESS; - } - } - - return DECRES_SUCCESS; -} -#endif - -_DecodeResult decode_instruction(uint8_t* ins_addr, _DInst* pdi, _DecodeType dt) -{ - const uint8_t* code = (uint8_t*)ins_addr; - int codeLen = 32; - - // variable features will be used to determine the addrMask, but it is not - // used yet. - /* unsigned int features = DF_NONE; - if (dt == Decode16Bits) features = DF_MAXIMUM_ADDR16; - else if (dt == Decode32Bits) features = DF_MAXIMUM_ADDR32;*/ - - _OffsetType addrMask = (_OffsetType)-1; - - // if (features & DF_MAXIMUM_ADDR32) addrMask = 0xffffffff; - // else if (features & DF_MAXIMUM_ADDR16) addrMask = 0xffff; - - /* startInstAddr holds the displayed offset of current instruction. */ - _OffsetType startInstAddr = (_OffsetType)code; - - _PrefixState ps; - memset(&ps, 0, (size_t)((char*)&ps.pfxIndexer[0] - (char*)&ps)); - memset(ps.pfxIndexer, PFXIDX_NONE, sizeof(int) * PFXIDX_MAX); - ps.start = code; - ps.last = code; - unsigned int prefixSize = 0; - - if (prefixes_is_valid(*code, dt)) { - prefixes_decode(code, codeLen, &ps, dt); - /* Count prefixes, start points to first prefix. */ - prefixSize = (unsigned int)(ps.last - ps.start); - /* - * It might be that we will just notice that we ran out of bytes, or - * only prefixes so we will have to drop everything and halt. Also take - * into consideration of flow control instruction filter. - */ - codeLen -= prefixSize; - if ((codeLen == 0) || (prefixSize == INST_MAXIMUM_SIZE)) - return DECRES_INPUTERR; - code += prefixSize; - } - - /* - * Now we decode the instruction and only then we do further prefixes - handling. - * This is because the instruction could not be decoded at all, or an - instruction requires - * a mandatory prefix, or some of the prefixes were useless, etc... - - * Even if there were a mandatory prefix, we already took into account its - size as a normal prefix. - * so prefixSize includes that, and the returned size in pdi is simply the - size of the real(=without prefixes) instruction. - */ - if (dt == Decode64Bits) { - if (ps.decodedPrefixes & INST_PRE_REX) { - /* REX prefix must precede first byte of instruction. */ - if (ps.rexPos != (code - 1)) { - ps.decodedPrefixes &= ~INST_PRE_REX; - ps.prefixExtType = PET_NONE; - prefixes_ignore(&ps, PFXIDX_REX); - } - /* - * We will disable operand size prefix, - * if it exists only after decoding the instruction, since it might - * be a mandatory prefix. This will be done after calling - * inst_lookup in decode_inst. - */ - } - /* In 64 bits, segment overrides of CS, DS, ES and SS are ignored. So - * don't take'em into account. */ - if (ps.decodedPrefixes & INST_PRE_SEGOVRD_MASK32) { - ps.decodedPrefixes &= ~INST_PRE_SEGOVRD_MASK32; - prefixes_ignore(&ps, PFXIDX_SEG); - } - } - - /* - * The reason we copy these two again is because we have to keep track on - * the input ourselves. There might be a case when an instruction is - * invalid, and then it will be counted as one byte only. But that - * instruction already read a byte or two from the stream and only then - * returned the error. Thus, we end up unsynchronized on the stream. This - * way, we are totally safe, because we keep track after the call to - * decode_inst, using the returned size. - */ - _CodeInfo ci; - ci.code = code; - ci.codeOffset = ci.nextOffset = 0; - ci.codeLen = codeLen; - ci.dt = dt; - ci.features = DF_NONE; - - /* Nobody uses codeOffset in the decoder itself, so spare it. */ - _DecodeResult decodeResult = decode_inst(&ci, &ps, pdi); - - /* Set address to the beginning of the instruction. */ - pdi->addr = startInstAddr & addrMask; - pdi->disp &= addrMask; - - /* Instruction's size should include prefixes. */ - pdi->size += (uint8_t)prefixSize; - - if (pdi->addr + pdi->size != (_OffsetType)ci.code) - return DECRES_INPUTERR; - - return decodeResult; -} diff --git a/target/i386/latx/diStorm/decoder.h b/target/i386/latx/diStorm/decoder.h deleted file mode 100644 index 5c5362b8a82..00000000000 --- a/target/i386/latx/diStorm/decoder.h +++ /dev/null @@ -1,34 +0,0 @@ -/* -decoder.h - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#ifndef DECODER_H -#define DECODER_H - -#include "config.h" - -typedef unsigned int _iflags; - -/*_DecodeResult decode_internal(_CodeInfo* ci, int supportOldIntr, _DInst */ -/*result[], unsigned int maxResultCount, unsigned int* usedInstructionsCount); - */ - -#endif /* DECODER_H */ diff --git a/target/i386/latx/diStorm/distorm.h b/target/i386/latx/diStorm/distorm.h deleted file mode 100644 index 73033febcea..00000000000 --- a/target/i386/latx/diStorm/distorm.h +++ /dev/null @@ -1,507 +0,0 @@ -/* diStorm3 1.0.0 */ - -/* -distorm.h - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#ifndef DISTORM_H -#define DISTORM_H - -#include - -/* - * 64 bit offsets support: - * If the diStorm library you use was compiled with 64 bits offsets, - * make sure you compile your own code with the following macro set: - * SUPPORT_64BIT_OFFSET - * Otherwise comment it out, or you will get a linker error of an unresolved - * symbol... Turned on by default! - */ - -#if 0 /*!(defined(DISTORM_STATIC) || defined(DISTORM_DYNAMIC)) */ - /* Define this macro for outer projects by default. */ -#define SUPPORT_64BIT_OFFSET -#endif - -/* TINYC has a problem with some 64bits library functions, so ignore 64 bit - * offsets. */ -/*#ifdef __TINYC__ - #undef SUPPORT_64BIT_OFFSET -#endif*/ - -/* If your compiler doesn't support stdint.h, define your own 64 bits type. */ -#if defined X64 -#ifdef _MSC_VER -#define OFFSET_INTEGER unsigned __int64 -#else -#include -#define OFFSET_INTEGER uint64_t -#endif -#else -/* 32 bit offsets are used. */ -#define OFFSET_INTEGER unsigned long -#endif - -#ifdef _MSC_VER -/* Since MSVC isn't shipped with stdint.h, we will have our own: */ -typedef signed __int64 int64_t; -typedef unsigned __int64 uint64_t; -typedef signed __int32 int32_t; -typedef unsigned __int32 uint32_t; -typedef signed __int16 int16_t; -typedef unsigned __int16 uint16_t; -typedef signed __int8 int8_t; -typedef unsigned __int8 uint8_t; -#endif - -/* Support C++ compilers */ -#ifdef __cplusplus -extern "C" { -#endif - -/* *** Helper Macros *** */ - -/* Get the ISC of the instruction, used with the definitions below. */ -#define META_GET_ISC(meta) (((meta) >> 3) & 0x1f) -#define META_SET_ISC(di, isc) (((di)->meta) |= ((isc) << 3)) -/* Get the flow control flags of the instruction, see 'features for decompose' - * below. */ -#define META_GET_FC(meta) ((meta)&0x7) - -/* Get the target address of a branching instruction. O_PC operand type. */ -#define INSTRUCTION_GET_TARGET(di) \ - ((_OffsetType)(((di)->addr + (di)->imm.addr + (di)->size))) -/* Get the target address of a RIP-relative memory indirection. */ -#define INSTRUCTION_GET_RIP_TARGET(di) \ - ((_OffsetType)(((di)->addr + (di)->disp + (di)->size))) - -/* - * Operand Size or Adderss size are stored inside the flags: - * 0 - 16 bits - * 1 - 32 bits - * 2 - 64 bits - * 3 - reserved - * - * If you call these set-macros more than once, you will have to clean the bits - * before doing so. - */ -#define FLAG_SET_OPSIZE(di, size) ((di->flags) |= (((size)&3) << 8)) -#define FLAG_SET_ADDRSIZE(di, size) ((di->flags) |= (((size)&3) << 10)) -#define FLAG_GET_OPSIZE(flags) (((flags) >> 8) & 3) -#define FLAG_GET_ADDRSIZE(flags) (((flags) >> 10) & 3) -/* To get the LOCK/REPNZ/REP prefixes. */ -#define FLAG_GET_PREFIX(flags) ((flags)&7) - -/* - * Macros to extract segment registers from 'segment': - */ -#define SEGMENT_DEFAULT 0x80 -#define SEGMENT_SET(di, seg) ((di->segment) |= seg) -#define SEGMENT_GET(segment) (((segment) == R_NONE) ? R_NONE : ((segment)&0x7f)) -#define SEGMENT_IS_DEFAULT(segment) \ - (((segment)&SEGMENT_DEFAULT) == SEGMENT_DEFAULT) - -/* Decodes modes of the disassembler, 16 bits or 32 bits or 64 bits for AMD64, - * x86-64. */ -typedef enum { - Decode16Bits = 0, - Decode32Bits = 1, - Decode64Bits = 2 -} _DecodeType; - -typedef OFFSET_INTEGER _OffsetType; - -typedef struct { - _OffsetType codeOffset, nextOffset; /* nextOffset is OUT only. */ - const uint8_t *code; - int codeLen; /* Using signed integer makes it easier to detect an underflow. - */ - _DecodeType dt; - unsigned int features; -} _CodeInfo; - -typedef enum { - O_NONE, - O_REG, - O_IMM, - O_IMM1, - O_IMM2, - O_DISP, - O_SMEM, - O_MEM, - O_PC, - O_PTR -} _OperandType; - -typedef union { - /* Used by O_IMM: */ - int8_t sbyte; - uint8_t byte; - int16_t sword; - uint16_t word; - int32_t sdword; - uint32_t dword; - int64_t sqword; /* All immediates are SIGN-EXTENDED to 64 bits! */ - uint64_t qword; - - /* Used by O_PC: (Use GET_TARGET_ADDR).*/ - _OffsetType addr; /* It's a relative offset as for now. */ - - /* Used by O_PTR: */ - struct { - uint16_t seg; - /* Can be 16 or 32 bits, size is in ops[n].size. */ - uint32_t off; - } ptr; - - /* Used by O_IMM1 (i1) and O_IMM2 (i2). ENTER instruction only. */ - struct { - uint32_t i1; - uint32_t i2; - } ex; -} _Value; - -typedef struct { - /* Type of operand: - O_NONE: operand is to be ignored. - O_REG: index holds global register index. - O_IMM: instruction.imm. - O_IMM1: instruction.imm.ex.i1. - O_IMM2: instruction.imm.ex.i2. - O_DISP: memory dereference with displacement only, instruction.disp. - O_SMEM: simple memory dereference with optional displacement (a single - register memory dereference). O_MEM: complex memory dereference (optional - fields: s/i/b/disp). O_PC: the relative address of a branch instruction - (instruction.imm.addr). O_PTR: the absolute target address of a far - branch instruction (instruction.imm.ptr.seg/off). - */ - uint8_t type; /* _OperandType */ - - /* Index of: - O_REG: holds global register index - O_SMEM: holds the 'base' register. E.G: [ECX], [EBX+0x1234] are both in - operand.index. O_MEM: holds the 'index' register. E.G: [EAX*4] is in - operand.index. - */ - uint8_t index; - - /* Size of: - O_REG: register - O_IMM: instruction.imm - O_IMM1: instruction.imm.ex.i1 - O_IMM2: instruction.imm.ex.i2 - O_DISP: instruction.disp - O_SMEM: size of indirection. - O_MEM: size of indirection. - O_PC: size of the relative offset - O_PTR: size of instruction.imm.ptr.off (16 or 32) - */ - uint16_t size; -} _Operand; - -#define OPCODE_ID_NONE 0 -/* Instruction could not be disassembled. */ -#define FLAG_NOT_DECODABLE ((uint16_t)-1) -/* The instruction locks memory access. */ -#define FLAG_LOCK (1 << 0) -/* The instruction is prefixed with a REPNZ. */ -#define FLAG_REPNZ (1 << 1) -/* The instruction is prefixed with a REP, this can be a REPZ, it depends on the - * specific instruction. */ -#define FLAG_REP (1 << 2) -/* Indicates there is a hint taken for Jcc instructions only. */ -#define FLAG_HINT_TAKEN (1 << 3) -/* Indicates there is a hint non-taken for Jcc instructions only. */ -#define FLAG_HINT_NOT_TAKEN (1 << 4) -/* The Imm value is signed extended. */ -#define FLAG_IMM_SIGNED (1 << 5) -/* The destination operand is writable. */ -#define FLAG_DST_WR (1 << 6) -/* The instruction uses RIP-relative indirection. */ -#define FLAG_RIP_RELATIVE (1 << 7) - -/* No register was defined. */ -#define R_NONE ((uint8_t)-1) - -#define REGS64_BASE (0) -#define REGS32_BASE (16) -#define REGS16_BASE (32) -#define REGS8_BASE (48) -#define REGS8_REX_BASE (64) -#define SREGS_BASE (68) -/* #define RIP 74 */ -#define FPUREGS_BASE (75) -#define MMXREGS_BASE (83) -#define SSEREGS_BASE (91) -#define AVXREGS_BASE (107) -#define CREGS_BASE (123) -#define DREGS_BASE (132) - -#define OPERANDS_NO (4) - -typedef struct { - /* Used by ops[n].type == O_IMM/O_IMM1&O_IMM2/O_PTR/O_PC. Its size is - * ops[n].size. */ - _Value imm; - /* Used by ops[n].type == O_SMEM/O_MEM/O_DISP. Its size is dispSize. */ - uint64_t disp; - /* Virtual address of first byte of instruction. */ - _OffsetType addr; - /* General flags of instruction, holds prefixes and more, if - * FLAG_NOT_DECODABLE, instruction is invalid. */ - uint16_t flags; - /* Unused prefixes mask, for each bit that is set that prefix is not used - * (LSB is byte [addr + 0]). */ - uint16_t unusedPrefixesMask; - /* Mask of registers that were used in the operands, only used for quick - * look up, in order to know *some* operand uses that register class. */ - uint16_t usedRegistersMask; - /* ID of opcode in the global opcode table. Use for mnemonic look up. */ - uint16_t opcode; - /* Up to four operands per instruction, ignored if ops[n].type == O_NONE. */ - _Operand ops[OPERANDS_NO]; - /* Size of the whole instruction. */ - uint8_t size; - /* Segment information of memory indirection, default segment, or overriden - * one, can be -1. Use SEGMENT macros. */ - uint8_t segment; - /* Used by ops[n].type == O_MEM. Base global register index (might be - * R_NONE), scale size (2/4/8), ignored for 0 or 1. */ - uint8_t base, scale; - uint8_t dispSize; - /* Meta defines the instruction set class, and the flow control flags. Use - * META macros. */ - uint8_t meta; -} _DInst; - -/* Static size of strings. Do not change this value. Keep Python wrapper in - * sync. */ -#define MAX_TEXT_SIZE (48) -typedef struct { - unsigned int length; - unsigned char p[MAX_TEXT_SIZE]; /* p is a null terminated string. */ -} _WString; - -/* - * Old decoded instruction structure in text format. - * Used only for backward compatibility with diStorm64. - * This structure holds all information the disassembler generates per - * instruction. - */ -typedef struct { - _WString mnemonic; /* Mnemonic of decoded instruction, prefixed if required - by REP, LOCK etc. */ - _WString operands; /* Operands of the decoded instruction, up to 3 operands, - comma-seperated. */ - _WString instructionHex; /* Hex dump - little endian, including prefixes. */ - unsigned int size; /* Size of decoded instruction. */ - _OffsetType offset; /* Start offset of the decoded instruction. */ -} _DecodedInst; - -/* Register masks for quick look up, each mask indicates one of a register-class - * that is being used in some operand. */ -#define RM_AX 1 /* AL, AH, AX, EAX, RAX */ -#define RM_CX 2 /* CL, CH, CX, ECX, RCX */ -#define RM_DX 4 /* DL, DH, DX, EDX, RDX */ -#define RM_BX 8 /* BL, BH, BX, EBX, RBX */ -#define RM_SP 0x10 /* SPL, SP, ESP, RSP */ -#define RM_BP 0x20 /* BPL, BP, EBP, RBP */ -#define RM_SI 0x40 /* SIL, SI, ESI, RSI */ -#define RM_DI 0x80 /* DIL, DI, EDI, RDI */ -#define RM_FPU 0x100 /* ST(0) - ST(7) */ -#define RM_MMX 0x200 /* MM0 - MM7 */ -#define RM_SSE 0x400 /* XMM0 - XMM15 */ -#define RM_AVX 0x800 /* YMM0 - YMM15 */ -#define RM_CR 0x1000 /* CR0, CR2, CR3, CR4, CR8 */ -#define RM_DR 0x2000 /* DR0, DR1, DR2, DR3, DR6, DR7 */ -/* RIP should be checked using the 'flags' field and FLAG_RIP_RELATIVE. - * Segments should be checked using the segment macros. - * For now R8 - R15 are not supported and non general purpose registers map into - * same RM. - */ - -/* - * Instructions Set classes: - * if you want a better understanding of the available classes, look at disOps - * project, file: x86sets.py. - */ -/* Indicates the instruction belongs to the General Integer set. */ -#define ISC_INTEGER 1 -/* Indicates the instruction belongs to the 387 FPU set. */ -#define ISC_FPU 2 -/* Indicates the instruction belongs to the P6 set. */ -#define ISC_P6 3 -/* Indicates the instruction belongs to the MMX set. */ -#define ISC_MMX 4 -/* Indicates the instruction belongs to the SSE set. */ -#define ISC_SSE 5 -/* Indicates the instruction belongs to the SSE2 set. */ -#define ISC_SSE2 6 -/* Indicates the instruction belongs to the SSE3 set. */ -#define ISC_SSE3 7 -/* Indicates the instruction belongs to the SSSE3 set. */ -#define ISC_SSSE3 8 -/* Indicates the instruction belongs to the SSE4.1 set. */ -#define ISC_SSE4_1 9 -/* Indicates the instruction belongs to the SSE4.2 set. */ -#define ISC_SSE4_2 10 -/* Indicates the instruction belongs to the AMD's SSE4.A set. */ -#define ISC_SSE4_A 11 -/* Indicates the instruction belongs to the 3DNow! set. */ -#define ISC_3DNOW 12 -/* Indicates the instruction belongs to the 3DNow! Extensions set. */ -#define ISC_3DNOWEXT 13 -/* Indicates the instruction belongs to the VMX (Intel) set. */ -#define ISC_VMX 14 -/* Indicates the instruction belongs to the SVM (AMD) set. */ -#define ISC_SVM 15 -/* Indicates the instruction belongs to the AVX (Intel) set. */ -#define ISC_AVX 16 -/* Indicates the instruction belongs to the FMA (Intel) set. */ -#define ISC_FMA 17 -/* Indicates the instruction belongs to the AES/AVX (Intel) set. */ -#define ISC_AES 18 -/* Indicates the instruction belongs to the CLMUL (Intel) set. */ -#define ISC_CLMUL 19 - -/* Features for decompose: */ -#define DF_NONE 0 -/* The decoder will limit addresses to a maximum of 16 bits. */ -#define DF_MAXIMUM_ADDR16 1 -/* The decoder will limit addresses to a maximum of 32 bits. */ -#define DF_MAXIMUM_ADDR32 2 -/* The decoder will return only flow control instructions (and filter the others - * internally). */ -#define DF_RETURN_FC_ONLY 4 -/* The decoder will stop and return to the caller when the instruction 'CALL' - * (near and far) was decoded. */ -#define DF_STOP_ON_CALL 8 -/* The decoder will stop and return to the caller when the instruction 'RET' - * (near and far) was decoded. */ -#define DF_STOP_ON_RET 0x10 -/* The decoder will stop and return to the caller when the instruction - * system-call/ret was decoded. */ -#define DF_STOP_ON_SYS 0x20 -/* The decoder will stop and return to the caller when any of the branch 'JMP', - * (near and far) instructions were decoded. */ -#define DF_STOP_ON_UNC_BRANCH 0x40 -/* The decoder will stop and return to the caller when any of the conditional - * branch instruction were decoded. */ -#define DF_STOP_ON_CND_BRANCH 0x80 -/* The decoder will stop and return to the caller when the instruction 'INT' - * (INT, INT1, INTO, INT 3) was decoded. */ -#define DF_STOP_ON_INT 0x100 -/* The decoder will stop and return to the caller when any of the 'CMOVxx' - * instruction was decoded. */ -#define DF_STOP_ON_CMOV 0x200 -/* The decoder will stop and return to the caller when any flow control - * instruction was decoded. */ -#define DF_STOP_ON_FLOW_CONTROL \ - (DF_STOP_ON_CALL | DF_STOP_ON_RET | DF_STOP_ON_SYS | \ - DF_STOP_ON_UNC_BRANCH | DF_STOP_ON_CND_BRANCH | DF_STOP_ON_INT | \ - DF_STOP_ON_CMOV) - -/* Indicates the instruction is not a flow-control instruction. */ -#define FC_NONE 0 -/* Indicates the instruction is one of: CALL, CALL FAR. */ -#define FC_CALL 1 -/* Indicates the instruction is one of: RET, IRET, RETF. */ -#define FC_RET 2 -/* Indicates the instruction is one of: SYSCALL, SYSRET, SYSENTER, SYSEXIT. */ -#define FC_SYS 3 -/* Indicates the instruction is one of: JMP, JMP FAR. */ -#define FC_UNC_BRANCH 4 -/* - * Indicates the instruction is one of: - * JCXZ, JO, JNO, JB, JAE, JZ, JNZ, JBE, JA, JS, JNS, JP, JNP, JL, JGE, JLE, JG, - * LOOP, LOOPZ, LOOPNZ. - */ -#define FC_CND_BRANCH 5 -/* Indiciates the instruction is one of: INT, INT1, INT 3, INTO, UD2. */ -#define FC_INT 6 -/* Indicates the instruction is one of: CMOVxx. */ -#define FC_CMOV 7 - -/* Return code of the decoding function. */ -typedef enum { - DECRES_NONE, - DECRES_SUCCESS, - DECRES_MEMORYERR, - DECRES_INPUTERR, - DECRES_FILTERED -} _DecodeResult; - -/* Define the following interface functions only for outer projects. */ -#if 0 /*!(defined(DISTORM_STATIC) || defined(DISTORM_DYNAMIC)) */ - -/* distorm_decode - * Input: - * offset - Origin of the given code (virtual address that is), NOT an offset in code. - * code - Pointer to the code buffer to be disassembled. - * length - Amount of bytes that should be decoded from the code buffer. - * dt - Decoding mode, 16 bits (Decode16Bits), 32 bits (Decode32Bits) or AMD64 (Decode64Bits). - * result - Array of type _DecodeInst which will be used by this function in order to return the disassembled instructions. - * maxInstructions - The maximum number of entries in the result array that you pass to this function, so it won't exceed its bound. - * usedInstructionsCount - Number of the instruction that successfully were disassembled and written to the result array. - * Output: usedInstructionsCount will hold the number of entries used in the result array - * and the result array itself will be filled with the disassembled instructions. - * Return: DECRES_SUCCESS on success (no more to disassemble), DECRES_INPUTERR on input error (null code buffer, invalid decoding mode, etc...), - * DECRES_MEMORYERR when there are not enough entries to use in the result array, BUT YOU STILL have to check for usedInstructionsCount! - * Side-Effects: Even if the return code is DECRES_MEMORYERR, there might STILL be data in the - * array you passed, this function will try to use as much entries as possible! - * Notes: 1)The minimal size of maxInstructions is 15. - * 2)You will have to synchronize the offset,code and length by yourself if you pass code fragments and not a complete code block! - */ -#ifdef SUPPORT_64BIT_OFFSET - _DecodeResult distorm_decompose64(_CodeInfo* ci, _DInst result[], unsigned int maxInstructions, unsigned int* usedInstructionsCount); - _DecodeResult distorm_decode64(_OffsetType codeOffset, const unsigned char* code, int codeLen, _DecodeType dt, _DecodedInst result[], unsigned int maxInstructions, unsigned int* usedInstructionsCount); - void distorm_format64(const _CodeInfo* ci, const _DInst* di, _DecodedInst* result); -#define distorm_decompose distorm_decompose64 -#define distorm_decode distorm_decode64 -#define distorm_format distorm_format64 -#else - _DecodeResult distorm_decompose32(_CodeInfo* ci, _DInst result[], unsigned int maxInstructions, unsigned int* usedInstructionsCount); - _DecodeResult distorm_decode32(_OffsetType codeOffset, const unsigned char* code, int codeLen, _DecodeType dt, _DecodedInst result[], unsigned int maxInstructions, unsigned int* usedInstructionsCount); - void distorm_format32(const _CodeInfo* ci, const _DInst* di, _DecodedInst* result); -#define distorm_decompose distorm_decompose32 -#define distorm_decode distorm_decode32 -#define distorm_format distorm_format32 -#endif - -/* - * distorm_version - * Input: - * none - * - * Output: unsigned int - version of compiled library. - */ -unsigned int distorm_version(); - -#endif /* DISTORM_STATIC */ - -extern _DecodeResult decode_instruction(uint8_t *ins_addr, _DInst *pdi, - _DecodeType dt); - -#ifdef __cplusplus -} /* End Of Extern */ -#endif - -#endif /* DISTORM_H */ diff --git a/target/i386/latx/diStorm/instructions.c b/target/i386/latx/diStorm/instructions.c deleted file mode 100644 index 23ae9b1338e..00000000000 --- a/target/i386/latx/diStorm/instructions.c +++ /dev/null @@ -1,706 +0,0 @@ -/* -instructions.c - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#include "instructions.h" - -#include "insts.h" -#include "prefix.h" -#include "x86defs.h" -#include "mnemonics.h" - -/* Helper macros to extract the type or index from an inst-node value. */ -#define INST_NODE_INDEX(n) ((n)&0x1fff) -#define INST_NODE_TYPE(n) ((n) >> 13) - -/* -I use the trie data structure as I found it most fitting to a disassembler -mechanism. When you read a byte and have to decide if it's enough or you should -read more bytes, 'till you get to the instruction information. It's really fast -because you POP the instruction info in top 3 iterates on the DB, because an -instruction can be formed from two bytes + 3 bits reg from the ModR/M byte. For -a simple explanation, check this out: -http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Tree/Trie/ -Futher reading: http://en.wikipedia.org/wiki/Trie - -The first GATE (array you read off a trie data structure), as I call them, is -statically allocated by the compiler. The second and third gates if used are -being allocated dynamically by the instructions-insertion functionality. - -How would such a thing look in memory, say we support 4 instructions with 3 -bytes top (means 2 dynamically allocated gates). - --> -|-------| 0, -|0| -------------------------------> |-------| -|1|RET | 1, |0|AND | -|2| -----> |-------| |1|XOR | -|3|INT3 | |0|PUSH | |2|OR | 0,3, -|-------| |1|POP | |3| --------->|-------| - |2|PUSHF| |-------| |0|ROR | - |3|POPF | |1|ROL | - |-------| |2|SHR | - |3|SHL | - |-------| - -Of course, this is NOT how Intel instructions set looks!!! -but I just wanted to give a small demonstration. -Now the instructions you get from such a trie DB goes like this: - -0, 0 - AND -0, 1 - XOR -0, 2 - OR -0, 3, 0, ROR -0, 3, 1, ROL -0, 3, 2, SHR -0, 3, 3, SHL -1 - RET -2, 0 - PUSH -2, 1 - POP -2, 2 - PUSHF -2, 3 - POPF -3 - INT3 - -I guess it's clear by now. -So now, if you read 0, you know that you have to enter the second gate(list) -with the second byte specifying the index. But if you read 1, you know that you -go to an instruction (in this case, a RET). That's why there's an -Instruction-Node structure, it tells you whether you got to an instruction or -another list so you should keep on reading byte). - -In Intel, you could go through 4 gates at top, because there're instructions -which are built from 2 bytes and another smaller list for the REG part, or -newest SSE4 instructions which use 4 bytes for opcode. Therefore, Intel's first -gate is 256 long, and other gates are 256 (/72) or 8 long, yes, it costs pretty -much alot of memory for non-used defined instructions, but I think that it still -rocks. -*/ - -/* - * A helper function to look up the correct inst-info structure. - * It does one fetch from the index-table, and then another to get the - * inst-info. Note that it takes care about basic inst-info or inst-info-ex. The - * caller should worry about boundary checks and whether it accesses a - * last-level table. - */ -static _InstInfo* inst_get_info(_InstNode in, int index) -{ - int instIndex = 0; - - in = InstructionsTree[INST_NODE_INDEX(in) + index]; - if (in == INT_NOTEXISTS) { - return NULL; - } - - instIndex = INST_NODE_INDEX(in); - return INST_NODE_TYPE(in) == INT_INFO ? &InstInfos[instIndex] - : (_InstInfo*)&InstInfosEx[instIndex]; -} - -/* - * This function is reponsible to return the instruction information of the - first found in code. - * It returns the _InstInfo of the found instruction, otherwise NULL. - * code should point to the ModR/M byte upon exit (if used), or after the - instruction binary code itself. - * This function is NOT decoding-type dependant, it is up to the caller to see - whether the instruction is valid. - * Get the instruction info, using a Trie data structure. - * - * Sometimes normal prefixes become mandatory prefixes, which means they are now - part of the instruction opcode bytes. - - * This is a bit tricky now, - * if the first byte is a REP (F3) prefix, we will have to give a chance to an - SSE instruction. - * If an instruction doesn't exist, we will make it as a prefix and - re-locateinst. - * A case such that a REP prefix is being changed into an instruction byte and - also an SSE instruction will not be found can't happen, - * simply because there are no collisions between string instruction and SSE - instructions (they are escaped). - - * As for S/SSE2/3, check for F2 and 66 as well. - - * In 64 bits, we have to make sure that we will skip the REX prefix, if it - exists. - * There's a specific case, where a 66 is mandatory but it was dropped because - REG.W was used, - * but it doesn't behave as an operand size prefix but as a mandatory, so we - will have to take it into account. - - * For example (64 bits decoding mode): - * 66 98 CBW - * 48 98 CDQE - * 66 48 98: db 0x66; CDQE - * Shows that operand size is dropped. - - * Now, it's a mandatory prefix and NOT an operand size one. - * 66480f2dc0 db 0x48; CVTPD2PI XMM0, XMM0 - * Although this instruction doesn't require a REX.W, it just shows, that even - if it did - it doesn't matter. - * REX.W is dropped because it's not requried, but the decode function disabled - the operand size even so. - */ -static _InstInfo* inst_lookup_prefixed(_InstNode in, _PrefixState* ps) -{ - int checkOpSize = FALSE; - int index = 0; - _InstInfo* ii = NULL; - - /* Check prefixes of current decoded instruction (None, 0x66, 0xf3, 0xf2). - */ - switch (ps->decodedPrefixes & (INST_PRE_OP_SIZE | INST_PRE_REPS)) { - case 0: - /* Non-prefixed, index = 0. */ - index = 0; - break; - case INST_PRE_OP_SIZE: - /* 0x66, index = 1. */ - index = 1; - /* Mark that we used it as a mandatory prefix. */ - ps->isOpSizeMandatory = TRUE; - ps->decodedPrefixes &= ~INST_PRE_OP_SIZE; - break; - case INST_PRE_REP: - /* 0xf3, index = 2. */ - index = 2; - ps->decodedPrefixes &= ~INST_PRE_REP; - break; - case INST_PRE_REPNZ: - /* 0xf2, index = 3. */ - index = 3; - ps->decodedPrefixes &= ~INST_PRE_REPNZ; - break; - default: - /* - * Now we got a problem, since there are a few mandatory prefixes at - * once. There is only one case when it's ok, when the operand size - * prefix is for real (not mandatory). Otherwise we will have to - * return NULL, since the instruction is illegal. Therefore we will - * start with REPNZ and REP prefixes, try to get the instruction and - * only then check for the operand size prefix. - */ - - /* If both REPNZ and REP are together, it's illegal for sure. */ - if ((ps->decodedPrefixes & INST_PRE_REPS) == INST_PRE_REPS) { - return NULL; - } - - /* Now we know it's either REPNZ+OPSIZE or REP+OPSIZE, so examine - * the instruction. */ - if (ps->decodedPrefixes & INST_PRE_REPNZ) { - index = 3; - ps->decodedPrefixes &= ~INST_PRE_REPNZ; - } else if (ps->decodedPrefixes & INST_PRE_REP) { - index = 2; - ps->decodedPrefixes &= ~INST_PRE_REP; - } - /* Mark to verify the operand-size prefix of the fetched instruction - * below. */ - checkOpSize = TRUE; - break; - } - - /* Fetch the inst-info from the index. */ - ii = inst_get_info(in, index); - - if (checkOpSize) { - /* If the instruction doesn't support operand size prefix, then it's - * illegal. */ - if ((ii == NULL) || (~INST_INFO_FLAGS(ii) & INST_PRE_OP_SIZE)) { - return NULL; - } - } - - /* If there was a prefix, but the instruction wasn't found. Try to fall back - * to use the normal instruction. */ - if (ii == NULL) { - ii = inst_get_info(in, 0); - } - return ii; -} - -static _InstInfo* inst_vex_lookup(_CodeInfo* ci, _PrefixState* ps) -{ - _InstNode in = 0; - unsigned int pp = 0, start = 0; - unsigned int index = - 4; /* VEX instructions start at index 4 in the Prefixed table. */ - uint8_t vex = *ps->vexPos, vex2 = 0, v = 0; - int instType = 0, instIndex = 0; - - /* The VEX instruction will #ud if any of 66, f0, f2, f3, REX prefixes - * precede. */ - _iflags illegal = (INST_PRE_OP_SIZE | INST_PRE_LOCK | INST_PRE_REP | - INST_PRE_REPNZ | INST_PRE_REX); - if ((ps->decodedPrefixes & illegal) != 0) { - return NULL; - } - - /* Read the some fields from the VEX prefix we need to extract the - * instruction. */ - if (ps->prefixExtType == PET_VEX2BYTES) { - ps->vexV = v = (~vex >> 3) & 0xf; - pp = vex & 3; - /* Implied leading 0x0f byte by default for 2 bytes VEX prefix. */ - start = 1; - } else { /* PET_VEX3BYTES */ - start = vex & 0x1f; - vex2 = *(ps->vexPos + 1); - ps->vexV = v = (~vex2 >> 3) & 0xf; - pp = vex2 & 3; - } - - /* start can be either 1 (0x0f), 2 (0x0f, 0x038) or 3 (0x0f, 0x3a), - * otherwise it's illegal. */ - switch (start) { - case 1: - in = Table_0F; - break; - case 2: - in = Table_0F_38; - break; - case 3: - in = Table_0F_3A; - break; - default: - return NULL; - } - - /* If the instruction is encoded using the vvvv field, fix the index into - * the Prefixed table. */ - if (v == 0) { - index += 4; - } - - /* pp is actually the implied mandatory prefix, apply it to the index. */ - index += pp; /* (None, 0x66, 0xf3, 0xf2) */ - - /* Read a byte from the stream. */ - ci->codeLen -= 1; - if (ci->codeLen < 0) { - return NULL; - } - - in = InstructionsTree[INST_NODE_INDEX(in) + *ci->code]; - if (in == INT_NOTEXISTS) { - return NULL; - } - - instType = INST_NODE_TYPE(in); - instIndex = INST_NODE_INDEX(in); - - /* - * If we started with 0f38 or 0f3a so it's a prefixed table, - * therefore it's surely a VEXed instruction (because of a high index). - * However, starting with 0f, could also lead immediately to a prefixed - * table for some bytes. it might return NULL, if the index is invalid. - */ - if (instType == INT_LIST_PREFIXED) { - return inst_get_info(in, index); - } - - /* - * If we reached here, obviously we started with 0f. VEXed instructions must - * be nodes of a prefixed table. But since we found an instruction (or - * divided one), just return NULL. They cannot lead to a VEXed instruction. - */ - if ((instType == INT_INFO) || (instType == INT_INFOEX) || - (instType == INT_LIST_DIVIDED)) { - return NULL; - } - - /* Now we are left with handling either GROUP or FULL tables, therefore we - * will read another byte from the stream. */ - ci->code += 1; - ci->codeLen -= 1; - if (ci->codeLen < 0) { - return NULL; - } - - if (instType == INT_LIST_GROUP) { - in = InstructionsTree[instIndex + ((*ci->code >> 3) & 7)]; - /* Continue below to check prefixed table. */ - } else if (instType == INT_LIST_FULL) { - in = InstructionsTree[instIndex + *ci->code]; - /* Continue below to check prefixed table. */ - } - - /* Now that we got to the last table in the trie, check for a prefixed - * table. */ - if (INST_NODE_TYPE(in) == INT_LIST_PREFIXED) { - return inst_get_info(in, index); - } - - /* No VEXed instruction was found. */ - return NULL; -} - -_InstInfo* inst_lookup(_CodeInfo* ci, _PrefixState* ps) -{ - unsigned int tmpIndex0 = 0, tmpIndex1 = 0, tmpIndex2 = 0, rex = ps->vrex; - int instType = 0; - _InstNode in = 0; - _InstInfo* ii = NULL; - int isWaitIncluded = FALSE; - - /* See whether we have to handle a VEX prefixed instruction. */ - if (ps->decodedPrefixes & INST_PRE_VEX) { - ii = inst_vex_lookup(ci, ps); - /* Make sure that VEX.L exists when forced. */ - if ((ii != NULL) && (((_InstInfoEx*)ii)->flagsEx & INST_FORCE_VEXL) && - (~ps->vrex & PREFIX_EX_L)) { - return NULL; - } - return ii; - } - - /* Read first byte. */ - ci->codeLen -= 1; - if (ci->codeLen < 0) { - return NULL; - } - tmpIndex0 = *ci->code; - - /* Check for special 0x9b, WAIT instruction, which can be part of some - * instructions(x87). */ - if (tmpIndex0 == INST_WAIT_INDEX) { - /* Only OCST_1dBYTES get a chance to include this byte as part of the - * opcode. */ - isWaitIncluded = TRUE; - - /* Ignore all prefixes, since they are useless and operate on the WAIT - * instruction itself. */ - prefixes_ignore_all(ps); - - /* Move to next code byte as a new whole instruction. */ - ci->code += 1; - ci->codeLen -= 1; - if (ci->codeLen < 0) { - return NULL; - } /* Faster to return NULL, it will be detected as WAIT - later anyway. */ - /* Since we got a WAIT prefix, we re-read the first byte. */ - tmpIndex0 = *ci->code; - } - - /* Walk first byte in InstructionsTree root. */ - in = InstructionsTree[tmpIndex0]; - if (in == INT_NOTEXISTS) { - return NULL; - } - instType = INST_NODE_TYPE(in); - - /* Single byte instruction (OCST_1BYTE). */ - if ((instType < INT_INFOS) && (!isWaitIncluded)) { - /* Some single byte instructions need extra treatment. */ - switch (tmpIndex0) { - case INST_ARPL_INDEX: - /* - * ARPL/MOVSXD share the same opcode, and both have different - * operands and mnemonics, of course. Practically, I couldn't - * come up with a comfortable way to merge the operands' types - * of ARPL/MOVSXD. And since the DB can't be patched - * dynamically, because the DB has to be multi-threaded - * compliant, I have no choice but to check for ARPL/MOVSXD - * right here - "right about now, the funk soul brother, check - * it out now, the funk soul brother...", fatboy slim - */ - return ci->dt == Decode64Bits ? &II_movsxd : &II_arpl; - - case INST_NOP_INDEX: /* Nopnopnop */ - /* Check for Pause, since it's prefixed with 0xf3, which is not - * a real mandatory prefix. */ - if (ps->decodedPrefixes & INST_PRE_REP) { - /* Flag this prefix as used. */ - ps->usedPrefixes |= INST_PRE_REP; - return &II_pause; - } - - /* - * Treat NOP/XCHG specially. - * If we're not in 64bits restore XCHG to NOP, since in the DB - * it's XCHG. Else if we're in 64bits examine REX, if exists, - * and decide which instruction should go to output. 48 90 XCHG - * RAX, RAX is a true NOP (eat REX in this case because it's - * valid). 90 XCHG EAX, EAX is a true NOP (and not high dword of - * RAX = 0 although it should be a 32 bits operation). Note that - * if the REX.B is used, then the register is not RAX anymore - * but R8, which means it's not a NOP. - */ - if (rex & PREFIX_EX_W) { - ps->usedPrefixes |= INST_PRE_REX; - } - if ((ci->dt != Decode64Bits) || (~rex & PREFIX_EX_B)) { - return &II_nop; - } - break; - - case INST_LEA_INDEX: - /* Ignore segment override prefixes for LEA instruction. */ - ps->decodedPrefixes &= ~INST_PRE_SEGOVRD_MASK; - /* Update unused mask for ignoring segment prefix. */ - prefixes_ignore(ps, PFXIDX_SEG); - break; - } - - /* Return the 1 byte instruction we found. */ - return instType == INT_INFO - ? &InstInfos[INST_NODE_INDEX(in)] - : (_InstInfo*)&InstInfosEx[INST_NODE_INDEX(in)]; - } - - /* Read second byte, still doens't mean all of its bits are used (I.E: - * ModRM). */ - ci->code += 1; - ci->codeLen -= 1; - if (ci->codeLen < 0) { - return NULL; - } - tmpIndex1 = *ci->code; - - /* Try single byte instruction + reg bits (OCST_13BYTES). */ - if ((instType == INT_LIST_GROUP) && (!isWaitIncluded)) { - return inst_get_info(in, (tmpIndex1 >> 3) & 7); - } - - /* Try single byte instruction + reg byte OR one whole byte (OCST_1dBYTES). - */ - if (instType == INT_LIST_DIVIDED) { - /* OCST_1dBYTES is relatively simple to OCST_2dBYTES, since it's really - * divided at 0xc0. */ - if (tmpIndex1 < INST_DIVIDED_MODRM) { - /* An instruction which requires a ModR/M byte. Thus it's 1.3 bytes - * long instruction. */ - tmpIndex1 = - (tmpIndex1 >> 3) & 7; /* Isolate the 3 REG/OPCODE bits. */ - } else { /* Normal 2 bytes instruction. */ - /* - * Divided instructions can't be in the range of 0x8-0xc0. - * That's because 0-8 are used for 3 bits group. - * And 0xc0-0xff are used for not-divided instruction. - * So the inbetween range is omitted, thus saving some more place in - * the tables. - */ - tmpIndex1 -= INST_DIVIDED_MODRM - 8; - } - - in = InstructionsTree[INST_NODE_INDEX(in) + tmpIndex1]; - if (in == INT_NOTEXISTS) { - return NULL; - } - instType = INST_NODE_TYPE(in); - - if (instType < INT_INFOS) { - /* If the instruction doesn't support the wait (marked as opsize) as - * part of the opcode, it's illegal. */ - ii = instType == INT_INFO - ? &InstInfos[INST_NODE_INDEX(in)] - : (_InstInfo*)&InstInfosEx[INST_NODE_INDEX(in)]; - if ((~INST_INFO_FLAGS(ii) & INST_PRE_OP_SIZE) && (isWaitIncluded)) { - return NULL; - } - return ii; - } - /* - * If we got here the instruction can support the wait prefix, so see if - * it was part of the stream. Examine prefixed table, specially used for - * 0x9b, since it's optional. No Wait: index = 0. Wait Exists, index - * = 1. - */ - return inst_get_info(in, isWaitIncluded); - } - - /* Don't allow to continue if WAIT is part of the opcode, because there are - * no instructions that include it. */ - if (isWaitIncluded) { - return NULL; - } - - /* Try 2 bytes long instruction (doesn't include ModRM byte). */ - if (instType == INT_LIST_FULL) { - in = InstructionsTree[INST_NODE_INDEX(in) + tmpIndex1]; - if (in == INT_NOTEXISTS) { - return NULL; - } - instType = INST_NODE_TYPE(in); - - /* This is where we check if we just read two escape bytes in a row, - * which means it is a 3DNow! instruction. */ - if ((tmpIndex0 == _3DNOW_ESCAPE_BYTE) && - (tmpIndex1 == _3DNOW_ESCAPE_BYTE)) { - return &II_3dnow; - } - - /* 2 bytes instruction (OCST_2BYTES). */ - if (instType < INT_INFOS) { - return instType == INT_INFO - ? &InstInfos[INST_NODE_INDEX(in)] - : (_InstInfo*)&InstInfosEx[INST_NODE_INDEX(in)]; - } - - /* - * 2 bytes + mandatory perfix. - * Mandatory prefixes can be anywhere in the prefixes. - * There cannot be more than one mandatory prefix, unless it's a normal - * operand size prefix. - */ - if (instType == INT_LIST_PREFIXED) { - return inst_lookup_prefixed(in, ps); - } - } - - /* Read third byte, still doens't mean all of its bits are used (I.E: - * ModRM). */ - ci->code += 1; - ci->codeLen -= 1; - if (ci->codeLen < 0) { - return NULL; - } - tmpIndex2 = *ci->code; - - /* Try 2 bytes + reg instruction (OCST_23BYTES). */ - if (instType == INT_LIST_GROUP) { - in = InstructionsTree[INST_NODE_INDEX(in) + ((tmpIndex2 >> 3) & 7)]; - if (in == INT_NOTEXISTS) { - return NULL; - } - instType = INST_NODE_TYPE(in); - - if (instType < INT_INFOS) { - return instType == INT_INFO - ? &InstInfos[INST_NODE_INDEX(in)] - : (_InstInfo*)&InstInfosEx[INST_NODE_INDEX(in)]; - } - - /* It has to be a prefixed table then. */ - return inst_lookup_prefixed(in, ps); - } - - /* Try 2 bytes + divided range (OCST_2dBYTES). */ - if (instType == INT_LIST_DIVIDED) { - _InstNode in2 = - InstructionsTree[INST_NODE_INDEX(in) + ((tmpIndex2 >> 3) & 7)]; - /* - * Do NOT check for NULL here, since we do a bit of a guess work, - * hence we don't override 'in', cause we might still need it. - */ - instType = INST_NODE_TYPE(in2); - - if (instType == INT_INFO) { - ii = &InstInfos[INST_NODE_INDEX(in2)]; - } else if (instType == INT_INFOEX) { - ii = (_InstInfo*)&InstInfosEx[INST_NODE_INDEX(in2)]; - } - - /* - * OCST_2dBYTES is complex, because there are a few instructions which - * are not divided in some special cases. If the instruction wasn't - * divided (but still it must be a 2.3 because we are in divided - * category) or it was an official 2.3 (because its index was less than - * 0xc0) - Then it means the instruction should be using the REG bits, - * otherwise give a chance to range 0xc0-0xff. - */ - /* If we found an instruction only by its REG bits, AND it is not - * divided, then return it. */ - if ((ii != NULL) && (INST_INFO_FLAGS(ii) & INST_NOT_DIVIDED)) { - return ii; - } - /* Otherwise, if the range is above 0xc0, try the special divided range - * (range 0x8-0xc0 is omitted). */ - if (tmpIndex2 >= INST_DIVIDED_MODRM) { - return inst_get_info(in, tmpIndex2 - INST_DIVIDED_MODRM + 8); - } - - /* It might be that we got here without touching ii in the above if - * statements, then it becomes an invalid instruction prolly. */ - return ii; - } - - /* Try 3 full bytes (OCST_3BYTES - no ModRM byte). */ - if (instType == INT_LIST_FULL) { - /* OCST_3BYTES. */ - in = InstructionsTree[INST_NODE_INDEX(in) + tmpIndex2]; - if (in == INT_NOTEXISTS) { - return NULL; - } - instType = INST_NODE_TYPE(in); - - if (instType < INT_INFOS) { - return instType == INT_INFO - ? &InstInfos[INST_NODE_INDEX(in)] - : (_InstInfo*)&InstInfosEx[INST_NODE_INDEX(in)]; - } - - if (instType == INT_LIST_PREFIXED) { - return inst_lookup_prefixed(in, ps); - } - } - - /* Kahtchinggg, damn. */ - return NULL; -} - -/* -* 3DNow! instruction handling: - -* This is used when we encounter a 3DNow! instruction. -* We can't really locate a 3DNow! instruction before we see two escaped bytes, -* 0x0f, 0x0f. Then we have to extract operands which are, dest=mmx register, -src=mmx register or quadword indirection. -* When we are finished with the extraction of operands we can resume to locate -the instruction by reading another byte -* which tells us which 3DNow instruction we really tracked down... -* So in order to tell the extract operands function which operands the 3DNow! -instruction require, we need to set up some -* generic instruction info for 3DNow! instructions. - -* In the inst_lookup itself, when we read an OCST_3BYTES which the two first -bytes are 0x0f and 0x0f. -* we will return this special generic II for the specific operands we are -interested in (MM, MM64). -* Then after extracting the operand, we'll call a completion routine for -locating the instruction -* which will be called only for 3DNow! instructions, distinguished by a flag, -and it will read the last byte of the 3 bytes. -* -* The id of this opcode should not be used, the following function should change -it anyway. -*/ -_InstInfo* inst_lookup_3dnow(_CodeInfo* ci) -{ - /* Start off from the two escape bytes gates... which is 3DNow! table.*/ - _InstNode in = Table_0F_0F; - - int index; - - /* Make sure we can read a byte off the stream. */ - if (ci->codeLen < 1) { - return NULL; - } - - index = *ci->code; - - ci->codeLen -= 1; - ci->code += 1; - return inst_get_info(in, index); -} diff --git a/target/i386/latx/diStorm/instructions.h b/target/i386/latx/diStorm/instructions.h deleted file mode 100644 index afbe1fcd98a..00000000000 --- a/target/i386/latx/diStorm/instructions.h +++ /dev/null @@ -1,485 +0,0 @@ -/* -instructions.h - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#ifndef INSTRUCTIONS_H -#define INSTRUCTIONS_H - -#include "config.h" - -#include "prefix.h" - -/* - * Operand type possibilities: - * Note "_FULL" suffix indicates to decode the operand as 16 bits or 32 bits - * depends on DecodeType - actually, it depends on the decoding mode, unless - * there's an operand/address size prefix. For example, the code: 33 c0 could be - * decoded/executed as XOR AX, AX or XOR EAX, EAX. - */ -typedef enum OpType { - /* No operand is set */ - OT_NONE = 0, - - /* Read a byte(8 bits) immediate */ - OT_IMM8, - /* Force a read of a word(16 bits) immediate, used by ret only */ - OT_IMM16, - /* Read a word/dword immediate */ - OT_IMM_FULL, - /* Read a double-word(32 bits) immediate */ - OT_IMM32, - - /* Read a signed extended byte(8 bits) immediate */ - OT_SEIMM8, - - /* - * Special immediates for instructions which have more than one immediate, - * which is an exception from standard instruction format. - * As to version v1.0: ENTER, INSERTQ, EXTRQ are the only problematic ones. - */ - /* 16 bits immediate using the first imm-slot */ - OT_IMM16_1, - /* 8 bits immediate using the first imm-slot */ - OT_IMM8_1, - /* 8 bits immediate using the second imm-slot */ - OT_IMM8_2, - - /* Use a 8bit register */ - OT_REG8, - /* Use a 16bit register */ - OT_REG16, - /* Use a 16/32/64bit register */ - OT_REG_FULL, - /* Use a 32bit register */ - OT_REG32, - /* - * If used with REX the reg operand size becomes 64 bits, otherwise 32 bits. - * VMX instructions are promoted automatically without a REX prefix. - */ - OT_REG32_64, - /* Used only by MOV CR/DR(n). Promoted with REX onlly. */ - OT_FREG32_64_RM, - - /* Use or read (indirection) a 8bit register or immediate byte */ - OT_RM8, - /* Some instructions force 16 bits (mov sreg, rm16) */ - OT_RM16, - /* Use or read a 16/32/64bit register or immediate word/dword/qword */ - OT_RM_FULL, - /* - * 32 or 64 bits (with REX) operand size indirection memory operand. - * Some instructions are promoted automatically without a REX prefix. - */ - OT_RM32_64, - /* 16 or 32 bits RM. This is used only with MOVZXD instruction in 64bits. */ - OT_RM16_32, - /* Same as OT_RMXX but POINTS to 16 bits [cannot use GENERAL-PURPOSE REG!] - */ - OT_FPUM16, - /* Same as OT_RMXX but POINTS to 32 bits (single precision) [cannot use - GENERAL-PURPOSE REG!] */ - OT_FPUM32, - /* Same as OT_RMXX but POINTS to 64 bits (double precision) [cannot use - GENERAL-PURPOSE REG!] */ - OT_FPUM64, - /* Same as OT_RMXX but POINTS to 80 bits (extended precision) [cannot use - GENERAL-PURPOSE REG!] */ - OT_FPUM80, - - /* - * Special operand type for SSE4 where the ModR/M might - * be a 32 bits register or 8 bits memory indirection operand. - */ - OT_R32_M8, - /* - * Special ModR/M for PINSRW, which need a 16 bits memory operand or 32 bits - * register. In 16 bits decoding mode R32 becomes R16, operand size cannot - * affect this. - */ - OT_R32_M16, - /* - * Special type for SSE4, ModR/M might be a 32 bits or 64 bits (with REX) - * register or a 8 bits memory indirection operand. - */ - OT_R32_64_M8, - /* - * Special type for SSE4, ModR/M might be a 32 bits or 64 bits (with REX) - * register or a 16 bits memory indirection operand. - */ - OT_R32_64_M16, - /* - * Special operand type for MOV reg16/32/64/mem16, segReg 8C /r. and SMSW. - * It supports all decoding modes, but if used as a memory indirection it's - * a 16 bit ModR/M indirection. - */ - OT_RFULL_M16, - - /* Use a control register */ - OT_CREG, - /* Use a debug register */ - OT_DREG, - /* Use a segment register */ - OT_SREG, - /* - * SEG is encoded in the flags of the opcode itself! - * This is used for specific "push SS" where SS is a segment where - * each "push SS" has an absolutely different opcode byte. - * We need this to detect whether an operand size prefix is used. - */ - OT_SEG, - - /* Use AL */ - OT_ACC8, - /* Use AX (FSTSW) */ - OT_ACC16, - /* Use AX/EAX/RAX */ - OT_ACC_FULL, - /* Use AX/EAX, no REX is possible for RAX, used only with IN/OUT which don't - support 64 bit registers */ - OT_ACC_FULL_NOT64, - - /* - * Read one word (seg), and a word/dword/qword (depends on operand size) - * from memory. JMP FAR [EBX] means EBX point to 16:32 ptr. - */ - OT_MEM16_FULL, - /* Read one word (seg) and a word/dword/qword (depends on operand size), - usually SEG:OFF, JMP 1234:1234 */ - OT_PTR16_FULL, - /* Read one word (limit) and a dword/qword (limit) (depends on operand - size), used by SGDT, SIDT, LGDT, LIDT. */ - OT_MEM16_3264, - - /* Read a byte(8 bits) immediate and calculate it relatively to the current - offset of the instruction being decoded */ - OT_RELCB, - /* Read a word/dword immediate and calculate it relatively to the current - offset of the instruction being decoded */ - OT_RELC_FULL, - - /* Use general memory indirection, with varying sizes: */ - OT_MEM, - /* Used when a memory indirection is required, but if the mod field is 11, - this operand will be ignored. */ - OT_MEM_OPT, - OT_MEM32, - /* Memory dereference for MOVNTI, either 32 or 64 bits (with REX). */ - OT_MEM32_64, - OT_MEM64, - OT_MEM128, - /* Used for cmpxchg8b/16b. */ - OT_MEM64_128, - - /* Read an immediate as an absolute address, size is known by instruction, - used by MOV (memory offset) only */ - OT_MOFFS8, - OT_MOFFS_FULL, - /* Use an immediate of 1, as for SHR R/M, 1 */ - OT_CONST1, - /* Use CL, as for SHR R/M, CL */ - OT_REGCL, - - /* - * Instruction-Block for one byte long instructions, used by - * INC/DEC/PUSH/POP/XCHG, REG is extracted from the value of opcode Use a - * 8bit register - */ - OT_IB_RB, - /* Use a 16/32/64bit register */ - OT_IB_R_FULL, - - /* Use [(r)SI] as INDIRECTION, for repeatable instructions */ - OT_REGI_ESI, - /* Use [(r)DI] as INDIRECTION, for repeatable instructions */ - OT_REGI_EDI, - /* Use [(r)BX + AL] as INDIRECTIOM, used by XLAT only */ - OT_REGI_EBXAL, - /* Use [(r)AX] as INDIRECTION, used by AMD's SVM instructions */ - OT_REGI_EAX, - /* Use DX, as for OUTS DX, BYTE [SI] */ - OT_REGDX, - /* Use ECX in INVLPGA instruction */ - OT_REGECX, - - /* FPU registers: */ - OT_FPU_SI, /* ST(i) */ - OT_FPU_SSI, /* ST(0), ST(i) */ - OT_FPU_SIS, /* ST(i), ST(0) */ - - /* MMX registers: */ - OT_MM, - /* Extract the MMX register from the RM bits this time (used when the REG - bits are used for opcode extension) */ - OT_MM_RM, - /* ModR/M points to 32 bits MMX variable */ - OT_MM32, - /* ModR/M points to 32 bits MMX variable */ - OT_MM64, - - /* SSE registers: */ - OT_XMM, - /* Extract the SSE register from the RM bits this time (used when the REG - bits are used for opcode extension) */ - OT_XMM_RM, - /* ModR/M points to 16 bits SSE variable */ - OT_XMM16, - /* ModR/M points to 32 bits SSE variable */ - OT_XMM32, - /* ModR/M points to 64 bits SSE variable */ - OT_XMM64, - /* ModR/M points to 128 bits SSE variable */ - OT_XMM128, - /* Implied XMM0 register as operand, used in SSE4. */ - OT_REGXMM0, - - /* AVX operands: */ - - /* ModR/M for 32 bits. */ - OT_RM32, - /* Reg32/Reg64 (prefix width) or Mem8. */ - OT_REG32_64_M8, - /* Reg32/Reg64 (prefix width) or Mem16. */ - OT_REG32_64_M16, - /* Reg32/Reg 64 depends on prefix width only. */ - OT_WREG32_64, - /* RM32/RM64 depends on prefix width only. */ - OT_WRM32_64, - /* XMM or Mem32/Mem64 depends on perfix width only. */ - OT_WXMM32_64, - /* XMM is encoded in VEX.VVVV. */ - OT_VXMM, - /* XMM is encoded in the high nibble of an immediate byte. */ - OT_XMM_IMM, - /* YMM/XMM is dependent on VEX.L. */ - OT_YXMM, - /* YMM/XMM (depends on prefix length) is encoded in the high nibble of an - immediate byte. */ - OT_YXMM_IMM, - /* YMM is encoded in reg. */ - OT_YMM, - /* YMM or Mem256. */ - OT_YMM256, - /* YMM is encoded in VEX.VVVV. */ - OT_VYMM, - /* YMM/XMM is dependent on VEX.L, and encoded in VEX.VVVV. */ - OT_VYXMM, - /* YMM/XMM or Mem64/Mem256 is dependent on VEX.L. */ - OT_YXMM64_256, - /* YMM/XMM or Mem128/Mem256 is dependent on VEX.L. */ - OT_YXMM128_256, - /* XMM or Mem64/Mem256 is dependent on VEX.L. */ - OT_LXMM64_128, - /* Mem128/Mem256 is dependent on VEX.L. */ - OT_LMEM128_256 -} _OpType; - -/* Flags for instruction: */ - -/* Empty flags indicator: */ -#define INST_FLAGS_NONE (0) -/* The instruction we are going to decode requires ModR/M encoding. */ -#define INST_MODRM_REQUIRED (1) -/* Special treatment for instructions which are in the divided-category but - * still needs the whole byte for ModR/M... */ -#define INST_NOT_DIVIDED (1 << 1) -/* - * Used explicitly in repeatable instructions, - * which needs a suffix letter in their mnemonic to specify operation-size - * (depend on operands). - */ -#define INST_16BITS (1 << 2) -/* If the opcode is supported by 80286 and upper models (16/32 bits). */ -#define INST_32BITS (1 << 3) -/* - * Prefix flags (6 types: lock/rep, seg override, addr-size, oper-size, REX, - * VEX) There are several specific instructions that can follow LOCK prefix, - * note that they must be using a memory operand form, otherwise they generate - * an exception. - */ -#define INST_PRE_LOCK (1 << 4) -/* REPNZ prefix for string instructions only - means an instruction can follow - * it. */ -#define INST_PRE_REPNZ (1 << 5) -/* REP prefix for string instructions only - means an instruction can follow it. - */ -#define INST_PRE_REP (1 << 6) -/* CS override prefix. */ -#define INST_PRE_CS (1 << 7) -/* SS override prefix. */ -#define INST_PRE_SS (1 << 8) -/* DS override prefix. */ -#define INST_PRE_DS (1 << 9) -/* ES override prefix. */ -#define INST_PRE_ES (1 << 10) -/* FS override prefix. Funky Segment :) */ -#define INST_PRE_FS (1 << 11) -/* GS override prefix. Groovy Segment, of course not, duh ! */ -#define INST_PRE_GS (1 << 12) -/* Switch operand size from 32 to 16 and vice versa. */ -#define INST_PRE_OP_SIZE (1 << 13) -/* Switch address size from 32 to 16 and vice versa. */ -#define INST_PRE_ADDR_SIZE (1 << 14) -/* Native instructions which needs suffix letter to indicate their - * operation-size (and don't depend on operands). */ -#define INST_NATIVE (1 << 15) -/* Use extended mnemonic, means it's an _InstInfoEx structure, which contains - * another mnemonic for 32 bits specifically. */ -#define INST_USE_EXMNEMONIC (1 << 16) -/* Use third operand, means it's an _InstInfoEx structure, which contains - * another operand for special instructions. */ -#define INST_USE_OP3 (1 << 17) -/* Use fourth operand, means it's an _InstInfoEx structure, which contains - * another operand for special instructions. */ -#define INST_USE_OP4 (1 << 18) -/* The instruction's mnemonic depends on the mod value of the ModR/M byte - * (mod=11, mod!=11). */ -#define INST_MNEMONIC_MODRM_BASED (1 << 19) -/* The instruction uses a ModR/M byte which the MOD must be 11 (for registers - * operands only). */ -#define INST_MODRR (1 << 20) -/* The way of 3DNow! instructions are built, we have to handle their locating - * specially. Suffix imm8 tells which instruction it is. */ -#define INST_3DNOW_FETCH (1 << 21) -/* The instruction needs two suffixes, one for the comparison type (imm8) and - * the second for its operation size indication (second mnemonic). */ -#define INST_PSEUDO_OPCODE (1 << 22) -/* Invalid instruction at 64 bits decoding mode. */ -#define INST_INVALID_64BITS (1 << 23) -/* Specific instruction can be promoted to 64 bits (without REX, it is promoted - * automatically). */ -#define INST_64BITS (1 << 24) -/* Indicates the instruction must be REX prefixed in order to use 64 bits - * operands. */ -#define INST_PRE_REX (1 << 25) -/* Third mnemonic is set. */ -#define INST_USE_EXMNEMONIC2 (1 << 26) -/* Instruction is only valid in 64 bits decoding mode. */ -#define INST_64BITS_FETCH (1 << 27) -/* Forces that the ModRM-REG/Opcode field will be 0. (For EXTRQ). */ -#define INST_FORCE_REG0 (1 << 28) -/* Indicates that instruction is encoded with a VEX prefix. */ -#define INST_PRE_VEX (1 << 29) -/* Indicates that the instruction is encoded with a ModRM byte (REG field - * specifically). */ -#define INST_MODRM_INCLUDED (1 << 30) -/* Indicates that the first (/destination) operand of the instruction is - * writable. */ -#define INST_DST_WR (1 << 31) - -#define INST_PRE_REPS (INST_PRE_REPNZ | INST_PRE_REP) -#define INST_PRE_LOKREP_MASK (INST_PRE_LOCK | INST_PRE_REPNZ | INST_PRE_REP) -#define INST_PRE_SEGOVRD_MASK32 \ - (INST_PRE_CS | INST_PRE_SS | INST_PRE_DS | INST_PRE_ES) -#define INST_PRE_SEGOVRD_MASK64 (INST_PRE_FS | INST_PRE_GS) -#define INST_PRE_SEGOVRD_MASK \ - (INST_PRE_SEGOVRD_MASK32 | INST_PRE_SEGOVRD_MASK64) - -/* Extended flags for VEX: */ -/* Indicates that the instruction might have VEX.L encoded. */ -#define INST_VEX_L (1) -/* Indicates that the instruction might have VEX.W encoded. */ -#define INST_VEX_W (1 << 1) -/* Indicates that the mnemonic of the instruction is based on the VEX.W bit. */ -#define INST_MNEMONIC_VEXW_BASED (1 << 2) -/* Indicates that the mnemonic of the instruction is based on the VEX.L bit. */ -#define INST_MNEMONIC_VEXL_BASED (1 << 3) -/* Forces the instruction to be encoded with VEX.L, otherwise it's undefined. */ -#define INST_FORCE_VEXL (1 << 4) - -/* - * Indicates which operand is being decoded. - * Destination (1st), Source (2nd), op3 (3rd), op4 (4th). - * Used to set the operands' fields in the _DInst structure! - */ -typedef enum { - ONT_NONE = -1, - ONT_1 = 0, - ONT_2 = 1, - ONT_3 = 2, - ONT_4 = 3 -} _OperandNumberType; - -/* - * Info about the instruction, source/dest types, its name in text and flags. - * This structure is used for the instructions DB and NOT for the disassembled - * result code! This is the BASE structure, there are extentions to this - * structure below. - */ - -typedef struct { - uint8_t flagsIndex; /* An index into FlagsTables. */ - uint8_t s, d; /* OpType. */ - uint8_t meta; /* Hi 5 bits = Instruction set class | Lo 3 bits = flow - control flags. */ - uint16_t opcodeId; /* The opcodeId is really a byte-offset into the - mnemonics table. */ -} _InstInfo; - -/* - * There are merely few instructions which need a second mnemonic for 32 bits. - * Or a third for 64 bits. Therefore sometimes the second mnemonic is empty but - * not the third. In all decoding modes the first mnemonic is the default. A - * flag will indicate it uses another mnemonic. - * - * There are a couple of (SSE4) instructions in the whole DB which need both op3 - * and 3rd mnemonic for 64bits, therefore, I decided to make the extended - * structure contain all extra info in the same structure. There are a few - * instructions (SHLD/SHRD/IMUL and SSE too) which use third operand (or a - * fourth). A flag will indicate it uses a third/fourth operand. - * - */ -typedef struct { - /* Base structure (doesn't get accessed directly from code). */ - _InstInfo BASE; - - /* Extended starts here. */ - uint8_t flagsEx; /* 8 bits are enough, in the future we might make it a - bigger integer. */ - uint8_t op3, op4; /* OpType. */ - uint16_t opcodeId2, opcodeId3; -} _InstInfoEx; - -/* Trie data structure node type: */ -typedef enum { - INT_NOTEXISTS = 0, /* Not exists. */ - INT_INFO = 1, /* It's an instruction info. */ - INT_INFOEX, - INT_LIST_GROUP, - INT_LIST_FULL, - INT_LIST_DIVIDED, - INT_LIST_PREFIXED -} _InstNodeType; - -/* Used to check instType < INT_INFOS, means we got an inst-info. Cause it has - * to be only one of them. */ -#define INT_INFOS (INT_LIST_GROUP) - -/* Instruction node is treated as { int index:15; int type:3; } */ -typedef uint16_t _InstNode; - -/* Helper macro to read the actual flags that are associated with an inst-info. - */ -#define INST_INFO_FLAGS(ii) (FlagsTable[(ii)->flagsIndex]) - -_InstInfo* inst_lookup(_CodeInfo* ci, _PrefixState* ps); -_InstInfo* inst_lookup_3dnow(_CodeInfo* ci); - -#endif /* INSTRUCTIONS_H */ diff --git a/target/i386/latx/diStorm/insts.c b/target/i386/latx/diStorm/insts.c deleted file mode 100644 index ace8ad8bc84..00000000000 --- a/target/i386/latx/diStorm/insts.c +++ /dev/null @@ -1,7012 +0,0 @@ -/* -insts.c - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#include "config.h" -#include "insts.h" -#include "instructions.h" - -/* - * GENERATED BY disOps at Thu Jun 16 00:55:44 2011 - */ - -/* See x86defs.c if you get an error here. */ -_iflags FlagsTable[93 + 5] = { - INST_MODRM_REQUIRED, - INST_MODRM_REQUIRED | INST_PRE_REX | INST_64BITS, - INST_FLAGS_NONE, - INST_FLAGS_NONE, - INST_32BITS | INST_MODRM_REQUIRED | INST_3DNOW_FETCH, - 0x80000011, - 0x80000000, - 0x800400, - 0x80800400, - 0x800080, - 0x800100, - 0x80800100, - 0x800200, - 0x80800200, - 0x800000, - 0x1, - 0x0, - 0x80800000, - 0x1000000, - 0x81000000, - 0x808000, - 0x800001, - 0x1000001, - 0x80020001, - 0x1002000, - 0x60, - 0x64, - 0x80000001, - 0x4010000, - 0x1008000, - 0x80000060, - 0x83000064, - 0x3000064, - 0x83000000, - 0x3008000, - 0x200, - 0xc000, - 0x4014000, - 0x8, - 0x81000009, - 0x800008, - 0x9, - 0x80000009, - 0x1000808, - 0x81000808, - 0x80020009, - 0x1001008, - 0x81001008, - 0x80000019, - 0x3000009, - 0x83000009, - 0x83000008, - 0xc0000011, - 0x40000001, - 0xc0800011, - 0x40800001, - 0xc0000019, - 0xc1000001, - 0xc0000001, - 0x40000000, - 0x40000008, - 0x40000009, - 0x41000001, - 0x43000001, - 0xc0000003, - 0x40000003, - 0x48000000, - 0x200009, - 0x20020009, - 0x20000009, - 0x80090009, - 0x200a0009, - 0x80100009, - 0x21100009, - 0x87000009, - 0x20009, - 0x20000008, - 0x1000009, - 0x10020009, - 0x160009, - 0x100009, - 0x40090009, - 0x40100009, - 0x80002009, - 0xc0000009, - 0x80002001, - 0x410009, - 0x20420009, - 0x20060009, - 0x120009, - 0x21020009, - 0xc7000019, - 0x20100009, - 0x40002009, - 0x40002008, - 0x4020009, - 0x60120009, - 0x60000009}; - -_InstNode Table_0F = 256; -_InstNode Table_0F_0F = 1312; -_InstNode Table_0F_38 = 1768; -_InstNode Table_0F_3A = 2024; - -_InstInfo InstInfos[] = { - /*II_00*/ {0x5, 9, 15, 8, 11}, - /*II_01*/ {0x5, 11, 17, 8, 11}, - /*II_02*/ {0x5, 15, 9, 8, 11}, - /*II_03*/ {0x5, 17, 11, 8, 11}, - /*II_04*/ {0x6, 1, 33, 8, 11}, - /*II_05*/ {0x6, 3, 35, 8, 11}, - /*II_06*/ {0x7, 0, 32, 8, 16}, - /*II_07*/ {0x8, 0, 32, 8, 22}, - /*II_08*/ {0x5, 9, 15, 8, 27}, - /*II_09*/ {0x5, 11, 17, 8, 27}, - /*II_0A*/ {0x5, 15, 9, 8, 27}, - /*II_0B*/ {0x5, 17, 11, 8, 27}, - /*II_0C*/ {0x6, 1, 33, 8, 27}, - /*II_0D*/ {0x6, 3, 35, 8, 27}, - /*II_0E*/ {0x9, 0, 32, 8, 16}, - /*II_10*/ {0x5, 9, 15, 8, 31}, - /*II_11*/ {0x5, 11, 17, 8, 31}, - /*II_12*/ {0x5, 15, 9, 8, 31}, - /*II_13*/ {0x5, 17, 11, 8, 31}, - /*II_14*/ {0x6, 1, 33, 8, 31}, - /*II_15*/ {0x6, 3, 35, 8, 31}, - /*II_16*/ {0xa, 0, 32, 8, 16}, - /*II_17*/ {0xb, 0, 32, 8, 22}, - /*II_18*/ {0x5, 9, 15, 8, 36}, - /*II_19*/ {0x5, 11, 17, 8, 36}, - /*II_1A*/ {0x5, 15, 9, 8, 36}, - /*II_1B*/ {0x5, 17, 11, 8, 36}, - /*II_1C*/ {0x6, 1, 33, 8, 36}, - /*II_1D*/ {0x6, 3, 35, 8, 36}, - /*II_1E*/ {0xc, 0, 32, 8, 16}, - /*II_1F*/ {0xd, 0, 32, 8, 22}, - /*II_20*/ {0x5, 9, 15, 8, 41}, - /*II_21*/ {0x5, 11, 17, 8, 41}, - /*II_22*/ {0x5, 15, 9, 8, 41}, - /*II_23*/ {0x5, 17, 11, 8, 41}, - /*II_24*/ {0x6, 1, 33, 8, 41}, - /*II_25*/ {0x6, 3, 35, 8, 41}, - /*II_27*/ {0xe, 0, 0, 8, 46}, - /*II_28*/ {0x5, 9, 15, 8, 51}, - /*II_29*/ {0x5, 11, 17, 8, 51}, - /*II_2A*/ {0x5, 15, 9, 8, 51}, - /*II_2B*/ {0x5, 17, 11, 8, 51}, - /*II_2C*/ {0x6, 1, 33, 8, 51}, - /*II_2D*/ {0x6, 3, 35, 8, 51}, - /*II_2F*/ {0xe, 0, 0, 8, 56}, - /*II_30*/ {0x5, 9, 15, 8, 61}, - /*II_31*/ {0x5, 11, 17, 8, 61}, - /*II_32*/ {0x5, 15, 9, 8, 61}, - /*II_33*/ {0x5, 17, 11, 8, 61}, - /*II_34*/ {0x6, 1, 33, 8, 61}, - /*II_35*/ {0x6, 3, 35, 8, 61}, - /*II_37*/ {0xe, 0, 0, 8, 66}, - /*II_38*/ {0xf, 9, 15, 8, 71}, - /*II_39*/ {0xf, 11, 17, 8, 71}, - /*II_3A*/ {0xf, 15, 9, 8, 71}, - /*II_3B*/ {0xf, 17, 11, 8, 71}, - /*II_3C*/ {0x10, 1, 33, 8, 71}, - /*II_3D*/ {0x10, 3, 35, 8, 71}, - /*II_3F*/ {0xe, 0, 0, 8, 76}, - /*II_40*/ {0x11, 0, 54, 8, 81}, - /*II_40*/ {0x11, 0, 54, 8, 81}, - /*II_40*/ {0x11, 0, 54, 8, 81}, - /*II_40*/ {0x11, 0, 54, 8, 81}, - /*II_40*/ {0x11, 0, 54, 8, 81}, - /*II_40*/ {0x11, 0, 54, 8, 81}, - /*II_40*/ {0x11, 0, 54, 8, 81}, - /*II_40*/ {0x11, 0, 54, 8, 81}, - /*II_48*/ {0x11, 0, 54, 8, 86}, - /*II_48*/ {0x11, 0, 54, 8, 86}, - /*II_48*/ {0x11, 0, 54, 8, 86}, - /*II_48*/ {0x11, 0, 54, 8, 86}, - /*II_48*/ {0x11, 0, 54, 8, 86}, - /*II_48*/ {0x11, 0, 54, 8, 86}, - /*II_48*/ {0x11, 0, 54, 8, 86}, - /*II_48*/ {0x11, 0, 54, 8, 86}, - /*II_50*/ {0x12, 0, 54, 8, 16}, - /*II_50*/ {0x12, 0, 54, 8, 16}, - /*II_50*/ {0x12, 0, 54, 8, 16}, - /*II_50*/ {0x12, 0, 54, 8, 16}, - /*II_50*/ {0x12, 0, 54, 8, 16}, - /*II_50*/ {0x12, 0, 54, 8, 16}, - /*II_50*/ {0x12, 0, 54, 8, 16}, - /*II_50*/ {0x12, 0, 54, 8, 16}, - /*II_58*/ {0x13, 0, 54, 8, 22}, - /*II_58*/ {0x13, 0, 54, 8, 22}, - /*II_58*/ {0x13, 0, 54, 8, 22}, - /*II_58*/ {0x13, 0, 54, 8, 22}, - /*II_58*/ {0x13, 0, 54, 8, 22}, - /*II_58*/ {0x13, 0, 54, 8, 22}, - /*II_58*/ {0x13, 0, 54, 8, 22}, - /*II_58*/ {0x13, 0, 54, 8, 22}, - /*II_60*/ {0x14, 0, 0, 8, 91}, - /*II_61*/ {0x14, 0, 0, 8, 98}, - /*II_62*/ {0x15, 42, 11, 8, 104}, - /*II_63*/ {0x16, 10, 16, 8, 111}, - /*II_68*/ {0x12, 0, 3, 8, 16}, - /*II_6A*/ {0x18, 0, 5, 8, 16}, - /*II_6C*/ {0x19, 59, 56, 8, 123}, - /*II_6D*/ {0x1a, 59, 56, 8, 123}, - /*II_6E*/ {0x19, 55, 59, 8, 128}, - /*II_6F*/ {0x1a, 55, 59, 8, 128}, - /*II_70*/ {0x12, 0, 40, 13, 134}, - /*II_71*/ {0x12, 0, 40, 13, 138}, - /*II_72*/ {0x12, 0, 40, 13, 143}, - /*II_73*/ {0x12, 0, 40, 13, 147}, - /*II_74*/ {0x12, 0, 40, 13, 152}, - /*II_75*/ {0x12, 0, 40, 13, 156}, - /*II_76*/ {0x12, 0, 40, 13, 161}, - /*II_77*/ {0x12, 0, 40, 13, 166}, - /*II_78*/ {0x12, 0, 40, 13, 170}, - /*II_79*/ {0x12, 0, 40, 13, 174}, - /*II_7A*/ {0x12, 0, 40, 13, 179}, - /*II_7B*/ {0x12, 0, 40, 13, 183}, - /*II_7C*/ {0x12, 0, 40, 13, 188}, - /*II_7D*/ {0x12, 0, 40, 13, 192}, - /*II_7E*/ {0x12, 0, 40, 13, 197}, - /*II_7F*/ {0x12, 0, 40, 13, 202}, - /*II_84*/ {0xf, 9, 15, 8, 206}, - /*II_85*/ {0xf, 11, 17, 8, 206}, - /*II_86*/ {0x5, 9, 15, 8, 212}, - /*II_87*/ {0x5, 11, 17, 8, 212}, - /*II_88*/ {0x1b, 9, 15, 8, 218}, - /*II_89*/ {0x1b, 11, 17, 8, 218}, - /*II_8A*/ {0x1b, 15, 9, 8, 218}, - /*II_8B*/ {0x1b, 17, 11, 8, 218}, - /*II_8C*/ {0x1b, 31, 28, 8, 218}, - /*II_8D*/ {0x1b, 42, 11, 8, 223}, - /*II_8E*/ {0x1b, 16, 31, 8, 218}, - /*II_90*/ {0x6, 35, 54, 8, 212}, - /*II_91*/ {0x6, 35, 54, 8, 212}, - /*II_92*/ {0x6, 35, 54, 8, 212}, - /*II_93*/ {0x6, 35, 54, 8, 212}, - /*II_94*/ {0x6, 35, 54, 8, 212}, - /*II_95*/ {0x6, 35, 54, 8, 212}, - /*II_96*/ {0x6, 35, 54, 8, 212}, - /*II_97*/ {0x6, 35, 54, 8, 212}, - /*II_9A*/ {0xe, 0, 38, 9, 260}, - /*II_9C*/ {0x1d, 0, 0, 8, 270}, - /*II_9D*/ {0x1d, 0, 0, 8, 277}, - /*II_9E*/ {0x10, 0, 0, 8, 283}, - /*II_9F*/ {0x10, 0, 0, 8, 289}, - /*II_A0*/ {0x6, 49, 33, 8, 218}, - /*II_A1*/ {0x6, 50, 35, 8, 218}, - /*II_A2*/ {0x6, 33, 49, 8, 218}, - /*II_A3*/ {0x6, 35, 50, 8, 218}, - /*II_A4*/ {0x1e, 55, 56, 8, 295}, - /*II_A5*/ {0x1f, 55, 56, 8, 295}, - /*II_A6*/ {0x19, 56, 55, 8, 301}, - /*II_A7*/ {0x20, 56, 55, 8, 301}, - /*II_A8*/ {0x10, 1, 33, 8, 206}, - /*II_A9*/ {0x10, 3, 35, 8, 206}, - /*II_AA*/ {0x19, 33, 56, 8, 307}, - /*II_AB*/ {0x20, 35, 56, 8, 307}, - /*II_AC*/ {0x19, 55, 33, 8, 313}, - /*II_AD*/ {0x20, 55, 35, 8, 313}, - /*II_AE*/ {0x19, 33, 56, 8, 319}, - /*II_AF*/ {0x20, 35, 56, 8, 319}, - /*II_B0*/ {0x6, 1, 53, 8, 218}, - /*II_B0*/ {0x6, 1, 53, 8, 218}, - /*II_B0*/ {0x6, 1, 53, 8, 218}, - /*II_B0*/ {0x6, 1, 53, 8, 218}, - /*II_B0*/ {0x6, 1, 53, 8, 218}, - /*II_B0*/ {0x6, 1, 53, 8, 218}, - /*II_B0*/ {0x6, 1, 53, 8, 218}, - /*II_B0*/ {0x6, 1, 53, 8, 218}, - /*II_B8*/ {0x21, 3, 54, 8, 218}, - /*II_B8*/ {0x21, 3, 54, 8, 218}, - /*II_B8*/ {0x21, 3, 54, 8, 218}, - /*II_B8*/ {0x21, 3, 54, 8, 218}, - /*II_B8*/ {0x21, 3, 54, 8, 218}, - /*II_B8*/ {0x21, 3, 54, 8, 218}, - /*II_B8*/ {0x21, 3, 54, 8, 218}, - /*II_B8*/ {0x21, 3, 54, 8, 218}, - /*II_C2*/ {0x12, 0, 2, 10, 325}, - /*II_C3*/ {0x12, 0, 0, 10, 325}, - /*II_C4*/ {0x15, 37, 11, 8, 330}, - /*II_C5*/ {0x15, 37, 11, 8, 335}, - /*II_C8*/ {0x12, 8, 6, 8, 340}, - /*II_C9*/ {0x12, 0, 0, 8, 347}, - /*II_CA*/ {0x22, 0, 2, 10, 354}, - /*II_CB*/ {0x22, 0, 0, 10, 354}, - /*II_CC*/ {0x10, 0, 0, 14, 360}, - /*II_CD*/ {0x10, 0, 1, 14, 367}, - /*II_CE*/ {0xe, 0, 0, 14, 372}, - /*II_CF*/ {0x22, 0, 0, 10, 378}, - /*II_D4*/ {0xe, 0, 1, 8, 384}, - /*II_D5*/ {0xe, 0, 1, 8, 389}, - /*II_D6*/ {0xe, 0, 0, 8, 394}, - /*II_D7*/ {0x23, 0, 57, 8, 400}, - /*II_E0*/ {0x24, 0, 40, 13, 406}, - /*II_E1*/ {0x24, 0, 40, 13, 414}, - /*II_E2*/ {0x24, 0, 40, 13, 421}, - /*II_E4*/ {0x6, 1, 33, 8, 447}, - /*II_E5*/ {0x6, 1, 36, 8, 447}, - /*II_E6*/ {0x10, 33, 1, 8, 451}, - /*II_E7*/ {0x10, 36, 1, 8, 451}, - /*II_E8*/ {0x12, 0, 41, 9, 456}, - /*II_E9*/ {0x12, 0, 41, 12, 462}, - /*II_EA*/ {0xe, 0, 38, 12, 467}, - /*II_EB*/ {0x12, 0, 40, 12, 462}, - /*II_EC*/ {0x6, 59, 33, 8, 447}, - /*II_ED*/ {0x6, 59, 36, 8, 447}, - /*II_EE*/ {0x10, 33, 59, 8, 451}, - /*II_EF*/ {0x10, 36, 59, 8, 451}, - /*II_F1*/ {0x10, 0, 0, 14, 476}, - /*II_F4*/ {0x10, 0, 0, 8, 482}, - /*II_F5*/ {0x10, 0, 0, 8, 487}, - /*II_F8*/ {0x10, 0, 0, 8, 492}, - /*II_F9*/ {0x10, 0, 0, 8, 497}, - /*II_FA*/ {0x10, 0, 0, 8, 502}, - /*II_FB*/ {0x10, 0, 0, 8, 507}, - /*II_FC*/ {0x10, 0, 0, 8, 512}, - /*II_FD*/ {0x10, 0, 0, 8, 517}, - /*II_0F_02*/ {0xf, 16, 11, 8, 522}, - /*II_0F_03*/ {0xf, 16, 11, 8, 527}, - /*II_0F_05*/ {0x26, 0, 0, 27, 532}, - /*II_0F_06*/ {0x26, 0, 0, 8, 541}, - /*II_0F_07*/ {0x26, 0, 0, 27, 547}, - /*II_0F_08*/ {0x26, 0, 0, 8, 555}, - /*II_0F_09*/ {0x26, 0, 0, 8, 561}, - /*II_0F_0B*/ {0x26, 0, 0, 14, 569}, - /*II_0F_0E*/ {0x10, 0, 0, 96, 574}, - /*II_0F_1F*/ {0xf, 0, 17, 8, 581}, - /*II_0F_20*/ {0x27, 29, 14, 8, 218}, - /*II_0F_21*/ {0x27, 30, 14, 8, 218}, - /*II_0F_22*/ {0x27, 14, 29, 8, 218}, - /*II_0F_23*/ {0x27, 14, 30, 8, 218}, - /*II_0F_30*/ {0x26, 0, 0, 8, 586}, - /*II_0F_31*/ {0x26, 0, 0, 8, 593}, - /*II_0F_32*/ {0x26, 0, 0, 8, 600}, - /*II_0F_33*/ {0x26, 0, 0, 8, 607}, - /*II_0F_34*/ {0x28, 0, 0, 27, 614}, - /*II_0F_35*/ {0x28, 0, 0, 27, 624}, - /*II_0F_37*/ {0x29, 0, 0, 8, 633}, - /*II_0F_40*/ {0x2a, 17, 11, 31, 641}, - /*II_0F_41*/ {0x2a, 17, 11, 31, 648}, - /*II_0F_42*/ {0x2a, 17, 11, 31, 656}, - /*II_0F_43*/ {0x2a, 17, 11, 31, 663}, - /*II_0F_44*/ {0x2a, 17, 11, 31, 671}, - /*II_0F_45*/ {0x2a, 17, 11, 31, 678}, - /*II_0F_46*/ {0x2a, 17, 11, 31, 686}, - /*II_0F_47*/ {0x2a, 17, 11, 31, 694}, - /*II_0F_48*/ {0x2a, 17, 11, 31, 701}, - /*II_0F_49*/ {0x2a, 17, 11, 31, 708}, - /*II_0F_4A*/ {0x2a, 17, 11, 31, 716}, - /*II_0F_4B*/ {0x2a, 17, 11, 31, 723}, - /*II_0F_4C*/ {0x2a, 17, 11, 31, 731}, - /*II_0F_4D*/ {0x2a, 17, 11, 31, 738}, - /*II_0F_4E*/ {0x2a, 17, 11, 31, 746}, - /*II_0F_4F*/ {0x2a, 17, 11, 31, 754}, - /*II_0F_80*/ {0x26, 0, 41, 13, 134}, - /*II_0F_81*/ {0x26, 0, 41, 13, 138}, - /*II_0F_82*/ {0x26, 0, 41, 13, 143}, - /*II_0F_83*/ {0x26, 0, 41, 13, 147}, - /*II_0F_84*/ {0x26, 0, 41, 13, 152}, - /*II_0F_85*/ {0x26, 0, 41, 13, 156}, - /*II_0F_86*/ {0x26, 0, 41, 13, 161}, - /*II_0F_87*/ {0x26, 0, 41, 13, 166}, - /*II_0F_88*/ {0x26, 0, 41, 13, 170}, - /*II_0F_89*/ {0x26, 0, 41, 13, 174}, - /*II_0F_8A*/ {0x26, 0, 41, 13, 179}, - /*II_0F_8B*/ {0x26, 0, 41, 13, 183}, - /*II_0F_8C*/ {0x26, 0, 41, 13, 188}, - /*II_0F_8D*/ {0x26, 0, 41, 13, 192}, - /*II_0F_8E*/ {0x26, 0, 41, 13, 197}, - /*II_0F_8F*/ {0x26, 0, 41, 13, 202}, - /*II_0F_90*/ {0x2a, 0, 15, 8, 761}, - /*II_0F_91*/ {0x2a, 0, 15, 8, 767}, - /*II_0F_92*/ {0x2a, 0, 15, 8, 774}, - /*II_0F_93*/ {0x2a, 0, 15, 8, 780}, - /*II_0F_94*/ {0x2a, 0, 15, 8, 787}, - /*II_0F_95*/ {0x2a, 0, 15, 8, 793}, - /*II_0F_96*/ {0x2a, 0, 15, 8, 800}, - /*II_0F_97*/ {0x2a, 0, 15, 8, 807}, - /*II_0F_98*/ {0x2a, 0, 15, 8, 813}, - /*II_0F_99*/ {0x2a, 0, 15, 8, 819}, - /*II_0F_9A*/ {0x2a, 0, 15, 8, 826}, - /*II_0F_9B*/ {0x2a, 0, 15, 8, 832}, - /*II_0F_9C*/ {0x2a, 0, 15, 8, 839}, - /*II_0F_9D*/ {0x2a, 0, 15, 8, 845}, - /*II_0F_9E*/ {0x2a, 0, 15, 8, 852}, - /*II_0F_9F*/ {0x2a, 0, 15, 8, 859}, - /*II_0F_A0*/ {0x2b, 0, 32, 8, 16}, - /*II_0F_A1*/ {0x2c, 0, 32, 8, 22}, - /*II_0F_A2*/ {0x26, 0, 0, 8, 865}, - /*II_0F_A3*/ {0x2a, 11, 17, 8, 872}, - /*II_0F_A8*/ {0x2e, 0, 32, 8, 16}, - /*II_0F_A9*/ {0x2f, 0, 32, 8, 22}, - /*II_0F_AA*/ {0x26, 0, 0, 8, 882}, - /*II_0F_AB*/ {0x30, 11, 17, 8, 887}, - /*II_0F_AF*/ {0x2a, 17, 11, 8, 117}, - /*II_0F_B0*/ {0x30, 9, 15, 8, 898}, - /*II_0F_B1*/ {0x30, 11, 17, 8, 898}, - /*II_0F_B2*/ {0x31, 37, 11, 8, 907}, - /*II_0F_B3*/ {0x30, 11, 17, 8, 912}, - /*II_0F_B4*/ {0x31, 37, 11, 8, 917}, - /*II_0F_B5*/ {0x31, 37, 11, 8, 922}, - /*II_0F_B6*/ {0x2a, 15, 11, 8, 927}, - /*II_0F_B7*/ {0x32, 16, 11, 8, 927}, - /*II_0F_B9*/ {0x26, 0, 0, 14, 569}, - /*II_0F_BB*/ {0x30, 11, 17, 8, 934}, - /*II_0F_BC*/ {0x29, 17, 11, 8, 939}, - /*II_0F_BE*/ {0x2a, 15, 11, 8, 944}, - /*II_0F_BF*/ {0x32, 16, 11, 8, 944}, - /*II_0F_C0*/ {0x30, 9, 15, 8, 951}, - /*II_0F_C1*/ {0x30, 11, 17, 8, 951}, - /*II_0F_C3*/ {0x32, 13, 45, 48, 957}, - /*II_0F_C8*/ {0x33, 0, 54, 8, 965}, - /*II_0F_C8*/ {0x33, 0, 54, 8, 965}, - /*II_0F_C8*/ {0x33, 0, 54, 8, 965}, - /*II_0F_C8*/ {0x33, 0, 54, 8, 965}, - /*II_0F_C8*/ {0x33, 0, 54, 8, 965}, - /*II_0F_C8*/ {0x33, 0, 54, 8, 965}, - /*II_0F_C8*/ {0x33, 0, 54, 8, 965}, - /*II_0F_C8*/ {0x33, 0, 54, 8, 965}, - /*II_80_00*/ {0x34, 1, 15, 8, 11}, - /*II_80_01*/ {0x34, 1, 15, 8, 27}, - /*II_80_02*/ {0x34, 1, 15, 8, 31}, - /*II_80_03*/ {0x34, 1, 15, 8, 36}, - /*II_80_04*/ {0x34, 1, 15, 8, 41}, - /*II_80_05*/ {0x34, 1, 15, 8, 51}, - /*II_80_06*/ {0x34, 1, 15, 8, 61}, - /*II_80_07*/ {0x35, 1, 15, 8, 71}, - /*II_81_00*/ {0x34, 3, 17, 8, 11}, - /*II_81_01*/ {0x34, 3, 17, 8, 27}, - /*II_81_02*/ {0x34, 3, 17, 8, 31}, - /*II_81_03*/ {0x34, 3, 17, 8, 36}, - /*II_81_04*/ {0x34, 3, 17, 8, 41}, - /*II_81_05*/ {0x34, 3, 17, 8, 51}, - /*II_81_06*/ {0x34, 3, 17, 8, 61}, - /*II_81_07*/ {0x35, 3, 17, 8, 71}, - /*II_82_00*/ {0x36, 1, 15, 8, 11}, - /*II_82_01*/ {0x36, 1, 15, 8, 27}, - /*II_82_02*/ {0x36, 1, 15, 8, 31}, - /*II_82_03*/ {0x36, 1, 15, 8, 36}, - /*II_82_04*/ {0x36, 1, 15, 8, 41}, - /*II_82_05*/ {0x36, 1, 15, 8, 51}, - /*II_82_06*/ {0x36, 1, 15, 8, 61}, - /*II_82_07*/ {0x37, 1, 15, 8, 71}, - /*II_83_00*/ {0x34, 5, 17, 8, 11}, - /*II_83_01*/ {0x38, 5, 17, 8, 27}, - /*II_83_02*/ {0x34, 5, 17, 8, 31}, - /*II_83_03*/ {0x34, 5, 17, 8, 36}, - /*II_83_04*/ {0x38, 5, 17, 8, 41}, - /*II_83_05*/ {0x34, 5, 17, 8, 51}, - /*II_83_06*/ {0x38, 5, 17, 8, 61}, - /*II_83_07*/ {0x35, 5, 17, 8, 71}, - /*II_8F_00*/ {0x39, 0, 17, 8, 22}, - /*II_C0_00*/ {0x3a, 1, 15, 8, 972}, - /*II_C0_01*/ {0x3a, 1, 15, 8, 977}, - /*II_C0_02*/ {0x3a, 1, 15, 8, 982}, - /*II_C0_03*/ {0x3a, 1, 15, 8, 987}, - /*II_C0_04*/ {0x3a, 1, 15, 8, 992}, - /*II_C0_05*/ {0x3a, 1, 15, 8, 997}, - /*II_C0_06*/ {0x3a, 1, 15, 8, 1002}, - /*II_C0_07*/ {0x3a, 1, 15, 8, 1007}, - /*II_C1_00*/ {0x3a, 1, 17, 8, 972}, - /*II_C1_01*/ {0x3a, 1, 17, 8, 977}, - /*II_C1_02*/ {0x3a, 1, 17, 8, 982}, - /*II_C1_03*/ {0x3a, 1, 17, 8, 987}, - /*II_C1_04*/ {0x3a, 1, 17, 8, 992}, - /*II_C1_05*/ {0x3a, 1, 17, 8, 997}, - /*II_C1_06*/ {0x3a, 1, 17, 8, 1002}, - /*II_C1_07*/ {0x3a, 1, 17, 8, 1007}, - /*II_C6_00*/ {0x3a, 1, 15, 8, 218}, - /*II_C7_00*/ {0x3a, 3, 17, 8, 218}, - /*II_D0_00*/ {0x3a, 51, 15, 8, 972}, - /*II_D0_01*/ {0x3a, 51, 15, 8, 977}, - /*II_D0_02*/ {0x3a, 51, 15, 8, 982}, - /*II_D0_03*/ {0x3a, 51, 15, 8, 987}, - /*II_D0_04*/ {0x3a, 51, 15, 8, 992}, - /*II_D0_05*/ {0x3a, 51, 15, 8, 997}, - /*II_D0_06*/ {0x3a, 51, 15, 8, 1002}, - /*II_D0_07*/ {0x3a, 51, 15, 8, 1007}, - /*II_D1_00*/ {0x3a, 51, 17, 8, 972}, - /*II_D1_01*/ {0x3a, 51, 17, 8, 977}, - /*II_D1_02*/ {0x3a, 51, 17, 8, 982}, - /*II_D1_03*/ {0x3a, 51, 17, 8, 987}, - /*II_D1_04*/ {0x3a, 51, 17, 8, 992}, - /*II_D1_05*/ {0x3a, 51, 17, 8, 997}, - /*II_D1_06*/ {0x3a, 51, 17, 8, 1002}, - /*II_D1_07*/ {0x3a, 51, 17, 8, 1007}, - /*II_D2_00*/ {0x3a, 52, 15, 8, 972}, - /*II_D2_01*/ {0x3a, 52, 15, 8, 977}, - /*II_D2_02*/ {0x3a, 52, 15, 8, 982}, - /*II_D2_03*/ {0x3a, 52, 15, 8, 987}, - /*II_D2_04*/ {0x3a, 52, 15, 8, 992}, - /*II_D2_05*/ {0x3a, 52, 15, 8, 997}, - /*II_D2_06*/ {0x3a, 52, 15, 8, 1002}, - /*II_D2_07*/ {0x3a, 52, 15, 8, 1007}, - /*II_D3_00*/ {0x3a, 52, 17, 8, 972}, - /*II_D3_01*/ {0x3a, 52, 17, 8, 977}, - /*II_D3_02*/ {0x3a, 52, 17, 8, 982}, - /*II_D3_03*/ {0x3a, 52, 17, 8, 987}, - /*II_D3_04*/ {0x3a, 52, 17, 8, 992}, - /*II_D3_05*/ {0x3a, 52, 17, 8, 997}, - /*II_D3_06*/ {0x3a, 52, 17, 8, 1002}, - /*II_D3_07*/ {0x3a, 52, 17, 8, 1007}, - /*II_D8_00*/ {0x35, 0, 21, 16, 1012}, - /*II_D8_01*/ {0x35, 0, 21, 16, 1018}, - /*II_D8_02*/ {0x35, 0, 21, 16, 1024}, - /*II_D8_03*/ {0x35, 0, 21, 16, 1030}, - /*II_D8_04*/ {0x35, 0, 21, 16, 1037}, - /*II_D8_05*/ {0x35, 0, 21, 16, 1043}, - /*II_D8_06*/ {0x35, 0, 21, 16, 1050}, - /*II_D8_07*/ {0x35, 0, 21, 16, 1056}, - /*II_D8_C0*/ {0x3b, 0, 62, 16, 1012}, - /*II_D8_C0*/ {0x3b, 0, 62, 16, 1012}, - /*II_D8_C0*/ {0x3b, 0, 62, 16, 1012}, - /*II_D8_C0*/ {0x3b, 0, 62, 16, 1012}, - /*II_D8_C0*/ {0x3b, 0, 62, 16, 1012}, - /*II_D8_C0*/ {0x3b, 0, 62, 16, 1012}, - /*II_D8_C0*/ {0x3b, 0, 62, 16, 1012}, - /*II_D8_C0*/ {0x3b, 0, 62, 16, 1012}, - /*II_D8_C8*/ {0x3b, 0, 62, 16, 1018}, - /*II_D8_C8*/ {0x3b, 0, 62, 16, 1018}, - /*II_D8_C8*/ {0x3b, 0, 62, 16, 1018}, - /*II_D8_C8*/ {0x3b, 0, 62, 16, 1018}, - /*II_D8_C8*/ {0x3b, 0, 62, 16, 1018}, - /*II_D8_C8*/ {0x3b, 0, 62, 16, 1018}, - /*II_D8_C8*/ {0x3b, 0, 62, 16, 1018}, - /*II_D8_C8*/ {0x3b, 0, 62, 16, 1018}, - /*II_D8_D0*/ {0x3b, 0, 61, 16, 1024}, - /*II_D8_D0*/ {0x3b, 0, 61, 16, 1024}, - /*II_D8_D0*/ {0x3b, 0, 61, 16, 1024}, - /*II_D8_D0*/ {0x3b, 0, 61, 16, 1024}, - /*II_D8_D0*/ {0x3b, 0, 61, 16, 1024}, - /*II_D8_D0*/ {0x3b, 0, 61, 16, 1024}, - /*II_D8_D0*/ {0x3b, 0, 61, 16, 1024}, - /*II_D8_D0*/ {0x3b, 0, 61, 16, 1024}, - /*II_D8_D8*/ {0x3b, 0, 61, 16, 1030}, - /*II_D8_D9*/ {0x3b, 0, 0, 16, 1030}, - /*II_D8_D8*/ {0x3b, 0, 61, 16, 1030}, - /*II_D8_D8*/ {0x3b, 0, 61, 16, 1030}, - /*II_D8_D8*/ {0x3b, 0, 61, 16, 1030}, - /*II_D8_D8*/ {0x3b, 0, 61, 16, 1030}, - /*II_D8_D8*/ {0x3b, 0, 61, 16, 1030}, - /*II_D8_D8*/ {0x3b, 0, 61, 16, 1030}, - /*II_D8_E0*/ {0x3b, 0, 62, 16, 1037}, - /*II_D8_E0*/ {0x3b, 0, 62, 16, 1037}, - /*II_D8_E0*/ {0x3b, 0, 62, 16, 1037}, - /*II_D8_E0*/ {0x3b, 0, 62, 16, 1037}, - /*II_D8_E0*/ {0x3b, 0, 62, 16, 1037}, - /*II_D8_E0*/ {0x3b, 0, 62, 16, 1037}, - /*II_D8_E0*/ {0x3b, 0, 62, 16, 1037}, - /*II_D8_E0*/ {0x3b, 0, 62, 16, 1037}, - /*II_D8_E8*/ {0x3b, 0, 62, 16, 1043}, - /*II_D8_E8*/ {0x3b, 0, 62, 16, 1043}, - /*II_D8_E8*/ {0x3b, 0, 62, 16, 1043}, - /*II_D8_E8*/ {0x3b, 0, 62, 16, 1043}, - /*II_D8_E8*/ {0x3b, 0, 62, 16, 1043}, - /*II_D8_E8*/ {0x3b, 0, 62, 16, 1043}, - /*II_D8_E8*/ {0x3b, 0, 62, 16, 1043}, - /*II_D8_E8*/ {0x3b, 0, 62, 16, 1043}, - /*II_D8_F0*/ {0x3b, 0, 62, 16, 1050}, - /*II_D8_F0*/ {0x3b, 0, 62, 16, 1050}, - /*II_D8_F0*/ {0x3b, 0, 62, 16, 1050}, - /*II_D8_F0*/ {0x3b, 0, 62, 16, 1050}, - /*II_D8_F0*/ {0x3b, 0, 62, 16, 1050}, - /*II_D8_F0*/ {0x3b, 0, 62, 16, 1050}, - /*II_D8_F0*/ {0x3b, 0, 62, 16, 1050}, - /*II_D8_F0*/ {0x3b, 0, 62, 16, 1050}, - /*II_D8_F8*/ {0x3b, 0, 62, 16, 1056}, - /*II_D8_F8*/ {0x3b, 0, 62, 16, 1056}, - /*II_D8_F8*/ {0x3b, 0, 62, 16, 1056}, - /*II_D8_F8*/ {0x3b, 0, 62, 16, 1056}, - /*II_D8_F8*/ {0x3b, 0, 62, 16, 1056}, - /*II_D8_F8*/ {0x3b, 0, 62, 16, 1056}, - /*II_D8_F8*/ {0x3b, 0, 62, 16, 1056}, - /*II_D8_F8*/ {0x3b, 0, 62, 16, 1056}, - /*II_D9_00*/ {0x35, 0, 21, 16, 1063}, - /*II_D9_02*/ {0x35, 0, 21, 16, 1068}, - /*II_D9_03*/ {0x35, 0, 21, 16, 1073}, - /*II_D9_04*/ {0x35, 0, 42, 16, 1079}, - /*II_D9_05*/ {0x35, 0, 42, 16, 1087}, - /*II_D9_C0*/ {0x3b, 0, 61, 16, 1063}, - /*II_D9_C0*/ {0x3b, 0, 61, 16, 1063}, - /*II_D9_C0*/ {0x3b, 0, 61, 16, 1063}, - /*II_D9_C0*/ {0x3b, 0, 61, 16, 1063}, - /*II_D9_C0*/ {0x3b, 0, 61, 16, 1063}, - /*II_D9_C0*/ {0x3b, 0, 61, 16, 1063}, - /*II_D9_C0*/ {0x3b, 0, 61, 16, 1063}, - /*II_D9_C0*/ {0x3b, 0, 61, 16, 1063}, - /*II_D9_C8*/ {0x3b, 0, 61, 16, 1094}, - /*II_D9_C9*/ {0x3b, 0, 0, 16, 1094}, - /*II_D9_C8*/ {0x3b, 0, 61, 16, 1094}, - /*II_D9_C8*/ {0x3b, 0, 61, 16, 1094}, - /*II_D9_C8*/ {0x3b, 0, 61, 16, 1094}, - /*II_D9_C8*/ {0x3b, 0, 61, 16, 1094}, - /*II_D9_C8*/ {0x3b, 0, 61, 16, 1094}, - /*II_D9_C8*/ {0x3b, 0, 61, 16, 1094}, - /*II_D9_D0*/ {0x3b, 0, 0, 16, 1100}, - /*II_D9_E0*/ {0x3b, 0, 0, 16, 1106}, - /*II_D9_E1*/ {0x3b, 0, 0, 16, 1112}, - /*II_D9_E4*/ {0x3b, 0, 0, 16, 1118}, - /*II_D9_E5*/ {0x3b, 0, 0, 16, 1124}, - /*II_D9_E8*/ {0x3b, 0, 0, 16, 1130}, - /*II_D9_E9*/ {0x3b, 0, 0, 16, 1136}, - /*II_D9_EA*/ {0x3b, 0, 0, 16, 1144}, - /*II_D9_EB*/ {0x3b, 0, 0, 16, 1152}, - /*II_D9_EC*/ {0x3b, 0, 0, 16, 1159}, - /*II_D9_ED*/ {0x3b, 0, 0, 16, 1167}, - /*II_D9_EE*/ {0x3b, 0, 0, 16, 1175}, - /*II_D9_F0*/ {0x3b, 0, 0, 16, 1181}, - /*II_D9_F1*/ {0x3b, 0, 0, 16, 1188}, - /*II_D9_F2*/ {0x3b, 0, 0, 16, 1195}, - /*II_D9_F3*/ {0x3b, 0, 0, 16, 1202}, - /*II_D9_F4*/ {0x3b, 0, 0, 16, 1210}, - /*II_D9_F5*/ {0x3b, 0, 0, 16, 1219}, - /*II_D9_F6*/ {0x3b, 0, 0, 16, 1227}, - /*II_D9_F7*/ {0x3b, 0, 0, 16, 1236}, - /*II_D9_F8*/ {0x3b, 0, 0, 16, 1245}, - /*II_D9_F9*/ {0x3b, 0, 0, 16, 1252}, - /*II_D9_FA*/ {0x3b, 0, 0, 16, 1261}, - /*II_D9_FB*/ {0x3b, 0, 0, 16, 1268}, - /*II_D9_FC*/ {0x3b, 0, 0, 16, 1277}, - /*II_D9_FD*/ {0x3b, 0, 0, 16, 1286}, - /*II_D9_FE*/ {0x3b, 0, 0, 16, 1294}, - /*II_D9_FF*/ {0x3b, 0, 0, 16, 1300}, - /*II_DA_00*/ {0x35, 0, 21, 16, 1306}, - /*II_DA_01*/ {0x35, 0, 21, 16, 1313}, - /*II_DA_02*/ {0x35, 0, 21, 16, 1320}, - /*II_DA_03*/ {0x35, 0, 21, 16, 1327}, - /*II_DA_04*/ {0x35, 0, 21, 16, 1335}, - /*II_DA_05*/ {0x35, 0, 21, 16, 1342}, - /*II_DA_06*/ {0x35, 0, 21, 16, 1350}, - /*II_DA_07*/ {0x35, 0, 21, 16, 1357}, - /*II_DA_C0*/ {0x3c, 0, 62, 24, 1365}, - /*II_DA_C0*/ {0x3c, 0, 62, 24, 1365}, - /*II_DA_C0*/ {0x3c, 0, 62, 24, 1365}, - /*II_DA_C0*/ {0x3c, 0, 62, 24, 1365}, - /*II_DA_C0*/ {0x3c, 0, 62, 24, 1365}, - /*II_DA_C0*/ {0x3c, 0, 62, 24, 1365}, - /*II_DA_C0*/ {0x3c, 0, 62, 24, 1365}, - /*II_DA_C0*/ {0x3c, 0, 62, 24, 1365}, - /*II_DA_C8*/ {0x3c, 0, 62, 24, 1373}, - /*II_DA_C8*/ {0x3c, 0, 62, 24, 1373}, - /*II_DA_C8*/ {0x3c, 0, 62, 24, 1373}, - /*II_DA_C8*/ {0x3c, 0, 62, 24, 1373}, - /*II_DA_C8*/ {0x3c, 0, 62, 24, 1373}, - /*II_DA_C8*/ {0x3c, 0, 62, 24, 1373}, - /*II_DA_C8*/ {0x3c, 0, 62, 24, 1373}, - /*II_DA_C8*/ {0x3c, 0, 62, 24, 1373}, - /*II_DA_D0*/ {0x3c, 0, 62, 24, 1381}, - /*II_DA_D0*/ {0x3c, 0, 62, 24, 1381}, - /*II_DA_D0*/ {0x3c, 0, 62, 24, 1381}, - /*II_DA_D0*/ {0x3c, 0, 62, 24, 1381}, - /*II_DA_D0*/ {0x3c, 0, 62, 24, 1381}, - /*II_DA_D0*/ {0x3c, 0, 62, 24, 1381}, - /*II_DA_D0*/ {0x3c, 0, 62, 24, 1381}, - /*II_DA_D0*/ {0x3c, 0, 62, 24, 1381}, - /*II_DA_D8*/ {0x3c, 0, 62, 24, 1390}, - /*II_DA_D8*/ {0x3c, 0, 62, 24, 1390}, - /*II_DA_D8*/ {0x3c, 0, 62, 24, 1390}, - /*II_DA_D8*/ {0x3c, 0, 62, 24, 1390}, - /*II_DA_D8*/ {0x3c, 0, 62, 24, 1390}, - /*II_DA_D8*/ {0x3c, 0, 62, 24, 1390}, - /*II_DA_D8*/ {0x3c, 0, 62, 24, 1390}, - /*II_DA_D8*/ {0x3c, 0, 62, 24, 1390}, - /*II_DA_E9*/ {0x3b, 0, 0, 16, 1398}, - /*II_DB_00*/ {0x35, 0, 21, 16, 1407}, - /*II_DB_01*/ {0x3d, 0, 21, 56, 1413}, - /*II_DB_02*/ {0x35, 0, 21, 16, 1421}, - /*II_DB_03*/ {0x35, 0, 21, 16, 1427}, - /*II_DB_05*/ {0x35, 0, 23, 16, 1063}, - /*II_DB_07*/ {0x35, 0, 23, 16, 1073}, - /*II_DB_C0*/ {0x3c, 0, 62, 24, 1434}, - /*II_DB_C0*/ {0x3c, 0, 62, 24, 1434}, - /*II_DB_C0*/ {0x3c, 0, 62, 24, 1434}, - /*II_DB_C0*/ {0x3c, 0, 62, 24, 1434}, - /*II_DB_C0*/ {0x3c, 0, 62, 24, 1434}, - /*II_DB_C0*/ {0x3c, 0, 62, 24, 1434}, - /*II_DB_C0*/ {0x3c, 0, 62, 24, 1434}, - /*II_DB_C0*/ {0x3c, 0, 62, 24, 1434}, - /*II_DB_C8*/ {0x3c, 0, 62, 24, 1443}, - /*II_DB_C8*/ {0x3c, 0, 62, 24, 1443}, - /*II_DB_C8*/ {0x3c, 0, 62, 24, 1443}, - /*II_DB_C8*/ {0x3c, 0, 62, 24, 1443}, - /*II_DB_C8*/ {0x3c, 0, 62, 24, 1443}, - /*II_DB_C8*/ {0x3c, 0, 62, 24, 1443}, - /*II_DB_C8*/ {0x3c, 0, 62, 24, 1443}, - /*II_DB_C8*/ {0x3c, 0, 62, 24, 1443}, - /*II_DB_D0*/ {0x3c, 0, 62, 24, 1452}, - /*II_DB_D0*/ {0x3c, 0, 62, 24, 1452}, - /*II_DB_D0*/ {0x3c, 0, 62, 24, 1452}, - /*II_DB_D0*/ {0x3c, 0, 62, 24, 1452}, - /*II_DB_D0*/ {0x3c, 0, 62, 24, 1452}, - /*II_DB_D0*/ {0x3c, 0, 62, 24, 1452}, - /*II_DB_D0*/ {0x3c, 0, 62, 24, 1452}, - /*II_DB_D0*/ {0x3c, 0, 62, 24, 1452}, - /*II_DB_D8*/ {0x3c, 0, 62, 24, 1462}, - /*II_DB_D8*/ {0x3c, 0, 62, 24, 1462}, - /*II_DB_D8*/ {0x3c, 0, 62, 24, 1462}, - /*II_DB_D8*/ {0x3c, 0, 62, 24, 1462}, - /*II_DB_D8*/ {0x3c, 0, 62, 24, 1462}, - /*II_DB_D8*/ {0x3c, 0, 62, 24, 1462}, - /*II_DB_D8*/ {0x3c, 0, 62, 24, 1462}, - /*II_DB_D8*/ {0x3c, 0, 62, 24, 1462}, - /*II_DB_E0*/ {0x3b, 0, 0, 16, 1471}, - /*II_DB_E1*/ {0x3b, 0, 0, 16, 1477}, - /*II_DB_E4*/ {0x3b, 0, 0, 16, 1485}, - /*II_DB_E8*/ {0x3c, 0, 62, 16, 1493}, - /*II_DB_E8*/ {0x3c, 0, 62, 16, 1493}, - /*II_DB_E8*/ {0x3c, 0, 62, 16, 1493}, - /*II_DB_E8*/ {0x3c, 0, 62, 16, 1493}, - /*II_DB_E8*/ {0x3c, 0, 62, 16, 1493}, - /*II_DB_E8*/ {0x3c, 0, 62, 16, 1493}, - /*II_DB_E8*/ {0x3c, 0, 62, 16, 1493}, - /*II_DB_E8*/ {0x3c, 0, 62, 16, 1493}, - /*II_DB_F0*/ {0x3c, 0, 62, 24, 1501}, - /*II_DB_F0*/ {0x3c, 0, 62, 24, 1501}, - /*II_DB_F0*/ {0x3c, 0, 62, 24, 1501}, - /*II_DB_F0*/ {0x3c, 0, 62, 24, 1501}, - /*II_DB_F0*/ {0x3c, 0, 62, 24, 1501}, - /*II_DB_F0*/ {0x3c, 0, 62, 24, 1501}, - /*II_DB_F0*/ {0x3c, 0, 62, 24, 1501}, - /*II_DB_F0*/ {0x3c, 0, 62, 24, 1501}, - /*II_DC_00*/ {0x35, 0, 22, 16, 1012}, - /*II_DC_01*/ {0x35, 0, 22, 16, 1018}, - /*II_DC_02*/ {0x35, 0, 22, 16, 1024}, - /*II_DC_03*/ {0x35, 0, 22, 16, 1030}, - /*II_DC_04*/ {0x35, 0, 22, 16, 1037}, - /*II_DC_05*/ {0x35, 0, 22, 16, 1043}, - /*II_DC_06*/ {0x35, 0, 22, 16, 1050}, - /*II_DC_07*/ {0x35, 0, 22, 16, 1056}, - /*II_DC_C0*/ {0x3b, 0, 63, 16, 1012}, - /*II_DC_C0*/ {0x3b, 0, 63, 16, 1012}, - /*II_DC_C0*/ {0x3b, 0, 63, 16, 1012}, - /*II_DC_C0*/ {0x3b, 0, 63, 16, 1012}, - /*II_DC_C0*/ {0x3b, 0, 63, 16, 1012}, - /*II_DC_C0*/ {0x3b, 0, 63, 16, 1012}, - /*II_DC_C0*/ {0x3b, 0, 63, 16, 1012}, - /*II_DC_C0*/ {0x3b, 0, 63, 16, 1012}, - /*II_DC_C8*/ {0x3b, 0, 63, 16, 1018}, - /*II_DC_C8*/ {0x3b, 0, 63, 16, 1018}, - /*II_DC_C8*/ {0x3b, 0, 63, 16, 1018}, - /*II_DC_C8*/ {0x3b, 0, 63, 16, 1018}, - /*II_DC_C8*/ {0x3b, 0, 63, 16, 1018}, - /*II_DC_C8*/ {0x3b, 0, 63, 16, 1018}, - /*II_DC_C8*/ {0x3b, 0, 63, 16, 1018}, - /*II_DC_C8*/ {0x3b, 0, 63, 16, 1018}, - /*II_DC_E0*/ {0x3b, 0, 63, 16, 1043}, - /*II_DC_E0*/ {0x3b, 0, 63, 16, 1043}, - /*II_DC_E0*/ {0x3b, 0, 63, 16, 1043}, - /*II_DC_E0*/ {0x3b, 0, 63, 16, 1043}, - /*II_DC_E0*/ {0x3b, 0, 63, 16, 1043}, - /*II_DC_E0*/ {0x3b, 0, 63, 16, 1043}, - /*II_DC_E0*/ {0x3b, 0, 63, 16, 1043}, - /*II_DC_E0*/ {0x3b, 0, 63, 16, 1043}, - /*II_DC_E8*/ {0x3b, 0, 63, 16, 1037}, - /*II_DC_E8*/ {0x3b, 0, 63, 16, 1037}, - /*II_DC_E8*/ {0x3b, 0, 63, 16, 1037}, - /*II_DC_E8*/ {0x3b, 0, 63, 16, 1037}, - /*II_DC_E8*/ {0x3b, 0, 63, 16, 1037}, - /*II_DC_E8*/ {0x3b, 0, 63, 16, 1037}, - /*II_DC_E8*/ {0x3b, 0, 63, 16, 1037}, - /*II_DC_E8*/ {0x3b, 0, 63, 16, 1037}, - /*II_DC_F0*/ {0x3b, 0, 63, 16, 1056}, - /*II_DC_F0*/ {0x3b, 0, 63, 16, 1056}, - /*II_DC_F0*/ {0x3b, 0, 63, 16, 1056}, - /*II_DC_F0*/ {0x3b, 0, 63, 16, 1056}, - /*II_DC_F0*/ {0x3b, 0, 63, 16, 1056}, - /*II_DC_F0*/ {0x3b, 0, 63, 16, 1056}, - /*II_DC_F0*/ {0x3b, 0, 63, 16, 1056}, - /*II_DC_F0*/ {0x3b, 0, 63, 16, 1056}, - /*II_DC_F8*/ {0x3b, 0, 63, 16, 1050}, - /*II_DC_F8*/ {0x3b, 0, 63, 16, 1050}, - /*II_DC_F8*/ {0x3b, 0, 63, 16, 1050}, - /*II_DC_F8*/ {0x3b, 0, 63, 16, 1050}, - /*II_DC_F8*/ {0x3b, 0, 63, 16, 1050}, - /*II_DC_F8*/ {0x3b, 0, 63, 16, 1050}, - /*II_DC_F8*/ {0x3b, 0, 63, 16, 1050}, - /*II_DC_F8*/ {0x3b, 0, 63, 16, 1050}, - /*II_DD_00*/ {0x35, 0, 22, 16, 1063}, - /*II_DD_01*/ {0x3d, 0, 22, 56, 1413}, - /*II_DD_02*/ {0x35, 0, 22, 16, 1068}, - /*II_DD_03*/ {0x35, 0, 22, 16, 1073}, - /*II_DD_04*/ {0x35, 0, 42, 16, 1508}, - /*II_DD_C0*/ {0x3b, 0, 61, 16, 1516}, - /*II_DD_C0*/ {0x3b, 0, 61, 16, 1516}, - /*II_DD_C0*/ {0x3b, 0, 61, 16, 1516}, - /*II_DD_C0*/ {0x3b, 0, 61, 16, 1516}, - /*II_DD_C0*/ {0x3b, 0, 61, 16, 1516}, - /*II_DD_C0*/ {0x3b, 0, 61, 16, 1516}, - /*II_DD_C0*/ {0x3b, 0, 61, 16, 1516}, - /*II_DD_C0*/ {0x3b, 0, 61, 16, 1516}, - /*II_DD_D0*/ {0x3b, 0, 61, 16, 1068}, - /*II_DD_D0*/ {0x3b, 0, 61, 16, 1068}, - /*II_DD_D0*/ {0x3b, 0, 61, 16, 1068}, - /*II_DD_D0*/ {0x3b, 0, 61, 16, 1068}, - /*II_DD_D0*/ {0x3b, 0, 61, 16, 1068}, - /*II_DD_D0*/ {0x3b, 0, 61, 16, 1068}, - /*II_DD_D0*/ {0x3b, 0, 61, 16, 1068}, - /*II_DD_D0*/ {0x3b, 0, 61, 16, 1068}, - /*II_DD_D8*/ {0x3b, 0, 61, 16, 1073}, - /*II_DD_D8*/ {0x3b, 0, 61, 16, 1073}, - /*II_DD_D8*/ {0x3b, 0, 61, 16, 1073}, - /*II_DD_D8*/ {0x3b, 0, 61, 16, 1073}, - /*II_DD_D8*/ {0x3b, 0, 61, 16, 1073}, - /*II_DD_D8*/ {0x3b, 0, 61, 16, 1073}, - /*II_DD_D8*/ {0x3b, 0, 61, 16, 1073}, - /*II_DD_D8*/ {0x3b, 0, 61, 16, 1073}, - /*II_DD_E0*/ {0x3b, 0, 63, 16, 1523}, - /*II_DD_E1*/ {0x3b, 0, 0, 16, 1523}, - /*II_DD_E0*/ {0x3b, 0, 63, 16, 1523}, - /*II_DD_E0*/ {0x3b, 0, 63, 16, 1523}, - /*II_DD_E0*/ {0x3b, 0, 63, 16, 1523}, - /*II_DD_E0*/ {0x3b, 0, 63, 16, 1523}, - /*II_DD_E0*/ {0x3b, 0, 63, 16, 1523}, - /*II_DD_E0*/ {0x3b, 0, 63, 16, 1523}, - /*II_DD_E8*/ {0x3b, 0, 61, 16, 1530}, - /*II_DD_E9*/ {0x3b, 0, 0, 16, 1530}, - /*II_DD_E8*/ {0x3b, 0, 61, 16, 1530}, - /*II_DD_E8*/ {0x3b, 0, 61, 16, 1530}, - /*II_DD_E8*/ {0x3b, 0, 61, 16, 1530}, - /*II_DD_E8*/ {0x3b, 0, 61, 16, 1530}, - /*II_DD_E8*/ {0x3b, 0, 61, 16, 1530}, - /*II_DD_E8*/ {0x3b, 0, 61, 16, 1530}, - /*II_DE_00*/ {0x35, 0, 20, 16, 1306}, - /*II_DE_01*/ {0x35, 0, 20, 16, 1313}, - /*II_DE_02*/ {0x35, 0, 20, 16, 1320}, - /*II_DE_03*/ {0x35, 0, 20, 16, 1327}, - /*II_DE_04*/ {0x35, 0, 20, 16, 1335}, - /*II_DE_05*/ {0x35, 0, 20, 16, 1342}, - /*II_DE_06*/ {0x35, 0, 20, 16, 1350}, - /*II_DE_07*/ {0x35, 0, 20, 16, 1357}, - /*II_DE_C0*/ {0x3b, 0, 63, 16, 1538}, - /*II_DE_C1*/ {0x3b, 0, 0, 16, 1538}, - /*II_DE_C0*/ {0x3b, 0, 63, 16, 1538}, - /*II_DE_C0*/ {0x3b, 0, 63, 16, 1538}, - /*II_DE_C0*/ {0x3b, 0, 63, 16, 1538}, - /*II_DE_C0*/ {0x3b, 0, 63, 16, 1538}, - /*II_DE_C0*/ {0x3b, 0, 63, 16, 1538}, - /*II_DE_C0*/ {0x3b, 0, 63, 16, 1538}, - /*II_DE_C8*/ {0x3b, 0, 63, 16, 1545}, - /*II_DE_C9*/ {0x3b, 0, 0, 16, 1545}, - /*II_DE_C8*/ {0x3b, 0, 63, 16, 1545}, - /*II_DE_C8*/ {0x3b, 0, 63, 16, 1545}, - /*II_DE_C8*/ {0x3b, 0, 63, 16, 1545}, - /*II_DE_C8*/ {0x3b, 0, 63, 16, 1545}, - /*II_DE_C8*/ {0x3b, 0, 63, 16, 1545}, - /*II_DE_C8*/ {0x3b, 0, 63, 16, 1545}, - /*II_DE_D9*/ {0x3b, 0, 0, 16, 1552}, - /*II_DE_E0*/ {0x3b, 0, 63, 16, 1560}, - /*II_DE_E1*/ {0x3b, 0, 0, 16, 1560}, - /*II_DE_E0*/ {0x3b, 0, 63, 16, 1560}, - /*II_DE_E0*/ {0x3b, 0, 63, 16, 1560}, - /*II_DE_E0*/ {0x3b, 0, 63, 16, 1560}, - /*II_DE_E0*/ {0x3b, 0, 63, 16, 1560}, - /*II_DE_E0*/ {0x3b, 0, 63, 16, 1560}, - /*II_DE_E0*/ {0x3b, 0, 63, 16, 1560}, - /*II_DE_E8*/ {0x3b, 0, 63, 16, 1568}, - /*II_DE_E9*/ {0x3b, 0, 0, 16, 1568}, - /*II_DE_E8*/ {0x3b, 0, 63, 16, 1568}, - /*II_DE_E8*/ {0x3b, 0, 63, 16, 1568}, - /*II_DE_E8*/ {0x3b, 0, 63, 16, 1568}, - /*II_DE_E8*/ {0x3b, 0, 63, 16, 1568}, - /*II_DE_E8*/ {0x3b, 0, 63, 16, 1568}, - /*II_DE_E8*/ {0x3b, 0, 63, 16, 1568}, - /*II_DE_F0*/ {0x3b, 0, 63, 16, 1575}, - /*II_DE_F1*/ {0x3b, 0, 0, 16, 1575}, - /*II_DE_F0*/ {0x3b, 0, 63, 16, 1575}, - /*II_DE_F0*/ {0x3b, 0, 63, 16, 1575}, - /*II_DE_F0*/ {0x3b, 0, 63, 16, 1575}, - /*II_DE_F0*/ {0x3b, 0, 63, 16, 1575}, - /*II_DE_F0*/ {0x3b, 0, 63, 16, 1575}, - /*II_DE_F0*/ {0x3b, 0, 63, 16, 1575}, - /*II_DE_F8*/ {0x3b, 0, 63, 16, 1583}, - /*II_DE_F9*/ {0x3b, 0, 0, 16, 1583}, - /*II_DE_F8*/ {0x3b, 0, 63, 16, 1583}, - /*II_DE_F8*/ {0x3b, 0, 63, 16, 1583}, - /*II_DE_F8*/ {0x3b, 0, 63, 16, 1583}, - /*II_DE_F8*/ {0x3b, 0, 63, 16, 1583}, - /*II_DE_F8*/ {0x3b, 0, 63, 16, 1583}, - /*II_DE_F8*/ {0x3b, 0, 63, 16, 1583}, - /*II_DF_00*/ {0x35, 0, 20, 16, 1407}, - /*II_DF_01*/ {0x3d, 0, 20, 56, 1413}, - /*II_DF_02*/ {0x35, 0, 20, 16, 1421}, - /*II_DF_03*/ {0x35, 0, 20, 16, 1427}, - /*II_DF_04*/ {0x35, 0, 23, 16, 1590}, - /*II_DF_05*/ {0x35, 0, 22, 16, 1407}, - /*II_DF_06*/ {0x35, 0, 23, 16, 1596}, - /*II_DF_07*/ {0x35, 0, 22, 16, 1427}, - /*II_DF_E8*/ {0x3c, 0, 62, 16, 1603}, - /*II_DF_E8*/ {0x3c, 0, 62, 16, 1603}, - /*II_DF_E8*/ {0x3c, 0, 62, 16, 1603}, - /*II_DF_E8*/ {0x3c, 0, 62, 16, 1603}, - /*II_DF_E8*/ {0x3c, 0, 62, 16, 1603}, - /*II_DF_E8*/ {0x3c, 0, 62, 16, 1603}, - /*II_DF_E8*/ {0x3c, 0, 62, 16, 1603}, - /*II_DF_E8*/ {0x3c, 0, 62, 16, 1603}, - /*II_DF_F0*/ {0x3c, 0, 62, 16, 1612}, - /*II_DF_F0*/ {0x3c, 0, 62, 16, 1612}, - /*II_DF_F0*/ {0x3c, 0, 62, 16, 1612}, - /*II_DF_F0*/ {0x3c, 0, 62, 16, 1612}, - /*II_DF_F0*/ {0x3c, 0, 62, 16, 1612}, - /*II_DF_F0*/ {0x3c, 0, 62, 16, 1612}, - /*II_DF_F0*/ {0x3c, 0, 62, 16, 1612}, - /*II_DF_F0*/ {0x3c, 0, 62, 16, 1612}, - /*II_F6_00*/ {0x35, 1, 15, 8, 206}, - /*II_F6_02*/ {0x34, 0, 15, 8, 1620}, - /*II_F6_03*/ {0x34, 0, 15, 8, 1625}, - /*II_F6_04*/ {0x3a, 0, 15, 8, 1630}, - /*II_F6_05*/ {0x3a, 0, 15, 8, 117}, - /*II_F6_06*/ {0x3a, 0, 15, 8, 1635}, - /*II_F6_07*/ {0x3a, 0, 15, 8, 1640}, - /*II_F7_00*/ {0x35, 3, 17, 8, 206}, - /*II_F7_02*/ {0x34, 0, 17, 8, 1620}, - /*II_F7_03*/ {0x34, 0, 17, 8, 1625}, - /*II_F7_04*/ {0x3a, 0, 17, 8, 1630}, - /*II_F7_05*/ {0x3a, 0, 17, 8, 117}, - /*II_F7_06*/ {0x3a, 0, 17, 8, 1635}, - /*II_F7_07*/ {0x3a, 0, 17, 8, 1640}, - /*II_FE_00*/ {0x34, 0, 15, 8, 81}, - /*II_FE_01*/ {0x34, 0, 15, 8, 86}, - /*II_FF_00*/ {0x34, 0, 17, 8, 81}, - /*II_FF_01*/ {0x34, 0, 17, 8, 86}, - /*II_FF_02*/ {0x3e, 0, 17, 9, 456}, - /*II_FF_03*/ {0x3f, 0, 37, 9, 260}, - /*II_FF_04*/ {0x3e, 0, 17, 12, 462}, - /*II_FF_05*/ {0x3f, 0, 37, 12, 467}, - /*II_FF_06*/ {0x3e, 0, 17, 8, 16}, - /*II_0F_00_00*/ {0x35, 0, 17, 8, 1646}, - /*II_0F_00_01*/ {0x35, 0, 16, 8, 1652}, - /*II_0F_00_02*/ {0x35, 0, 16, 8, 1657}, - /*II_0F_00_03*/ {0x3d, 0, 16, 8, 1663}, - /*II_0F_00_04*/ {0x35, 0, 16, 8, 1668}, - /*II_0F_00_05*/ {0x35, 0, 16, 8, 1674}, - /*II_0F_01_00*/ {0x3e, 0, 39, 8, 1680}, - /*II_0F_01_01*/ {0x3e, 0, 39, 8, 1686}, - /*II_0F_01_02*/ {0x3e, 0, 39, 8, 1692}, - /*II_0F_01_03*/ {0x3e, 0, 39, 8, 1698}, - /*II_0F_01_04*/ {0x40, 0, 28, 8, 1704}, - /*II_0F_01_06*/ {0x41, 0, 16, 8, 1710}, - /*II_0F_01_07*/ {0x3d, 0, 42, 8, 1716}, - /*II_0F_01_C1*/ {0x3c, 0, 0, 112, 1724}, - /*II_0F_01_C2*/ {0x3c, 0, 0, 112, 1732}, - /*II_0F_01_C3*/ {0x3c, 0, 0, 112, 1742}, - /*II_0F_01_C4*/ {0x3c, 0, 0, 112, 1752}, - /*II_0F_01_C8*/ {0x3c, 0, 0, 8, 1760}, - /*II_0F_01_C9*/ {0x3c, 0, 0, 8, 1769}, - /*II_0F_01_D0*/ {0x26, 0, 0, 8, 1776}, - /*II_0F_01_D1*/ {0x26, 0, 0, 8, 1784}, - /*II_0F_01_D8*/ {0x3d, 0, 58, 120, 1792}, - /*II_0F_01_D9*/ {0x3c, 0, 0, 120, 1799}, - /*II_0F_01_DA*/ {0x3c, 0, 58, 120, 1808}, - /*II_0F_01_DB*/ {0x3c, 0, 58, 120, 1816}, - /*II_0F_01_DC*/ {0x3c, 0, 0, 120, 1824}, - /*II_0F_01_DD*/ {0x3c, 0, 0, 120, 1830}, - /*II_0F_01_DE*/ {0x3c, 0, 58, 120, 1836}, - /*II_0F_01_DF*/ {0x3c, 60, 58, 120, 1844}, - /*II_0F_01_F8*/ {0x42, 0, 0, 8, 1853}, - /*II_0F_01_F9*/ {0x42, 0, 0, 8, 1861}, - /*II_0F_0D_00*/ {0x3d, 0, 42, 96, 1869}, - /*II_0F_0D_01*/ {0x3d, 0, 42, 96, 1879}, - /*II_0F_0F_0C*/ {0x43, 67, 64, 104, 1890}, - /*II_0F_0F_0D*/ {0x43, 67, 64, 96, 1897}, - /*II_0F_0F_1C*/ {0x43, 67, 64, 104, 1904}, - /*II_0F_0F_1D*/ {0x43, 67, 64, 96, 1911}, - /*II_0F_0F_8A*/ {0x43, 67, 64, 104, 1918}, - /*II_0F_0F_8E*/ {0x43, 67, 64, 104, 1926}, - /*II_0F_0F_90*/ {0x43, 67, 64, 96, 1935}, - /*II_0F_0F_94*/ {0x43, 67, 64, 96, 1944}, - /*II_0F_0F_96*/ {0x43, 67, 64, 96, 1951}, - /*II_0F_0F_97*/ {0x43, 67, 64, 96, 1958}, - /*II_0F_0F_9A*/ {0x43, 67, 64, 96, 1967}, - /*II_0F_0F_9E*/ {0x43, 67, 64, 96, 1974}, - /*II_0F_0F_A0*/ {0x43, 67, 64, 96, 1981}, - /*II_0F_0F_A4*/ {0x43, 67, 64, 96, 1990}, - /*II_0F_0F_A6*/ {0x43, 67, 64, 96, 1997}, - /*II_0F_0F_A7*/ {0x43, 67, 64, 96, 2007}, - /*II_0F_0F_AA*/ {0x43, 67, 64, 96, 2017}, - /*II_0F_0F_AE*/ {0x43, 67, 64, 96, 2025}, - /*II_0F_0F_B0*/ {0x43, 67, 64, 96, 2032}, - /*II_0F_0F_B4*/ {0x43, 67, 64, 96, 2041}, - /*II_0F_0F_B6*/ {0x43, 67, 64, 96, 2048}, - /*II_0F_0F_B7*/ {0x43, 67, 64, 96, 2058}, - /*II_0F_0F_BB*/ {0x43, 67, 64, 104, 2067}, - /*II_0F_0F_BF*/ {0x43, 67, 64, 96, 2075}, - /*II_0F_10*/ {0x2a, 73, 68, 40, 2084}, - /*II_66_0F_10*/ {0x2a, 73, 68, 48, 2092}, - /*II_F3_0F_10*/ {0x2a, 71, 68, 40, 2100}, - /*II_F2_0F_10*/ {0x2a, 72, 68, 48, 2107}, - /*II_0F_11*/ {0x2a, 68, 73, 40, 2084}, - /*II_66_0F_11*/ {0x2a, 68, 73, 48, 2092}, - /*II_F3_0F_11*/ {0x2a, 68, 71, 40, 2100}, - /*II_F2_0F_11*/ {0x2a, 68, 72, 48, 2107}, - /*II_66_0F_12*/ {0x2a, 46, 68, 48, 2165}, - /*II_F3_0F_12*/ {0x2a, 72, 68, 56, 2173}, - /*II_F2_0F_12*/ {0x2a, 72, 68, 56, 2183}, - /*II_0F_13*/ {0x2a, 68, 46, 40, 2157}, - /*II_66_0F_13*/ {0x2a, 68, 46, 48, 2165}, - /*II_0F_14*/ {0x29, 73, 68, 40, 2241}, - /*II_66_0F_14*/ {0x29, 73, 68, 48, 2251}, - /*II_0F_15*/ {0x29, 73, 68, 40, 2283}, - /*II_66_0F_15*/ {0x29, 73, 68, 48, 2293}, - /*II_66_0F_16*/ {0x2a, 46, 68, 48, 2342}, - /*II_F3_0F_16*/ {0x2a, 73, 68, 56, 2350}, - /*II_0F_17*/ {0x2a, 68, 46, 40, 2334}, - /*II_66_0F_17*/ {0x2a, 68, 46, 48, 2342}, - /*II_0F_18_00*/ {0x3d, 0, 42, 40, 2399}, - /*II_0F_18_01*/ {0x3d, 0, 42, 40, 2412}, - /*II_0F_18_02*/ {0x3d, 0, 42, 40, 2424}, - /*II_0F_18_03*/ {0x3d, 0, 42, 40, 2436}, - /*II_0F_28*/ {0x2a, 73, 68, 40, 2448}, - /*II_66_0F_28*/ {0x2a, 73, 68, 48, 2456}, - /*II_0F_29*/ {0x2a, 68, 73, 40, 2448}, - /*II_66_0F_29*/ {0x2a, 68, 73, 48, 2456}, - /*II_0F_2A*/ {0x29, 67, 68, 40, 2482}, - /*II_66_0F_2A*/ {0x29, 67, 68, 48, 2492}, - /*II_F3_0F_2A*/ {0x31, 18, 68, 40, 2502}, - /*II_F2_0F_2A*/ {0x31, 18, 68, 48, 2512}, - /*II_0F_2B*/ {0x2a, 68, 47, 40, 2544}, - /*II_66_0F_2B*/ {0x2a, 68, 47, 48, 2553}, - /*II_F3_0F_2B*/ {0x2a, 68, 44, 88, 2562}, - /*II_F2_0F_2B*/ {0x2a, 68, 46, 88, 2571}, - /*II_0F_2C*/ {0x29, 72, 64, 40, 2600}, - /*II_66_0F_2C*/ {0x29, 73, 64, 48, 2611}, - /*II_F3_0F_2C*/ {0x31, 71, 13, 40, 2622}, - /*II_F2_0F_2C*/ {0x31, 72, 13, 48, 2633}, - /*II_0F_2D*/ {0x29, 72, 64, 40, 2668}, - /*II_66_0F_2D*/ {0x29, 73, 64, 48, 2678}, - /*II_F3_0F_2D*/ {0x31, 71, 13, 40, 2688}, - /*II_F2_0F_2D*/ {0x31, 72, 13, 48, 2698}, - /*II_0F_2E*/ {0x29, 71, 68, 40, 2730}, - /*II_66_0F_2E*/ {0x29, 72, 68, 48, 2739}, - /*II_0F_2F*/ {0x29, 71, 68, 40, 2768}, - /*II_66_0F_2F*/ {0x29, 72, 68, 48, 2776}, - /*II_0F_50*/ {0x48, 69, 12, 40, 2802}, - /*II_66_0F_50*/ {0x48, 69, 12, 48, 2812}, - /*II_0F_51*/ {0x29, 73, 68, 40, 2844}, - /*II_66_0F_51*/ {0x29, 73, 68, 48, 2852}, - /*II_F3_0F_51*/ {0x29, 71, 68, 40, 2860}, - /*II_F2_0F_51*/ {0x29, 72, 68, 48, 2868}, - /*II_0F_52*/ {0x29, 73, 68, 40, 2912}, - /*II_F3_0F_52*/ {0x29, 71, 68, 40, 2921}, - /*II_0F_53*/ {0x29, 73, 68, 40, 2950}, - /*II_F3_0F_53*/ {0x29, 71, 68, 40, 2957}, - /*II_0F_54*/ {0x29, 73, 68, 40, 2980}, - /*II_66_0F_54*/ {0x29, 73, 68, 48, 2987}, - /*II_0F_55*/ {0x29, 73, 68, 40, 3010}, - /*II_66_0F_55*/ {0x29, 73, 68, 48, 3018}, - /*II_0F_56*/ {0x29, 73, 68, 40, 3044}, - /*II_66_0F_56*/ {0x29, 73, 68, 48, 3050}, - /*II_0F_57*/ {0x29, 73, 68, 40, 3070}, - /*II_66_0F_57*/ {0x29, 73, 68, 48, 3077}, - /*II_0F_58*/ {0x29, 73, 68, 40, 3100}, - /*II_66_0F_58*/ {0x29, 73, 68, 48, 3107}, - /*II_F3_0F_58*/ {0x29, 71, 68, 40, 3114}, - /*II_F2_0F_58*/ {0x29, 72, 68, 48, 3121}, - /*II_0F_59*/ {0x29, 73, 68, 40, 3160}, - /*II_66_0F_59*/ {0x29, 73, 68, 48, 3167}, - /*II_F3_0F_59*/ {0x29, 71, 68, 40, 3174}, - /*II_F2_0F_59*/ {0x29, 72, 68, 48, 3181}, - /*II_0F_5A*/ {0x29, 72, 68, 48, 3220}, - /*II_66_0F_5A*/ {0x29, 73, 68, 48, 3230}, - /*II_F3_0F_5A*/ {0x29, 71, 68, 48, 3240}, - /*II_F2_0F_5A*/ {0x29, 72, 68, 48, 3250}, - /*II_0F_5B*/ {0x29, 73, 68, 48, 3304}, - /*II_66_0F_5B*/ {0x29, 73, 68, 48, 3314}, - /*II_F3_0F_5B*/ {0x29, 73, 68, 48, 3324}, - /*II_0F_5C*/ {0x29, 73, 68, 40, 3369}, - /*II_66_0F_5C*/ {0x29, 73, 68, 48, 3376}, - /*II_F3_0F_5C*/ {0x29, 71, 68, 40, 3383}, - /*II_F2_0F_5C*/ {0x29, 72, 68, 48, 3390}, - /*II_0F_5D*/ {0x29, 73, 68, 40, 3429}, - /*II_66_0F_5D*/ {0x29, 73, 68, 48, 3436}, - /*II_F3_0F_5D*/ {0x29, 71, 68, 40, 3443}, - /*II_F2_0F_5D*/ {0x29, 72, 68, 48, 3450}, - /*II_0F_5E*/ {0x29, 73, 68, 40, 3489}, - /*II_66_0F_5E*/ {0x29, 73, 68, 48, 3496}, - /*II_F3_0F_5E*/ {0x29, 71, 68, 40, 3503}, - /*II_F2_0F_5E*/ {0x29, 72, 68, 48, 3510}, - /*II_0F_5F*/ {0x29, 73, 68, 40, 3549}, - /*II_66_0F_5F*/ {0x29, 73, 68, 48, 3556}, - /*II_F3_0F_5F*/ {0x29, 71, 68, 40, 3563}, - /*II_F2_0F_5F*/ {0x29, 72, 68, 48, 3570}, - /*II_0F_60*/ {0x29, 66, 64, 32, 3609}, - /*II_66_0F_60*/ {0x29, 73, 68, 48, 3609}, - /*II_0F_61*/ {0x29, 66, 64, 32, 3632}, - /*II_66_0F_61*/ {0x29, 73, 68, 48, 3632}, - /*II_0F_62*/ {0x29, 66, 64, 32, 3655}, - /*II_66_0F_62*/ {0x29, 73, 68, 48, 3655}, - /*II_0F_63*/ {0x29, 67, 64, 32, 3678}, - /*II_66_0F_63*/ {0x29, 73, 68, 48, 3678}, - /*II_0F_64*/ {0x29, 67, 64, 32, 3699}, - /*II_66_0F_64*/ {0x29, 73, 68, 48, 3699}, - /*II_0F_65*/ {0x29, 67, 64, 32, 3718}, - /*II_66_0F_65*/ {0x29, 73, 68, 48, 3718}, - /*II_0F_66*/ {0x29, 67, 64, 32, 3737}, - /*II_66_0F_66*/ {0x29, 73, 68, 48, 3737}, - /*II_0F_67*/ {0x29, 67, 64, 32, 3756}, - /*II_66_0F_67*/ {0x29, 73, 68, 48, 3756}, - /*II_0F_68*/ {0x29, 67, 64, 32, 3777}, - /*II_66_0F_68*/ {0x29, 73, 68, 48, 3777}, - /*II_0F_69*/ {0x29, 67, 64, 32, 3800}, - /*II_66_0F_69*/ {0x29, 73, 68, 48, 3800}, - /*II_0F_6A*/ {0x29, 67, 64, 32, 3823}, - /*II_66_0F_6A*/ {0x29, 73, 68, 48, 3823}, - /*II_0F_6B*/ {0x29, 67, 64, 32, 3846}, - /*II_66_0F_6B*/ {0x29, 73, 68, 48, 3846}, - /*II_66_0F_6C*/ {0x29, 73, 68, 48, 3867}, - /*II_66_0F_6D*/ {0x29, 73, 68, 48, 3892}, - /*II_0F_6F*/ {0x2a, 67, 64, 32, 3923}, - /*II_66_0F_6F*/ {0x2a, 73, 68, 48, 3943}, - /*II_F3_0F_6F*/ {0x2a, 73, 68, 48, 3951}, - /*II_0F_74*/ {0x29, 67, 64, 32, 4040}, - /*II_66_0F_74*/ {0x29, 73, 68, 48, 4040}, - /*II_0F_75*/ {0x29, 67, 64, 32, 4059}, - /*II_66_0F_75*/ {0x29, 73, 68, 48, 4059}, - /*II_0F_76*/ {0x29, 67, 64, 32, 4078}, - /*II_66_0F_76*/ {0x29, 73, 68, 48, 4078}, - /*II_0F_77*/ {0x26, 0, 0, 32, 4097}, - /*II_0F_78*/ {0x4d, 13, 18, 112, 4125}, - /*II_0F_79*/ {0x4d, 18, 13, 112, 4149}, - /*II_66_0F_79*/ {0x29, 69, 68, 88, 4133}, - /*II_F2_0F_79*/ {0x50, 69, 68, 88, 4140}, - /*II_66_0F_7C*/ {0x29, 73, 68, 56, 4158}, - /*II_F2_0F_7C*/ {0x29, 73, 68, 56, 4166}, - /*II_66_0F_7D*/ {0x29, 73, 68, 56, 4192}, - /*II_F2_0F_7D*/ {0x29, 73, 68, 56, 4200}, - /*II_F3_0F_7E*/ {0x2a, 72, 68, 48, 3923}, - /*II_0F_7F*/ {0x2a, 64, 67, 32, 3923}, - /*II_66_0F_7F*/ {0x2a, 68, 73, 48, 3943}, - /*II_F3_0F_7F*/ {0x2a, 68, 73, 48, 3951}, - /*II_0F_AE_00*/ {0x3d, 0, 42, 8, 4226}, - /*II_0F_AE_01*/ {0x3d, 0, 42, 8, 4234}, - /*II_0F_AE_04*/ {0x3d, 0, 42, 8, 4243}, - /*II_0F_AE_06*/ {0x52, 0, 0, 8, 4265}, - /*II_F3_0F_B8*/ {0x53, 17, 11, 80, 4290}, - /*II_0F_BA_04*/ {0x54, 1, 17, 8, 872}, - /*II_0F_BA_05*/ {0x38, 1, 17, 8, 887}, - /*II_0F_BA_06*/ {0x38, 1, 17, 8, 912}, - /*II_0F_BA_07*/ {0x38, 1, 17, 8, 934}, - /*II_0F_BD*/ {0x29, 17, 11, 8, 4298}, - /*II_F3_0F_BD*/ {0x55, 17, 11, 8, 4303}, - /*II_0F_C7_07*/ {0x3d, 0, 46, 112, 5065}, - /*II_66_0F_D0*/ {0x29, 73, 68, 56, 5074}, - /*II_F2_0F_D0*/ {0x29, 73, 68, 56, 5084}, - /*II_0F_D1*/ {0x29, 67, 64, 32, 5116}, - /*II_66_0F_D1*/ {0x29, 73, 68, 48, 5116}, - /*II_0F_D2*/ {0x29, 67, 64, 32, 5131}, - /*II_66_0F_D2*/ {0x29, 73, 68, 48, 5131}, - /*II_0F_D3*/ {0x29, 67, 64, 32, 5146}, - /*II_66_0F_D3*/ {0x29, 73, 68, 48, 5146}, - /*II_0F_D4*/ {0x29, 67, 64, 48, 5161}, - /*II_66_0F_D4*/ {0x29, 73, 68, 48, 5161}, - /*II_0F_D5*/ {0x29, 67, 64, 32, 5176}, - /*II_66_0F_D5*/ {0x29, 73, 68, 48, 5176}, - /*II_66_0F_D6*/ {0x2a, 68, 72, 48, 3923}, - /*II_F3_0F_D6*/ {0x48, 65, 68, 48, 5193}, - /*II_F2_0F_D6*/ {0x48, 69, 64, 48, 5202}, - /*II_0F_D7*/ {0x50, 65, 12, 40, 5211}, - /*II_66_0F_D7*/ {0x50, 69, 12, 48, 5211}, - /*II_0F_D8*/ {0x29, 67, 64, 32, 5232}, - /*II_66_0F_D8*/ {0x29, 73, 68, 48, 5232}, - /*II_0F_D9*/ {0x29, 67, 64, 32, 5251}, - /*II_66_0F_D9*/ {0x29, 73, 68, 48, 5251}, - /*II_0F_DA*/ {0x29, 67, 64, 40, 5270}, - /*II_66_0F_DA*/ {0x29, 73, 68, 48, 5270}, - /*II_0F_DB*/ {0x29, 67, 64, 32, 5287}, - /*II_66_0F_DB*/ {0x29, 73, 68, 48, 5287}, - /*II_0F_DC*/ {0x29, 67, 64, 32, 5300}, - /*II_66_0F_DC*/ {0x29, 73, 68, 48, 5300}, - /*II_0F_DD*/ {0x29, 67, 64, 32, 5319}, - /*II_66_0F_DD*/ {0x29, 73, 68, 48, 5319}, - /*II_0F_DE*/ {0x29, 67, 64, 40, 5328}, - /*II_66_0F_DE*/ {0x29, 73, 68, 48, 5328}, - /*II_0F_DF*/ {0x29, 67, 64, 32, 5345}, - /*II_66_0F_DF*/ {0x29, 73, 68, 48, 5345}, - /*II_0F_E0*/ {0x29, 67, 64, 40, 5360}, - /*II_66_0F_E0*/ {0x29, 73, 68, 48, 5360}, - /*II_0F_E1*/ {0x29, 67, 64, 32, 5375}, - /*II_66_0F_E1*/ {0x29, 73, 68, 48, 5375}, - /*II_0F_E2*/ {0x29, 67, 64, 32, 5390}, - /*II_66_0F_E2*/ {0x29, 73, 68, 48, 5390}, - /*II_0F_E3*/ {0x29, 67, 64, 40, 5405}, - /*II_66_0F_E3*/ {0x29, 73, 68, 48, 5405}, - /*II_0F_E4*/ {0x29, 67, 64, 40, 5420}, - /*II_66_0F_E4*/ {0x29, 73, 68, 48, 5420}, - /*II_0F_E5*/ {0x29, 67, 64, 32, 5439}, - /*II_66_0F_E5*/ {0x29, 73, 68, 48, 5439}, - /*II_66_0F_E6*/ {0x29, 73, 68, 48, 5456}, - /*II_F3_0F_E6*/ {0x29, 72, 68, 48, 5467}, - /*II_F2_0F_E6*/ {0x29, 73, 68, 48, 5477}, - /*II_0F_E7*/ {0x2a, 64, 46, 40, 5521}, - /*II_66_0F_E7*/ {0x2a, 68, 47, 48, 5529}, - /*II_0F_E8*/ {0x29, 67, 64, 32, 5548}, - /*II_66_0F_E8*/ {0x29, 73, 68, 48, 5548}, - /*II_0F_E9*/ {0x29, 67, 64, 32, 5565}, - /*II_66_0F_E9*/ {0x29, 73, 68, 48, 5565}, - /*II_0F_EA*/ {0x29, 67, 64, 40, 5582}, - /*II_66_0F_EA*/ {0x29, 73, 68, 48, 5582}, - /*II_0F_EB*/ {0x29, 67, 64, 32, 5599}, - /*II_66_0F_EB*/ {0x29, 73, 68, 48, 5599}, - /*II_0F_EC*/ {0x29, 67, 64, 32, 5610}, - /*II_66_0F_EC*/ {0x29, 73, 68, 48, 5610}, - /*II_0F_ED*/ {0x29, 67, 64, 32, 5627}, - /*II_66_0F_ED*/ {0x29, 73, 68, 48, 5627}, - /*II_0F_EE*/ {0x29, 67, 64, 40, 5644}, - /*II_66_0F_EE*/ {0x29, 73, 68, 48, 5644}, - /*II_0F_EF*/ {0x29, 67, 64, 32, 5661}, - /*II_66_0F_EF*/ {0x29, 73, 68, 48, 5661}, - /*II_F2_0F_F0*/ {0x29, 42, 68, 56, 5674}, - /*II_0F_F1*/ {0x29, 67, 64, 32, 5689}, - /*II_66_0F_F1*/ {0x29, 73, 68, 48, 5689}, - /*II_0F_F2*/ {0x29, 67, 64, 32, 5704}, - /*II_66_0F_F2*/ {0x29, 73, 68, 48, 5704}, - /*II_0F_F3*/ {0x29, 67, 64, 32, 5719}, - /*II_66_0F_F3*/ {0x29, 73, 68, 48, 5719}, - /*II_0F_F4*/ {0x29, 67, 64, 48, 5734}, - /*II_66_0F_F4*/ {0x29, 73, 68, 48, 5734}, - /*II_0F_F5*/ {0x29, 67, 64, 32, 5753}, - /*II_66_0F_F5*/ {0x29, 73, 68, 48, 5753}, - /*II_0F_F6*/ {0x29, 67, 64, 40, 5772}, - /*II_66_0F_F6*/ {0x29, 73, 68, 48, 5772}, - /*II_0F_F7*/ {0x50, 65, 64, 40, 5789}, - /*II_66_0F_F7*/ {0x50, 69, 68, 48, 5799}, - /*II_0F_F8*/ {0x29, 67, 64, 32, 5824}, - /*II_66_0F_F8*/ {0x29, 73, 68, 48, 5824}, - /*II_0F_F9*/ {0x29, 67, 64, 32, 5839}, - /*II_66_0F_F9*/ {0x29, 73, 68, 48, 5839}, - /*II_0F_FA*/ {0x29, 67, 64, 32, 5854}, - /*II_66_0F_FA*/ {0x29, 73, 68, 48, 5854}, - /*II_0F_FB*/ {0x29, 67, 64, 48, 5869}, - /*II_66_0F_FB*/ {0x29, 73, 68, 48, 5869}, - /*II_0F_FC*/ {0x29, 67, 64, 32, 5884}, - /*II_66_0F_FC*/ {0x29, 73, 68, 48, 5884}, - /*II_0F_FD*/ {0x29, 67, 64, 32, 5899}, - /*II_66_0F_FD*/ {0x29, 73, 68, 48, 5899}, - /*II_0F_FE*/ {0x29, 67, 64, 32, 5914}, - /*II_66_0F_FE*/ {0x29, 73, 68, 48, 5914}, - /*II_D9_06*/ {0x35, 0, 42, 16, 5929}, - /*II_9B_D9_06*/ {0x5d, 0, 42, 16, 5938}, - /*II_D9_07*/ {0x35, 0, 42, 16, 5946}, - /*II_9B_D9_07*/ {0x5d, 0, 42, 16, 5954}, - /*II_DB_E2*/ {0x3b, 0, 0, 16, 5961}, - /*II_9B_DB_E2*/ {0x5e, 0, 0, 16, 5969}, - /*II_DB_E3*/ {0x3b, 0, 0, 16, 5976}, - /*II_9B_DB_E3*/ {0x5e, 0, 0, 16, 5984}, - /*II_DD_06*/ {0x35, 0, 42, 16, 5991}, - /*II_9B_DD_06*/ {0x5d, 0, 42, 16, 5999}, - /*II_DD_07*/ {0x35, 0, 42, 16, 6006}, - /*II_9B_DD_07*/ {0x5d, 0, 42, 16, 6014}, - /*II_DF_E0*/ {0x3b, 0, 34, 16, 6006}, - /*II_9B_DF_E0*/ {0x5e, 0, 34, 16, 6014}, - /*II_0F_38_00*/ {0x29, 67, 64, 64, 6021}, - /*II_66_0F_38_00*/ {0x29, 73, 68, 64, 6021}, - /*II_0F_38_01*/ {0x29, 67, 64, 64, 6038}, - /*II_66_0F_38_01*/ {0x29, 73, 68, 64, 6038}, - /*II_0F_38_02*/ {0x29, 67, 64, 64, 6055}, - /*II_66_0F_38_02*/ {0x29, 73, 68, 64, 6055}, - /*II_0F_38_03*/ {0x29, 67, 64, 64, 6072}, - /*II_66_0F_38_03*/ {0x29, 73, 68, 64, 6072}, - /*II_0F_38_04*/ {0x29, 67, 64, 64, 6091}, - /*II_66_0F_38_04*/ {0x29, 73, 68, 64, 6091}, - /*II_0F_38_05*/ {0x29, 67, 64, 64, 6114}, - /*II_66_0F_38_05*/ {0x29, 73, 68, 64, 6114}, - /*II_0F_38_06*/ {0x29, 67, 64, 64, 6131}, - /*II_66_0F_38_06*/ {0x29, 73, 68, 64, 6131}, - /*II_0F_38_07*/ {0x29, 67, 64, 64, 6148}, - /*II_66_0F_38_07*/ {0x29, 73, 68, 64, 6148}, - /*II_0F_38_08*/ {0x29, 67, 64, 64, 6167}, - /*II_66_0F_38_08*/ {0x29, 73, 68, 64, 6167}, - /*II_0F_38_09*/ {0x29, 67, 64, 64, 6184}, - /*II_66_0F_38_09*/ {0x29, 73, 68, 64, 6184}, - /*II_0F_38_0A*/ {0x29, 67, 64, 64, 6201}, - /*II_66_0F_38_0A*/ {0x29, 73, 68, 64, 6201}, - /*II_0F_38_0B*/ {0x29, 67, 64, 64, 6218}, - /*II_66_0F_38_0B*/ {0x29, 73, 68, 64, 6218}, - /*II_66_0F_38_17*/ {0x29, 73, 68, 80, 6311}, - /*II_0F_38_1C*/ {0x29, 67, 64, 64, 6370}, - /*II_66_0F_38_1C*/ {0x29, 73, 68, 64, 6370}, - /*II_0F_38_1D*/ {0x29, 67, 64, 64, 6385}, - /*II_66_0F_38_1D*/ {0x29, 73, 68, 64, 6385}, - /*II_0F_38_1E*/ {0x29, 67, 64, 64, 6400}, - /*II_66_0F_38_1E*/ {0x29, 73, 68, 64, 6400}, - /*II_66_0F_38_20*/ {0x29, 72, 68, 72, 6415}, - /*II_66_0F_38_21*/ {0x29, 71, 68, 72, 6436}, - /*II_66_0F_38_22*/ {0x29, 70, 68, 72, 6457}, - /*II_66_0F_38_23*/ {0x29, 72, 68, 72, 6478}, - /*II_66_0F_38_24*/ {0x29, 71, 68, 72, 6499}, - /*II_66_0F_38_25*/ {0x29, 72, 68, 72, 6520}, - /*II_66_0F_38_28*/ {0x29, 73, 68, 72, 6541}, - /*II_66_0F_38_29*/ {0x29, 73, 68, 72, 6558}, - /*II_66_0F_38_2A*/ {0x2a, 47, 68, 72, 6577}, - /*II_66_0F_38_2B*/ {0x29, 73, 68, 72, 6598}, - /*II_66_0F_38_30*/ {0x29, 72, 68, 72, 6643}, - /*II_66_0F_38_31*/ {0x29, 71, 68, 72, 6664}, - /*II_66_0F_38_32*/ {0x29, 70, 68, 72, 6685}, - /*II_66_0F_38_33*/ {0x29, 72, 68, 72, 6706}, - /*II_66_0F_38_34*/ {0x29, 71, 68, 72, 6727}, - /*II_66_0F_38_35*/ {0x29, 72, 68, 72, 6748}, - /*II_66_0F_38_37*/ {0x29, 73, 68, 80, 6769}, - /*II_66_0F_38_38*/ {0x29, 73, 68, 72, 6788}, - /*II_66_0F_38_39*/ {0x29, 73, 68, 72, 6805}, - /*II_66_0F_38_3A*/ {0x29, 73, 68, 72, 6822}, - /*II_66_0F_38_3B*/ {0x29, 73, 68, 72, 6839}, - /*II_66_0F_38_3C*/ {0x29, 73, 68, 72, 6856}, - /*II_66_0F_38_3D*/ {0x29, 73, 68, 72, 6873}, - /*II_66_0F_38_3E*/ {0x29, 73, 68, 72, 6890}, - /*II_66_0F_38_3F*/ {0x29, 73, 68, 72, 6907}, - /*II_66_0F_38_40*/ {0x29, 73, 68, 72, 6924}, - /*II_66_0F_38_41*/ {0x29, 73, 68, 72, 6941}, - /*II_66_0F_38_80*/ {0x4d, 47, 13, 112, 6966}, - /*II_66_0F_38_81*/ {0x4d, 47, 13, 112, 6974}, - /*II_66_0F_38_DB*/ {0x29, 73, 68, 152, 7823}, - /*II_66_0F_38_DC*/ {0x29, 73, 68, 152, 7840}, - /*II_66_0F_38_DD*/ {0x29, 73, 68, 152, 7857}, - /*II_66_0F_38_DE*/ {0x29, 73, 68, 152, 7882}, - /*II_66_0F_38_DF*/ {0x29, 73, 68, 152, 7899}, - /*II_0F_38_F0*/ {0x2a, 17, 11, 8, 7924}, - /*II_F2_0F_38_F0*/ {0x2a, 15, 13, 80, 7931}, - /*II_0F_38_F1*/ {0x2a, 11, 17, 8, 7924}, - /*II_F2_0F_38_F1*/ {0x2a, 17, 13, 80, 7931}, - /*II_0F_71_02*/ {0x52, 1, 65, 32, 5116}, - /*II_66_0F_71_02*/ {0x3d, 1, 69, 48, 5116}, - /*II_0F_71_04*/ {0x52, 1, 65, 32, 5375}, - /*II_66_0F_71_04*/ {0x3d, 1, 69, 48, 5375}, - /*II_0F_71_06*/ {0x52, 1, 65, 32, 5689}, - /*II_66_0F_71_06*/ {0x3d, 1, 69, 48, 5689}, - /*II_0F_72_02*/ {0x52, 1, 65, 32, 5131}, - /*II_66_0F_72_02*/ {0x3d, 1, 69, 48, 5131}, - /*II_0F_72_04*/ {0x52, 1, 65, 32, 5390}, - /*II_66_0F_72_04*/ {0x3d, 1, 69, 48, 5390}, - /*II_0F_72_06*/ {0x52, 1, 65, 32, 5704}, - /*II_66_0F_72_06*/ {0x3d, 1, 69, 48, 5704}, - /*II_0F_73_02*/ {0x52, 1, 65, 32, 5146}, - /*II_66_0F_73_02*/ {0x3d, 1, 69, 48, 5146}, - /*II_66_0F_73_03*/ {0x3d, 1, 69, 48, 8494}, - /*II_0F_73_06*/ {0x52, 1, 65, 32, 5719}, - /*II_66_0F_73_06*/ {0x3d, 1, 69, 48, 5719}, - /*II_66_0F_73_07*/ {0x3d, 1, 69, 48, 8511}, - /*II_0F_AE_02*/ {0x3d, 0, 42, 8, 8528}, - /*II_0F_AE_03*/ {0x3d, 0, 42, 8, 8547}, - /*II_0F_C7_06*/ {0x3d, 0, 46, 112, 8566}, - /*II_66_0F_C7_06*/ {0x3d, 0, 46, 112, 8575}, - /*II_F3_0F_C7_06*/ {0x3d, 0, 46, 112, 8584}}; - -_InstInfoEx InstInfosEx[] = { - /*II_69*/ {{0x17, 17, 11, 8, 117}, 0x0, 3, 0, 0, 0}, - /*II_6B*/ {{0x17, 17, 11, 8, 117}, 0x0, 5, 0, 0, 0}, - /*II_98*/ {{0x1c, 0, 0, 8, 228}, 0x0, 0, 0, 233, 239}, - /*II_99*/ {{0x1c, 0, 0, 8, 245}, 0x0, 0, 0, 250, 255}, - /*II_E3*/ {{0x25, 0, 40, 13, 427}, 0x0, 0, 0, 433, 440}, - /*II_0F_A4*/ {{0x2d, 11, 17, 8, 876}, 0x0, 1, 0, 0, 0}, - /*II_0F_A5*/ {{0x2d, 11, 17, 8, 876}, 0x0, 52, 0, 0, 0}, - /*II_0F_AC*/ {{0x2d, 11, 17, 8, 892}, 0x0, 1, 0, 0, 0}, - /*II_0F_AD*/ {{0x2d, 11, 17, 8, 892}, 0x0, 52, 0, 0, 0}, - /*II_V_F3_0F_10*/ {{0x44, 81, 68, 128, 2114}, 0x0, 69, 0, 0, 0}, - /*II_V_F2_0F_10*/ {{0x44, 81, 68, 128, 2122}, 0x0, 69, 0, 0, 0}, - /*II_NV_0F_10*/ {{0x45, 90, 83, 128, 2130}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_10*/ {{0x45, 90, 83, 128, 2139}, 0x1, 0, 0, 0, 0}, - /*II_NV_F3_0F_10*/ {{0x45, 44, 68, 128, 2114}, 0x0, 0, 0, 0, 0}, - /*II_NV_F2_0F_10*/ {{0x45, 46, 68, 128, 2122}, 0x0, 0, 0, 0, 0}, - /*II_V_F3_0F_11*/ {{0x44, 81, 68, 128, 2114}, 0x0, 69, 0, 0, 0}, - /*II_V_F2_0F_11*/ {{0x44, 81, 68, 128, 2122}, 0x0, 69, 0, 0, 0}, - /*II_NV_0F_11*/ {{0x45, 83, 90, 128, 2130}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_11*/ {{0x45, 83, 90, 128, 2139}, 0x1, 0, 0, 0, 0}, - /*II_NV_F3_0F_11*/ {{0x45, 68, 44, 128, 2114}, 0x0, 0, 0, 0, 0}, - /*II_NV_F2_0F_11*/ {{0x45, 68, 46, 128, 2122}, 0x0, 0, 0, 0, 0}, - /*II_0F_12*/ {{0x46, 72, 68, 40, 2148}, 0x0, 0, 0, 2157, 0}, - /*II_V_0F_12*/ {{0x47, 81, 68, 128, 2192}, 0x0, 72, 0, 2202, 0}, - /*II_V_66_0F_12*/ {{0x44, 81, 68, 128, 2211}, 0x0, 46, 0, 0, 0}, - /*II_NV_F3_0F_12*/ {{0x45, 90, 83, 128, 2220}, 0x1, 0, 0, 0, 0}, - /*II_NV_F2_0F_12*/ {{0x45, 89, 83, 128, 2231}, 0x1, 0, 0, 0, 0}, - /*II_NV_0F_13*/ {{0x45, 68, 46, 128, 2202}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_13*/ {{0x45, 68, 46, 128, 2211}, 0x0, 0, 0, 0, 0}, - /*II_V_0F_14*/ {{0x44, 88, 83, 128, 2261}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_14*/ {{0x44, 88, 83, 128, 2272}, 0x1, 90, 0, 0, 0}, - /*II_V_0F_15*/ {{0x44, 88, 83, 128, 2303}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_15*/ {{0x44, 88, 83, 128, 2314}, 0x1, 90, 0, 0, 0}, - /*II_0F_16*/ {{0x46, 72, 68, 40, 2325}, 0x0, 0, 0, 2334, 0}, - /*II_V_0F_16*/ {{0x47, 81, 68, 128, 2360}, 0x0, 72, 0, 2370, 0}, - /*II_V_66_0F_16*/ {{0x44, 81, 68, 128, 2379}, 0x0, 46, 0, 0, 0}, - /*II_NV_F3_0F_16*/ {{0x45, 90, 83, 128, 2388}, 0x1, 0, 0, 0, 0}, - /*II_NV_0F_17*/ {{0x45, 68, 46, 128, 2370}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_17*/ {{0x45, 68, 46, 128, 2379}, 0x0, 0, 0, 0, 0}, - /*II_NV_0F_28*/ {{0x45, 90, 83, 128, 2464}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_28*/ {{0x45, 90, 83, 128, 2473}, 0x1, 0, 0, 0, 0}, - /*II_NV_0F_29*/ {{0x45, 83, 90, 128, 2464}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_29*/ {{0x45, 83, 90, 128, 2473}, 0x1, 0, 0, 0, 0}, - /*II_V_F3_0F_2A*/ {{0x44, 81, 68, 128, 2522}, 0x2, 79, 0, 0, 0}, - /*II_V_F2_0F_2A*/ {{0x44, 81, 68, 128, 2533}, 0x2, 79, 0, 0, 0}, - /*II_NV_0F_2B*/ {{0x45, 83, 92, 128, 2580}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_2B*/ {{0x45, 83, 92, 128, 2590}, 0x1, 0, 0, 0, 0}, - /*II_NV_F3_0F_2C*/ {{0x45, 80, 78, 128, 2644}, 0x2, 0, 0, 0, 0}, - /*II_NV_F2_0F_2C*/ {{0x45, 80, 78, 128, 2656}, 0x2, 0, 0, 0, 0}, - /*II_NV_F3_0F_2D*/ {{0x45, 80, 78, 128, 2708}, 0x2, 0, 0, 0, 0}, - /*II_NV_F2_0F_2D*/ {{0x45, 80, 78, 128, 2719}, 0x2, 0, 0, 0, 0}, - /*II_NV_0F_2E*/ {{0x45, 71, 68, 128, 2748}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_2E*/ {{0x45, 72, 68, 128, 2758}, 0x0, 0, 0, 0, 0}, - /*II_NV_0F_2F*/ {{0x45, 71, 68, 128, 2784}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_2F*/ {{0x45, 72, 68, 128, 2793}, 0x0, 0, 0, 0, 0}, - /*II_NV_0F_50*/ {{0x49, 83, 13, 128, 2822}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_50*/ {{0x49, 83, 13, 128, 2833}, 0x1, 0, 0, 0, 0}, - /*II_V_F3_0F_51*/ {{0x44, 81, 68, 128, 2876}, 0x0, 71, 0, 0, 0}, - /*II_V_F2_0F_51*/ {{0x44, 81, 68, 128, 2885}, 0x0, 72, 0, 0, 0}, - /*II_NV_0F_51*/ {{0x45, 90, 83, 128, 2894}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_51*/ {{0x45, 90, 83, 128, 2903}, 0x1, 0, 0, 0, 0}, - /*II_V_F3_0F_52*/ {{0x44, 81, 68, 128, 2930}, 0x0, 71, 0, 0, 0}, - /*II_NV_0F_52*/ {{0x45, 90, 83, 128, 2940}, 0x1, 0, 0, 0, 0}, - /*II_V_F3_0F_53*/ {{0x44, 81, 68, 128, 2964}, 0x0, 71, 0, 0, 0}, - /*II_NV_0F_53*/ {{0x45, 90, 83, 128, 2972}, 0x1, 0, 0, 0, 0}, - /*II_V_0F_54*/ {{0x44, 88, 83, 128, 2994}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_54*/ {{0x44, 88, 83, 128, 3002}, 0x1, 90, 0, 0, 0}, - /*II_V_0F_55*/ {{0x44, 88, 83, 128, 3026}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_55*/ {{0x44, 88, 83, 128, 3035}, 0x1, 90, 0, 0, 0}, - /*II_V_0F_56*/ {{0x44, 88, 83, 128, 3056}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_56*/ {{0x44, 88, 83, 128, 3063}, 0x1, 90, 0, 0, 0}, - /*II_V_0F_57*/ {{0x44, 88, 83, 128, 3084}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_57*/ {{0x44, 88, 83, 128, 3092}, 0x1, 90, 0, 0, 0}, - /*II_V_0F_58*/ {{0x44, 88, 83, 128, 3128}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_58*/ {{0x44, 88, 83, 128, 3136}, 0x1, 90, 0, 0, 0}, - /*II_V_F3_0F_58*/ {{0x44, 81, 68, 128, 3144}, 0x0, 71, 0, 0, 0}, - /*II_V_F2_0F_58*/ {{0x44, 81, 68, 128, 3152}, 0x0, 72, 0, 0, 0}, - /*II_V_0F_59*/ {{0x44, 88, 83, 128, 3188}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_59*/ {{0x44, 88, 83, 128, 3196}, 0x1, 90, 0, 0, 0}, - /*II_V_F3_0F_59*/ {{0x44, 81, 68, 128, 3204}, 0x0, 71, 0, 0, 0}, - /*II_V_F2_0F_59*/ {{0x44, 81, 68, 128, 3212}, 0x0, 72, 0, 0, 0}, - /*II_V_F3_0F_5A*/ {{0x44, 81, 68, 128, 3260}, 0x0, 71, 0, 0, 0}, - /*II_V_F2_0F_5A*/ {{0x44, 81, 68, 128, 3271}, 0x0, 72, 0, 0, 0}, - /*II_NV_0F_5A*/ {{0x45, 91, 83, 128, 3282}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_5A*/ {{0x45, 90, 68, 128, 3293}, 0x1, 0, 0, 0, 0}, - /*II_NV_0F_5B*/ {{0x45, 90, 83, 128, 3335}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_5B*/ {{0x45, 90, 83, 128, 3346}, 0x1, 0, 0, 0, 0}, - /*II_NV_F3_0F_5B*/ {{0x45, 90, 83, 128, 3357}, 0x1, 0, 0, 0, 0}, - /*II_V_0F_5C*/ {{0x44, 88, 83, 128, 3397}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_5C*/ {{0x44, 88, 83, 128, 3405}, 0x1, 90, 0, 0, 0}, - /*II_V_F3_0F_5C*/ {{0x44, 81, 68, 128, 3413}, 0x0, 71, 0, 0, 0}, - /*II_V_F2_0F_5C*/ {{0x44, 81, 68, 128, 3421}, 0x0, 72, 0, 0, 0}, - /*II_V_0F_5D*/ {{0x44, 88, 83, 128, 3457}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_5D*/ {{0x44, 88, 83, 128, 3465}, 0x1, 90, 0, 0, 0}, - /*II_V_F3_0F_5D*/ {{0x44, 81, 68, 128, 3473}, 0x0, 71, 0, 0, 0}, - /*II_V_F2_0F_5D*/ {{0x44, 81, 68, 128, 3481}, 0x0, 72, 0, 0, 0}, - /*II_V_0F_5E*/ {{0x44, 88, 83, 128, 3517}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_5E*/ {{0x44, 88, 83, 128, 3525}, 0x1, 90, 0, 0, 0}, - /*II_V_F3_0F_5E*/ {{0x44, 81, 68, 128, 3533}, 0x0, 71, 0, 0, 0}, - /*II_V_F2_0F_5E*/ {{0x44, 81, 68, 128, 3541}, 0x0, 72, 0, 0, 0}, - /*II_V_0F_5F*/ {{0x44, 88, 83, 128, 3577}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_5F*/ {{0x44, 88, 83, 128, 3585}, 0x1, 90, 0, 0, 0}, - /*II_V_F3_0F_5F*/ {{0x44, 81, 68, 128, 3593}, 0x0, 71, 0, 0, 0}, - /*II_V_F2_0F_5F*/ {{0x44, 81, 68, 128, 3601}, 0x0, 72, 0, 0, 0}, - /*II_V_66_0F_60*/ {{0x44, 81, 68, 128, 3620}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_61*/ {{0x44, 81, 68, 128, 3643}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_62*/ {{0x44, 81, 68, 128, 3666}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_63*/ {{0x44, 81, 68, 128, 3688}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_64*/ {{0x44, 81, 68, 128, 3708}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_65*/ {{0x44, 81, 68, 128, 3727}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_66*/ {{0x44, 81, 68, 128, 3746}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_67*/ {{0x44, 81, 68, 128, 3766}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_68*/ {{0x44, 81, 68, 128, 3788}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_69*/ {{0x44, 81, 68, 128, 3811}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_6A*/ {{0x44, 81, 68, 128, 3834}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_6B*/ {{0x44, 81, 68, 128, 3856}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_6C*/ {{0x44, 81, 68, 128, 3879}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_6D*/ {{0x44, 81, 68, 128, 3904}, 0x0, 73, 0, 0, 0}, - /*II_0F_6E*/ {{0x4a, 18, 64, 32, 3917}, 0x0, 0, 0, 3923, 0}, - /*II_66_0F_6E*/ {{0x4a, 18, 68, 48, 3917}, 0x0, 0, 0, 3923, 0}, - /*II_NV_66_0F_6E*/ {{0x45, 79, 68, 128, 3929}, 0x6, 0, 0, 3936, 0}, - /*II_NV_66_0F_6F*/ {{0x45, 90, 83, 128, 3959}, 0x1, 0, 0, 0, 0}, - /*II_NV_F3_0F_6F*/ {{0x45, 90, 83, 128, 3968}, 0x1, 0, 0, 0, 0}, - /*II_0F_70*/ {{0x4b, 67, 64, 40, 3977}, 0x0, 1, 0, 0, 0}, - /*II_66_0F_70*/ {{0x4b, 73, 68, 48, 3985}, 0x0, 1, 0, 0, 0}, - /*II_F3_0F_70*/ {{0x4b, 73, 68, 48, 3993}, 0x0, 1, 0, 0, 0}, - /*II_F2_0F_70*/ {{0x4b, 73, 68, 48, 4002}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_70*/ {{0x44, 73, 68, 128, 4011}, 0x0, 1, 0, 0, 0}, - /*II_NV_F3_0F_70*/ {{0x44, 73, 68, 128, 4020}, 0x0, 1, 0, 0, 0}, - /*II_NV_F2_0F_70*/ {{0x44, 73, 68, 128, 4030}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_74*/ {{0x44, 81, 68, 128, 4049}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_75*/ {{0x44, 81, 68, 128, 4068}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_76*/ {{0x44, 81, 68, 128, 4087}, 0x0, 73, 0, 0, 0}, - /*II_NV_0F_77*/ {{0x4c, 0, 0, 128, 4103}, 0x9, 0, 0, 4115, 0}, - /*II_66_0F_78*/ {{0x4e, 7, 69, 88, 4133}, 0x0, 8, 0, 0, 0}, - /*II_F2_0F_78*/ {{0x4f, 69, 68, 88, 4140}, 0x0, 7, 8, 0, 0}, - /*II_V_66_0F_7C*/ {{0x44, 88, 83, 128, 4174}, 0x1, 90, 0, 0, 0}, - /*II_V_F2_0F_7C*/ {{0x44, 88, 83, 128, 4183}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_7D*/ {{0x44, 88, 83, 128, 4208}, 0x1, 90, 0, 0, 0}, - /*II_V_F2_0F_7D*/ {{0x44, 88, 83, 128, 4217}, 0x1, 90, 0, 0, 0}, - /*II_0F_7E*/ {{0x4a, 64, 18, 32, 3917}, 0x0, 0, 0, 3923, 0}, - /*II_66_0F_7E*/ {{0x4a, 68, 18, 48, 3917}, 0x0, 0, 0, 3923, 0}, - /*II_NV_66_0F_7E*/ {{0x45, 68, 79, 128, 3929}, 0x6, 0, 0, 3936, 0}, - /*II_NV_F3_0F_7E*/ {{0x45, 72, 68, 128, 3936}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_7F*/ {{0x45, 83, 90, 128, 3959}, 0x1, 0, 0, 0, 0}, - /*II_NV_F3_0F_7F*/ {{0x45, 83, 90, 128, 3968}, 0x1, 0, 0, 0, 0}, - /*II_0F_AE_05*/ {{0x51, 0, 43, 8, 4249}, 0x0, 0, 0, 4257, 0}, - /*II_0F_AE_07*/ {{0x51, 0, 43, 8, 4273}, 0x0, 0, 0, 4281, 0}, - /*II_0F_C2*/ {{0x56, 73, 68, 40, 4310}, 0x0, 0, 0, 4319, 4328}, - /*II_66_0F_C2*/ {{0x56, 73, 68, 48, 4389}, 0x0, 0, 0, 4398, 4407}, - /*II_F3_0F_C2*/ {{0x56, 71, 68, 40, 4468}, 0x0, 0, 0, 4477, 4486}, - /*II_F2_0F_C2*/ {{0x56, 72, 68, 48, 4547}, 0x0, 0, 0, 4556, 4565}, - /*II_V_0F_C2*/ {{0x57, 88, 83, 128, 4626}, 0x1, 90, 0, 4636, 4646}, - /*II_V_66_0F_C2*/ {{0x57, 88, 83, 128, 4713}, 0x1, 90, 0, 4723, 4733}, - /*II_V_F3_0F_C2*/ {{0x57, 81, 68, 128, 4800}, 0x0, 71, 0, 4810, 4820}, - /*II_V_F2_0F_C2*/ {{0x57, 81, 68, 128, 4887}, 0x0, 72, 0, 4897, 4907}, - /*II_0F_C4*/ {{0x4b, 25, 64, 40, 4974}, 0x0, 1, 0, 0, 0}, - /*II_66_0F_C4*/ {{0x4b, 25, 68, 48, 4974}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_C4*/ {{0x58, 81, 68, 128, 4982}, 0x0, 25, 1, 0, 0}, - /*II_0F_C5*/ {{0x59, 65, 12, 40, 4991}, 0x0, 1, 0, 0, 0}, - /*II_66_0F_C5*/ {{0x4b, 69, 12, 48, 4991}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_C5*/ {{0x5a, 68, 13, 128, 4999}, 0x0, 1, 0, 0, 0}, - /*II_0F_C6*/ {{0x4b, 73, 68, 40, 5008}, 0x0, 1, 0, 0, 0}, - /*II_66_0F_C6*/ {{0x4b, 73, 68, 48, 5016}, 0x0, 1, 0, 0, 0}, - /*II_V_0F_C6*/ {{0x58, 88, 83, 128, 5024}, 0x1, 90, 1, 0, 0}, - /*II_V_66_0F_C6*/ {{0x58, 88, 83, 128, 5033}, 0x1, 90, 1, 0, 0}, - /*II_0F_C7_01*/ {{0x5b, 0, 48, 8, 5042}, 0x0, 0, 0, 5053, 0}, - /*II_V_66_0F_D0*/ {{0x44, 88, 83, 128, 5094}, 0x1, 90, 0, 0, 0}, - /*II_V_F2_0F_D0*/ {{0x44, 88, 83, 128, 5105}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_D1*/ {{0x44, 81, 68, 128, 5123}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_D2*/ {{0x44, 81, 68, 128, 5138}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_D3*/ {{0x44, 81, 68, 128, 5153}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_D4*/ {{0x44, 81, 68, 128, 5168}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_D5*/ {{0x44, 81, 68, 128, 5184}, 0x0, 73, 0, 0, 0}, - /*II_NV_66_0F_D6*/ {{0x45, 68, 72, 128, 3936}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_D7*/ {{0x49, 68, 13, 128, 5221}, 0x0, 0, 0, 0, 0}, - /*II_V_66_0F_D8*/ {{0x44, 81, 68, 128, 5241}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_D9*/ {{0x44, 81, 68, 128, 5260}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_DA*/ {{0x44, 81, 68, 128, 5278}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_DB*/ {{0x44, 81, 68, 128, 5293}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_DC*/ {{0x44, 81, 68, 128, 5309}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_DD*/ {{0x44, 81, 68, 128, 5309}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_DE*/ {{0x44, 81, 68, 128, 5336}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_DF*/ {{0x44, 81, 68, 128, 5352}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_E0*/ {{0x44, 81, 68, 128, 5367}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_E1*/ {{0x44, 81, 68, 128, 5382}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_E2*/ {{0x44, 81, 68, 128, 5397}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_E3*/ {{0x44, 81, 68, 128, 5412}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_E4*/ {{0x44, 81, 68, 128, 5429}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_E5*/ {{0x44, 81, 68, 128, 5447}, 0x0, 73, 0, 0, 0}, - /*II_NV_66_0F_E6*/ {{0x45, 90, 68, 128, 5487}, 0x1, 0, 0, 0, 0}, - /*II_NV_F3_0F_E6*/ {{0x45, 91, 83, 128, 5499}, 0x1, 0, 0, 0, 0}, - /*II_NV_F2_0F_E6*/ {{0x45, 90, 68, 128, 5510}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_E7*/ {{0x45, 83, 92, 128, 5538}, 0x1, 0, 0, 0, 0}, - /*II_V_66_0F_E8*/ {{0x44, 81, 68, 128, 5556}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_E9*/ {{0x44, 81, 68, 128, 5573}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_EA*/ {{0x44, 81, 68, 128, 5590}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_EB*/ {{0x44, 81, 68, 128, 5604}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_EC*/ {{0x44, 81, 68, 128, 5618}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_ED*/ {{0x44, 81, 68, 128, 5635}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_EE*/ {{0x44, 81, 68, 128, 5652}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_EF*/ {{0x44, 81, 68, 128, 5667}, 0x0, 73, 0, 0, 0}, - /*II_NV_F2_0F_F0*/ {{0x45, 92, 83, 128, 5681}, 0x1, 0, 0, 0, 0}, - /*II_V_66_0F_F1*/ {{0x44, 81, 68, 128, 5696}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_F2*/ {{0x44, 81, 68, 128, 5711}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_F3*/ {{0x44, 81, 68, 128, 5726}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_F4*/ {{0x44, 81, 68, 128, 5743}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_F5*/ {{0x44, 81, 68, 128, 5762}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_F6*/ {{0x44, 81, 68, 128, 5780}, 0x0, 73, 0, 0, 0}, - /*II_NV_66_0F_F7*/ {{0x5c, 69, 68, 128, 5811}, 0x0, 0, 0, 0, 0}, - /*II_V_66_0F_F8*/ {{0x44, 81, 68, 128, 5831}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_F9*/ {{0x44, 81, 68, 128, 5846}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_FA*/ {{0x44, 81, 68, 128, 5861}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_FB*/ {{0x44, 81, 68, 128, 5876}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_FC*/ {{0x44, 81, 68, 128, 5891}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_FD*/ {{0x44, 81, 68, 128, 5906}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_FE*/ {{0x44, 81, 68, 128, 5921}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_00*/ {{0x44, 81, 68, 128, 6029}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_01*/ {{0x44, 81, 68, 128, 6046}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_02*/ {{0x44, 81, 68, 128, 6063}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_03*/ {{0x44, 81, 68, 128, 6081}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_04*/ {{0x44, 81, 68, 128, 6102}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_05*/ {{0x44, 81, 68, 128, 6122}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_06*/ {{0x44, 81, 68, 128, 6139}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_07*/ {{0x44, 81, 68, 128, 6157}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_08*/ {{0x44, 81, 68, 128, 6175}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_09*/ {{0x44, 81, 68, 128, 6192}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_0A*/ {{0x44, 81, 68, 128, 6209}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_0B*/ {{0x44, 81, 68, 128, 6228}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_0C*/ {{0x44, 88, 83, 128, 6239}, 0x1, 90, 0, 0, 0}, - /*II_V_66_0F_38_0D*/ {{0x44, 88, 83, 128, 6250}, 0x1, 90, 0, 0, 0}, - /*II_NV_66_0F_38_0E*/ {{0x45, 90, 83, 128, 6261}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_38_0F*/ {{0x45, 90, 83, 128, 6271}, 0x1, 0, 0, 0, 0}, - /*II_66_0F_38_10*/ {{0x4b, 73, 68, 72, 6281}, 0x0, 74, 0, 0, 0}, - /*II_66_0F_38_14*/ {{0x4b, 73, 68, 72, 6291}, 0x0, 74, 0, 0, 0}, - /*II_66_0F_38_15*/ {{0x4b, 73, 68, 72, 6301}, 0x0, 74, 0, 0, 0}, - /*II_NV_66_0F_38_17*/ {{0x45, 90, 83, 128, 6318}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_38_18*/ {{0x45, 44, 83, 128, 6326}, 0x1, 0, 0, 0, 0}, - /*II_NV_66_0F_38_19*/ {{0x45, 46, 85, 128, 6340}, 0x10, 0, 0, 0, 0}, - /*II_NV_66_0F_38_1A*/ {{0x45, 47, 85, 128, 6354}, 0x10, 0, 0, 0, 0}, - /*II_NV_66_0F_38_1C*/ {{0x45, 73, 68, 128, 6377}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_1D*/ {{0x45, 73, 68, 128, 6392}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_1E*/ {{0x45, 73, 68, 128, 6407}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_20*/ {{0x45, 72, 68, 128, 6425}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_21*/ {{0x45, 71, 68, 128, 6446}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_22*/ {{0x45, 70, 68, 128, 6467}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_23*/ {{0x45, 72, 68, 128, 6488}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_24*/ {{0x45, 71, 68, 128, 6509}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_25*/ {{0x45, 72, 68, 128, 6530}, 0x0, 0, 0, 0, 0}, - /*II_V_66_0F_38_28*/ {{0x44, 81, 68, 128, 6549}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_29*/ {{0x44, 81, 68, 128, 6567}, 0x0, 73, 0, 0, 0}, - /*II_NV_66_0F_38_2A*/ {{0x45, 47, 68, 128, 6587}, 0x0, 0, 0, 0, 0}, - /*II_V_66_0F_38_2B*/ {{0x44, 81, 68, 128, 6608}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_2C*/ {{0x44, 88, 83, 128, 6619}, 0x1, 92, 0, 0, 0}, - /*II_V_66_0F_38_2D*/ {{0x44, 88, 83, 128, 6631}, 0x1, 92, 0, 0, 0}, - /*II_V_66_0F_38_2E*/ {{0x44, 88, 92, 128, 6619}, 0x1, 83, 0, 0, 0}, - /*II_V_66_0F_38_2F*/ {{0x44, 88, 92, 128, 6631}, 0x1, 83, 0, 0, 0}, - /*II_NV_66_0F_38_30*/ {{0x45, 72, 68, 128, 6653}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_31*/ {{0x45, 71, 68, 128, 6674}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_32*/ {{0x45, 70, 68, 128, 6695}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_33*/ {{0x45, 72, 68, 128, 6716}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_34*/ {{0x45, 71, 68, 128, 6737}, 0x0, 0, 0, 0, 0}, - /*II_NV_66_0F_38_35*/ {{0x45, 72, 68, 128, 6758}, 0x0, 0, 0, 0, 0}, - /*II_V_66_0F_38_37*/ {{0x44, 81, 68, 128, 6778}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_38*/ {{0x44, 81, 68, 128, 6796}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_39*/ {{0x44, 81, 68, 128, 6813}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_3A*/ {{0x44, 81, 68, 128, 6830}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_3B*/ {{0x44, 81, 68, 128, 6847}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_3C*/ {{0x44, 81, 68, 128, 6864}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_3D*/ {{0x44, 81, 68, 128, 6881}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_3E*/ {{0x44, 81, 68, 128, 6898}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_3F*/ {{0x44, 81, 68, 128, 6915}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_40*/ {{0x44, 81, 68, 128, 6932}, 0x0, 73, 0, 0, 0}, - /*II_NV_66_0F_38_41*/ {{0x45, 73, 68, 128, 6953}, 0x0, 0, 0, 0, 0}, - /*II_V_66_0F_38_96*/ {{0x44, 88, 83, 136, 6983}, 0x7, 90, 0, 6999, 0}, - /*II_V_66_0F_38_97*/ {{0x44, 88, 83, 136, 7015}, 0x7, 90, 0, 7031, 0}, - /*II_V_66_0F_38_98*/ {{0x44, 88, 83, 136, 7047}, 0x7, 90, 0, 7060, 0}, - /*II_V_66_0F_38_99*/ {{0x44, 81, 68, 136, 7073}, 0x6, 80, 0, 7086, 0}, - /*II_V_66_0F_38_9A*/ {{0x44, 88, 83, 136, 7099}, 0x7, 90, 0, 7112, 0}, - /*II_V_66_0F_38_9B*/ {{0x44, 81, 68, 136, 7125}, 0x6, 80, 0, 7138, 0}, - /*II_V_66_0F_38_9C*/ {{0x44, 88, 83, 136, 7151}, 0x7, 90, 0, 7165, 0}, - /*II_V_66_0F_38_9D*/ {{0x44, 81, 68, 136, 7179}, 0x6, 80, 0, 7193, 0}, - /*II_V_66_0F_38_9E*/ {{0x44, 88, 83, 136, 7207}, 0x7, 90, 0, 7221, 0}, - /*II_V_66_0F_38_9F*/ {{0x44, 81, 68, 136, 7235}, 0x6, 80, 0, 7249, 0}, - /*II_V_66_0F_38_A6*/ {{0x44, 88, 83, 136, 7263}, 0x7, 90, 0, 7279, 0}, - /*II_V_66_0F_38_A7*/ {{0x44, 88, 83, 136, 7295}, 0x7, 90, 0, 7311, 0}, - /*II_V_66_0F_38_A8*/ {{0x44, 88, 83, 136, 7327}, 0x7, 90, 0, 7340, 0}, - /*II_V_66_0F_38_A9*/ {{0x44, 81, 68, 136, 7353}, 0x6, 80, 0, 7366, 0}, - /*II_V_66_0F_38_AA*/ {{0x44, 88, 83, 136, 7379}, 0x7, 90, 0, 7392, 0}, - /*II_V_66_0F_38_AB*/ {{0x44, 81, 68, 136, 7405}, 0x6, 80, 0, 7418, 0}, - /*II_V_66_0F_38_AC*/ {{0x44, 88, 83, 136, 7431}, 0x7, 90, 0, 7445, 0}, - /*II_V_66_0F_38_AD*/ {{0x44, 81, 68, 136, 7459}, 0x6, 80, 0, 7473, 0}, - /*II_V_66_0F_38_AE*/ {{0x44, 88, 83, 136, 7487}, 0x7, 90, 0, 7501, 0}, - /*II_V_66_0F_38_AF*/ {{0x44, 81, 68, 136, 7515}, 0x6, 80, 0, 7529, 0}, - /*II_V_66_0F_38_B6*/ {{0x44, 88, 83, 136, 7543}, 0x7, 90, 0, 7559, 0}, - /*II_V_66_0F_38_B7*/ {{0x44, 88, 83, 136, 7575}, 0x7, 90, 0, 7591, 0}, - /*II_V_66_0F_38_B8*/ {{0x44, 88, 83, 136, 7607}, 0x7, 90, 0, 7620, 0}, - /*II_V_66_0F_38_B9*/ {{0x44, 81, 68, 136, 7633}, 0x6, 80, 0, 7646, 0}, - /*II_V_66_0F_38_BA*/ {{0x44, 88, 83, 136, 7659}, 0x7, 90, 0, 7672, 0}, - /*II_V_66_0F_38_BB*/ {{0x44, 81, 68, 136, 7685}, 0x6, 80, 0, 7698, 0}, - /*II_V_66_0F_38_BC*/ {{0x44, 88, 83, 136, 7711}, 0x7, 90, 0, 7725, 0}, - /*II_V_66_0F_38_BD*/ {{0x44, 81, 68, 136, 7739}, 0x6, 80, 0, 7753, 0}, - /*II_V_66_0F_38_BE*/ {{0x44, 88, 83, 136, 7767}, 0x7, 90, 0, 7781, 0}, - /*II_V_66_0F_38_BF*/ {{0x44, 81, 68, 136, 7795}, 0x6, 80, 0, 7809, 0}, - /*II_NV_66_0F_38_DB*/ {{0x45, 73, 68, 152, 7831}, 0x0, 0, 0, 0, 0}, - /*II_V_66_0F_38_DC*/ {{0x44, 81, 68, 152, 7848}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_DD*/ {{0x44, 81, 68, 152, 7869}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_DE*/ {{0x44, 81, 68, 152, 7890}, 0x0, 73, 0, 0, 0}, - /*II_V_66_0F_38_DF*/ {{0x44, 81, 68, 152, 7911}, 0x0, 73, 0, 0, 0}, - /*II_NV_66_0F_3A_04*/ {{0x44, 90, 83, 128, 6239}, 0x1, 1, 0, 0, 0}, - /*II_NV_66_0F_3A_05*/ {{0x44, 90, 83, 128, 6250}, 0x1, 1, 0, 0, 0}, - /*II_V_66_0F_3A_06*/ {{0x58, 87, 85, 128, 7938}, 0x10, 86, 1, 0, 0}, - /*II_66_0F_3A_08*/ {{0x4b, 73, 68, 72, 7950}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_3A_08*/ {{0x44, 90, 83, 128, 7959}, 0x1, 1, 0, 0, 0}, - /*II_66_0F_3A_09*/ {{0x4b, 73, 68, 72, 7969}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_3A_09*/ {{0x44, 90, 83, 128, 7978}, 0x1, 1, 0, 0, 0}, - /*II_66_0F_3A_0A*/ {{0x4b, 71, 68, 72, 7988}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_0A*/ {{0x58, 81, 68, 128, 7997}, 0x0, 71, 1, 0, 0}, - /*II_66_0F_3A_0B*/ {{0x4b, 72, 68, 72, 8007}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_0B*/ {{0x58, 81, 68, 128, 8016}, 0x0, 72, 1, 0, 0}, - /*II_66_0F_3A_0C*/ {{0x4b, 73, 68, 72, 8026}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_0C*/ {{0x58, 88, 83, 128, 8035}, 0x1, 90, 1, 0, 0}, - /*II_66_0F_3A_0D*/ {{0x4b, 73, 68, 72, 8045}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_0D*/ {{0x58, 88, 83, 128, 8054}, 0x1, 90, 1, 0, 0}, - /*II_66_0F_3A_0E*/ {{0x4b, 73, 68, 72, 8064}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_0E*/ {{0x58, 81, 68, 128, 8073}, 0x0, 73, 1, 0, 0}, - /*II_0F_3A_0F*/ {{0x4b, 67, 64, 64, 8084}, 0x0, 1, 0, 0, 0}, - /*II_66_0F_3A_0F*/ {{0x4b, 73, 68, 64, 8084}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_0F*/ {{0x58, 81, 68, 128, 8093}, 0x0, 73, 1, 0, 0}, - /*II_66_0F_3A_14*/ {{0x4b, 68, 26, 72, 8103}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_3A_14*/ {{0x5a, 68, 76, 128, 8111}, 0x0, 1, 0, 0, 0}, - /*II_66_0F_3A_15*/ {{0x4b, 68, 27, 72, 4991}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_3A_15*/ {{0x5a, 68, 77, 128, 4999}, 0x0, 1, 0, 0, 0}, - /*II_66_0F_3A_16*/ {{0x5f, 68, 18, 72, 8120}, 0x0, 1, 0, 8128, 0}, - /*II_NV_66_0F_3A_16*/ {{0x44, 68, 79, 128, 8136}, 0x2, 1, 0, 0, 0}, - /*II_66_0F_3A_17*/ {{0x4b, 68, 18, 72, 8145}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_3A_17*/ {{0x44, 68, 75, 128, 8156}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_18*/ {{0x58, 87, 85, 128, 8168}, 0x10, 73, 1, 0, 0}, - /*II_NV_66_0F_3A_19*/ {{0x44, 85, 73, 128, 8181}, 0x10, 1, 0, 0, 0}, - /*II_66_0F_3A_20*/ {{0x4b, 24, 68, 72, 8195}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_20*/ {{0x58, 81, 68, 128, 8203}, 0x0, 76, 1, 0, 0}, - /*II_66_0F_3A_21*/ {{0x4b, 71, 68, 72, 8212}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_21*/ {{0x58, 81, 68, 128, 8222}, 0x0, 71, 1, 0, 0}, - /*II_66_0F_3A_22*/ {{0x5f, 18, 68, 72, 8233}, 0x0, 1, 0, 8241, 0}, - /*II_V_66_0F_3A_22*/ {{0x58, 81, 68, 128, 8249}, 0x6, 79, 1, 8258, 0}, - /*II_66_0F_3A_40*/ {{0x4b, 73, 68, 72, 8267}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_40*/ {{0x58, 88, 83, 128, 8273}, 0x1, 90, 1, 0, 0}, - /*II_66_0F_3A_41*/ {{0x4b, 73, 68, 72, 8280}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_41*/ {{0x58, 81, 68, 128, 8286}, 0x0, 73, 1, 0, 0}, - /*II_66_0F_3A_42*/ {{0x4b, 73, 68, 72, 8293}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_42*/ {{0x58, 81, 68, 128, 8302}, 0x0, 73, 1, 0, 0}, - /*II_66_0F_3A_44*/ {{0x4b, 73, 68, 144, 8312}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_3A_44*/ {{0x58, 81, 68, 144, 8323}, 0x0, 73, 1, 0, 0}, - /*II_V_66_0F_3A_4A*/ {{0x58, 88, 83, 128, 8335}, 0x1, 90, 84, 0, 0}, - /*II_V_66_0F_3A_4B*/ {{0x58, 88, 83, 128, 8346}, 0x1, 90, 84, 0, 0}, - /*II_V_66_0F_3A_4C*/ {{0x58, 81, 68, 128, 8357}, 0x0, 73, 82, 0, 0}, - /*II_66_0F_3A_60*/ {{0x4b, 73, 68, 80, 8368}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_3A_60*/ {{0x44, 73, 68, 128, 8379}, 0x0, 1, 0, 0, 0}, - /*II_66_0F_3A_61*/ {{0x4b, 73, 68, 80, 8391}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_3A_61*/ {{0x44, 73, 68, 128, 8402}, 0x0, 1, 0, 0, 0}, - /*II_66_0F_3A_62*/ {{0x4b, 73, 68, 80, 8413}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_3A_62*/ {{0x44, 73, 68, 128, 8424}, 0x0, 1, 0, 0, 0}, - /*II_66_0F_3A_63*/ {{0x4b, 73, 68, 80, 8436}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_3A_63*/ {{0x44, 73, 68, 128, 8447}, 0x0, 1, 0, 0, 0}, - /*II_66_0F_3A_DF*/ {{0x4b, 73, 68, 152, 8459}, 0x0, 1, 0, 0, 0}, - /*II_NV_66_0F_3A_DF*/ {{0x44, 73, 68, 152, 8476}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_71_02*/ {{0x60, 69, 81, 128, 5123}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_71_04*/ {{0x60, 69, 81, 128, 5382}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_71_06*/ {{0x60, 69, 81, 128, 5696}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_72_02*/ {{0x60, 69, 81, 128, 5138}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_72_04*/ {{0x60, 69, 81, 128, 5397}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_72_06*/ {{0x60, 69, 81, 128, 5711}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_73_02*/ {{0x60, 69, 81, 128, 5153}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_73_03*/ {{0x60, 69, 81, 128, 8502}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_73_06*/ {{0x60, 69, 81, 128, 5726}, 0x0, 1, 0, 0, 0}, - /*II_V_66_0F_73_07*/ {{0x60, 69, 81, 128, 8519}, 0x0, 1, 0, 0, 0}, - /*II_NV_0F_AE_02*/ {{0x61, 0, 44, 128, 8537}, 0x0, 0, 0, 0, 0}, - /*II_NV_0F_AE_03*/ {{0x61, 0, 44, 128, 8556}, 0x0, 0, 0, 0, 0}}; - -_InstNode InstructionsTree[] = { - /* 0 - _00 */ 0x2000, - /* 1 - _01 */ 0x2001, - /* 2 - _02 */ 0x2002, - /* 3 - _03 */ 0x2003, - /* 4 - _04 */ 0x2004, - /* 5 - _05 */ 0x2005, - /* 6 - _06 */ 0x2006, - /* 7 - _07 */ 0x2007, - /* 8 - _08 */ 0x2008, - /* 9 - _09 */ 0x2009, - /* a - _0A */ 0x200a, - /* b - _0B */ 0x200b, - /* c - _0C */ 0x200c, - /* d - _0D */ 0x200d, - /* e - _0E */ 0x200e, - /* f - _0F */ 0x8100, - /* 10 - _10 */ 0x200f, - /* 11 - _11 */ 0x2010, - /* 12 - _12 */ 0x2011, - /* 13 - _13 */ 0x2012, - /* 14 - _14 */ 0x2013, - /* 15 - _15 */ 0x2014, - /* 16 - _16 */ 0x2015, - /* 17 - _17 */ 0x2016, - /* 18 - _18 */ 0x2017, - /* 19 - _19 */ 0x2018, - /* 1a - _1A */ 0x2019, - /* 1b - _1B */ 0x201a, - /* 1c - _1C */ 0x201b, - /* 1d - _1D */ 0x201c, - /* 1e - _1E */ 0x201d, - /* 1f - _1F */ 0x201e, - /* 20 - _20 */ 0x201f, - /* 21 - _21 */ 0x2020, - /* 22 - _22 */ 0x2021, - /* 23 - _23 */ 0x2022, - /* 24 - _24 */ 0x2023, - /* 25 - _25 */ 0x2024, - /* 26 - */ 0, - /* 27 - _27 */ 0x2025, - /* 28 - _28 */ 0x2026, - /* 29 - _29 */ 0x2027, - /* 2a - _2A */ 0x2028, - /* 2b - _2B */ 0x2029, - /* 2c - _2C */ 0x202a, - /* 2d - _2D */ 0x202b, - /* 2e - */ 0, - /* 2f - _2F */ 0x202c, - /* 30 - _30 */ 0x202d, - /* 31 - _31 */ 0x202e, - /* 32 - _32 */ 0x202f, - /* 33 - _33 */ 0x2030, - /* 34 - _34 */ 0x2031, - /* 35 - _35 */ 0x2032, - /* 36 - */ 0, - /* 37 - _37 */ 0x2033, - /* 38 - _38 */ 0x2034, - /* 39 - _39 */ 0x2035, - /* 3a - _3A */ 0x2036, - /* 3b - _3B */ 0x2037, - /* 3c - _3C */ 0x2038, - /* 3d - _3D */ 0x2039, - /* 3e - */ 0, - /* 3f - _3F */ 0x203a, - /* 40 - _40 */ 0x203b, - /* 41 - _40 */ 0x203c, - /* 42 - _40 */ 0x203d, - /* 43 - _40 */ 0x203e, - /* 44 - _40 */ 0x203f, - /* 45 - _40 */ 0x2040, - /* 46 - _40 */ 0x2041, - /* 47 - _40 */ 0x2042, - /* 48 - _48 */ 0x2043, - /* 49 - _48 */ 0x2044, - /* 4a - _48 */ 0x2045, - /* 4b - _48 */ 0x2046, - /* 4c - _48 */ 0x2047, - /* 4d - _48 */ 0x2048, - /* 4e - _48 */ 0x2049, - /* 4f - _48 */ 0x204a, - /* 50 - _50 */ 0x204b, - /* 51 - _50 */ 0x204c, - /* 52 - _50 */ 0x204d, - /* 53 - _50 */ 0x204e, - /* 54 - _50 */ 0x204f, - /* 55 - _50 */ 0x2050, - /* 56 - _50 */ 0x2051, - /* 57 - _50 */ 0x2052, - /* 58 - _58 */ 0x2053, - /* 59 - _58 */ 0x2054, - /* 5a - _58 */ 0x2055, - /* 5b - _58 */ 0x2056, - /* 5c - _58 */ 0x2057, - /* 5d - _58 */ 0x2058, - /* 5e - _58 */ 0x2059, - /* 5f - _58 */ 0x205a, - /* 60 - _60 */ 0x205b, - /* 61 - _61 */ 0x205c, - /* 62 - _62 */ 0x205d, - /* 63 - _63 */ 0x205e, - /* 64 - */ 0, - /* 65 - */ 0, - /* 66 - */ 0, - /* 67 - */ 0, - /* 68 - _68 */ 0x205f, - /* 69 - _69 */ 0x4000, - /* 6a - _6A */ 0x2060, - /* 6b - _6B */ 0x4001, - /* 6c - _6C */ 0x2061, - /* 6d - _6D */ 0x2062, - /* 6e - _6E */ 0x2063, - /* 6f - _6F */ 0x2064, - /* 70 - _70 */ 0x2065, - /* 71 - _71 */ 0x2066, - /* 72 - _72 */ 0x2067, - /* 73 - _73 */ 0x2068, - /* 74 - _74 */ 0x2069, - /* 75 - _75 */ 0x206a, - /* 76 - _76 */ 0x206b, - /* 77 - _77 */ 0x206c, - /* 78 - _78 */ 0x206d, - /* 79 - _79 */ 0x206e, - /* 7a - _7A */ 0x206f, - /* 7b - _7B */ 0x2070, - /* 7c - _7C */ 0x2071, - /* 7d - _7D */ 0x2072, - /* 7e - _7E */ 0x2073, - /* 7f - _7F */ 0x2074, - /* 80 - _80 */ 0x6200, - /* 81 - _81 */ 0x6208, - /* 82 - _82 */ 0x6210, - /* 83 - _83 */ 0x6218, - /* 84 - _84 */ 0x2075, - /* 85 - _85 */ 0x2076, - /* 86 - _86 */ 0x2077, - /* 87 - _87 */ 0x2078, - /* 88 - _88 */ 0x2079, - /* 89 - _89 */ 0x207a, - /* 8a - _8A */ 0x207b, - /* 8b - _8B */ 0x207c, - /* 8c - _8C */ 0x207d, - /* 8d - _8D */ 0x207e, - /* 8e - _8E */ 0x207f, - /* 8f - _8F */ 0x6220, - /* 90 - _90 */ 0x2080, - /* 91 - _91 */ 0x2081, - /* 92 - _92 */ 0x2082, - /* 93 - _93 */ 0x2083, - /* 94 - _94 */ 0x2084, - /* 95 - _95 */ 0x2085, - /* 96 - _96 */ 0x2086, - /* 97 - _97 */ 0x2087, - /* 98 - _98 */ 0x4002, - /* 99 - _99 */ 0x4003, - /* 9a - _9A */ 0x2088, - /* 9b - */ 0, - /* 9c - _9C */ 0x2089, - /* 9d - _9D */ 0x208a, - /* 9e - _9E */ 0x208b, - /* 9f - _9F */ 0x208c, - /* a0 - _A0 */ 0x208d, - /* a1 - _A1 */ 0x208e, - /* a2 - _A2 */ 0x208f, - /* a3 - _A3 */ 0x2090, - /* a4 - _A4 */ 0x2091, - /* a5 - _A5 */ 0x2092, - /* a6 - _A6 */ 0x2093, - /* a7 - _A7 */ 0x2094, - /* a8 - _A8 */ 0x2095, - /* a9 - _A9 */ 0x2096, - /* aa - _AA */ 0x2097, - /* ab - _AB */ 0x2098, - /* ac - _AC */ 0x2099, - /* ad - _AD */ 0x209a, - /* ae - _AE */ 0x209b, - /* af - _AF */ 0x209c, - /* b0 - _B0 */ 0x209d, - /* b1 - _B0 */ 0x209e, - /* b2 - _B0 */ 0x209f, - /* b3 - _B0 */ 0x20a0, - /* b4 - _B0 */ 0x20a1, - /* b5 - _B0 */ 0x20a2, - /* b6 - _B0 */ 0x20a3, - /* b7 - _B0 */ 0x20a4, - /* b8 - _B8 */ 0x20a5, - /* b9 - _B8 */ 0x20a6, - /* ba - _B8 */ 0x20a7, - /* bb - _B8 */ 0x20a8, - /* bc - _B8 */ 0x20a9, - /* bd - _B8 */ 0x20aa, - /* be - _B8 */ 0x20ab, - /* bf - _B8 */ 0x20ac, - /* c0 - _C0 */ 0x6228, - /* c1 - _C1 */ 0x6230, - /* c2 - _C2 */ 0x20ad, - /* c3 - _C3 */ 0x20ae, - /* c4 - _C4 */ 0x20af, - /* c5 - _C5 */ 0x20b0, - /* c6 - _C6 */ 0x6238, - /* c7 - _C7 */ 0x6240, - /* c8 - _C8 */ 0x20b1, - /* c9 - _C9 */ 0x20b2, - /* ca - _CA */ 0x20b3, - /* cb - _CB */ 0x20b4, - /* cc - _CC */ 0x20b5, - /* cd - _CD */ 0x20b6, - /* ce - _CE */ 0x20b7, - /* cf - _CF */ 0x20b8, - /* d0 - _D0 */ 0x6248, - /* d1 - _D1 */ 0x6250, - /* d2 - _D2 */ 0x6258, - /* d3 - _D3 */ 0x6260, - /* d4 - _D4 */ 0x20b9, - /* d5 - _D5 */ 0x20ba, - /* d6 - _D6 */ 0x20bb, - /* d7 - _D7 */ 0x20bc, - /* d8 - _D8 */ 0xa268, - /* d9 - _D9 */ 0xa2b0, - /* da - _DA */ 0xa2f8, - /* db - _DB */ 0xa340, - /* dc - _DC */ 0xa388, - /* dd - _DD */ 0xa3d0, - /* de - _DE */ 0xa418, - /* df - _DF */ 0xa460, - /* e0 - _E0 */ 0x20bd, - /* e1 - _E1 */ 0x20be, - /* e2 - _E2 */ 0x20bf, - /* e3 - _E3 */ 0x4004, - /* e4 - _E4 */ 0x20c0, - /* e5 - _E5 */ 0x20c1, - /* e6 - _E6 */ 0x20c2, - /* e7 - _E7 */ 0x20c3, - /* e8 - _E8 */ 0x20c4, - /* e9 - _E9 */ 0x20c5, - /* ea - _EA */ 0x20c6, - /* eb - _EB */ 0x20c7, - /* ec - _EC */ 0x20c8, - /* ed - _ED */ 0x20c9, - /* ee - _EE */ 0x20ca, - /* ef - _EF */ 0x20cb, - /* f0 - */ 0, - /* f1 - _F1 */ 0x20cc, - /* f2 - */ 0, - /* f3 - */ 0, - /* f4 - _F4 */ 0x20cd, - /* f5 - _F5 */ 0x20ce, - /* f6 - _F6 */ 0x64a8, - /* f7 - _F7 */ 0x64b0, - /* f8 - _F8 */ 0x20cf, - /* f9 - _F9 */ 0x20d0, - /* fa - _FA */ 0x20d1, - /* fb - _FB */ 0x20d2, - /* fc - _FC */ 0x20d3, - /* fd - _FD */ 0x20d4, - /* fe - _FE */ 0x64b8, - /* ff - _FF */ 0x64c0, - /* 100 - _0F_00 */ 0x64c8, - /* 101 - _0F_01 */ 0xa4d0, - /* 102 - _0F_02 */ 0x20d5, - /* 103 - _0F_03 */ 0x20d6, - /* 104 - */ 0, - /* 105 - _0F_05 */ 0x20d7, - /* 106 - _0F_06 */ 0x20d8, - /* 107 - _0F_07 */ 0x20d9, - /* 108 - _0F_08 */ 0x20da, - /* 109 - _0F_09 */ 0x20db, - /* 10a - */ 0, - /* 10b - _0F_0B */ 0x20dc, - /* 10c - */ 0, - /* 10d - _0F_0D */ 0x6518, - /* 10e - _0F_0E */ 0x20dd, - /* 10f - _0F_0F */ 0x8520, - /* 110 - _0F_10 */ 0xc620, - /* 111 - _0F_11 */ 0xc62c, - /* 112 - _0F_12 */ 0xc638, - /* 113 - _0F_13 */ 0xc644, - /* 114 - _0F_14 */ 0xc650, - /* 115 - _0F_15 */ 0xc65c, - /* 116 - _0F_16 */ 0xc668, - /* 117 - _0F_17 */ 0xc674, - /* 118 - _0F_18 */ 0x6680, - /* 119 - */ 0, - /* 11a - */ 0, - /* 11b - */ 0, - /* 11c - */ 0, - /* 11d - */ 0, - /* 11e - */ 0, - /* 11f - _0F_1F */ 0x20de, - /* 120 - _0F_20 */ 0x20df, - /* 121 - _0F_21 */ 0x20e0, - /* 122 - _0F_22 */ 0x20e1, - /* 123 - _0F_23 */ 0x20e2, - /* 124 - */ 0, - /* 125 - */ 0, - /* 126 - */ 0, - /* 127 - */ 0, - /* 128 - _0F_28 */ 0xc688, - /* 129 - _0F_29 */ 0xc694, - /* 12a - _0F_2A */ 0xc6a0, - /* 12b - _0F_2B */ 0xc6ac, - /* 12c - _0F_2C */ 0xc6b8, - /* 12d - _0F_2D */ 0xc6c4, - /* 12e - _0F_2E */ 0xc6d0, - /* 12f - _0F_2F */ 0xc6dc, - /* 130 - _0F_30 */ 0x20e3, - /* 131 - _0F_31 */ 0x20e4, - /* 132 - _0F_32 */ 0x20e5, - /* 133 - _0F_33 */ 0x20e6, - /* 134 - _0F_34 */ 0x20e7, - /* 135 - _0F_35 */ 0x20e8, - /* 136 - */ 0, - /* 137 - _0F_37 */ 0x20e9, - /* 138 - _0F_38 */ 0x86e8, - /* 139 - */ 0, - /* 13a - _0F_3A */ 0x87e8, - /* 13b - */ 0, - /* 13c - */ 0, - /* 13d - */ 0, - /* 13e - */ 0, - /* 13f - */ 0, - /* 140 - _0F_40 */ 0x20ea, - /* 141 - _0F_41 */ 0x20eb, - /* 142 - _0F_42 */ 0x20ec, - /* 143 - _0F_43 */ 0x20ed, - /* 144 - _0F_44 */ 0x20ee, - /* 145 - _0F_45 */ 0x20ef, - /* 146 - _0F_46 */ 0x20f0, - /* 147 - _0F_47 */ 0x20f1, - /* 148 - _0F_48 */ 0x20f2, - /* 149 - _0F_49 */ 0x20f3, - /* 14a - _0F_4A */ 0x20f4, - /* 14b - _0F_4B */ 0x20f5, - /* 14c - _0F_4C */ 0x20f6, - /* 14d - _0F_4D */ 0x20f7, - /* 14e - _0F_4E */ 0x20f8, - /* 14f - _0F_4F */ 0x20f9, - /* 150 - _0F_50 */ 0xc8e8, - /* 151 - _0F_51 */ 0xc8f4, - /* 152 - _0F_52 */ 0xc900, - /* 153 - _0F_53 */ 0xc90c, - /* 154 - _0F_54 */ 0xc918, - /* 155 - _0F_55 */ 0xc924, - /* 156 - _0F_56 */ 0xc930, - /* 157 - _0F_57 */ 0xc93c, - /* 158 - _0F_58 */ 0xc948, - /* 159 - _0F_59 */ 0xc954, - /* 15a - _0F_5A */ 0xc960, - /* 15b - _0F_5B */ 0xc96c, - /* 15c - _0F_5C */ 0xc978, - /* 15d - _0F_5D */ 0xc984, - /* 15e - _0F_5E */ 0xc990, - /* 15f - _0F_5F */ 0xc99c, - /* 160 - _0F_60 */ 0xc9a8, - /* 161 - _0F_61 */ 0xc9b4, - /* 162 - _0F_62 */ 0xc9c0, - /* 163 - _0F_63 */ 0xc9cc, - /* 164 - _0F_64 */ 0xc9d8, - /* 165 - _0F_65 */ 0xc9e4, - /* 166 - _0F_66 */ 0xc9f0, - /* 167 - _0F_67 */ 0xc9fc, - /* 168 - _0F_68 */ 0xca08, - /* 169 - _0F_69 */ 0xca14, - /* 16a - _0F_6A */ 0xca20, - /* 16b - _0F_6B */ 0xca2c, - /* 16c - _0F_6C */ 0xca38, - /* 16d - _0F_6D */ 0xca44, - /* 16e - _0F_6E */ 0xca50, - /* 16f - _0F_6F */ 0xca5c, - /* 170 - _0F_70 */ 0xca68, - /* 171 - _0F_71 */ 0x6a74, - /* 172 - _0F_72 */ 0x6a7c, - /* 173 - _0F_73 */ 0x6a84, - /* 174 - _0F_74 */ 0xca8c, - /* 175 - _0F_75 */ 0xca98, - /* 176 - _0F_76 */ 0xcaa4, - /* 177 - _0F_77 */ 0xcab0, - /* 178 - _0F_78 */ 0xcabc, - /* 179 - _0F_79 */ 0xcac8, - /* 17a - */ 0, - /* 17b - */ 0, - /* 17c - _0F_7C */ 0xcad4, - /* 17d - _0F_7D */ 0xcae0, - /* 17e - _0F_7E */ 0xcaec, - /* 17f - _0F_7F */ 0xcaf8, - /* 180 - _0F_80 */ 0x20fa, - /* 181 - _0F_81 */ 0x20fb, - /* 182 - _0F_82 */ 0x20fc, - /* 183 - _0F_83 */ 0x20fd, - /* 184 - _0F_84 */ 0x20fe, - /* 185 - _0F_85 */ 0x20ff, - /* 186 - _0F_86 */ 0x2100, - /* 187 - _0F_87 */ 0x2101, - /* 188 - _0F_88 */ 0x2102, - /* 189 - _0F_89 */ 0x2103, - /* 18a - _0F_8A */ 0x2104, - /* 18b - _0F_8B */ 0x2105, - /* 18c - _0F_8C */ 0x2106, - /* 18d - _0F_8D */ 0x2107, - /* 18e - _0F_8E */ 0x2108, - /* 18f - _0F_8F */ 0x2109, - /* 190 - _0F_90 */ 0x210a, - /* 191 - _0F_91 */ 0x210b, - /* 192 - _0F_92 */ 0x210c, - /* 193 - _0F_93 */ 0x210d, - /* 194 - _0F_94 */ 0x210e, - /* 195 - _0F_95 */ 0x210f, - /* 196 - _0F_96 */ 0x2110, - /* 197 - _0F_97 */ 0x2111, - /* 198 - _0F_98 */ 0x2112, - /* 199 - _0F_99 */ 0x2113, - /* 19a - _0F_9A */ 0x2114, - /* 19b - _0F_9B */ 0x2115, - /* 19c - _0F_9C */ 0x2116, - /* 19d - _0F_9D */ 0x2117, - /* 19e - _0F_9E */ 0x2118, - /* 19f - _0F_9F */ 0x2119, - /* 1a0 - _0F_A0 */ 0x211a, - /* 1a1 - _0F_A1 */ 0x211b, - /* 1a2 - _0F_A2 */ 0x211c, - /* 1a3 - _0F_A3 */ 0x211d, - /* 1a4 - _0F_A4 */ 0x4005, - /* 1a5 - _0F_A5 */ 0x4006, - /* 1a6 - */ 0, - /* 1a7 - */ 0, - /* 1a8 - _0F_A8 */ 0x211e, - /* 1a9 - _0F_A9 */ 0x211f, - /* 1aa - _0F_AA */ 0x2120, - /* 1ab - _0F_AB */ 0x2121, - /* 1ac - _0F_AC */ 0x4007, - /* 1ad - _0F_AD */ 0x4008, - /* 1ae - _0F_AE */ 0x6b04, - /* 1af - _0F_AF */ 0x2122, - /* 1b0 - _0F_B0 */ 0x2123, - /* 1b1 - _0F_B1 */ 0x2124, - /* 1b2 - _0F_B2 */ 0x2125, - /* 1b3 - _0F_B3 */ 0x2126, - /* 1b4 - _0F_B4 */ 0x2127, - /* 1b5 - _0F_B5 */ 0x2128, - /* 1b6 - _0F_B6 */ 0x2129, - /* 1b7 - _0F_B7 */ 0x212a, - /* 1b8 - _0F_B8 */ 0xcb0c, - /* 1b9 - _0F_B9 */ 0x212b, - /* 1ba - _0F_BA */ 0x6b18, - /* 1bb - _0F_BB */ 0x212c, - /* 1bc - _0F_BC */ 0x212d, - /* 1bd - _0F_BD */ 0x240a, - /* 1be - _0F_BE */ 0x212e, - /* 1bf - _0F_BF */ 0x212f, - /* 1c0 - _0F_C0 */ 0x2130, - /* 1c1 - _0F_C1 */ 0x2131, - /* 1c2 - _0F_C2 */ 0xcb2c, - /* 1c3 - _0F_C3 */ 0x2132, - /* 1c4 - _0F_C4 */ 0xcb38, - /* 1c5 - _0F_C5 */ 0xcb44, - /* 1c6 - _0F_C6 */ 0xcb50, - /* 1c7 - _0F_C7 */ 0x6b5c, - /* 1c8 - _0F_C8 */ 0x2133, - /* 1c9 - _0F_C8 */ 0x2134, - /* 1ca - _0F_C8 */ 0x2135, - /* 1cb - _0F_C8 */ 0x2136, - /* 1cc - _0F_C8 */ 0x2137, - /* 1cd - _0F_C8 */ 0x2138, - /* 1ce - _0F_C8 */ 0x2139, - /* 1cf - _0F_C8 */ 0x213a, - /* 1d0 - _0F_D0 */ 0xcb64, - /* 1d1 - _0F_D1 */ 0xcb70, - /* 1d2 - _0F_D2 */ 0xcb7c, - /* 1d3 - _0F_D3 */ 0xcb88, - /* 1d4 - _0F_D4 */ 0xcb94, - /* 1d5 - _0F_D5 */ 0xcba0, - /* 1d6 - _0F_D6 */ 0xcbac, - /* 1d7 - _0F_D7 */ 0xcbb8, - /* 1d8 - _0F_D8 */ 0xcbc4, - /* 1d9 - _0F_D9 */ 0xcbd0, - /* 1da - _0F_DA */ 0xcbdc, - /* 1db - _0F_DB */ 0xcbe8, - /* 1dc - _0F_DC */ 0xcbf4, - /* 1dd - _0F_DD */ 0xcc00, - /* 1de - _0F_DE */ 0xcc0c, - /* 1df - _0F_DF */ 0xcc18, - /* 1e0 - _0F_E0 */ 0xcc24, - /* 1e1 - _0F_E1 */ 0xcc30, - /* 1e2 - _0F_E2 */ 0xcc3c, - /* 1e3 - _0F_E3 */ 0xcc48, - /* 1e4 - _0F_E4 */ 0xcc54, - /* 1e5 - _0F_E5 */ 0xcc60, - /* 1e6 - _0F_E6 */ 0xcc6c, - /* 1e7 - _0F_E7 */ 0xcc78, - /* 1e8 - _0F_E8 */ 0xcc84, - /* 1e9 - _0F_E9 */ 0xcc90, - /* 1ea - _0F_EA */ 0xcc9c, - /* 1eb - _0F_EB */ 0xcca8, - /* 1ec - _0F_EC */ 0xccb4, - /* 1ed - _0F_ED */ 0xccc0, - /* 1ee - _0F_EE */ 0xcccc, - /* 1ef - _0F_EF */ 0xccd8, - /* 1f0 - _0F_F0 */ 0xcce4, - /* 1f1 - _0F_F1 */ 0xccf0, - /* 1f2 - _0F_F2 */ 0xccfc, - /* 1f3 - _0F_F3 */ 0xcd08, - /* 1f4 - _0F_F4 */ 0xcd14, - /* 1f5 - _0F_F5 */ 0xcd20, - /* 1f6 - _0F_F6 */ 0xcd2c, - /* 1f7 - _0F_F7 */ 0xcd38, - /* 1f8 - _0F_F8 */ 0xcd44, - /* 1f9 - _0F_F9 */ 0xcd50, - /* 1fa - _0F_FA */ 0xcd5c, - /* 1fb - _0F_FB */ 0xcd68, - /* 1fc - _0F_FC */ 0xcd74, - /* 1fd - _0F_FD */ 0xcd80, - /* 1fe - _0F_FE */ 0xcd8c, - /* 1ff - */ 0, - /* 200 - _80_00 */ 0x213b, - /* 201 - _80_01 */ 0x213c, - /* 202 - _80_02 */ 0x213d, - /* 203 - _80_03 */ 0x213e, - /* 204 - _80_04 */ 0x213f, - /* 205 - _80_05 */ 0x2140, - /* 206 - _80_06 */ 0x2141, - /* 207 - _80_07 */ 0x2142, - /* 208 - _81_00 */ 0x2143, - /* 209 - _81_01 */ 0x2144, - /* 20a - _81_02 */ 0x2145, - /* 20b - _81_03 */ 0x2146, - /* 20c - _81_04 */ 0x2147, - /* 20d - _81_05 */ 0x2148, - /* 20e - _81_06 */ 0x2149, - /* 20f - _81_07 */ 0x214a, - /* 210 - _82_00 */ 0x214b, - /* 211 - _82_01 */ 0x214c, - /* 212 - _82_02 */ 0x214d, - /* 213 - _82_03 */ 0x214e, - /* 214 - _82_04 */ 0x214f, - /* 215 - _82_05 */ 0x2150, - /* 216 - _82_06 */ 0x2151, - /* 217 - _82_07 */ 0x2152, - /* 218 - _83_00 */ 0x2153, - /* 219 - _83_01 */ 0x2154, - /* 21a - _83_02 */ 0x2155, - /* 21b - _83_03 */ 0x2156, - /* 21c - _83_04 */ 0x2157, - /* 21d - _83_05 */ 0x2158, - /* 21e - _83_06 */ 0x2159, - /* 21f - _83_07 */ 0x215a, - /* 220 - _8F_00 */ 0x215b, - /* 221 - */ 0, - /* 222 - */ 0, - /* 223 - */ 0, - /* 224 - */ 0, - /* 225 - */ 0, - /* 226 - */ 0, - /* 227 - */ 0, - /* 228 - _C0_00 */ 0x215c, - /* 229 - _C0_01 */ 0x215d, - /* 22a - _C0_02 */ 0x215e, - /* 22b - _C0_03 */ 0x215f, - /* 22c - _C0_04 */ 0x2160, - /* 22d - _C0_05 */ 0x2161, - /* 22e - _C0_06 */ 0x2162, - /* 22f - _C0_07 */ 0x2163, - /* 230 - _C1_00 */ 0x2164, - /* 231 - _C1_01 */ 0x2165, - /* 232 - _C1_02 */ 0x2166, - /* 233 - _C1_03 */ 0x2167, - /* 234 - _C1_04 */ 0x2168, - /* 235 - _C1_05 */ 0x2169, - /* 236 - _C1_06 */ 0x216a, - /* 237 - _C1_07 */ 0x216b, - /* 238 - _C6_00 */ 0x216c, - /* 239 - */ 0, - /* 23a - */ 0, - /* 23b - */ 0, - /* 23c - */ 0, - /* 23d - */ 0, - /* 23e - */ 0, - /* 23f - */ 0, - /* 240 - _C7_00 */ 0x216d, - /* 241 - */ 0, - /* 242 - */ 0, - /* 243 - */ 0, - /* 244 - */ 0, - /* 245 - */ 0, - /* 246 - */ 0, - /* 247 - */ 0, - /* 248 - _D0_00 */ 0x216e, - /* 249 - _D0_01 */ 0x216f, - /* 24a - _D0_02 */ 0x2170, - /* 24b - _D0_03 */ 0x2171, - /* 24c - _D0_04 */ 0x2172, - /* 24d - _D0_05 */ 0x2173, - /* 24e - _D0_06 */ 0x2174, - /* 24f - _D0_07 */ 0x2175, - /* 250 - _D1_00 */ 0x2176, - /* 251 - _D1_01 */ 0x2177, - /* 252 - _D1_02 */ 0x2178, - /* 253 - _D1_03 */ 0x2179, - /* 254 - _D1_04 */ 0x217a, - /* 255 - _D1_05 */ 0x217b, - /* 256 - _D1_06 */ 0x217c, - /* 257 - _D1_07 */ 0x217d, - /* 258 - _D2_00 */ 0x217e, - /* 259 - _D2_01 */ 0x217f, - /* 25a - _D2_02 */ 0x2180, - /* 25b - _D2_03 */ 0x2181, - /* 25c - _D2_04 */ 0x2182, - /* 25d - _D2_05 */ 0x2183, - /* 25e - _D2_06 */ 0x2184, - /* 25f - _D2_07 */ 0x2185, - /* 260 - _D3_00 */ 0x2186, - /* 261 - _D3_01 */ 0x2187, - /* 262 - _D3_02 */ 0x2188, - /* 263 - _D3_03 */ 0x2189, - /* 264 - _D3_04 */ 0x218a, - /* 265 - _D3_05 */ 0x218b, - /* 266 - _D3_06 */ 0x218c, - /* 267 - _D3_07 */ 0x218d, - /* 268 - _D8_00 */ 0x218e, - /* 269 - _D8_01 */ 0x218f, - /* 26a - _D8_02 */ 0x2190, - /* 26b - _D8_03 */ 0x2191, - /* 26c - _D8_04 */ 0x2192, - /* 26d - _D8_05 */ 0x2193, - /* 26e - _D8_06 */ 0x2194, - /* 26f - _D8_07 */ 0x2195, - /* 270 - _D8_C0 */ 0x2196, - /* 271 - _D8_C0 */ 0x2197, - /* 272 - _D8_C0 */ 0x2198, - /* 273 - _D8_C0 */ 0x2199, - /* 274 - _D8_C0 */ 0x219a, - /* 275 - _D8_C0 */ 0x219b, - /* 276 - _D8_C0 */ 0x219c, - /* 277 - _D8_C0 */ 0x219d, - /* 278 - _D8_C8 */ 0x219e, - /* 279 - _D8_C8 */ 0x219f, - /* 27a - _D8_C8 */ 0x21a0, - /* 27b - _D8_C8 */ 0x21a1, - /* 27c - _D8_C8 */ 0x21a2, - /* 27d - _D8_C8 */ 0x21a3, - /* 27e - _D8_C8 */ 0x21a4, - /* 27f - _D8_C8 */ 0x21a5, - /* 280 - _D8_D0 */ 0x21a6, - /* 281 - _D8_D0 */ 0x21a7, - /* 282 - _D8_D0 */ 0x21a8, - /* 283 - _D8_D0 */ 0x21a9, - /* 284 - _D8_D0 */ 0x21aa, - /* 285 - _D8_D0 */ 0x21ab, - /* 286 - _D8_D0 */ 0x21ac, - /* 287 - _D8_D0 */ 0x21ad, - /* 288 - _D8_D8 */ 0x21ae, - /* 289 - _D8_D9 */ 0x21af, - /* 28a - _D8_D8 */ 0x21b0, - /* 28b - _D8_D8 */ 0x21b1, - /* 28c - _D8_D8 */ 0x21b2, - /* 28d - _D8_D8 */ 0x21b3, - /* 28e - _D8_D8 */ 0x21b4, - /* 28f - _D8_D8 */ 0x21b5, - /* 290 - _D8_E0 */ 0x21b6, - /* 291 - _D8_E0 */ 0x21b7, - /* 292 - _D8_E0 */ 0x21b8, - /* 293 - _D8_E0 */ 0x21b9, - /* 294 - _D8_E0 */ 0x21ba, - /* 295 - _D8_E0 */ 0x21bb, - /* 296 - _D8_E0 */ 0x21bc, - /* 297 - _D8_E0 */ 0x21bd, - /* 298 - _D8_E8 */ 0x21be, - /* 299 - _D8_E8 */ 0x21bf, - /* 29a - _D8_E8 */ 0x21c0, - /* 29b - _D8_E8 */ 0x21c1, - /* 29c - _D8_E8 */ 0x21c2, - /* 29d - _D8_E8 */ 0x21c3, - /* 29e - _D8_E8 */ 0x21c4, - /* 29f - _D8_E8 */ 0x21c5, - /* 2a0 - _D8_F0 */ 0x21c6, - /* 2a1 - _D8_F0 */ 0x21c7, - /* 2a2 - _D8_F0 */ 0x21c8, - /* 2a3 - _D8_F0 */ 0x21c9, - /* 2a4 - _D8_F0 */ 0x21ca, - /* 2a5 - _D8_F0 */ 0x21cb, - /* 2a6 - _D8_F0 */ 0x21cc, - /* 2a7 - _D8_F0 */ 0x21cd, - /* 2a8 - _D8_F8 */ 0x21ce, - /* 2a9 - _D8_F8 */ 0x21cf, - /* 2aa - _D8_F8 */ 0x21d0, - /* 2ab - _D8_F8 */ 0x21d1, - /* 2ac - _D8_F8 */ 0x21d2, - /* 2ad - _D8_F8 */ 0x21d3, - /* 2ae - _D8_F8 */ 0x21d4, - /* 2af - _D8_F8 */ 0x21d5, - /* 2b0 - _D9_00 */ 0x21d6, - /* 2b1 - */ 0, - /* 2b2 - _D9_02 */ 0x21d7, - /* 2b3 - _D9_03 */ 0x21d8, - /* 2b4 - _D9_04 */ 0x21d9, - /* 2b5 - _D9_05 */ 0x21da, - /* 2b6 - _D9_06 */ 0xcd98, - /* 2b7 - _D9_07 */ 0xcda4, - /* 2b8 - _D9_C0 */ 0x21db, - /* 2b9 - _D9_C0 */ 0x21dc, - /* 2ba - _D9_C0 */ 0x21dd, - /* 2bb - _D9_C0 */ 0x21de, - /* 2bc - _D9_C0 */ 0x21df, - /* 2bd - _D9_C0 */ 0x21e0, - /* 2be - _D9_C0 */ 0x21e1, - /* 2bf - _D9_C0 */ 0x21e2, - /* 2c0 - _D9_C8 */ 0x21e3, - /* 2c1 - _D9_C9 */ 0x21e4, - /* 2c2 - _D9_C8 */ 0x21e5, - /* 2c3 - _D9_C8 */ 0x21e6, - /* 2c4 - _D9_C8 */ 0x21e7, - /* 2c5 - _D9_C8 */ 0x21e8, - /* 2c6 - _D9_C8 */ 0x21e9, - /* 2c7 - _D9_C8 */ 0x21ea, - /* 2c8 - _D9_D0 */ 0x21eb, - /* 2c9 - */ 0, - /* 2ca - */ 0, - /* 2cb - */ 0, - /* 2cc - */ 0, - /* 2cd - */ 0, - /* 2ce - */ 0, - /* 2cf - */ 0, - /* 2d0 - */ 0, - /* 2d1 - */ 0, - /* 2d2 - */ 0, - /* 2d3 - */ 0, - /* 2d4 - */ 0, - /* 2d5 - */ 0, - /* 2d6 - */ 0, - /* 2d7 - */ 0, - /* 2d8 - _D9_E0 */ 0x21ec, - /* 2d9 - _D9_E1 */ 0x21ed, - /* 2da - */ 0, - /* 2db - */ 0, - /* 2dc - _D9_E4 */ 0x21ee, - /* 2dd - _D9_E5 */ 0x21ef, - /* 2de - */ 0, - /* 2df - */ 0, - /* 2e0 - _D9_E8 */ 0x21f0, - /* 2e1 - _D9_E9 */ 0x21f1, - /* 2e2 - _D9_EA */ 0x21f2, - /* 2e3 - _D9_EB */ 0x21f3, - /* 2e4 - _D9_EC */ 0x21f4, - /* 2e5 - _D9_ED */ 0x21f5, - /* 2e6 - _D9_EE */ 0x21f6, - /* 2e7 - */ 0, - /* 2e8 - _D9_F0 */ 0x21f7, - /* 2e9 - _D9_F1 */ 0x21f8, - /* 2ea - _D9_F2 */ 0x21f9, - /* 2eb - _D9_F3 */ 0x21fa, - /* 2ec - _D9_F4 */ 0x21fb, - /* 2ed - _D9_F5 */ 0x21fc, - /* 2ee - _D9_F6 */ 0x21fd, - /* 2ef - _D9_F7 */ 0x21fe, - /* 2f0 - _D9_F8 */ 0x21ff, - /* 2f1 - _D9_F9 */ 0x2200, - /* 2f2 - _D9_FA */ 0x2201, - /* 2f3 - _D9_FB */ 0x2202, - /* 2f4 - _D9_FC */ 0x2203, - /* 2f5 - _D9_FD */ 0x2204, - /* 2f6 - _D9_FE */ 0x2205, - /* 2f7 - _D9_FF */ 0x2206, - /* 2f8 - _DA_00 */ 0x2207, - /* 2f9 - _DA_01 */ 0x2208, - /* 2fa - _DA_02 */ 0x2209, - /* 2fb - _DA_03 */ 0x220a, - /* 2fc - _DA_04 */ 0x220b, - /* 2fd - _DA_05 */ 0x220c, - /* 2fe - _DA_06 */ 0x220d, - /* 2ff - _DA_07 */ 0x220e, - /* 300 - _DA_C0 */ 0x220f, - /* 301 - _DA_C0 */ 0x2210, - /* 302 - _DA_C0 */ 0x2211, - /* 303 - _DA_C0 */ 0x2212, - /* 304 - _DA_C0 */ 0x2213, - /* 305 - _DA_C0 */ 0x2214, - /* 306 - _DA_C0 */ 0x2215, - /* 307 - _DA_C0 */ 0x2216, - /* 308 - _DA_C8 */ 0x2217, - /* 309 - _DA_C8 */ 0x2218, - /* 30a - _DA_C8 */ 0x2219, - /* 30b - _DA_C8 */ 0x221a, - /* 30c - _DA_C8 */ 0x221b, - /* 30d - _DA_C8 */ 0x221c, - /* 30e - _DA_C8 */ 0x221d, - /* 30f - _DA_C8 */ 0x221e, - /* 310 - _DA_D0 */ 0x221f, - /* 311 - _DA_D0 */ 0x2220, - /* 312 - _DA_D0 */ 0x2221, - /* 313 - _DA_D0 */ 0x2222, - /* 314 - _DA_D0 */ 0x2223, - /* 315 - _DA_D0 */ 0x2224, - /* 316 - _DA_D0 */ 0x2225, - /* 317 - _DA_D0 */ 0x2226, - /* 318 - _DA_D8 */ 0x2227, - /* 319 - _DA_D8 */ 0x2228, - /* 31a - _DA_D8 */ 0x2229, - /* 31b - _DA_D8 */ 0x222a, - /* 31c - _DA_D8 */ 0x222b, - /* 31d - _DA_D8 */ 0x222c, - /* 31e - _DA_D8 */ 0x222d, - /* 31f - _DA_D8 */ 0x222e, - /* 320 - */ 0, - /* 321 - */ 0, - /* 322 - */ 0, - /* 323 - */ 0, - /* 324 - */ 0, - /* 325 - */ 0, - /* 326 - */ 0, - /* 327 - */ 0, - /* 328 - */ 0, - /* 329 - _DA_E9 */ 0x222f, - /* 32a - */ 0, - /* 32b - */ 0, - /* 32c - */ 0, - /* 32d - */ 0, - /* 32e - */ 0, - /* 32f - */ 0, - /* 330 - */ 0, - /* 331 - */ 0, - /* 332 - */ 0, - /* 333 - */ 0, - /* 334 - */ 0, - /* 335 - */ 0, - /* 336 - */ 0, - /* 337 - */ 0, - /* 338 - */ 0, - /* 339 - */ 0, - /* 33a - */ 0, - /* 33b - */ 0, - /* 33c - */ 0, - /* 33d - */ 0, - /* 33e - */ 0, - /* 33f - */ 0, - /* 340 - _DB_00 */ 0x2230, - /* 341 - _DB_01 */ 0x2231, - /* 342 - _DB_02 */ 0x2232, - /* 343 - _DB_03 */ 0x2233, - /* 344 - */ 0, - /* 345 - _DB_05 */ 0x2234, - /* 346 - */ 0, - /* 347 - _DB_07 */ 0x2235, - /* 348 - _DB_C0 */ 0x2236, - /* 349 - _DB_C0 */ 0x2237, - /* 34a - _DB_C0 */ 0x2238, - /* 34b - _DB_C0 */ 0x2239, - /* 34c - _DB_C0 */ 0x223a, - /* 34d - _DB_C0 */ 0x223b, - /* 34e - _DB_C0 */ 0x223c, - /* 34f - _DB_C0 */ 0x223d, - /* 350 - _DB_C8 */ 0x223e, - /* 351 - _DB_C8 */ 0x223f, - /* 352 - _DB_C8 */ 0x2240, - /* 353 - _DB_C8 */ 0x2241, - /* 354 - _DB_C8 */ 0x2242, - /* 355 - _DB_C8 */ 0x2243, - /* 356 - _DB_C8 */ 0x2244, - /* 357 - _DB_C8 */ 0x2245, - /* 358 - _DB_D0 */ 0x2246, - /* 359 - _DB_D0 */ 0x2247, - /* 35a - _DB_D0 */ 0x2248, - /* 35b - _DB_D0 */ 0x2249, - /* 35c - _DB_D0 */ 0x224a, - /* 35d - _DB_D0 */ 0x224b, - /* 35e - _DB_D0 */ 0x224c, - /* 35f - _DB_D0 */ 0x224d, - /* 360 - _DB_D8 */ 0x224e, - /* 361 - _DB_D8 */ 0x224f, - /* 362 - _DB_D8 */ 0x2250, - /* 363 - _DB_D8 */ 0x2251, - /* 364 - _DB_D8 */ 0x2252, - /* 365 - _DB_D8 */ 0x2253, - /* 366 - _DB_D8 */ 0x2254, - /* 367 - _DB_D8 */ 0x2255, - /* 368 - _DB_E0 */ 0x2256, - /* 369 - _DB_E1 */ 0x2257, - /* 36a - _DB_E2 */ 0xcdb0, - /* 36b - _DB_E3 */ 0xcdbc, - /* 36c - _DB_E4 */ 0x2258, - /* 36d - */ 0, - /* 36e - */ 0, - /* 36f - */ 0, - /* 370 - _DB_E8 */ 0x2259, - /* 371 - _DB_E8 */ 0x225a, - /* 372 - _DB_E8 */ 0x225b, - /* 373 - _DB_E8 */ 0x225c, - /* 374 - _DB_E8 */ 0x225d, - /* 375 - _DB_E8 */ 0x225e, - /* 376 - _DB_E8 */ 0x225f, - /* 377 - _DB_E8 */ 0x2260, - /* 378 - _DB_F0 */ 0x2261, - /* 379 - _DB_F0 */ 0x2262, - /* 37a - _DB_F0 */ 0x2263, - /* 37b - _DB_F0 */ 0x2264, - /* 37c - _DB_F0 */ 0x2265, - /* 37d - _DB_F0 */ 0x2266, - /* 37e - _DB_F0 */ 0x2267, - /* 37f - _DB_F0 */ 0x2268, - /* 380 - */ 0, - /* 381 - */ 0, - /* 382 - */ 0, - /* 383 - */ 0, - /* 384 - */ 0, - /* 385 - */ 0, - /* 386 - */ 0, - /* 387 - */ 0, - /* 388 - _DC_00 */ 0x2269, - /* 389 - _DC_01 */ 0x226a, - /* 38a - _DC_02 */ 0x226b, - /* 38b - _DC_03 */ 0x226c, - /* 38c - _DC_04 */ 0x226d, - /* 38d - _DC_05 */ 0x226e, - /* 38e - _DC_06 */ 0x226f, - /* 38f - _DC_07 */ 0x2270, - /* 390 - _DC_C0 */ 0x2271, - /* 391 - _DC_C0 */ 0x2272, - /* 392 - _DC_C0 */ 0x2273, - /* 393 - _DC_C0 */ 0x2274, - /* 394 - _DC_C0 */ 0x2275, - /* 395 - _DC_C0 */ 0x2276, - /* 396 - _DC_C0 */ 0x2277, - /* 397 - _DC_C0 */ 0x2278, - /* 398 - _DC_C8 */ 0x2279, - /* 399 - _DC_C8 */ 0x227a, - /* 39a - _DC_C8 */ 0x227b, - /* 39b - _DC_C8 */ 0x227c, - /* 39c - _DC_C8 */ 0x227d, - /* 39d - _DC_C8 */ 0x227e, - /* 39e - _DC_C8 */ 0x227f, - /* 39f - _DC_C8 */ 0x2280, - /* 3a0 - */ 0, - /* 3a1 - */ 0, - /* 3a2 - */ 0, - /* 3a3 - */ 0, - /* 3a4 - */ 0, - /* 3a5 - */ 0, - /* 3a6 - */ 0, - /* 3a7 - */ 0, - /* 3a8 - */ 0, - /* 3a9 - */ 0, - /* 3aa - */ 0, - /* 3ab - */ 0, - /* 3ac - */ 0, - /* 3ad - */ 0, - /* 3ae - */ 0, - /* 3af - */ 0, - /* 3b0 - _DC_E0 */ 0x2281, - /* 3b1 - _DC_E0 */ 0x2282, - /* 3b2 - _DC_E0 */ 0x2283, - /* 3b3 - _DC_E0 */ 0x2284, - /* 3b4 - _DC_E0 */ 0x2285, - /* 3b5 - _DC_E0 */ 0x2286, - /* 3b6 - _DC_E0 */ 0x2287, - /* 3b7 - _DC_E0 */ 0x2288, - /* 3b8 - _DC_E8 */ 0x2289, - /* 3b9 - _DC_E8 */ 0x228a, - /* 3ba - _DC_E8 */ 0x228b, - /* 3bb - _DC_E8 */ 0x228c, - /* 3bc - _DC_E8 */ 0x228d, - /* 3bd - _DC_E8 */ 0x228e, - /* 3be - _DC_E8 */ 0x228f, - /* 3bf - _DC_E8 */ 0x2290, - /* 3c0 - _DC_F0 */ 0x2291, - /* 3c1 - _DC_F0 */ 0x2292, - /* 3c2 - _DC_F0 */ 0x2293, - /* 3c3 - _DC_F0 */ 0x2294, - /* 3c4 - _DC_F0 */ 0x2295, - /* 3c5 - _DC_F0 */ 0x2296, - /* 3c6 - _DC_F0 */ 0x2297, - /* 3c7 - _DC_F0 */ 0x2298, - /* 3c8 - _DC_F8 */ 0x2299, - /* 3c9 - _DC_F8 */ 0x229a, - /* 3ca - _DC_F8 */ 0x229b, - /* 3cb - _DC_F8 */ 0x229c, - /* 3cc - _DC_F8 */ 0x229d, - /* 3cd - _DC_F8 */ 0x229e, - /* 3ce - _DC_F8 */ 0x229f, - /* 3cf - _DC_F8 */ 0x22a0, - /* 3d0 - _DD_00 */ 0x22a1, - /* 3d1 - _DD_01 */ 0x22a2, - /* 3d2 - _DD_02 */ 0x22a3, - /* 3d3 - _DD_03 */ 0x22a4, - /* 3d4 - _DD_04 */ 0x22a5, - /* 3d5 - */ 0, - /* 3d6 - _DD_06 */ 0xcdc8, - /* 3d7 - _DD_07 */ 0xcdd4, - /* 3d8 - _DD_C0 */ 0x22a6, - /* 3d9 - _DD_C0 */ 0x22a7, - /* 3da - _DD_C0 */ 0x22a8, - /* 3db - _DD_C0 */ 0x22a9, - /* 3dc - _DD_C0 */ 0x22aa, - /* 3dd - _DD_C0 */ 0x22ab, - /* 3de - _DD_C0 */ 0x22ac, - /* 3df - _DD_C0 */ 0x22ad, - /* 3e0 - */ 0, - /* 3e1 - */ 0, - /* 3e2 - */ 0, - /* 3e3 - */ 0, - /* 3e4 - */ 0, - /* 3e5 - */ 0, - /* 3e6 - */ 0, - /* 3e7 - */ 0, - /* 3e8 - _DD_D0 */ 0x22ae, - /* 3e9 - _DD_D0 */ 0x22af, - /* 3ea - _DD_D0 */ 0x22b0, - /* 3eb - _DD_D0 */ 0x22b1, - /* 3ec - _DD_D0 */ 0x22b2, - /* 3ed - _DD_D0 */ 0x22b3, - /* 3ee - _DD_D0 */ 0x22b4, - /* 3ef - _DD_D0 */ 0x22b5, - /* 3f0 - _DD_D8 */ 0x22b6, - /* 3f1 - _DD_D8 */ 0x22b7, - /* 3f2 - _DD_D8 */ 0x22b8, - /* 3f3 - _DD_D8 */ 0x22b9, - /* 3f4 - _DD_D8 */ 0x22ba, - /* 3f5 - _DD_D8 */ 0x22bb, - /* 3f6 - _DD_D8 */ 0x22bc, - /* 3f7 - _DD_D8 */ 0x22bd, - /* 3f8 - _DD_E0 */ 0x22be, - /* 3f9 - _DD_E1 */ 0x22bf, - /* 3fa - _DD_E0 */ 0x22c0, - /* 3fb - _DD_E0 */ 0x22c1, - /* 3fc - _DD_E0 */ 0x22c2, - /* 3fd - _DD_E0 */ 0x22c3, - /* 3fe - _DD_E0 */ 0x22c4, - /* 3ff - _DD_E0 */ 0x22c5, - /* 400 - _DD_E8 */ 0x22c6, - /* 401 - _DD_E9 */ 0x22c7, - /* 402 - _DD_E8 */ 0x22c8, - /* 403 - _DD_E8 */ 0x22c9, - /* 404 - _DD_E8 */ 0x22ca, - /* 405 - _DD_E8 */ 0x22cb, - /* 406 - _DD_E8 */ 0x22cc, - /* 407 - _DD_E8 */ 0x22cd, - /* 408 - */ 0, - /* 409 - */ 0, - /* 40a - */ 0, - /* 40b - */ 0, - /* 40c - */ 0, - /* 40d - */ 0, - /* 40e - */ 0, - /* 40f - */ 0, - /* 410 - */ 0, - /* 411 - */ 0, - /* 412 - */ 0, - /* 413 - */ 0, - /* 414 - */ 0, - /* 415 - */ 0, - /* 416 - */ 0, - /* 417 - */ 0, - /* 418 - _DE_00 */ 0x22ce, - /* 419 - _DE_01 */ 0x22cf, - /* 41a - _DE_02 */ 0x22d0, - /* 41b - _DE_03 */ 0x22d1, - /* 41c - _DE_04 */ 0x22d2, - /* 41d - _DE_05 */ 0x22d3, - /* 41e - _DE_06 */ 0x22d4, - /* 41f - _DE_07 */ 0x22d5, - /* 420 - _DE_C0 */ 0x22d6, - /* 421 - _DE_C1 */ 0x22d7, - /* 422 - _DE_C0 */ 0x22d8, - /* 423 - _DE_C0 */ 0x22d9, - /* 424 - _DE_C0 */ 0x22da, - /* 425 - _DE_C0 */ 0x22db, - /* 426 - _DE_C0 */ 0x22dc, - /* 427 - _DE_C0 */ 0x22dd, - /* 428 - _DE_C8 */ 0x22de, - /* 429 - _DE_C9 */ 0x22df, - /* 42a - _DE_C8 */ 0x22e0, - /* 42b - _DE_C8 */ 0x22e1, - /* 42c - _DE_C8 */ 0x22e2, - /* 42d - _DE_C8 */ 0x22e3, - /* 42e - _DE_C8 */ 0x22e4, - /* 42f - _DE_C8 */ 0x22e5, - /* 430 - */ 0, - /* 431 - */ 0, - /* 432 - */ 0, - /* 433 - */ 0, - /* 434 - */ 0, - /* 435 - */ 0, - /* 436 - */ 0, - /* 437 - */ 0, - /* 438 - */ 0, - /* 439 - _DE_D9 */ 0x22e6, - /* 43a - */ 0, - /* 43b - */ 0, - /* 43c - */ 0, - /* 43d - */ 0, - /* 43e - */ 0, - /* 43f - */ 0, - /* 440 - _DE_E0 */ 0x22e7, - /* 441 - _DE_E1 */ 0x22e8, - /* 442 - _DE_E0 */ 0x22e9, - /* 443 - _DE_E0 */ 0x22ea, - /* 444 - _DE_E0 */ 0x22eb, - /* 445 - _DE_E0 */ 0x22ec, - /* 446 - _DE_E0 */ 0x22ed, - /* 447 - _DE_E0 */ 0x22ee, - /* 448 - _DE_E8 */ 0x22ef, - /* 449 - _DE_E9 */ 0x22f0, - /* 44a - _DE_E8 */ 0x22f1, - /* 44b - _DE_E8 */ 0x22f2, - /* 44c - _DE_E8 */ 0x22f3, - /* 44d - _DE_E8 */ 0x22f4, - /* 44e - _DE_E8 */ 0x22f5, - /* 44f - _DE_E8 */ 0x22f6, - /* 450 - _DE_F0 */ 0x22f7, - /* 451 - _DE_F1 */ 0x22f8, - /* 452 - _DE_F0 */ 0x22f9, - /* 453 - _DE_F0 */ 0x22fa, - /* 454 - _DE_F0 */ 0x22fb, - /* 455 - _DE_F0 */ 0x22fc, - /* 456 - _DE_F0 */ 0x22fd, - /* 457 - _DE_F0 */ 0x22fe, - /* 458 - _DE_F8 */ 0x22ff, - /* 459 - _DE_F9 */ 0x2300, - /* 45a - _DE_F8 */ 0x2301, - /* 45b - _DE_F8 */ 0x2302, - /* 45c - _DE_F8 */ 0x2303, - /* 45d - _DE_F8 */ 0x2304, - /* 45e - _DE_F8 */ 0x2305, - /* 45f - _DE_F8 */ 0x2306, - /* 460 - _DF_00 */ 0x2307, - /* 461 - _DF_01 */ 0x2308, - /* 462 - _DF_02 */ 0x2309, - /* 463 - _DF_03 */ 0x230a, - /* 464 - _DF_04 */ 0x230b, - /* 465 - _DF_05 */ 0x230c, - /* 466 - _DF_06 */ 0x230d, - /* 467 - _DF_07 */ 0x230e, - /* 468 - */ 0, - /* 469 - */ 0, - /* 46a - */ 0, - /* 46b - */ 0, - /* 46c - */ 0, - /* 46d - */ 0, - /* 46e - */ 0, - /* 46f - */ 0, - /* 470 - */ 0, - /* 471 - */ 0, - /* 472 - */ 0, - /* 473 - */ 0, - /* 474 - */ 0, - /* 475 - */ 0, - /* 476 - */ 0, - /* 477 - */ 0, - /* 478 - */ 0, - /* 479 - */ 0, - /* 47a - */ 0, - /* 47b - */ 0, - /* 47c - */ 0, - /* 47d - */ 0, - /* 47e - */ 0, - /* 47f - */ 0, - /* 480 - */ 0, - /* 481 - */ 0, - /* 482 - */ 0, - /* 483 - */ 0, - /* 484 - */ 0, - /* 485 - */ 0, - /* 486 - */ 0, - /* 487 - */ 0, - /* 488 - _DF_E0 */ 0xcde0, - /* 489 - */ 0, - /* 48a - */ 0, - /* 48b - */ 0, - /* 48c - */ 0, - /* 48d - */ 0, - /* 48e - */ 0, - /* 48f - */ 0, - /* 490 - _DF_E8 */ 0x230f, - /* 491 - _DF_E8 */ 0x2310, - /* 492 - _DF_E8 */ 0x2311, - /* 493 - _DF_E8 */ 0x2312, - /* 494 - _DF_E8 */ 0x2313, - /* 495 - _DF_E8 */ 0x2314, - /* 496 - _DF_E8 */ 0x2315, - /* 497 - _DF_E8 */ 0x2316, - /* 498 - _DF_F0 */ 0x2317, - /* 499 - _DF_F0 */ 0x2318, - /* 49a - _DF_F0 */ 0x2319, - /* 49b - _DF_F0 */ 0x231a, - /* 49c - _DF_F0 */ 0x231b, - /* 49d - _DF_F0 */ 0x231c, - /* 49e - _DF_F0 */ 0x231d, - /* 49f - _DF_F0 */ 0x231e, - /* 4a0 - */ 0, - /* 4a1 - */ 0, - /* 4a2 - */ 0, - /* 4a3 - */ 0, - /* 4a4 - */ 0, - /* 4a5 - */ 0, - /* 4a6 - */ 0, - /* 4a7 - */ 0, - /* 4a8 - _F6_00 */ 0x231f, - /* 4a9 - */ 0, - /* 4aa - _F6_02 */ 0x2320, - /* 4ab - _F6_03 */ 0x2321, - /* 4ac - _F6_04 */ 0x2322, - /* 4ad - _F6_05 */ 0x2323, - /* 4ae - _F6_06 */ 0x2324, - /* 4af - _F6_07 */ 0x2325, - /* 4b0 - _F7_00 */ 0x2326, - /* 4b1 - */ 0, - /* 4b2 - _F7_02 */ 0x2327, - /* 4b3 - _F7_03 */ 0x2328, - /* 4b4 - _F7_04 */ 0x2329, - /* 4b5 - _F7_05 */ 0x232a, - /* 4b6 - _F7_06 */ 0x232b, - /* 4b7 - _F7_07 */ 0x232c, - /* 4b8 - _FE_00 */ 0x232d, - /* 4b9 - _FE_01 */ 0x232e, - /* 4ba - */ 0, - /* 4bb - */ 0, - /* 4bc - */ 0, - /* 4bd - */ 0, - /* 4be - */ 0, - /* 4bf - */ 0, - /* 4c0 - _FF_00 */ 0x232f, - /* 4c1 - _FF_01 */ 0x2330, - /* 4c2 - _FF_02 */ 0x2331, - /* 4c3 - _FF_03 */ 0x2332, - /* 4c4 - _FF_04 */ 0x2333, - /* 4c5 - _FF_05 */ 0x2334, - /* 4c6 - _FF_06 */ 0x2335, - /* 4c7 - */ 0, - /* 4c8 - _0F_00_00 */ 0x2336, - /* 4c9 - _0F_00_01 */ 0x2337, - /* 4ca - _0F_00_02 */ 0x2338, - /* 4cb - _0F_00_03 */ 0x2339, - /* 4cc - _0F_00_04 */ 0x233a, - /* 4cd - _0F_00_05 */ 0x233b, - /* 4ce - */ 0, - /* 4cf - */ 0, - /* 4d0 - _0F_01_00 */ 0x233c, - /* 4d1 - _0F_01_01 */ 0x233d, - /* 4d2 - _0F_01_02 */ 0x233e, - /* 4d3 - _0F_01_03 */ 0x233f, - /* 4d4 - _0F_01_04 */ 0x2340, - /* 4d5 - */ 0, - /* 4d6 - _0F_01_06 */ 0x2341, - /* 4d7 - _0F_01_07 */ 0x2342, - /* 4d8 - */ 0, - /* 4d9 - _0F_01_C1 */ 0x2343, - /* 4da - _0F_01_C2 */ 0x2344, - /* 4db - _0F_01_C3 */ 0x2345, - /* 4dc - _0F_01_C4 */ 0x2346, - /* 4dd - */ 0, - /* 4de - */ 0, - /* 4df - */ 0, - /* 4e0 - _0F_01_C8 */ 0x2347, - /* 4e1 - _0F_01_C9 */ 0x2348, - /* 4e2 - */ 0, - /* 4e3 - */ 0, - /* 4e4 - */ 0, - /* 4e5 - */ 0, - /* 4e6 - */ 0, - /* 4e7 - */ 0, - /* 4e8 - _0F_01_D0 */ 0x2349, - /* 4e9 - _0F_01_D1 */ 0x234a, - /* 4ea - */ 0, - /* 4eb - */ 0, - /* 4ec - */ 0, - /* 4ed - */ 0, - /* 4ee - */ 0, - /* 4ef - */ 0, - /* 4f0 - _0F_01_D8 */ 0x234b, - /* 4f1 - _0F_01_D9 */ 0x234c, - /* 4f2 - _0F_01_DA */ 0x234d, - /* 4f3 - _0F_01_DB */ 0x234e, - /* 4f4 - _0F_01_DC */ 0x234f, - /* 4f5 - _0F_01_DD */ 0x2350, - /* 4f6 - _0F_01_DE */ 0x2351, - /* 4f7 - _0F_01_DF */ 0x2352, - /* 4f8 - */ 0, - /* 4f9 - */ 0, - /* 4fa - */ 0, - /* 4fb - */ 0, - /* 4fc - */ 0, - /* 4fd - */ 0, - /* 4fe - */ 0, - /* 4ff - */ 0, - /* 500 - */ 0, - /* 501 - */ 0, - /* 502 - */ 0, - /* 503 - */ 0, - /* 504 - */ 0, - /* 505 - */ 0, - /* 506 - */ 0, - /* 507 - */ 0, - /* 508 - */ 0, - /* 509 - */ 0, - /* 50a - */ 0, - /* 50b - */ 0, - /* 50c - */ 0, - /* 50d - */ 0, - /* 50e - */ 0, - /* 50f - */ 0, - /* 510 - _0F_01_F8 */ 0x2353, - /* 511 - _0F_01_F9 */ 0x2354, - /* 512 - */ 0, - /* 513 - */ 0, - /* 514 - */ 0, - /* 515 - */ 0, - /* 516 - */ 0, - /* 517 - */ 0, - /* 518 - _0F_0D_00 */ 0x2355, - /* 519 - _0F_0D_01 */ 0x2356, - /* 51a - */ 0, - /* 51b - */ 0, - /* 51c - */ 0, - /* 51d - */ 0, - /* 51e - */ 0, - /* 51f - */ 0, - /* 520 - */ 0, - /* 521 - */ 0, - /* 522 - */ 0, - /* 523 - */ 0, - /* 524 - */ 0, - /* 525 - */ 0, - /* 526 - */ 0, - /* 527 - */ 0, - /* 528 - */ 0, - /* 529 - */ 0, - /* 52a - */ 0, - /* 52b - */ 0, - /* 52c - _0F_0F_0C */ 0x2357, - /* 52d - _0F_0F_0D */ 0x2358, - /* 52e - */ 0, - /* 52f - */ 0, - /* 530 - */ 0, - /* 531 - */ 0, - /* 532 - */ 0, - /* 533 - */ 0, - /* 534 - */ 0, - /* 535 - */ 0, - /* 536 - */ 0, - /* 537 - */ 0, - /* 538 - */ 0, - /* 539 - */ 0, - /* 53a - */ 0, - /* 53b - */ 0, - /* 53c - _0F_0F_1C */ 0x2359, - /* 53d - _0F_0F_1D */ 0x235a, - /* 53e - */ 0, - /* 53f - */ 0, - /* 540 - */ 0, - /* 541 - */ 0, - /* 542 - */ 0, - /* 543 - */ 0, - /* 544 - */ 0, - /* 545 - */ 0, - /* 546 - */ 0, - /* 547 - */ 0, - /* 548 - */ 0, - /* 549 - */ 0, - /* 54a - */ 0, - /* 54b - */ 0, - /* 54c - */ 0, - /* 54d - */ 0, - /* 54e - */ 0, - /* 54f - */ 0, - /* 550 - */ 0, - /* 551 - */ 0, - /* 552 - */ 0, - /* 553 - */ 0, - /* 554 - */ 0, - /* 555 - */ 0, - /* 556 - */ 0, - /* 557 - */ 0, - /* 558 - */ 0, - /* 559 - */ 0, - /* 55a - */ 0, - /* 55b - */ 0, - /* 55c - */ 0, - /* 55d - */ 0, - /* 55e - */ 0, - /* 55f - */ 0, - /* 560 - */ 0, - /* 561 - */ 0, - /* 562 - */ 0, - /* 563 - */ 0, - /* 564 - */ 0, - /* 565 - */ 0, - /* 566 - */ 0, - /* 567 - */ 0, - /* 568 - */ 0, - /* 569 - */ 0, - /* 56a - */ 0, - /* 56b - */ 0, - /* 56c - */ 0, - /* 56d - */ 0, - /* 56e - */ 0, - /* 56f - */ 0, - /* 570 - */ 0, - /* 571 - */ 0, - /* 572 - */ 0, - /* 573 - */ 0, - /* 574 - */ 0, - /* 575 - */ 0, - /* 576 - */ 0, - /* 577 - */ 0, - /* 578 - */ 0, - /* 579 - */ 0, - /* 57a - */ 0, - /* 57b - */ 0, - /* 57c - */ 0, - /* 57d - */ 0, - /* 57e - */ 0, - /* 57f - */ 0, - /* 580 - */ 0, - /* 581 - */ 0, - /* 582 - */ 0, - /* 583 - */ 0, - /* 584 - */ 0, - /* 585 - */ 0, - /* 586 - */ 0, - /* 587 - */ 0, - /* 588 - */ 0, - /* 589 - */ 0, - /* 58a - */ 0, - /* 58b - */ 0, - /* 58c - */ 0, - /* 58d - */ 0, - /* 58e - */ 0, - /* 58f - */ 0, - /* 590 - */ 0, - /* 591 - */ 0, - /* 592 - */ 0, - /* 593 - */ 0, - /* 594 - */ 0, - /* 595 - */ 0, - /* 596 - */ 0, - /* 597 - */ 0, - /* 598 - */ 0, - /* 599 - */ 0, - /* 59a - */ 0, - /* 59b - */ 0, - /* 59c - */ 0, - /* 59d - */ 0, - /* 59e - */ 0, - /* 59f - */ 0, - /* 5a0 - */ 0, - /* 5a1 - */ 0, - /* 5a2 - */ 0, - /* 5a3 - */ 0, - /* 5a4 - */ 0, - /* 5a5 - */ 0, - /* 5a6 - */ 0, - /* 5a7 - */ 0, - /* 5a8 - */ 0, - /* 5a9 - */ 0, - /* 5aa - _0F_0F_8A */ 0x235b, - /* 5ab - */ 0, - /* 5ac - */ 0, - /* 5ad - */ 0, - /* 5ae - _0F_0F_8E */ 0x235c, - /* 5af - */ 0, - /* 5b0 - _0F_0F_90 */ 0x235d, - /* 5b1 - */ 0, - /* 5b2 - */ 0, - /* 5b3 - */ 0, - /* 5b4 - _0F_0F_94 */ 0x235e, - /* 5b5 - */ 0, - /* 5b6 - _0F_0F_96 */ 0x235f, - /* 5b7 - _0F_0F_97 */ 0x2360, - /* 5b8 - */ 0, - /* 5b9 - */ 0, - /* 5ba - _0F_0F_9A */ 0x2361, - /* 5bb - */ 0, - /* 5bc - */ 0, - /* 5bd - */ 0, - /* 5be - _0F_0F_9E */ 0x2362, - /* 5bf - */ 0, - /* 5c0 - _0F_0F_A0 */ 0x2363, - /* 5c1 - */ 0, - /* 5c2 - */ 0, - /* 5c3 - */ 0, - /* 5c4 - _0F_0F_A4 */ 0x2364, - /* 5c5 - */ 0, - /* 5c6 - _0F_0F_A6 */ 0x2365, - /* 5c7 - _0F_0F_A7 */ 0x2366, - /* 5c8 - */ 0, - /* 5c9 - */ 0, - /* 5ca - _0F_0F_AA */ 0x2367, - /* 5cb - */ 0, - /* 5cc - */ 0, - /* 5cd - */ 0, - /* 5ce - _0F_0F_AE */ 0x2368, - /* 5cf - */ 0, - /* 5d0 - _0F_0F_B0 */ 0x2369, - /* 5d1 - */ 0, - /* 5d2 - */ 0, - /* 5d3 - */ 0, - /* 5d4 - _0F_0F_B4 */ 0x236a, - /* 5d5 - */ 0, - /* 5d6 - _0F_0F_B6 */ 0x236b, - /* 5d7 - _0F_0F_B7 */ 0x236c, - /* 5d8 - */ 0, - /* 5d9 - */ 0, - /* 5da - */ 0, - /* 5db - _0F_0F_BB */ 0x236d, - /* 5dc - */ 0, - /* 5dd - */ 0, - /* 5de - */ 0, - /* 5df - _0F_0F_BF */ 0x236e, - /* 5e0 - */ 0, - /* 5e1 - */ 0, - /* 5e2 - */ 0, - /* 5e3 - */ 0, - /* 5e4 - */ 0, - /* 5e5 - */ 0, - /* 5e6 - */ 0, - /* 5e7 - */ 0, - /* 5e8 - */ 0, - /* 5e9 - */ 0, - /* 5ea - */ 0, - /* 5eb - */ 0, - /* 5ec - */ 0, - /* 5ed - */ 0, - /* 5ee - */ 0, - /* 5ef - */ 0, - /* 5f0 - */ 0, - /* 5f1 - */ 0, - /* 5f2 - */ 0, - /* 5f3 - */ 0, - /* 5f4 - */ 0, - /* 5f5 - */ 0, - /* 5f6 - */ 0, - /* 5f7 - */ 0, - /* 5f8 - */ 0, - /* 5f9 - */ 0, - /* 5fa - */ 0, - /* 5fb - */ 0, - /* 5fc - */ 0, - /* 5fd - */ 0, - /* 5fe - */ 0, - /* 5ff - */ 0, - /* 600 - */ 0, - /* 601 - */ 0, - /* 602 - */ 0, - /* 603 - */ 0, - /* 604 - */ 0, - /* 605 - */ 0, - /* 606 - */ 0, - /* 607 - */ 0, - /* 608 - */ 0, - /* 609 - */ 0, - /* 60a - */ 0, - /* 60b - */ 0, - /* 60c - */ 0, - /* 60d - */ 0, - /* 60e - */ 0, - /* 60f - */ 0, - /* 610 - */ 0, - /* 611 - */ 0, - /* 612 - */ 0, - /* 613 - */ 0, - /* 614 - */ 0, - /* 615 - */ 0, - /* 616 - */ 0, - /* 617 - */ 0, - /* 618 - */ 0, - /* 619 - */ 0, - /* 61a - */ 0, - /* 61b - */ 0, - /* 61c - */ 0, - /* 61d - */ 0, - /* 61e - */ 0, - /* 61f - */ 0, - /* 620 - _0F_10 */ 0x236f, - /* 621 - _66_0F_10 */ 0x2370, - /* 622 - _F3_0F_10 */ 0x2371, - /* 623 - _F2_0F_10 */ 0x2372, - /* 624 - */ 0, - /* 625 - */ 0, - /* 626 - _V_F3_0F_10 */ 0x4009, - /* 627 - _V_F2_0F_10 */ 0x400a, - /* 628 - _NV_0F_10 */ 0x400b, - /* 629 - _NV_66_0F_10 */ 0x400c, - /* 62a - _NV_F3_0F_10 */ 0x400d, - /* 62b - _NV_F2_0F_10 */ 0x400e, - /* 62c - _0F_11 */ 0x2373, - /* 62d - _66_0F_11 */ 0x2374, - /* 62e - _F3_0F_11 */ 0x2375, - /* 62f - _F2_0F_11 */ 0x2376, - /* 630 - */ 0, - /* 631 - */ 0, - /* 632 - _V_F3_0F_11 */ 0x400f, - /* 633 - _V_F2_0F_11 */ 0x4010, - /* 634 - _NV_0F_11 */ 0x4011, - /* 635 - _NV_66_0F_11 */ 0x4012, - /* 636 - _NV_F3_0F_11 */ 0x4013, - /* 637 - _NV_F2_0F_11 */ 0x4014, - /* 638 - _0F_12 */ 0x4015, - /* 639 - _66_0F_12 */ 0x2377, - /* 63a - _F3_0F_12 */ 0x2378, - /* 63b - _F2_0F_12 */ 0x2379, - /* 63c - _V_0F_12 */ 0x4016, - /* 63d - _V_66_0F_12 */ 0x4017, - /* 63e - */ 0, - /* 63f - */ 0, - /* 640 - */ 0, - /* 641 - */ 0, - /* 642 - _NV_F3_0F_12 */ 0x4018, - /* 643 - _NV_F2_0F_12 */ 0x4019, - /* 644 - _0F_13 */ 0x237a, - /* 645 - _66_0F_13 */ 0x237b, - /* 646 - */ 0, - /* 647 - */ 0, - /* 648 - */ 0, - /* 649 - */ 0, - /* 64a - */ 0, - /* 64b - */ 0, - /* 64c - _NV_0F_13 */ 0x401a, - /* 64d - _NV_66_0F_13 */ 0x401b, - /* 64e - */ 0, - /* 64f - */ 0, - /* 650 - _0F_14 */ 0x237c, - /* 651 - _66_0F_14 */ 0x237d, - /* 652 - */ 0, - /* 653 - */ 0, - /* 654 - _V_0F_14 */ 0x401c, - /* 655 - _V_66_0F_14 */ 0x401d, - /* 656 - */ 0, - /* 657 - */ 0, - /* 658 - */ 0, - /* 659 - */ 0, - /* 65a - */ 0, - /* 65b - */ 0, - /* 65c - _0F_15 */ 0x237e, - /* 65d - _66_0F_15 */ 0x237f, - /* 65e - */ 0, - /* 65f - */ 0, - /* 660 - _V_0F_15 */ 0x401e, - /* 661 - _V_66_0F_15 */ 0x401f, - /* 662 - */ 0, - /* 663 - */ 0, - /* 664 - */ 0, - /* 665 - */ 0, - /* 666 - */ 0, - /* 667 - */ 0, - /* 668 - _0F_16 */ 0x4020, - /* 669 - _66_0F_16 */ 0x2380, - /* 66a - _F3_0F_16 */ 0x2381, - /* 66b - */ 0, - /* 66c - _V_0F_16 */ 0x4021, - /* 66d - _V_66_0F_16 */ 0x4022, - /* 66e - */ 0, - /* 66f - */ 0, - /* 670 - */ 0, - /* 671 - */ 0, - /* 672 - _NV_F3_0F_16 */ 0x4023, - /* 673 - */ 0, - /* 674 - _0F_17 */ 0x2382, - /* 675 - _66_0F_17 */ 0x2383, - /* 676 - */ 0, - /* 677 - */ 0, - /* 678 - */ 0, - /* 679 - */ 0, - /* 67a - */ 0, - /* 67b - */ 0, - /* 67c - _NV_0F_17 */ 0x4024, - /* 67d - _NV_66_0F_17 */ 0x4025, - /* 67e - */ 0, - /* 67f - */ 0, - /* 680 - _0F_18_00 */ 0x2384, - /* 681 - _0F_18_01 */ 0x2385, - /* 682 - _0F_18_02 */ 0x2386, - /* 683 - _0F_18_03 */ 0x2387, - /* 684 - */ 0, - /* 685 - */ 0, - /* 686 - */ 0, - /* 687 - */ 0, - /* 688 - _0F_28 */ 0x2388, - /* 689 - _66_0F_28 */ 0x2389, - /* 68a - */ 0, - /* 68b - */ 0, - /* 68c - */ 0, - /* 68d - */ 0, - /* 68e - */ 0, - /* 68f - */ 0, - /* 690 - _NV_0F_28 */ 0x4026, - /* 691 - _NV_66_0F_28 */ 0x4027, - /* 692 - */ 0, - /* 693 - */ 0, - /* 694 - _0F_29 */ 0x238a, - /* 695 - _66_0F_29 */ 0x238b, - /* 696 - */ 0, - /* 697 - */ 0, - /* 698 - */ 0, - /* 699 - */ 0, - /* 69a - */ 0, - /* 69b - */ 0, - /* 69c - _NV_0F_29 */ 0x4028, - /* 69d - _NV_66_0F_29 */ 0x4029, - /* 69e - */ 0, - /* 69f - */ 0, - /* 6a0 - _0F_2A */ 0x238c, - /* 6a1 - _66_0F_2A */ 0x238d, - /* 6a2 - _F3_0F_2A */ 0x238e, - /* 6a3 - _F2_0F_2A */ 0x238f, - /* 6a4 - */ 0, - /* 6a5 - */ 0, - /* 6a6 - _V_F3_0F_2A */ 0x402a, - /* 6a7 - _V_F2_0F_2A */ 0x402b, - /* 6a8 - */ 0, - /* 6a9 - */ 0, - /* 6aa - */ 0, - /* 6ab - */ 0, - /* 6ac - _0F_2B */ 0x2390, - /* 6ad - _66_0F_2B */ 0x2391, - /* 6ae - _F3_0F_2B */ 0x2392, - /* 6af - _F2_0F_2B */ 0x2393, - /* 6b0 - */ 0, - /* 6b1 - */ 0, - /* 6b2 - */ 0, - /* 6b3 - */ 0, - /* 6b4 - _NV_0F_2B */ 0x402c, - /* 6b5 - _NV_66_0F_2B */ 0x402d, - /* 6b6 - */ 0, - /* 6b7 - */ 0, - /* 6b8 - _0F_2C */ 0x2394, - /* 6b9 - _66_0F_2C */ 0x2395, - /* 6ba - _F3_0F_2C */ 0x2396, - /* 6bb - _F2_0F_2C */ 0x2397, - /* 6bc - */ 0, - /* 6bd - */ 0, - /* 6be - */ 0, - /* 6bf - */ 0, - /* 6c0 - */ 0, - /* 6c1 - */ 0, - /* 6c2 - _NV_F3_0F_2C */ 0x402e, - /* 6c3 - _NV_F2_0F_2C */ 0x402f, - /* 6c4 - _0F_2D */ 0x2398, - /* 6c5 - _66_0F_2D */ 0x2399, - /* 6c6 - _F3_0F_2D */ 0x239a, - /* 6c7 - _F2_0F_2D */ 0x239b, - /* 6c8 - */ 0, - /* 6c9 - */ 0, - /* 6ca - */ 0, - /* 6cb - */ 0, - /* 6cc - */ 0, - /* 6cd - */ 0, - /* 6ce - _NV_F3_0F_2D */ 0x4030, - /* 6cf - _NV_F2_0F_2D */ 0x4031, - /* 6d0 - _0F_2E */ 0x239c, - /* 6d1 - _66_0F_2E */ 0x239d, - /* 6d2 - */ 0, - /* 6d3 - */ 0, - /* 6d4 - */ 0, - /* 6d5 - */ 0, - /* 6d6 - */ 0, - /* 6d7 - */ 0, - /* 6d8 - _NV_0F_2E */ 0x4032, - /* 6d9 - _NV_66_0F_2E */ 0x4033, - /* 6da - */ 0, - /* 6db - */ 0, - /* 6dc - _0F_2F */ 0x239e, - /* 6dd - _66_0F_2F */ 0x239f, - /* 6de - */ 0, - /* 6df - */ 0, - /* 6e0 - */ 0, - /* 6e1 - */ 0, - /* 6e2 - */ 0, - /* 6e3 - */ 0, - /* 6e4 - _NV_0F_2F */ 0x4034, - /* 6e5 - _NV_66_0F_2F */ 0x4035, - /* 6e6 - */ 0, - /* 6e7 - */ 0, - /* 6e8 - _0F_38_00 */ 0xcdec, - /* 6e9 - _0F_38_01 */ 0xcdf8, - /* 6ea - _0F_38_02 */ 0xce04, - /* 6eb - _0F_38_03 */ 0xce10, - /* 6ec - _0F_38_04 */ 0xce1c, - /* 6ed - _0F_38_05 */ 0xce28, - /* 6ee - _0F_38_06 */ 0xce34, - /* 6ef - _0F_38_07 */ 0xce40, - /* 6f0 - _0F_38_08 */ 0xce4c, - /* 6f1 - _0F_38_09 */ 0xce58, - /* 6f2 - _0F_38_0A */ 0xce64, - /* 6f3 - _0F_38_0B */ 0xce70, - /* 6f4 - _0F_38_0C */ 0xce7c, - /* 6f5 - _0F_38_0D */ 0xce88, - /* 6f6 - _0F_38_0E */ 0xce94, - /* 6f7 - _0F_38_0F */ 0xcea0, - /* 6f8 - _0F_38_10 */ 0xceac, - /* 6f9 - */ 0, - /* 6fa - */ 0, - /* 6fb - */ 0, - /* 6fc - _0F_38_14 */ 0xceb8, - /* 6fd - _0F_38_15 */ 0xcec4, - /* 6fe - */ 0, - /* 6ff - _0F_38_17 */ 0xced0, - /* 700 - _0F_38_18 */ 0xcedc, - /* 701 - _0F_38_19 */ 0xcee8, - /* 702 - _0F_38_1A */ 0xcef4, - /* 703 - */ 0, - /* 704 - _0F_38_1C */ 0xcf00, - /* 705 - _0F_38_1D */ 0xcf0c, - /* 706 - _0F_38_1E */ 0xcf18, - /* 707 - */ 0, - /* 708 - _0F_38_20 */ 0xcf24, - /* 709 - _0F_38_21 */ 0xcf30, - /* 70a - _0F_38_22 */ 0xcf3c, - /* 70b - _0F_38_23 */ 0xcf48, - /* 70c - _0F_38_24 */ 0xcf54, - /* 70d - _0F_38_25 */ 0xcf60, - /* 70e - */ 0, - /* 70f - */ 0, - /* 710 - _0F_38_28 */ 0xcf6c, - /* 711 - _0F_38_29 */ 0xcf78, - /* 712 - _0F_38_2A */ 0xcf84, - /* 713 - _0F_38_2B */ 0xcf90, - /* 714 - _0F_38_2C */ 0xcf9c, - /* 715 - _0F_38_2D */ 0xcfa8, - /* 716 - _0F_38_2E */ 0xcfb4, - /* 717 - _0F_38_2F */ 0xcfc0, - /* 718 - _0F_38_30 */ 0xcfcc, - /* 719 - _0F_38_31 */ 0xcfd8, - /* 71a - _0F_38_32 */ 0xcfe4, - /* 71b - _0F_38_33 */ 0xcff0, - /* 71c - _0F_38_34 */ 0xcffc, - /* 71d - _0F_38_35 */ 0xd008, - /* 71e - */ 0, - /* 71f - _0F_38_37 */ 0xd014, - /* 720 - _0F_38_38 */ 0xd020, - /* 721 - _0F_38_39 */ 0xd02c, - /* 722 - _0F_38_3A */ 0xd038, - /* 723 - _0F_38_3B */ 0xd044, - /* 724 - _0F_38_3C */ 0xd050, - /* 725 - _0F_38_3D */ 0xd05c, - /* 726 - _0F_38_3E */ 0xd068, - /* 727 - _0F_38_3F */ 0xd074, - /* 728 - _0F_38_40 */ 0xd080, - /* 729 - _0F_38_41 */ 0xd08c, - /* 72a - */ 0, - /* 72b - */ 0, - /* 72c - */ 0, - /* 72d - */ 0, - /* 72e - */ 0, - /* 72f - */ 0, - /* 730 - */ 0, - /* 731 - */ 0, - /* 732 - */ 0, - /* 733 - */ 0, - /* 734 - */ 0, - /* 735 - */ 0, - /* 736 - */ 0, - /* 737 - */ 0, - /* 738 - */ 0, - /* 739 - */ 0, - /* 73a - */ 0, - /* 73b - */ 0, - /* 73c - */ 0, - /* 73d - */ 0, - /* 73e - */ 0, - /* 73f - */ 0, - /* 740 - */ 0, - /* 741 - */ 0, - /* 742 - */ 0, - /* 743 - */ 0, - /* 744 - */ 0, - /* 745 - */ 0, - /* 746 - */ 0, - /* 747 - */ 0, - /* 748 - */ 0, - /* 749 - */ 0, - /* 74a - */ 0, - /* 74b - */ 0, - /* 74c - */ 0, - /* 74d - */ 0, - /* 74e - */ 0, - /* 74f - */ 0, - /* 750 - */ 0, - /* 751 - */ 0, - /* 752 - */ 0, - /* 753 - */ 0, - /* 754 - */ 0, - /* 755 - */ 0, - /* 756 - */ 0, - /* 757 - */ 0, - /* 758 - */ 0, - /* 759 - */ 0, - /* 75a - */ 0, - /* 75b - */ 0, - /* 75c - */ 0, - /* 75d - */ 0, - /* 75e - */ 0, - /* 75f - */ 0, - /* 760 - */ 0, - /* 761 - */ 0, - /* 762 - */ 0, - /* 763 - */ 0, - /* 764 - */ 0, - /* 765 - */ 0, - /* 766 - */ 0, - /* 767 - */ 0, - /* 768 - _0F_38_80 */ 0xd098, - /* 769 - _0F_38_81 */ 0xd0a4, - /* 76a - */ 0, - /* 76b - */ 0, - /* 76c - */ 0, - /* 76d - */ 0, - /* 76e - */ 0, - /* 76f - */ 0, - /* 770 - */ 0, - /* 771 - */ 0, - /* 772 - */ 0, - /* 773 - */ 0, - /* 774 - */ 0, - /* 775 - */ 0, - /* 776 - */ 0, - /* 777 - */ 0, - /* 778 - */ 0, - /* 779 - */ 0, - /* 77a - */ 0, - /* 77b - */ 0, - /* 77c - */ 0, - /* 77d - */ 0, - /* 77e - _0F_38_96 */ 0xd0b0, - /* 77f - _0F_38_97 */ 0xd0bc, - /* 780 - _0F_38_98 */ 0xd0c8, - /* 781 - _0F_38_99 */ 0xd0d4, - /* 782 - _0F_38_9A */ 0xd0e0, - /* 783 - _0F_38_9B */ 0xd0ec, - /* 784 - _0F_38_9C */ 0xd0f8, - /* 785 - _0F_38_9D */ 0xd104, - /* 786 - _0F_38_9E */ 0xd110, - /* 787 - _0F_38_9F */ 0xd11c, - /* 788 - */ 0, - /* 789 - */ 0, - /* 78a - */ 0, - /* 78b - */ 0, - /* 78c - */ 0, - /* 78d - */ 0, - /* 78e - _0F_38_A6 */ 0xd128, - /* 78f - _0F_38_A7 */ 0xd134, - /* 790 - _0F_38_A8 */ 0xd140, - /* 791 - _0F_38_A9 */ 0xd14c, - /* 792 - _0F_38_AA */ 0xd158, - /* 793 - _0F_38_AB */ 0xd164, - /* 794 - _0F_38_AC */ 0xd170, - /* 795 - _0F_38_AD */ 0xd17c, - /* 796 - _0F_38_AE */ 0xd188, - /* 797 - _0F_38_AF */ 0xd194, - /* 798 - */ 0, - /* 799 - */ 0, - /* 79a - */ 0, - /* 79b - */ 0, - /* 79c - */ 0, - /* 79d - */ 0, - /* 79e - _0F_38_B6 */ 0xd1a0, - /* 79f - _0F_38_B7 */ 0xd1ac, - /* 7a0 - _0F_38_B8 */ 0xd1b8, - /* 7a1 - _0F_38_B9 */ 0xd1c4, - /* 7a2 - _0F_38_BA */ 0xd1d0, - /* 7a3 - _0F_38_BB */ 0xd1dc, - /* 7a4 - _0F_38_BC */ 0xd1e8, - /* 7a5 - _0F_38_BD */ 0xd1f4, - /* 7a6 - _0F_38_BE */ 0xd200, - /* 7a7 - _0F_38_BF */ 0xd20c, - /* 7a8 - */ 0, - /* 7a9 - */ 0, - /* 7aa - */ 0, - /* 7ab - */ 0, - /* 7ac - */ 0, - /* 7ad - */ 0, - /* 7ae - */ 0, - /* 7af - */ 0, - /* 7b0 - */ 0, - /* 7b1 - */ 0, - /* 7b2 - */ 0, - /* 7b3 - */ 0, - /* 7b4 - */ 0, - /* 7b5 - */ 0, - /* 7b6 - */ 0, - /* 7b7 - */ 0, - /* 7b8 - */ 0, - /* 7b9 - */ 0, - /* 7ba - */ 0, - /* 7bb - */ 0, - /* 7bc - */ 0, - /* 7bd - */ 0, - /* 7be - */ 0, - /* 7bf - */ 0, - /* 7c0 - */ 0, - /* 7c1 - */ 0, - /* 7c2 - */ 0, - /* 7c3 - _0F_38_DB */ 0xd218, - /* 7c4 - _0F_38_DC */ 0xd224, - /* 7c5 - _0F_38_DD */ 0xd230, - /* 7c6 - _0F_38_DE */ 0xd23c, - /* 7c7 - _0F_38_DF */ 0xd248, - /* 7c8 - */ 0, - /* 7c9 - */ 0, - /* 7ca - */ 0, - /* 7cb - */ 0, - /* 7cc - */ 0, - /* 7cd - */ 0, - /* 7ce - */ 0, - /* 7cf - */ 0, - /* 7d0 - */ 0, - /* 7d1 - */ 0, - /* 7d2 - */ 0, - /* 7d3 - */ 0, - /* 7d4 - */ 0, - /* 7d5 - */ 0, - /* 7d6 - */ 0, - /* 7d7 - */ 0, - /* 7d8 - _0F_38_F0 */ 0xd254, - /* 7d9 - _0F_38_F1 */ 0xd260, - /* 7da - */ 0, - /* 7db - */ 0, - /* 7dc - */ 0, - /* 7dd - */ 0, - /* 7de - */ 0, - /* 7df - */ 0, - /* 7e0 - */ 0, - /* 7e1 - */ 0, - /* 7e2 - */ 0, - /* 7e3 - */ 0, - /* 7e4 - */ 0, - /* 7e5 - */ 0, - /* 7e6 - */ 0, - /* 7e7 - */ 0, - /* 7e8 - */ 0, - /* 7e9 - */ 0, - /* 7ea - */ 0, - /* 7eb - */ 0, - /* 7ec - _0F_3A_04 */ 0xd26c, - /* 7ed - _0F_3A_05 */ 0xd278, - /* 7ee - _0F_3A_06 */ 0xd284, - /* 7ef - */ 0, - /* 7f0 - _0F_3A_08 */ 0xd290, - /* 7f1 - _0F_3A_09 */ 0xd29c, - /* 7f2 - _0F_3A_0A */ 0xd2a8, - /* 7f3 - _0F_3A_0B */ 0xd2b4, - /* 7f4 - _0F_3A_0C */ 0xd2c0, - /* 7f5 - _0F_3A_0D */ 0xd2cc, - /* 7f6 - _0F_3A_0E */ 0xd2d8, - /* 7f7 - _0F_3A_0F */ 0xd2e4, - /* 7f8 - */ 0, - /* 7f9 - */ 0, - /* 7fa - */ 0, - /* 7fb - */ 0, - /* 7fc - _0F_3A_14 */ 0xd2f0, - /* 7fd - _0F_3A_15 */ 0xd2fc, - /* 7fe - _0F_3A_16 */ 0xd308, - /* 7ff - _0F_3A_17 */ 0xd314, - /* 800 - _0F_3A_18 */ 0xd320, - /* 801 - _0F_3A_19 */ 0xd32c, - /* 802 - */ 0, - /* 803 - */ 0, - /* 804 - */ 0, - /* 805 - */ 0, - /* 806 - */ 0, - /* 807 - */ 0, - /* 808 - _0F_3A_20 */ 0xd338, - /* 809 - _0F_3A_21 */ 0xd344, - /* 80a - _0F_3A_22 */ 0xd350, - /* 80b - */ 0, - /* 80c - */ 0, - /* 80d - */ 0, - /* 80e - */ 0, - /* 80f - */ 0, - /* 810 - */ 0, - /* 811 - */ 0, - /* 812 - */ 0, - /* 813 - */ 0, - /* 814 - */ 0, - /* 815 - */ 0, - /* 816 - */ 0, - /* 817 - */ 0, - /* 818 - */ 0, - /* 819 - */ 0, - /* 81a - */ 0, - /* 81b - */ 0, - /* 81c - */ 0, - /* 81d - */ 0, - /* 81e - */ 0, - /* 81f - */ 0, - /* 820 - */ 0, - /* 821 - */ 0, - /* 822 - */ 0, - /* 823 - */ 0, - /* 824 - */ 0, - /* 825 - */ 0, - /* 826 - */ 0, - /* 827 - */ 0, - /* 828 - _0F_3A_40 */ 0xd35c, - /* 829 - _0F_3A_41 */ 0xd368, - /* 82a - _0F_3A_42 */ 0xd374, - /* 82b - */ 0, - /* 82c - _0F_3A_44 */ 0xd380, - /* 82d - */ 0, - /* 82e - */ 0, - /* 82f - */ 0, - /* 830 - */ 0, - /* 831 - */ 0, - /* 832 - _0F_3A_4A */ 0xd38c, - /* 833 - _0F_3A_4B */ 0xd398, - /* 834 - _0F_3A_4C */ 0xd3a4, - /* 835 - */ 0, - /* 836 - */ 0, - /* 837 - */ 0, - /* 838 - */ 0, - /* 839 - */ 0, - /* 83a - */ 0, - /* 83b - */ 0, - /* 83c - */ 0, - /* 83d - */ 0, - /* 83e - */ 0, - /* 83f - */ 0, - /* 840 - */ 0, - /* 841 - */ 0, - /* 842 - */ 0, - /* 843 - */ 0, - /* 844 - */ 0, - /* 845 - */ 0, - /* 846 - */ 0, - /* 847 - */ 0, - /* 848 - _0F_3A_60 */ 0xd3b0, - /* 849 - _0F_3A_61 */ 0xd3bc, - /* 84a - _0F_3A_62 */ 0xd3c8, - /* 84b - _0F_3A_63 */ 0xd3d4, - /* 84c - */ 0, - /* 84d - */ 0, - /* 84e - */ 0, - /* 84f - */ 0, - /* 850 - */ 0, - /* 851 - */ 0, - /* 852 - */ 0, - /* 853 - */ 0, - /* 854 - */ 0, - /* 855 - */ 0, - /* 856 - */ 0, - /* 857 - */ 0, - /* 858 - */ 0, - /* 859 - */ 0, - /* 85a - */ 0, - /* 85b - */ 0, - /* 85c - */ 0, - /* 85d - */ 0, - /* 85e - */ 0, - /* 85f - */ 0, - /* 860 - */ 0, - /* 861 - */ 0, - /* 862 - */ 0, - /* 863 - */ 0, - /* 864 - */ 0, - /* 865 - */ 0, - /* 866 - */ 0, - /* 867 - */ 0, - /* 868 - */ 0, - /* 869 - */ 0, - /* 86a - */ 0, - /* 86b - */ 0, - /* 86c - */ 0, - /* 86d - */ 0, - /* 86e - */ 0, - /* 86f - */ 0, - /* 870 - */ 0, - /* 871 - */ 0, - /* 872 - */ 0, - /* 873 - */ 0, - /* 874 - */ 0, - /* 875 - */ 0, - /* 876 - */ 0, - /* 877 - */ 0, - /* 878 - */ 0, - /* 879 - */ 0, - /* 87a - */ 0, - /* 87b - */ 0, - /* 87c - */ 0, - /* 87d - */ 0, - /* 87e - */ 0, - /* 87f - */ 0, - /* 880 - */ 0, - /* 881 - */ 0, - /* 882 - */ 0, - /* 883 - */ 0, - /* 884 - */ 0, - /* 885 - */ 0, - /* 886 - */ 0, - /* 887 - */ 0, - /* 888 - */ 0, - /* 889 - */ 0, - /* 88a - */ 0, - /* 88b - */ 0, - /* 88c - */ 0, - /* 88d - */ 0, - /* 88e - */ 0, - /* 88f - */ 0, - /* 890 - */ 0, - /* 891 - */ 0, - /* 892 - */ 0, - /* 893 - */ 0, - /* 894 - */ 0, - /* 895 - */ 0, - /* 896 - */ 0, - /* 897 - */ 0, - /* 898 - */ 0, - /* 899 - */ 0, - /* 89a - */ 0, - /* 89b - */ 0, - /* 89c - */ 0, - /* 89d - */ 0, - /* 89e - */ 0, - /* 89f - */ 0, - /* 8a0 - */ 0, - /* 8a1 - */ 0, - /* 8a2 - */ 0, - /* 8a3 - */ 0, - /* 8a4 - */ 0, - /* 8a5 - */ 0, - /* 8a6 - */ 0, - /* 8a7 - */ 0, - /* 8a8 - */ 0, - /* 8a9 - */ 0, - /* 8aa - */ 0, - /* 8ab - */ 0, - /* 8ac - */ 0, - /* 8ad - */ 0, - /* 8ae - */ 0, - /* 8af - */ 0, - /* 8b0 - */ 0, - /* 8b1 - */ 0, - /* 8b2 - */ 0, - /* 8b3 - */ 0, - /* 8b4 - */ 0, - /* 8b5 - */ 0, - /* 8b6 - */ 0, - /* 8b7 - */ 0, - /* 8b8 - */ 0, - /* 8b9 - */ 0, - /* 8ba - */ 0, - /* 8bb - */ 0, - /* 8bc - */ 0, - /* 8bd - */ 0, - /* 8be - */ 0, - /* 8bf - */ 0, - /* 8c0 - */ 0, - /* 8c1 - */ 0, - /* 8c2 - */ 0, - /* 8c3 - */ 0, - /* 8c4 - */ 0, - /* 8c5 - */ 0, - /* 8c6 - */ 0, - /* 8c7 - _0F_3A_DF */ 0xd3e0, - /* 8c8 - */ 0, - /* 8c9 - */ 0, - /* 8ca - */ 0, - /* 8cb - */ 0, - /* 8cc - */ 0, - /* 8cd - */ 0, - /* 8ce - */ 0, - /* 8cf - */ 0, - /* 8d0 - */ 0, - /* 8d1 - */ 0, - /* 8d2 - */ 0, - /* 8d3 - */ 0, - /* 8d4 - */ 0, - /* 8d5 - */ 0, - /* 8d6 - */ 0, - /* 8d7 - */ 0, - /* 8d8 - */ 0, - /* 8d9 - */ 0, - /* 8da - */ 0, - /* 8db - */ 0, - /* 8dc - */ 0, - /* 8dd - */ 0, - /* 8de - */ 0, - /* 8df - */ 0, - /* 8e0 - */ 0, - /* 8e1 - */ 0, - /* 8e2 - */ 0, - /* 8e3 - */ 0, - /* 8e4 - */ 0, - /* 8e5 - */ 0, - /* 8e6 - */ 0, - /* 8e7 - */ 0, - /* 8e8 - _0F_50 */ 0x23a0, - /* 8e9 - _66_0F_50 */ 0x23a1, - /* 8ea - */ 0, - /* 8eb - */ 0, - /* 8ec - */ 0, - /* 8ed - */ 0, - /* 8ee - */ 0, - /* 8ef - */ 0, - /* 8f0 - _NV_0F_50 */ 0x4036, - /* 8f1 - _NV_66_0F_50 */ 0x4037, - /* 8f2 - */ 0, - /* 8f3 - */ 0, - /* 8f4 - _0F_51 */ 0x23a2, - /* 8f5 - _66_0F_51 */ 0x23a3, - /* 8f6 - _F3_0F_51 */ 0x23a4, - /* 8f7 - _F2_0F_51 */ 0x23a5, - /* 8f8 - */ 0, - /* 8f9 - */ 0, - /* 8fa - _V_F3_0F_51 */ 0x4038, - /* 8fb - _V_F2_0F_51 */ 0x4039, - /* 8fc - _NV_0F_51 */ 0x403a, - /* 8fd - _NV_66_0F_51 */ 0x403b, - /* 8fe - */ 0, - /* 8ff - */ 0, - /* 900 - _0F_52 */ 0x23a6, - /* 901 - */ 0, - /* 902 - _F3_0F_52 */ 0x23a7, - /* 903 - */ 0, - /* 904 - */ 0, - /* 905 - */ 0, - /* 906 - _V_F3_0F_52 */ 0x403c, - /* 907 - */ 0, - /* 908 - _NV_0F_52 */ 0x403d, - /* 909 - */ 0, - /* 90a - */ 0, - /* 90b - */ 0, - /* 90c - _0F_53 */ 0x23a8, - /* 90d - */ 0, - /* 90e - _F3_0F_53 */ 0x23a9, - /* 90f - */ 0, - /* 910 - */ 0, - /* 911 - */ 0, - /* 912 - _V_F3_0F_53 */ 0x403e, - /* 913 - */ 0, - /* 914 - _NV_0F_53 */ 0x403f, - /* 915 - */ 0, - /* 916 - */ 0, - /* 917 - */ 0, - /* 918 - _0F_54 */ 0x23aa, - /* 919 - _66_0F_54 */ 0x23ab, - /* 91a - */ 0, - /* 91b - */ 0, - /* 91c - _V_0F_54 */ 0x4040, - /* 91d - _V_66_0F_54 */ 0x4041, - /* 91e - */ 0, - /* 91f - */ 0, - /* 920 - */ 0, - /* 921 - */ 0, - /* 922 - */ 0, - /* 923 - */ 0, - /* 924 - _0F_55 */ 0x23ac, - /* 925 - _66_0F_55 */ 0x23ad, - /* 926 - */ 0, - /* 927 - */ 0, - /* 928 - _V_0F_55 */ 0x4042, - /* 929 - _V_66_0F_55 */ 0x4043, - /* 92a - */ 0, - /* 92b - */ 0, - /* 92c - */ 0, - /* 92d - */ 0, - /* 92e - */ 0, - /* 92f - */ 0, - /* 930 - _0F_56 */ 0x23ae, - /* 931 - _66_0F_56 */ 0x23af, - /* 932 - */ 0, - /* 933 - */ 0, - /* 934 - _V_0F_56 */ 0x4044, - /* 935 - _V_66_0F_56 */ 0x4045, - /* 936 - */ 0, - /* 937 - */ 0, - /* 938 - */ 0, - /* 939 - */ 0, - /* 93a - */ 0, - /* 93b - */ 0, - /* 93c - _0F_57 */ 0x23b0, - /* 93d - _66_0F_57 */ 0x23b1, - /* 93e - */ 0, - /* 93f - */ 0, - /* 940 - _V_0F_57 */ 0x4046, - /* 941 - _V_66_0F_57 */ 0x4047, - /* 942 - */ 0, - /* 943 - */ 0, - /* 944 - */ 0, - /* 945 - */ 0, - /* 946 - */ 0, - /* 947 - */ 0, - /* 948 - _0F_58 */ 0x23b2, - /* 949 - _66_0F_58 */ 0x23b3, - /* 94a - _F3_0F_58 */ 0x23b4, - /* 94b - _F2_0F_58 */ 0x23b5, - /* 94c - _V_0F_58 */ 0x4048, - /* 94d - _V_66_0F_58 */ 0x4049, - /* 94e - _V_F3_0F_58 */ 0x404a, - /* 94f - _V_F2_0F_58 */ 0x404b, - /* 950 - */ 0, - /* 951 - */ 0, - /* 952 - */ 0, - /* 953 - */ 0, - /* 954 - _0F_59 */ 0x23b6, - /* 955 - _66_0F_59 */ 0x23b7, - /* 956 - _F3_0F_59 */ 0x23b8, - /* 957 - _F2_0F_59 */ 0x23b9, - /* 958 - _V_0F_59 */ 0x404c, - /* 959 - _V_66_0F_59 */ 0x404d, - /* 95a - _V_F3_0F_59 */ 0x404e, - /* 95b - _V_F2_0F_59 */ 0x404f, - /* 95c - */ 0, - /* 95d - */ 0, - /* 95e - */ 0, - /* 95f - */ 0, - /* 960 - _0F_5A */ 0x23ba, - /* 961 - _66_0F_5A */ 0x23bb, - /* 962 - _F3_0F_5A */ 0x23bc, - /* 963 - _F2_0F_5A */ 0x23bd, - /* 964 - */ 0, - /* 965 - */ 0, - /* 966 - _V_F3_0F_5A */ 0x4050, - /* 967 - _V_F2_0F_5A */ 0x4051, - /* 968 - _NV_0F_5A */ 0x4052, - /* 969 - _NV_66_0F_5A */ 0x4053, - /* 96a - */ 0, - /* 96b - */ 0, - /* 96c - _0F_5B */ 0x23be, - /* 96d - _66_0F_5B */ 0x23bf, - /* 96e - _F3_0F_5B */ 0x23c0, - /* 96f - */ 0, - /* 970 - */ 0, - /* 971 - */ 0, - /* 972 - */ 0, - /* 973 - */ 0, - /* 974 - _NV_0F_5B */ 0x4054, - /* 975 - _NV_66_0F_5B */ 0x4055, - /* 976 - _NV_F3_0F_5B */ 0x4056, - /* 977 - */ 0, - /* 978 - _0F_5C */ 0x23c1, - /* 979 - _66_0F_5C */ 0x23c2, - /* 97a - _F3_0F_5C */ 0x23c3, - /* 97b - _F2_0F_5C */ 0x23c4, - /* 97c - _V_0F_5C */ 0x4057, - /* 97d - _V_66_0F_5C */ 0x4058, - /* 97e - _V_F3_0F_5C */ 0x4059, - /* 97f - _V_F2_0F_5C */ 0x405a, - /* 980 - */ 0, - /* 981 - */ 0, - /* 982 - */ 0, - /* 983 - */ 0, - /* 984 - _0F_5D */ 0x23c5, - /* 985 - _66_0F_5D */ 0x23c6, - /* 986 - _F3_0F_5D */ 0x23c7, - /* 987 - _F2_0F_5D */ 0x23c8, - /* 988 - _V_0F_5D */ 0x405b, - /* 989 - _V_66_0F_5D */ 0x405c, - /* 98a - _V_F3_0F_5D */ 0x405d, - /* 98b - _V_F2_0F_5D */ 0x405e, - /* 98c - */ 0, - /* 98d - */ 0, - /* 98e - */ 0, - /* 98f - */ 0, - /* 990 - _0F_5E */ 0x23c9, - /* 991 - _66_0F_5E */ 0x23ca, - /* 992 - _F3_0F_5E */ 0x23cb, - /* 993 - _F2_0F_5E */ 0x23cc, - /* 994 - _V_0F_5E */ 0x405f, - /* 995 - _V_66_0F_5E */ 0x4060, - /* 996 - _V_F3_0F_5E */ 0x4061, - /* 997 - _V_F2_0F_5E */ 0x4062, - /* 998 - */ 0, - /* 999 - */ 0, - /* 99a - */ 0, - /* 99b - */ 0, - /* 99c - _0F_5F */ 0x23cd, - /* 99d - _66_0F_5F */ 0x23ce, - /* 99e - _F3_0F_5F */ 0x23cf, - /* 99f - _F2_0F_5F */ 0x23d0, - /* 9a0 - _V_0F_5F */ 0x4063, - /* 9a1 - _V_66_0F_5F */ 0x4064, - /* 9a2 - _V_F3_0F_5F */ 0x4065, - /* 9a3 - _V_F2_0F_5F */ 0x4066, - /* 9a4 - */ 0, - /* 9a5 - */ 0, - /* 9a6 - */ 0, - /* 9a7 - */ 0, - /* 9a8 - _0F_60 */ 0x23d1, - /* 9a9 - _66_0F_60 */ 0x23d2, - /* 9aa - */ 0, - /* 9ab - */ 0, - /* 9ac - */ 0, - /* 9ad - _V_66_0F_60 */ 0x4067, - /* 9ae - */ 0, - /* 9af - */ 0, - /* 9b0 - */ 0, - /* 9b1 - */ 0, - /* 9b2 - */ 0, - /* 9b3 - */ 0, - /* 9b4 - _0F_61 */ 0x23d3, - /* 9b5 - _66_0F_61 */ 0x23d4, - /* 9b6 - */ 0, - /* 9b7 - */ 0, - /* 9b8 - */ 0, - /* 9b9 - _V_66_0F_61 */ 0x4068, - /* 9ba - */ 0, - /* 9bb - */ 0, - /* 9bc - */ 0, - /* 9bd - */ 0, - /* 9be - */ 0, - /* 9bf - */ 0, - /* 9c0 - _0F_62 */ 0x23d5, - /* 9c1 - _66_0F_62 */ 0x23d6, - /* 9c2 - */ 0, - /* 9c3 - */ 0, - /* 9c4 - */ 0, - /* 9c5 - _V_66_0F_62 */ 0x4069, - /* 9c6 - */ 0, - /* 9c7 - */ 0, - /* 9c8 - */ 0, - /* 9c9 - */ 0, - /* 9ca - */ 0, - /* 9cb - */ 0, - /* 9cc - _0F_63 */ 0x23d7, - /* 9cd - _66_0F_63 */ 0x23d8, - /* 9ce - */ 0, - /* 9cf - */ 0, - /* 9d0 - */ 0, - /* 9d1 - _V_66_0F_63 */ 0x406a, - /* 9d2 - */ 0, - /* 9d3 - */ 0, - /* 9d4 - */ 0, - /* 9d5 - */ 0, - /* 9d6 - */ 0, - /* 9d7 - */ 0, - /* 9d8 - _0F_64 */ 0x23d9, - /* 9d9 - _66_0F_64 */ 0x23da, - /* 9da - */ 0, - /* 9db - */ 0, - /* 9dc - */ 0, - /* 9dd - _V_66_0F_64 */ 0x406b, - /* 9de - */ 0, - /* 9df - */ 0, - /* 9e0 - */ 0, - /* 9e1 - */ 0, - /* 9e2 - */ 0, - /* 9e3 - */ 0, - /* 9e4 - _0F_65 */ 0x23db, - /* 9e5 - _66_0F_65 */ 0x23dc, - /* 9e6 - */ 0, - /* 9e7 - */ 0, - /* 9e8 - */ 0, - /* 9e9 - _V_66_0F_65 */ 0x406c, - /* 9ea - */ 0, - /* 9eb - */ 0, - /* 9ec - */ 0, - /* 9ed - */ 0, - /* 9ee - */ 0, - /* 9ef - */ 0, - /* 9f0 - _0F_66 */ 0x23dd, - /* 9f1 - _66_0F_66 */ 0x23de, - /* 9f2 - */ 0, - /* 9f3 - */ 0, - /* 9f4 - */ 0, - /* 9f5 - _V_66_0F_66 */ 0x406d, - /* 9f6 - */ 0, - /* 9f7 - */ 0, - /* 9f8 - */ 0, - /* 9f9 - */ 0, - /* 9fa - */ 0, - /* 9fb - */ 0, - /* 9fc - _0F_67 */ 0x23df, - /* 9fd - _66_0F_67 */ 0x23e0, - /* 9fe - */ 0, - /* 9ff - */ 0, - /* a00 - */ 0, - /* a01 - _V_66_0F_67 */ 0x406e, - /* a02 - */ 0, - /* a03 - */ 0, - /* a04 - */ 0, - /* a05 - */ 0, - /* a06 - */ 0, - /* a07 - */ 0, - /* a08 - _0F_68 */ 0x23e1, - /* a09 - _66_0F_68 */ 0x23e2, - /* a0a - */ 0, - /* a0b - */ 0, - /* a0c - */ 0, - /* a0d - _V_66_0F_68 */ 0x406f, - /* a0e - */ 0, - /* a0f - */ 0, - /* a10 - */ 0, - /* a11 - */ 0, - /* a12 - */ 0, - /* a13 - */ 0, - /* a14 - _0F_69 */ 0x23e3, - /* a15 - _66_0F_69 */ 0x23e4, - /* a16 - */ 0, - /* a17 - */ 0, - /* a18 - */ 0, - /* a19 - _V_66_0F_69 */ 0x4070, - /* a1a - */ 0, - /* a1b - */ 0, - /* a1c - */ 0, - /* a1d - */ 0, - /* a1e - */ 0, - /* a1f - */ 0, - /* a20 - _0F_6A */ 0x23e5, - /* a21 - _66_0F_6A */ 0x23e6, - /* a22 - */ 0, - /* a23 - */ 0, - /* a24 - */ 0, - /* a25 - _V_66_0F_6A */ 0x4071, - /* a26 - */ 0, - /* a27 - */ 0, - /* a28 - */ 0, - /* a29 - */ 0, - /* a2a - */ 0, - /* a2b - */ 0, - /* a2c - _0F_6B */ 0x23e7, - /* a2d - _66_0F_6B */ 0x23e8, - /* a2e - */ 0, - /* a2f - */ 0, - /* a30 - */ 0, - /* a31 - _V_66_0F_6B */ 0x4072, - /* a32 - */ 0, - /* a33 - */ 0, - /* a34 - */ 0, - /* a35 - */ 0, - /* a36 - */ 0, - /* a37 - */ 0, - /* a38 - */ 0, - /* a39 - _66_0F_6C */ 0x23e9, - /* a3a - */ 0, - /* a3b - */ 0, - /* a3c - */ 0, - /* a3d - _V_66_0F_6C */ 0x4073, - /* a3e - */ 0, - /* a3f - */ 0, - /* a40 - */ 0, - /* a41 - */ 0, - /* a42 - */ 0, - /* a43 - */ 0, - /* a44 - */ 0, - /* a45 - _66_0F_6D */ 0x23ea, - /* a46 - */ 0, - /* a47 - */ 0, - /* a48 - */ 0, - /* a49 - _V_66_0F_6D */ 0x4074, - /* a4a - */ 0, - /* a4b - */ 0, - /* a4c - */ 0, - /* a4d - */ 0, - /* a4e - */ 0, - /* a4f - */ 0, - /* a50 - _0F_6E */ 0x4075, - /* a51 - _66_0F_6E */ 0x4076, - /* a52 - */ 0, - /* a53 - */ 0, - /* a54 - */ 0, - /* a55 - */ 0, - /* a56 - */ 0, - /* a57 - */ 0, - /* a58 - */ 0, - /* a59 - _NV_66_0F_6E */ 0x4077, - /* a5a - */ 0, - /* a5b - */ 0, - /* a5c - _0F_6F */ 0x23eb, - /* a5d - _66_0F_6F */ 0x23ec, - /* a5e - _F3_0F_6F */ 0x23ed, - /* a5f - */ 0, - /* a60 - */ 0, - /* a61 - */ 0, - /* a62 - */ 0, - /* a63 - */ 0, - /* a64 - */ 0, - /* a65 - _NV_66_0F_6F */ 0x4078, - /* a66 - _NV_F3_0F_6F */ 0x4079, - /* a67 - */ 0, - /* a68 - _0F_70 */ 0x407a, - /* a69 - _66_0F_70 */ 0x407b, - /* a6a - _F3_0F_70 */ 0x407c, - /* a6b - _F2_0F_70 */ 0x407d, - /* a6c - */ 0, - /* a6d - */ 0, - /* a6e - */ 0, - /* a6f - */ 0, - /* a70 - */ 0, - /* a71 - _NV_66_0F_70 */ 0x407e, - /* a72 - _NV_F3_0F_70 */ 0x407f, - /* a73 - _NV_F2_0F_70 */ 0x4080, - /* a74 - */ 0, - /* a75 - */ 0, - /* a76 - _0F_71_02 */ 0xd3ec, - /* a77 - */ 0, - /* a78 - _0F_71_04 */ 0xd3f8, - /* a79 - */ 0, - /* a7a - _0F_71_06 */ 0xd404, - /* a7b - */ 0, - /* a7c - */ 0, - /* a7d - */ 0, - /* a7e - _0F_72_02 */ 0xd410, - /* a7f - */ 0, - /* a80 - _0F_72_04 */ 0xd41c, - /* a81 - */ 0, - /* a82 - _0F_72_06 */ 0xd428, - /* a83 - */ 0, - /* a84 - */ 0, - /* a85 - */ 0, - /* a86 - _0F_73_02 */ 0xd434, - /* a87 - _0F_73_03 */ 0xd440, - /* a88 - */ 0, - /* a89 - */ 0, - /* a8a - _0F_73_06 */ 0xd44c, - /* a8b - _0F_73_07 */ 0xd458, - /* a8c - _0F_74 */ 0x23ee, - /* a8d - _66_0F_74 */ 0x23ef, - /* a8e - */ 0, - /* a8f - */ 0, - /* a90 - */ 0, - /* a91 - _V_66_0F_74 */ 0x4081, - /* a92 - */ 0, - /* a93 - */ 0, - /* a94 - */ 0, - /* a95 - */ 0, - /* a96 - */ 0, - /* a97 - */ 0, - /* a98 - _0F_75 */ 0x23f0, - /* a99 - _66_0F_75 */ 0x23f1, - /* a9a - */ 0, - /* a9b - */ 0, - /* a9c - */ 0, - /* a9d - _V_66_0F_75 */ 0x4082, - /* a9e - */ 0, - /* a9f - */ 0, - /* aa0 - */ 0, - /* aa1 - */ 0, - /* aa2 - */ 0, - /* aa3 - */ 0, - /* aa4 - _0F_76 */ 0x23f2, - /* aa5 - _66_0F_76 */ 0x23f3, - /* aa6 - */ 0, - /* aa7 - */ 0, - /* aa8 - */ 0, - /* aa9 - _V_66_0F_76 */ 0x4083, - /* aaa - */ 0, - /* aab - */ 0, - /* aac - */ 0, - /* aad - */ 0, - /* aae - */ 0, - /* aaf - */ 0, - /* ab0 - _0F_77 */ 0x23f4, - /* ab1 - */ 0, - /* ab2 - */ 0, - /* ab3 - */ 0, - /* ab4 - */ 0, - /* ab5 - */ 0, - /* ab6 - */ 0, - /* ab7 - */ 0, - /* ab8 - _NV_0F_77 */ 0x4084, - /* ab9 - */ 0, - /* aba - */ 0, - /* abb - */ 0, - /* abc - _0F_78 */ 0x23f5, - /* abd - _66_0F_78 */ 0x4085, - /* abe - */ 0, - /* abf - _F2_0F_78 */ 0x4086, - /* ac0 - */ 0, - /* ac1 - */ 0, - /* ac2 - */ 0, - /* ac3 - */ 0, - /* ac4 - */ 0, - /* ac5 - */ 0, - /* ac6 - */ 0, - /* ac7 - */ 0, - /* ac8 - _0F_79 */ 0x23f6, - /* ac9 - _66_0F_79 */ 0x23f7, - /* aca - */ 0, - /* acb - _F2_0F_79 */ 0x23f8, - /* acc - */ 0, - /* acd - */ 0, - /* ace - */ 0, - /* acf - */ 0, - /* ad0 - */ 0, - /* ad1 - */ 0, - /* ad2 - */ 0, - /* ad3 - */ 0, - /* ad4 - */ 0, - /* ad5 - _66_0F_7C */ 0x23f9, - /* ad6 - */ 0, - /* ad7 - _F2_0F_7C */ 0x23fa, - /* ad8 - */ 0, - /* ad9 - _V_66_0F_7C */ 0x4087, - /* ada - */ 0, - /* adb - _V_F2_0F_7C */ 0x4088, - /* adc - */ 0, - /* add - */ 0, - /* ade - */ 0, - /* adf - */ 0, - /* ae0 - */ 0, - /* ae1 - _66_0F_7D */ 0x23fb, - /* ae2 - */ 0, - /* ae3 - _F2_0F_7D */ 0x23fc, - /* ae4 - */ 0, - /* ae5 - _V_66_0F_7D */ 0x4089, - /* ae6 - */ 0, - /* ae7 - _V_F2_0F_7D */ 0x408a, - /* ae8 - */ 0, - /* ae9 - */ 0, - /* aea - */ 0, - /* aeb - */ 0, - /* aec - _0F_7E */ 0x408b, - /* aed - _66_0F_7E */ 0x408c, - /* aee - _F3_0F_7E */ 0x23fd, - /* aef - */ 0, - /* af0 - */ 0, - /* af1 - */ 0, - /* af2 - */ 0, - /* af3 - */ 0, - /* af4 - */ 0, - /* af5 - _NV_66_0F_7E */ 0x408d, - /* af6 - _NV_F3_0F_7E */ 0x408e, - /* af7 - */ 0, - /* af8 - _0F_7F */ 0x23fe, - /* af9 - _66_0F_7F */ 0x23ff, - /* afa - _F3_0F_7F */ 0x2400, - /* afb - */ 0, - /* afc - */ 0, - /* afd - */ 0, - /* afe - */ 0, - /* aff - */ 0, - /* b00 - */ 0, - /* b01 - _NV_66_0F_7F */ 0x408f, - /* b02 - _NV_F3_0F_7F */ 0x4090, - /* b03 - */ 0, - /* b04 - _0F_AE_00 */ 0x2401, - /* b05 - _0F_AE_01 */ 0x2402, - /* b06 - _0F_AE_02 */ 0xd464, - /* b07 - _0F_AE_03 */ 0xd470, - /* b08 - _0F_AE_04 */ 0x2403, - /* b09 - _0F_AE_05 */ 0x4091, - /* b0a - _0F_AE_06 */ 0x2404, - /* b0b - _0F_AE_07 */ 0x4092, - /* b0c - */ 0, - /* b0d - */ 0, - /* b0e - _F3_0F_B8 */ 0x2405, - /* b0f - */ 0, - /* b10 - */ 0, - /* b11 - */ 0, - /* b12 - */ 0, - /* b13 - */ 0, - /* b14 - */ 0, - /* b15 - */ 0, - /* b16 - */ 0, - /* b17 - */ 0, - /* b18 - */ 0, - /* b19 - */ 0, - /* b1a - */ 0, - /* b1b - */ 0, - /* b1c - _0F_BA_04 */ 0x2406, - /* b1d - _0F_BA_05 */ 0x2407, - /* b1e - _0F_BA_06 */ 0x2408, - /* b1f - _0F_BA_07 */ 0x2409, - /* b20 - _0F_BD */ 0x240a, - /* b21 - */ 0, - /* b22 - _F3_0F_BD */ 0x240b, - /* b23 - */ 0, - /* b24 - */ 0, - /* b25 - */ 0, - /* b26 - */ 0, - /* b27 - */ 0, - /* b28 - */ 0, - /* b29 - */ 0, - /* b2a - */ 0, - /* b2b - */ 0, - /* b2c - _0F_C2 */ 0x4093, - /* b2d - _66_0F_C2 */ 0x4094, - /* b2e - _F3_0F_C2 */ 0x4095, - /* b2f - _F2_0F_C2 */ 0x4096, - /* b30 - _V_0F_C2 */ 0x4097, - /* b31 - _V_66_0F_C2 */ 0x4098, - /* b32 - _V_F3_0F_C2 */ 0x4099, - /* b33 - _V_F2_0F_C2 */ 0x409a, - /* b34 - */ 0, - /* b35 - */ 0, - /* b36 - */ 0, - /* b37 - */ 0, - /* b38 - _0F_C4 */ 0x409b, - /* b39 - _66_0F_C4 */ 0x409c, - /* b3a - */ 0, - /* b3b - */ 0, - /* b3c - */ 0, - /* b3d - _V_66_0F_C4 */ 0x409d, - /* b3e - */ 0, - /* b3f - */ 0, - /* b40 - */ 0, - /* b41 - */ 0, - /* b42 - */ 0, - /* b43 - */ 0, - /* b44 - _0F_C5 */ 0x409e, - /* b45 - _66_0F_C5 */ 0x409f, - /* b46 - */ 0, - /* b47 - */ 0, - /* b48 - */ 0, - /* b49 - */ 0, - /* b4a - */ 0, - /* b4b - */ 0, - /* b4c - */ 0, - /* b4d - _NV_66_0F_C5 */ 0x40a0, - /* b4e - */ 0, - /* b4f - */ 0, - /* b50 - _0F_C6 */ 0x40a1, - /* b51 - _66_0F_C6 */ 0x40a2, - /* b52 - */ 0, - /* b53 - */ 0, - /* b54 - _V_0F_C6 */ 0x40a3, - /* b55 - _V_66_0F_C6 */ 0x40a4, - /* b56 - */ 0, - /* b57 - */ 0, - /* b58 - */ 0, - /* b59 - */ 0, - /* b5a - */ 0, - /* b5b - */ 0, - /* b5c - */ 0, - /* b5d - _0F_C7_01 */ 0x40a5, - /* b5e - */ 0, - /* b5f - */ 0, - /* b60 - */ 0, - /* b61 - */ 0, - /* b62 - _0F_C7_06 */ 0xd47c, - /* b63 - _0F_C7_07 */ 0x240c, - /* b64 - */ 0, - /* b65 - _66_0F_D0 */ 0x240d, - /* b66 - */ 0, - /* b67 - _F2_0F_D0 */ 0x240e, - /* b68 - */ 0, - /* b69 - _V_66_0F_D0 */ 0x40a6, - /* b6a - */ 0, - /* b6b - _V_F2_0F_D0 */ 0x40a7, - /* b6c - */ 0, - /* b6d - */ 0, - /* b6e - */ 0, - /* b6f - */ 0, - /* b70 - _0F_D1 */ 0x240f, - /* b71 - _66_0F_D1 */ 0x2410, - /* b72 - */ 0, - /* b73 - */ 0, - /* b74 - */ 0, - /* b75 - _V_66_0F_D1 */ 0x40a8, - /* b76 - */ 0, - /* b77 - */ 0, - /* b78 - */ 0, - /* b79 - */ 0, - /* b7a - */ 0, - /* b7b - */ 0, - /* b7c - _0F_D2 */ 0x2411, - /* b7d - _66_0F_D2 */ 0x2412, - /* b7e - */ 0, - /* b7f - */ 0, - /* b80 - */ 0, - /* b81 - _V_66_0F_D2 */ 0x40a9, - /* b82 - */ 0, - /* b83 - */ 0, - /* b84 - */ 0, - /* b85 - */ 0, - /* b86 - */ 0, - /* b87 - */ 0, - /* b88 - _0F_D3 */ 0x2413, - /* b89 - _66_0F_D3 */ 0x2414, - /* b8a - */ 0, - /* b8b - */ 0, - /* b8c - */ 0, - /* b8d - _V_66_0F_D3 */ 0x40aa, - /* b8e - */ 0, - /* b8f - */ 0, - /* b90 - */ 0, - /* b91 - */ 0, - /* b92 - */ 0, - /* b93 - */ 0, - /* b94 - _0F_D4 */ 0x2415, - /* b95 - _66_0F_D4 */ 0x2416, - /* b96 - */ 0, - /* b97 - */ 0, - /* b98 - */ 0, - /* b99 - _V_66_0F_D4 */ 0x40ab, - /* b9a - */ 0, - /* b9b - */ 0, - /* b9c - */ 0, - /* b9d - */ 0, - /* b9e - */ 0, - /* b9f - */ 0, - /* ba0 - _0F_D5 */ 0x2417, - /* ba1 - _66_0F_D5 */ 0x2418, - /* ba2 - */ 0, - /* ba3 - */ 0, - /* ba4 - */ 0, - /* ba5 - _V_66_0F_D5 */ 0x40ac, - /* ba6 - */ 0, - /* ba7 - */ 0, - /* ba8 - */ 0, - /* ba9 - */ 0, - /* baa - */ 0, - /* bab - */ 0, - /* bac - */ 0, - /* bad - _66_0F_D6 */ 0x2419, - /* bae - _F3_0F_D6 */ 0x241a, - /* baf - _F2_0F_D6 */ 0x241b, - /* bb0 - */ 0, - /* bb1 - */ 0, - /* bb2 - */ 0, - /* bb3 - */ 0, - /* bb4 - */ 0, - /* bb5 - _NV_66_0F_D6 */ 0x40ad, - /* bb6 - */ 0, - /* bb7 - */ 0, - /* bb8 - _0F_D7 */ 0x241c, - /* bb9 - _66_0F_D7 */ 0x241d, - /* bba - */ 0, - /* bbb - */ 0, - /* bbc - */ 0, - /* bbd - */ 0, - /* bbe - */ 0, - /* bbf - */ 0, - /* bc0 - */ 0, - /* bc1 - _NV_66_0F_D7 */ 0x40ae, - /* bc2 - */ 0, - /* bc3 - */ 0, - /* bc4 - _0F_D8 */ 0x241e, - /* bc5 - _66_0F_D8 */ 0x241f, - /* bc6 - */ 0, - /* bc7 - */ 0, - /* bc8 - */ 0, - /* bc9 - _V_66_0F_D8 */ 0x40af, - /* bca - */ 0, - /* bcb - */ 0, - /* bcc - */ 0, - /* bcd - */ 0, - /* bce - */ 0, - /* bcf - */ 0, - /* bd0 - _0F_D9 */ 0x2420, - /* bd1 - _66_0F_D9 */ 0x2421, - /* bd2 - */ 0, - /* bd3 - */ 0, - /* bd4 - */ 0, - /* bd5 - _V_66_0F_D9 */ 0x40b0, - /* bd6 - */ 0, - /* bd7 - */ 0, - /* bd8 - */ 0, - /* bd9 - */ 0, - /* bda - */ 0, - /* bdb - */ 0, - /* bdc - _0F_DA */ 0x2422, - /* bdd - _66_0F_DA */ 0x2423, - /* bde - */ 0, - /* bdf - */ 0, - /* be0 - */ 0, - /* be1 - _V_66_0F_DA */ 0x40b1, - /* be2 - */ 0, - /* be3 - */ 0, - /* be4 - */ 0, - /* be5 - */ 0, - /* be6 - */ 0, - /* be7 - */ 0, - /* be8 - _0F_DB */ 0x2424, - /* be9 - _66_0F_DB */ 0x2425, - /* bea - */ 0, - /* beb - */ 0, - /* bec - */ 0, - /* bed - _V_66_0F_DB */ 0x40b2, - /* bee - */ 0, - /* bef - */ 0, - /* bf0 - */ 0, - /* bf1 - */ 0, - /* bf2 - */ 0, - /* bf3 - */ 0, - /* bf4 - _0F_DC */ 0x2426, - /* bf5 - _66_0F_DC */ 0x2427, - /* bf6 - */ 0, - /* bf7 - */ 0, - /* bf8 - */ 0, - /* bf9 - _V_66_0F_DC */ 0x40b3, - /* bfa - */ 0, - /* bfb - */ 0, - /* bfc - */ 0, - /* bfd - */ 0, - /* bfe - */ 0, - /* bff - */ 0, - /* c00 - _0F_DD */ 0x2428, - /* c01 - _66_0F_DD */ 0x2429, - /* c02 - */ 0, - /* c03 - */ 0, - /* c04 - */ 0, - /* c05 - _V_66_0F_DD */ 0x40b4, - /* c06 - */ 0, - /* c07 - */ 0, - /* c08 - */ 0, - /* c09 - */ 0, - /* c0a - */ 0, - /* c0b - */ 0, - /* c0c - _0F_DE */ 0x242a, - /* c0d - _66_0F_DE */ 0x242b, - /* c0e - */ 0, - /* c0f - */ 0, - /* c10 - */ 0, - /* c11 - _V_66_0F_DE */ 0x40b5, - /* c12 - */ 0, - /* c13 - */ 0, - /* c14 - */ 0, - /* c15 - */ 0, - /* c16 - */ 0, - /* c17 - */ 0, - /* c18 - _0F_DF */ 0x242c, - /* c19 - _66_0F_DF */ 0x242d, - /* c1a - */ 0, - /* c1b - */ 0, - /* c1c - */ 0, - /* c1d - _V_66_0F_DF */ 0x40b6, - /* c1e - */ 0, - /* c1f - */ 0, - /* c20 - */ 0, - /* c21 - */ 0, - /* c22 - */ 0, - /* c23 - */ 0, - /* c24 - _0F_E0 */ 0x242e, - /* c25 - _66_0F_E0 */ 0x242f, - /* c26 - */ 0, - /* c27 - */ 0, - /* c28 - */ 0, - /* c29 - _V_66_0F_E0 */ 0x40b7, - /* c2a - */ 0, - /* c2b - */ 0, - /* c2c - */ 0, - /* c2d - */ 0, - /* c2e - */ 0, - /* c2f - */ 0, - /* c30 - _0F_E1 */ 0x2430, - /* c31 - _66_0F_E1 */ 0x2431, - /* c32 - */ 0, - /* c33 - */ 0, - /* c34 - */ 0, - /* c35 - _V_66_0F_E1 */ 0x40b8, - /* c36 - */ 0, - /* c37 - */ 0, - /* c38 - */ 0, - /* c39 - */ 0, - /* c3a - */ 0, - /* c3b - */ 0, - /* c3c - _0F_E2 */ 0x2432, - /* c3d - _66_0F_E2 */ 0x2433, - /* c3e - */ 0, - /* c3f - */ 0, - /* c40 - */ 0, - /* c41 - _V_66_0F_E2 */ 0x40b9, - /* c42 - */ 0, - /* c43 - */ 0, - /* c44 - */ 0, - /* c45 - */ 0, - /* c46 - */ 0, - /* c47 - */ 0, - /* c48 - _0F_E3 */ 0x2434, - /* c49 - _66_0F_E3 */ 0x2435, - /* c4a - */ 0, - /* c4b - */ 0, - /* c4c - */ 0, - /* c4d - _V_66_0F_E3 */ 0x40ba, - /* c4e - */ 0, - /* c4f - */ 0, - /* c50 - */ 0, - /* c51 - */ 0, - /* c52 - */ 0, - /* c53 - */ 0, - /* c54 - _0F_E4 */ 0x2436, - /* c55 - _66_0F_E4 */ 0x2437, - /* c56 - */ 0, - /* c57 - */ 0, - /* c58 - */ 0, - /* c59 - _V_66_0F_E4 */ 0x40bb, - /* c5a - */ 0, - /* c5b - */ 0, - /* c5c - */ 0, - /* c5d - */ 0, - /* c5e - */ 0, - /* c5f - */ 0, - /* c60 - _0F_E5 */ 0x2438, - /* c61 - _66_0F_E5 */ 0x2439, - /* c62 - */ 0, - /* c63 - */ 0, - /* c64 - */ 0, - /* c65 - _V_66_0F_E5 */ 0x40bc, - /* c66 - */ 0, - /* c67 - */ 0, - /* c68 - */ 0, - /* c69 - */ 0, - /* c6a - */ 0, - /* c6b - */ 0, - /* c6c - */ 0, - /* c6d - _66_0F_E6 */ 0x243a, - /* c6e - _F3_0F_E6 */ 0x243b, - /* c6f - _F2_0F_E6 */ 0x243c, - /* c70 - */ 0, - /* c71 - */ 0, - /* c72 - */ 0, - /* c73 - */ 0, - /* c74 - */ 0, - /* c75 - _NV_66_0F_E6 */ 0x40bd, - /* c76 - _NV_F3_0F_E6 */ 0x40be, - /* c77 - _NV_F2_0F_E6 */ 0x40bf, - /* c78 - _0F_E7 */ 0x243d, - /* c79 - _66_0F_E7 */ 0x243e, - /* c7a - */ 0, - /* c7b - */ 0, - /* c7c - */ 0, - /* c7d - */ 0, - /* c7e - */ 0, - /* c7f - */ 0, - /* c80 - */ 0, - /* c81 - _NV_66_0F_E7 */ 0x40c0, - /* c82 - */ 0, - /* c83 - */ 0, - /* c84 - _0F_E8 */ 0x243f, - /* c85 - _66_0F_E8 */ 0x2440, - /* c86 - */ 0, - /* c87 - */ 0, - /* c88 - */ 0, - /* c89 - _V_66_0F_E8 */ 0x40c1, - /* c8a - */ 0, - /* c8b - */ 0, - /* c8c - */ 0, - /* c8d - */ 0, - /* c8e - */ 0, - /* c8f - */ 0, - /* c90 - _0F_E9 */ 0x2441, - /* c91 - _66_0F_E9 */ 0x2442, - /* c92 - */ 0, - /* c93 - */ 0, - /* c94 - */ 0, - /* c95 - _V_66_0F_E9 */ 0x40c2, - /* c96 - */ 0, - /* c97 - */ 0, - /* c98 - */ 0, - /* c99 - */ 0, - /* c9a - */ 0, - /* c9b - */ 0, - /* c9c - _0F_EA */ 0x2443, - /* c9d - _66_0F_EA */ 0x2444, - /* c9e - */ 0, - /* c9f - */ 0, - /* ca0 - */ 0, - /* ca1 - _V_66_0F_EA */ 0x40c3, - /* ca2 - */ 0, - /* ca3 - */ 0, - /* ca4 - */ 0, - /* ca5 - */ 0, - /* ca6 - */ 0, - /* ca7 - */ 0, - /* ca8 - _0F_EB */ 0x2445, - /* ca9 - _66_0F_EB */ 0x2446, - /* caa - */ 0, - /* cab - */ 0, - /* cac - */ 0, - /* cad - _V_66_0F_EB */ 0x40c4, - /* cae - */ 0, - /* caf - */ 0, - /* cb0 - */ 0, - /* cb1 - */ 0, - /* cb2 - */ 0, - /* cb3 - */ 0, - /* cb4 - _0F_EC */ 0x2447, - /* cb5 - _66_0F_EC */ 0x2448, - /* cb6 - */ 0, - /* cb7 - */ 0, - /* cb8 - */ 0, - /* cb9 - _V_66_0F_EC */ 0x40c5, - /* cba - */ 0, - /* cbb - */ 0, - /* cbc - */ 0, - /* cbd - */ 0, - /* cbe - */ 0, - /* cbf - */ 0, - /* cc0 - _0F_ED */ 0x2449, - /* cc1 - _66_0F_ED */ 0x244a, - /* cc2 - */ 0, - /* cc3 - */ 0, - /* cc4 - */ 0, - /* cc5 - _V_66_0F_ED */ 0x40c6, - /* cc6 - */ 0, - /* cc7 - */ 0, - /* cc8 - */ 0, - /* cc9 - */ 0, - /* cca - */ 0, - /* ccb - */ 0, - /* ccc - _0F_EE */ 0x244b, - /* ccd - _66_0F_EE */ 0x244c, - /* cce - */ 0, - /* ccf - */ 0, - /* cd0 - */ 0, - /* cd1 - _V_66_0F_EE */ 0x40c7, - /* cd2 - */ 0, - /* cd3 - */ 0, - /* cd4 - */ 0, - /* cd5 - */ 0, - /* cd6 - */ 0, - /* cd7 - */ 0, - /* cd8 - _0F_EF */ 0x244d, - /* cd9 - _66_0F_EF */ 0x244e, - /* cda - */ 0, - /* cdb - */ 0, - /* cdc - */ 0, - /* cdd - _V_66_0F_EF */ 0x40c8, - /* cde - */ 0, - /* cdf - */ 0, - /* ce0 - */ 0, - /* ce1 - */ 0, - /* ce2 - */ 0, - /* ce3 - */ 0, - /* ce4 - */ 0, - /* ce5 - */ 0, - /* ce6 - */ 0, - /* ce7 - _F2_0F_F0 */ 0x244f, - /* ce8 - */ 0, - /* ce9 - */ 0, - /* cea - */ 0, - /* ceb - */ 0, - /* cec - */ 0, - /* ced - */ 0, - /* cee - */ 0, - /* cef - _NV_F2_0F_F0 */ 0x40c9, - /* cf0 - _0F_F1 */ 0x2450, - /* cf1 - _66_0F_F1 */ 0x2451, - /* cf2 - */ 0, - /* cf3 - */ 0, - /* cf4 - */ 0, - /* cf5 - _V_66_0F_F1 */ 0x40ca, - /* cf6 - */ 0, - /* cf7 - */ 0, - /* cf8 - */ 0, - /* cf9 - */ 0, - /* cfa - */ 0, - /* cfb - */ 0, - /* cfc - _0F_F2 */ 0x2452, - /* cfd - _66_0F_F2 */ 0x2453, - /* cfe - */ 0, - /* cff - */ 0, - /* d00 - */ 0, - /* d01 - _V_66_0F_F2 */ 0x40cb, - /* d02 - */ 0, - /* d03 - */ 0, - /* d04 - */ 0, - /* d05 - */ 0, - /* d06 - */ 0, - /* d07 - */ 0, - /* d08 - _0F_F3 */ 0x2454, - /* d09 - _66_0F_F3 */ 0x2455, - /* d0a - */ 0, - /* d0b - */ 0, - /* d0c - */ 0, - /* d0d - _V_66_0F_F3 */ 0x40cc, - /* d0e - */ 0, - /* d0f - */ 0, - /* d10 - */ 0, - /* d11 - */ 0, - /* d12 - */ 0, - /* d13 - */ 0, - /* d14 - _0F_F4 */ 0x2456, - /* d15 - _66_0F_F4 */ 0x2457, - /* d16 - */ 0, - /* d17 - */ 0, - /* d18 - */ 0, - /* d19 - _V_66_0F_F4 */ 0x40cd, - /* d1a - */ 0, - /* d1b - */ 0, - /* d1c - */ 0, - /* d1d - */ 0, - /* d1e - */ 0, - /* d1f - */ 0, - /* d20 - _0F_F5 */ 0x2458, - /* d21 - _66_0F_F5 */ 0x2459, - /* d22 - */ 0, - /* d23 - */ 0, - /* d24 - */ 0, - /* d25 - _V_66_0F_F5 */ 0x40ce, - /* d26 - */ 0, - /* d27 - */ 0, - /* d28 - */ 0, - /* d29 - */ 0, - /* d2a - */ 0, - /* d2b - */ 0, - /* d2c - _0F_F6 */ 0x245a, - /* d2d - _66_0F_F6 */ 0x245b, - /* d2e - */ 0, - /* d2f - */ 0, - /* d30 - */ 0, - /* d31 - _V_66_0F_F6 */ 0x40cf, - /* d32 - */ 0, - /* d33 - */ 0, - /* d34 - */ 0, - /* d35 - */ 0, - /* d36 - */ 0, - /* d37 - */ 0, - /* d38 - _0F_F7 */ 0x245c, - /* d39 - _66_0F_F7 */ 0x245d, - /* d3a - */ 0, - /* d3b - */ 0, - /* d3c - */ 0, - /* d3d - */ 0, - /* d3e - */ 0, - /* d3f - */ 0, - /* d40 - */ 0, - /* d41 - _NV_66_0F_F7 */ 0x40d0, - /* d42 - */ 0, - /* d43 - */ 0, - /* d44 - _0F_F8 */ 0x245e, - /* d45 - _66_0F_F8 */ 0x245f, - /* d46 - */ 0, - /* d47 - */ 0, - /* d48 - */ 0, - /* d49 - _V_66_0F_F8 */ 0x40d1, - /* d4a - */ 0, - /* d4b - */ 0, - /* d4c - */ 0, - /* d4d - */ 0, - /* d4e - */ 0, - /* d4f - */ 0, - /* d50 - _0F_F9 */ 0x2460, - /* d51 - _66_0F_F9 */ 0x2461, - /* d52 - */ 0, - /* d53 - */ 0, - /* d54 - */ 0, - /* d55 - _V_66_0F_F9 */ 0x40d2, - /* d56 - */ 0, - /* d57 - */ 0, - /* d58 - */ 0, - /* d59 - */ 0, - /* d5a - */ 0, - /* d5b - */ 0, - /* d5c - _0F_FA */ 0x2462, - /* d5d - _66_0F_FA */ 0x2463, - /* d5e - */ 0, - /* d5f - */ 0, - /* d60 - */ 0, - /* d61 - _V_66_0F_FA */ 0x40d3, - /* d62 - */ 0, - /* d63 - */ 0, - /* d64 - */ 0, - /* d65 - */ 0, - /* d66 - */ 0, - /* d67 - */ 0, - /* d68 - _0F_FB */ 0x2464, - /* d69 - _66_0F_FB */ 0x2465, - /* d6a - */ 0, - /* d6b - */ 0, - /* d6c - */ 0, - /* d6d - _V_66_0F_FB */ 0x40d4, - /* d6e - */ 0, - /* d6f - */ 0, - /* d70 - */ 0, - /* d71 - */ 0, - /* d72 - */ 0, - /* d73 - */ 0, - /* d74 - _0F_FC */ 0x2466, - /* d75 - _66_0F_FC */ 0x2467, - /* d76 - */ 0, - /* d77 - */ 0, - /* d78 - */ 0, - /* d79 - _V_66_0F_FC */ 0x40d5, - /* d7a - */ 0, - /* d7b - */ 0, - /* d7c - */ 0, - /* d7d - */ 0, - /* d7e - */ 0, - /* d7f - */ 0, - /* d80 - _0F_FD */ 0x2468, - /* d81 - _66_0F_FD */ 0x2469, - /* d82 - */ 0, - /* d83 - */ 0, - /* d84 - */ 0, - /* d85 - _V_66_0F_FD */ 0x40d6, - /* d86 - */ 0, - /* d87 - */ 0, - /* d88 - */ 0, - /* d89 - */ 0, - /* d8a - */ 0, - /* d8b - */ 0, - /* d8c - _0F_FE */ 0x246a, - /* d8d - _66_0F_FE */ 0x246b, - /* d8e - */ 0, - /* d8f - */ 0, - /* d90 - */ 0, - /* d91 - _V_66_0F_FE */ 0x40d7, - /* d92 - */ 0, - /* d93 - */ 0, - /* d94 - */ 0, - /* d95 - */ 0, - /* d96 - */ 0, - /* d97 - */ 0, - /* d98 - _D9_06 */ 0x246c, - /* d99 - _9B_D9_06 */ 0x246d, - /* d9a - */ 0, - /* d9b - */ 0, - /* d9c - */ 0, - /* d9d - */ 0, - /* d9e - */ 0, - /* d9f - */ 0, - /* da0 - */ 0, - /* da1 - */ 0, - /* da2 - */ 0, - /* da3 - */ 0, - /* da4 - _D9_07 */ 0x246e, - /* da5 - _9B_D9_07 */ 0x246f, - /* da6 - */ 0, - /* da7 - */ 0, - /* da8 - */ 0, - /* da9 - */ 0, - /* daa - */ 0, - /* dab - */ 0, - /* dac - */ 0, - /* dad - */ 0, - /* dae - */ 0, - /* daf - */ 0, - /* db0 - _DB_E2 */ 0x2470, - /* db1 - _9B_DB_E2 */ 0x2471, - /* db2 - */ 0, - /* db3 - */ 0, - /* db4 - */ 0, - /* db5 - */ 0, - /* db6 - */ 0, - /* db7 - */ 0, - /* db8 - */ 0, - /* db9 - */ 0, - /* dba - */ 0, - /* dbb - */ 0, - /* dbc - _DB_E3 */ 0x2472, - /* dbd - _9B_DB_E3 */ 0x2473, - /* dbe - */ 0, - /* dbf - */ 0, - /* dc0 - */ 0, - /* dc1 - */ 0, - /* dc2 - */ 0, - /* dc3 - */ 0, - /* dc4 - */ 0, - /* dc5 - */ 0, - /* dc6 - */ 0, - /* dc7 - */ 0, - /* dc8 - _DD_06 */ 0x2474, - /* dc9 - _9B_DD_06 */ 0x2475, - /* dca - */ 0, - /* dcb - */ 0, - /* dcc - */ 0, - /* dcd - */ 0, - /* dce - */ 0, - /* dcf - */ 0, - /* dd0 - */ 0, - /* dd1 - */ 0, - /* dd2 - */ 0, - /* dd3 - */ 0, - /* dd4 - _DD_07 */ 0x2476, - /* dd5 - _9B_DD_07 */ 0x2477, - /* dd6 - */ 0, - /* dd7 - */ 0, - /* dd8 - */ 0, - /* dd9 - */ 0, - /* dda - */ 0, - /* ddb - */ 0, - /* ddc - */ 0, - /* ddd - */ 0, - /* dde - */ 0, - /* ddf - */ 0, - /* de0 - _DF_E0 */ 0x2478, - /* de1 - _9B_DF_E0 */ 0x2479, - /* de2 - */ 0, - /* de3 - */ 0, - /* de4 - */ 0, - /* de5 - */ 0, - /* de6 - */ 0, - /* de7 - */ 0, - /* de8 - */ 0, - /* de9 - */ 0, - /* dea - */ 0, - /* deb - */ 0, - /* dec - _0F_38_00 */ 0x247a, - /* ded - _66_0F_38_00 */ 0x247b, - /* dee - */ 0, - /* def - */ 0, - /* df0 - */ 0, - /* df1 - _V_66_0F_38_00 */ 0x40d8, - /* df2 - */ 0, - /* df3 - */ 0, - /* df4 - */ 0, - /* df5 - */ 0, - /* df6 - */ 0, - /* df7 - */ 0, - /* df8 - _0F_38_01 */ 0x247c, - /* df9 - _66_0F_38_01 */ 0x247d, - /* dfa - */ 0, - /* dfb - */ 0, - /* dfc - */ 0, - /* dfd - _V_66_0F_38_01 */ 0x40d9, - /* dfe - */ 0, - /* dff - */ 0, - /* e00 - */ 0, - /* e01 - */ 0, - /* e02 - */ 0, - /* e03 - */ 0, - /* e04 - _0F_38_02 */ 0x247e, - /* e05 - _66_0F_38_02 */ 0x247f, - /* e06 - */ 0, - /* e07 - */ 0, - /* e08 - */ 0, - /* e09 - _V_66_0F_38_02 */ 0x40da, - /* e0a - */ 0, - /* e0b - */ 0, - /* e0c - */ 0, - /* e0d - */ 0, - /* e0e - */ 0, - /* e0f - */ 0, - /* e10 - _0F_38_03 */ 0x2480, - /* e11 - _66_0F_38_03 */ 0x2481, - /* e12 - */ 0, - /* e13 - */ 0, - /* e14 - */ 0, - /* e15 - _V_66_0F_38_03 */ 0x40db, - /* e16 - */ 0, - /* e17 - */ 0, - /* e18 - */ 0, - /* e19 - */ 0, - /* e1a - */ 0, - /* e1b - */ 0, - /* e1c - _0F_38_04 */ 0x2482, - /* e1d - _66_0F_38_04 */ 0x2483, - /* e1e - */ 0, - /* e1f - */ 0, - /* e20 - */ 0, - /* e21 - _V_66_0F_38_04 */ 0x40dc, - /* e22 - */ 0, - /* e23 - */ 0, - /* e24 - */ 0, - /* e25 - */ 0, - /* e26 - */ 0, - /* e27 - */ 0, - /* e28 - _0F_38_05 */ 0x2484, - /* e29 - _66_0F_38_05 */ 0x2485, - /* e2a - */ 0, - /* e2b - */ 0, - /* e2c - */ 0, - /* e2d - _V_66_0F_38_05 */ 0x40dd, - /* e2e - */ 0, - /* e2f - */ 0, - /* e30 - */ 0, - /* e31 - */ 0, - /* e32 - */ 0, - /* e33 - */ 0, - /* e34 - _0F_38_06 */ 0x2486, - /* e35 - _66_0F_38_06 */ 0x2487, - /* e36 - */ 0, - /* e37 - */ 0, - /* e38 - */ 0, - /* e39 - _V_66_0F_38_06 */ 0x40de, - /* e3a - */ 0, - /* e3b - */ 0, - /* e3c - */ 0, - /* e3d - */ 0, - /* e3e - */ 0, - /* e3f - */ 0, - /* e40 - _0F_38_07 */ 0x2488, - /* e41 - _66_0F_38_07 */ 0x2489, - /* e42 - */ 0, - /* e43 - */ 0, - /* e44 - */ 0, - /* e45 - _V_66_0F_38_07 */ 0x40df, - /* e46 - */ 0, - /* e47 - */ 0, - /* e48 - */ 0, - /* e49 - */ 0, - /* e4a - */ 0, - /* e4b - */ 0, - /* e4c - _0F_38_08 */ 0x248a, - /* e4d - _66_0F_38_08 */ 0x248b, - /* e4e - */ 0, - /* e4f - */ 0, - /* e50 - */ 0, - /* e51 - _V_66_0F_38_08 */ 0x40e0, - /* e52 - */ 0, - /* e53 - */ 0, - /* e54 - */ 0, - /* e55 - */ 0, - /* e56 - */ 0, - /* e57 - */ 0, - /* e58 - _0F_38_09 */ 0x248c, - /* e59 - _66_0F_38_09 */ 0x248d, - /* e5a - */ 0, - /* e5b - */ 0, - /* e5c - */ 0, - /* e5d - _V_66_0F_38_09 */ 0x40e1, - /* e5e - */ 0, - /* e5f - */ 0, - /* e60 - */ 0, - /* e61 - */ 0, - /* e62 - */ 0, - /* e63 - */ 0, - /* e64 - _0F_38_0A */ 0x248e, - /* e65 - _66_0F_38_0A */ 0x248f, - /* e66 - */ 0, - /* e67 - */ 0, - /* e68 - */ 0, - /* e69 - _V_66_0F_38_0A */ 0x40e2, - /* e6a - */ 0, - /* e6b - */ 0, - /* e6c - */ 0, - /* e6d - */ 0, - /* e6e - */ 0, - /* e6f - */ 0, - /* e70 - _0F_38_0B */ 0x2490, - /* e71 - _66_0F_38_0B */ 0x2491, - /* e72 - */ 0, - /* e73 - */ 0, - /* e74 - */ 0, - /* e75 - _V_66_0F_38_0B */ 0x40e3, - /* e76 - */ 0, - /* e77 - */ 0, - /* e78 - */ 0, - /* e79 - */ 0, - /* e7a - */ 0, - /* e7b - */ 0, - /* e7c - */ 0, - /* e7d - */ 0, - /* e7e - */ 0, - /* e7f - */ 0, - /* e80 - */ 0, - /* e81 - _V_66_0F_38_0C */ 0x40e4, - /* e82 - */ 0, - /* e83 - */ 0, - /* e84 - */ 0, - /* e85 - */ 0, - /* e86 - */ 0, - /* e87 - */ 0, - /* e88 - */ 0, - /* e89 - */ 0, - /* e8a - */ 0, - /* e8b - */ 0, - /* e8c - */ 0, - /* e8d - _V_66_0F_38_0D */ 0x40e5, - /* e8e - */ 0, - /* e8f - */ 0, - /* e90 - */ 0, - /* e91 - */ 0, - /* e92 - */ 0, - /* e93 - */ 0, - /* e94 - */ 0, - /* e95 - */ 0, - /* e96 - */ 0, - /* e97 - */ 0, - /* e98 - */ 0, - /* e99 - */ 0, - /* e9a - */ 0, - /* e9b - */ 0, - /* e9c - */ 0, - /* e9d - _NV_66_0F_38_0E */ 0x40e6, - /* e9e - */ 0, - /* e9f - */ 0, - /* ea0 - */ 0, - /* ea1 - */ 0, - /* ea2 - */ 0, - /* ea3 - */ 0, - /* ea4 - */ 0, - /* ea5 - */ 0, - /* ea6 - */ 0, - /* ea7 - */ 0, - /* ea8 - */ 0, - /* ea9 - _NV_66_0F_38_0F */ 0x40e7, - /* eaa - */ 0, - /* eab - */ 0, - /* eac - */ 0, - /* ead - _66_0F_38_10 */ 0x40e8, - /* eae - */ 0, - /* eaf - */ 0, - /* eb0 - */ 0, - /* eb1 - */ 0, - /* eb2 - */ 0, - /* eb3 - */ 0, - /* eb4 - */ 0, - /* eb5 - */ 0, - /* eb6 - */ 0, - /* eb7 - */ 0, - /* eb8 - */ 0, - /* eb9 - _66_0F_38_14 */ 0x40e9, - /* eba - */ 0, - /* ebb - */ 0, - /* ebc - */ 0, - /* ebd - */ 0, - /* ebe - */ 0, - /* ebf - */ 0, - /* ec0 - */ 0, - /* ec1 - */ 0, - /* ec2 - */ 0, - /* ec3 - */ 0, - /* ec4 - */ 0, - /* ec5 - _66_0F_38_15 */ 0x40ea, - /* ec6 - */ 0, - /* ec7 - */ 0, - /* ec8 - */ 0, - /* ec9 - */ 0, - /* eca - */ 0, - /* ecb - */ 0, - /* ecc - */ 0, - /* ecd - */ 0, - /* ece - */ 0, - /* ecf - */ 0, - /* ed0 - */ 0, - /* ed1 - _66_0F_38_17 */ 0x2492, - /* ed2 - */ 0, - /* ed3 - */ 0, - /* ed4 - */ 0, - /* ed5 - */ 0, - /* ed6 - */ 0, - /* ed7 - */ 0, - /* ed8 - */ 0, - /* ed9 - _NV_66_0F_38_17 */ 0x40eb, - /* eda - */ 0, - /* edb - */ 0, - /* edc - */ 0, - /* edd - */ 0, - /* ede - */ 0, - /* edf - */ 0, - /* ee0 - */ 0, - /* ee1 - */ 0, - /* ee2 - */ 0, - /* ee3 - */ 0, - /* ee4 - */ 0, - /* ee5 - _NV_66_0F_38_18 */ 0x40ec, - /* ee6 - */ 0, - /* ee7 - */ 0, - /* ee8 - */ 0, - /* ee9 - */ 0, - /* eea - */ 0, - /* eeb - */ 0, - /* eec - */ 0, - /* eed - */ 0, - /* eee - */ 0, - /* eef - */ 0, - /* ef0 - */ 0, - /* ef1 - _NV_66_0F_38_19 */ 0x40ed, - /* ef2 - */ 0, - /* ef3 - */ 0, - /* ef4 - */ 0, - /* ef5 - */ 0, - /* ef6 - */ 0, - /* ef7 - */ 0, - /* ef8 - */ 0, - /* ef9 - */ 0, - /* efa - */ 0, - /* efb - */ 0, - /* efc - */ 0, - /* efd - _NV_66_0F_38_1A */ 0x40ee, - /* efe - */ 0, - /* eff - */ 0, - /* f00 - _0F_38_1C */ 0x2493, - /* f01 - _66_0F_38_1C */ 0x2494, - /* f02 - */ 0, - /* f03 - */ 0, - /* f04 - */ 0, - /* f05 - */ 0, - /* f06 - */ 0, - /* f07 - */ 0, - /* f08 - */ 0, - /* f09 - _NV_66_0F_38_1C */ 0x40ef, - /* f0a - */ 0, - /* f0b - */ 0, - /* f0c - _0F_38_1D */ 0x2495, - /* f0d - _66_0F_38_1D */ 0x2496, - /* f0e - */ 0, - /* f0f - */ 0, - /* f10 - */ 0, - /* f11 - */ 0, - /* f12 - */ 0, - /* f13 - */ 0, - /* f14 - */ 0, - /* f15 - _NV_66_0F_38_1D */ 0x40f0, - /* f16 - */ 0, - /* f17 - */ 0, - /* f18 - _0F_38_1E */ 0x2497, - /* f19 - _66_0F_38_1E */ 0x2498, - /* f1a - */ 0, - /* f1b - */ 0, - /* f1c - */ 0, - /* f1d - */ 0, - /* f1e - */ 0, - /* f1f - */ 0, - /* f20 - */ 0, - /* f21 - _NV_66_0F_38_1E */ 0x40f1, - /* f22 - */ 0, - /* f23 - */ 0, - /* f24 - */ 0, - /* f25 - _66_0F_38_20 */ 0x2499, - /* f26 - */ 0, - /* f27 - */ 0, - /* f28 - */ 0, - /* f29 - */ 0, - /* f2a - */ 0, - /* f2b - */ 0, - /* f2c - */ 0, - /* f2d - _NV_66_0F_38_20 */ 0x40f2, - /* f2e - */ 0, - /* f2f - */ 0, - /* f30 - */ 0, - /* f31 - _66_0F_38_21 */ 0x249a, - /* f32 - */ 0, - /* f33 - */ 0, - /* f34 - */ 0, - /* f35 - */ 0, - /* f36 - */ 0, - /* f37 - */ 0, - /* f38 - */ 0, - /* f39 - _NV_66_0F_38_21 */ 0x40f3, - /* f3a - */ 0, - /* f3b - */ 0, - /* f3c - */ 0, - /* f3d - _66_0F_38_22 */ 0x249b, - /* f3e - */ 0, - /* f3f - */ 0, - /* f40 - */ 0, - /* f41 - */ 0, - /* f42 - */ 0, - /* f43 - */ 0, - /* f44 - */ 0, - /* f45 - _NV_66_0F_38_22 */ 0x40f4, - /* f46 - */ 0, - /* f47 - */ 0, - /* f48 - */ 0, - /* f49 - _66_0F_38_23 */ 0x249c, - /* f4a - */ 0, - /* f4b - */ 0, - /* f4c - */ 0, - /* f4d - */ 0, - /* f4e - */ 0, - /* f4f - */ 0, - /* f50 - */ 0, - /* f51 - _NV_66_0F_38_23 */ 0x40f5, - /* f52 - */ 0, - /* f53 - */ 0, - /* f54 - */ 0, - /* f55 - _66_0F_38_24 */ 0x249d, - /* f56 - */ 0, - /* f57 - */ 0, - /* f58 - */ 0, - /* f59 - */ 0, - /* f5a - */ 0, - /* f5b - */ 0, - /* f5c - */ 0, - /* f5d - _NV_66_0F_38_24 */ 0x40f6, - /* f5e - */ 0, - /* f5f - */ 0, - /* f60 - */ 0, - /* f61 - _66_0F_38_25 */ 0x249e, - /* f62 - */ 0, - /* f63 - */ 0, - /* f64 - */ 0, - /* f65 - */ 0, - /* f66 - */ 0, - /* f67 - */ 0, - /* f68 - */ 0, - /* f69 - _NV_66_0F_38_25 */ 0x40f7, - /* f6a - */ 0, - /* f6b - */ 0, - /* f6c - */ 0, - /* f6d - _66_0F_38_28 */ 0x249f, - /* f6e - */ 0, - /* f6f - */ 0, - /* f70 - */ 0, - /* f71 - _V_66_0F_38_28 */ 0x40f8, - /* f72 - */ 0, - /* f73 - */ 0, - /* f74 - */ 0, - /* f75 - */ 0, - /* f76 - */ 0, - /* f77 - */ 0, - /* f78 - */ 0, - /* f79 - _66_0F_38_29 */ 0x24a0, - /* f7a - */ 0, - /* f7b - */ 0, - /* f7c - */ 0, - /* f7d - _V_66_0F_38_29 */ 0x40f9, - /* f7e - */ 0, - /* f7f - */ 0, - /* f80 - */ 0, - /* f81 - */ 0, - /* f82 - */ 0, - /* f83 - */ 0, - /* f84 - */ 0, - /* f85 - _66_0F_38_2A */ 0x24a1, - /* f86 - */ 0, - /* f87 - */ 0, - /* f88 - */ 0, - /* f89 - */ 0, - /* f8a - */ 0, - /* f8b - */ 0, - /* f8c - */ 0, - /* f8d - _NV_66_0F_38_2A */ 0x40fa, - /* f8e - */ 0, - /* f8f - */ 0, - /* f90 - */ 0, - /* f91 - _66_0F_38_2B */ 0x24a2, - /* f92 - */ 0, - /* f93 - */ 0, - /* f94 - */ 0, - /* f95 - _V_66_0F_38_2B */ 0x40fb, - /* f96 - */ 0, - /* f97 - */ 0, - /* f98 - */ 0, - /* f99 - */ 0, - /* f9a - */ 0, - /* f9b - */ 0, - /* f9c - */ 0, - /* f9d - */ 0, - /* f9e - */ 0, - /* f9f - */ 0, - /* fa0 - */ 0, - /* fa1 - _V_66_0F_38_2C */ 0x40fc, - /* fa2 - */ 0, - /* fa3 - */ 0, - /* fa4 - */ 0, - /* fa5 - */ 0, - /* fa6 - */ 0, - /* fa7 - */ 0, - /* fa8 - */ 0, - /* fa9 - */ 0, - /* faa - */ 0, - /* fab - */ 0, - /* fac - */ 0, - /* fad - _V_66_0F_38_2D */ 0x40fd, - /* fae - */ 0, - /* faf - */ 0, - /* fb0 - */ 0, - /* fb1 - */ 0, - /* fb2 - */ 0, - /* fb3 - */ 0, - /* fb4 - */ 0, - /* fb5 - */ 0, - /* fb6 - */ 0, - /* fb7 - */ 0, - /* fb8 - */ 0, - /* fb9 - _V_66_0F_38_2E */ 0x40fe, - /* fba - */ 0, - /* fbb - */ 0, - /* fbc - */ 0, - /* fbd - */ 0, - /* fbe - */ 0, - /* fbf - */ 0, - /* fc0 - */ 0, - /* fc1 - */ 0, - /* fc2 - */ 0, - /* fc3 - */ 0, - /* fc4 - */ 0, - /* fc5 - _V_66_0F_38_2F */ 0x40ff, - /* fc6 - */ 0, - /* fc7 - */ 0, - /* fc8 - */ 0, - /* fc9 - */ 0, - /* fca - */ 0, - /* fcb - */ 0, - /* fcc - */ 0, - /* fcd - _66_0F_38_30 */ 0x24a3, - /* fce - */ 0, - /* fcf - */ 0, - /* fd0 - */ 0, - /* fd1 - */ 0, - /* fd2 - */ 0, - /* fd3 - */ 0, - /* fd4 - */ 0, - /* fd5 - _NV_66_0F_38_30 */ 0x4100, - /* fd6 - */ 0, - /* fd7 - */ 0, - /* fd8 - */ 0, - /* fd9 - _66_0F_38_31 */ 0x24a4, - /* fda - */ 0, - /* fdb - */ 0, - /* fdc - */ 0, - /* fdd - */ 0, - /* fde - */ 0, - /* fdf - */ 0, - /* fe0 - */ 0, - /* fe1 - _NV_66_0F_38_31 */ 0x4101, - /* fe2 - */ 0, - /* fe3 - */ 0, - /* fe4 - */ 0, - /* fe5 - _66_0F_38_32 */ 0x24a5, - /* fe6 - */ 0, - /* fe7 - */ 0, - /* fe8 - */ 0, - /* fe9 - */ 0, - /* fea - */ 0, - /* feb - */ 0, - /* fec - */ 0, - /* fed - _NV_66_0F_38_32 */ 0x4102, - /* fee - */ 0, - /* fef - */ 0, - /* ff0 - */ 0, - /* ff1 - _66_0F_38_33 */ 0x24a6, - /* ff2 - */ 0, - /* ff3 - */ 0, - /* ff4 - */ 0, - /* ff5 - */ 0, - /* ff6 - */ 0, - /* ff7 - */ 0, - /* ff8 - */ 0, - /* ff9 - _NV_66_0F_38_33 */ 0x4103, - /* ffa - */ 0, - /* ffb - */ 0, - /* ffc - */ 0, - /* ffd - _66_0F_38_34 */ 0x24a7, - /* ffe - */ 0, - /* fff - */ 0, - /* 1000 - */ 0, - /* 1001 - */ 0, - /* 1002 - */ 0, - /* 1003 - */ 0, - /* 1004 - */ 0, - /* 1005 - _NV_66_0F_38_34 */ 0x4104, - /* 1006 - */ 0, - /* 1007 - */ 0, - /* 1008 - */ 0, - /* 1009 - _66_0F_38_35 */ 0x24a8, - /* 100a - */ 0, - /* 100b - */ 0, - /* 100c - */ 0, - /* 100d - */ 0, - /* 100e - */ 0, - /* 100f - */ 0, - /* 1010 - */ 0, - /* 1011 - _NV_66_0F_38_35 */ 0x4105, - /* 1012 - */ 0, - /* 1013 - */ 0, - /* 1014 - */ 0, - /* 1015 - _66_0F_38_37 */ 0x24a9, - /* 1016 - */ 0, - /* 1017 - */ 0, - /* 1018 - */ 0, - /* 1019 - _V_66_0F_38_37 */ 0x4106, - /* 101a - */ 0, - /* 101b - */ 0, - /* 101c - */ 0, - /* 101d - */ 0, - /* 101e - */ 0, - /* 101f - */ 0, - /* 1020 - */ 0, - /* 1021 - _66_0F_38_38 */ 0x24aa, - /* 1022 - */ 0, - /* 1023 - */ 0, - /* 1024 - */ 0, - /* 1025 - _V_66_0F_38_38 */ 0x4107, - /* 1026 - */ 0, - /* 1027 - */ 0, - /* 1028 - */ 0, - /* 1029 - */ 0, - /* 102a - */ 0, - /* 102b - */ 0, - /* 102c - */ 0, - /* 102d - _66_0F_38_39 */ 0x24ab, - /* 102e - */ 0, - /* 102f - */ 0, - /* 1030 - */ 0, - /* 1031 - _V_66_0F_38_39 */ 0x4108, - /* 1032 - */ 0, - /* 1033 - */ 0, - /* 1034 - */ 0, - /* 1035 - */ 0, - /* 1036 - */ 0, - /* 1037 - */ 0, - /* 1038 - */ 0, - /* 1039 - _66_0F_38_3A */ 0x24ac, - /* 103a - */ 0, - /* 103b - */ 0, - /* 103c - */ 0, - /* 103d - _V_66_0F_38_3A */ 0x4109, - /* 103e - */ 0, - /* 103f - */ 0, - /* 1040 - */ 0, - /* 1041 - */ 0, - /* 1042 - */ 0, - /* 1043 - */ 0, - /* 1044 - */ 0, - /* 1045 - _66_0F_38_3B */ 0x24ad, - /* 1046 - */ 0, - /* 1047 - */ 0, - /* 1048 - */ 0, - /* 1049 - _V_66_0F_38_3B */ 0x410a, - /* 104a - */ 0, - /* 104b - */ 0, - /* 104c - */ 0, - /* 104d - */ 0, - /* 104e - */ 0, - /* 104f - */ 0, - /* 1050 - */ 0, - /* 1051 - _66_0F_38_3C */ 0x24ae, - /* 1052 - */ 0, - /* 1053 - */ 0, - /* 1054 - */ 0, - /* 1055 - _V_66_0F_38_3C */ 0x410b, - /* 1056 - */ 0, - /* 1057 - */ 0, - /* 1058 - */ 0, - /* 1059 - */ 0, - /* 105a - */ 0, - /* 105b - */ 0, - /* 105c - */ 0, - /* 105d - _66_0F_38_3D */ 0x24af, - /* 105e - */ 0, - /* 105f - */ 0, - /* 1060 - */ 0, - /* 1061 - _V_66_0F_38_3D */ 0x410c, - /* 1062 - */ 0, - /* 1063 - */ 0, - /* 1064 - */ 0, - /* 1065 - */ 0, - /* 1066 - */ 0, - /* 1067 - */ 0, - /* 1068 - */ 0, - /* 1069 - _66_0F_38_3E */ 0x24b0, - /* 106a - */ 0, - /* 106b - */ 0, - /* 106c - */ 0, - /* 106d - _V_66_0F_38_3E */ 0x410d, - /* 106e - */ 0, - /* 106f - */ 0, - /* 1070 - */ 0, - /* 1071 - */ 0, - /* 1072 - */ 0, - /* 1073 - */ 0, - /* 1074 - */ 0, - /* 1075 - _66_0F_38_3F */ 0x24b1, - /* 1076 - */ 0, - /* 1077 - */ 0, - /* 1078 - */ 0, - /* 1079 - _V_66_0F_38_3F */ 0x410e, - /* 107a - */ 0, - /* 107b - */ 0, - /* 107c - */ 0, - /* 107d - */ 0, - /* 107e - */ 0, - /* 107f - */ 0, - /* 1080 - */ 0, - /* 1081 - _66_0F_38_40 */ 0x24b2, - /* 1082 - */ 0, - /* 1083 - */ 0, - /* 1084 - */ 0, - /* 1085 - _V_66_0F_38_40 */ 0x410f, - /* 1086 - */ 0, - /* 1087 - */ 0, - /* 1088 - */ 0, - /* 1089 - */ 0, - /* 108a - */ 0, - /* 108b - */ 0, - /* 108c - */ 0, - /* 108d - _66_0F_38_41 */ 0x24b3, - /* 108e - */ 0, - /* 108f - */ 0, - /* 1090 - */ 0, - /* 1091 - */ 0, - /* 1092 - */ 0, - /* 1093 - */ 0, - /* 1094 - */ 0, - /* 1095 - _NV_66_0F_38_41 */ 0x4110, - /* 1096 - */ 0, - /* 1097 - */ 0, - /* 1098 - */ 0, - /* 1099 - _66_0F_38_80 */ 0x24b4, - /* 109a - */ 0, - /* 109b - */ 0, - /* 109c - */ 0, - /* 109d - */ 0, - /* 109e - */ 0, - /* 109f - */ 0, - /* 10a0 - */ 0, - /* 10a1 - */ 0, - /* 10a2 - */ 0, - /* 10a3 - */ 0, - /* 10a4 - */ 0, - /* 10a5 - _66_0F_38_81 */ 0x24b5, - /* 10a6 - */ 0, - /* 10a7 - */ 0, - /* 10a8 - */ 0, - /* 10a9 - */ 0, - /* 10aa - */ 0, - /* 10ab - */ 0, - /* 10ac - */ 0, - /* 10ad - */ 0, - /* 10ae - */ 0, - /* 10af - */ 0, - /* 10b0 - */ 0, - /* 10b1 - */ 0, - /* 10b2 - */ 0, - /* 10b3 - */ 0, - /* 10b4 - */ 0, - /* 10b5 - _V_66_0F_38_96 */ 0x4111, - /* 10b6 - */ 0, - /* 10b7 - */ 0, - /* 10b8 - */ 0, - /* 10b9 - */ 0, - /* 10ba - */ 0, - /* 10bb - */ 0, - /* 10bc - */ 0, - /* 10bd - */ 0, - /* 10be - */ 0, - /* 10bf - */ 0, - /* 10c0 - */ 0, - /* 10c1 - _V_66_0F_38_97 */ 0x4112, - /* 10c2 - */ 0, - /* 10c3 - */ 0, - /* 10c4 - */ 0, - /* 10c5 - */ 0, - /* 10c6 - */ 0, - /* 10c7 - */ 0, - /* 10c8 - */ 0, - /* 10c9 - */ 0, - /* 10ca - */ 0, - /* 10cb - */ 0, - /* 10cc - */ 0, - /* 10cd - _V_66_0F_38_98 */ 0x4113, - /* 10ce - */ 0, - /* 10cf - */ 0, - /* 10d0 - */ 0, - /* 10d1 - */ 0, - /* 10d2 - */ 0, - /* 10d3 - */ 0, - /* 10d4 - */ 0, - /* 10d5 - */ 0, - /* 10d6 - */ 0, - /* 10d7 - */ 0, - /* 10d8 - */ 0, - /* 10d9 - _V_66_0F_38_99 */ 0x4114, - /* 10da - */ 0, - /* 10db - */ 0, - /* 10dc - */ 0, - /* 10dd - */ 0, - /* 10de - */ 0, - /* 10df - */ 0, - /* 10e0 - */ 0, - /* 10e1 - */ 0, - /* 10e2 - */ 0, - /* 10e3 - */ 0, - /* 10e4 - */ 0, - /* 10e5 - _V_66_0F_38_9A */ 0x4115, - /* 10e6 - */ 0, - /* 10e7 - */ 0, - /* 10e8 - */ 0, - /* 10e9 - */ 0, - /* 10ea - */ 0, - /* 10eb - */ 0, - /* 10ec - */ 0, - /* 10ed - */ 0, - /* 10ee - */ 0, - /* 10ef - */ 0, - /* 10f0 - */ 0, - /* 10f1 - _V_66_0F_38_9B */ 0x4116, - /* 10f2 - */ 0, - /* 10f3 - */ 0, - /* 10f4 - */ 0, - /* 10f5 - */ 0, - /* 10f6 - */ 0, - /* 10f7 - */ 0, - /* 10f8 - */ 0, - /* 10f9 - */ 0, - /* 10fa - */ 0, - /* 10fb - */ 0, - /* 10fc - */ 0, - /* 10fd - _V_66_0F_38_9C */ 0x4117, - /* 10fe - */ 0, - /* 10ff - */ 0, - /* 1100 - */ 0, - /* 1101 - */ 0, - /* 1102 - */ 0, - /* 1103 - */ 0, - /* 1104 - */ 0, - /* 1105 - */ 0, - /* 1106 - */ 0, - /* 1107 - */ 0, - /* 1108 - */ 0, - /* 1109 - _V_66_0F_38_9D */ 0x4118, - /* 110a - */ 0, - /* 110b - */ 0, - /* 110c - */ 0, - /* 110d - */ 0, - /* 110e - */ 0, - /* 110f - */ 0, - /* 1110 - */ 0, - /* 1111 - */ 0, - /* 1112 - */ 0, - /* 1113 - */ 0, - /* 1114 - */ 0, - /* 1115 - _V_66_0F_38_9E */ 0x4119, - /* 1116 - */ 0, - /* 1117 - */ 0, - /* 1118 - */ 0, - /* 1119 - */ 0, - /* 111a - */ 0, - /* 111b - */ 0, - /* 111c - */ 0, - /* 111d - */ 0, - /* 111e - */ 0, - /* 111f - */ 0, - /* 1120 - */ 0, - /* 1121 - _V_66_0F_38_9F */ 0x411a, - /* 1122 - */ 0, - /* 1123 - */ 0, - /* 1124 - */ 0, - /* 1125 - */ 0, - /* 1126 - */ 0, - /* 1127 - */ 0, - /* 1128 - */ 0, - /* 1129 - */ 0, - /* 112a - */ 0, - /* 112b - */ 0, - /* 112c - */ 0, - /* 112d - _V_66_0F_38_A6 */ 0x411b, - /* 112e - */ 0, - /* 112f - */ 0, - /* 1130 - */ 0, - /* 1131 - */ 0, - /* 1132 - */ 0, - /* 1133 - */ 0, - /* 1134 - */ 0, - /* 1135 - */ 0, - /* 1136 - */ 0, - /* 1137 - */ 0, - /* 1138 - */ 0, - /* 1139 - _V_66_0F_38_A7 */ 0x411c, - /* 113a - */ 0, - /* 113b - */ 0, - /* 113c - */ 0, - /* 113d - */ 0, - /* 113e - */ 0, - /* 113f - */ 0, - /* 1140 - */ 0, - /* 1141 - */ 0, - /* 1142 - */ 0, - /* 1143 - */ 0, - /* 1144 - */ 0, - /* 1145 - _V_66_0F_38_A8 */ 0x411d, - /* 1146 - */ 0, - /* 1147 - */ 0, - /* 1148 - */ 0, - /* 1149 - */ 0, - /* 114a - */ 0, - /* 114b - */ 0, - /* 114c - */ 0, - /* 114d - */ 0, - /* 114e - */ 0, - /* 114f - */ 0, - /* 1150 - */ 0, - /* 1151 - _V_66_0F_38_A9 */ 0x411e, - /* 1152 - */ 0, - /* 1153 - */ 0, - /* 1154 - */ 0, - /* 1155 - */ 0, - /* 1156 - */ 0, - /* 1157 - */ 0, - /* 1158 - */ 0, - /* 1159 - */ 0, - /* 115a - */ 0, - /* 115b - */ 0, - /* 115c - */ 0, - /* 115d - _V_66_0F_38_AA */ 0x411f, - /* 115e - */ 0, - /* 115f - */ 0, - /* 1160 - */ 0, - /* 1161 - */ 0, - /* 1162 - */ 0, - /* 1163 - */ 0, - /* 1164 - */ 0, - /* 1165 - */ 0, - /* 1166 - */ 0, - /* 1167 - */ 0, - /* 1168 - */ 0, - /* 1169 - _V_66_0F_38_AB */ 0x4120, - /* 116a - */ 0, - /* 116b - */ 0, - /* 116c - */ 0, - /* 116d - */ 0, - /* 116e - */ 0, - /* 116f - */ 0, - /* 1170 - */ 0, - /* 1171 - */ 0, - /* 1172 - */ 0, - /* 1173 - */ 0, - /* 1174 - */ 0, - /* 1175 - _V_66_0F_38_AC */ 0x4121, - /* 1176 - */ 0, - /* 1177 - */ 0, - /* 1178 - */ 0, - /* 1179 - */ 0, - /* 117a - */ 0, - /* 117b - */ 0, - /* 117c - */ 0, - /* 117d - */ 0, - /* 117e - */ 0, - /* 117f - */ 0, - /* 1180 - */ 0, - /* 1181 - _V_66_0F_38_AD */ 0x4122, - /* 1182 - */ 0, - /* 1183 - */ 0, - /* 1184 - */ 0, - /* 1185 - */ 0, - /* 1186 - */ 0, - /* 1187 - */ 0, - /* 1188 - */ 0, - /* 1189 - */ 0, - /* 118a - */ 0, - /* 118b - */ 0, - /* 118c - */ 0, - /* 118d - _V_66_0F_38_AE */ 0x4123, - /* 118e - */ 0, - /* 118f - */ 0, - /* 1190 - */ 0, - /* 1191 - */ 0, - /* 1192 - */ 0, - /* 1193 - */ 0, - /* 1194 - */ 0, - /* 1195 - */ 0, - /* 1196 - */ 0, - /* 1197 - */ 0, - /* 1198 - */ 0, - /* 1199 - _V_66_0F_38_AF */ 0x4124, - /* 119a - */ 0, - /* 119b - */ 0, - /* 119c - */ 0, - /* 119d - */ 0, - /* 119e - */ 0, - /* 119f - */ 0, - /* 11a0 - */ 0, - /* 11a1 - */ 0, - /* 11a2 - */ 0, - /* 11a3 - */ 0, - /* 11a4 - */ 0, - /* 11a5 - _V_66_0F_38_B6 */ 0x4125, - /* 11a6 - */ 0, - /* 11a7 - */ 0, - /* 11a8 - */ 0, - /* 11a9 - */ 0, - /* 11aa - */ 0, - /* 11ab - */ 0, - /* 11ac - */ 0, - /* 11ad - */ 0, - /* 11ae - */ 0, - /* 11af - */ 0, - /* 11b0 - */ 0, - /* 11b1 - _V_66_0F_38_B7 */ 0x4126, - /* 11b2 - */ 0, - /* 11b3 - */ 0, - /* 11b4 - */ 0, - /* 11b5 - */ 0, - /* 11b6 - */ 0, - /* 11b7 - */ 0, - /* 11b8 - */ 0, - /* 11b9 - */ 0, - /* 11ba - */ 0, - /* 11bb - */ 0, - /* 11bc - */ 0, - /* 11bd - _V_66_0F_38_B8 */ 0x4127, - /* 11be - */ 0, - /* 11bf - */ 0, - /* 11c0 - */ 0, - /* 11c1 - */ 0, - /* 11c2 - */ 0, - /* 11c3 - */ 0, - /* 11c4 - */ 0, - /* 11c5 - */ 0, - /* 11c6 - */ 0, - /* 11c7 - */ 0, - /* 11c8 - */ 0, - /* 11c9 - _V_66_0F_38_B9 */ 0x4128, - /* 11ca - */ 0, - /* 11cb - */ 0, - /* 11cc - */ 0, - /* 11cd - */ 0, - /* 11ce - */ 0, - /* 11cf - */ 0, - /* 11d0 - */ 0, - /* 11d1 - */ 0, - /* 11d2 - */ 0, - /* 11d3 - */ 0, - /* 11d4 - */ 0, - /* 11d5 - _V_66_0F_38_BA */ 0x4129, - /* 11d6 - */ 0, - /* 11d7 - */ 0, - /* 11d8 - */ 0, - /* 11d9 - */ 0, - /* 11da - */ 0, - /* 11db - */ 0, - /* 11dc - */ 0, - /* 11dd - */ 0, - /* 11de - */ 0, - /* 11df - */ 0, - /* 11e0 - */ 0, - /* 11e1 - _V_66_0F_38_BB */ 0x412a, - /* 11e2 - */ 0, - /* 11e3 - */ 0, - /* 11e4 - */ 0, - /* 11e5 - */ 0, - /* 11e6 - */ 0, - /* 11e7 - */ 0, - /* 11e8 - */ 0, - /* 11e9 - */ 0, - /* 11ea - */ 0, - /* 11eb - */ 0, - /* 11ec - */ 0, - /* 11ed - _V_66_0F_38_BC */ 0x412b, - /* 11ee - */ 0, - /* 11ef - */ 0, - /* 11f0 - */ 0, - /* 11f1 - */ 0, - /* 11f2 - */ 0, - /* 11f3 - */ 0, - /* 11f4 - */ 0, - /* 11f5 - */ 0, - /* 11f6 - */ 0, - /* 11f7 - */ 0, - /* 11f8 - */ 0, - /* 11f9 - _V_66_0F_38_BD */ 0x412c, - /* 11fa - */ 0, - /* 11fb - */ 0, - /* 11fc - */ 0, - /* 11fd - */ 0, - /* 11fe - */ 0, - /* 11ff - */ 0, - /* 1200 - */ 0, - /* 1201 - */ 0, - /* 1202 - */ 0, - /* 1203 - */ 0, - /* 1204 - */ 0, - /* 1205 - _V_66_0F_38_BE */ 0x412d, - /* 1206 - */ 0, - /* 1207 - */ 0, - /* 1208 - */ 0, - /* 1209 - */ 0, - /* 120a - */ 0, - /* 120b - */ 0, - /* 120c - */ 0, - /* 120d - */ 0, - /* 120e - */ 0, - /* 120f - */ 0, - /* 1210 - */ 0, - /* 1211 - _V_66_0F_38_BF */ 0x412e, - /* 1212 - */ 0, - /* 1213 - */ 0, - /* 1214 - */ 0, - /* 1215 - */ 0, - /* 1216 - */ 0, - /* 1217 - */ 0, - /* 1218 - */ 0, - /* 1219 - _66_0F_38_DB */ 0x24b6, - /* 121a - */ 0, - /* 121b - */ 0, - /* 121c - */ 0, - /* 121d - */ 0, - /* 121e - */ 0, - /* 121f - */ 0, - /* 1220 - */ 0, - /* 1221 - _NV_66_0F_38_DB */ 0x412f, - /* 1222 - */ 0, - /* 1223 - */ 0, - /* 1224 - */ 0, - /* 1225 - _66_0F_38_DC */ 0x24b7, - /* 1226 - */ 0, - /* 1227 - */ 0, - /* 1228 - */ 0, - /* 1229 - _V_66_0F_38_DC */ 0x4130, - /* 122a - */ 0, - /* 122b - */ 0, - /* 122c - */ 0, - /* 122d - */ 0, - /* 122e - */ 0, - /* 122f - */ 0, - /* 1230 - */ 0, - /* 1231 - _66_0F_38_DD */ 0x24b8, - /* 1232 - */ 0, - /* 1233 - */ 0, - /* 1234 - */ 0, - /* 1235 - _V_66_0F_38_DD */ 0x4131, - /* 1236 - */ 0, - /* 1237 - */ 0, - /* 1238 - */ 0, - /* 1239 - */ 0, - /* 123a - */ 0, - /* 123b - */ 0, - /* 123c - */ 0, - /* 123d - _66_0F_38_DE */ 0x24b9, - /* 123e - */ 0, - /* 123f - */ 0, - /* 1240 - */ 0, - /* 1241 - _V_66_0F_38_DE */ 0x4132, - /* 1242 - */ 0, - /* 1243 - */ 0, - /* 1244 - */ 0, - /* 1245 - */ 0, - /* 1246 - */ 0, - /* 1247 - */ 0, - /* 1248 - */ 0, - /* 1249 - _66_0F_38_DF */ 0x24ba, - /* 124a - */ 0, - /* 124b - */ 0, - /* 124c - */ 0, - /* 124d - _V_66_0F_38_DF */ 0x4133, - /* 124e - */ 0, - /* 124f - */ 0, - /* 1250 - */ 0, - /* 1251 - */ 0, - /* 1252 - */ 0, - /* 1253 - */ 0, - /* 1254 - _0F_38_F0 */ 0x24bb, - /* 1255 - */ 0, - /* 1256 - */ 0, - /* 1257 - _F2_0F_38_F0 */ 0x24bc, - /* 1258 - */ 0, - /* 1259 - */ 0, - /* 125a - */ 0, - /* 125b - */ 0, - /* 125c - */ 0, - /* 125d - */ 0, - /* 125e - */ 0, - /* 125f - */ 0, - /* 1260 - _0F_38_F1 */ 0x24bd, - /* 1261 - */ 0, - /* 1262 - */ 0, - /* 1263 - _F2_0F_38_F1 */ 0x24be, - /* 1264 - */ 0, - /* 1265 - */ 0, - /* 1266 - */ 0, - /* 1267 - */ 0, - /* 1268 - */ 0, - /* 1269 - */ 0, - /* 126a - */ 0, - /* 126b - */ 0, - /* 126c - */ 0, - /* 126d - */ 0, - /* 126e - */ 0, - /* 126f - */ 0, - /* 1270 - */ 0, - /* 1271 - */ 0, - /* 1272 - */ 0, - /* 1273 - */ 0, - /* 1274 - */ 0, - /* 1275 - _NV_66_0F_3A_04 */ 0x4134, - /* 1276 - */ 0, - /* 1277 - */ 0, - /* 1278 - */ 0, - /* 1279 - */ 0, - /* 127a - */ 0, - /* 127b - */ 0, - /* 127c - */ 0, - /* 127d - */ 0, - /* 127e - */ 0, - /* 127f - */ 0, - /* 1280 - */ 0, - /* 1281 - _NV_66_0F_3A_05 */ 0x4135, - /* 1282 - */ 0, - /* 1283 - */ 0, - /* 1284 - */ 0, - /* 1285 - */ 0, - /* 1286 - */ 0, - /* 1287 - */ 0, - /* 1288 - */ 0, - /* 1289 - _V_66_0F_3A_06 */ 0x4136, - /* 128a - */ 0, - /* 128b - */ 0, - /* 128c - */ 0, - /* 128d - */ 0, - /* 128e - */ 0, - /* 128f - */ 0, - /* 1290 - */ 0, - /* 1291 - _66_0F_3A_08 */ 0x4137, - /* 1292 - */ 0, - /* 1293 - */ 0, - /* 1294 - */ 0, - /* 1295 - */ 0, - /* 1296 - */ 0, - /* 1297 - */ 0, - /* 1298 - */ 0, - /* 1299 - _NV_66_0F_3A_08 */ 0x4138, - /* 129a - */ 0, - /* 129b - */ 0, - /* 129c - */ 0, - /* 129d - _66_0F_3A_09 */ 0x4139, - /* 129e - */ 0, - /* 129f - */ 0, - /* 12a0 - */ 0, - /* 12a1 - */ 0, - /* 12a2 - */ 0, - /* 12a3 - */ 0, - /* 12a4 - */ 0, - /* 12a5 - _NV_66_0F_3A_09 */ 0x413a, - /* 12a6 - */ 0, - /* 12a7 - */ 0, - /* 12a8 - */ 0, - /* 12a9 - _66_0F_3A_0A */ 0x413b, - /* 12aa - */ 0, - /* 12ab - */ 0, - /* 12ac - */ 0, - /* 12ad - _V_66_0F_3A_0A */ 0x413c, - /* 12ae - */ 0, - /* 12af - */ 0, - /* 12b0 - */ 0, - /* 12b1 - */ 0, - /* 12b2 - */ 0, - /* 12b3 - */ 0, - /* 12b4 - */ 0, - /* 12b5 - _66_0F_3A_0B */ 0x413d, - /* 12b6 - */ 0, - /* 12b7 - */ 0, - /* 12b8 - */ 0, - /* 12b9 - _V_66_0F_3A_0B */ 0x413e, - /* 12ba - */ 0, - /* 12bb - */ 0, - /* 12bc - */ 0, - /* 12bd - */ 0, - /* 12be - */ 0, - /* 12bf - */ 0, - /* 12c0 - */ 0, - /* 12c1 - _66_0F_3A_0C */ 0x413f, - /* 12c2 - */ 0, - /* 12c3 - */ 0, - /* 12c4 - */ 0, - /* 12c5 - _V_66_0F_3A_0C */ 0x4140, - /* 12c6 - */ 0, - /* 12c7 - */ 0, - /* 12c8 - */ 0, - /* 12c9 - */ 0, - /* 12ca - */ 0, - /* 12cb - */ 0, - /* 12cc - */ 0, - /* 12cd - _66_0F_3A_0D */ 0x4141, - /* 12ce - */ 0, - /* 12cf - */ 0, - /* 12d0 - */ 0, - /* 12d1 - _V_66_0F_3A_0D */ 0x4142, - /* 12d2 - */ 0, - /* 12d3 - */ 0, - /* 12d4 - */ 0, - /* 12d5 - */ 0, - /* 12d6 - */ 0, - /* 12d7 - */ 0, - /* 12d8 - */ 0, - /* 12d9 - _66_0F_3A_0E */ 0x4143, - /* 12da - */ 0, - /* 12db - */ 0, - /* 12dc - */ 0, - /* 12dd - _V_66_0F_3A_0E */ 0x4144, - /* 12de - */ 0, - /* 12df - */ 0, - /* 12e0 - */ 0, - /* 12e1 - */ 0, - /* 12e2 - */ 0, - /* 12e3 - */ 0, - /* 12e4 - _0F_3A_0F */ 0x4145, - /* 12e5 - _66_0F_3A_0F */ 0x4146, - /* 12e6 - */ 0, - /* 12e7 - */ 0, - /* 12e8 - */ 0, - /* 12e9 - _V_66_0F_3A_0F */ 0x4147, - /* 12ea - */ 0, - /* 12eb - */ 0, - /* 12ec - */ 0, - /* 12ed - */ 0, - /* 12ee - */ 0, - /* 12ef - */ 0, - /* 12f0 - */ 0, - /* 12f1 - _66_0F_3A_14 */ 0x4148, - /* 12f2 - */ 0, - /* 12f3 - */ 0, - /* 12f4 - */ 0, - /* 12f5 - */ 0, - /* 12f6 - */ 0, - /* 12f7 - */ 0, - /* 12f8 - */ 0, - /* 12f9 - _NV_66_0F_3A_14 */ 0x4149, - /* 12fa - */ 0, - /* 12fb - */ 0, - /* 12fc - */ 0, - /* 12fd - _66_0F_3A_15 */ 0x414a, - /* 12fe - */ 0, - /* 12ff - */ 0, - /* 1300 - */ 0, - /* 1301 - */ 0, - /* 1302 - */ 0, - /* 1303 - */ 0, - /* 1304 - */ 0, - /* 1305 - _NV_66_0F_3A_15 */ 0x414b, - /* 1306 - */ 0, - /* 1307 - */ 0, - /* 1308 - */ 0, - /* 1309 - _66_0F_3A_16 */ 0x414c, - /* 130a - */ 0, - /* 130b - */ 0, - /* 130c - */ 0, - /* 130d - */ 0, - /* 130e - */ 0, - /* 130f - */ 0, - /* 1310 - */ 0, - /* 1311 - _NV_66_0F_3A_16 */ 0x414d, - /* 1312 - */ 0, - /* 1313 - */ 0, - /* 1314 - */ 0, - /* 1315 - _66_0F_3A_17 */ 0x414e, - /* 1316 - */ 0, - /* 1317 - */ 0, - /* 1318 - */ 0, - /* 1319 - */ 0, - /* 131a - */ 0, - /* 131b - */ 0, - /* 131c - */ 0, - /* 131d - _NV_66_0F_3A_17 */ 0x414f, - /* 131e - */ 0, - /* 131f - */ 0, - /* 1320 - */ 0, - /* 1321 - */ 0, - /* 1322 - */ 0, - /* 1323 - */ 0, - /* 1324 - */ 0, - /* 1325 - _V_66_0F_3A_18 */ 0x4150, - /* 1326 - */ 0, - /* 1327 - */ 0, - /* 1328 - */ 0, - /* 1329 - */ 0, - /* 132a - */ 0, - /* 132b - */ 0, - /* 132c - */ 0, - /* 132d - */ 0, - /* 132e - */ 0, - /* 132f - */ 0, - /* 1330 - */ 0, - /* 1331 - */ 0, - /* 1332 - */ 0, - /* 1333 - */ 0, - /* 1334 - */ 0, - /* 1335 - _NV_66_0F_3A_19 */ 0x4151, - /* 1336 - */ 0, - /* 1337 - */ 0, - /* 1338 - */ 0, - /* 1339 - _66_0F_3A_20 */ 0x4152, - /* 133a - */ 0, - /* 133b - */ 0, - /* 133c - */ 0, - /* 133d - _V_66_0F_3A_20 */ 0x4153, - /* 133e - */ 0, - /* 133f - */ 0, - /* 1340 - */ 0, - /* 1341 - */ 0, - /* 1342 - */ 0, - /* 1343 - */ 0, - /* 1344 - */ 0, - /* 1345 - _66_0F_3A_21 */ 0x4154, - /* 1346 - */ 0, - /* 1347 - */ 0, - /* 1348 - */ 0, - /* 1349 - _V_66_0F_3A_21 */ 0x4155, - /* 134a - */ 0, - /* 134b - */ 0, - /* 134c - */ 0, - /* 134d - */ 0, - /* 134e - */ 0, - /* 134f - */ 0, - /* 1350 - */ 0, - /* 1351 - _66_0F_3A_22 */ 0x4156, - /* 1352 - */ 0, - /* 1353 - */ 0, - /* 1354 - */ 0, - /* 1355 - _V_66_0F_3A_22 */ 0x4157, - /* 1356 - */ 0, - /* 1357 - */ 0, - /* 1358 - */ 0, - /* 1359 - */ 0, - /* 135a - */ 0, - /* 135b - */ 0, - /* 135c - */ 0, - /* 135d - _66_0F_3A_40 */ 0x4158, - /* 135e - */ 0, - /* 135f - */ 0, - /* 1360 - */ 0, - /* 1361 - _V_66_0F_3A_40 */ 0x4159, - /* 1362 - */ 0, - /* 1363 - */ 0, - /* 1364 - */ 0, - /* 1365 - */ 0, - /* 1366 - */ 0, - /* 1367 - */ 0, - /* 1368 - */ 0, - /* 1369 - _66_0F_3A_41 */ 0x415a, - /* 136a - */ 0, - /* 136b - */ 0, - /* 136c - */ 0, - /* 136d - _V_66_0F_3A_41 */ 0x415b, - /* 136e - */ 0, - /* 136f - */ 0, - /* 1370 - */ 0, - /* 1371 - */ 0, - /* 1372 - */ 0, - /* 1373 - */ 0, - /* 1374 - */ 0, - /* 1375 - _66_0F_3A_42 */ 0x415c, - /* 1376 - */ 0, - /* 1377 - */ 0, - /* 1378 - */ 0, - /* 1379 - _V_66_0F_3A_42 */ 0x415d, - /* 137a - */ 0, - /* 137b - */ 0, - /* 137c - */ 0, - /* 137d - */ 0, - /* 137e - */ 0, - /* 137f - */ 0, - /* 1380 - */ 0, - /* 1381 - _66_0F_3A_44 */ 0x415e, - /* 1382 - */ 0, - /* 1383 - */ 0, - /* 1384 - */ 0, - /* 1385 - _V_66_0F_3A_44 */ 0x415f, - /* 1386 - */ 0, - /* 1387 - */ 0, - /* 1388 - */ 0, - /* 1389 - */ 0, - /* 138a - */ 0, - /* 138b - */ 0, - /* 138c - */ 0, - /* 138d - */ 0, - /* 138e - */ 0, - /* 138f - */ 0, - /* 1390 - */ 0, - /* 1391 - _V_66_0F_3A_4A */ 0x4160, - /* 1392 - */ 0, - /* 1393 - */ 0, - /* 1394 - */ 0, - /* 1395 - */ 0, - /* 1396 - */ 0, - /* 1397 - */ 0, - /* 1398 - */ 0, - /* 1399 - */ 0, - /* 139a - */ 0, - /* 139b - */ 0, - /* 139c - */ 0, - /* 139d - _V_66_0F_3A_4B */ 0x4161, - /* 139e - */ 0, - /* 139f - */ 0, - /* 13a0 - */ 0, - /* 13a1 - */ 0, - /* 13a2 - */ 0, - /* 13a3 - */ 0, - /* 13a4 - */ 0, - /* 13a5 - */ 0, - /* 13a6 - */ 0, - /* 13a7 - */ 0, - /* 13a8 - */ 0, - /* 13a9 - _V_66_0F_3A_4C */ 0x4162, - /* 13aa - */ 0, - /* 13ab - */ 0, - /* 13ac - */ 0, - /* 13ad - */ 0, - /* 13ae - */ 0, - /* 13af - */ 0, - /* 13b0 - */ 0, - /* 13b1 - _66_0F_3A_60 */ 0x4163, - /* 13b2 - */ 0, - /* 13b3 - */ 0, - /* 13b4 - */ 0, - /* 13b5 - */ 0, - /* 13b6 - */ 0, - /* 13b7 - */ 0, - /* 13b8 - */ 0, - /* 13b9 - _NV_66_0F_3A_60 */ 0x4164, - /* 13ba - */ 0, - /* 13bb - */ 0, - /* 13bc - */ 0, - /* 13bd - _66_0F_3A_61 */ 0x4165, - /* 13be - */ 0, - /* 13bf - */ 0, - /* 13c0 - */ 0, - /* 13c1 - */ 0, - /* 13c2 - */ 0, - /* 13c3 - */ 0, - /* 13c4 - */ 0, - /* 13c5 - _NV_66_0F_3A_61 */ 0x4166, - /* 13c6 - */ 0, - /* 13c7 - */ 0, - /* 13c8 - */ 0, - /* 13c9 - _66_0F_3A_62 */ 0x4167, - /* 13ca - */ 0, - /* 13cb - */ 0, - /* 13cc - */ 0, - /* 13cd - */ 0, - /* 13ce - */ 0, - /* 13cf - */ 0, - /* 13d0 - */ 0, - /* 13d1 - _NV_66_0F_3A_62 */ 0x4168, - /* 13d2 - */ 0, - /* 13d3 - */ 0, - /* 13d4 - */ 0, - /* 13d5 - _66_0F_3A_63 */ 0x4169, - /* 13d6 - */ 0, - /* 13d7 - */ 0, - /* 13d8 - */ 0, - /* 13d9 - */ 0, - /* 13da - */ 0, - /* 13db - */ 0, - /* 13dc - */ 0, - /* 13dd - _NV_66_0F_3A_63 */ 0x416a, - /* 13de - */ 0, - /* 13df - */ 0, - /* 13e0 - */ 0, - /* 13e1 - _66_0F_3A_DF */ 0x416b, - /* 13e2 - */ 0, - /* 13e3 - */ 0, - /* 13e4 - */ 0, - /* 13e5 - */ 0, - /* 13e6 - */ 0, - /* 13e7 - */ 0, - /* 13e8 - */ 0, - /* 13e9 - _NV_66_0F_3A_DF */ 0x416c, - /* 13ea - */ 0, - /* 13eb - */ 0, - /* 13ec - _0F_71_02 */ 0x24bf, - /* 13ed - _66_0F_71_02 */ 0x24c0, - /* 13ee - */ 0, - /* 13ef - */ 0, - /* 13f0 - */ 0, - /* 13f1 - _V_66_0F_71_02 */ 0x416d, - /* 13f2 - */ 0, - /* 13f3 - */ 0, - /* 13f4 - */ 0, - /* 13f5 - */ 0, - /* 13f6 - */ 0, - /* 13f7 - */ 0, - /* 13f8 - _0F_71_04 */ 0x24c1, - /* 13f9 - _66_0F_71_04 */ 0x24c2, - /* 13fa - */ 0, - /* 13fb - */ 0, - /* 13fc - */ 0, - /* 13fd - _V_66_0F_71_04 */ 0x416e, - /* 13fe - */ 0, - /* 13ff - */ 0, - /* 1400 - */ 0, - /* 1401 - */ 0, - /* 1402 - */ 0, - /* 1403 - */ 0, - /* 1404 - _0F_71_06 */ 0x24c3, - /* 1405 - _66_0F_71_06 */ 0x24c4, - /* 1406 - */ 0, - /* 1407 - */ 0, - /* 1408 - */ 0, - /* 1409 - _V_66_0F_71_06 */ 0x416f, - /* 140a - */ 0, - /* 140b - */ 0, - /* 140c - */ 0, - /* 140d - */ 0, - /* 140e - */ 0, - /* 140f - */ 0, - /* 1410 - _0F_72_02 */ 0x24c5, - /* 1411 - _66_0F_72_02 */ 0x24c6, - /* 1412 - */ 0, - /* 1413 - */ 0, - /* 1414 - */ 0, - /* 1415 - _V_66_0F_72_02 */ 0x4170, - /* 1416 - */ 0, - /* 1417 - */ 0, - /* 1418 - */ 0, - /* 1419 - */ 0, - /* 141a - */ 0, - /* 141b - */ 0, - /* 141c - _0F_72_04 */ 0x24c7, - /* 141d - _66_0F_72_04 */ 0x24c8, - /* 141e - */ 0, - /* 141f - */ 0, - /* 1420 - */ 0, - /* 1421 - _V_66_0F_72_04 */ 0x4171, - /* 1422 - */ 0, - /* 1423 - */ 0, - /* 1424 - */ 0, - /* 1425 - */ 0, - /* 1426 - */ 0, - /* 1427 - */ 0, - /* 1428 - _0F_72_06 */ 0x24c9, - /* 1429 - _66_0F_72_06 */ 0x24ca, - /* 142a - */ 0, - /* 142b - */ 0, - /* 142c - */ 0, - /* 142d - _V_66_0F_72_06 */ 0x4172, - /* 142e - */ 0, - /* 142f - */ 0, - /* 1430 - */ 0, - /* 1431 - */ 0, - /* 1432 - */ 0, - /* 1433 - */ 0, - /* 1434 - _0F_73_02 */ 0x24cb, - /* 1435 - _66_0F_73_02 */ 0x24cc, - /* 1436 - */ 0, - /* 1437 - */ 0, - /* 1438 - */ 0, - /* 1439 - _V_66_0F_73_02 */ 0x4173, - /* 143a - */ 0, - /* 143b - */ 0, - /* 143c - */ 0, - /* 143d - */ 0, - /* 143e - */ 0, - /* 143f - */ 0, - /* 1440 - */ 0, - /* 1441 - _66_0F_73_03 */ 0x24cd, - /* 1442 - */ 0, - /* 1443 - */ 0, - /* 1444 - */ 0, - /* 1445 - _V_66_0F_73_03 */ 0x4174, - /* 1446 - */ 0, - /* 1447 - */ 0, - /* 1448 - */ 0, - /* 1449 - */ 0, - /* 144a - */ 0, - /* 144b - */ 0, - /* 144c - _0F_73_06 */ 0x24ce, - /* 144d - _66_0F_73_06 */ 0x24cf, - /* 144e - */ 0, - /* 144f - */ 0, - /* 1450 - */ 0, - /* 1451 - _V_66_0F_73_06 */ 0x4175, - /* 1452 - */ 0, - /* 1453 - */ 0, - /* 1454 - */ 0, - /* 1455 - */ 0, - /* 1456 - */ 0, - /* 1457 - */ 0, - /* 1458 - */ 0, - /* 1459 - _66_0F_73_07 */ 0x24d0, - /* 145a - */ 0, - /* 145b - */ 0, - /* 145c - */ 0, - /* 145d - _V_66_0F_73_07 */ 0x4176, - /* 145e - */ 0, - /* 145f - */ 0, - /* 1460 - */ 0, - /* 1461 - */ 0, - /* 1462 - */ 0, - /* 1463 - */ 0, - /* 1464 - _0F_AE_02 */ 0x24d1, - /* 1465 - */ 0, - /* 1466 - */ 0, - /* 1467 - */ 0, - /* 1468 - */ 0, - /* 1469 - */ 0, - /* 146a - */ 0, - /* 146b - */ 0, - /* 146c - _NV_0F_AE_02 */ 0x4177, - /* 146d - */ 0, - /* 146e - */ 0, - /* 146f - */ 0, - /* 1470 - _0F_AE_03 */ 0x24d2, - /* 1471 - */ 0, - /* 1472 - */ 0, - /* 1473 - */ 0, - /* 1474 - */ 0, - /* 1475 - */ 0, - /* 1476 - */ 0, - /* 1477 - */ 0, - /* 1478 - _NV_0F_AE_03 */ 0x4178, - /* 1479 - */ 0, - /* 147a - */ 0, - /* 147b - */ 0, - /* 147c - _0F_C7_06 */ 0x24d3, - /* 147d - _66_0F_C7_06 */ 0x24d4, - /* 147e - _F3_0F_C7_06 */ 0x24d5, - /* 147f - */ 0, - /* 1480 - */ 0, - /* 1481 - */ 0, - /* 1482 - */ 0, - /* 1483 - */ 0, - /* 1484 - */ 0, - /* 1485 - */ 0, - /* 1486 - */ 0, - /* 1487 - */ 0}; diff --git a/target/i386/latx/diStorm/insts.h b/target/i386/latx/diStorm/insts.h deleted file mode 100644 index 5d27235a822..00000000000 --- a/target/i386/latx/diStorm/insts.h +++ /dev/null @@ -1,41 +0,0 @@ -/* -insts.h - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#ifndef INSTS_H -#define INSTS_H - -#include "instructions.h" - -/* Flags Table */ -extern _iflags FlagsTable[]; - -/* Root Trie DB */ -extern _InstInfo InstInfos[]; -extern _InstInfoEx InstInfosEx[]; -extern _InstNode InstructionsTree[]; - -/* 3DNow! Trie DB */ -extern _InstNode Table_0F_0F; -/* AVX related: */ -extern _InstNode Table_0F, Table_0F_38, Table_0F_3A; - -#endif /* INSTS_H */ diff --git a/target/i386/latx/diStorm/meson.build b/target/i386/latx/diStorm/meson.build deleted file mode 100644 index 3479ec26ff1..00000000000 --- a/target/i386/latx/diStorm/meson.build +++ /dev/null @@ -1,9 +0,0 @@ -i386_ss.add(when: 'CONFIG_LATX', if_true: files( - 'decoder.c', - 'instructions.c', - 'insts.c', - 'mnemonics.c', - 'operands.c', - 'prefix.c', - 'x86defs.c' -)) diff --git a/target/i386/latx/diStorm/mnemonics.c b/target/i386/latx/diStorm/mnemonics.c deleted file mode 100644 index 570c2cd9c6d..00000000000 --- a/target/i386/latx/diStorm/mnemonics.c +++ /dev/null @@ -1,278 +0,0 @@ -/* -mnemonics.c - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#include "mnemonics.h" - -// clang-format off -const unsigned char _MNEMONICS[] = -"\x09" "UNDEFINED\0" "\x03" "ADD\0" "\x04" "PUSH\0" "\x03" "POP\0" "\x02" "OR\0" \ -"\x03" "ADC\0" "\x03" "SBB\0" "\x03" "AND\0" "\x03" "DAA\0" "\x03" "SUB\0" \ -"\x03" "DAS\0" "\x03" "XOR\0" "\x03" "AAA\0" "\x03" "CMP\0" "\x03" "AAS\0" \ -"\x03" "INC\0" "\x03" "DEC\0" "\x05" "PUSHA\0" "\x04" "POPA\0" "\x05" "BOUND\0" \ -"\x04" "ARPL\0" "\x04" "IMUL\0" "\x03" "INS\0" "\x04" "OUTS\0" "\x02" "JO\0" \ -"\x03" "JNO\0" "\x02" "JB\0" "\x03" "JAE\0" "\x02" "JZ\0" "\x03" "JNZ\0" "\x03" "JBE\0" \ -"\x02" "JA\0" "\x02" "JS\0" "\x03" "JNS\0" "\x02" "JP\0" "\x03" "JNP\0" "\x02" "JL\0" \ -"\x03" "JGE\0" "\x03" "JLE\0" "\x02" "JG\0" "\x04" "TEST\0" "\x04" "XCHG\0" \ -"\x03" "MOV\0" "\x03" "LEA\0" "\x03" "CBW\0" "\x04" "CWDE\0" "\x04" "CDQE\0" \ -"\x03" "CWD\0" "\x03" "CDQ\0" "\x03" "CQO\0" "\x08" "CALL FAR\0" "\x05" "PUSHF\0" \ -"\x04" "POPF\0" "\x04" "SAHF\0" "\x04" "LAHF\0" "\x04" "MOVS\0" "\x04" "CMPS\0" \ -"\x04" "STOS\0" "\x04" "LODS\0" "\x04" "SCAS\0" "\x03" "RET\0" "\x03" "LES\0" \ -"\x03" "LDS\0" "\x05" "ENTER\0" "\x05" "LEAVE\0" "\x04" "RETF\0" "\x05" "INT 3\0" \ -"\x03" "INT\0" "\x04" "INTO\0" "\x04" "IRET\0" "\x03" "AAM\0" "\x03" "AAD\0" \ -"\x04" "SALC\0" "\x04" "XLAT\0" "\x06" "LOOPNZ\0" "\x05" "LOOPZ\0" "\x04" "LOOP\0" \ -"\x04" "JCXZ\0" "\x05" "JECXZ\0" "\x05" "JRCXZ\0" "\x02" "IN\0" "\x03" "OUT\0" \ -"\x04" "CALL\0" "\x03" "JMP\0" "\x07" "JMP FAR\0" "\x04" "INT1\0" "\x03" "HLT\0" \ -"\x03" "CMC\0" "\x03" "CLC\0" "\x03" "STC\0" "\x03" "CLI\0" "\x03" "STI\0" \ -"\x03" "CLD\0" "\x03" "STD\0" "\x03" "LAR\0" "\x03" "LSL\0" "\x07" "SYSCALL\0" \ -"\x04" "CLTS\0" "\x06" "SYSRET\0" "\x04" "INVD\0" "\x06" "WBINVD\0" "\x03" "UD2\0" \ -"\x05" "FEMMS\0" "\x03" "NOP\0" "\x05" "WRMSR\0" "\x05" "RDTSC\0" "\x05" "RDMSR\0" \ -"\x05" "RDPMC\0" "\x08" "SYSENTER\0" "\x07" "SYSEXIT\0" "\x06" "GETSEC\0" "\x05" "CMOVO\0" \ -"\x06" "CMOVNO\0" "\x05" "CMOVB\0" "\x06" "CMOVAE\0" "\x05" "CMOVZ\0" "\x06" "CMOVNZ\0" \ -"\x06" "CMOVBE\0" "\x05" "CMOVA\0" "\x05" "CMOVS\0" "\x06" "CMOVNS\0" "\x05" "CMOVP\0" \ -"\x06" "CMOVNP\0" "\x05" "CMOVL\0" "\x06" "CMOVGE\0" "\x06" "CMOVLE\0" "\x05" "CMOVG\0" \ -"\x04" "SETO\0" "\x05" "SETNO\0" "\x04" "SETB\0" "\x05" "SETAE\0" "\x04" "SETZ\0" \ -"\x05" "SETNZ\0" "\x05" "SETBE\0" "\x04" "SETA\0" "\x04" "SETS\0" "\x05" "SETNS\0" \ -"\x04" "SETP\0" "\x05" "SETNP\0" "\x04" "SETL\0" "\x05" "SETGE\0" "\x05" "SETLE\0" \ -"\x04" "SETG\0" "\x05" "CPUID\0" "\x02" "BT\0" "\x04" "SHLD\0" "\x03" "RSM\0" \ -"\x03" "BTS\0" "\x04" "SHRD\0" "\x07" "CMPXCHG\0" "\x03" "LSS\0" "\x03" "BTR\0" \ -"\x03" "LFS\0" "\x03" "LGS\0" "\x05" "MOVZX\0" "\x03" "BTC\0" "\x03" "BSF\0" \ -"\x05" "MOVSX\0" "\x04" "XADD\0" "\x06" "MOVNTI\0" "\x05" "BSWAP\0" "\x03" "ROL\0" \ -"\x03" "ROR\0" "\x03" "RCL\0" "\x03" "RCR\0" "\x03" "SHL\0" "\x03" "SHR\0" \ -"\x03" "SAL\0" "\x03" "SAR\0" "\x04" "FADD\0" "\x04" "FMUL\0" "\x04" "FCOM\0" \ -"\x05" "FCOMP\0" "\x04" "FSUB\0" "\x05" "FSUBR\0" "\x04" "FDIV\0" "\x05" "FDIVR\0" \ -"\x03" "FLD\0" "\x03" "FST\0" "\x04" "FSTP\0" "\x06" "FLDENV\0" "\x05" "FLDCW\0" \ -"\x04" "FXCH\0" "\x04" "FNOP\0" "\x04" "FCHS\0" "\x04" "FABS\0" "\x04" "FTST\0" \ -"\x04" "FXAM\0" "\x04" "FLD1\0" "\x06" "FLDL2T\0" "\x06" "FLDL2E\0" "\x05" "FLDPI\0" \ -"\x06" "FLDLG2\0" "\x06" "FLDLN2\0" "\x04" "FLDZ\0" "\x05" "F2XM1\0" "\x05" "FYL2X\0" \ -"\x05" "FPTAN\0" "\x06" "FPATAN\0" "\x07" "FXTRACT\0" "\x06" "FPREM1\0" "\x07" "FDECSTP\0" \ -"\x07" "FINCSTP\0" "\x05" "FPREM\0" "\x07" "FYL2XP1\0" "\x05" "FSQRT\0" "\x07" "FSINCOS\0" \ -"\x07" "FRNDINT\0" "\x06" "FSCALE\0" "\x04" "FSIN\0" "\x04" "FCOS\0" "\x05" "FIADD\0" \ -"\x05" "FIMUL\0" "\x05" "FICOM\0" "\x06" "FICOMP\0" "\x05" "FISUB\0" "\x06" "FISUBR\0" \ -"\x05" "FIDIV\0" "\x06" "FIDIVR\0" "\x06" "FCMOVB\0" "\x06" "FCMOVE\0" "\x07" "FCMOVBE\0" \ -"\x06" "FCMOVU\0" "\x07" "FUCOMPP\0" "\x04" "FILD\0" "\x06" "FISTTP\0" "\x04" "FIST\0" \ -"\x05" "FISTP\0" "\x07" "FCMOVNB\0" "\x07" "FCMOVNE\0" "\x08" "FCMOVNBE\0" \ -"\x07" "FCMOVNU\0" "\x04" "FENI\0" "\x06" "FEDISI\0" "\x06" "FSETPM\0" "\x06" "FUCOMI\0" \ -"\x05" "FCOMI\0" "\x06" "FRSTOR\0" "\x05" "FFREE\0" "\x05" "FUCOM\0" "\x06" "FUCOMP\0" \ -"\x05" "FADDP\0" "\x05" "FMULP\0" "\x06" "FCOMPP\0" "\x06" "FSUBRP\0" "\x05" "FSUBP\0" \ -"\x06" "FDIVRP\0" "\x05" "FDIVP\0" "\x04" "FBLD\0" "\x05" "FBSTP\0" "\x07" "FUCOMIP\0" \ -"\x06" "FCOMIP\0" "\x03" "NOT\0" "\x03" "NEG\0" "\x03" "MUL\0" "\x03" "DIV\0" \ -"\x04" "IDIV\0" "\x04" "SLDT\0" "\x03" "STR\0" "\x04" "LLDT\0" "\x03" "LTR\0" \ -"\x04" "VERR\0" "\x04" "VERW\0" "\x04" "SGDT\0" "\x04" "SIDT\0" "\x04" "LGDT\0" \ -"\x04" "LIDT\0" "\x04" "SMSW\0" "\x04" "LMSW\0" "\x06" "INVLPG\0" "\x06" "VMCALL\0" \ -"\x08" "VMLAUNCH\0" "\x08" "VMRESUME\0" "\x06" "VMXOFF\0" "\x07" "MONITOR\0" \ -"\x05" "MWAIT\0" "\x06" "XGETBV\0" "\x06" "XSETBV\0" "\x05" "VMRUN\0" "\x07" "VMMCALL\0" \ -"\x06" "VMLOAD\0" "\x06" "VMSAVE\0" "\x04" "STGI\0" "\x04" "CLGI\0" "\x06" "SKINIT\0" \ -"\x07" "INVLPGA\0" "\x06" "SWAPGS\0" "\x06" "RDTSCP\0" "\x08" "PREFETCH\0" \ -"\x09" "PREFETCHW\0" "\x05" "PI2FW\0" "\x05" "PI2FD\0" "\x05" "PF2IW\0" "\x05" "PF2ID\0" \ -"\x06" "PFNACC\0" "\x07" "PFPNACC\0" "\x07" "PFCMPGE\0" "\x05" "PFMIN\0" "\x05" "PFRCP\0" \ -"\x07" "PFRSQRT\0" "\x05" "PFSUB\0" "\x05" "PFADD\0" "\x07" "PFCMPGT\0" "\x05" "PFMAX\0" \ -"\x08" "PFRCPIT1\0" "\x08" "PFRSQIT1\0" "\x06" "PFSUBR\0" "\x05" "PFACC\0" \ -"\x07" "PFCMPEQ\0" "\x05" "PFMUL\0" "\x08" "PFRCPIT2\0" "\x07" "PMULHRW\0" \ -"\x06" "PSWAPD\0" "\x07" "PAVGUSB\0" "\x06" "MOVUPS\0" "\x06" "MOVUPD\0" "\x05" "MOVSS\0" \ -"\x05" "MOVSD\0" "\x06" "VMOVSS\0" "\x06" "VMOVSD\0" "\x07" "VMOVUPS\0" "\x07" "VMOVUPD\0" \ -"\x07" "MOVHLPS\0" "\x06" "MOVLPS\0" "\x06" "MOVLPD\0" "\x08" "MOVSLDUP\0" \ -"\x07" "MOVDDUP\0" "\x08" "VMOVHLPS\0" "\x07" "VMOVLPS\0" "\x07" "VMOVLPD\0" \ -"\x09" "VMOVSLDUP\0" "\x08" "VMOVDDUP\0" "\x08" "UNPCKLPS\0" "\x08" "UNPCKLPD\0" \ -"\x09" "VUNPCKLPS\0" "\x09" "VUNPCKLPD\0" "\x08" "UNPCKHPS\0" "\x08" "UNPCKHPD\0" \ -"\x09" "VUNPCKHPS\0" "\x09" "VUNPCKHPD\0" "\x07" "MOVLHPS\0" "\x06" "MOVHPS\0" \ -"\x06" "MOVHPD\0" "\x08" "MOVSHDUP\0" "\x08" "VMOVLHPS\0" "\x07" "VMOVHPS\0" \ -"\x07" "VMOVHPD\0" "\x09" "VMOVSHDUP\0" "\x0b" "PREFETCHNTA\0" "\x0a" "PREFETCHT0\0" \ -"\x0a" "PREFETCHT1\0" "\x0a" "PREFETCHT2\0" "\x06" "MOVAPS\0" "\x06" "MOVAPD\0" \ -"\x07" "VMOVAPS\0" "\x07" "VMOVAPD\0" "\x08" "CVTPI2PS\0" "\x08" "CVTPI2PD\0" \ -"\x08" "CVTSI2SS\0" "\x08" "CVTSI2SD\0" "\x09" "VCVTSI2SS\0" "\x09" "VCVTSI2SD\0" \ -"\x07" "MOVNTPS\0" "\x07" "MOVNTPD\0" "\x07" "MOVNTSS\0" "\x07" "MOVNTSD\0" \ -"\x08" "VMOVNTPS\0" "\x08" "VMOVNTPD\0" "\x09" "CVTTPS2PI\0" "\x09" "CVTTPD2PI\0" \ -"\x09" "CVTTSS2SI\0" "\x09" "CVTTSD2SI\0" "\x0a" "VCVTTSS2SI\0" "\x0a" "VCVTTSD2SI\0" \ -"\x08" "CVTPS2PI\0" "\x08" "CVTPD2PI\0" "\x08" "CVTSS2SI\0" "\x08" "CVTSD2SI\0" \ -"\x09" "VCVTSS2SI\0" "\x09" "VCVTSD2SI\0" "\x07" "UCOMISS\0" "\x07" "UCOMISD\0" \ -"\x08" "VUCOMISS\0" "\x08" "VUCOMISD\0" "\x06" "COMISS\0" "\x06" "COMISD\0" \ -"\x07" "VCOMISS\0" "\x07" "VCOMISD\0" "\x08" "MOVMSKPS\0" "\x08" "MOVMSKPD\0" \ -"\x09" "VMOVMSKPS\0" "\x09" "VMOVMSKPD\0" "\x06" "SQRTPS\0" "\x06" "SQRTPD\0" \ -"\x06" "SQRTSS\0" "\x06" "SQRTSD\0" "\x07" "VSQRTSS\0" "\x07" "VSQRTSD\0" "\x07" "VSQRTPS\0" \ -"\x07" "VSQRTPD\0" "\x07" "RSQRTPS\0" "\x07" "RSQRTSS\0" "\x08" "VRSQRTSS\0" \ -"\x08" "VRSQRTPS\0" "\x05" "RCPPS\0" "\x05" "RCPSS\0" "\x06" "VRCPSS\0" "\x06" "VRCPPS\0" \ -"\x05" "ANDPS\0" "\x05" "ANDPD\0" "\x06" "VANDPS\0" "\x06" "VANDPD\0" "\x06" "ANDNPS\0" \ -"\x06" "ANDNPD\0" "\x07" "VANDNPS\0" "\x07" "VANDNPD\0" "\x04" "ORPS\0" "\x04" "ORPD\0" \ -"\x05" "VORPS\0" "\x05" "VORPD\0" "\x05" "XORPS\0" "\x05" "XORPD\0" "\x06" "VXORPS\0" \ -"\x06" "VXORPD\0" "\x05" "ADDPS\0" "\x05" "ADDPD\0" "\x05" "ADDSS\0" "\x05" "ADDSD\0" \ -"\x06" "VADDPS\0" "\x06" "VADDPD\0" "\x06" "VADDSS\0" "\x06" "VADDSD\0" "\x05" "MULPS\0" \ -"\x05" "MULPD\0" "\x05" "MULSS\0" "\x05" "MULSD\0" "\x06" "VMULPS\0" "\x06" "VMULPD\0" \ -"\x06" "VMULSS\0" "\x06" "VMULSD\0" "\x08" "CVTPS2PD\0" "\x08" "CVTPD2PS\0" \ -"\x08" "CVTSS2SD\0" "\x08" "CVTSD2SS\0" "\x09" "VCVTSS2SD\0" "\x09" "VCVTSD2SS\0" \ -"\x09" "VCVTPS2PD\0" "\x09" "VCVTPD2PS\0" "\x08" "CVTDQ2PS\0" "\x08" "CVTPS2DQ\0" \ -"\x09" "CVTTPS2DQ\0" "\x09" "VCVTDQ2PS\0" "\x09" "VCVTPS2DQ\0" "\x0a" "VCVTTPS2DQ\0" \ -"\x05" "SUBPS\0" "\x05" "SUBPD\0" "\x05" "SUBSS\0" "\x05" "SUBSD\0" "\x06" "VSUBPS\0" \ -"\x06" "VSUBPD\0" "\x06" "VSUBSS\0" "\x06" "VSUBSD\0" "\x05" "MINPS\0" "\x05" "MINPD\0" \ -"\x05" "MINSS\0" "\x05" "MINSD\0" "\x06" "VMINPS\0" "\x06" "VMINPD\0" "\x06" "VMINSS\0" \ -"\x06" "VMINSD\0" "\x05" "DIVPS\0" "\x05" "DIVPD\0" "\x05" "DIVSS\0" "\x05" "DIVSD\0" \ -"\x06" "VDIVPS\0" "\x06" "VDIVPD\0" "\x06" "VDIVSS\0" "\x06" "VDIVSD\0" "\x05" "MAXPS\0" \ -"\x05" "MAXPD\0" "\x05" "MAXSS\0" "\x05" "MAXSD\0" "\x06" "VMAXPS\0" "\x06" "VMAXPD\0" \ -"\x06" "VMAXSS\0" "\x06" "VMAXSD\0" "\x09" "PUNPCKLBW\0" "\x0a" "VPUNPCKLBW\0" \ -"\x09" "PUNPCKLWD\0" "\x0a" "VPUNPCKLWD\0" "\x09" "PUNPCKLDQ\0" "\x0a" "VPUNPCKLDQ\0" \ -"\x08" "PACKSSWB\0" "\x09" "VPACKSSWB\0" "\x07" "PCMPGTB\0" "\x08" "VPCMPGTB\0" \ -"\x07" "PCMPGTW\0" "\x08" "VPCMPGTW\0" "\x07" "PCMPGTD\0" "\x08" "VPCMPGTD\0" \ -"\x08" "PACKUSWB\0" "\x09" "VPACKUSWB\0" "\x09" "PUNPCKHBW\0" "\x0a" "VPUNPCKHBW\0" \ -"\x09" "PUNPCKHWD\0" "\x0a" "VPUNPCKHWD\0" "\x09" "PUNPCKHDQ\0" "\x0a" "VPUNPCKHDQ\0" \ -"\x08" "PACKSSDW\0" "\x09" "VPACKSSDW\0" "\x0a" "PUNPCKLQDQ\0" "\x0b" "VPUNPCKLQDQ\0" \ -"\x0a" "PUNPCKHQDQ\0" "\x0b" "VPUNPCKHQDQ\0" "\x04" "MOVD\0" "\x04" "MOVQ\0" \ -"\x05" "VMOVD\0" "\x05" "VMOVQ\0" "\x06" "MOVDQA\0" "\x06" "MOVDQU\0" "\x07" "VMOVDQA\0" \ -"\x07" "VMOVDQU\0" "\x06" "PSHUFW\0" "\x06" "PSHUFD\0" "\x07" "PSHUFHW\0" "\x07" "PSHUFLW\0" \ -"\x07" "VPSHUFD\0" "\x08" "VPSHUFHW\0" "\x08" "VPSHUFLW\0" "\x07" "PCMPEQB\0" \ -"\x08" "VPCMPEQB\0" "\x07" "PCMPEQW\0" "\x08" "VPCMPEQW\0" "\x07" "PCMPEQD\0" \ -"\x08" "VPCMPEQD\0" "\x04" "EMMS\0" "\x0a" "VZEROUPPER\0" "\x08" "VZEROALL\0" \ -"\x06" "VMREAD\0" "\x05" "EXTRQ\0" "\x07" "INSERTQ\0" "\x07" "VMWRITE\0" "\x06" "HADDPD\0" \ -"\x06" "HADDPS\0" "\x07" "VHADDPD\0" "\x07" "VHADDPS\0" "\x06" "HSUBPD\0" "\x06" "HSUBPS\0" \ -"\x07" "VHSUBPD\0" "\x07" "VHSUBPS\0" "\x06" "FXSAVE\0" "\x07" "FXRSTOR\0" \ -"\x04" "XAVE\0" "\x06" "LFENCE\0" "\x06" "XRSTOR\0" "\x06" "MFENCE\0" "\x06" "SFENCE\0" \ -"\x07" "CLFLUSH\0" "\x06" "POPCNT\0" "\x03" "BSR\0" "\x05" "LZCNT\0" "\x07" "CMPEQPS\0" \ -"\x07" "CMPLTPS\0" "\x07" "CMPLEPS\0" "\x0a" "CMPUNORDPS\0" "\x08" "CMPNEQPS\0" \ -"\x08" "CMPNLTPS\0" "\x08" "CMPNLEPS\0" "\x08" "CMPORDPS\0" "\x07" "CMPEQPD\0" \ -"\x07" "CMPLTPD\0" "\x07" "CMPLEPD\0" "\x0a" "CMPUNORDPD\0" "\x08" "CMPNEQPD\0" \ -"\x08" "CMPNLTPD\0" "\x08" "CMPNLEPD\0" "\x08" "CMPORDPD\0" "\x07" "CMPEQSS\0" \ -"\x07" "CMPLTSS\0" "\x07" "CMPLESS\0" "\x0a" "CMPUNORDSS\0" "\x08" "CMPNEQSS\0" \ -"\x08" "CMPNLTSS\0" "\x08" "CMPNLESS\0" "\x08" "CMPORDSS\0" "\x07" "CMPEQSD\0" \ -"\x07" "CMPLTSD\0" "\x07" "CMPLESD\0" "\x0a" "CMPUNORDSD\0" "\x08" "CMPNEQSD\0" \ -"\x08" "CMPNLTSD\0" "\x08" "CMPNLESD\0" "\x08" "CMPORDSD\0" "\x08" "VCMPEQPS\0" \ -"\x08" "VCMPLTPS\0" "\x08" "VCMPLEPS\0" "\x0b" "VCMPUNORDPS\0" "\x09" "VCMPNEQPS\0" \ -"\x09" "VCMPNLTPS\0" "\x09" "VCMPNLEPS\0" "\x09" "VCMPORDPS\0" "\x08" "VCMPEQPD\0" \ -"\x08" "VCMPLTPD\0" "\x08" "VCMPLEPD\0" "\x0b" "VCMPUNORDPD\0" "\x09" "VCMPNEQPD\0" \ -"\x09" "VCMPNLTPD\0" "\x09" "VCMPNLEPD\0" "\x09" "VCMPORDPD\0" "\x08" "VCMPEQSS\0" \ -"\x08" "VCMPLTSS\0" "\x08" "VCMPLESS\0" "\x0b" "VCMPUNORDSS\0" "\x09" "VCMPNEQSS\0" \ -"\x09" "VCMPNLTSS\0" "\x09" "VCMPNLESS\0" "\x09" "VCMPORDSS\0" "\x08" "VCMPEQSD\0" \ -"\x08" "VCMPLTSD\0" "\x08" "VCMPLESD\0" "\x0b" "VCMPUNORDSD\0" "\x09" "VCMPNEQSD\0" \ -"\x09" "VCMPNLTSD\0" "\x09" "VCMPNLESD\0" "\x09" "VCMPORDSD\0" "\x06" "PINSRW\0" \ -"\x07" "VPINSRW\0" "\x06" "PEXTRW\0" "\x07" "VPEXTRW\0" "\x06" "SHUFPS\0" "\x06" "SHUFPD\0" \ -"\x07" "VSHUFPS\0" "\x07" "VSHUFPD\0" "\x09" "CMPXCHG8B\0" "\x0a" "CMPXCHG16B\0" \ -"\x07" "VMPTRST\0" "\x08" "ADDSUBPD\0" "\x08" "ADDSUBPS\0" "\x09" "VADDSUBPD\0" \ -"\x09" "VADDSUBPS\0" "\x05" "PSRLW\0" "\x06" "VPSRLW\0" "\x05" "PSRLD\0" "\x06" "VPSRLD\0" \ -"\x05" "PSRLQ\0" "\x06" "VPSRLQ\0" "\x05" "PADDQ\0" "\x06" "VPADDQ\0" "\x06" "PMULLW\0" \ -"\x07" "VPMULLW\0" "\x07" "MOVQ2DQ\0" "\x07" "MOVDQ2Q\0" "\x08" "PMOVMSKB\0" \ -"\x09" "VPMOVMSKB\0" "\x07" "PSUBUSB\0" "\x08" "VPSUBUSB\0" "\x07" "PSUBUSW\0" \ -"\x08" "VPSUBUSW\0" "\x06" "PMINUB\0" "\x07" "VPMINUB\0" "\x04" "PAND\0" "\x05" "VPAND\0" \ -"\x07" "PADDUSB\0" "\x08" "VPADDUSW\0" "\x07" "PADDUSW\0" "\x06" "PMAXUB\0" \ -"\x07" "VPMAXUB\0" "\x05" "PANDN\0" "\x06" "VPANDN\0" "\x05" "PAVGB\0" "\x06" "VPAVGB\0" \ -"\x05" "PSRAW\0" "\x06" "VPSRAW\0" "\x05" "PSRAD\0" "\x06" "VPSRAD\0" "\x05" "PAVGW\0" \ -"\x06" "VPAVGW\0" "\x07" "PMULHUW\0" "\x08" "VPMULHUW\0" "\x06" "PMULHW\0" \ -"\x07" "VPMULHW\0" "\x09" "CVTTPD2DQ\0" "\x08" "CVTDQ2PD\0" "\x08" "CVTPD2DQ\0" \ -"\x0a" "VCVTTPD2DQ\0" "\x09" "VCVTDQ2PD\0" "\x09" "VCVTPD2DQ\0" "\x06" "MOVNTQ\0" \ -"\x07" "MOVNTDQ\0" "\x08" "VMOVNTDQ\0" "\x06" "PSUBSB\0" "\x07" "VPSUBSB\0" \ -"\x06" "PSUBSW\0" "\x07" "VPSUBSW\0" "\x06" "PMINSW\0" "\x07" "VPMINSW\0" "\x03" "POR\0" \ -"\x04" "VPOR\0" "\x06" "PADDSB\0" "\x07" "VPADDSB\0" "\x06" "PADDSW\0" "\x07" "VPADDSW\0" \ -"\x06" "PMAXSW\0" "\x07" "VPMAXSW\0" "\x04" "PXOR\0" "\x05" "VPXOR\0" "\x05" "LDDQU\0" \ -"\x06" "VLDDQU\0" "\x05" "PSLLW\0" "\x06" "VPSLLW\0" "\x05" "PSLLD\0" "\x06" "VPSLLD\0" \ -"\x05" "PSLLQ\0" "\x06" "VPSLLQ\0" "\x07" "PMULUDQ\0" "\x08" "VPMULUDQ\0" "\x07" "PMADDWD\0" \ -"\x08" "VPMADDWD\0" "\x06" "PSADBW\0" "\x07" "VPSADBW\0" "\x08" "MASKMOVQ\0" \ -"\x0a" "MASKMOVDQU\0" "\x0b" "VMASKMOVDQU\0" "\x05" "PSUBB\0" "\x06" "VPSUBB\0" \ -"\x05" "PSUBW\0" "\x06" "VPSUBW\0" "\x05" "PSUBD\0" "\x06" "VPSUBD\0" "\x05" "PSUBQ\0" \ -"\x06" "VPSUBQ\0" "\x05" "PADDB\0" "\x06" "VPADDB\0" "\x05" "PADDW\0" "\x06" "VPADDW\0" \ -"\x05" "PADDD\0" "\x06" "VPADDD\0" "\x07" "FNSTENV\0" "\x06" "FSTENV\0" "\x06" "FNSTCW\0" \ -"\x05" "FSTCW\0" "\x06" "FNCLEX\0" "\x05" "FCLEX\0" "\x06" "FNINIT\0" "\x05" "FINIT\0" \ -"\x06" "FNSAVE\0" "\x05" "FSAVE\0" "\x06" "FNSTSW\0" "\x05" "FSTSW\0" "\x06" "PSHUFB\0" \ -"\x07" "VPSHUFB\0" "\x06" "PHADDW\0" "\x07" "VPHADDW\0" "\x06" "PHADDD\0" "\x07" "VPHADDD\0" \ -"\x07" "PHADDSW\0" "\x08" "VPHADDSW\0" "\x09" "PMADDUBSW\0" "\x0a" "VPMADDUBSW\0" \ -"\x06" "PHSUBW\0" "\x07" "VPHSUBW\0" "\x06" "PHSUBD\0" "\x07" "VPHSUBD\0" "\x07" "PHSUBSW\0" \ -"\x08" "VPHSUBSW\0" "\x06" "PSIGNB\0" "\x07" "VPSIGNB\0" "\x06" "PSIGNW\0" \ -"\x07" "VPSIGNW\0" "\x06" "PSIGND\0" "\x07" "VPSIGND\0" "\x08" "PMULHRSW\0" \ -"\x09" "VPMULHRSW\0" "\x09" "VPERMILPS\0" "\x09" "VPERMILPD\0" "\x08" "VPTESTPS\0" \ -"\x08" "VPTESTPD\0" "\x08" "PBLENDVB\0" "\x08" "BLENDVPS\0" "\x08" "BLENDVPD\0" \ -"\x05" "PTEST\0" "\x06" "VPTEST\0" "\x0c" "VBROADCASTSS\0" "\x0c" "VBROADCASTSD\0" \ -"\x0e" "VBROADCASTF128\0" "\x05" "PABSB\0" "\x06" "VPABSB\0" "\x05" "PABSW\0" \ -"\x06" "VPABSW\0" "\x05" "PABSD\0" "\x06" "VPABSD\0" "\x08" "PMOVSXBW\0" "\x09" "VPMOVSXBW\0" \ -"\x08" "PMOVSXBD\0" "\x09" "VPMOVSXBD\0" "\x08" "PMOVSXBQ\0" "\x09" "VPMOVSXBQ\0" \ -"\x08" "PMOVSXWD\0" "\x09" "VPMOVSXWD\0" "\x08" "PMOVSXWQ\0" "\x09" "VPMOVSXWQ\0" \ -"\x08" "PMOVSXDQ\0" "\x09" "VPMOVSXDQ\0" "\x06" "PMULDQ\0" "\x07" "VPMULDQ\0" \ -"\x07" "PCMPEQQ\0" "\x08" "VPCMPEQQ\0" "\x08" "MOVNTDQA\0" "\x09" "VMOVNTDQA\0" \ -"\x08" "PACKUSDW\0" "\x09" "VPACKUSDW\0" "\x0a" "VMASKMOVPS\0" "\x0a" "VMASKMOVPD\0" \ -"\x08" "PMOVZXBW\0" "\x09" "VPMOVZXBW\0" "\x08" "PMOVZXBD\0" "\x09" "VPMOVZXBD\0" \ -"\x08" "PMOVZXBQ\0" "\x09" "VPMOVZXBQ\0" "\x08" "PMOVZXWD\0" "\x09" "VPMOVZXWD\0" \ -"\x08" "PMOVZXWQ\0" "\x09" "VPMOVZXWQ\0" "\x08" "PMOVZXDQ\0" "\x09" "VPMOVZXDQ\0" \ -"\x07" "PCMPGTQ\0" "\x08" "VPCMPGTQ\0" "\x06" "PMINSB\0" "\x07" "VPMINSB\0" \ -"\x06" "PMINSD\0" "\x07" "VPMINSD\0" "\x06" "PMINUW\0" "\x07" "VPMINUW\0" "\x06" "PMINUD\0" \ -"\x07" "VPMINUD\0" "\x06" "PMAXSB\0" "\x07" "VPMAXSB\0" "\x06" "PMAXSD\0" "\x07" "VPMAXSD\0" \ -"\x06" "PMAXUW\0" "\x07" "VPMAXUW\0" "\x06" "PMAXUD\0" "\x07" "VPMAXUD\0" "\x06" "PMULLD\0" \ -"\x07" "VPMULLD\0" "\x0a" "PHMINPOSUW\0" "\x0b" "VPHMINPOSUW\0" "\x06" "INVEPT\0" \ -"\x07" "INVVPID\0" "\x0e" "VFMADDSUB132PS\0" "\x0e" "VFMADDSUB132PD\0" "\x0e" "VFMSUBADD132PS\0" \ -"\x0e" "VFMSUBADD132PD\0" "\x0b" "VFMADD132PS\0" "\x0b" "VFMADD132PD\0" "\x0b" "VFMADD132SS\0" \ -"\x0b" "VFMADD132SD\0" "\x0b" "VFMSUB132PS\0" "\x0b" "VFMSUB132PD\0" "\x0b" "VFMSUB132SS\0" \ -"\x0b" "VFMSUB132SD\0" "\x0c" "VFNMADD132PS\0" "\x0c" "VFNMADD132PD\0" "\x0c" "VFNMADD132SS\0" \ -"\x0c" "VFNMADD132SD\0" "\x0c" "VFNMSUB132PS\0" "\x0c" "VFNMSUB132PD\0" "\x0c" "VFNMSUB132SS\0" \ -"\x0c" "VFNMSUB132SD\0" "\x0e" "VFMADDSUB213PS\0" "\x0e" "VFMADDSUB213PD\0" \ -"\x0e" "VFMSUBADD213PS\0" "\x0e" "VFMSUBADD213PD\0" "\x0b" "VFMADD213PS\0" \ -"\x0b" "VFMADD213PD\0" "\x0b" "VFMADD213SS\0" "\x0b" "VFMADD213SD\0" "\x0b" "VFMSUB213PS\0" \ -"\x0b" "VFMSUB213PD\0" "\x0b" "VFMSUB213SS\0" "\x0b" "VFMSUB213SD\0" "\x0c" "VFNMADD213PS\0" \ -"\x0c" "VFNMADD213PD\0" "\x0c" "VFNMADD213SS\0" "\x0c" "VFNMADD213SD\0" "\x0c" "VFNMSUB213PS\0" \ -"\x0c" "VFNMSUB213PD\0" "\x0c" "VFNMSUB213SS\0" "\x0c" "VFNMSUB213SD\0" "\x0e" "VFMADDSUB231PS\0" \ -"\x0e" "VFMADDSUB231PD\0" "\x0e" "VFMSUBADD231PS\0" "\x0e" "VFMSUBADD231PD\0" \ -"\x0b" "VFMADD231PS\0" "\x0b" "VFMADD231PD\0" "\x0b" "VFMADD231SS\0" "\x0b" "VFMADD231SD\0" \ -"\x0b" "VFMSUB231PS\0" "\x0b" "VFMSUB231PD\0" "\x0b" "VFMSUB231SS\0" "\x0b" "VFMSUB231SD\0" \ -"\x0c" "VFNMADD231PS\0" "\x0c" "VFNMADD231PD\0" "\x0c" "VFNMADD231SS\0" "\x0c" "VFNMADD231SD\0" \ -"\x0c" "VFNMSUB231PS\0" "\x0c" "VFNMSUB231PD\0" "\x0c" "VFNMSUB231SS\0" "\x0c" "VFNMSUB231SD\0" \ -"\x06" "AESIMC\0" "\x07" "VAESIMC\0" "\x06" "AESENC\0" "\x07" "VAESENC\0" "\x0a" "AESENCLAST\0" \ -"\x0b" "VAESENCLAST\0" "\x06" "AESDEC\0" "\x07" "VAESDEC\0" "\x0a" "AESDECLAST\0" \ -"\x0b" "VAESDECLAST\0" "\x05" "MOVBE\0" "\x05" "CRC32\0" "\x0a" "VPERM2F128\0" \ -"\x07" "ROUNDPS\0" "\x08" "VROUNDPS\0" "\x07" "ROUNDPD\0" "\x08" "VROUNDPD\0" \ -"\x07" "ROUNDSS\0" "\x08" "VROUNDSS\0" "\x07" "ROUNDSD\0" "\x08" "VROUNDSD\0" \ -"\x07" "BLENDPS\0" "\x08" "VBLENDPS\0" "\x07" "BLENDPD\0" "\x08" "VBLENDPD\0" \ -"\x07" "PBLENDW\0" "\x09" "VPBLENDVW\0" "\x07" "PALIGNR\0" "\x08" "VPALIGNR\0" \ -"\x06" "PEXTRB\0" "\x07" "VPEXTRB\0" "\x06" "PEXTRD\0" "\x06" "PEXTRQ\0" "\x07" "VPEXTRD\0" \ -"\x09" "EXTRACTPS\0" "\x0a" "VEXTRACTPS\0" "\x0b" "VINSERTF128\0" "\x0c" "VEXTRACTF128\0" \ -"\x06" "PINSRB\0" "\x07" "VPINSRB\0" "\x08" "INSERTPS\0" "\x09" "VINSERTPS\0" \ -"\x06" "PINSRD\0" "\x06" "PINSRQ\0" "\x07" "VPINSRD\0" "\x07" "VPINSRQ\0" "\x04" "DPPS\0" \ -"\x05" "VDPPS\0" "\x04" "DPPD\0" "\x05" "VDPPD\0" "\x07" "MPSADBW\0" "\x08" "VMPSADBW\0" \ -"\x09" "PCLMULQDQ\0" "\x0a" "VPCLMULQDQ\0" "\x09" "VBLENDVPS\0" "\x09" "VBLENDVPD\0" \ -"\x09" "VPBLENDVB\0" "\x09" "PCMPESTRM\0" "\x0a" "VPCMPESTRM\0" "\x09" "PCMPESTRI\0" \ -"\x09" "VCMPESTRI\0" "\x09" "PCMPISTRM\0" "\x0a" "VPCMPISTRM\0" "\x09" "PCMPISTRI\0" \ -"\x0a" "VPCMPISTRI\0" "\x0f" "AESKEYGENASSIST\0" "\x10" "VAESKEYGENASSIST\0" \ -"\x06" "PSRLDQ\0" "\x07" "VPSRLDQ\0" "\x06" "PSLLDQ\0" "\x07" "VPSLLDQ\0" "\x07" "LDMXCSR\0" \ -"\x08" "VLDMXCSR\0" "\x07" "STMXCSR\0" "\x08" "VSTMXCSR\0" "\x07" "VMPTRLD\0" \ -"\x07" "VMCLEAR\0" "\x05" "VMXON\0" "\x04" "WAIT\0" "\x06" "MOVSXD\0" "\x05" "PAUSE\0"; -// clang-format on - -const _WRegister _REGISTERS[] = { - {3, "RAX"}, {3, "RCX"}, {3, "RDX"}, {3, "RBX"}, {3, "RSP"}, - {3, "RBP"}, {3, "RSI"}, {3, "RDI"}, {2, "R8"}, {2, "R9"}, - {3, "R10"}, {3, "R11"}, {3, "R12"}, {3, "R13"}, {3, "R14"}, - {3, "R15"}, {3, "EAX"}, {3, "ECX"}, {3, "EDX"}, {3, "EBX"}, - {3, "ESP"}, {3, "EBP"}, {3, "ESI"}, {3, "EDI"}, {3, "R8D"}, - {3, "R9D"}, {4, "R10D"}, {4, "R11D"}, {4, "R12D"}, {4, "R13D"}, - {4, "R14D"}, {4, "R15D"}, {2, "AX"}, {2, "CX"}, {2, "DX"}, - {2, "BX"}, {2, "SP"}, {2, "BP"}, {2, "SI"}, {2, "DI"}, - {3, "R8W"}, {3, "R9W"}, {4, "R10W"}, {4, "R11W"}, {4, "R12W"}, - {4, "R13W"}, {4, "R14W"}, {4, "R15W"}, {2, "AL"}, {2, "CL"}, - {2, "DL"}, {2, "BL"}, {2, "AH"}, {2, "CH"}, {2, "DH"}, - {2, "BH"}, {3, "R8B"}, {3, "R9B"}, {4, "R10B"}, {4, "R11B"}, - {4, "R12B"}, {4, "R13B"}, {4, "R14B"}, {4, "R15B"}, {3, "SPL"}, - {3, "BPL"}, {3, "SIL"}, {3, "DIL"}, {2, "ES"}, {2, "CS"}, - {2, "SS"}, {2, "DS"}, {2, "FS"}, {2, "GS"}, {3, "RIP"}, - {3, "ST0"}, {3, "ST1"}, {3, "ST2"}, {3, "ST3"}, {3, "ST4"}, - {3, "ST5"}, {3, "ST6"}, {3, "ST7"}, {3, "MM0"}, {3, "MM1"}, - {3, "MM2"}, {3, "MM3"}, {3, "MM4"}, {3, "MM5"}, {3, "MM6"}, - {3, "MM7"}, {4, "XMM0"}, {4, "XMM1"}, {4, "XMM2"}, {4, "XMM3"}, - {4, "XMM4"}, {4, "XMM5"}, {4, "XMM6"}, {4, "XMM7"}, {4, "XMM8"}, - {4, "XMM9"}, {5, "XMM10"}, {5, "XMM11"}, {5, "XMM12"}, {5, "XMM13"}, - {5, "XMM14"}, {5, "XMM15"}, {4, "YMM0"}, {4, "YMM1"}, {4, "YMM2"}, - {4, "YMM3"}, {4, "YMM4"}, {4, "YMM5"}, {4, "YMM6"}, {4, "YMM7"}, - {4, "YMM8"}, {4, "YMM9"}, {5, "YMM10"}, {5, "YMM11"}, {5, "YMM12"}, - {5, "YMM13"}, {5, "YMM14"}, {5, "YMM15"}, {3, "CR0"}, {0, ""}, - {3, "CR2"}, {3, "CR3"}, {3, "CR4"}, {0, ""}, {0, ""}, - {0, ""}, {3, "CR8"}, {3, "DR0"}, {3, "DR1"}, {3, "DR2"}, - {3, "DR3"}, {0, ""}, {0, ""}, {3, "DR6"}, {3, "DR7"}}; diff --git a/target/i386/latx/diStorm/mnemonics.h b/target/i386/latx/diStorm/mnemonics.h deleted file mode 100644 index 6c7ef1fef4a..00000000000 --- a/target/i386/latx/diStorm/mnemonics.h +++ /dev/null @@ -1,1187 +0,0 @@ -/* -mnemonics.h - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#ifndef MNEMONICS_H -#define MNEMONICS_H - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct WMnemonic { - unsigned char length; - unsigned char p[1]; /* p is a null terminated string, which contains - 'length' characters. */ -} _WMnemonic; - -typedef struct WRegister { - unsigned int length; - unsigned char p[6]; /* p is a null terminated string. */ -} _WRegister; - -extern const unsigned char _MNEMONICS[]; -extern const _WRegister _REGISTERS[]; - -#ifdef __cplusplus -} /* End Of Extern */ -#endif - -#define GET_REGISTER_NAME(r) (unsigned char*)_REGISTERS[(r)].p -#define GET_MNEMONIC_NAME(m) ((_WMnemonic*)&_MNEMONICS[(m)])->p - -typedef enum { - I_UNDEFINED = 0, - I_AAA = 66, - I_AAD = 389, - I_AAM = 384, - I_AAS = 76, - I_ADC = 31, - I_ADD = 11, - I_ADDPD = 3107, - I_ADDPS = 3100, - I_ADDSD = 3121, - I_ADDSS = 3114, - I_ADDSUBPD = 5074, - I_ADDSUBPS = 5084, - I_AESDEC = 7882, - I_AESDECLAST = 7899, - I_AESENC = 7840, - I_AESENCLAST = 7857, - I_AESIMC = 7823, - I_AESKEYGENASSIST = 8459, - I_AND = 41, - I_ANDNPD = 3018, - I_ANDNPS = 3010, - I_ANDPD = 2987, - I_ANDPS = 2980, - I_ARPL = 111, - I_BLENDPD = 8045, - I_BLENDPS = 8026, - I_BLENDVPD = 6301, - I_BLENDVPS = 6291, - I_BOUND = 104, - I_BSF = 939, - I_BSR = 4298, - I_BSWAP = 965, - I_BT = 872, - I_BTC = 934, - I_BTR = 912, - I_BTS = 887, - I_CALL = 456, - I_CALL_FAR = 260, - I_CBW = 228, - I_CDQ = 250, - I_CDQE = 239, - I_CLC = 492, - I_CLD = 512, - I_CLFLUSH = 4281, - I_CLGI = 1830, - I_CLI = 502, - I_CLTS = 541, - I_CMC = 487, - I_CMOVA = 694, - I_CMOVAE = 663, - I_CMOVB = 656, - I_CMOVBE = 686, - I_CMOVG = 754, - I_CMOVGE = 738, - I_CMOVL = 731, - I_CMOVLE = 746, - I_CMOVNO = 648, - I_CMOVNP = 723, - I_CMOVNS = 708, - I_CMOVNZ = 678, - I_CMOVO = 641, - I_CMOVP = 716, - I_CMOVS = 701, - I_CMOVZ = 671, - I_CMP = 71, - I_CMPEQPD = 4389, - I_CMPEQPS = 4310, - I_CMPEQSD = 4547, - I_CMPEQSS = 4468, - I_CMPLEPD = 4407, - I_CMPLEPS = 4328, - I_CMPLESD = 4565, - I_CMPLESS = 4486, - I_CMPLTPD = 4398, - I_CMPLTPS = 4319, - I_CMPLTSD = 4556, - I_CMPLTSS = 4477, - I_CMPNEQPD = 4428, - I_CMPNEQPS = 4349, - I_CMPNEQSD = 4586, - I_CMPNEQSS = 4507, - I_CMPNLEPD = 4448, - I_CMPNLEPS = 4369, - I_CMPNLESD = 4606, - I_CMPNLESS = 4527, - I_CMPNLTPD = 4438, - I_CMPNLTPS = 4359, - I_CMPNLTSD = 4596, - I_CMPNLTSS = 4517, - I_CMPORDPD = 4458, - I_CMPORDPS = 4379, - I_CMPORDSD = 4616, - I_CMPORDSS = 4537, - I_CMPS = 301, - I_CMPUNORDPD = 4416, - I_CMPUNORDPS = 4337, - I_CMPUNORDSD = 4574, - I_CMPUNORDSS = 4495, - I_CMPXCHG = 898, - I_CMPXCHG16B = 5053, - I_CMPXCHG8B = 5042, - I_COMISD = 2776, - I_COMISS = 2768, - I_CPUID = 865, - I_CQO = 255, - I_CRC32 = 7931, - I_CVTDQ2PD = 5467, - I_CVTDQ2PS = 3304, - I_CVTPD2DQ = 5477, - I_CVTPD2PI = 2678, - I_CVTPD2PS = 3230, - I_CVTPI2PD = 2492, - I_CVTPI2PS = 2482, - I_CVTPS2DQ = 3314, - I_CVTPS2PD = 3220, - I_CVTPS2PI = 2668, - I_CVTSD2SI = 2698, - I_CVTSD2SS = 3250, - I_CVTSI2SD = 2512, - I_CVTSI2SS = 2502, - I_CVTSS2SD = 3240, - I_CVTSS2SI = 2688, - I_CVTTPD2DQ = 5456, - I_CVTTPD2PI = 2611, - I_CVTTPS2DQ = 3324, - I_CVTTPS2PI = 2600, - I_CVTTSD2SI = 2633, - I_CVTTSS2SI = 2622, - I_CWD = 245, - I_CWDE = 233, - I_DAA = 46, - I_DAS = 56, - I_DEC = 86, - I_DIV = 1635, - I_DIVPD = 3496, - I_DIVPS = 3489, - I_DIVSD = 3510, - I_DIVSS = 3503, - I_DPPD = 8280, - I_DPPS = 8267, - I_EMMS = 4097, - I_ENTER = 340, - I_EXTRACTPS = 8145, - I_EXTRQ = 4133, - I_F2XM1 = 1181, - I_FABS = 1112, - I_FADD = 1012, - I_FADDP = 1538, - I_FBLD = 1590, - I_FBSTP = 1596, - I_FCHS = 1106, - I_FCLEX = 5969, - I_FCMOVB = 1365, - I_FCMOVBE = 1381, - I_FCMOVE = 1373, - I_FCMOVNB = 1434, - I_FCMOVNBE = 1452, - I_FCMOVNE = 1443, - I_FCMOVNU = 1462, - I_FCMOVU = 1390, - I_FCOM = 1024, - I_FCOMI = 1501, - I_FCOMIP = 1612, - I_FCOMP = 1030, - I_FCOMPP = 1552, - I_FCOS = 1300, - I_FDECSTP = 1227, - I_FDIV = 1050, - I_FDIVP = 1583, - I_FDIVR = 1056, - I_FDIVRP = 1575, - I_FEDISI = 1477, - I_FEMMS = 574, - I_FENI = 1471, - I_FFREE = 1516, - I_FIADD = 1306, - I_FICOM = 1320, - I_FICOMP = 1327, - I_FIDIV = 1350, - I_FIDIVR = 1357, - I_FILD = 1407, - I_FIMUL = 1313, - I_FINCSTP = 1236, - I_FINIT = 5984, - I_FIST = 1421, - I_FISTP = 1427, - I_FISTTP = 1413, - I_FISUB = 1335, - I_FISUBR = 1342, - I_FLD = 1063, - I_FLD1 = 1130, - I_FLDCW = 1087, - I_FLDENV = 1079, - I_FLDL2E = 1144, - I_FLDL2T = 1136, - I_FLDLG2 = 1159, - I_FLDLN2 = 1167, - I_FLDPI = 1152, - I_FLDZ = 1175, - I_FMUL = 1018, - I_FMULP = 1545, - I_FNCLEX = 5961, - I_FNINIT = 5976, - I_FNOP = 1100, - I_FNSAVE = 5991, - I_FNSTCW = 5946, - I_FNSTENV = 5929, - I_FNSTSW = 6006, - I_FPATAN = 1202, - I_FPREM = 1245, - I_FPREM1 = 1219, - I_FPTAN = 1195, - I_FRNDINT = 1277, - I_FRSTOR = 1508, - I_FSAVE = 5999, - I_FSCALE = 1286, - I_FSETPM = 1485, - I_FSIN = 1294, - I_FSINCOS = 1268, - I_FSQRT = 1261, - I_FST = 1068, - I_FSTCW = 5954, - I_FSTENV = 5938, - I_FSTP = 1073, - I_FSTSW = 6014, - I_FSUB = 1037, - I_FSUBP = 1568, - I_FSUBR = 1043, - I_FSUBRP = 1560, - I_FTST = 1118, - I_FUCOM = 1523, - I_FUCOMI = 1493, - I_FUCOMIP = 1603, - I_FUCOMP = 1530, - I_FUCOMPP = 1398, - I_FXAM = 1124, - I_FXCH = 1094, - I_FXRSTOR = 4234, - I_FXSAVE = 4226, - I_FXTRACT = 1210, - I_FYL2X = 1188, - I_FYL2XP1 = 1252, - I_GETSEC = 633, - I_HADDPD = 4158, - I_HADDPS = 4166, - I_HLT = 482, - I_HSUBPD = 4192, - I_HSUBPS = 4200, - I_IDIV = 1640, - I_IMUL = 117, - I_IN = 447, - I_INC = 81, - I_INS = 123, - I_INSERTPS = 8212, - I_INSERTQ = 4140, - I_INT = 367, - I_INT_3 = 360, - I_INT1 = 476, - I_INTO = 372, - I_INVD = 555, - I_INVEPT = 6966, - I_INVLPG = 1716, - I_INVLPGA = 1844, - I_INVVPID = 6974, - I_IRET = 378, - I_JA = 166, - I_JAE = 147, - I_JB = 143, - I_JBE = 161, - I_JCXZ = 427, - I_JECXZ = 433, - I_JG = 202, - I_JGE = 192, - I_JL = 188, - I_JLE = 197, - I_JMP = 462, - I_JMP_FAR = 467, - I_JNO = 138, - I_JNP = 183, - I_JNS = 174, - I_JNZ = 156, - I_JO = 134, - I_JP = 179, - I_JRCXZ = 440, - I_JS = 170, - I_JZ = 152, - I_LAHF = 289, - I_LAR = 522, - I_LDDQU = 5674, - I_LDMXCSR = 8528, - I_LDS = 335, - I_LEA = 223, - I_LEAVE = 347, - I_LES = 330, - I_LFENCE = 4249, - I_LFS = 917, - I_LGDT = 1692, - I_LGS = 922, - I_LIDT = 1698, - I_LLDT = 1657, - I_LMSW = 1710, - I_LODS = 313, - I_LOOP = 421, - I_LOOPNZ = 406, - I_LOOPZ = 414, - I_LSL = 527, - I_LSS = 907, - I_LTR = 1663, - I_LZCNT = 4303, - I_MASKMOVDQU = 5799, - I_MASKMOVQ = 5789, - I_MAXPD = 3556, - I_MAXPS = 3549, - I_MAXSD = 3570, - I_MAXSS = 3563, - I_MFENCE = 4265, - I_MINPD = 3436, - I_MINPS = 3429, - I_MINSD = 3450, - I_MINSS = 3443, - I_MONITOR = 1760, - I_MOV = 218, - I_MOVAPD = 2456, - I_MOVAPS = 2448, - I_MOVBE = 7924, - I_MOVD = 3917, - I_MOVDDUP = 2183, - I_MOVDQ2Q = 5202, - I_MOVDQA = 3943, - I_MOVDQU = 3951, - I_MOVHLPS = 2148, - I_MOVHPD = 2342, - I_MOVHPS = 2334, - I_MOVLHPS = 2325, - I_MOVLPD = 2165, - I_MOVLPS = 2157, - I_MOVMSKPD = 2812, - I_MOVMSKPS = 2802, - I_MOVNTDQ = 5529, - I_MOVNTDQA = 6577, - I_MOVNTI = 957, - I_MOVNTPD = 2553, - I_MOVNTPS = 2544, - I_MOVNTQ = 5521, - I_MOVNTSD = 2571, - I_MOVNTSS = 2562, - I_MOVQ = 3923, - I_MOVQ2DQ = 5193, - I_MOVS = 295, - I_MOVSD = 2107, - I_MOVSHDUP = 2350, - I_MOVSLDUP = 2173, - I_MOVSS = 2100, - I_MOVSX = 944, - I_MOVSXD = 8597, - I_MOVUPD = 2092, - I_MOVUPS = 2084, - I_MOVZX = 927, - I_MPSADBW = 8293, - I_MUL = 1630, - I_MULPD = 3167, - I_MULPS = 3160, - I_MULSD = 3181, - I_MULSS = 3174, - I_MWAIT = 1769, - I_NEG = 1625, - I_NOP = 581, - I_NOT = 1620, - I_OR = 27, - I_ORPD = 3050, - I_ORPS = 3044, - I_OUT = 451, - I_OUTS = 128, - I_PABSB = 6370, - I_PABSD = 6400, - I_PABSW = 6385, - I_PACKSSDW = 3846, - I_PACKSSWB = 3678, - I_PACKUSDW = 6598, - I_PACKUSWB = 3756, - I_PADDB = 5884, - I_PADDD = 5914, - I_PADDQ = 5161, - I_PADDSB = 5610, - I_PADDSW = 5627, - I_PADDUSB = 5300, - I_PADDUSW = 5319, - I_PADDW = 5899, - I_PALIGNR = 8084, - I_PAND = 5287, - I_PANDN = 5345, - I_PAUSE = 8605, - I_PAVGB = 5360, - I_PAVGUSB = 2075, - I_PAVGW = 5405, - I_PBLENDVB = 6281, - I_PBLENDW = 8064, - I_PCLMULQDQ = 8312, - I_PCMPEQB = 4040, - I_PCMPEQD = 4078, - I_PCMPEQQ = 6558, - I_PCMPEQW = 4059, - I_PCMPESTRI = 8391, - I_PCMPESTRM = 8368, - I_PCMPGTB = 3699, - I_PCMPGTD = 3737, - I_PCMPGTQ = 6769, - I_PCMPGTW = 3718, - I_PCMPISTRI = 8436, - I_PCMPISTRM = 8413, - I_PEXTRB = 8103, - I_PEXTRD = 8120, - I_PEXTRQ = 8128, - I_PEXTRW = 4991, - I_PF2ID = 1911, - I_PF2IW = 1904, - I_PFACC = 2025, - I_PFADD = 1974, - I_PFCMPEQ = 2032, - I_PFCMPGE = 1935, - I_PFCMPGT = 1981, - I_PFMAX = 1990, - I_PFMIN = 1944, - I_PFMUL = 2041, - I_PFNACC = 1918, - I_PFPNACC = 1926, - I_PFRCP = 1951, - I_PFRCPIT1 = 1997, - I_PFRCPIT2 = 2048, - I_PFRSQIT1 = 2007, - I_PFRSQRT = 1958, - I_PFSUB = 1967, - I_PFSUBR = 2017, - I_PHADDD = 6055, - I_PHADDSW = 6072, - I_PHADDW = 6038, - I_PHMINPOSUW = 6941, - I_PHSUBD = 6131, - I_PHSUBSW = 6148, - I_PHSUBW = 6114, - I_PI2FD = 1897, - I_PI2FW = 1890, - I_PINSRB = 8195, - I_PINSRD = 8233, - I_PINSRQ = 8241, - I_PINSRW = 4974, - I_PMADDUBSW = 6091, - I_PMADDWD = 5753, - I_PMAXSB = 6856, - I_PMAXSD = 6873, - I_PMAXSW = 5644, - I_PMAXUB = 5328, - I_PMAXUD = 6907, - I_PMAXUW = 6890, - I_PMINSB = 6788, - I_PMINSD = 6805, - I_PMINSW = 5582, - I_PMINUB = 5270, - I_PMINUD = 6839, - I_PMINUW = 6822, - I_PMOVMSKB = 5211, - I_PMOVSXBD = 6436, - I_PMOVSXBQ = 6457, - I_PMOVSXBW = 6415, - I_PMOVSXDQ = 6520, - I_PMOVSXWD = 6478, - I_PMOVSXWQ = 6499, - I_PMOVZXBD = 6664, - I_PMOVZXBQ = 6685, - I_PMOVZXBW = 6643, - I_PMOVZXDQ = 6748, - I_PMOVZXWD = 6706, - I_PMOVZXWQ = 6727, - I_PMULDQ = 6541, - I_PMULHRSW = 6218, - I_PMULHRW = 2058, - I_PMULHUW = 5420, - I_PMULHW = 5439, - I_PMULLD = 6924, - I_PMULLW = 5176, - I_PMULUDQ = 5734, - I_POP = 22, - I_POPA = 98, - I_POPCNT = 4290, - I_POPF = 277, - I_POR = 5599, - I_PREFETCH = 1869, - I_PREFETCHNTA = 2399, - I_PREFETCHT0 = 2412, - I_PREFETCHT1 = 2424, - I_PREFETCHT2 = 2436, - I_PREFETCHW = 1879, - I_PSADBW = 5772, - I_PSHUFB = 6021, - I_PSHUFD = 3985, - I_PSHUFHW = 3993, - I_PSHUFLW = 4002, - I_PSHUFW = 3977, - I_PSIGNB = 6167, - I_PSIGND = 6201, - I_PSIGNW = 6184, - I_PSLLD = 5704, - I_PSLLDQ = 8511, - I_PSLLQ = 5719, - I_PSLLW = 5689, - I_PSRAD = 5390, - I_PSRAW = 5375, - I_PSRLD = 5131, - I_PSRLDQ = 8494, - I_PSRLQ = 5146, - I_PSRLW = 5116, - I_PSUBB = 5824, - I_PSUBD = 5854, - I_PSUBQ = 5869, - I_PSUBSB = 5548, - I_PSUBSW = 5565, - I_PSUBUSB = 5232, - I_PSUBUSW = 5251, - I_PSUBW = 5839, - I_PSWAPD = 2067, - I_PTEST = 6311, - I_PUNPCKHBW = 3777, - I_PUNPCKHDQ = 3823, - I_PUNPCKHQDQ = 3892, - I_PUNPCKHWD = 3800, - I_PUNPCKLBW = 3609, - I_PUNPCKLDQ = 3655, - I_PUNPCKLQDQ = 3867, - I_PUNPCKLWD = 3632, - I_PUSH = 16, - I_PUSHA = 91, - I_PUSHF = 270, - I_PXOR = 5661, - I_RCL = 982, - I_RCPPS = 2950, - I_RCPSS = 2957, - I_RCR = 987, - I_RDMSR = 600, - I_RDPMC = 607, - I_RDTSC = 593, - I_RDTSCP = 1861, - I_RET = 325, - I_RETF = 354, - I_ROL = 972, - I_ROR = 977, - I_ROUNDPD = 7969, - I_ROUNDPS = 7950, - I_ROUNDSD = 8007, - I_ROUNDSS = 7988, - I_RSM = 882, - I_RSQRTPS = 2912, - I_RSQRTSS = 2921, - I_SAHF = 283, - I_SAL = 1002, - I_SALC = 394, - I_SAR = 1007, - I_SBB = 36, - I_SCAS = 319, - I_SETA = 807, - I_SETAE = 780, - I_SETB = 774, - I_SETBE = 800, - I_SETG = 859, - I_SETGE = 845, - I_SETL = 839, - I_SETLE = 852, - I_SETNO = 767, - I_SETNP = 832, - I_SETNS = 819, - I_SETNZ = 793, - I_SETO = 761, - I_SETP = 826, - I_SETS = 813, - I_SETZ = 787, - I_SFENCE = 4273, - I_SGDT = 1680, - I_SHL = 992, - I_SHLD = 876, - I_SHR = 997, - I_SHRD = 892, - I_SHUFPD = 5016, - I_SHUFPS = 5008, - I_SIDT = 1686, - I_SKINIT = 1836, - I_SLDT = 1646, - I_SMSW = 1704, - I_SQRTPD = 2852, - I_SQRTPS = 2844, - I_SQRTSD = 2868, - I_SQRTSS = 2860, - I_STC = 497, - I_STD = 517, - I_STGI = 1824, - I_STI = 507, - I_STMXCSR = 8547, - I_STOS = 307, - I_STR = 1652, - I_SUB = 51, - I_SUBPD = 3376, - I_SUBPS = 3369, - I_SUBSD = 3390, - I_SUBSS = 3383, - I_SWAPGS = 1853, - I_SYSCALL = 532, - I_SYSENTER = 614, - I_SYSEXIT = 624, - I_SYSRET = 547, - I_TEST = 206, - I_UCOMISD = 2739, - I_UCOMISS = 2730, - I_UD2 = 569, - I_UNPCKHPD = 2293, - I_UNPCKHPS = 2283, - I_UNPCKLPD = 2251, - I_UNPCKLPS = 2241, - I_VADDPD = 3136, - I_VADDPS = 3128, - I_VADDSD = 3152, - I_VADDSS = 3144, - I_VADDSUBPD = 5094, - I_VADDSUBPS = 5105, - I_VAESDEC = 7890, - I_VAESDECLAST = 7911, - I_VAESENC = 7848, - I_VAESENCLAST = 7869, - I_VAESIMC = 7831, - I_VAESKEYGENASSIST = 8476, - I_VANDNPD = 3035, - I_VANDNPS = 3026, - I_VANDPD = 3002, - I_VANDPS = 2994, - I_VBLENDPD = 8054, - I_VBLENDPS = 8035, - I_VBLENDVPD = 8346, - I_VBLENDVPS = 8335, - I_VBROADCASTF128 = 6354, - I_VBROADCASTSD = 6340, - I_VBROADCASTSS = 6326, - I_VCMPEQPD = 4713, - I_VCMPEQPS = 4626, - I_VCMPEQSD = 4887, - I_VCMPEQSS = 4800, - I_VCMPESTRI = 8402, - I_VCMPLEPD = 4733, - I_VCMPLEPS = 4646, - I_VCMPLESD = 4907, - I_VCMPLESS = 4820, - I_VCMPLTPD = 4723, - I_VCMPLTPS = 4636, - I_VCMPLTSD = 4897, - I_VCMPLTSS = 4810, - I_VCMPNEQPD = 4756, - I_VCMPNEQPS = 4669, - I_VCMPNEQSD = 4930, - I_VCMPNEQSS = 4843, - I_VCMPNLEPD = 4778, - I_VCMPNLEPS = 4691, - I_VCMPNLESD = 4952, - I_VCMPNLESS = 4865, - I_VCMPNLTPD = 4767, - I_VCMPNLTPS = 4680, - I_VCMPNLTSD = 4941, - I_VCMPNLTSS = 4854, - I_VCMPORDPD = 4789, - I_VCMPORDPS = 4702, - I_VCMPORDSD = 4963, - I_VCMPORDSS = 4876, - I_VCMPUNORDPD = 4743, - I_VCMPUNORDPS = 4656, - I_VCMPUNORDSD = 4917, - I_VCMPUNORDSS = 4830, - I_VCOMISD = 2793, - I_VCOMISS = 2784, - I_VCVTDQ2PD = 5499, - I_VCVTDQ2PS = 3335, - I_VCVTPD2DQ = 5510, - I_VCVTPD2PS = 3293, - I_VCVTPS2DQ = 3346, - I_VCVTPS2PD = 3282, - I_VCVTSD2SI = 2719, - I_VCVTSD2SS = 3271, - I_VCVTSI2SD = 2533, - I_VCVTSI2SS = 2522, - I_VCVTSS2SD = 3260, - I_VCVTSS2SI = 2708, - I_VCVTTPD2DQ = 5487, - I_VCVTTPS2DQ = 3357, - I_VCVTTSD2SI = 2656, - I_VCVTTSS2SI = 2644, - I_VDIVPD = 3525, - I_VDIVPS = 3517, - I_VDIVSD = 3541, - I_VDIVSS = 3533, - I_VDPPD = 8286, - I_VDPPS = 8273, - I_VERR = 1668, - I_VERW = 1674, - I_VEXTRACTF128 = 8181, - I_VEXTRACTPS = 8156, - I_VFMADD132PD = 7060, - I_VFMADD132PS = 7047, - I_VFMADD132SD = 7086, - I_VFMADD132SS = 7073, - I_VFMADD213PD = 7340, - I_VFMADD213PS = 7327, - I_VFMADD213SD = 7366, - I_VFMADD213SS = 7353, - I_VFMADD231PD = 7620, - I_VFMADD231PS = 7607, - I_VFMADD231SD = 7646, - I_VFMADD231SS = 7633, - I_VFMADDSUB132PD = 6999, - I_VFMADDSUB132PS = 6983, - I_VFMADDSUB213PD = 7279, - I_VFMADDSUB213PS = 7263, - I_VFMADDSUB231PD = 7559, - I_VFMADDSUB231PS = 7543, - I_VFMSUB132PD = 7112, - I_VFMSUB132PS = 7099, - I_VFMSUB132SD = 7138, - I_VFMSUB132SS = 7125, - I_VFMSUB213PD = 7392, - I_VFMSUB213PS = 7379, - I_VFMSUB213SD = 7418, - I_VFMSUB213SS = 7405, - I_VFMSUB231PD = 7672, - I_VFMSUB231PS = 7659, - I_VFMSUB231SD = 7698, - I_VFMSUB231SS = 7685, - I_VFMSUBADD132PD = 7031, - I_VFMSUBADD132PS = 7015, - I_VFMSUBADD213PD = 7311, - I_VFMSUBADD213PS = 7295, - I_VFMSUBADD231PD = 7591, - I_VFMSUBADD231PS = 7575, - I_VFNMADD132PD = 7165, - I_VFNMADD132PS = 7151, - I_VFNMADD132SD = 7193, - I_VFNMADD132SS = 7179, - I_VFNMADD213PD = 7445, - I_VFNMADD213PS = 7431, - I_VFNMADD213SD = 7473, - I_VFNMADD213SS = 7459, - I_VFNMADD231PD = 7725, - I_VFNMADD231PS = 7711, - I_VFNMADD231SD = 7753, - I_VFNMADD231SS = 7739, - I_VFNMSUB132PD = 7221, - I_VFNMSUB132PS = 7207, - I_VFNMSUB132SD = 7249, - I_VFNMSUB132SS = 7235, - I_VFNMSUB213PD = 7501, - I_VFNMSUB213PS = 7487, - I_VFNMSUB213SD = 7529, - I_VFNMSUB213SS = 7515, - I_VFNMSUB231PD = 7781, - I_VFNMSUB231PS = 7767, - I_VFNMSUB231SD = 7809, - I_VFNMSUB231SS = 7795, - I_VHADDPD = 4174, - I_VHADDPS = 4183, - I_VHSUBPD = 4208, - I_VHSUBPS = 4217, - I_VINSERTF128 = 8168, - I_VINSERTPS = 8222, - I_VLDDQU = 5681, - I_VLDMXCSR = 8537, - I_VMASKMOVDQU = 5811, - I_VMASKMOVPD = 6631, - I_VMASKMOVPS = 6619, - I_VMAXPD = 3585, - I_VMAXPS = 3577, - I_VMAXSD = 3601, - I_VMAXSS = 3593, - I_VMCALL = 1724, - I_VMCLEAR = 8575, - I_VMINPD = 3465, - I_VMINPS = 3457, - I_VMINSD = 3481, - I_VMINSS = 3473, - I_VMLAUNCH = 1732, - I_VMLOAD = 1808, - I_VMMCALL = 1799, - I_VMOVAPD = 2473, - I_VMOVAPS = 2464, - I_VMOVD = 3929, - I_VMOVDDUP = 2231, - I_VMOVDQA = 3959, - I_VMOVDQU = 3968, - I_VMOVHLPS = 2192, - I_VMOVHPD = 2379, - I_VMOVHPS = 2370, - I_VMOVLHPS = 2360, - I_VMOVLPD = 2211, - I_VMOVLPS = 2202, - I_VMOVMSKPD = 2833, - I_VMOVMSKPS = 2822, - I_VMOVNTDQ = 5538, - I_VMOVNTDQA = 6587, - I_VMOVNTPD = 2590, - I_VMOVNTPS = 2580, - I_VMOVQ = 3936, - I_VMOVSD = 2122, - I_VMOVSHDUP = 2388, - I_VMOVSLDUP = 2220, - I_VMOVSS = 2114, - I_VMOVUPD = 2139, - I_VMOVUPS = 2130, - I_VMPSADBW = 8302, - I_VMPTRLD = 8566, - I_VMPTRST = 5065, - I_VMREAD = 4125, - I_VMRESUME = 1742, - I_VMRUN = 1792, - I_VMSAVE = 1816, - I_VMULPD = 3196, - I_VMULPS = 3188, - I_VMULSD = 3212, - I_VMULSS = 3204, - I_VMWRITE = 4149, - I_VMXOFF = 1752, - I_VMXON = 8584, - I_VORPD = 3063, - I_VORPS = 3056, - I_VPABSB = 6377, - I_VPABSD = 6407, - I_VPABSW = 6392, - I_VPACKSSDW = 3856, - I_VPACKSSWB = 3688, - I_VPACKUSDW = 6608, - I_VPACKUSWB = 3766, - I_VPADDB = 5891, - I_VPADDD = 5921, - I_VPADDQ = 5168, - I_VPADDSB = 5618, - I_VPADDSW = 5635, - I_VPADDUSW = 5309, - I_VPADDW = 5906, - I_VPALIGNR = 8093, - I_VPAND = 5293, - I_VPANDN = 5352, - I_VPAVGB = 5367, - I_VPAVGW = 5412, - I_VPBLENDVB = 8357, - I_VPBLENDVW = 8073, - I_VPCLMULQDQ = 8323, - I_VPCMPEQB = 4049, - I_VPCMPEQD = 4087, - I_VPCMPEQQ = 6567, - I_VPCMPEQW = 4068, - I_VPCMPESTRM = 8379, - I_VPCMPGTB = 3708, - I_VPCMPGTD = 3746, - I_VPCMPGTQ = 6778, - I_VPCMPGTW = 3727, - I_VPCMPISTRI = 8447, - I_VPCMPISTRM = 8424, - I_VPERM2F128 = 7938, - I_VPERMILPD = 6250, - I_VPERMILPS = 6239, - I_VPEXTRB = 8111, - I_VPEXTRD = 8136, - I_VPEXTRW = 4999, - I_VPHADDD = 6063, - I_VPHADDSW = 6081, - I_VPHADDW = 6046, - I_VPHMINPOSUW = 6953, - I_VPHSUBD = 6139, - I_VPHSUBSW = 6157, - I_VPHSUBW = 6122, - I_VPINSRB = 8203, - I_VPINSRD = 8249, - I_VPINSRQ = 8258, - I_VPINSRW = 4982, - I_VPMADDUBSW = 6102, - I_VPMADDWD = 5762, - I_VPMAXSB = 6864, - I_VPMAXSD = 6881, - I_VPMAXSW = 5652, - I_VPMAXUB = 5336, - I_VPMAXUD = 6915, - I_VPMAXUW = 6898, - I_VPMINSB = 6796, - I_VPMINSD = 6813, - I_VPMINSW = 5590, - I_VPMINUB = 5278, - I_VPMINUD = 6847, - I_VPMINUW = 6830, - I_VPMOVMSKB = 5221, - I_VPMOVSXBD = 6446, - I_VPMOVSXBQ = 6467, - I_VPMOVSXBW = 6425, - I_VPMOVSXDQ = 6530, - I_VPMOVSXWD = 6488, - I_VPMOVSXWQ = 6509, - I_VPMOVZXBD = 6674, - I_VPMOVZXBQ = 6695, - I_VPMOVZXBW = 6653, - I_VPMOVZXDQ = 6758, - I_VPMOVZXWD = 6716, - I_VPMOVZXWQ = 6737, - I_VPMULDQ = 6549, - I_VPMULHRSW = 6228, - I_VPMULHUW = 5429, - I_VPMULHW = 5447, - I_VPMULLD = 6932, - I_VPMULLW = 5184, - I_VPMULUDQ = 5743, - I_VPOR = 5604, - I_VPSADBW = 5780, - I_VPSHUFB = 6029, - I_VPSHUFD = 4011, - I_VPSHUFHW = 4020, - I_VPSHUFLW = 4030, - I_VPSIGNB = 6175, - I_VPSIGND = 6209, - I_VPSIGNW = 6192, - I_VPSLLD = 5711, - I_VPSLLDQ = 8519, - I_VPSLLQ = 5726, - I_VPSLLW = 5696, - I_VPSRAD = 5397, - I_VPSRAW = 5382, - I_VPSRLD = 5138, - I_VPSRLDQ = 8502, - I_VPSRLQ = 5153, - I_VPSRLW = 5123, - I_VPSUBB = 5831, - I_VPSUBD = 5861, - I_VPSUBQ = 5876, - I_VPSUBSB = 5556, - I_VPSUBSW = 5573, - I_VPSUBUSB = 5241, - I_VPSUBUSW = 5260, - I_VPSUBW = 5846, - I_VPTEST = 6318, - I_VPTESTPD = 6271, - I_VPTESTPS = 6261, - I_VPUNPCKHBW = 3788, - I_VPUNPCKHDQ = 3834, - I_VPUNPCKHQDQ = 3904, - I_VPUNPCKHWD = 3811, - I_VPUNPCKLBW = 3620, - I_VPUNPCKLDQ = 3666, - I_VPUNPCKLQDQ = 3879, - I_VPUNPCKLWD = 3643, - I_VPXOR = 5667, - I_VRCPPS = 2972, - I_VRCPSS = 2964, - I_VROUNDPD = 7978, - I_VROUNDPS = 7959, - I_VROUNDSD = 8016, - I_VROUNDSS = 7997, - I_VRSQRTPS = 2940, - I_VRSQRTSS = 2930, - I_VSHUFPD = 5033, - I_VSHUFPS = 5024, - I_VSQRTPD = 2903, - I_VSQRTPS = 2894, - I_VSQRTSD = 2885, - I_VSQRTSS = 2876, - I_VSTMXCSR = 8556, - I_VSUBPD = 3405, - I_VSUBPS = 3397, - I_VSUBSD = 3421, - I_VSUBSS = 3413, - I_VUCOMISD = 2758, - I_VUCOMISS = 2748, - I_VUNPCKHPD = 2314, - I_VUNPCKHPS = 2303, - I_VUNPCKLPD = 2272, - I_VUNPCKLPS = 2261, - I_VXORPD = 3092, - I_VXORPS = 3084, - I_VZEROALL = 4115, - I_VZEROUPPER = 4103, - I_WAIT = 8591, - I_WBINVD = 561, - I_WRMSR = 586, - I_XADD = 951, - I_XAVE = 4243, - I_XCHG = 212, - I_XGETBV = 1776, - I_XLAT = 400, - I_XOR = 61, - I_XORPD = 3077, - I_XORPS = 3070, - I_XRSTOR = 4257, - I_XSETBV = 1784 -} _InstructionType; - -typedef enum { - R_RAX, - R_RCX, - R_RDX, - R_RBX, - R_RSP, - R_RBP, - R_RSI, - R_RDI, - R_R8, - R_R9, - R_R10, - R_R11, - R_R12, - R_R13, - R_R14, - R_R15, - R_EAX, - R_ECX, - R_EDX, - R_EBX, - R_ESP, - R_EBP, - R_ESI, - R_EDI, - R_R8D, - R_R9D, - R_R10D, - R_R11D, - R_R12D, - R_R13D, - R_R14D, - R_R15D, - R_AX, - R_CX, - R_DX, - R_BX, - R_SP, - R_BP, - R_SI, - R_DI, - R_R8W, - R_R9W, - R_R10W, - R_R11W, - R_R12W, - R_R13W, - R_R14W, - R_R15W, - R_AL, - R_CL, - R_DL, - R_BL, - R_AH, - R_CH, - R_DH, - R_BH, - R_R8B, - R_R9B, - R_R10B, - R_R11B, - R_R12B, - R_R13B, - R_R14B, - R_R15B, - R_SPL, - R_BPL, - R_SIL, - R_DIL, - R_ES, - R_CS, - R_SS, - R_DS, - R_FS, - R_GS, - R_RIP, - R_ST0, - R_ST1, - R_ST2, - R_ST3, - R_ST4, - R_ST5, - R_ST6, - R_ST7, - R_MM0, - R_MM1, - R_MM2, - R_MM3, - R_MM4, - R_MM5, - R_MM6, - R_MM7, - R_XMM0, - R_XMM1, - R_XMM2, - R_XMM3, - R_XMM4, - R_XMM5, - R_XMM6, - R_XMM7, - R_XMM8, - R_XMM9, - R_XMM10, - R_XMM11, - R_XMM12, - R_XMM13, - R_XMM14, - R_XMM15, - R_YMM0, - R_YMM1, - R_YMM2, - R_YMM3, - R_YMM4, - R_YMM5, - R_YMM6, - R_YMM7, - R_YMM8, - R_YMM9, - R_YMM10, - R_YMM11, - R_YMM12, - R_YMM13, - R_YMM14, - R_YMM15, - R_CR0, - R_UNUSED0, - R_CR2, - R_CR3, - R_CR4, - R_UNUSED1, - R_UNUSED2, - R_UNUSED3, - R_CR8, - R_DR0, - R_DR1, - R_DR2, - R_DR3, - R_UNUSED4, - R_UNUSED5, - R_DR6, - R_DR7 -} _RegisterType; - -#endif /* MNEMONICS_H */ diff --git a/target/i386/latx/diStorm/operands.c b/target/i386/latx/diStorm/operands.c deleted file mode 100644 index 38e0aa2cd73..00000000000 --- a/target/i386/latx/diStorm/operands.c +++ /dev/null @@ -1,1596 +0,0 @@ -/* -operands.c - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#include "config.h" - -#include "operands.h" -#include "x86defs.h" -#include "insts.h" -#include "mnemonics.h" - -/* Maps a register to its register-class mask. */ -uint16_t _REGISTERTORCLASS[] = /* Based on _RegisterType enumeration! */ - {RM_AX, RM_CX, RM_DX, RM_BX, RM_SP, RM_BP, RM_SI, RM_DI, 0, - 0, 0, 0, 0, 0, 0, 0, RM_AX, RM_CX, - RM_DX, RM_BX, RM_SP, RM_BP, RM_SI, RM_DI, 0, 0, 0, - 0, 0, 0, 0, 0, RM_AX, RM_CX, RM_DX, RM_BX, - RM_SP, RM_BP, RM_SI, RM_DI, 0, 0, 0, 0, 0, - 0, 0, 0, RM_AX, RM_CX, RM_DX, RM_BX, RM_AX, RM_CX, - RM_DX, RM_BX, 0, 0, 0, 0, 0, 0, 0, - 0, RM_SP, RM_BP, RM_SI, RM_DI, 0, 0, 0, 0, - 0, 0, 0, RM_FPU, RM_FPU, RM_FPU, RM_FPU, RM_FPU, RM_FPU, - RM_FPU, RM_FPU, RM_MMX, RM_MMX, RM_MMX, RM_MMX, RM_MMX, RM_MMX, RM_MMX, - RM_MMX, RM_SSE, RM_SSE, RM_SSE, RM_SSE, RM_SSE, RM_SSE, RM_SSE, RM_SSE, - RM_SSE, RM_SSE, RM_SSE, RM_SSE, RM_SSE, RM_SSE, RM_SSE, RM_SSE, RM_AVX, - RM_AVX, RM_AVX, RM_AVX, RM_AVX, RM_AVX, RM_AVX, RM_AVX, RM_AVX, RM_AVX, - RM_AVX, RM_AVX, RM_AVX, RM_AVX, RM_AVX, RM_AVX, RM_CR, 0, RM_CR, - RM_CR, RM_CR, 0, 0, 0, RM_CR, RM_DR, RM_DR, RM_DR, - RM_DR, 0, 0, RM_DR, RM_DR}; - -typedef enum { - OPERAND_SIZE_NONE = 0, - OPERAND_SIZE8, - OPERAND_SIZE16, - OPERAND_SIZE32, - OPERAND_SIZE64, - OPERAND_SIZE80, - OPERAND_SIZE128, - OPERAND_SIZE256 -} _OperandSizeType; -static uint16_t _OPSIZETOINT[] = {0, 8, 16, 32, 64, 80, 128, 256}; - -/* A helper function to fix the 8 bits register if REX is used (to support SIL, - * DIL, etc). */ -static unsigned int _FASTCALL_ operands_fix_8bit_rex_base(unsigned int reg) -{ - if ((reg >= 4) && (reg < 8)) - return reg + REGS8_REX_BASE - 4; - return reg + REGS8_BASE; -} - -/* A helper function to set operand's type and size. */ -static void _FASTCALL_ operands_set_ts(_Operand* op, _OperandType type, - uint16_t size) -{ - op->type = type; - op->size = size; -} - -/* A helper function to set operand's type, size and index. */ -static void _FASTCALL_ operands_set_tsi(_Operand* op, _OperandType type, - uint16_t size, unsigned int index) -{ - op->type = type; - op->index = (uint8_t)index; - op->size = size; -} - -/* A helper function to read an unsigned integer from the stream safely. */ -static int _FASTCALL_ read_stream_safe_uint(_CodeInfo* ci, void* result, - unsigned int size) -{ - ci->codeLen -= size; - if (ci->codeLen < 0) - return FALSE; - switch (size) { - case 1: - *(uint8_t*)result = *(uint8_t*)ci->code; - break; - case 2: - *(uint16_t*)result = RUSHORT(ci->code); - break; - case 4: - *(uint32_t*)result = RULONG(ci->code); - break; - case 8: - *(uint64_t*)result = RULLONG(ci->code); - break; - } - ci->code += size; - return TRUE; -} - -/* A helper function to read a signed integer from the stream safely. */ -static int _FASTCALL_ read_stream_safe_sint(_CodeInfo* ci, int64_t* result, - unsigned int size) -{ - ci->codeLen -= size; - if (ci->codeLen < 0) - return FALSE; - switch (size) { - case 1: - *result = *(int8_t*)ci->code; - break; - case 2: - *result = RSHORT(ci->code); - break; - case 4: - *result = RLONG(ci->code); - break; - case 8: - *result = RLLONG(ci->code); - break; - } - ci->code += size; - return TRUE; -} - -/* - * SIB decoding is the most confusing part when decoding IA-32 instructions. - * This explanation should clear up some stuff. - * - * ! When base == 5, use EBP as the base register ! - * if (rm == 4) { - * if mod == 01, decode SIB byte and ALSO read a 8 bits displacement. - * if mod == 10, decode SIB byte and ALSO read a 32 bits displacement. - * if mod == 11 <-- EXCEPTION, this is a general-purpose register and mustn't - *lead to SIB decoding! ; So far so good, now the confusing part comes in with - *mod == 0 and base=5, but no worry. if (mod == 00) { decode SIB byte WITHOUT - *any displacement. EXCEPTION!!! when base == 5, read a 32 bits displacement, - *but this time DO NOT use (EBP) BASE at all! - * } - * - * NOTE: base could specify None (no base register) if base==5 and mod==0, but - *then you also need DISP32. - * } - */ -static void operands_extract_sib(_DInst* di, _OperandNumberType opNum, - _PrefixState* ps, _DecodeType effAdrSz, - unsigned int sib, unsigned int mod) -{ - unsigned int scale = 0, index = 0, base = 0; - unsigned int vrex = ps->vrex; - uint8_t* pIndex = NULL; - - _Operand* op = &di->ops[opNum]; - - /* - * SIB bits: - * |7---6-5----3-2---0| - * |SCALE| INDEX| BASE| - * |------------------| - */ - scale = (sib >> 6) & 3; - index = (sib >> 3) & 7; - base = sib & 7; - - /* - * The following fields: base/index/scale/disp8/32 are ALL optional by - * specific rules! The idea here is to keep the indirection as a - * simple-memory type. Because the base is optional, and we might be left - * with only one index. So even if there's a base but no index, or vice - * versa, we end up with one index register. - */ - - /* In 64 bits the REX prefix might affect the index of the SIB byte. */ - if (vrex & PREFIX_EX_X) { - ps->usedPrefixes |= INST_PRE_REX; - index += EX_GPR_BASE; - } - - if (index == 4) { /* No index is used. Use SMEM. */ - op->type = O_SMEM; - pIndex = &op->index; - } else { - op->type = O_MEM; - pIndex = &di->base; - /* No base, unless it is updated below. E.G: [EAX*4] has no base reg. */ - } - - if (base != 5) { - if (vrex & PREFIX_EX_B) - ps->usedPrefixes |= INST_PRE_REX; - *pIndex = effAdrSz == Decode64Bits ? REGS64_BASE : REGS32_BASE; - *pIndex += (uint8_t)(base + ((vrex & PREFIX_EX_B) ? EX_GPR_BASE : 0)); - } else if (mod != 0) { - /* - * if base == 5 then you have to decode according to MOD. - * mod(00) - disp32. - * mod(01) - disp8 + rBP - * mod(10) - disp32 + rBP - * mod(11) - not possible, it's a general-purpose register. - */ - - if (vrex & PREFIX_EX_B) - ps->usedPrefixes |= INST_PRE_REX; - if (effAdrSz == Decode64Bits) - *pIndex = - REGS64_BASE + 5 + ((vrex & PREFIX_EX_B) ? EX_GPR_BASE : 0); - else - *pIndex = - REGS32_BASE + 5 + ((vrex & PREFIX_EX_B) ? EX_GPR_BASE : 0); - } else if (index == 4) { - /* 32bits displacement only. */ - op->type = O_DISP; - return; - } - - if (index != - 4) { /* In 64 bits decoding mode, if index == R12, it's valid! */ - if (effAdrSz == Decode64Bits) - op->index = (uint8_t)(REGS64_BASE + index); - else - op->index = (uint8_t)(REGS32_BASE + index); - di->scale = scale != 0 ? (1 << scale) : 0; - } -} - -/* - * This seems to be the hardest part in decoding the operands. - * If you take a look carefully at Table 2-2. 32-Bit Addressing Forms with the - ModR/M Byte, - * you will understand it's easy to decode the operands. - - * First we check the DT, so we can decide according to which Table in the - documentation we are supposed to decode. - * Then we follow the specific table whether it's 16 bits or 32/64 bits. - - * Don't forget that Operand Size AND Address Size prefixes may change the - decoding! - - * Some instructions force the use of RM16 or other specific types, so take it - into account. - */ -static int operands_extract_modrm(_CodeInfo* ci, _DInst* di, _OpType type, - _OperandNumberType opNum, _PrefixState* ps, - _DecodeType effOpSz, _DecodeType effAdrSz, - int* lockableInstruction, unsigned int mod, - unsigned int rm, _iflags instFlags) -{ - unsigned int vrex = ps->vrex, sib = 0, base = 0; - _Operand* op = &di->ops[opNum]; - uint16_t size = 0; - - if (mod == 3) { - /* - * General-purpose register is handled the same way in 16/32/64 bits - * decoding modes. NOTE!! that we have to override the size of the - * register, since it was set earlier as Memory and not Register! - */ - op->type = O_REG; - /* Start with original size which was set earlier, some registers have - * same size of memory and depend on it. */ - size = op->size; - switch (type) { - case OT_RFULL_M16: - case OT_RM_FULL: - switch (effOpSz) { - case Decode16Bits: - ps->usedPrefixes |= INST_PRE_OP_SIZE; - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - rm += EX_GPR_BASE; - } - size = 16; - rm += REGS16_BASE; - break; - case Decode32Bits: - ps->usedPrefixes |= INST_PRE_OP_SIZE; - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - rm += EX_GPR_BASE; - } - size = 32; - rm += REGS32_BASE; - break; - case Decode64Bits: - /* A fix for SMSW RAX which use the REX prefix. */ - if (type == OT_RFULL_M16) - ps->usedPrefixes |= INST_PRE_REX; - /* CALL NEAR/PUSH/POP defaults to 64 bits. --> - * INST_64BITS, REX isn't required, thus ignored - * anyways. */ - if (instFlags & INST_PRE_REX) - ps->usedPrefixes |= INST_PRE_REX; - /* Include REX is used for REX.B. */ - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - rm += EX_GPR_BASE; - } - size = 64; - rm += REGS64_BASE; - break; - } - break; - case OT_R32_64_M8: - /* FALL THROUGH, decode 32 or 64 bits register. */ - case OT_R32_64_M16: - /* FALL THROUGH, decode 32 or 64 bits register. */ - case OT_RM32_64: /* Take care specifically in MOVNTI/MOVD/CVT's - instructions, making it _REG64 with REX or if - they are promoted. */ - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - rm += EX_GPR_BASE; - } - /* Is it a promoted instruction? (only INST_64BITS is set and - * REX isn't required.) */ - if ((ci->dt == Decode64Bits) && - ((instFlags & (INST_64BITS | INST_PRE_REX)) == INST_64BITS)) { - size = 64; - rm += REGS64_BASE; - break; - } - /* Give a chance to REX.W. Because if it was a promoted - * instruction we don't care about REX.W anyways. */ - if (vrex & PREFIX_EX_W) { - ps->usedPrefixes |= INST_PRE_REX; - size = 64; - rm += REGS64_BASE; - } else { - size = 32; - rm += REGS32_BASE; - } - break; - case OT_RM16_32: /* Used only with MOVZXD instruction to support 16 - bits operand. */ - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - rm += EX_GPR_BASE; - } - /* Is it 16 bits operand size? */ - if (ps->decodedPrefixes & INST_PRE_OP_SIZE) { - ps->usedPrefixes |= INST_PRE_OP_SIZE; - size = 16; - rm += REGS16_BASE; - } else { - size = 32; - rm += REGS32_BASE; - } - break; - case OT_RM16: - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - rm += EX_GPR_BASE; - } - rm += REGS16_BASE; - break; - case OT_RM8: - if (ps->prefixExtType == PET_REX) { - ps->usedPrefixes |= INST_PRE_REX; - rm = operands_fix_8bit_rex_base( - rm + ((vrex & PREFIX_EX_B) ? EX_GPR_BASE : 0)); - } else - rm += REGS8_BASE; - break; - case OT_MM32: - case OT_MM64: - /* MMX doesn't support extended registers. */ - size = 64; - rm += MMXREGS_BASE; - break; - - case OT_XMM16: - case OT_XMM32: - case OT_XMM64: - case OT_XMM128: - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - rm += EX_GPR_BASE; - } - size = 128; - rm += SSEREGS_BASE; - break; - - case OT_RM32: - case OT_R32_M8: - case OT_R32_M16: - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - rm += EX_GPR_BASE; - } - size = 32; - rm += REGS32_BASE; - break; - - case OT_YMM256: - if (vrex & PREFIX_EX_B) - rm += EX_GPR_BASE; - rm += AVXREGS_BASE; - break; - case OT_YXMM64_256: - case OT_YXMM128_256: - if (vrex & PREFIX_EX_B) - rm += EX_GPR_BASE; - if (vrex & PREFIX_EX_L) { - size = 256; - rm += AVXREGS_BASE; - } else { - size = 128; - rm += SSEREGS_BASE; - } - break; - case OT_WXMM32_64: - case OT_LXMM64_128: - if (vrex & PREFIX_EX_B) - rm += EX_GPR_BASE; - size = 128; - rm += SSEREGS_BASE; - break; - - case OT_WRM32_64: - case OT_REG32_64_M8: - case OT_REG32_64_M16: - if (vrex & PREFIX_EX_B) - rm += EX_GPR_BASE; - if (vrex & PREFIX_EX_W) { - size = 64; - rm += REGS64_BASE; - } else { - size = 32; - rm += REGS32_BASE; - } - break; - - default: - return FALSE; - } - op->size = size; - op->index = (uint8_t)rm; - return TRUE; - } - - /* Memory indirection decoding ahead:) */ - - ps->usedPrefixes |= INST_PRE_ADDR_SIZE; - if (lockableInstruction && (ps->decodedPrefixes & INST_PRE_LOCK)) - *lockableInstruction = TRUE; - - if (effAdrSz == Decode16Bits) { - /* Decoding according to Table 2-1. (16 bits) */ - if ((mod == 0) && (rm == 6)) { - /* 6 is a special case - only 16 bits displacement. */ - op->type = O_DISP; - di->dispSize = 16; - if (!read_stream_safe_sint(ci, (int64_t*)&di->disp, - sizeof(int16_t))) - return FALSE; - } else { - /* - * Create the O_MEM for 16 bits indirection that requires 2 - * registers, E.G: [BS+SI]. or create O_SMEM for a single register - * indirection, E.G: [BP]. - */ - static uint8_t MODS[] = {R_BX, R_BX, R_BP, R_BP, - R_SI, R_DI, R_BP, R_BX}; - static uint8_t MODS2[] = {R_SI, R_DI, R_SI, R_DI}; - if (rm < 4) { - op->type = O_MEM; - di->base = MODS[rm]; - op->index = MODS2[rm]; - } else { - op->type = O_SMEM; - op->index = MODS[rm]; - } - - if (mod == 1) { /* 8 bits displacement + indirection */ - di->dispSize = 8; - if (!read_stream_safe_sint(ci, (int64_t*)&di->disp, - sizeof(int8_t))) - return FALSE; - } else if (mod == 2) { /* 16 bits displacement + indirection */ - di->dispSize = 16; - if (!read_stream_safe_sint(ci, (int64_t*)&di->disp, - sizeof(int16_t))) - return FALSE; - } - } - - if ((rm == 2) || (rm == 3) || ((rm == 6) && (mod != 0))) { - /* BP's default segment is SS, so ignore it. */ - prefixes_use_segment(INST_PRE_SS, ps, ci->dt, di); - } else { - /* Ignore default DS segment. */ - prefixes_use_segment(INST_PRE_DS, ps, ci->dt, di); - } - } else { /* Decode32Bits or Decode64Bits! */ - /* Remember that from a 32/64 bits ModR/M byte a SIB byte could follow! - */ - if ((mod == 0) && (rm == 5)) { - /* 5 is a special case - only 32 bits displacement, or RIP relative. - */ - di->dispSize = 32; - if (!read_stream_safe_sint(ci, (int64_t*)&di->disp, - sizeof(int32_t))) - return FALSE; - - if (ci->dt == Decode64Bits) { - /* In 64 bits decoding mode depsite of the address size, a - * RIP-relative address it is. */ - op->type = O_SMEM; - op->index = R_RIP; - di->flags |= FLAG_RIP_RELATIVE; - } else { - /* Absolute address: */ - op->type = O_DISP; - } - } else { - if (rm == 4) { - /* 4 is a special case - SIB byte + disp8/32 follows! */ - /* Read SIB byte. */ - if (!read_stream_safe_uint(ci, &sib, sizeof(int8_t))) - return FALSE; - operands_extract_sib(di, opNum, ps, effAdrSz, sib, mod); - } else { - op->type = O_SMEM; - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - rm += EX_GPR_BASE; - } - - if (effAdrSz == Decode64Bits) - op->index = (uint8_t)(REGS64_BASE + rm); - else - op->index = (uint8_t)(REGS32_BASE + rm); - } - - if (mod == 1) { - di->dispSize = 8; - if (!read_stream_safe_sint(ci, (int64_t*)&di->disp, - sizeof(int8_t))) - return FALSE; - } else if ((mod == 2) || - ((sib & 7) == - 5)) { /* If there is no BASE, read DISP32! */ - di->dispSize = 32; - if (!read_stream_safe_sint(ci, (int64_t*)&di->disp, - sizeof(int32_t))) - return FALSE; - } - } - - /* Get the base register. */ - base = op->index; - if (di->base != R_NONE) - base = di->base; - else if (di->scale >= 2) - base = 0; /* If it's only an index but got scale, it's still DS. */ - /* Default for EBP/ESP is SS segment. 64 bits mode ignores DS anyway. */ - if ((base == R_EBP) || (base == R_ESP)) - prefixes_use_segment(INST_PRE_SS, ps, ci->dt, di); - else - prefixes_use_segment(INST_PRE_DS, ps, ci->dt, di); - } - - return TRUE; -} - -/* - * This function is reponsible to textually format a required operand according - to its type. - * It is vital to understand that there are other operands than what the ModR/M - byte specifies. - - * Only by decoding the operands of an instruction which got a LOCK prefix, we - could tell whether it may use the LOCK prefix. - * According to Intel, LOCK prefix must precede some specific instructions AND - in their memory destination operand form (which means first operand). - * LOCK INC EAX, would generate an exception, but LOCK INC [EAX] is alright. - * Also LOCK ADD BX, [BP] would generate an exception. - - * Return code: - * TRUE - continue parsing the instruction and its operands, everything went - right 'till now. - * FALSE - not enough bytes, or invalid operands. - */ - -int operands_extract(_CodeInfo* ci, _DInst* di, _InstInfo* ii, _OpType type, - _OperandNumberType opNum, unsigned int modrm, - _PrefixState* ps, _DecodeType effOpSz, - _DecodeType effAdrSz, int* lockableInstruction) -{ - int ret = 0; - unsigned int mod = 0, reg = 0, rm = 0, vexV = ps->vexV; - unsigned int vrex = ps->vrex, typeHandled = TRUE; - _iflags instFlags = INST_INFO_FLAGS(ii); - _Operand* op = &di->ops[opNum]; - - /* Used to indicate the size of the MEMORY INDIRECTION only. */ - _OperandSizeType opSize = OPERAND_SIZE_NONE; - - /* - * ModRM bits: - * |7-6-5--------3-2-0| - * |MOD|REG/OPCODE|RM | - * |------------------| - */ - mod = (modrm >> 6) & - 3; /* Mode(register-indirection, disp8+reg+indirection, - disp16+reg+indirection, general-purpose register) */ - reg = (modrm >> 3) & 7; /* Register(could be part of the opcode itself or - general-purpose register) */ - rm = modrm & - 7; /* Specifies which general-purpose register or disp+reg to use. */ - - /* -- Memory Indirection Operands (that cannot be a general purpose - * register) -- */ - switch (type) { - case OT_MEM64_128: /* Used only by CMPXCHG8/16B. */ - /* Make a specific check when the type is OT_MEM64_128 since the - * lockable CMPXCHG8B uses this one... */ - if (lockableInstruction && (ps->decodedPrefixes & INST_PRE_LOCK)) - *lockableInstruction = TRUE; - if (effOpSz == Decode64Bits) { - ps->usedPrefixes |= INST_PRE_REX; - opSize = OPERAND_SIZE128; - } else - opSize = OPERAND_SIZE64; - break; - case OT_MEM32: - opSize = OPERAND_SIZE32; - break; - case OT_MEM32_64: - /* Used by MOVNTI. Default size is 32bits, 64bits with REX. */ - if (effOpSz == Decode64Bits) { - ps->usedPrefixes |= INST_PRE_REX; - opSize = OPERAND_SIZE64; - } else - opSize = OPERAND_SIZE32; - break; - case OT_MEM64: - opSize = OPERAND_SIZE64; - break; - case OT_MEM128: - opSize = OPERAND_SIZE128; - break; - case OT_MEM16_FULL: /* The size indicates about the second item of the - pair. */ - switch (effOpSz) { - case Decode16Bits: - ps->usedPrefixes |= INST_PRE_OP_SIZE; - opSize = OPERAND_SIZE16; - break; - case Decode32Bits: - ps->usedPrefixes |= INST_PRE_OP_SIZE; - opSize = OPERAND_SIZE32; - break; - case Decode64Bits: - /* Mark usage of REX only if it was required. */ - if ((instFlags & (INST_64BITS | INST_PRE_REX)) == - (INST_64BITS | INST_PRE_REX)) - ps->usedPrefixes |= INST_PRE_REX; - opSize = OPERAND_SIZE64; - break; - } - break; - case OT_MEM16_3264: /* The size indicates about the second item of the - pair. */ - if (ci->dt == Decode64Bits) - opSize = OPERAND_SIZE64; - else - opSize = OPERAND_SIZE32; - break; - case OT_MEM_OPT: - /* Since the MEM is optional, only when mod != 3, then return true - * as if the operand was alright. */ - if (mod == 0x3) - return TRUE; - break; - case OT_FPUM16: - opSize = OPERAND_SIZE16; - break; - case OT_FPUM32: - opSize = OPERAND_SIZE32; - break; - case OT_FPUM64: - opSize = OPERAND_SIZE64; - break; - case OT_FPUM80: - opSize = OPERAND_SIZE80; - break; - case OT_LMEM128_256: - if (vrex & PREFIX_EX_L) - opSize = OPERAND_SIZE256; - else - opSize = OPERAND_SIZE128; - break; - case OT_MEM: /* Size is unknown, but still handled. */ -#ifndef _DISTORM_NO_DEBUG /*prefetch.., fldenv..., are not handled*/ - if (ii->opcodeId == I_FLDCW || ii->opcodeId == I_FSTCW || - ii->opcodeId == I_FNSTCW || ii->opcodeId == I_FSTSW || - ii->opcodeId == I_FNSTSW) - opSize = OPERAND_SIZE16; - else if (ii->opcodeId == I_LDMXCSR || ii->opcodeId == I_STMXCSR) - opSize = OPERAND_SIZE32; - else if (ii->opcodeId == I_LDDQU) - opSize = OPERAND_SIZE128; - else if (ii->opcodeId == I_BOUND) - opSize = effOpSz + 3; -#endif - break; - default: - typeHandled = FALSE; - break; - } - if (typeHandled) { - /* All of the above types can't use a general-purpose register (a MOD of - * 3)!. */ - if (mod == 0x3) { - if (lockableInstruction) - *lockableInstruction = FALSE; - return FALSE; - } - op->size = _OPSIZETOINT[opSize]; - ret = operands_extract_modrm(ci, di, type, opNum, ps, effOpSz, effAdrSz, - lockableInstruction, mod, rm, instFlags); - if ((op->type == O_REG) || (op->type == O_SMEM) || - (op->type == O_MEM)) { - di->usedRegistersMask |= _REGISTERTORCLASS[op->index]; - } - return ret; - } - - /* -- Memory Indirection Operands (that can be a register) -- */ - typeHandled = TRUE; - switch (type) { - case OT_RM_FULL: - ps->usedPrefixes |= INST_PRE_OP_SIZE; - /* PUSH/JMP/CALL are automatically promoted to 64 bits! */ - if (effOpSz == Decode32Bits) { - opSize = OPERAND_SIZE32; - break; - } else if (effOpSz == Decode64Bits) { - /* Mark usage of REX only if it was required. */ - if ((instFlags & INST_64BITS) == 0) - ps->usedPrefixes |= INST_PRE_REX; - opSize = OPERAND_SIZE64; - break; - } - /* FALL THROUGH BECAUSE dt==Decoded16Bits @-<----*/ - case OT_RM16: - /* If we got here not from OT_RM16, then the prefix was used. */ - if (type != OT_RM16) - ps->usedPrefixes |= INST_PRE_OP_SIZE; - opSize = OPERAND_SIZE16; - break; - case OT_RM32_64: - /* The default size is 32, which can be 64 with a REX only. */ - if (effOpSz == Decode64Bits) { - opSize = OPERAND_SIZE64; - /* Mark REX prefix as used if non-promoted instruction. */ - if ((instFlags & (INST_64BITS | INST_PRE_REX)) == - (INST_64BITS | INST_PRE_REX)) { - ps->usedPrefixes |= INST_PRE_REX; - } - } else - opSize = OPERAND_SIZE32; - break; - case OT_RM16_32: - /* Ignore REX, it's either 32 or 16 bits RM. */ - if (ps->decodedPrefixes & INST_PRE_OP_SIZE) { - ps->usedPrefixes |= INST_PRE_OP_SIZE; - /* Assume: We are in 64bits when we have this operand used. */ - opSize = OPERAND_SIZE16; - } else - opSize = OPERAND_SIZE32; - break; - case OT_WXMM32_64: - case OT_WRM32_64: - if (vrex & PREFIX_EX_W) - opSize = OPERAND_SIZE64; - else - opSize = OPERAND_SIZE32; - break; - case OT_YXMM64_256: - if (vrex & PREFIX_EX_L) - opSize = OPERAND_SIZE256; - else - opSize = OPERAND_SIZE64; - break; - case OT_YXMM128_256: - if (vrex & PREFIX_EX_L) - opSize = OPERAND_SIZE256; - else - opSize = OPERAND_SIZE128; - break; - case OT_LXMM64_128: - if (vrex & PREFIX_EX_L) - opSize = OPERAND_SIZE128; - else - opSize = OPERAND_SIZE64; - break; - case OT_RFULL_M16: - ps->usedPrefixes |= INST_PRE_OP_SIZE; - opSize = OPERAND_SIZE16; - break; - - case OT_RM8: - case OT_R32_M8: - case OT_R32_64_M8: - case OT_REG32_64_M8: - opSize = OPERAND_SIZE8; - break; - - case OT_XMM16: - case OT_R32_M16: - case OT_R32_64_M16: - case OT_REG32_64_M16: - opSize = OPERAND_SIZE16; - break; - - case OT_RM32: - case OT_MM32: - case OT_XMM32: - opSize = OPERAND_SIZE32; - break; - - case OT_MM64: - case OT_XMM64: - opSize = OPERAND_SIZE64; - break; - - case OT_XMM128: - opSize = OPERAND_SIZE128; - break; - case OT_YMM256: - opSize = OPERAND_SIZE256; - break; - default: - typeHandled = FALSE; - break; - } - if (typeHandled) { - /* Fill size of memory dereference for operand. */ - op->size = _OPSIZETOINT[opSize]; - ret = operands_extract_modrm(ci, di, type, opNum, ps, effOpSz, effAdrSz, - lockableInstruction, mod, rm, instFlags); - if ((op->type == O_REG) || (op->type == O_SMEM) || - (op->type == O_MEM)) { - di->usedRegistersMask |= _REGISTERTORCLASS[op->index]; - } - return ret; - } - - /* Simple operand type (no ModRM byte). */ - switch (type) { - case OT_IMM8: - operands_set_ts(op, O_IMM, 8); - if (!read_stream_safe_uint(ci, &di->imm.byte, sizeof(int8_t))) - return FALSE; - break; - case OT_IMM_FULL: /* 16, 32 or 64, depends on prefixes. */ - if (effOpSz == Decode16Bits) { - ps->usedPrefixes |= INST_PRE_OP_SIZE; - /* FALL THROUGH */ - case OT_IMM16: /* Force 16 bits imm. */ - operands_set_ts(op, O_IMM, 16); - if (!read_stream_safe_uint(ci, &di->imm.word, sizeof(int16_t))) - return FALSE; - break; - /* - * Extension: MOV imm64, requires REX. - * Make sure it needs the REX. - * REX must be present because op size function takes it - * into consideration. - */ - } else if ((effOpSz == Decode64Bits) && - ((instFlags & (INST_64BITS | INST_PRE_REX)) == - (INST_64BITS | INST_PRE_REX))) { - ps->usedPrefixes |= INST_PRE_REX; - - operands_set_ts(op, O_IMM, 64); - if (!read_stream_safe_uint(ci, &di->imm.qword, sizeof(int64_t))) - return FALSE; - break; - } else - ps->usedPrefixes |= INST_PRE_OP_SIZE; - /* FALL THROUGH BECAUSE dt==Decoded32Bits @-<----*/ - case OT_IMM32: - op->type = O_IMM; - if (ci->dt == Decode64Bits) { - /* Imm32 is sign extended to 64 bits! */ - op->size = 64; - di->flags |= FLAG_IMM_SIGNED; - if (!read_stream_safe_sint(ci, &di->imm.sqword, sizeof(int32_t))) - return FALSE; - } else { - op->size = 32; - if (!read_stream_safe_uint(ci, &di->imm.dword, sizeof(int32_t))) - return FALSE; - } - break; - case OT_SEIMM8: /* Sign extended immediate. */ - /* - * PUSH SEIMM8 can be prefixed by operand size: - * Input stream: 66, 6a, 55 - * 64bits DT: push small 55 - * 32bits DT: push small 55 - * 16bits DT: push large 55 - * small/large indicates the size of the eSP pointer advancement. - * Check the instFlags (ii->flags) if it can be - * operand-size-prefixed and if the prefix exists. - */ - op->type = O_IMM; - if ((instFlags & INST_PRE_OP_SIZE) && - (ps->decodedPrefixes & INST_PRE_OP_SIZE)) { - ps->usedPrefixes |= INST_PRE_OP_SIZE; - switch (ci->dt) { - case Decode16Bits: - op->size = 32; - break; - case Decode32Bits: - case Decode64Bits: - op->size = 16; - break; - } - } else - op->size = 8; - di->flags |= FLAG_IMM_SIGNED; - if (!read_stream_safe_sint(ci, &di->imm.sqword, sizeof(int8_t))) - return FALSE; - break; - case OT_IMM16_1: - operands_set_ts(op, O_IMM1, 16); - if (!read_stream_safe_uint(ci, &di->imm.ex.i1, sizeof(int16_t))) - return FALSE; - break; - case OT_IMM8_1: - operands_set_ts(op, O_IMM1, 8); - if (!read_stream_safe_uint(ci, &di->imm.ex.i1, sizeof(int8_t))) - return FALSE; - break; - case OT_IMM8_2: - operands_set_ts(op, O_IMM2, 8); - if (!read_stream_safe_uint(ci, &di->imm.ex.i2, sizeof(int8_t))) - return FALSE; - break; - case OT_REG8: - operands_set_ts(op, O_REG, 8); - if (ps->prefixExtType) { - /* - * If REX prefix is valid then we will have to use low bytes. - * This is a PASSIVE behaviour changer of REX prefix, it affects - * operands even if its value is 0x40 ! - */ - ps->usedPrefixes |= INST_PRE_REX; - op->index = (uint8_t)operands_fix_8bit_rex_base( - reg + ((vrex & PREFIX_EX_R) ? EX_GPR_BASE : 0)); - } else - op->index = (uint8_t)(REGS8_BASE + reg); - break; - case OT_REG16: - operands_set_tsi(op, O_REG, 16, REGS16_BASE + reg); - break; - case OT_REG_FULL: - switch (effOpSz) { - case Decode16Bits: - ps->usedPrefixes |= INST_PRE_OP_SIZE; - if (vrex & PREFIX_EX_R) { - ps->usedPrefixes |= INST_PRE_REX; - reg += EX_GPR_BASE; - } - operands_set_tsi(op, O_REG, 16, REGS16_BASE + reg); - break; - case Decode32Bits: - if (vrex & PREFIX_EX_R) { - ps->usedPrefixes |= INST_PRE_REX; - reg += EX_GPR_BASE; - } else - ps->usedPrefixes |= INST_PRE_OP_SIZE; - operands_set_tsi(op, O_REG, 32, REGS32_BASE + reg); - break; - case Decode64Bits: /* rex must be presented. */ - ps->usedPrefixes |= INST_PRE_REX; - operands_set_tsi( - op, O_REG, 64, - REGS64_BASE + reg + ((vrex & PREFIX_EX_R) ? EX_GPR_BASE : 0)); - break; - } - break; - case OT_REG32: - if (vrex & PREFIX_EX_R) { - ps->usedPrefixes |= INST_PRE_REX; - reg += EX_GPR_BASE; - } - operands_set_tsi(op, O_REG, 32, REGS32_BASE + reg); - break; - case OT_REG32_64: /* Handle CVT's, MOVxX and MOVNTI instructions which - could be extended to 64 bits registers with REX. */ - if (vrex & PREFIX_EX_R) { - ps->usedPrefixes |= INST_PRE_REX; - reg += EX_GPR_BASE; - } - - /* Is it a promoted instruction? (only INST_64BITS is set and REX - * isn't required.) */ - if ((ci->dt == Decode64Bits) && - ((instFlags & (INST_64BITS | INST_PRE_REX)) == INST_64BITS)) { - operands_set_tsi(op, O_REG, 64, REGS64_BASE + reg); - break; - } - /* Give a chance to REX.W. Because if it was a promoted instruction - * we don't care about REX.W anyways. */ - if (vrex & PREFIX_EX_W) { - ps->usedPrefixes |= INST_PRE_REX; - operands_set_tsi(op, O_REG, 64, REGS64_BASE + reg); - } else - operands_set_tsi(op, O_REG, 32, REGS32_BASE + reg); - break; - case OT_FREG32_64_RM: /* Force decoding mode. Used for MOV CR(n)/DR(n) - which defaults to 64 bits operand size in 64 - bits. */ - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - rm += EX_GPR_BASE; - } - - if (ci->dt == Decode64Bits) - operands_set_tsi(op, O_REG, 64, REGS64_BASE + rm); - else - operands_set_tsi(op, O_REG, 32, REGS32_BASE + rm); - break; - case OT_MM: /* MMX register */ - operands_set_tsi(op, O_REG, 64, MMXREGS_BASE + reg); - break; - case OT_MM_RM: /* MMX register, this time from the RM field */ - operands_set_tsi(op, O_REG, 64, MMXREGS_BASE + rm); - break; - case OT_REGXMM0: /* Implicit XMM0 operand. */ - reg = 0; - vrex = 0; - /* FALL THROUGH */ - case OT_XMM: /* SSE register */ - if (vrex & PREFIX_EX_R) { - ps->usedPrefixes |= INST_PRE_REX; - reg += EX_GPR_BASE; - } - operands_set_tsi(op, O_REG, 128, SSEREGS_BASE + reg); - break; - case OT_XMM_RM: /* SSE register, this time from the RM field */ - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - rm += EX_GPR_BASE; - } - operands_set_tsi(op, O_REG, 128, SSEREGS_BASE + rm); - break; - case OT_CREG: - /* - * Don't parse if the reg exceeds the bounds of the array. - * Most of the CR's are not implemented, so if there's no matching - * string, the operand is invalid. - */ - if (vrex & PREFIX_EX_R) { - ps->usedPrefixes |= INST_PRE_REX; - reg += EX_GPR_BASE; - } else if ((ci->dt == Decode32Bits) && - (ps->decodedPrefixes & INST_PRE_LOCK)) { - /* - * NOTE: In 32 bits decoding mode, - * if the lock prefix is set before MOV CR(n) it will become the - * 4th bit of the REG field like REX.R in 64 bits. - */ - reg += EX_GPR_BASE; - ps->usedPrefixes |= INST_PRE_LOCK; - } - /* Ignore some registers which do not exist. */ - if ((reg >= CREGS_MAX) || (reg == 1) || ((reg >= 5) && (reg <= 7))) - return FALSE; - - op->type = O_REG; - if (ci->dt == Decode64Bits) - op->size = 64; - else - op->size = 32; - op->index = (uint8_t)(CREGS_BASE + reg); - break; - case OT_DREG: - /* - * In 64 bits there are 16 debug registers. - * but accessing any of dr8-15 which aren't implemented will cause - * an #ud. - */ - if ((reg == 4) || (reg == 5) || (vrex & PREFIX_EX_R)) - return FALSE; - - op->type = O_REG; - if (ci->dt == Decode64Bits) - op->size = 64; - else - op->size = 32; - op->index = (uint8_t)(DREGS_BASE + reg); - break; - case OT_SREG: /* Works with REG16 only! */ - /* If lockableInstruction pointer is non-null we know it's the first - * operand. */ - if (lockableInstruction && (reg == 1)) - return FALSE; /* Can't MOV CS, . */ - /*Don't parse if the reg exceeds the bounds of the array. */ - if (reg <= SEG_REGS_MAX - 1) - operands_set_tsi(op, O_REG, 16, SREGS_BASE + reg); - else - return FALSE; - break; - case OT_SEG: - op->type = O_REG; - /* Size of reg is always 16, it's up to caller to zero extend it to - * operand size. */ - op->size = 16; - ps->usedPrefixes |= INST_PRE_OP_SIZE; - /* - * Extract the SEG from ii->flags this time!!! - * Check whether an operand size prefix is used. - */ - switch (instFlags & INST_PRE_SEGOVRD_MASK) { - case INST_PRE_ES: - op->index = R_ES; - break; - case INST_PRE_CS: - op->index = R_CS; - break; - case INST_PRE_SS: - op->index = R_SS; - break; - case INST_PRE_DS: - op->index = R_DS; - break; - case INST_PRE_FS: - op->index = R_FS; - break; - case INST_PRE_GS: - op->index = R_GS; - break; - } - break; - case OT_ACC8: - operands_set_tsi(op, O_REG, 8, R_AL); - break; - case OT_ACC16: - operands_set_tsi(op, O_REG, 16, R_AX); - break; - case OT_ACC_FULL_NOT64: /* No REX.W support for IN/OUT. */ - case OT_ACC_FULL: - if (type == OT_ACC_FULL_NOT64) { - vrex &= ~PREFIX_EX_W; - } - if (effOpSz == Decode16Bits) { - ps->usedPrefixes |= INST_PRE_OP_SIZE; - operands_set_tsi(op, O_REG, 16, R_AX); - } else if (effOpSz == Decode32Bits) { - ps->usedPrefixes |= INST_PRE_OP_SIZE; - operands_set_tsi(op, O_REG, 32, R_EAX); - } else { /* Decode64Bits */ - /* Only non-promoted instructions need REX in order to decode in - * 64 bits. */ - /* MEM-OFFSET MOV's are NOT automatically promoted to 64 bits. - */ - if (~instFlags & INST_64BITS) { - ps->usedPrefixes |= INST_PRE_REX; - } - operands_set_tsi(op, O_REG, 64, R_RAX); - } - break; - case OT_PTR16_FULL: - /* ptr16:full - full is size of operand size to read, therefore - * Operand Size Prefix affects this. So we need to handle it. */ - if (effOpSz == Decode16Bits) { - ps->usedPrefixes |= INST_PRE_OP_SIZE; - ci->codeLen -= sizeof(int16_t) * 2; - if (ci->codeLen < 0) - return FALSE; - - operands_set_ts(op, O_PTR, 16); - di->imm.ptr.off = RUSHORT(ci->code); /* Read offset first. */ - di->imm.ptr.seg = - RUSHORT((ci->code + sizeof(int16_t))); /* And read segment. */ - - ci->code += sizeof(int16_t) * 2; - } else { /* Decode32Bits, for Decode64Bits this instruction is - invalid. */ - ps->usedPrefixes |= INST_PRE_OP_SIZE; - ci->codeLen -= sizeof(int32_t) + sizeof(int16_t); - if (ci->codeLen < 0) - return FALSE; - - operands_set_ts(op, O_PTR, 32); - di->imm.ptr.off = - RULONG(ci->code); /* Read 32bits offset this time. */ - di->imm.ptr.seg = RUSHORT( - (ci->code + sizeof(int32_t))); /* And read segment, 16 bits. */ - - ci->code += sizeof(int32_t) + sizeof(int16_t); - } - break; - case OT_RELCB: - case OT_RELC_FULL: - - if (type == OT_RELCB) { - operands_set_ts(op, O_PC, 8); - if (!read_stream_safe_sint(ci, &di->imm.sqword, sizeof(int8_t))) - return FALSE; - } else { /* OT_RELC_FULL */ - - /* Yep, operand size prefix affects relc also. */ - ps->usedPrefixes |= INST_PRE_OP_SIZE; - if (effOpSz == Decode16Bits) { - operands_set_ts(op, O_PC, 16); - if (!read_stream_safe_sint(ci, &di->imm.sqword, - sizeof(int16_t))) - return FALSE; - } else { /* Decode32Bits or Decode64Bits = for now they are the - same */ - operands_set_ts(op, O_PC, 32); - if (!read_stream_safe_sint(ci, &di->imm.sqword, - sizeof(int32_t))) - return FALSE; - } - } - - /* Support for hint, see if there's a segment override. */ - if ((ii->opcodeId >= I_JO) && (ii->opcodeId <= I_JG)) { - if (ps->decodedPrefixes & INST_PRE_CS) { - ps->usedPrefixes |= INST_PRE_CS; - di->flags |= FLAG_HINT_NOT_TAKEN; - } else if (ps->decodedPrefixes & INST_PRE_DS) { - ps->usedPrefixes |= INST_PRE_DS; - di->flags |= FLAG_HINT_TAKEN; - } - } - break; - case OT_MOFFS8: - op->size = 8; - /* FALL THROUGH, size won't be changed. */ - case OT_MOFFS_FULL: - op->type = O_DISP; - if (op->size == 0) { - /* Calculate size of operand (same as ACC size). */ - switch (effOpSz) { - case Decode16Bits: - op->size = 16; - break; - case Decode32Bits: - op->size = 32; - break; - case Decode64Bits: - op->size = 64; - break; - } - } - - prefixes_use_segment(INST_PRE_DS, ps, ci->dt, di); - - /* - * Just a pointer to a BYTE, WORD, DWORD, QWORD. Works only with - * ACC8/16/32/64 respectively. MOV [0x1234], AL ; MOV AX, [0x1234] ; - * MOV EAX, [0x1234], note that R/E/AX will be chosen by - * OT_ACC_FULL. - */ - if (effAdrSz == Decode16Bits) { - ps->usedPrefixes |= INST_PRE_ADDR_SIZE; - - di->dispSize = 16; - if (!read_stream_safe_uint(ci, &di->disp, sizeof(int16_t))) - return FALSE; - } else if (effAdrSz == Decode32Bits) { - ps->usedPrefixes |= INST_PRE_ADDR_SIZE; - - di->dispSize = 32; - if (!read_stream_safe_uint(ci, &di->disp, sizeof(int32_t))) - return FALSE; - } else { /* Decode64Bits */ - di->dispSize = 64; - if (!read_stream_safe_uint(ci, &di->disp, sizeof(int64_t))) - return FALSE; - } - break; - case OT_CONST1: - operands_set_ts(op, O_IMM, 8); - di->imm.byte = 1; - break; - case OT_REGCL: - operands_set_tsi(op, O_REG, 8, R_CL); - break; - - case OT_FPU_SI: - /* Low 3 bits specify the REG, similar to the MODR/M byte reg. */ - operands_set_tsi(op, O_REG, 32, FPUREGS_BASE + (*(ci->code - 1) & 7)); - break; - case OT_FPU_SSI: - operands_set_tsi(op, O_REG, 32, R_ST0); - operands_set_tsi(op + 1, O_REG, 32, - FPUREGS_BASE + (*(ci->code - 1) & 7)); - break; - case OT_FPU_SIS: - operands_set_tsi(op, O_REG, 32, FPUREGS_BASE + (*(ci->code - 1) & 7)); - operands_set_tsi(op + 1, O_REG, 32, R_ST0); - break; - - /* - * Special treatment for Instructions-Block: - * INC/DEC (only 16/32 bits) /PUSH/POP/XCHG instructions, which get - their REG from their own binary code. - - * Notice these instructions are 1 or 2 byte long, - * code points after the byte which represents the instruction itself, - * thus, even if the instructions are 2 bytes long it will read its last - byte which contains the REG info. - */ - case OT_IB_RB: - /* Low 3 bits specify the REG, similar to the MODR/M byte reg. */ - operands_set_ts(op, O_REG, 8); - reg = *(ci->code - 1) & 7; - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - op->index = (uint8_t)operands_fix_8bit_rex_base(reg + EX_GPR_BASE); - } else if (ps->prefixExtType == PET_REX) { - ps->usedPrefixes |= INST_PRE_REX; - op->index = (uint8_t)operands_fix_8bit_rex_base(reg); - } else - op->index = (uint8_t)(REGS8_BASE + reg); - break; - case OT_IB_R_FULL: - reg = *(ci->code - 1) & 7; - switch (effOpSz) { - case Decode16Bits: - ps->usedPrefixes |= INST_PRE_OP_SIZE; - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - reg += EX_GPR_BASE; - } - operands_set_tsi(op, O_REG, 16, REGS16_BASE + reg); - break; - case Decode32Bits: - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - reg += EX_GPR_BASE; - } else - ps->usedPrefixes |= INST_PRE_OP_SIZE; - operands_set_tsi(op, O_REG, 32, REGS32_BASE + reg); - break; - case Decode64Bits: - /* - * Automatically promoted instruction can drop REX prefix if - * not required. PUSH/POP defaults to 64 bits. --> - * INST_64BITS MOV imm64 / BSWAP requires REX.W to be 64 - * bits --> INST_64BITS | INST_PRE_REX - */ - if ((instFlags & INST_64BITS) && - ((instFlags & INST_PRE_REX) == 0)) { - if (vrex & PREFIX_EX_B) { - ps->usedPrefixes |= INST_PRE_REX; - reg += EX_GPR_BASE; - } - } else { - ps->usedPrefixes |= INST_PRE_REX; - reg += (vrex & PREFIX_EX_B) ? EX_GPR_BASE : 0; - } - operands_set_tsi(op, O_REG, 64, REGS64_BASE + reg); - break; - } - break; - - /* - * Special treatment for repeatable instructions. - - * We want the following output: - * If there's only the REP/NZ prefix, we won't output anything (All - operands are implicit). - * If there's an operand size prefix, we will change the suffix letter - of the mnemonic, which specifies the size of operand to the required - one. - * If there's a segment override prefix, we will output the segment and - the used index register (EDI/ESI). - * If there's an address size prefix, we will output the (segment if - needed and) the used and inverted index register (DI/SI). - - * Example: - * :: Decoding in 16 bits mode! :: - * AD ~ LODSW - * 66 AD ~ LODSD - * F3 AC ~ REP LODSB - * F3 66 AD ~ REP LODSD - * F3 3E AC ~ REP LODS BYTE DS:[SI] - * F3 67 AD ~ REP LODS WORD [ESI] - - * The basic form of a repeatable instruction has its operands hidden - and has a suffix letter - * which implies on the size of operation being done. - * Therefore, we cannot change the mnemonic here when we encounter - another prefix and its not the decoder's responsibility to do so. - * That's why the caller is responsible to add the suffix letter if no - other prefixes are used. - * And all we are doing here is formatting the operand correctly. - */ - case OT_REGI_ESI: - ps->usedPrefixes |= INST_PRE_ADDR_SIZE; - - op->type = O_SMEM; - - /* This might be a 16, 32 or 64 bits instruction, depends on the - * decoding mode. */ - if (instFlags & INST_16BITS) { - ps->usedPrefixes |= INST_PRE_OP_SIZE; - - if (effOpSz == Decode16Bits) - op->size = 16; - else if ((effOpSz == Decode64Bits) && (instFlags & INST_64BITS)) { - ps->usedPrefixes |= INST_PRE_REX; - op->size = 64; - } else - op->size = 32; - } else - op->size = 8; - - /* - * Clear segment in case OT_REGI_EDI was parsed earlier, - * DS can be overridden and therefore has precedence. - */ - di->segment = 0; - prefixes_use_segment(INST_PRE_DS, ps, ci->dt, di); - - if (effAdrSz == Decode16Bits) - op->index = R_SI; - else if (effAdrSz == Decode32Bits) - op->index = R_ESI; - else - op->index = R_RSI; - break; - case OT_REGI_EDI: - ps->usedPrefixes |= INST_PRE_ADDR_SIZE; - - op->type = O_SMEM; - - /* This might be a 16 or 32 bits instruction, depends on the - * decoding mode. */ - if (instFlags & INST_16BITS) { - ps->usedPrefixes |= INST_PRE_OP_SIZE; - - if (effOpSz == Decode16Bits) - op->size = 16; - else if ((effOpSz == Decode64Bits) && (instFlags & INST_64BITS)) { - ps->usedPrefixes |= INST_PRE_REX; - op->size = 64; - } else - op->size = 32; - } else - op->size = 8; - - /* Note: The [rDI] operand can't be prefixed by a segment override, - * therefore we don't set usedPrefixes. */ - if ((opNum == ONT_1) && (ci->dt != Decode64Bits)) - di->segment = R_ES | SEGMENT_DEFAULT; /* No ES in 64 bits mode. */ - - if (effAdrSz == Decode16Bits) - op->index = R_DI; - else if (effAdrSz == Decode32Bits) - op->index = R_EDI; - else - op->index = R_RDI; - break; - - /* Used for In/Out instructions varying forms. */ - case OT_REGDX: - /* Simple single IN/OUT instruction. */ - operands_set_tsi(op, O_REG, 16, R_DX); - break; - - /* Used for INVLPGA instruction. */ - case OT_REGECX: - operands_set_tsi(op, O_REG, 32, R_ECX); - break; - case OT_REGI_EBXAL: - /* XLAT BYTE [rBX + AL] */ - ps->usedPrefixes |= INST_PRE_ADDR_SIZE; - - prefixes_use_segment(INST_PRE_DS, ps, ci->dt, di); - - /* Size of deref is always 8 for xlat. */ - operands_set_tsi(op, O_MEM, 8, R_AL); - - if (effAdrSz == Decode16Bits) - di->base = R_BX; - else if (effAdrSz == Decode32Bits) - di->base = R_EBX; - else { - ps->usedPrefixes |= INST_PRE_REX; - di->base = R_RBX; - } - break; - case OT_REGI_EAX: - /* - * Implicit rAX as memory indirection operand. Used by AMD's SVM - * instructions. Since this is a memory indirection, the default - * address size in 64bits decoding mode is 64. - */ - - if (effAdrSz == Decode64Bits) - operands_set_tsi(op, O_SMEM, 64, R_RAX); - else if (effAdrSz == Decode32Bits) { - ps->usedPrefixes |= INST_PRE_ADDR_SIZE; - operands_set_tsi(op, O_SMEM, 32, R_EAX); - } else { - ps->usedPrefixes |= INST_PRE_ADDR_SIZE; - operands_set_tsi(op, O_SMEM, 16, R_AX); - } - break; - case OT_VXMM: - operands_set_tsi(op, O_REG, 128, SSEREGS_BASE + vexV); - break; - case OT_XMM_IMM: - ci->codeLen -= sizeof(int8_t); - if (ci->codeLen < 0) - return FALSE; - - if (ci->dt == Decode32Bits) - reg = (*ci->code >> 4) & 0x7; - else - reg = (*ci->code >> 4) & 0xf; - operands_set_tsi(op, O_REG, 128, SSEREGS_BASE + reg); - - ci->code += sizeof(int8_t); - break; - case OT_YXMM: - if (vrex & PREFIX_EX_R) - reg += EX_GPR_BASE; - if (ps->vrex & PREFIX_EX_L) - operands_set_tsi(op, O_REG, 256, AVXREGS_BASE + reg); - else - operands_set_tsi(op, O_REG, 128, SSEREGS_BASE + reg); - break; - case OT_YXMM_IMM: - ci->codeLen -= sizeof(int8_t); - if (ci->codeLen < 0) - return FALSE; - - if (ci->dt == Decode32Bits) - reg = (*ci->code >> 4) & 0x7; - else - reg = (*ci->code >> 4) & 0xf; - - if (ps->vrex & PREFIX_EX_L) - operands_set_tsi(op, O_REG, 256, AVXREGS_BASE + reg); - else - operands_set_tsi(op, O_REG, 128, SSEREGS_BASE + reg); - - ci->code += sizeof(int8_t); - break; - case OT_YMM: - if (vrex & PREFIX_EX_R) - reg += EX_GPR_BASE; - operands_set_tsi(op, O_REG, 256, AVXREGS_BASE + reg); - break; - case OT_VYMM: - operands_set_tsi(op, O_REG, 256, AVXREGS_BASE + vexV); - break; - case OT_VYXMM: - if (ps->vrex & PREFIX_EX_L) - operands_set_tsi(op, O_REG, 256, AVXREGS_BASE + vexV); - else - operands_set_tsi(op, O_REG, 128, SSEREGS_BASE + vexV); - break; - case OT_WREG32_64: - if (vrex & PREFIX_EX_R) - reg += EX_GPR_BASE; - if (ps->vrex & PREFIX_EX_W) - operands_set_tsi(op, O_REG, 64, REGS64_BASE + reg); - else - operands_set_tsi(op, O_REG, 32, REGS32_BASE + reg); - break; - default: - return FALSE; - } - - if ((op->type == O_REG) || (op->type == O_SMEM) || (op->type == O_MEM)) { - di->usedRegistersMask |= _REGISTERTORCLASS[op->index]; - } - - return TRUE; -} diff --git a/target/i386/latx/diStorm/operands.h b/target/i386/latx/diStorm/operands.h deleted file mode 100644 index 1aa9467509c..00000000000 --- a/target/i386/latx/diStorm/operands.h +++ /dev/null @@ -1,39 +0,0 @@ -/* -operands.h - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#ifndef OPERANDS_H -#define OPERANDS_H - -#include "config.h" - -#include "decoder.h" -#include "prefix.h" -#include "instructions.h" - -extern uint16_t _REGISTERTORCLASS[]; - -int operands_extract(_CodeInfo* ci, _DInst* di, _InstInfo* ii, _OpType type, - _OperandNumberType opNum, unsigned int modrm, - _PrefixState* ps, _DecodeType effOpSz, - _DecodeType effAdrSz, int* lockableInstruction); - -#endif /* OPERANDS_H */ diff --git a/target/i386/latx/diStorm/prefix.c b/target/i386/latx/diStorm/prefix.c deleted file mode 100644 index 333c63a531e..00000000000 --- a/target/i386/latx/diStorm/prefix.c +++ /dev/null @@ -1,441 +0,0 @@ -/* -prefix.c - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#include "prefix.h" - -#include "x86defs.h" -#include "instructions.h" -#include "mnemonics.h" - -/* - * The main purpose of this module is to keep track of all kind of prefixes a - * single instruction may have. The problem is that a single instruction may - * have up to six different prefix-types. That's why I have to detect such cases - * and drop those excess prefixes. - */ - -int prefixes_is_valid(unsigned int ch, _DecodeType dt) -{ - switch (ch) { - /* for i in xrange(0x40, 0x50): print "case 0x%2x:" % i */ - case 0x40: /* REX: */ - case 0x41: - case 0x42: - case 0x43: - case 0x44: - case 0x45: - case 0x46: - case 0x47: - case 0x48: - case 0x49: - case 0x4a: - case 0x4b: - case 0x4c: - case 0x4d: - case 0x4e: - case 0x4f: - return (dt == Decode64Bits); - case PREFIX_LOCK: - return TRUE; - case PREFIX_REPNZ: - return TRUE; - case PREFIX_REP: - return TRUE; - case PREFIX_CS: - return TRUE; - case PREFIX_SS: - return TRUE; - case PREFIX_DS: - return TRUE; - case PREFIX_ES: - return TRUE; - case PREFIX_FS: - return TRUE; - case PREFIX_GS: - return TRUE; - case PREFIX_OP_SIZE: - return TRUE; - case PREFIX_ADDR_SIZE: - return TRUE; - /* The VEXs might be false positives, the decode_perfixes will determine - * for sure. */ - case PREFIX_VEX2b: /* VEX is supported for all modes, because 16 bits - Pmode is included. */ - case PREFIX_VEX3b: - return TRUE; - } - return FALSE; -} - -/* Ignore a specific prefix type. */ -void prefixes_ignore(_PrefixState* ps, _PrefixIndexer pi) -{ - /* - * If that type of prefix appeared already, set the bit of that *former* - * prefix. Anyway, set the new index of that prefix type to the current - * index, so next time we know its position. - */ - if (ps->pfxIndexer[pi] != PFXIDX_NONE) - ps->unusedPrefixesMask |= (1 << ps->pfxIndexer[pi]); -} - -/* Ignore all prefix. */ -void prefixes_ignore_all(_PrefixState* ps) -{ - int i; - for (i = 0; i < PFXIDX_MAX; i++) - prefixes_ignore(ps, i); -} - -/* Calculates which prefixes weren't used and accordingly sets the bits in the - * unusedPrefixesMask. */ -uint16_t prefixes_set_unused_mask(_PrefixState* ps) -{ - /* - * The decodedPrefixes represents the prefixes that were *read* from the - * binary stream for the instruction. The usedPrefixes represents the - * prefixes that were actually used by the instruction in the *decode* - * phase. Xoring between the two will result in a 'diff' which returns the - * prefixes that were read from the stream *and* that were never used in the - * actual decoding. - * - * Only one prefix per type can be set in decodedPrefixes from the stream. - * Therefore it's enough to check each type once and set the flag - * accordingly. That's why we had to book-keep each prefix type and its - * position. So now we know which bits we need to set exactly in the mask. - */ - _iflags unusedPrefixesDiff = ps->decodedPrefixes ^ ps->usedPrefixes; - - /* Examine unused prefixes by type: */ - /* - * About REX: it might be set in the diff although it was never in the - * stream itself. This is because the vrex is shared between VEX and REX and - * some places flag it as REX usage, while we were really decoding an AVX - * instruction. It's not a big problem, because the prefixes_ignore func - * will ignore it anyway, since it wasn't seen earlier. But it's important - * to know this. - */ - if (unusedPrefixesDiff & INST_PRE_REX) - prefixes_ignore(ps, PFXIDX_REX); - if (unusedPrefixesDiff & INST_PRE_SEGOVRD_MASK) - prefixes_ignore(ps, PFXIDX_SEG); - if (unusedPrefixesDiff & INST_PRE_LOKREP_MASK) - prefixes_ignore(ps, PFXIDX_LOREP); - if (unusedPrefixesDiff & INST_PRE_OP_SIZE) - prefixes_ignore(ps, PFXIDX_OP_SIZE); - if (unusedPrefixesDiff & INST_PRE_ADDR_SIZE) - prefixes_ignore(ps, PFXIDX_ADRS); - /* If a VEX instruction was found, its prefix is considered as used, - * therefore no point for checking for it. */ - - return ps->unusedPrefixesMask; -} - -/* - * Mark a prefix as unused, and bookkeep where we last saw this same type, - * because in the future we might want to disable it too. - */ -_INLINE_ void prefixes_track_unused(_PrefixState* ps, int index, - _PrefixIndexer pi) -{ - prefixes_ignore(ps, pi); - /* Book-keep the current index for this type. */ - ps->pfxIndexer[pi] = index; -} - -/* - * Read as many prefixes as possible, up to 15 bytes, and halt when we encounter - * non-prefix byte. This algorithm tries to imitate a real processor, where the - * same prefix can appear a few times, etc. The tiny complexity is that we want - * to know when a prefix was superfluous and mark any copy of it as unused. Note - * that the last prefix of its type will be considered as used, and all the - * others (of same type) before it as unused. - */ -void prefixes_decode(const uint8_t* code, int codeLen, _PrefixState* ps, - _DecodeType dt) -{ - int index, done; - uint8_t vex; - - /* - * First thing to do, scan for prefixes, there are six types of prefixes. - * There may be up to six prefixes before a single instruction, not the same - * type, no special order, except REX/VEX must precede immediately the first - * opcode byte. BTW - This is the reason why I didn't make the REP prefixes - * part of the instructions (STOS/SCAS/etc). - * - * Another thing, the instruction maximum size is 15 bytes, thus if we read - * more than 15 bytes, we will halt. - * - * We attach all prefixes to the next instruction, there might be two or - * more occurrences from the same prefix. Also, since VEX can be allowed - * only once we will test it separately. - */ - for (index = 0, done = FALSE; - (codeLen > 0) && (code - ps->start < INST_MAXIMUM_SIZE); - code++, codeLen--, index++) { - /* - NOTE: AMD treat lock/rep as two different groups... But I am based on - Intel. - - - Lock and Repeat: - - 0xF0 LOCK - - 0xF2 REPNE/REPNZ - - 0xF3 - REP/REPE/REPZ - - Segment Override: - - 0x2E - CS - - 0x36 - SS - - 0x3E - DS - - 0x26 - ES - - 0x64 - FS - - 0x65 - GS - - Operand-Size Override: 0x66, switching default size. - - Address-Size Override: 0x67, switching default size. - - 64 Bits: - - REX: 0x40 - 0x4f, extends register access. - - 2 Bytes VEX: 0xc4 - - 3 Bytes VEX: 0xc5 - 32 Bits: - - 2 Bytes VEX: 0xc4 11xx-xxxx - - 3 Bytes VEX: 0xc5 11xx-xxxx - */ - - /* Examine what type of prefix we got. */ - switch (*code) { - /* REX type, 64 bits decoding mode only: */ - case 0x40: - case 0x41: - case 0x42: - case 0x43: - case 0x44: - case 0x45: - case 0x46: - case 0x47: - case 0x48: - case 0x49: - case 0x4a: - case 0x4b: - case 0x4c: - case 0x4d: - case 0x4e: - case 0x4f: - if (dt == Decode64Bits) { - ps->decodedPrefixes |= INST_PRE_REX; - ps->vrex = *code & 0xf; /* Keep only BXRW. */ - ps->rexPos = code; - ps->prefixExtType = PET_REX; - prefixes_track_unused(ps, index, PFXIDX_REX); - } else - done = TRUE; /* If we are not in 64 bits mode, it's an - instruction, then halt. */ - break; - - /* LOCK and REPx type: */ - case PREFIX_LOCK: - ps->decodedPrefixes |= INST_PRE_LOCK; - prefixes_track_unused(ps, index, PFXIDX_LOREP); - break; - case PREFIX_REPNZ: - ps->decodedPrefixes |= INST_PRE_REPNZ; - prefixes_track_unused(ps, index, PFXIDX_LOREP); - break; - case PREFIX_REP: - ps->decodedPrefixes |= INST_PRE_REP; - prefixes_track_unused(ps, index, PFXIDX_LOREP); - break; - - /* Seg Overide type: */ - case PREFIX_CS: - ps->decodedPrefixes |= INST_PRE_CS; - prefixes_track_unused(ps, index, PFXIDX_SEG); - break; - case PREFIX_SS: - ps->decodedPrefixes |= INST_PRE_SS; - prefixes_track_unused(ps, index, PFXIDX_SEG); - break; - case PREFIX_DS: - ps->decodedPrefixes |= INST_PRE_DS; - prefixes_track_unused(ps, index, PFXIDX_SEG); - break; - case PREFIX_ES: - ps->decodedPrefixes |= INST_PRE_ES; - prefixes_track_unused(ps, index, PFXIDX_SEG); - break; - case PREFIX_FS: - ps->decodedPrefixes |= INST_PRE_FS; - prefixes_track_unused(ps, index, PFXIDX_SEG); - break; - case PREFIX_GS: - ps->decodedPrefixes |= INST_PRE_GS; - prefixes_track_unused(ps, index, PFXIDX_SEG); - break; - - /* Op Size type: */ - case PREFIX_OP_SIZE: - ps->decodedPrefixes |= INST_PRE_OP_SIZE; - prefixes_track_unused(ps, index, PFXIDX_OP_SIZE); - break; - - /* Addr Size type: */ - case PREFIX_ADDR_SIZE: - ps->decodedPrefixes |= INST_PRE_ADDR_SIZE; - prefixes_track_unused(ps, index, PFXIDX_ADRS); - break; - - /* Non-prefix byte now, so break 2. */ - default: - done = TRUE; - break; - } - if (done) - break; - } - - /* 2 Bytes VEX: */ - if ((codeLen >= 2) && (*code == PREFIX_VEX2b) && - ((code - ps->start) <= INST_MAXIMUM_SIZE - 2)) { - /* - * In 32 bits the second byte has to be in the special range of Mod=11. - * Otherwise it might be a normal LDS instruction. - */ - if ((dt == Decode64Bits) || (*(code + 1) >= INST_DIVIDED_MODRM)) { - ps->vexPos = code + 1; - ps->decodedPrefixes |= INST_PRE_VEX; - ps->prefixExtType = PET_VEX2BYTES; - - /* - * VEX 1 byte bits: - * |7-6--3-2-10| - * |R|vvvv|L|pp| - * |-----------| - */ - - /* -- Convert from VEX prefix to VREX flags -- */ - vex = *ps->vexPos; - if (~vex & 0x80 && dt == Decode64Bits) - ps->vrex |= PREFIX_EX_R; /* Convert VEX.R. */ - if (vex & 4) - ps->vrex |= PREFIX_EX_L; /* Convert VEX.L. */ - - code += 2; - } - } - - /* 3 Bytes VEX: */ - if ((codeLen >= 3) && (*code == PREFIX_VEX3b) && - ((code - ps->start) <= INST_MAXIMUM_SIZE - 3) && - (~ps->decodedPrefixes & INST_PRE_VEX)) { - /* - * In 32 bits the second byte has to be in the special range of Mod=11. - * Otherwise it might be a normal LES instruction. - * And we don't care now about the 3rd byte. - */ - if ((dt == Decode64Bits) || (*(code + 1) >= INST_DIVIDED_MODRM)) { - ps->vexPos = code + 1; - ps->decodedPrefixes |= INST_PRE_VEX; - ps->prefixExtType = PET_VEX3BYTES; - - /* - * VEX first and second bytes: - * |7-6-5-4----0| |7-6--3-2-10| - * |R|X|B|m-mmmm| |W|vvvv|L|pp| - * |------------| |-----------| - */ - - /* -- Convert from VEX prefix to VREX flags -- */ - vex = *ps->vexPos; - ps->vrex |= ((~vex >> 5) & - 0x7); /* Shift and invert VEX.R/X/B to their place */ - vex = *(ps->vexPos + 1); - if (vex & 4) - ps->vrex |= PREFIX_EX_L; /* Convert VEX.L. */ - if (vex & 0x80) - ps->vrex |= PREFIX_EX_W; /* Convert VEX.W. */ - - /* Clear some flags if the mode isn't 64 bits. */ - if (dt != Decode64Bits) - ps->vrex &= - ~(PREFIX_EX_B | PREFIX_EX_X | PREFIX_EX_R | PREFIX_EX_W); - - code += 3; - } - } - - /* - * Save last byte scanned address, so the decoder could keep on scanning - * from this point and on and on and on. In addition the decoder is able to - * know that the last byte could lead to MMX/SSE instructions (preceding REX - * if exists). - */ - ps->last = code; /* ps->last points to an opcode byte. */ -} - -/* - * For every memory-indirection operand we want to set its corresponding default - * segment. If the segment is being overrided, we need to see whether we use it - * or not. We will use it only if it's not the default one already. - */ -void prefixes_use_segment(_iflags defaultSeg, _PrefixState* ps, _DecodeType dt, - _DInst* di) -{ - _iflags flags = 0; - if (dt == Decode64Bits) - flags = ps->decodedPrefixes & INST_PRE_SEGOVRD_MASK64; - else - flags = ps->decodedPrefixes & INST_PRE_SEGOVRD_MASK; - - if ((flags == 0) || (flags == defaultSeg)) { - flags = defaultSeg; - di->segment |= SEGMENT_DEFAULT; - } else if (flags != defaultSeg) { - /* Use it only if it's non-default segment. */ - ps->usedPrefixes |= flags; - } - - /* ASSERT: R_XX must be below 128. */ - switch (flags) { - case INST_PRE_ES: - di->segment |= R_ES; - break; - case INST_PRE_CS: - di->segment |= R_CS; - break; - case INST_PRE_SS: - di->segment |= R_SS; - break; - case INST_PRE_DS: - di->segment |= R_DS; - break; - case INST_PRE_FS: - di->segment |= R_FS; - break; - case INST_PRE_GS: - di->segment |= R_GS; - break; - } - - /* If it's one of the CS,SS,DS,ES and the mode is 64 bits, set segment it to - * none, since it's ignored. */ - if ((dt == Decode64Bits) && (flags & INST_PRE_SEGOVRD_MASK32)) - di->segment = R_NONE; -} diff --git a/target/i386/latx/diStorm/prefix.h b/target/i386/latx/diStorm/prefix.h deleted file mode 100644 index 9d52d8823c8..00000000000 --- a/target/i386/latx/diStorm/prefix.h +++ /dev/null @@ -1,94 +0,0 @@ -/* -prefix.h - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#ifndef PREFIX_H -#define PREFIX_H - -#include "config.h" - -#include "decoder.h" - -/* Specifies the type of the extension prefix, such as: REX, 2 bytes VEX, 3 - * bytes VEX. */ -typedef enum { - PET_NONE = 0, - PET_REX, - PET_VEX2BYTES, - PET_VEX3BYTES -} _PrefixExtType; - -/* Specifies an index into a table of prefixes by their type. */ -typedef enum { - PFXIDX_NONE = -1, - PFXIDX_REX, - PFXIDX_LOREP, - PFXIDX_SEG, - PFXIDX_OP_SIZE, - PFXIDX_ADRS, - PFXIDX_MAX -} _PrefixIndexer; - -/* - * This holds the prefixes state for the current instruction we decode. - * decodedPrefixes includes all specific prefixes that the instruction got. - * start is a pointer to the first prefix to take into account. - * last is a pointer to the last byte we scanned. - * Other pointers are used to keep track of prefixes positions and help us know - * if they appeared already and where. - */ -typedef struct { - _iflags decodedPrefixes, usedPrefixes; - const uint8_t *start, *last, *vexPos, *rexPos; - _PrefixExtType prefixExtType; - uint16_t unusedPrefixesMask; - /* Indicates whether the operand size prefix (0x66) was used as a mandatory - * prefix. */ - int isOpSizeMandatory; - /* If VEX prefix is used, store the VEX.vvvv field. */ - unsigned int vexV; - /* The fields B/X/R/W/L of REX and VEX are stored together in this byte. */ - unsigned int vrex; - - /* !! Make sure pfxIndexer is LAST! Otherwise memset won't work well with - * it. !! */ - - /* Holds the offset to the prefix byte by its type. */ - int pfxIndexer[PFXIDX_MAX]; -} _PrefixState; - -/* - * Intel supports 6 types of prefixes, whereas AMD supports 5 types (lock is - * seperated from rep/nz). REX is the fifth prefix type, this time I'm based on - * AMD64. VEX is the 6th, though it can't be repeated. - */ -#define MAX_PREFIXES (5) - -int prefixes_is_valid(unsigned int ch, _DecodeType dt); -void prefixes_ignore(_PrefixState* ps, _PrefixIndexer pi); -void prefixes_ignore_all(_PrefixState* ps); -uint16_t prefixes_set_unused_mask(_PrefixState* ps); -void prefixes_decode(const uint8_t* code, int codeLen, _PrefixState* ps, - _DecodeType dt); -void prefixes_use_segment(_iflags defaultSeg, _PrefixState* ps, _DecodeType dt, - _DInst* di); - -#endif /* PREFIX_H */ diff --git a/target/i386/latx/diStorm/x86defs.c b/target/i386/latx/diStorm/x86defs.c deleted file mode 100644 index b5b637f6f0d..00000000000 --- a/target/i386/latx/diStorm/x86defs.c +++ /dev/null @@ -1,54 +0,0 @@ -/* -x86defs.c - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#include "x86defs.h" -#include "instructions.h" -#include "mnemonics.h" - -/* - * The first field of an _InstInfo is the flagsInex, which goes into FlagsTable - * in insts.c Since this table is auto generated in disOps, we have to make sure - * that the first 5 entries are reserved for our use here. The following defined - * inst-infos have to be synced manually every time you change insts.c. - */ - -_InstInfo II_arpl = {0 /* INST_MODRM_REQUIRED */, OT_REG16, OT_RM16, - ISC_INTEGER << 3, I_ARPL}; -/* - * MOVSXD: - * This is the worst defined instruction ever. It has so many variations. - * I decided after a third review, to make it like MOVSXD RAX, EAX when there IS - * a REX.W. Otherwise it will be MOVSXD EAX, EAX, which really zero extends to - * RAX. Completely ignoring DB 0x66, which is possible by the docs, BTW. - */ -_InstInfo II_movsxd = {1 /* INST_MODRM_REQUIRED | INST_PRE_REX | INST_64BITS */, - OT_RM32, OT_REG32_64, ISC_INTEGER << 3, I_MOVSXD}; - -_InstInfo II_nop = {2 /* INST_FLAGS_NONE */, OT_NONE, OT_NONE, ISC_INTEGER << 3, - I_NOP}; - -_InstInfo II_pause = {3 /* INST_FLAGS_NONE */, OT_NONE, OT_NONE, - ISC_INTEGER << 3, I_PAUSE}; - -_InstInfo II_3dnow = { - 4 /* INST_32BITS | INST_MODRM_REQUIRED | INST_3DNOW_FETCH */, OT_MM64, - OT_MM, ISC_3DNOW << 3, I_UNDEFINED}; diff --git a/target/i386/latx/diStorm/x86defs.h b/target/i386/latx/diStorm/x86defs.h deleted file mode 100644 index 8ea751fdd8a..00000000000 --- a/target/i386/latx/diStorm/x86defs.h +++ /dev/null @@ -1,115 +0,0 @@ -/* -x86defs.h - -diStorm3 - Powerful disassembler for X86/AMD64 -http://ragestorm.net/distorm/ -distorm at gmail dot com -Copyright (C) 2011 Gil Dabah - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see -*/ - -#ifndef X86DEFS_H -#define X86DEFS_H - -#include "config.h" - -#include "instructions.h" - -#define SEG_REGS_MAX (6) -#define CREGS_MAX (9) -#define DREGS_MAX (8) - -/* Maximum instruction size, including prefixes */ -#define INST_MAXIMUM_SIZE (15) - -/* Maximum range of imm8 (comparison type) of special SSE instructions. */ -#define INST_CMP_MAX_RANGE (8) - -/* Wait instruction byte code. */ -#define INST_WAIT_INDEX (0x9b) - -/* Lea instruction byte code. */ -#define INST_LEA_INDEX (0x8d) - -/* - * Minimal MODR/M value of divided instructions. - * It's 0xc0, two MSBs set, which indicates a general purpose register is used - * too. - */ -#define INST_DIVIDED_MODRM (0xc0) - -/* This is the escape byte value used for 3DNow! instructions. */ -#define _3DNOW_ESCAPE_BYTE (0x0f) - -#define PREFIX_LOCK (0xf0) -#define PREFIX_REPNZ (0xf2) -#define PREFIX_REP (0xf3) -#define PREFIX_CS (0x2e) -#define PREFIX_SS (0x36) -#define PREFIX_DS (0x3e) -#define PREFIX_ES (0x26) -#define PREFIX_FS (0x64) -#define PREFIX_GS (0x65) -#define PREFIX_OP_SIZE (0x66) -#define PREFIX_ADDR_SIZE (0x67) -#define PREFIX_VEX2b (0xc5) -#define PREFIX_VEX3b (0xc4) - -/* REX prefix value range, 64 bits mode decoding only. */ -#define PREFIX_REX_LOW (0x40) -#define PREFIX_REX_HI (0x4f) -/* In order to use the extended GPR's we have to add 8 to the Modr/M info - * values. */ -#define EX_GPR_BASE (8) - -/* Mask for REX and VEX features: */ -/* Base */ -#define PREFIX_EX_B (1) -/* Index */ -#define PREFIX_EX_X (2) -/* Register */ -#define PREFIX_EX_R (4) -/* Operand Width */ -#define PREFIX_EX_W (8) -/* Vector Lengh */ -#define PREFIX_EX_L (0x10) - -/* - * The inst_lookup will return on of these two instructions according to the - * specified decoding mode. ARPL or MOVSXD on 64 bits is one byte instruction at - * index 0x63. - */ -#define INST_ARPL_INDEX (0x63) -extern _InstInfo II_arpl; -extern _InstInfo II_movsxd; - -/* - * The NOP instruction can be prefixed by REX in 64bits, therefore we have to - * decide in runtime whether it's an XCHG or NOP instruction. If 0x90 is - * prefixed by a useable REX it will become XCHG, otherwise it will become a - * NOP. Also note that if it's prefixed by 0xf3, it becomes a Pause. - */ -#define INST_NOP_INDEX (0x90) -extern _InstInfo II_nop; -extern _InstInfo II_pause; - -/* - * Used for letting the extract operand know the type of operands without - * knowing the instruction itself yet, because of the way those instructions - * work. See function instructions.c!inst_lookup_3dnow. - */ -extern _InstInfo II_3dnow; - -#endif /* X86DEFS_H */ diff --git a/target/i386/latx/error.c b/target/i386/latx/error.c index 983615c3e23..619d1039967 100644 --- a/target/i386/latx/error.c +++ b/target/i386/latx/error.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "error.h" #include #include diff --git a/target/i386/latx/exlib/libxed.a b/target/i386/latx/exlib/libxed.a deleted file mode 100644 index b132cabfc60..00000000000 Binary files a/target/i386/latx/exlib/libxed.a and /dev/null differ diff --git a/target/i386/latx/include/aot.h b/target/i386/latx/include/aot.h index b69fc1ebd97..40765253888 100644 --- a/target/i386/latx/include/aot.h +++ b/target/i386/latx/include/aot.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot.h * @author wwq diff --git a/target/i386/latx/include/aot_lib.h b/target/i386/latx/include/aot_lib.h index 651b1eef6f0..8c9c9dd1f2b 100644 --- a/target/i386/latx/include/aot_lib.h +++ b/target/i386/latx/include/aot_lib.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_lib.h * @author wwq diff --git a/target/i386/latx/include/aot_link_seg.h b/target/i386/latx/include/aot_link_seg.h index e8998d576e3..2dead86c10e 100644 --- a/target/i386/latx/include/aot_link_seg.h +++ b/target/i386/latx/include/aot_link_seg.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_link_seg.h * @author wwq diff --git a/target/i386/latx/include/aot_merge.h b/target/i386/latx/include/aot_merge.h index a553dfe786a..19286531886 100644 --- a/target/i386/latx/include/aot_merge.h +++ b/target/i386/latx/include/aot_merge.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_merge.h * @author wwq diff --git a/target/i386/latx/include/aot_page.h b/target/i386/latx/include/aot_page.h index 04846c7a2e8..302e3ab5aa2 100644 --- a/target/i386/latx/include/aot_page.h +++ b/target/i386/latx/include/aot_page.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_page.h * @author wwq diff --git a/target/i386/latx/include/aot_recover_tb.h b/target/i386/latx/include/aot_recover_tb.h index caf2234bfa3..27826cae4c3 100644 --- a/target/i386/latx/include/aot_recover_tb.h +++ b/target/i386/latx/include/aot_recover_tb.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_recover_tb.h * @author wwq diff --git a/target/i386/latx/include/aot_smc.h b/target/i386/latx/include/aot_smc.h index 9286a3fe146..cfccac8974a 100644 --- a/target/i386/latx/include/aot_smc.h +++ b/target/i386/latx/include/aot_smc.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_smc.h * @author wwq diff --git a/target/i386/latx/include/box64context.h b/target/i386/latx/include/box64context.h index 489d1b79ad4..3fd76986845 100755 --- a/target/i386/latx/include/box64context.h +++ b/target/i386/latx/include/box64context.h @@ -15,6 +15,7 @@ typedef struct kh_symbol1map_s kh_symbol1map_t; typedef struct library_s library_t; typedef struct linkmap_s linkmap_t; typedef struct kh_threadstack_s kh_threadstack_t; +typedef struct guest_object_registry_s guest_object_registry_t; typedef struct atfork_fnc_s { uintptr_t prepare; uintptr_t parent; @@ -42,18 +43,22 @@ void free_dependedlib(needed_libs_t* depended); typedef struct dlprivate_s { library_t **libs; + void **handles; size_t *count; size_t *dlopened; - struct link_map *dlx86handle; size_t lib_sz; size_t lib_cap; char* last_error; + char* last_error_returned; void * x86dlopen; + void * x86dlmopen; void * x86dlclose; void * x86dlsym; void * x86dladdr1; void * x86dladdr; void * x86dlinfo; + void * x86dlvsym; + void * x86dlerror; } dlprivate_t; struct latx_kzt_debug { char *name; @@ -62,144 +67,16 @@ struct latx_kzt_debug { unsigned long map_end; }; -enum r_dir_status { unknown, nonexisting, existing }; -struct r_scope_elem -{ - /* Array of maps for the scope. */ - struct link_map_x64 **r_list; - /* Number of entries in the scope. */ - unsigned int r_nlist; -}; -struct r_search_path_elem -{ - /* This link is only used in the `all_dirs' member of `r_search_path'. */ - struct r_search_path_elem *next; - - /* Strings saying where the definition came from. */ - const char *what; - const char *where; - - /* Basename for this search path element. The string must end with - a slash character. */ - const char *dirname; - size_t dirnamelen; - - enum r_dir_status status[0]; -}; - -struct r_search_path_struct -{ - struct r_search_path_elem **dirs; - int malloced; -}; -typedef Elf64_Half Elf64_Versym; -typedef unsigned long dev_t; -struct r_file_id -{ - dev_t dev; - ino64_t ino; -}; -struct link_map_machine -{ - Elf64_Addr plt; - Elf64_Addr gotplt; - void *tlsdesc_table; -}; -struct auditstate { - uintptr_t cookie; - unsigned int bindflags; -}; - -typedef long ptrdiff_t; - +/* + * Only the public ABI prefix from is used here. Glibc fields after + * l_prev are private and their offsets change between loader versions. + */ struct link_map_x64 { Elf64_Addr l_addr; char *l_name; Elf64_Dyn *l_ld; struct link_map_x64 *l_next; struct link_map_x64 *l_prev; - struct link_map_x64 *l_real; - Lmid_t l_ns; - struct libname_list *l_libname; - Elf64_Dyn *l_info[77];//get form gdb ptype ---latx - const Elf64_Phdr *l_phdr; - Elf64_Addr l_entry; - Elf64_Half l_phnum; - Elf64_Half l_ldnum; - struct r_scope_elem l_searchlist; - struct r_scope_elem l_symbolic_searchlist; - struct link_map_x64 *l_loader; - struct r_found_version *l_versions; - unsigned int l_nversions; - Elf_Symndx l_nbuckets; - Elf32_Word l_gnu_bitmask_idxbits; - Elf32_Word l_gnu_shift; - const Elf64_Addr *l_gnu_bitmask; - union { - const Elf32_Word *l_gnu_buckets; - const Elf_Symndx *l_chain; - }; - union { - const Elf32_Word *l_gnu_chain_zero; - const Elf_Symndx *l_buckets; - }; - unsigned int l_direct_opencount; - enum {lt_executable, lt_library, lt_loaded} l_type : 2; - unsigned int l_relocated : 1; - unsigned int l_init_called : 1; - unsigned int l_global : 1; - unsigned int l_reserved : 2; - unsigned int l_phdr_allocated : 1; - unsigned int l_soname_added : 1; - unsigned int l_faked : 1; - unsigned int l_need_tls_init : 1; - unsigned int l_auditing : 1; - unsigned int l_audit_any_plt : 1; - unsigned int l_removed : 1; - unsigned int l_contiguous : 1; - unsigned int l_symbolic_in_local_scope : 1; - unsigned int l_free_initfini : 1; - enum {lc_unknown, lc_none, lc_ibt, lc_shstk = 4, lc_ibt_and_shstk = 6} l_cet : 3; - struct r_search_path_struct l_rpath_dirs; - struct reloc_result *l_reloc_result; - Elf64_Versym *l_versyms; - const char *l_origin; - Elf64_Addr l_map_start; - Elf64_Addr l_map_end; - Elf64_Addr l_text_end; - struct r_scope_elem *l_scope_mem[4]; - size_t l_scope_max; - struct r_scope_elem **l_scope; - struct r_scope_elem *l_local_scope[2]; - struct r_file_id l_file_id; - struct r_search_path_struct l_runpath_dirs; - struct link_map_x64 **l_initfini; - struct link_map_reldeps *l_reldeps; - unsigned int l_reldepsmax; - unsigned int l_used; - Elf64_Word l_feature_1; - Elf64_Word l_flags_1; - Elf64_Word l_flags; - int l_idx; - struct link_map_machine l_mach; - struct { - const Elf64_Sym *sym; - int type_class; - struct link_map *value; - const Elf64_Sym *ret; - } l_lookup_cache; - void *l_tls_initimage; - size_t l_tls_initimage_size; - size_t l_tls_blocksize; - size_t l_tls_align; - size_t l_tls_firstbyte_offset; - ptrdiff_t l_tls_offset; - size_t l_tls_modid; - size_t l_tls_dtor_count; - Elf64_Addr l_relro_addr; - size_t l_relro_size; - unsigned long long l_serial; - struct auditstate l_audit[]; }; struct malloc_map { void* mallocp; @@ -238,6 +115,7 @@ typedef struct box64context_s { elfheader_t **elfs; // elf headers and memory int elfcap; int elfsize; // number of elf loaded + guest_object_registry_t *guest_objects; struct malloc_map **mallocmaps; // elf filepath and memory int mallocmapcap; diff --git a/target/i386/latx/include/capstone_git.h b/target/i386/latx/include/capstone_git.h index c34549d9b2c..f6e27344693 100644 --- a/target/i386/latx/include/capstone_git.h +++ b/target/i386/latx/include/capstone_git.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef LATX_DISASSEMBLE_FROM_NEXTCAPSTONE_H #define LATX_DISASSEMBLE_FROM_NEXTCAPSTONE_H #include "latx-disassemble-trace.h" diff --git a/target/i386/latx/include/common.h b/target/i386/latx/include/common.h index b209b1a202c..fa89345a621 100644 --- a/target/i386/latx/include/common.h +++ b/target/i386/latx/include/common.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _COMMON_H_ #define _COMMON_H_ diff --git a/target/i386/latx/include/complext.h b/target/i386/latx/include/complext.h index 8535607ab0e..98d750c9d07 100644 --- a/target/i386/latx/include/complext.h +++ b/target/i386/latx/include/complext.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef __COMPLEX_T__H_ #define __COMPLEX_T__H_ diff --git a/target/i386/latx/include/debug.h b/target/i386/latx/include/debug.h index 2e302fa22cf..de2315b347e 100755 --- a/target/i386/latx/include/debug.h +++ b/target/i386/latx/include/debug.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef __DEBUG_H_ #define __DEBUG_H_ #include diff --git a/target/i386/latx/include/elfloader.h b/target/i386/latx/include/elfloader.h index 40a0f915fa6..6aaa0542783 100755 --- a/target/i386/latx/include/elfloader.h +++ b/target/i386/latx/include/elfloader.h @@ -2,9 +2,6 @@ #define __ELF_LOADER_H_ #include #include "elf.h" -extern uintptr_t pltResolver; -extern uintptr_t dl_runtime_resolver; -extern uintptr_t link_map_obj; typedef struct elfheader_s elfheader_t; typedef struct lib_s lib_t; typedef struct library_s library_t; @@ -32,7 +29,6 @@ int RelocateElf(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t* he int RelocateElfPlt(lib_t *maplib, lib_t* local_maplib, int bindnow, elfheader_t* head); void CalcStack(elfheader_t* h, uint64_t* stacksz, size_t* stackalign); void AddSymbols(lib_t *maplib, kh_mapsymbols_t* mapsymbols, kh_mapsymbols_t* weaksymbols, kh_mapsymbols_t* localsymbols, elfheader_t* h); -int LoadNeededLibs(elfheader_t* h, lib_t *maplib, needed_libs_t* neededlibs, library_t *deplib, int local, int bindnow, box64context_t *box64); uintptr_t GetElfInit(elfheader_t* h); uintptr_t GetElfFini(elfheader_t* h); @@ -58,8 +54,6 @@ const char* GetNeededVersionString(elfheader_t* h, const char* libname, int idx) void* GetNativeSymbolUnversionned(void* lib, const char* name); void AddMainElfToLinkmap(elfheader_t* lib); -void PltResolver(void); - int RelocateElfRELA(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t* head, int cnt, Elf64_Rela *rela, int* need_resolv); uintptr_t loadSoaddrFromMap(char * real_path); void ElfHeadReFix (elfheader_t* head, uintptr_t delta); diff --git a/target/i386/latx/include/elfmap.h b/target/i386/latx/include/elfmap.h new file mode 100644 index 00000000000..95096fb6b89 --- /dev/null +++ b/target/i386/latx/include/elfmap.h @@ -0,0 +1,17 @@ +#ifndef __ELFMAP_H_ +#define __ELFMAP_H_ + +#include +#include + +#include "elf.h" + +int GetElfLoadRange( + const Elf64_Phdr *program_headers, + size_t program_header_count, + uintptr_t load_bias, + uintptr_t page_size, + uintptr_t *map_start, + uintptr_t *map_end); + +#endif diff --git a/target/i386/latx/include/env.h b/target/i386/latx/include/env.h index 1467ffadc2d..8495d46d26b 100644 --- a/target/i386/latx/include/env.h +++ b/target/i386/latx/include/env.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _ENV_H_ #define _ENV_H_ diff --git a/target/i386/latx/include/error.h b/target/i386/latx/include/error.h index 92e528a1167..bf222cd03b1 100644 --- a/target/i386/latx/include/error.h +++ b/target/i386/latx/include/error.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _ERROR_H_ #define _ERROR_H_ diff --git a/target/i386/latx/include/file_ctx.h b/target/i386/latx/include/file_ctx.h index 3f30e118988..28c13e8a467 100644 --- a/target/i386/latx/include/file_ctx.h +++ b/target/i386/latx/include/file_ctx.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file file_ctx.h * @author wwq diff --git a/target/i386/latx/include/flag-lbt.h b/target/i386/latx/include/flag-lbt.h index 7c31d7a7fd0..2916a9dcd3c 100644 --- a/target/i386/latx/include/flag-lbt.h +++ b/target/i386/latx/include/flag-lbt.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _FLAG_LBT_H_ #define _FLAG_LBT_H_ diff --git a/target/i386/latx/include/flag-reduction.h b/target/i386/latx/include/flag-reduction.h index 721785a37f4..ee50169bb77 100644 --- a/target/i386/latx/include/flag-reduction.h +++ b/target/i386/latx/include/flag-reduction.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _FLAG_REDUCTION_H_ #define _FLAG_REDUCTION_H_ diff --git a/target/i386/latx/include/guestdynamic.h b/target/i386/latx/include/guestdynamic.h new file mode 100644 index 00000000000..a0cbd721515 --- /dev/null +++ b/target/i386/latx/include/guestdynamic.h @@ -0,0 +1,238 @@ +#ifndef __GUESTDYNAMIC_H_ +#define __GUESTDYNAMIC_H_ + +#include +#include + +#include "elf.h" + +#define KZT_DYNAMIC_SCAN_MAX 4096 +#define KZT_DYNAMIC_VERSION_WALK_MAX 4096 + +typedef int (*KztDynamicRangeValidator)(const void *addr, size_t size, + void *opaque); + +typedef struct KztDynamicSummary { + size_t entries; + size_t needed_count; + size_t rpath_count; + size_t runpath_count; + int has_null; + int truncated; + uintptr_t strtab; + size_t strsz; + uintptr_t symtab; + size_t syment; + uintptr_t hash; + uintptr_t gnu_hash; + uintptr_t rel; + size_t relsz; + size_t relent; + uintptr_t rela; + size_t relasz; + size_t relaent; + uintptr_t jmprel; + size_t pltrelsz; + uint64_t pltrel; + uintptr_t pltgot; + uintptr_t init; + uintptr_t init_array; + size_t init_arraysz; + uintptr_t fini; + uintptr_t fini_array; + size_t fini_arraysz; + uintptr_t versym; + uintptr_t verneed; + size_t verneednum; + uintptr_t verdef; + size_t verdefnum; +} KztDynamicSummary; + +typedef enum KztDynamicViewStatus { + KZT_DYNAMIC_VIEW_EMPTY, + KZT_DYNAMIC_VIEW_READY, + KZT_DYNAMIC_VIEW_TRUNCATED, +} KztDynamicViewStatus; + +typedef struct KztDynamicView { + const Elf64_Dyn *entries; + size_t entry_count; + KztDynamicViewStatus status; + KztDynamicSummary summary; +} KztDynamicView; + +typedef enum KztDynamicError { + KZT_DYNAMIC_ERROR_RELENT = 1u << 0, + KZT_DYNAMIC_ERROR_RELAENT = 1u << 1, + KZT_DYNAMIC_ERROR_PLTREL = 1u << 2, + KZT_DYNAMIC_ERROR_PLTSZ = 1u << 3, + KZT_DYNAMIC_ERROR_GNU_HASH = 1u << 4, +} KztDynamicError; + +typedef struct KztDynamicInfo { + KztDynamicRangeValidator range_is_readable; + void *range_opaque; + uintptr_t strtab; + size_t strsz; + uintptr_t symtab; + size_t syment; + uintptr_t hash; + uintptr_t gnu_hash; + size_t dynsym_count; + int has_dynsym_count; + uintptr_t rel; + size_t relsz; + int relent; + size_t rel_count; + int has_rel_count; + uintptr_t rela; + size_t relasz; + int relaent; + size_t rela_count; + int has_rela_count; + uintptr_t jmprel; + size_t pltsz; + int pltent; + size_t plt_count; + int has_plt_count; + uint64_t pltrel; + uintptr_t pltgot; + uintptr_t initentry; + uintptr_t initarray; + size_t initarray_count; + uintptr_t finientry; + uintptr_t finiarray; + size_t finiarray_count; + uintptr_t versym; + uintptr_t verneed; + int verneed_count; + uintptr_t verdef; + int verdef_count; + unsigned errors; +} KztDynamicInfo; + +typedef struct KztDynamicStringTable { + const char *data; + size_t size; +} KztDynamicStringTable; + +typedef struct KztDynamicStringEntry { + const Elf64_Dyn *dynamic; + size_t offset; + const char *value; +} KztDynamicStringEntry; + +typedef struct KztDynamicSymbolTable { + const Elf64_Sym *symbols; + size_t count; + KztDynamicStringTable strings; +} KztDynamicSymbolTable; + +typedef struct KztDynamicSymbolEntry { + const Elf64_Sym *symbol; + const char *name; +} KztDynamicSymbolEntry; + +typedef struct KztDynamicVerneedEntry { + const KztDynamicInfo *info; + const Elf64_Verneed *record; + const char *file; +} KztDynamicVerneedEntry; + +typedef struct KztDynamicVernauxEntry { + const Elf64_Vernaux *record; + const char *name; +} KztDynamicVernauxEntry; + +typedef struct KztDynamicVerdefEntry { + const KztDynamicInfo *info; + const Elf64_Verdef *record; +} KztDynamicVerdefEntry; + +typedef struct KztDynamicVerdauxEntry { + const Elf64_Verdaux *record; + const char *name; +} KztDynamicVerdauxEntry; + +typedef struct KztDynamicRelocationTable { + const void *entries; + size_t count; + int entry_size; +} KztDynamicRelocationTable; + +typedef struct KztDynamicRelocationEntry { + uintptr_t offset; + uint64_t info; + int64_t addend; + int has_addend; +} KztDynamicRelocationEntry; + +void KztParseDynamicView(KztDynamicView *view, const Elf64_Dyn *dynamic, + size_t max_entries); +void KztBuildDynamicInfo(KztDynamicInfo *info, const KztDynamicView *view); +void KztDynamicInfoSetRangeValidator(KztDynamicInfo *info, + KztDynamicRangeValidator validator, + void *opaque); +void KztBuildDynamicInfoForObject(KztDynamicInfo *info, + const KztDynamicView *view, + uintptr_t load_bias); +uintptr_t KztDynamicApplyLoadBias(uintptr_t value, uintptr_t load_bias); +const char *KztDynamicStrtabFromPtr(uintptr_t strtab, uintptr_t load_bias); +int KztDynamicStringTableFromInfo(const KztDynamicInfo *info, + uintptr_t load_bias, + KztDynamicStringTable *table); +const char *KztDynamicStringAt(const KztDynamicStringTable *strtab, + size_t offset); +int KztNextDynamicString(const KztDynamicView *view, int tag, + size_t *index, + const KztDynamicStringTable *strtab, + KztDynamicStringEntry *entry); +int KztResolveDynamicSymbolCount(KztDynamicInfo *info, uintptr_t load_bias); +const Elf64_Sym *KztDynamicSymtabFromPtr(uintptr_t symtab, + uintptr_t load_bias); +int KztDynamicSymbolTableFromInfo(const KztDynamicInfo *info, + uintptr_t load_bias, + KztDynamicSymbolTable *table); +int KztDynamicSymbolAt(const KztDynamicSymbolTable *symtab, size_t index, + KztDynamicSymbolEntry *entry); +const Elf64_Half *KztDynamicVersymFromPtr(uintptr_t versym, + uintptr_t load_bias); +const Elf64_Half *KztDynamicVersymFromInfo(const KztDynamicInfo *info, + uintptr_t load_bias); +const Elf64_Verneed *KztDynamicVerneedFromPtr(uintptr_t verneed, + uintptr_t load_bias); +const Elf64_Verneed *KztDynamicVerneedFromInfo(const KztDynamicInfo *info, + uintptr_t load_bias); +int KztDynamicVerneedAt(const Elf64_Verneed *base, size_t index, + const KztDynamicStringTable *strtab, + KztDynamicVerneedEntry *entry); +int KztDynamicVerneedAtFromInfo(const KztDynamicInfo *info, + const Elf64_Verneed *base, size_t index, + const KztDynamicStringTable *strtab, + KztDynamicVerneedEntry *entry); +int KztDynamicVernauxAt(const KztDynamicVerneedEntry *verneed, size_t index, + const KztDynamicStringTable *strtab, + KztDynamicVernauxEntry *entry); +const Elf64_Verdef *KztDynamicVerdefFromPtr(uintptr_t verdef, + uintptr_t load_bias); +const Elf64_Verdef *KztDynamicVerdefFromInfo(const KztDynamicInfo *info, + uintptr_t load_bias); +int KztDynamicVerdefAt(const Elf64_Verdef *base, size_t index, + KztDynamicVerdefEntry *entry); +int KztDynamicVerdefAtFromInfo(const KztDynamicInfo *info, + const Elf64_Verdef *base, size_t index, + KztDynamicVerdefEntry *entry); +int KztDynamicVerdauxAt(const KztDynamicVerdefEntry *verdef, size_t index, + const KztDynamicStringTable *strtab, + KztDynamicVerdauxEntry *entry); +const void *KztDynamicRelocationsFromPtr(uintptr_t relocations, + uintptr_t load_bias); +const void *KztDynamicRelocationsFromInfo(const KztDynamicInfo *info, + uintptr_t relocations, + uintptr_t load_bias, + size_t count, int entry_size); +int KztDynamicRelocationAt(const KztDynamicRelocationTable *table, + size_t index, + KztDynamicRelocationEntry *entry); + +#endif //__GUESTDYNAMIC_H_ diff --git a/target/i386/latx/include/guestlazy.h b/target/i386/latx/include/guestlazy.h new file mode 100644 index 00000000000..34f46f673be --- /dev/null +++ b/target/i386/latx/include/guestlazy.h @@ -0,0 +1,146 @@ +#ifndef __GUESTLAZY_H_ +#define __GUESTLAZY_H_ + +#include + +#include "elf.h" +#include "guestpatch.h" + +typedef struct elfheader_s elfheader_t; +typedef struct CPUX86State CPUX86State; +typedef struct bridge_s bridge_t; + +typedef struct KztLazyBinding_s KztLazyBinding; + +typedef struct KztLazyResolvePlan_s { + int opaque_policy; + int opaque_reason; +} KztLazyResolvePlan; + +typedef struct KztLazyResolveResult_s { + int opaque_policy; + int opaque_reason; + uintptr_t opaque_target; +} KztLazyResolveResult; + +typedef struct KztLazyRelocationSymbolArgs_s { + elfheader_t *head; + Elf64_Sym *symbol_entry; + const char *symbol; + int bind; + int relocation_type; + uintptr_t current_target; + int version; + const char *version_name; +} KztLazyRelocationSymbolArgs; + +typedef struct KztLazyPltSymbolArgs_s { + elfheader_t *head; + const char *symbol; + int version; + const char *version_name; +} KztLazyPltSymbolArgs; + +typedef struct KztLazySymbolLookupPlan_s { + int has_relocation_symbol; + KztLazyRelocationSymbolArgs relocation_args; + KztLazyPltSymbolArgs plt_args; +} KztLazySymbolLookupPlan; + +typedef struct KztLazyPatchArgs_s { + elfheader_t *head; + const Elf64_Rela *relocation; + size_t relocation_index; + int relocation_type; + const char *symbol; + int version; + const char *version_name; + uintptr_t slot; + uintptr_t old_target; +} KztLazyPatchArgs; + +typedef struct KztLazyResolverInstallPlan_s { + KztLazyPatchArgs resolver_args; + uintptr_t resolver_bridge; + KztLazyPatchArgs link_map_args; + uintptr_t link_map; + const char *table_name; + uintptr_t resolver_slot; +} KztLazyResolverInstallPlan; + +typedef struct KztLazyTargetPatchPlan_s { + KztLazyPatchArgs args; + uintptr_t target; + KztPatchDecisionReason reason; + int has_target_slot; +} KztLazyTargetPatchPlan; + +typedef struct KztLazyRelocationPatchPlan_s { + KztLazyPatchArgs args; + long addend; + KztPatchDecisionReason reason; + const char *scope_name; +} KztLazyRelocationPatchPlan; + +typedef KztLazyResolveResult (*KztLazyPatchCurrentTargetFn)( + KztLazyBinding *binding); +typedef void (*KztLazyRelocationHandlerFn)( + void *opaque, const KztLazyBinding *binding); + +void KztLazyHandleRelocation(elfheader_t *head, + const Elf64_Rela *relocation, + int slot, + int bind, + const char *symbol, + int version, + const char *version_name, + uint64_t *target_slot, + int bindnow, + const int *need_resolv, + KztLazyRelocationHandlerFn handler, + void *opaque); +KztLazySymbolLookupPlan KztLazyPrepareSymbolLookup( + const KztLazyBinding *binding); +void KztLazyLogRelocationPatch( + const KztLazyRelocationPatchPlan *patch_plan, + uintptr_t bridge); +void KztLazyLogDeferredRelocation(const KztLazyBinding *binding); +void KztLazyLogMissingRelocationSlot(const KztLazyBinding *binding); +void KztLazyLogResolvePatch(const KztLazyBinding *binding, + uintptr_t target, + const char *owner, + const KztLazyResolvePlan *plan); +void KztLazyLogResolveMissingSlot(const KztLazyBinding *binding, + const KztLazyResolvePlan *plan); +void KztLazyLogResolveGuestFallback(const KztLazyBinding *binding, + const KztLazyResolvePlan *plan); +int KztLazyRefreshCurrentBinding(KztLazyBinding *binding); +int KztLazyBindingShouldDefer(const KztLazyBinding *binding); +uintptr_t KztLazyEnsureResolverBridge( + bridge_t *bridge, KztLazyPatchCurrentTargetFn callback); +int KztLazyPrepareResolverInstall( + elfheader_t *head, + KztLazyResolverInstallPlan *plan); +KztLazyResolveResult KztLazyResolveResultFromPlan( + const KztLazyResolvePlan *plan); +KztLazyResolveResult KztLazyResolveResultFromBridgePatch( + const KztLazyBinding *binding, + const KztLazyResolvePlan *plan, + uintptr_t bridge, + KztLazyTargetPatchPlan *patch_plan); +KztLazyResolvePlan KztLazySelectResolvePlan( + const KztLazyBinding *binding, int has_bridge); +int KztLazyResolvePlanUsesGuestFallback( + const KztLazyResolvePlan *plan); +int KztLazyPrepareRelocationPatch( + const KztLazyBinding *binding, + KztLazyRelocationPatchPlan *patch_plan); +int KztLazyPrepareDeferredPatch( + const KztLazyBinding *binding, + KztLazyTargetPatchPlan *patch_plan); +int KztLazyPrepareUnresolvedPatch( + const KztLazyBinding *binding, + KztPatchDecisionReason reason, + KztLazyTargetPatchPlan *patch_plan); + +#endif //__GUESTLAZY_H_ diff --git a/target/i386/latx/include/guestobject.h b/target/i386/latx/include/guestobject.h new file mode 100644 index 00000000000..713f9a4fdcb --- /dev/null +++ b/target/i386/latx/include/guestobject.h @@ -0,0 +1,73 @@ +#ifndef __GUESTOBJECT_H_ +#define __GUESTOBJECT_H_ + +#include + +typedef struct guest_object_registry_s guest_object_registry_t; + +typedef enum guest_object_state_e { + GUEST_OBJECT_DISCOVERED = 0, + GUEST_OBJECT_PROCESSING, + GUEST_OBJECT_WRAPPED, + GUEST_OBJECT_EMULATED, + GUEST_OBJECT_FAILED, +} guest_object_state_t; + +typedef enum guest_object_observation_e { + GUEST_OBJECT_OBSERVE_INVALID = -1, + GUEST_OBJECT_OBSERVE_UNCHANGED = 0, + GUEST_OBJECT_OBSERVE_NEW, + GUEST_OBJECT_OBSERVE_CHANGED, +} guest_object_observation_t; + +typedef enum guest_object_process_result_e { + GUEST_OBJECT_PROCESS_INVALID = -1, + GUEST_OBJECT_PROCESS_STARTED = 0, + GUEST_OBJECT_PROCESS_IN_PROGRESS, + GUEST_OBJECT_PROCESS_DONE, +} guest_object_process_result_t; + +typedef struct guest_object_lookup_s { + uintptr_t link_map_addr; + uintptr_t load_bias; + uintptr_t dynamic_addr; + uintptr_t map_start; + uintptr_t map_end; + const char *name; + guest_object_state_t state; + unsigned long generation; +} guest_object_lookup_t; + +guest_object_registry_t *NewGuestObjectRegistry(void); +void FreeGuestObjectRegistry(guest_object_registry_t **registry); + +guest_object_observation_t ObserveGuestObject( + guest_object_registry_t *registry, + uintptr_t link_map_addr, + uintptr_t load_bias, + uintptr_t dynamic_addr, + const char *name); + +int SetGuestObjectMapRange( + guest_object_registry_t *registry, + uintptr_t link_map_addr, + uintptr_t map_start, + uintptr_t map_end); + +int LookupGuestObjectByAddress( + guest_object_registry_t *registry, + uintptr_t addr, + guest_object_lookup_t *lookup); + +guest_object_process_result_t BeginGuestObjectProcessing( + guest_object_registry_t *registry, + uintptr_t link_map_addr); + +int SetGuestObjectState( + guest_object_registry_t *registry, + uintptr_t link_map_addr, + guest_object_state_t state); + +const char *GuestObjectStateName(guest_object_state_t state); + +#endif diff --git a/target/i386/latx/include/guestpatch.h b/target/i386/latx/include/guestpatch.h new file mode 100644 index 00000000000..d7934a7159e --- /dev/null +++ b/target/i386/latx/include/guestpatch.h @@ -0,0 +1,105 @@ +#ifndef __GUESTPATCH_H_ +#define __GUESTPATCH_H_ + +#include +#include + +#include "elf.h" + +typedef enum KztPatchDecisionReason { + KZT_PATCH_REASON_NONE, + KZT_PATCH_REASON_LOCAL_SYMBOL, + KZT_PATCH_REASON_GLOBAL_SYMBOL, + KZT_PATCH_REASON_LAZY_BINDING_DEFERRED, + KZT_PATCH_REASON_LAZY_BINDING_RESOLVED, + KZT_PATCH_REASON_LAZY_BINDING_CURRENT_TARGET, + KZT_PATCH_REASON_PLT_RESOLVER, + KZT_PATCH_REASON_GUEST_OWNER_TARGET, + KZT_PATCH_REASON_SYMBOL_MISSING, + KZT_PATCH_REASON_UNSUPPORTED_RELOCATION, +} KztPatchDecisionReason; + +typedef enum KztPatchOwnerRelation { + KZT_PATCH_OWNER_RELATION_UNKNOWN, + KZT_PATCH_OWNER_RELATION_GUEST_ONLY, + KZT_PATCH_OWNER_RELATION_MAPLIB_ONLY, + KZT_PATCH_OWNER_RELATION_MATCH, + KZT_PATCH_OWNER_RELATION_MISMATCH, +} KztPatchOwnerRelation; + +typedef enum KztPatchShadowResult { + KZT_PATCH_SHADOW_DISABLED, + KZT_PATCH_SHADOW_NO_MAPLIB_TARGET, + KZT_PATCH_SHADOW_NO_GUEST_OWNER, + KZT_PATCH_SHADOW_SELF_PLT, + KZT_PATCH_SHADOW_NO_WRAPPER, + KZT_PATCH_SHADOW_NO_LIBRARY, + KZT_PATCH_SHADOW_SYMBOL_MISSING, + KZT_PATCH_SHADOW_MATCH, + KZT_PATCH_SHADOW_MISMATCH, +} KztPatchShadowResult; + +typedef enum KztPatchTargetSource { + KZT_PATCH_TARGET_MAPLIB, + KZT_PATCH_TARGET_GUEST_OWNER, +} KztPatchTargetSource; + +typedef struct KztPatchDecision { + const char *object; + uintptr_t object_base; + const void *relocation; + size_t relocation_index; + int relocation_type; + const char *symbol; + int symbol_version; + const char *symbol_version_name; + uintptr_t slot; + uintptr_t old_target; + const char *old_owner; + uintptr_t old_owner_base; + const char *old_guest_object; + uintptr_t old_guest_object_base; + uintptr_t maplib_bridge; + const char *maplib_owner; + uintptr_t maplib_owner_base; + KztPatchOwnerRelation maplib_owner_relation; + uintptr_t new_bridge; + const char *new_owner; + uintptr_t new_owner_base; + uintptr_t guest_owner_bridge; + const char *guest_owner_library; + const char *guest_owner; + uintptr_t guest_owner_base; + KztPatchOwnerRelation guest_owner_relation; + KztPatchDecisionReason reason; + KztPatchOwnerRelation owner_relation; + KztPatchShadowResult shadow_result; + KztPatchTargetSource target_source; +} KztPatchDecision; + +void KztPatchDecisionInit(KztPatchDecision *decision); +int KztPatchDecisionHasTarget(const KztPatchDecision *decision); +void KztPatchDecisionSetMaplibTarget(KztPatchDecision *decision, + uintptr_t bridge, + const char *owner, + uintptr_t owner_base); +void KztPatchDecisionSetGuestOwnerFailure(KztPatchDecision *decision, + KztPatchShadowResult failure); +void KztPatchDecisionSetGuestOwnerTarget(KztPatchDecision *decision, + uintptr_t bridge, + const char *library, + const char *owner, + uintptr_t owner_base, + int select_target); +void KztPatchDecisionSelectGuestOwnerTarget(KztPatchDecision *decision); +KztPatchOwnerRelation KztPatchOwnerRelationForNames(const char *guest_object, + const char *owner); +const char *KztPatchDecisionReasonName(KztPatchDecisionReason reason); +const char *KztPatchOwnerRelationName(KztPatchOwnerRelation relation); +const char *KztPatchShadowResultName(KztPatchShadowResult result); +const char *KztPatchTargetSourceName(KztPatchTargetSource source); +const char *KztPatchRelocationTypeName(int relocation_type); +size_t KztFormatPatchDecision(char *buffer, size_t buffer_size, + const KztPatchDecision *decision); + +#endif //__GUESTPATCH_H_ diff --git a/target/i386/latx/include/hbr.h b/target/i386/latx/include/hbr.h index 12c58cd2cb8..edd998a93fa 100644 --- a/target/i386/latx/include/hbr.h +++ b/target/i386/latx/include/hbr.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file hbr.h * @author wwq diff --git a/target/i386/latx/include/imm-cache.h b/target/i386/latx/include/imm-cache.h index 586892bb628..bb699881687 100644 --- a/target/i386/latx/include/imm-cache.h +++ b/target/i386/latx/include/imm-cache.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file imm-cache.h * @author liuxinpeng diff --git a/target/i386/latx/include/insts-pattern.h b/target/i386/latx/include/insts-pattern.h index 6f997629fac..4ccca5f45c4 100644 --- a/target/i386/latx/include/insts-pattern.h +++ b/target/i386/latx/include/insts-pattern.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file insts-pattern.h * @author huqi diff --git a/target/i386/latx/include/ir1-optimization.h b/target/i386/latx/include/ir1-optimization.h index 4d138aa903e..6305b114395 100644 --- a/target/i386/latx/include/ir1-optimization.h +++ b/target/i386/latx/include/ir1-optimization.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _IR1_OPTIMIZATION_H_ #define _IR1_OPTIMIZATION_H_ diff --git a/target/i386/latx/include/ir1.h b/target/i386/latx/include/ir1.h index 53533edc08d..d1efe26b121 100644 --- a/target/i386/latx/include/ir1.h +++ b/target/i386/latx/include/ir1.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _IR1_H_ #define _IR1_H_ diff --git a/target/i386/latx/include/ir2-la-assemble.h b/target/i386/latx/include/ir2-la-assemble.h index 3514f25ed36..72d1c57f2d6 100644 --- a/target/i386/latx/include/ir2-la-assemble.h +++ b/target/i386/latx/include/ir2-la-assemble.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef __LISA_ASSEMBLE_H_ #define __LISA_ASSEMBLE_H_ diff --git a/target/i386/latx/include/ir2-relocate.h b/target/i386/latx/include/ir2-relocate.h index a6dcb1b289d..fc1fa086607 100644 --- a/target/i386/latx/include/ir2-relocate.h +++ b/target/i386/latx/include/ir2-relocate.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _IR2_RELOCATE_H_ #define _IR2_RELOCATE_H_ #include diff --git a/target/i386/latx/include/ir2.h b/target/i386/latx/include/ir2.h index bd8823bb585..f188ae84f90 100644 --- a/target/i386/latx/include/ir2.h +++ b/target/i386/latx/include/ir2.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _IR2_H_ #define _IR2_H_ diff --git a/target/i386/latx/include/jrra-translator.h b/target/i386/latx/include/jrra-translator.h index 862e149823c..14cb927884f 100644 --- a/target/i386/latx/include/jrra-translator.h +++ b/target/i386/latx/include/jrra-translator.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _JRRA_TRANSLATOR_H_ #define _JRRA_TRANSLATOR_H_ diff --git a/target/i386/latx/include/jrra.h b/target/i386/latx/include/jrra.h index 4b81cd5254e..3e748025519 100644 --- a/target/i386/latx/include/jrra.h +++ b/target/i386/latx/include/jrra.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file jrra.h * @author Hanlu Li diff --git a/target/i386/latx/include/khash.h b/target/i386/latx/include/khash.h index 68f288fc08b..01a848591a3 100755 --- a/target/i386/latx/include/khash.h +++ b/target/i386/latx/include/khash.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2008, 2009, 2011 Attractive Chaos + * + * SPDX-License-Identifier: MIT + */ + /* The MIT License Copyright (c) 2008, 2009, 2011 by Attractive Chaos diff --git a/target/i386/latx/include/la-ir2.h b/target/i386/latx/include/la-ir2.h index 3b5136ed732..794e03845eb 100644 --- a/target/i386/latx/include/la-ir2.h +++ b/target/i386/latx/include/la-ir2.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef __LA_IR2_H_ #define __LA_IR2_H_ diff --git a/target/i386/latx/include/lacapstone.h b/target/i386/latx/include/lacapstone.h index 1b62d59b83e..5fc78255dd7 100644 --- a/target/i386/latx/include/lacapstone.h +++ b/target/i386/latx/include/lacapstone.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef LATX_DISASSEMBLE_LACAPSTONE_H #define LATX_DISASSEMBLE_LACAPSTONE_H #include "latx-disassemble-trace.h" diff --git a/target/i386/latx/include/latx-backtrace.h b/target/i386/latx/include/latx-backtrace.h index 1174dfc112c..80d524751dd 100644 --- a/target/i386/latx/include/latx-backtrace.h +++ b/target/i386/latx/include/latx-backtrace.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _LATX_BACKTRACE_H_ #define _LATX_BACKTRACE_H_ void print_stack_trace(void); diff --git a/target/i386/latx/include/latx-config.h b/target/i386/latx/include/latx-config.h index 22a0f893520..73eb151eca9 100644 --- a/target/i386/latx/include/latx-config.h +++ b/target/i386/latx/include/latx-config.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _LATX_CONFIG_H_ #define _LATX_CONFIG_H_ diff --git a/target/i386/latx/include/latx-debug.h b/target/i386/latx/include/latx-debug.h index 7d5fe833e26..8cb08b0e60c 100644 --- a/target/i386/latx/include/latx-debug.h +++ b/target/i386/latx/include/latx-debug.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _LATX_DEBUG_H_ #define _LATX_DEBUG_H_ extern int option_debug_lative; diff --git a/target/i386/latx/include/latx-disassemble-trace.h b/target/i386/latx/include/latx-disassemble-trace.h index a3f15d7b332..5bfa647e2de 100644 --- a/target/i386/latx/include/latx-disassemble-trace.h +++ b/target/i386/latx/include/latx-disassemble-trace.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef LATX_DISASSEMBLE_TRACE_H #define LATX_DISASSEMBLE_TRACE_H @@ -12,11 +18,9 @@ #define OPT_V1LACAPSTONE (1 << 0) #define OPT_V1NEXTCAPSTONE (1 << 1) -#define OPT_V1LAXED (1 << 2) #define OPT_V1LAZYDIS (1 << 3) #define OPT_V2LACAPSTONE (1 << 16) #define OPT_V2NEXTCAPSTONE (1 << 17) -#define OPT_V2LAXED (1 << 18) #define OPT_V2LAZYDIS (1 << 19) #ifdef CONFIG_LATX_DEBUG @@ -151,7 +155,6 @@ void disassemble_trace_loop(const uint8_t *code, size_t code_size, void lacapstone_init(int abi_bits); void nextcapstone_init(int abi_bits); void gitcapstone_init(int abi_bits); -void laxed_init(int abi_bits); void lazydis_init(int abi_bits); int lacapstone_get(const uint8_t *code, size_t code_size, uint64_t address, @@ -165,10 +168,6 @@ int nextcapstone_get(const uint8_t *code, size_t code_size, uint64_t address, size_t count, struct la_dt_insn **insn, int ir1_num, void *pir1_base); -int laxed_get(const uint8_t *code, size_t code_size, - uint64_t address, - size_t count, struct la_dt_insn **insn, - int ir1_num, void *pir1_base, int mode); int lazydis_get(const uint8_t *code, size_t code_size, uint64_t address, size_t count, struct la_dt_insn **insn, diff --git a/target/i386/latx/include/latx-native-asm.h b/target/i386/latx/include/latx-native-asm.h index 43209103719..0961344956f 100644 --- a/target/i386/latx/include/latx-native-asm.h +++ b/target/i386/latx/include/latx-native-asm.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _LATX_NATIVE_ASM_H_ #define _LATX_NATIVE_ASM_H_ diff --git a/target/i386/latx/include/latx-options.h b/target/i386/latx/include/latx-options.h index bbe3756c178..e9913988618 100644 --- a/target/i386/latx/include/latx-options.h +++ b/target/i386/latx/include/latx-options.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _LATX_OPTIONS_H_ #define _LATX_OPTIONS_H_ @@ -90,6 +96,11 @@ extern unsigned long long counter_tb_tr; extern unsigned long long counter_ir1_tr; extern unsigned long long counter_mips_tr; +#if defined(CONFIG_LATX_KZT) +extern int option_kzt_patch_guest_owner; +extern int option_kzt_patch_shadow; +#endif + #ifdef CONFIG_LATX #define ENVSUP_LATX \ ENVFUN(LATX_OPTIMIZE, handle_arg_optimize) \ @@ -125,7 +136,9 @@ extern unsigned long long counter_mips_tr; #if defined(CONFIG_LATX) && defined(CONFIG_LATX_KZT) #define ENVSUP_KZT \ - ENVFUN(LATX_KZT, handle_arg_latx_kzt) + ENVFUN(LATX_KZT, handle_arg_latx_kzt) \ + ENVFUN(LATX_KZT_PATCH_GUEST_OWNER, handle_arg_latx_kzt_patch_guest_owner) \ + ENVFUN(LATX_KZT_PATCH_SHADOW, handle_arg_latx_kzt_patch_shadow) #else #define ENVSUP_KZT #endif diff --git a/target/i386/latx/include/latx-perf.h b/target/i386/latx/include/latx-perf.h index 36db74109cf..71d82860179 100644 --- a/target/i386/latx/include/latx-perf.h +++ b/target/i386/latx/include/latx-perf.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file latx-perf.h * @author Hanlu Li diff --git a/target/i386/latx/include/latx-signal.h b/target/i386/latx/include/latx-signal.h index 02046954866..502be8ff581 100644 --- a/target/i386/latx/include/latx-signal.h +++ b/target/i386/latx/include/latx-signal.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file latx-signal.h * @author Hanlu Li diff --git a/target/i386/latx/include/latx-smc.h b/target/i386/latx/include/latx-smc.h index 78fa183b074..25f8910f1e3 100644 --- a/target/i386/latx/include/latx-smc.h +++ b/target/i386/latx/include/latx-smc.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _LATX_SMC_H_ #define _LATX_SMC_H_ diff --git a/target/i386/latx/include/latx-types.h b/target/i386/latx/include/latx-types.h index 70b2ea87634..5fb14b8041d 100644 --- a/target/i386/latx/include/latx-types.h +++ b/target/i386/latx/include/latx-types.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _TYPES_H_ #define _TYPES_H_ diff --git a/target/i386/latx/include/laxed.h b/target/i386/latx/include/laxed.h deleted file mode 100644 index a947bbb7e20..00000000000 --- a/target/i386/latx/include/laxed.h +++ /dev/null @@ -1,7 +0,0 @@ -#ifndef LAXED_H -#define LAXED_H -#include "latx-disassemble-trace.h" -#include "xed/xed-interface.h" -struct la_dt_insn *laxed_get_from_insn(int64_t address, xed_decoded_inst_t *inputinfo, - int ir1_num, void *pir1_base); -#endif diff --git a/target/i386/latx/include/lazydis.h b/target/i386/latx/include/lazydis.h index 66836ba8656..2115c2b6fb0 100644 --- a/target/i386/latx/include/lazydis.h +++ b/target/i386/latx/include/lazydis.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef LA_ZYDIS_H #define LA_ZYDIS_H #include "latx-disassemble-trace.h" diff --git a/target/i386/latx/include/library_private.h b/target/i386/latx/include/library_private.h index 7ba6e4ce5e7..77a4683eece 100755 --- a/target/i386/latx/include/library_private.h +++ b/target/i386/latx/include/library_private.h @@ -82,7 +82,7 @@ typedef struct library_s { needed_libs_t depended; // used to free library lib_t *maplib; // local maplib, for dlopen'd library with LOCAL binding (most of the dlopen) struct link_map *x86linkmap; - int x86dlopenflag; //for redlopen + int x86dlopenflag; // guest dlopen flags for dlsym reopen } library_t; // type for map elements diff --git a/target/i386/latx/include/lsenv.h b/target/i386/latx/include/lsenv.h index aba9dd6db83..d765d4733b0 100644 --- a/target/i386/latx/include/lsenv.h +++ b/target/i386/latx/include/lsenv.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _LSENV_H_ #define _LSENV_H_ diff --git a/target/i386/latx/include/macro-inst.h b/target/i386/latx/include/macro-inst.h index 94932491a44..37117e49c26 100644 --- a/target/i386/latx/include/macro-inst.h +++ b/target/i386/latx/include/macro-inst.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _MACRO_INST_H_ #define _MACRO_INST_H_ #include "aot.h" diff --git a/target/i386/latx/include/mem.h b/target/i386/latx/include/mem.h index 5c056a003cc..60853592cb7 100644 --- a/target/i386/latx/include/mem.h +++ b/target/i386/latx/include/mem.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _MEM_H_ #define _MEM_H_ diff --git a/target/i386/latx/include/nextcapstone.h b/target/i386/latx/include/nextcapstone.h index 898727cde55..32d818eba57 100644 --- a/target/i386/latx/include/nextcapstone.h +++ b/target/i386/latx/include/nextcapstone.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef LATX_DISASSEMBLE_FROM_NEXTCAPSTONE_H #define LATX_DISASSEMBLE_FROM_NEXTCAPSTONE_H #include "latx-disassemble-trace.h" diff --git a/target/i386/latx/include/optimize-config.h b/target/i386/latx/include/optimize-config.h index cd22580ab38..e6abfa1e07f 100644 --- a/target/i386/latx/include/optimize-config.h +++ b/target/i386/latx/include/optimize-config.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file optimize-config.h * @author huqi diff --git a/target/i386/latx/include/pclmul.h b/target/i386/latx/include/pclmul.h index c4a584a6a56..d300330f3a1 100644 --- a/target/i386/latx/include/pclmul.h +++ b/target/i386/latx/include/pclmul.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _PCLMUL_H_ #define _PCLMUL_H_ diff --git a/target/i386/latx/include/profile.h b/target/i386/latx/include/profile.h index 1cb8428cc82..185b7ee6e44 100644 --- a/target/i386/latx/include/profile.h +++ b/target/i386/latx/include/profile.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _PROFILE_H_ #define _PROFILE_H_ diff --git a/target/i386/latx/include/qemu-def.h b/target/i386/latx/include/qemu-def.h index e2980942b6a..535e02e5e4a 100644 --- a/target/i386/latx/include/qemu-def.h +++ b/target/i386/latx/include/qemu-def.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _QEMU_DEF_H_ #define _QEMU_DEF_H_ diff --git a/target/i386/latx/include/reg-alloc.h b/target/i386/latx/include/reg-alloc.h index f8ba84bb047..4c996d3dd3e 100644 --- a/target/i386/latx/include/reg-alloc.h +++ b/target/i386/latx/include/reg-alloc.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file reg-alloc.h * @author Hanlu Li diff --git a/target/i386/latx/include/reg-map.h b/target/i386/latx/include/reg-map.h index b9afc3046b0..58c41396887 100644 --- a/target/i386/latx/include/reg-map.h +++ b/target/i386/latx/include/reg-map.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file reg-map.h * @author Hanlu Li diff --git a/target/i386/latx/include/runtime-trace.h b/target/i386/latx/include/runtime-trace.h index cd2fa9eb8cf..c20abc6ad5c 100644 --- a/target/i386/latx/include/runtime-trace.h +++ b/target/i386/latx/include/runtime-trace.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include #include #include diff --git a/target/i386/latx/include/segment.h b/target/i386/latx/include/segment.h index 74914c58f05..fd8a065682f 100644 --- a/target/i386/latx/include/segment.h +++ b/target/i386/latx/include/segment.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef __SEGMENT_H_ #define __SEGMENT_H_ diff --git a/target/i386/latx/include/super80.h b/target/i386/latx/include/super80.h index b6f7f9658ed..4d85a8c7859 100644 --- a/target/i386/latx/include/super80.h +++ b/target/i386/latx/include/super80.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #define SUPER() \ GO(0) \ GO(1) \ diff --git a/target/i386/latx/include/syscall-tunnel.h b/target/i386/latx/include/syscall-tunnel.h index 42d7c7f11d7..6983e5d5de8 100644 --- a/target/i386/latx/include/syscall-tunnel.h +++ b/target/i386/latx/include/syscall-tunnel.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _SYSCALL_TUNNEL_H_ #define _SYSCALL_TUNNEL_H_ diff --git a/target/i386/latx/include/tb-dump.h b/target/i386/latx/include/tb-dump.h index ac5ef9f59a7..fc6e9dd00ae 100644 --- a/target/i386/latx/include/tb-dump.h +++ b/target/i386/latx/include/tb-dump.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef __TB_DUMP_H_ #define __TB_DUMP_H_ diff --git a/target/i386/latx/include/translate.h b/target/i386/latx/include/translate.h index ab17ecd4951..dfb8c11269b 100644 --- a/target/i386/latx/include/translate.h +++ b/target/i386/latx/include/translate.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef _TRANSLATE_H_ #define _TRANSLATE_H_ diff --git a/target/i386/latx/include/ts.h b/target/i386/latx/include/ts.h index c4bf45ef4c9..98051886cd2 100644 --- a/target/i386/latx/include/ts.h +++ b/target/i386/latx/include/ts.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file ts.h * @author wwq diff --git a/target/i386/latx/include/tu.h b/target/i386/latx/include/tu.h index b3d7092525b..5daa95f1867 100644 --- a/target/i386/latx/include/tu.h +++ b/target/i386/latx/include/tu.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file tu.h * @author wwq diff --git a/target/i386/latx/include/tunnel_lib.h b/target/i386/latx/include/tunnel_lib.h index 049dbb305dc..9d1637f74aa 100644 --- a/target/i386/latx/include/tunnel_lib.h +++ b/target/i386/latx/include/tunnel_lib.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "include/exec/user/abitypes.h" #include diff --git a/target/i386/latx/include/x86.h b/target/i386/latx/include/x86.h index 946268a1a5c..07953cbea41 100644 --- a/target/i386/latx/include/x86.h +++ b/target/i386/latx/include/x86.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef CAPSTONE_dt_X86_H #define CAPSTONE_dt_X86_H diff --git a/target/i386/latx/include/xed/xed-address-width-enum.h b/target/i386/latx/include/xed/xed-address-width-enum.h deleted file mode 100644 index 2931930180a..00000000000 --- a/target/i386/latx/include/xed/xed-address-width-enum.h +++ /dev/null @@ -1,54 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-address-width-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_ADDRESS_WIDTH_ENUM_H) -# define XED_ADDRESS_WIDTH_ENUM_H -#include "xed-common-hdrs.h" -#define XED_ADDRESS_WIDTH_INVALID_DEFINED 1 -#define XED_ADDRESS_WIDTH_16b_DEFINED 1 -#define XED_ADDRESS_WIDTH_32b_DEFINED 1 -#define XED_ADDRESS_WIDTH_64b_DEFINED 1 -#define XED_ADDRESS_WIDTH_LAST_DEFINED 1 -typedef enum { - XED_ADDRESS_WIDTH_INVALID=0, - XED_ADDRESS_WIDTH_16b=2, ///< 16b addressing - XED_ADDRESS_WIDTH_32b=4, ///< 32b addressing - XED_ADDRESS_WIDTH_64b=8, ///< 64b addressing - XED_ADDRESS_WIDTH_LAST -} xed_address_width_enum_t; - -/// This converts strings to #xed_address_width_enum_t types. -/// @param s A C-string. -/// @return #xed_address_width_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_address_width_enum_t str2xed_address_width_enum_t(const char* s); -/// This converts strings to #xed_address_width_enum_t types. -/// @param p An enumeration element of type xed_address_width_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_address_width_enum_t2str(const xed_address_width_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_address_width_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_address_width_enum_t xed_address_width_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-agen.h b/target/i386/latx/include/xed/xed-agen.h deleted file mode 100644 index e24092b3ea3..00000000000 --- a/target/i386/latx/include/xed/xed-agen.h +++ /dev/null @@ -1,66 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-agen.h -/// - - -#ifndef XED_AGEN_H -# define XED_AGEN_H -#include "xed-decoded-inst.h" -#include "xed-error-enum.h" - - -/// A function for obtaining register values. 32b return values should be -/// zero extended to 64b. The error value is set to nonzero if the callback -/// experiences some sort of problem. @ingroup AGEN -typedef xed_uint64_t (*xed_register_callback_fn_t)(xed_reg_enum_t reg, - void* context, - xed_bool_t* error); - -/// A function for obtaining the segment base values. 32b return values -/// should be zero extended zero extended to 64b. The error value is set to -/// nonzero if the callback experiences some sort of problem. -/// @ingroup AGEN -typedef xed_uint64_t (*xed_segment_base_callback_fn_t)(xed_reg_enum_t reg, - void* context, - xed_bool_t* error); - - -/// Initialize the callback functions. Tell XED what to call when using -/// #xed_agen. -/// @ingroup AGEN -XED_DLL_EXPORT void xed_agen_register_callback(xed_register_callback_fn_t register_fn, - xed_segment_base_callback_fn_t segment_fn); - -/// Using the registered callbacks, compute the memory address for a -/// specified memop in a decoded instruction. memop_index can have the -/// value 0 for XED_OPERAND_MEM0, XED_OPERAND_AGEN, or 1 for -/// XED_OPERAND_MEM1. Any other value results in an error being -/// returned. The context parameter which is passed to the registered -/// callbacks can be used to identify which thread's state is being -/// referenced. The context parameter can also be used to specify which -/// element of a vector register should be returned for gather an scatter -/// operations. -/// @ingroup AGEN -XED_DLL_EXPORT xed_error_enum_t xed_agen(xed_decoded_inst_t* xedd, - unsigned int memop_index, - void* context, - xed_uint64_t* out_address); - - -#endif diff --git a/target/i386/latx/include/xed/xed-attribute-enum.h b/target/i386/latx/include/xed/xed-attribute-enum.h deleted file mode 100644 index be354c95731..00000000000 --- a/target/i386/latx/include/xed/xed-attribute-enum.h +++ /dev/null @@ -1,234 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-attribute-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_ATTRIBUTE_ENUM_H) -# define XED_ATTRIBUTE_ENUM_H -#include "xed-common-hdrs.h" -#define XED_ATTRIBUTE_INVALID_DEFINED 1 -#define XED_ATTRIBUTE_AMDONLY_DEFINED 1 -#define XED_ATTRIBUTE_ATT_OPERAND_ORDER_EXCEPTION_DEFINED 1 -#define XED_ATTRIBUTE_BROADCAST_ENABLED_DEFINED 1 -#define XED_ATTRIBUTE_BYTEOP_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_EIGHTHMEM_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_FULL_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_FULLMEM_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_GPR_READER_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_GPR_READER_BYTE_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_GPR_READER_WORD_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_GPR_WRITER_LDOP_D_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_GPR_WRITER_LDOP_Q_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_GPR_WRITER_STORE_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_GPR_WRITER_STORE_BYTE_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_GPR_WRITER_STORE_WORD_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_GSCAT_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_HALF_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_HALFMEM_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_MEM128_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_MOVDDUP_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_QUARTER_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_QUARTERMEM_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_SCALAR_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_TUPLE1_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_TUPLE1_4X_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_TUPLE1_BYTE_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_TUPLE1_WORD_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_TUPLE2_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_TUPLE4_DEFINED 1 -#define XED_ATTRIBUTE_DISP8_TUPLE8_DEFINED 1 -#define XED_ATTRIBUTE_DOUBLE_WIDE_MEMOP_DEFINED 1 -#define XED_ATTRIBUTE_DOUBLE_WIDE_OUTPUT_DEFINED 1 -#define XED_ATTRIBUTE_DWORD_INDICES_DEFINED 1 -#define XED_ATTRIBUTE_ELEMENT_SIZE_D_DEFINED 1 -#define XED_ATTRIBUTE_ELEMENT_SIZE_Q_DEFINED 1 -#define XED_ATTRIBUTE_EXCEPTION_BR_DEFINED 1 -#define XED_ATTRIBUTE_FAR_XFER_DEFINED 1 -#define XED_ATTRIBUTE_FIXED_BASE0_DEFINED 1 -#define XED_ATTRIBUTE_FIXED_BASE1_DEFINED 1 -#define XED_ATTRIBUTE_GATHER_DEFINED 1 -#define XED_ATTRIBUTE_HALF_WIDE_OUTPUT_DEFINED 1 -#define XED_ATTRIBUTE_HLE_ACQ_ABLE_DEFINED 1 -#define XED_ATTRIBUTE_HLE_REL_ABLE_DEFINED 1 -#define XED_ATTRIBUTE_IGNORES_OSFXSR_DEFINED 1 -#define XED_ATTRIBUTE_IMPLICIT_ONE_DEFINED 1 -#define XED_ATTRIBUTE_INDEX_REG_IS_POINTER_DEFINED 1 -#define XED_ATTRIBUTE_INDIRECT_BRANCH_DEFINED 1 -#define XED_ATTRIBUTE_KMASK_DEFINED 1 -#define XED_ATTRIBUTE_LOCKABLE_DEFINED 1 -#define XED_ATTRIBUTE_LOCKED_DEFINED 1 -#define XED_ATTRIBUTE_MASKOP_DEFINED 1 -#define XED_ATTRIBUTE_MASKOP_EVEX_DEFINED 1 -#define XED_ATTRIBUTE_MASK_AS_CONTROL_DEFINED 1 -#define XED_ATTRIBUTE_MASK_VARIABLE_MEMOP_DEFINED 1 -#define XED_ATTRIBUTE_MEMORY_FAULT_SUPPRESSION_DEFINED 1 -#define XED_ATTRIBUTE_MMX_EXCEPT_DEFINED 1 -#define XED_ATTRIBUTE_MPX_PREFIX_ABLE_DEFINED 1 -#define XED_ATTRIBUTE_MULTIDEST2_DEFINED 1 -#define XED_ATTRIBUTE_MULTISOURCE4_DEFINED 1 -#define XED_ATTRIBUTE_MXCSR_DEFINED 1 -#define XED_ATTRIBUTE_MXCSR_RD_DEFINED 1 -#define XED_ATTRIBUTE_NONTEMPORAL_DEFINED 1 -#define XED_ATTRIBUTE_NOP_DEFINED 1 -#define XED_ATTRIBUTE_NOTSX_DEFINED 1 -#define XED_ATTRIBUTE_NOTSX_COND_DEFINED 1 -#define XED_ATTRIBUTE_NO_RIP_REL_DEFINED 1 -#define XED_ATTRIBUTE_NO_SRC_DEST_MATCH_DEFINED 1 -#define XED_ATTRIBUTE_PREFETCH_DEFINED 1 -#define XED_ATTRIBUTE_PROTECTED_MODE_DEFINED 1 -#define XED_ATTRIBUTE_QWORD_INDICES_DEFINED 1 -#define XED_ATTRIBUTE_REP_DEFINED 1 -#define XED_ATTRIBUTE_REQUIRES_ALIGNMENT_DEFINED 1 -#define XED_ATTRIBUTE_RING0_DEFINED 1 -#define XED_ATTRIBUTE_SCALABLE_DEFINED 1 -#define XED_ATTRIBUTE_SCATTER_DEFINED 1 -#define XED_ATTRIBUTE_SIMD_SCALAR_DEFINED 1 -#define XED_ATTRIBUTE_SKIPLOW32_DEFINED 1 -#define XED_ATTRIBUTE_SKIPLOW64_DEFINED 1 -#define XED_ATTRIBUTE_SPECIAL_AGEN_REQUIRED_DEFINED 1 -#define XED_ATTRIBUTE_STACKPOP0_DEFINED 1 -#define XED_ATTRIBUTE_STACKPOP1_DEFINED 1 -#define XED_ATTRIBUTE_STACKPUSH0_DEFINED 1 -#define XED_ATTRIBUTE_STACKPUSH1_DEFINED 1 -#define XED_ATTRIBUTE_USES_DAZ_DEFINED 1 -#define XED_ATTRIBUTE_USES_FTZ_DEFINED 1 -#define XED_ATTRIBUTE_X87_CONTROL_DEFINED 1 -#define XED_ATTRIBUTE_X87_MMX_STATE_CW_DEFINED 1 -#define XED_ATTRIBUTE_X87_MMX_STATE_R_DEFINED 1 -#define XED_ATTRIBUTE_X87_MMX_STATE_W_DEFINED 1 -#define XED_ATTRIBUTE_X87_NOWAIT_DEFINED 1 -#define XED_ATTRIBUTE_XMM_STATE_CW_DEFINED 1 -#define XED_ATTRIBUTE_XMM_STATE_R_DEFINED 1 -#define XED_ATTRIBUTE_XMM_STATE_W_DEFINED 1 -#define XED_ATTRIBUTE_LAST_DEFINED 1 -typedef enum { - XED_ATTRIBUTE_INVALID, - XED_ATTRIBUTE_AMDONLY, - XED_ATTRIBUTE_ATT_OPERAND_ORDER_EXCEPTION, - XED_ATTRIBUTE_BROADCAST_ENABLED, - XED_ATTRIBUTE_BYTEOP, - XED_ATTRIBUTE_DISP8_EIGHTHMEM, - XED_ATTRIBUTE_DISP8_FULL, - XED_ATTRIBUTE_DISP8_FULLMEM, - XED_ATTRIBUTE_DISP8_GPR_READER, - XED_ATTRIBUTE_DISP8_GPR_READER_BYTE, - XED_ATTRIBUTE_DISP8_GPR_READER_WORD, - XED_ATTRIBUTE_DISP8_GPR_WRITER_LDOP_D, - XED_ATTRIBUTE_DISP8_GPR_WRITER_LDOP_Q, - XED_ATTRIBUTE_DISP8_GPR_WRITER_STORE, - XED_ATTRIBUTE_DISP8_GPR_WRITER_STORE_BYTE, - XED_ATTRIBUTE_DISP8_GPR_WRITER_STORE_WORD, - XED_ATTRIBUTE_DISP8_GSCAT, - XED_ATTRIBUTE_DISP8_HALF, - XED_ATTRIBUTE_DISP8_HALFMEM, - XED_ATTRIBUTE_DISP8_MEM128, - XED_ATTRIBUTE_DISP8_MOVDDUP, - XED_ATTRIBUTE_DISP8_QUARTER, - XED_ATTRIBUTE_DISP8_QUARTERMEM, - XED_ATTRIBUTE_DISP8_SCALAR, - XED_ATTRIBUTE_DISP8_TUPLE1, - XED_ATTRIBUTE_DISP8_TUPLE1_4X, - XED_ATTRIBUTE_DISP8_TUPLE1_BYTE, - XED_ATTRIBUTE_DISP8_TUPLE1_WORD, - XED_ATTRIBUTE_DISP8_TUPLE2, - XED_ATTRIBUTE_DISP8_TUPLE4, - XED_ATTRIBUTE_DISP8_TUPLE8, - XED_ATTRIBUTE_DOUBLE_WIDE_MEMOP, - XED_ATTRIBUTE_DOUBLE_WIDE_OUTPUT, - XED_ATTRIBUTE_DWORD_INDICES, - XED_ATTRIBUTE_ELEMENT_SIZE_D, - XED_ATTRIBUTE_ELEMENT_SIZE_Q, - XED_ATTRIBUTE_EXCEPTION_BR, - XED_ATTRIBUTE_FAR_XFER, - XED_ATTRIBUTE_FIXED_BASE0, - XED_ATTRIBUTE_FIXED_BASE1, - XED_ATTRIBUTE_GATHER, - XED_ATTRIBUTE_HALF_WIDE_OUTPUT, - XED_ATTRIBUTE_HLE_ACQ_ABLE, - XED_ATTRIBUTE_HLE_REL_ABLE, - XED_ATTRIBUTE_IGNORES_OSFXSR, - XED_ATTRIBUTE_IMPLICIT_ONE, - XED_ATTRIBUTE_INDEX_REG_IS_POINTER, - XED_ATTRIBUTE_INDIRECT_BRANCH, - XED_ATTRIBUTE_KMASK, - XED_ATTRIBUTE_LOCKABLE, - XED_ATTRIBUTE_LOCKED, - XED_ATTRIBUTE_MASKOP, - XED_ATTRIBUTE_MASKOP_EVEX, - XED_ATTRIBUTE_MASK_AS_CONTROL, - XED_ATTRIBUTE_MASK_VARIABLE_MEMOP, - XED_ATTRIBUTE_MEMORY_FAULT_SUPPRESSION, - XED_ATTRIBUTE_MMX_EXCEPT, - XED_ATTRIBUTE_MPX_PREFIX_ABLE, - XED_ATTRIBUTE_MULTIDEST2, - XED_ATTRIBUTE_MULTISOURCE4, - XED_ATTRIBUTE_MXCSR, - XED_ATTRIBUTE_MXCSR_RD, - XED_ATTRIBUTE_NONTEMPORAL, - XED_ATTRIBUTE_NOP, - XED_ATTRIBUTE_NOTSX, - XED_ATTRIBUTE_NOTSX_COND, - XED_ATTRIBUTE_NO_RIP_REL, - XED_ATTRIBUTE_NO_SRC_DEST_MATCH, - XED_ATTRIBUTE_PREFETCH, - XED_ATTRIBUTE_PROTECTED_MODE, - XED_ATTRIBUTE_QWORD_INDICES, - XED_ATTRIBUTE_REP, - XED_ATTRIBUTE_REQUIRES_ALIGNMENT, - XED_ATTRIBUTE_RING0, - XED_ATTRIBUTE_SCALABLE, - XED_ATTRIBUTE_SCATTER, - XED_ATTRIBUTE_SIMD_SCALAR, - XED_ATTRIBUTE_SKIPLOW32, - XED_ATTRIBUTE_SKIPLOW64, - XED_ATTRIBUTE_SPECIAL_AGEN_REQUIRED, - XED_ATTRIBUTE_STACKPOP0, - XED_ATTRIBUTE_STACKPOP1, - XED_ATTRIBUTE_STACKPUSH0, - XED_ATTRIBUTE_STACKPUSH1, - XED_ATTRIBUTE_USES_DAZ, - XED_ATTRIBUTE_USES_FTZ, - XED_ATTRIBUTE_X87_CONTROL, - XED_ATTRIBUTE_X87_MMX_STATE_CW, - XED_ATTRIBUTE_X87_MMX_STATE_R, - XED_ATTRIBUTE_X87_MMX_STATE_W, - XED_ATTRIBUTE_X87_NOWAIT, - XED_ATTRIBUTE_XMM_STATE_CW, - XED_ATTRIBUTE_XMM_STATE_R, - XED_ATTRIBUTE_XMM_STATE_W, - XED_ATTRIBUTE_LAST -} xed_attribute_enum_t; - -/// This converts strings to #xed_attribute_enum_t types. -/// @param s A C-string. -/// @return #xed_attribute_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_attribute_enum_t str2xed_attribute_enum_t(const char* s); -/// This converts strings to #xed_attribute_enum_t types. -/// @param p An enumeration element of type xed_attribute_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_attribute_enum_t2str(const xed_attribute_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_attribute_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_attribute_enum_t xed_attribute_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-attributes.h b/target/i386/latx/include/xed/xed-attributes.h deleted file mode 100644 index b65263b7942..00000000000 --- a/target/i386/latx/include/xed/xed-attributes.h +++ /dev/null @@ -1,28 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ - -#if !defined(XED_ATTRIBUTES_H) -# define XED_ATTRIBUTES_H -#include "xed-types.h" - -typedef struct { - xed_uint64_t a1; - xed_uint64_t a2; -} xed_attributes_t; - -#endif diff --git a/target/i386/latx/include/xed/xed-build-defines.h b/target/i386/latx/include/xed/xed-build-defines.h deleted file mode 100644 index 402ebdc1814..00000000000 --- a/target/i386/latx/include/xed/xed-build-defines.h +++ /dev/null @@ -1,60 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -#if !defined(XED_BUILD_DEFINES_H) -# define XED_BUILD_DEFINES_H - -# if !defined(XED_AMD_ENABLED) -# define XED_AMD_ENABLED -# endif -# if !defined(XED_AVX) -# define XED_AVX -# endif -# if !defined(XED_CET) -# define XED_CET -# endif -# if !defined(XED_DECODER) -# define XED_DECODER -# endif -# if !defined(XED_ENCODER) -# define XED_ENCODER -# endif -# if !defined(XED_GIT_VERSION) -# define XED_GIT_VERSION "12.0.1-72-gd57a3bd" -# endif -# if !defined(XED_MESSAGES) -# define XED_MESSAGES -# endif -# if !defined(XED_MPX) -# define XED_MPX -# endif -# if !defined(XED_SUPPORTS_AVX512) -# define XED_SUPPORTS_AVX512 -# endif -# if !defined(XED_SUPPORTS_LZCNT_TZCNT) -# define XED_SUPPORTS_LZCNT_TZCNT -# endif -# if !defined(XED_SUPPORTS_SHA) -# define XED_SUPPORTS_SHA -# endif -# if !defined(XED_SUPPORTS_WBNOINVD) -# define XED_SUPPORTS_WBNOINVD -# endif -# if !defined(XED_VIA_ENABLED) -# define XED_VIA_ENABLED -# endif -#endif diff --git a/target/i386/latx/include/xed/xed-category-enum.h b/target/i386/latx/include/xed/xed-category-enum.h deleted file mode 100644 index 7bf6e21a42f..00000000000 --- a/target/i386/latx/include/xed/xed-category-enum.h +++ /dev/null @@ -1,256 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-category-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_CATEGORY_ENUM_H) -# define XED_CATEGORY_ENUM_H -#include "xed-common-hdrs.h" -#define XED_CATEGORY_INVALID_DEFINED 1 -#define XED_CATEGORY_3DNOW_DEFINED 1 -#define XED_CATEGORY_ADOX_ADCX_DEFINED 1 -#define XED_CATEGORY_AES_DEFINED 1 -#define XED_CATEGORY_AMX_TILE_DEFINED 1 -#define XED_CATEGORY_AVX_DEFINED 1 -#define XED_CATEGORY_AVX2_DEFINED 1 -#define XED_CATEGORY_AVX2GATHER_DEFINED 1 -#define XED_CATEGORY_AVX512_DEFINED 1 -#define XED_CATEGORY_AVX512_4FMAPS_DEFINED 1 -#define XED_CATEGORY_AVX512_4VNNIW_DEFINED 1 -#define XED_CATEGORY_AVX512_BITALG_DEFINED 1 -#define XED_CATEGORY_AVX512_VBMI_DEFINED 1 -#define XED_CATEGORY_AVX512_VP2INTERSECT_DEFINED 1 -#define XED_CATEGORY_BINARY_DEFINED 1 -#define XED_CATEGORY_BITBYTE_DEFINED 1 -#define XED_CATEGORY_BLEND_DEFINED 1 -#define XED_CATEGORY_BMI1_DEFINED 1 -#define XED_CATEGORY_BMI2_DEFINED 1 -#define XED_CATEGORY_BROADCAST_DEFINED 1 -#define XED_CATEGORY_CALL_DEFINED 1 -#define XED_CATEGORY_CET_DEFINED 1 -#define XED_CATEGORY_CLDEMOTE_DEFINED 1 -#define XED_CATEGORY_CLFLUSHOPT_DEFINED 1 -#define XED_CATEGORY_CLWB_DEFINED 1 -#define XED_CATEGORY_CLZERO_DEFINED 1 -#define XED_CATEGORY_CMOV_DEFINED 1 -#define XED_CATEGORY_COMPRESS_DEFINED 1 -#define XED_CATEGORY_COND_BR_DEFINED 1 -#define XED_CATEGORY_CONFLICT_DEFINED 1 -#define XED_CATEGORY_CONVERT_DEFINED 1 -#define XED_CATEGORY_DATAXFER_DEFINED 1 -#define XED_CATEGORY_DECIMAL_DEFINED 1 -#define XED_CATEGORY_ENQCMD_DEFINED 1 -#define XED_CATEGORY_EXPAND_DEFINED 1 -#define XED_CATEGORY_FCMOV_DEFINED 1 -#define XED_CATEGORY_FLAGOP_DEFINED 1 -#define XED_CATEGORY_FMA4_DEFINED 1 -#define XED_CATEGORY_FP16_DEFINED 1 -#define XED_CATEGORY_GATHER_DEFINED 1 -#define XED_CATEGORY_GFNI_DEFINED 1 -#define XED_CATEGORY_HRESET_DEFINED 1 -#define XED_CATEGORY_IFMA_DEFINED 1 -#define XED_CATEGORY_INTERRUPT_DEFINED 1 -#define XED_CATEGORY_IO_DEFINED 1 -#define XED_CATEGORY_IOSTRINGOP_DEFINED 1 -#define XED_CATEGORY_KEYLOCKER_DEFINED 1 -#define XED_CATEGORY_KEYLOCKER_WIDE_DEFINED 1 -#define XED_CATEGORY_KMASK_DEFINED 1 -#define XED_CATEGORY_LEGACY_DEFINED 1 -#define XED_CATEGORY_LOGICAL_DEFINED 1 -#define XED_CATEGORY_LOGICAL_FP_DEFINED 1 -#define XED_CATEGORY_LZCNT_DEFINED 1 -#define XED_CATEGORY_MISC_DEFINED 1 -#define XED_CATEGORY_MMX_DEFINED 1 -#define XED_CATEGORY_MOVDIR_DEFINED 1 -#define XED_CATEGORY_MPX_DEFINED 1 -#define XED_CATEGORY_NOP_DEFINED 1 -#define XED_CATEGORY_PCLMULQDQ_DEFINED 1 -#define XED_CATEGORY_PCONFIG_DEFINED 1 -#define XED_CATEGORY_PKU_DEFINED 1 -#define XED_CATEGORY_POP_DEFINED 1 -#define XED_CATEGORY_PREFETCH_DEFINED 1 -#define XED_CATEGORY_PREFETCHWT1_DEFINED 1 -#define XED_CATEGORY_PTWRITE_DEFINED 1 -#define XED_CATEGORY_PUSH_DEFINED 1 -#define XED_CATEGORY_RDPID_DEFINED 1 -#define XED_CATEGORY_RDPRU_DEFINED 1 -#define XED_CATEGORY_RDRAND_DEFINED 1 -#define XED_CATEGORY_RDSEED_DEFINED 1 -#define XED_CATEGORY_RDWRFSGS_DEFINED 1 -#define XED_CATEGORY_RET_DEFINED 1 -#define XED_CATEGORY_ROTATE_DEFINED 1 -#define XED_CATEGORY_SCATTER_DEFINED 1 -#define XED_CATEGORY_SEGOP_DEFINED 1 -#define XED_CATEGORY_SEMAPHORE_DEFINED 1 -#define XED_CATEGORY_SERIALIZE_DEFINED 1 -#define XED_CATEGORY_SETCC_DEFINED 1 -#define XED_CATEGORY_SGX_DEFINED 1 -#define XED_CATEGORY_SHA_DEFINED 1 -#define XED_CATEGORY_SHIFT_DEFINED 1 -#define XED_CATEGORY_SMAP_DEFINED 1 -#define XED_CATEGORY_SSE_DEFINED 1 -#define XED_CATEGORY_STRINGOP_DEFINED 1 -#define XED_CATEGORY_STTNI_DEFINED 1 -#define XED_CATEGORY_SYSCALL_DEFINED 1 -#define XED_CATEGORY_SYSRET_DEFINED 1 -#define XED_CATEGORY_SYSTEM_DEFINED 1 -#define XED_CATEGORY_TBM_DEFINED 1 -#define XED_CATEGORY_TSX_LDTRK_DEFINED 1 -#define XED_CATEGORY_UINTR_DEFINED 1 -#define XED_CATEGORY_UNCOND_BR_DEFINED 1 -#define XED_CATEGORY_VAES_DEFINED 1 -#define XED_CATEGORY_VBMI2_DEFINED 1 -#define XED_CATEGORY_VEX_DEFINED 1 -#define XED_CATEGORY_VFMA_DEFINED 1 -#define XED_CATEGORY_VIA_PADLOCK_DEFINED 1 -#define XED_CATEGORY_VPCLMULQDQ_DEFINED 1 -#define XED_CATEGORY_VTX_DEFINED 1 -#define XED_CATEGORY_WAITPKG_DEFINED 1 -#define XED_CATEGORY_WIDENOP_DEFINED 1 -#define XED_CATEGORY_X87_ALU_DEFINED 1 -#define XED_CATEGORY_XOP_DEFINED 1 -#define XED_CATEGORY_XSAVE_DEFINED 1 -#define XED_CATEGORY_XSAVEOPT_DEFINED 1 -#define XED_CATEGORY_LAST_DEFINED 1 -typedef enum { - XED_CATEGORY_INVALID, - XED_CATEGORY_3DNOW, - XED_CATEGORY_ADOX_ADCX, - XED_CATEGORY_AES, - XED_CATEGORY_AMX_TILE, - XED_CATEGORY_AVX, - XED_CATEGORY_AVX2, - XED_CATEGORY_AVX2GATHER, - XED_CATEGORY_AVX512, - XED_CATEGORY_AVX512_4FMAPS, - XED_CATEGORY_AVX512_4VNNIW, - XED_CATEGORY_AVX512_BITALG, - XED_CATEGORY_AVX512_VBMI, - XED_CATEGORY_AVX512_VP2INTERSECT, - XED_CATEGORY_BINARY, - XED_CATEGORY_BITBYTE, - XED_CATEGORY_BLEND, - XED_CATEGORY_BMI1, - XED_CATEGORY_BMI2, - XED_CATEGORY_BROADCAST, - XED_CATEGORY_CALL, - XED_CATEGORY_CET, - XED_CATEGORY_CLDEMOTE, - XED_CATEGORY_CLFLUSHOPT, - XED_CATEGORY_CLWB, - XED_CATEGORY_CLZERO, - XED_CATEGORY_CMOV, - XED_CATEGORY_COMPRESS, - XED_CATEGORY_COND_BR, - XED_CATEGORY_CONFLICT, - XED_CATEGORY_CONVERT, - XED_CATEGORY_DATAXFER, - XED_CATEGORY_DECIMAL, - XED_CATEGORY_ENQCMD, - XED_CATEGORY_EXPAND, - XED_CATEGORY_FCMOV, - XED_CATEGORY_FLAGOP, - XED_CATEGORY_FMA4, - XED_CATEGORY_FP16, - XED_CATEGORY_GATHER, - XED_CATEGORY_GFNI, - XED_CATEGORY_HRESET, - XED_CATEGORY_IFMA, - XED_CATEGORY_INTERRUPT, - XED_CATEGORY_IO, - XED_CATEGORY_IOSTRINGOP, - XED_CATEGORY_KEYLOCKER, - XED_CATEGORY_KEYLOCKER_WIDE, - XED_CATEGORY_KMASK, - XED_CATEGORY_LEGACY, - XED_CATEGORY_LOGICAL, - XED_CATEGORY_LOGICAL_FP, - XED_CATEGORY_LZCNT, - XED_CATEGORY_MISC, - XED_CATEGORY_MMX, - XED_CATEGORY_MOVDIR, - XED_CATEGORY_MPX, - XED_CATEGORY_NOP, - XED_CATEGORY_PCLMULQDQ, - XED_CATEGORY_PCONFIG, - XED_CATEGORY_PKU, - XED_CATEGORY_POP, - XED_CATEGORY_PREFETCH, - XED_CATEGORY_PREFETCHWT1, - XED_CATEGORY_PTWRITE, - XED_CATEGORY_PUSH, - XED_CATEGORY_RDPID, - XED_CATEGORY_RDPRU, - XED_CATEGORY_RDRAND, - XED_CATEGORY_RDSEED, - XED_CATEGORY_RDWRFSGS, - XED_CATEGORY_RET, - XED_CATEGORY_ROTATE, - XED_CATEGORY_SCATTER, - XED_CATEGORY_SEGOP, - XED_CATEGORY_SEMAPHORE, - XED_CATEGORY_SERIALIZE, - XED_CATEGORY_SETCC, - XED_CATEGORY_SGX, - XED_CATEGORY_SHA, - XED_CATEGORY_SHIFT, - XED_CATEGORY_SMAP, - XED_CATEGORY_SSE, - XED_CATEGORY_STRINGOP, - XED_CATEGORY_STTNI, - XED_CATEGORY_SYSCALL, - XED_CATEGORY_SYSRET, - XED_CATEGORY_SYSTEM, - XED_CATEGORY_TBM, - XED_CATEGORY_TSX_LDTRK, - XED_CATEGORY_UINTR, - XED_CATEGORY_UNCOND_BR, - XED_CATEGORY_VAES, - XED_CATEGORY_VBMI2, - XED_CATEGORY_VEX, - XED_CATEGORY_VFMA, - XED_CATEGORY_VIA_PADLOCK, - XED_CATEGORY_VPCLMULQDQ, - XED_CATEGORY_VTX, - XED_CATEGORY_WAITPKG, - XED_CATEGORY_WIDENOP, - XED_CATEGORY_X87_ALU, - XED_CATEGORY_XOP, - XED_CATEGORY_XSAVE, - XED_CATEGORY_XSAVEOPT, - XED_CATEGORY_LAST -} xed_category_enum_t; - -/// This converts strings to #xed_category_enum_t types. -/// @param s A C-string. -/// @return #xed_category_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_category_enum_t str2xed_category_enum_t(const char* s); -/// This converts strings to #xed_category_enum_t types. -/// @param p An enumeration element of type xed_category_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_category_enum_t2str(const xed_category_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_category_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_category_enum_t xed_category_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-chip-enum.h b/target/i386/latx/include/xed/xed-chip-enum.h deleted file mode 100644 index 857922dc2e5..00000000000 --- a/target/i386/latx/include/xed/xed-chip-enum.h +++ /dev/null @@ -1,176 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-chip-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_CHIP_ENUM_H) -# define XED_CHIP_ENUM_H -#include "xed-common-hdrs.h" -#define XED_CHIP_INVALID_DEFINED 1 -#define XED_CHIP_I86_DEFINED 1 -#define XED_CHIP_I86FP_DEFINED 1 -#define XED_CHIP_I186_DEFINED 1 -#define XED_CHIP_I186FP_DEFINED 1 -#define XED_CHIP_I286REAL_DEFINED 1 -#define XED_CHIP_I286_DEFINED 1 -#define XED_CHIP_I2186FP_DEFINED 1 -#define XED_CHIP_I386REAL_DEFINED 1 -#define XED_CHIP_I386_DEFINED 1 -#define XED_CHIP_I386FP_DEFINED 1 -#define XED_CHIP_I486REAL_DEFINED 1 -#define XED_CHIP_I486_DEFINED 1 -#define XED_CHIP_PENTIUMREAL_DEFINED 1 -#define XED_CHIP_PENTIUM_DEFINED 1 -#define XED_CHIP_QUARK_DEFINED 1 -#define XED_CHIP_PENTIUMMMXREAL_DEFINED 1 -#define XED_CHIP_PENTIUMMMX_DEFINED 1 -#define XED_CHIP_ALLREAL_DEFINED 1 -#define XED_CHIP_PENTIUMPRO_DEFINED 1 -#define XED_CHIP_PENTIUM2_DEFINED 1 -#define XED_CHIP_PENTIUM3_DEFINED 1 -#define XED_CHIP_PENTIUM4_DEFINED 1 -#define XED_CHIP_P4PRESCOTT_DEFINED 1 -#define XED_CHIP_P4PRESCOTT_NOLAHF_DEFINED 1 -#define XED_CHIP_P4PRESCOTT_VTX_DEFINED 1 -#define XED_CHIP_MEROM_DEFINED 1 -#define XED_CHIP_PENRYN_DEFINED 1 -#define XED_CHIP_PENRYN_E_DEFINED 1 -#define XED_CHIP_NEHALEM_DEFINED 1 -#define XED_CHIP_WESTMERE_DEFINED 1 -#define XED_CHIP_BONNELL_DEFINED 1 -#define XED_CHIP_SALTWELL_DEFINED 1 -#define XED_CHIP_SILVERMONT_DEFINED 1 -#define XED_CHIP_VIA_DEFINED 1 -#define XED_CHIP_AMD_K10_DEFINED 1 -#define XED_CHIP_AMD_BULLDOZER_DEFINED 1 -#define XED_CHIP_AMD_PILEDRIVER_DEFINED 1 -#define XED_CHIP_AMD_ZEN_DEFINED 1 -#define XED_CHIP_AMD_ZENPLUS_DEFINED 1 -#define XED_CHIP_AMD_ZEN2_DEFINED 1 -#define XED_CHIP_AMD_FUTURE_DEFINED 1 -#define XED_CHIP_GOLDMONT_DEFINED 1 -#define XED_CHIP_GOLDMONT_PLUS_DEFINED 1 -#define XED_CHIP_TREMONT_DEFINED 1 -#define XED_CHIP_SNOW_RIDGE_DEFINED 1 -#define XED_CHIP_SANDYBRIDGE_DEFINED 1 -#define XED_CHIP_IVYBRIDGE_DEFINED 1 -#define XED_CHIP_HASWELL_DEFINED 1 -#define XED_CHIP_BROADWELL_DEFINED 1 -#define XED_CHIP_SKYLAKE_DEFINED 1 -#define XED_CHIP_COMET_LAKE_DEFINED 1 -#define XED_CHIP_SKYLAKE_SERVER_DEFINED 1 -#define XED_CHIP_CASCADE_LAKE_DEFINED 1 -#define XED_CHIP_COOPER_LAKE_DEFINED 1 -#define XED_CHIP_KNL_DEFINED 1 -#define XED_CHIP_KNM_DEFINED 1 -#define XED_CHIP_CANNONLAKE_DEFINED 1 -#define XED_CHIP_ICE_LAKE_DEFINED 1 -#define XED_CHIP_ICE_LAKE_SERVER_DEFINED 1 -#define XED_CHIP_TIGER_LAKE_DEFINED 1 -#define XED_CHIP_ALDER_LAKE_DEFINED 1 -#define XED_CHIP_SAPPHIRE_RAPIDS_DEFINED 1 -#define XED_CHIP_FUTURE_DEFINED 1 -#define XED_CHIP_ALL_DEFINED 1 -#define XED_CHIP_LAST_DEFINED 1 -typedef enum { - XED_CHIP_INVALID, - XED_CHIP_I86, - XED_CHIP_I86FP, - XED_CHIP_I186, - XED_CHIP_I186FP, - XED_CHIP_I286REAL, - XED_CHIP_I286, - XED_CHIP_I2186FP, - XED_CHIP_I386REAL, - XED_CHIP_I386, - XED_CHIP_I386FP, - XED_CHIP_I486REAL, - XED_CHIP_I486, - XED_CHIP_PENTIUMREAL, - XED_CHIP_PENTIUM, - XED_CHIP_QUARK, - XED_CHIP_PENTIUMMMXREAL, - XED_CHIP_PENTIUMMMX, - XED_CHIP_ALLREAL, - XED_CHIP_PENTIUMPRO, - XED_CHIP_PENTIUM2, - XED_CHIP_PENTIUM3, - XED_CHIP_PENTIUM4, - XED_CHIP_P4PRESCOTT, - XED_CHIP_P4PRESCOTT_NOLAHF, - XED_CHIP_P4PRESCOTT_VTX, - XED_CHIP_MEROM, - XED_CHIP_PENRYN, - XED_CHIP_PENRYN_E, - XED_CHIP_NEHALEM, - XED_CHIP_WESTMERE, - XED_CHIP_BONNELL, - XED_CHIP_SALTWELL, - XED_CHIP_SILVERMONT, - XED_CHIP_VIA, - XED_CHIP_AMD_K10, - XED_CHIP_AMD_BULLDOZER, - XED_CHIP_AMD_PILEDRIVER, - XED_CHIP_AMD_ZEN, - XED_CHIP_AMD_ZENPLUS, - XED_CHIP_AMD_ZEN2, - XED_CHIP_AMD_FUTURE, - XED_CHIP_GOLDMONT, - XED_CHIP_GOLDMONT_PLUS, - XED_CHIP_TREMONT, - XED_CHIP_SNOW_RIDGE, - XED_CHIP_SANDYBRIDGE, - XED_CHIP_IVYBRIDGE, - XED_CHIP_HASWELL, - XED_CHIP_BROADWELL, - XED_CHIP_SKYLAKE, - XED_CHIP_COMET_LAKE, - XED_CHIP_SKYLAKE_SERVER, - XED_CHIP_CASCADE_LAKE, - XED_CHIP_COOPER_LAKE, - XED_CHIP_KNL, - XED_CHIP_KNM, - XED_CHIP_CANNONLAKE, - XED_CHIP_ICE_LAKE, - XED_CHIP_ICE_LAKE_SERVER, - XED_CHIP_TIGER_LAKE, - XED_CHIP_ALDER_LAKE, - XED_CHIP_SAPPHIRE_RAPIDS, - XED_CHIP_FUTURE, - XED_CHIP_ALL, - XED_CHIP_LAST -} xed_chip_enum_t; - -/// This converts strings to #xed_chip_enum_t types. -/// @param s A C-string. -/// @return #xed_chip_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_chip_enum_t str2xed_chip_enum_t(const char* s); -/// This converts strings to #xed_chip_enum_t types. -/// @param p An enumeration element of type xed_chip_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_chip_enum_t2str(const xed_chip_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_chip_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_chip_enum_t xed_chip_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-chip-features.h b/target/i386/latx/include/xed/xed-chip-features.h deleted file mode 100644 index a6dd8b0e026..00000000000 --- a/target/i386/latx/include/xed/xed-chip-features.h +++ /dev/null @@ -1,46 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ - -#if !defined(XED_CHIP_FEATURES_H) -# define XED_CHIP_FEATURES_H - -#include "xed-common-hdrs.h" -#include "xed-types.h" -#include "xed-isa-set-enum.h" /* generated */ -#include "xed-chip-enum.h" /* generated */ - -#define XED_FEATURE_VECTOR_MAX 5 -/// @ingroup ISASET -typedef struct -{ - xed_uint64_t f[XED_FEATURE_VECTOR_MAX]; -} xed_chip_features_t; - - -/// fill in the contents of p with the vector of chip features. -XED_DLL_EXPORT void -xed_get_chip_features(xed_chip_features_t* p, xed_chip_enum_t chip); - -/// present = 1 to turn the feature on. present=0 to remove the feature. -XED_DLL_EXPORT void -xed_modify_chip_features(xed_chip_features_t* p, - xed_isa_set_enum_t isa_set, - xed_bool_t present); - - -#endif diff --git a/target/i386/latx/include/xed/xed-common-defs.h b/target/i386/latx/include/xed/xed-common-defs.h deleted file mode 100644 index 4f2d31fa8f2..00000000000 --- a/target/i386/latx/include/xed/xed-common-defs.h +++ /dev/null @@ -1,47 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-common-defs.h -/// @brief some pervasive defines - - - -#ifndef XED_COMMON_DEFS_H -# define XED_COMMON_DEFS_H - - // for most things it is 4, but one 64b mov allows 8 -#define XED_MAX_DISPLACEMENT_BYTES 8 - - // for most things it is max 4, but one 64b mov allows 8. -#define XED_MAX_IMMEDIATE_BYTES 8 - -#define XED_MAX_INSTRUCTION_BYTES 15 - - -#define XED_BYTE_MASK(x) ((x) & 0xFF) -#define XED_BYTE_CAST(x) (XED_STATIC_CAST(xed_uint8_t,x)) - -#endif - - - - - - - - - diff --git a/target/i386/latx/include/xed/xed-common-hdrs.h b/target/i386/latx/include/xed/xed-common-hdrs.h deleted file mode 100644 index a30a3e0ff2f..00000000000 --- a/target/i386/latx/include/xed/xed-common-hdrs.h +++ /dev/null @@ -1,71 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-common-hdrs.h -/// - - - -#ifndef XED_COMMON_HDRS_H -# define XED_COMMON_HDRS_H - - - -#if defined(__FreeBSD__) || defined(__NetBSD__) -# define XED_BSD -#endif -#if defined(__linux__) -# define XED_LINUX -#endif -#if defined(_MSC_VER) -# define XED_WINDOWS -#endif -#if defined(__APPLE__) -# define XED_MAC -#endif - - -#if defined(XED_DLL) -// __declspec(dllexport) works with GNU GCC or MS compilers, but not ICC -// on linux - -# if defined(XED_WINDOWS) -# define XED_DLL_EXPORT __declspec(dllexport) -# define XED_DLL_IMPORT __declspec(dllimport) -# elif defined(XED_LINUX) || defined(XED_BSD) || defined(XED_MAC) -# define XED_DLL_EXPORT __attribute__((visibility("default"))) -# define XED_DLL_IMPORT -# else -# define XED_DLL_EXPORT -# define XED_DLL_IMPORT -# endif - -# if defined(XED_BUILD) - /* when building XED, we export symbols */ -# define XED_DLL_GLOBAL XED_DLL_EXPORT -# else - /* when building XED clients, we import symbols */ -# define XED_DLL_GLOBAL XED_DLL_IMPORT -# endif -#else -# define XED_DLL_EXPORT -# define XED_DLL_IMPORT -# define XED_DLL_GLOBAL -#endif - -#endif - diff --git a/target/i386/latx/include/xed/xed-convert-table-init.h b/target/i386/latx/include/xed/xed-convert-table-init.h deleted file mode 100644 index 339c97766cd..00000000000 --- a/target/i386/latx/include/xed/xed-convert-table-init.h +++ /dev/null @@ -1,36 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-convert-table-init.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_CONVERT_TABLE_INIT_H) -# define XED_CONVERT_TABLE_INIT_H -#include "xed-internal-header.h" -typedef struct { - - const char** table_name; - - xed_operand_enum_t opnd; - - unsigned int limit; - -} xed_convert_table_t; -extern xed_convert_table_t xed_convert_table[XED_OPERAND_CONVERT_LAST]; -#endif diff --git a/target/i386/latx/include/xed/xed-cpuid-bit-enum.h b/target/i386/latx/include/xed/xed-cpuid-bit-enum.h deleted file mode 100644 index fec7a4f3d17..00000000000 --- a/target/i386/latx/include/xed/xed-cpuid-bit-enum.h +++ /dev/null @@ -1,254 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-cpuid-bit-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_CPUID_BIT_ENUM_H) -# define XED_CPUID_BIT_ENUM_H -#include "xed-common-hdrs.h" -#define XED_CPUID_BIT_INVALID_DEFINED 1 -#define XED_CPUID_BIT_ADOXADCX_DEFINED 1 -#define XED_CPUID_BIT_AES_DEFINED 1 -#define XED_CPUID_BIT_AMX_BF16_DEFINED 1 -#define XED_CPUID_BIT_AMX_INT8_DEFINED 1 -#define XED_CPUID_BIT_AMX_TILES_DEFINED 1 -#define XED_CPUID_BIT_AVX_DEFINED 1 -#define XED_CPUID_BIT_AVX2_DEFINED 1 -#define XED_CPUID_BIT_AVX512BW_DEFINED 1 -#define XED_CPUID_BIT_AVX512CD_DEFINED 1 -#define XED_CPUID_BIT_AVX512DQ_DEFINED 1 -#define XED_CPUID_BIT_AVX512ER_DEFINED 1 -#define XED_CPUID_BIT_AVX512F_DEFINED 1 -#define XED_CPUID_BIT_AVX512IFMA_DEFINED 1 -#define XED_CPUID_BIT_AVX512PF_DEFINED 1 -#define XED_CPUID_BIT_AVX512VBMI_DEFINED 1 -#define XED_CPUID_BIT_AVX512VL_DEFINED 1 -#define XED_CPUID_BIT_AVX512_4FMAPS_DEFINED 1 -#define XED_CPUID_BIT_AVX512_4VNNIW_DEFINED 1 -#define XED_CPUID_BIT_AVX512_BITALG_DEFINED 1 -#define XED_CPUID_BIT_AVX512_FP16_DEFINED 1 -#define XED_CPUID_BIT_AVX512_VBMI2_DEFINED 1 -#define XED_CPUID_BIT_AVX512_VNNI_DEFINED 1 -#define XED_CPUID_BIT_AVX512_VP2INTERSECT_DEFINED 1 -#define XED_CPUID_BIT_AVX512_VPOPCNTDQ_DEFINED 1 -#define XED_CPUID_BIT_AVX_VNNI_DEFINED 1 -#define XED_CPUID_BIT_BF16_DEFINED 1 -#define XED_CPUID_BIT_BMI1_DEFINED 1 -#define XED_CPUID_BIT_BMI2_DEFINED 1 -#define XED_CPUID_BIT_CET_DEFINED 1 -#define XED_CPUID_BIT_CLDEMOTE_DEFINED 1 -#define XED_CPUID_BIT_CLFLUSH_DEFINED 1 -#define XED_CPUID_BIT_CLFLUSHOPT_DEFINED 1 -#define XED_CPUID_BIT_CLWB_DEFINED 1 -#define XED_CPUID_BIT_CMPXCHG16B_DEFINED 1 -#define XED_CPUID_BIT_ENQCMD_DEFINED 1 -#define XED_CPUID_BIT_F16C_DEFINED 1 -#define XED_CPUID_BIT_FMA_DEFINED 1 -#define XED_CPUID_BIT_FXSAVE_DEFINED 1 -#define XED_CPUID_BIT_GFNI_DEFINED 1 -#define XED_CPUID_BIT_HRESET_DEFINED 1 -#define XED_CPUID_BIT_INTEL64_DEFINED 1 -#define XED_CPUID_BIT_INTELPT_DEFINED 1 -#define XED_CPUID_BIT_INVPCID_DEFINED 1 -#define XED_CPUID_BIT_KLENABLED_DEFINED 1 -#define XED_CPUID_BIT_KLSUPPORTED_DEFINED 1 -#define XED_CPUID_BIT_KLWIDE_DEFINED 1 -#define XED_CPUID_BIT_LAHF_DEFINED 1 -#define XED_CPUID_BIT_LZCNT_DEFINED 1 -#define XED_CPUID_BIT_MCOMMIT_DEFINED 1 -#define XED_CPUID_BIT_MONITOR_DEFINED 1 -#define XED_CPUID_BIT_MONITORX_DEFINED 1 -#define XED_CPUID_BIT_MOVDIR64B_DEFINED 1 -#define XED_CPUID_BIT_MOVDIRI_DEFINED 1 -#define XED_CPUID_BIT_MOVEBE_DEFINED 1 -#define XED_CPUID_BIT_MPX_DEFINED 1 -#define XED_CPUID_BIT_OSPKU_DEFINED 1 -#define XED_CPUID_BIT_OSXSAVE_DEFINED 1 -#define XED_CPUID_BIT_PCLMULQDQ_DEFINED 1 -#define XED_CPUID_BIT_PCONFIG_DEFINED 1 -#define XED_CPUID_BIT_PKU_DEFINED 1 -#define XED_CPUID_BIT_POPCNT_DEFINED 1 -#define XED_CPUID_BIT_PREFETCHW_DEFINED 1 -#define XED_CPUID_BIT_PREFETCHWT1_DEFINED 1 -#define XED_CPUID_BIT_PTWRITE_DEFINED 1 -#define XED_CPUID_BIT_RDP_DEFINED 1 -#define XED_CPUID_BIT_RDPRU_DEFINED 1 -#define XED_CPUID_BIT_RDRAND_DEFINED 1 -#define XED_CPUID_BIT_RDSEED_DEFINED 1 -#define XED_CPUID_BIT_RDTSCP_DEFINED 1 -#define XED_CPUID_BIT_RDWRFSGS_DEFINED 1 -#define XED_CPUID_BIT_RTM_DEFINED 1 -#define XED_CPUID_BIT_SERIALIZE_DEFINED 1 -#define XED_CPUID_BIT_SGX_DEFINED 1 -#define XED_CPUID_BIT_SHA_DEFINED 1 -#define XED_CPUID_BIT_SMAP_DEFINED 1 -#define XED_CPUID_BIT_SMX_DEFINED 1 -#define XED_CPUID_BIT_SNP_DEFINED 1 -#define XED_CPUID_BIT_SSE_DEFINED 1 -#define XED_CPUID_BIT_SSE2_DEFINED 1 -#define XED_CPUID_BIT_SSE3_DEFINED 1 -#define XED_CPUID_BIT_SSE4_DEFINED 1 -#define XED_CPUID_BIT_SSE42_DEFINED 1 -#define XED_CPUID_BIT_SSE4A_DEFINED 1 -#define XED_CPUID_BIT_SSSE3_DEFINED 1 -#define XED_CPUID_BIT_TSX_LDTRK_DEFINED 1 -#define XED_CPUID_BIT_UINTR_DEFINED 1 -#define XED_CPUID_BIT_VAES_DEFINED 1 -#define XED_CPUID_BIT_VIA_PADLOCK_AES_DEFINED 1 -#define XED_CPUID_BIT_VIA_PADLOCK_AES_EN_DEFINED 1 -#define XED_CPUID_BIT_VIA_PADLOCK_PMM_DEFINED 1 -#define XED_CPUID_BIT_VIA_PADLOCK_PMM_EN_DEFINED 1 -#define XED_CPUID_BIT_VIA_PADLOCK_RNG_DEFINED 1 -#define XED_CPUID_BIT_VIA_PADLOCK_RNG_EN_DEFINED 1 -#define XED_CPUID_BIT_VIA_PADLOCK_SHA_DEFINED 1 -#define XED_CPUID_BIT_VIA_PADLOCK_SHA_EN_DEFINED 1 -#define XED_CPUID_BIT_VMX_DEFINED 1 -#define XED_CPUID_BIT_VPCLMULQDQ_DEFINED 1 -#define XED_CPUID_BIT_WAITPKG_DEFINED 1 -#define XED_CPUID_BIT_WBNOINVD_DEFINED 1 -#define XED_CPUID_BIT_XSAVE_DEFINED 1 -#define XED_CPUID_BIT_XSAVEC_DEFINED 1 -#define XED_CPUID_BIT_XSAVEOPT_DEFINED 1 -#define XED_CPUID_BIT_XSAVES_DEFINED 1 -#define XED_CPUID_BIT_LAST_DEFINED 1 -typedef enum { - XED_CPUID_BIT_INVALID, - XED_CPUID_BIT_ADOXADCX, - XED_CPUID_BIT_AES, - XED_CPUID_BIT_AMX_BF16, - XED_CPUID_BIT_AMX_INT8, - XED_CPUID_BIT_AMX_TILES, - XED_CPUID_BIT_AVX, - XED_CPUID_BIT_AVX2, - XED_CPUID_BIT_AVX512BW, - XED_CPUID_BIT_AVX512CD, - XED_CPUID_BIT_AVX512DQ, - XED_CPUID_BIT_AVX512ER, - XED_CPUID_BIT_AVX512F, - XED_CPUID_BIT_AVX512IFMA, - XED_CPUID_BIT_AVX512PF, - XED_CPUID_BIT_AVX512VBMI, - XED_CPUID_BIT_AVX512VL, - XED_CPUID_BIT_AVX512_4FMAPS, - XED_CPUID_BIT_AVX512_4VNNIW, - XED_CPUID_BIT_AVX512_BITALG, - XED_CPUID_BIT_AVX512_FP16, - XED_CPUID_BIT_AVX512_VBMI2, - XED_CPUID_BIT_AVX512_VNNI, - XED_CPUID_BIT_AVX512_VP2INTERSECT, - XED_CPUID_BIT_AVX512_VPOPCNTDQ, - XED_CPUID_BIT_AVX_VNNI, - XED_CPUID_BIT_BF16, - XED_CPUID_BIT_BMI1, - XED_CPUID_BIT_BMI2, - XED_CPUID_BIT_CET, - XED_CPUID_BIT_CLDEMOTE, - XED_CPUID_BIT_CLFLUSH, - XED_CPUID_BIT_CLFLUSHOPT, - XED_CPUID_BIT_CLWB, - XED_CPUID_BIT_CMPXCHG16B, - XED_CPUID_BIT_ENQCMD, - XED_CPUID_BIT_F16C, - XED_CPUID_BIT_FMA, - XED_CPUID_BIT_FXSAVE, - XED_CPUID_BIT_GFNI, - XED_CPUID_BIT_HRESET, - XED_CPUID_BIT_INTEL64, - XED_CPUID_BIT_INTELPT, - XED_CPUID_BIT_INVPCID, - XED_CPUID_BIT_KLENABLED, - XED_CPUID_BIT_KLSUPPORTED, - XED_CPUID_BIT_KLWIDE, - XED_CPUID_BIT_LAHF, - XED_CPUID_BIT_LZCNT, - XED_CPUID_BIT_MCOMMIT, - XED_CPUID_BIT_MONITOR, - XED_CPUID_BIT_MONITORX, - XED_CPUID_BIT_MOVDIR64B, - XED_CPUID_BIT_MOVDIRI, - XED_CPUID_BIT_MOVEBE, - XED_CPUID_BIT_MPX, - XED_CPUID_BIT_OSPKU, - XED_CPUID_BIT_OSXSAVE, - XED_CPUID_BIT_PCLMULQDQ, - XED_CPUID_BIT_PCONFIG, - XED_CPUID_BIT_PKU, - XED_CPUID_BIT_POPCNT, - XED_CPUID_BIT_PREFETCHW, - XED_CPUID_BIT_PREFETCHWT1, - XED_CPUID_BIT_PTWRITE, - XED_CPUID_BIT_RDP, - XED_CPUID_BIT_RDPRU, - XED_CPUID_BIT_RDRAND, - XED_CPUID_BIT_RDSEED, - XED_CPUID_BIT_RDTSCP, - XED_CPUID_BIT_RDWRFSGS, - XED_CPUID_BIT_RTM, - XED_CPUID_BIT_SERIALIZE, - XED_CPUID_BIT_SGX, - XED_CPUID_BIT_SHA, - XED_CPUID_BIT_SMAP, - XED_CPUID_BIT_SMX, - XED_CPUID_BIT_SNP, - XED_CPUID_BIT_SSE, - XED_CPUID_BIT_SSE2, - XED_CPUID_BIT_SSE3, - XED_CPUID_BIT_SSE4, - XED_CPUID_BIT_SSE42, - XED_CPUID_BIT_SSE4A, - XED_CPUID_BIT_SSSE3, - XED_CPUID_BIT_TSX_LDTRK, - XED_CPUID_BIT_UINTR, - XED_CPUID_BIT_VAES, - XED_CPUID_BIT_VIA_PADLOCK_AES, - XED_CPUID_BIT_VIA_PADLOCK_AES_EN, - XED_CPUID_BIT_VIA_PADLOCK_PMM, - XED_CPUID_BIT_VIA_PADLOCK_PMM_EN, - XED_CPUID_BIT_VIA_PADLOCK_RNG, - XED_CPUID_BIT_VIA_PADLOCK_RNG_EN, - XED_CPUID_BIT_VIA_PADLOCK_SHA, - XED_CPUID_BIT_VIA_PADLOCK_SHA_EN, - XED_CPUID_BIT_VMX, - XED_CPUID_BIT_VPCLMULQDQ, - XED_CPUID_BIT_WAITPKG, - XED_CPUID_BIT_WBNOINVD, - XED_CPUID_BIT_XSAVE, - XED_CPUID_BIT_XSAVEC, - XED_CPUID_BIT_XSAVEOPT, - XED_CPUID_BIT_XSAVES, - XED_CPUID_BIT_LAST -} xed_cpuid_bit_enum_t; - -/// This converts strings to #xed_cpuid_bit_enum_t types. -/// @param s A C-string. -/// @return #xed_cpuid_bit_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_cpuid_bit_enum_t str2xed_cpuid_bit_enum_t(const char* s); -/// This converts strings to #xed_cpuid_bit_enum_t types. -/// @param p An enumeration element of type xed_cpuid_bit_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_cpuid_bit_enum_t2str(const xed_cpuid_bit_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_cpuid_bit_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_cpuid_bit_enum_t xed_cpuid_bit_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-cpuid-rec.h b/target/i386/latx/include/xed/xed-cpuid-rec.h deleted file mode 100644 index 420f811c7a0..00000000000 --- a/target/i386/latx/include/xed/xed-cpuid-rec.h +++ /dev/null @@ -1,55 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ - -#ifndef XED_CPUID_REC_H -# define XED_CPUID_REC_H -#include "xed-types.h" -#include "xed-portability.h" -#include "xed-cpuid-bit-enum.h" -#include "xed-isa-set-enum.h" - - -typedef struct { - xed_uint32_t leaf; // cpuid leaf - xed_uint32_t subleaf; // cpuid subleaf - xed_uint32_t bit; // the bit number for the feature - xed_reg_enum_t reg; // the register containing the bit (EAX,EBX,ECX,EDX) -} xed_cpuid_rec_t; - -#define XED_MAX_CPUID_BITS_PER_ISA_SET (4) - -/// Returns the name of the i'th cpuid bit associated with this isa-set. -/// Call this repeatedly, with 0 <= i < -/// XED_MAX_CPUID_BITS_PER_ISA_SET. Give up when i == -/// XED_MAX_CPUID_BITS_PER_ISA_SET or the return value is -/// XED_CPUID_BIT_INVALID. -XED_DLL_EXPORT -xed_cpuid_bit_enum_t -xed_get_cpuid_bit_for_isa_set(xed_isa_set_enum_t isaset, - xed_uint_t i); - -/// This provides the details of the CPUID bit specification, if the -/// enumeration value is not sufficient. Returns 1 on success and fills in -/// the structure pointed to by p. Returns 0 on failure. -XED_DLL_EXPORT -xed_int_t -xed_get_cpuid_rec(xed_cpuid_bit_enum_t cpuid_bit, - xed_cpuid_rec_t* p); - -#endif - diff --git a/target/i386/latx/include/xed/xed-decode.h b/target/i386/latx/include/xed/xed-decode.h deleted file mode 100644 index 2061d83fd79..00000000000 --- a/target/i386/latx/include/xed/xed-decode.h +++ /dev/null @@ -1,69 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-decode.h - - -#ifndef XED_DECODE_H -# define XED_DECODE_H - -#include "xed-decoded-inst.h" -#include "xed-error-enum.h" -#include "xed-chip-features.h" - -/// This is the main interface to the decoder. -/// @param xedd the decoded instruction of type #xed_decoded_inst_t . Mode/state sent in via xedd; See the #xed_state_t -/// @param itext the pointer to the array of instruction text bytes -/// @param bytes the length of the itext input array. 1 to 15 bytes, anything more is ignored. -/// @return #xed_error_enum_t indicating success (#XED_ERROR_NONE) or failure. Note failure can be due to not -/// enough bytes in the input array. -/// -/// The maximum instruction is 15B and XED will tell you how long the -/// actual instruction is via an API function call -/// xed_decoded_inst_get_length(). However, it is not always safe or -/// advisable for XED to read 15 bytes if the decode location is at the -/// boundary of some sort of protection limit. For example, if one is -/// decoding near the end of a page and the XED user does not want to cause -/// extra page faults, one might send in the number of bytes that would -/// stop at the page boundary. In this case, XED might not be able to -/// decode the instruction and would return an error. The XED user would -/// then have to decide if it was safe to touch the next page and try again -/// to decode with more bytes. Also sometimes the user process does not -/// have read access to the next page and this allows the user to prevent -/// XED from causing process termination by limiting the memory range that -/// XED will access. -/// -/// @ingroup DEC -XED_DLL_EXPORT xed_error_enum_t -xed_decode(xed_decoded_inst_t* xedd, - const xed_uint8_t* itext, - const unsigned int bytes); - -/// @ingroup DEC -/// See #xed_decode(). This version of the decode API adds a CPUID feature -/// vector to support restricting decode based on both a specified chip via -/// #xed_decoded_inst_set_input_chip() and a modify-able cpuid feature -/// vector obtained from #xed_get_chip_features(). -XED_DLL_EXPORT xed_error_enum_t -xed_decode_with_features(xed_decoded_inst_t* xedd, - const xed_uint8_t* itext, - const unsigned int bytes, - xed_chip_features_t* features); - - -#endif - diff --git a/target/i386/latx/include/xed/xed-decoded-inst-api.h b/target/i386/latx/include/xed/xed-decoded-inst-api.h deleted file mode 100644 index 39a8f2fe71b..00000000000 --- a/target/i386/latx/include/xed/xed-decoded-inst-api.h +++ /dev/null @@ -1,699 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-decoded-inst-api.h -/// - -#if !defined(XED_DECODED_INST_API_H) -# define XED_DECODED_INST_API_H - -#include "xed-decoded-inst.h" -#include "xed-operand-accessors.h" -#include "xed-state.h" -#include "xed-operand-values-interface.h" -#include "xed-print-info.h" - -/////////////////////////////////////////////////////// -/// API -/////////////////////////////////////////////////////// - -/// @name xed_decoded_inst_t High-level accessors -//@{ -/// @ingroup DEC -/// Return true if the instruction is valid -static XED_INLINE xed_bool_t -xed_decoded_inst_valid(const xed_decoded_inst_t* p ) { - return XED_STATIC_CAST(xed_bool_t,(p->_inst != 0)); -} -/// @ingroup DEC -/// Return the #xed_inst_t structure for this instruction. This is the -/// route to the basic operands form information. -static XED_INLINE const xed_inst_t* -xed_decoded_inst_inst( const xed_decoded_inst_t* p) { - return p->_inst; -} - - -/// @ingroup DEC -/// Return the instruction #xed_category_enum_t enumeration -static XED_INLINE xed_category_enum_t -xed_decoded_inst_get_category(const xed_decoded_inst_t* p) { - xed_assert(p->_inst != 0); - return xed_inst_category(p->_inst); -} -/// @ingroup DEC -/// Return the instruction #xed_extension_enum_t enumeration -static XED_INLINE xed_extension_enum_t -xed_decoded_inst_get_extension( const xed_decoded_inst_t* p) { - xed_assert(p->_inst != 0); - return xed_inst_extension(p->_inst); -} -/// @ingroup DEC -/// Return the instruction #xed_isa_set_enum_t enumeration -static XED_INLINE xed_isa_set_enum_t -xed_decoded_inst_get_isa_set(xed_decoded_inst_t const* const p) { - xed_assert(p->_inst != 0); - return xed_inst_isa_set(p->_inst); -} -/// @ingroup DEC -/// Return the instruction #xed_iclass_enum_t enumeration. -static XED_INLINE xed_iclass_enum_t -xed_decoded_inst_get_iclass( const xed_decoded_inst_t* p){ - xed_assert(p->_inst != 0); - return xed_inst_iclass(p->_inst); -} - -/// @name xed_decoded_inst_t Attributes and properties -//@{ -/// @ingroup DEC -/// Returns 1 if the attribute is defined for this instruction. -XED_DLL_EXPORT xed_uint32_t -xed_decoded_inst_get_attribute(const xed_decoded_inst_t* p, - xed_attribute_enum_t attr); - -/// @ingroup DEC -/// Returns the attribute bitvector -XED_DLL_EXPORT xed_attributes_t -xed_decoded_inst_get_attributes(const xed_decoded_inst_t* p); -//@} - -/// @ingroup DEC -/// Returns 1 if the instruction is xacquire. -XED_DLL_EXPORT xed_uint32_t -xed_decoded_inst_is_xacquire(const xed_decoded_inst_t* p); - -/// @ingroup DEC -/// Returns 1 if the instruction is xrelease. -XED_DLL_EXPORT xed_uint32_t -xed_decoded_inst_is_xrelease(const xed_decoded_inst_t* p); - -/// @ingroup DEC -/// Returns 1 if the instruction has mpx prefix. -XED_DLL_EXPORT xed_uint32_t -xed_decoded_inst_has_mpx_prefix(const xed_decoded_inst_t* p); - -/// @ingroup DEC -/// Returns the modrm byte -XED_DLL_EXPORT xed_uint8_t -xed_decoded_inst_get_modrm(const xed_decoded_inst_t* p); - -/// @ingroup DEC -/// Returns 1 iff the instruction uses destination-masking. This is 0 for -/// blend operations that use their mask field as a control. -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_masked_vector_operation(xed_decoded_inst_t* p); - -/// @ingroup DEC -/// Returns 128, 256 or 512 for operations in the VEX, EVEX (or XOP) -/// encoding space and returns 0 for (most) nonvector operations. -/// This usually the content of the VEX.L or EVEX.LL field, reinterpreted. -/// Some GPR instructions (like the BMI1/BMI2) are encoded in the VEX space -/// and return non-zero values from this API. -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_vector_length_bits(xed_decoded_inst_t const* const p); - -/// @ingroup DEC -/// Returns the number of legacy prefixes. -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_get_nprefixes(const xed_decoded_inst_t* p); - -//@} - - -/// @name xed_decoded_inst_t Operands -//@{ -/// @ingroup DEC -/// Obtain a constant pointer to the operands -static XED_INLINE const xed_operand_values_t* -xed_decoded_inst_operands_const(const xed_decoded_inst_t* p) { - return p; -} -/// @ingroup DEC -/// Obtain a non-constant pointer to the operands -static XED_INLINE xed_operand_values_t* -xed_decoded_inst_operands(xed_decoded_inst_t* p) { - return p; -} - -/// Return the length in bits of the operand_index'th operand. -/// @ingroup DEC -XED_DLL_EXPORT unsigned int -xed_decoded_inst_operand_length_bits(const xed_decoded_inst_t* p, - unsigned int operand_index); - - -/// Deprecated -- returns the length in bytes of the operand_index'th -/// operand. Use #xed_decoded_inst_operand_length_bits() instead. -/// @ingroup DEC -XED_DLL_EXPORT unsigned int -xed_decoded_inst_operand_length(const xed_decoded_inst_t* p, - unsigned int operand_index); - - -/// Return the number of operands -/// @ingroup DEC -static XED_INLINE unsigned int -xed_decoded_inst_noperands(const xed_decoded_inst_t* p) { - unsigned int noperands = xed_inst_noperands(xed_decoded_inst_inst(p)); - return noperands; -} - - -/// Return the number of element in the operand (for SSE and AVX operands) -/// @ingroup DEC -XED_DLL_EXPORT unsigned int -xed_decoded_inst_operand_elements(const xed_decoded_inst_t* p, - unsigned int operand_index); - -/// Return the size of an element in bits (for SSE and AVX operands) -/// @ingroup DEC -XED_DLL_EXPORT unsigned int -xed_decoded_inst_operand_element_size_bits(const xed_decoded_inst_t* p, - unsigned int operand_index); - -/// Return the type of an element of type #xed_operand_element_type_enum_t -/// (for SSE and AVX operands) -/// @ingroup DEC -XED_DLL_EXPORT xed_operand_element_type_enum_t -xed_decoded_inst_operand_element_type(const xed_decoded_inst_t* p, - unsigned int operand_index); - -/// Interpret the operand action in light of AVX512 masking and -/// zeroing/merging. If masking and merging are used together, the dest -/// operand may also be read. If masking and merging are used together, -/// the elemnents of dest operand register may be conditionally written (so -/// that input values live on in the output register). -/// @ingroup DEC -XED_DLL_EXPORT xed_operand_action_enum_t -xed_decoded_inst_operand_action(const xed_decoded_inst_t* p, - unsigned int operand_index); - -//@} - -/// @name xed_decoded_inst_t AVX512 Masking -//@{ -/// Returns true if the instruction uses write-masking -/// @ingroup DEC -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_masking(const xed_decoded_inst_t* p); - -/// Returns true if the instruction uses write-masking with merging -/// @ingroup DEC -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_merging(const xed_decoded_inst_t* p); - -/// Returns true if the instruction uses write-masking with zeroing -/// @ingroup DEC -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_zeroing(const xed_decoded_inst_t* p); - -/// Returns the maximum number elements processed for an AVX512 vector -/// instruction. Scalars report 1 element. -/// @ingroup DEC -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_avx512_dest_elements(const xed_decoded_inst_t* p); - -//@} - -/// @name xed_decoded_inst_t Initialization -//@{ -/// @ingroup DEC -/// Zero the decode structure, but set the machine state/mode -/// information. Re-initializes all operands. -XED_DLL_EXPORT void -xed_decoded_inst_zero_set_mode(xed_decoded_inst_t* p, - const xed_state_t* dstate); - -/// @ingroup DEC -/// Zero the decode structure, but preserve the existing machine state/mode -/// information. Re-initializes all operands. -XED_DLL_EXPORT void xed_decoded_inst_zero_keep_mode(xed_decoded_inst_t* p); - - -/// @ingroup DEC -/// Zero the decode structure completely. Re-initializes all operands. -XED_DLL_EXPORT void xed_decoded_inst_zero(xed_decoded_inst_t* p); - -/// @ingroup DEC -/// Set the machine mode and stack addressing width directly. This is NOT a -/// full initialization; Call #xed_decoded_inst_zero() before using this if -/// you want a clean slate. -static XED_INLINE void -xed_decoded_inst_set_mode(xed_decoded_inst_t* p, - xed_machine_mode_enum_t mmode, - xed_address_width_enum_t stack_addr_width) -{ - xed_state_t dstate; - dstate.mmode = mmode; - dstate.stack_addr_width = stack_addr_width; - xed_operand_values_set_mode(p, &dstate); -} - - - -/// @ingroup DEC -/// Zero the decode structure, but copy the existing machine state/mode -/// information from the supplied operands pointer. Same as -/// #xed_decoded_inst_zero_keep_mode. -XED_DLL_EXPORT void -xed_decoded_inst_zero_keep_mode_from_operands( - xed_decoded_inst_t* p, - const xed_operand_values_t* operands); - -/// @name xed_decoded_inst_t Length -//@{ -/// @ingroup DEC -/// Return the length of the decoded instruction in bytes. -static XED_INLINE xed_uint_t -xed_decoded_inst_get_length(const xed_decoded_inst_t* p) { - return p->_decoded_length; -} - -//@} - - -/// @name xed_decoded_inst_t get Byte -//@{ -/// @ingroup DEC -/// Read itext byte. -static XED_INLINE xed_uint8_t -xed_decoded_inst_get_byte(const xed_decoded_inst_t* p, xed_uint_t byte_index) -{ - /// Read a whole byte from the normal input bytes. - xed_uint8_t out = p->_byte_array._dec[byte_index]; - return out; -} - -//@} - -/// @name Modes -//@{ -/// @ingroup DEC -/// Returns 16/32/64 indicating the machine mode with in bits. This is -/// derived from the input mode information. -static XED_INLINE xed_uint_t -xed_decoded_inst_get_machine_mode_bits(const xed_decoded_inst_t* p) { - xed_uint_t mode = xed3_operand_get_mode(p); - if (mode == 2) return 64; - if (mode == 1) return 32; - return 16; -} -/// @ingroup DEC -/// Returns 16/32/64 indicating the stack addressing mode with in -/// bits. This is derived from the input mode information. -static XED_INLINE xed_uint_t -xed_decoded_inst_get_stack_address_mode_bits(const xed_decoded_inst_t* p) { - xed_uint_t smode = xed3_operand_get_smode(p); - if (smode == 2) return 64; - if (smode == 1) return 32; - return 16; -} - -/// Returns the operand width in bits: 8/16/32/64. This is different than -/// the #xed_operand_values_get_effective_operand_width() which only -/// returns 16/32/64. This factors in the BYTEOP attribute when computing -/// its return value. This function provides a information for that is only -/// useful for (scalable) GPR-operations. Individual operands have more -/// specific information available from -/// #xed_decoded_inst_operand_element_size_bits() -/// @ingroup DEC -XED_DLL_EXPORT xed_uint32_t -xed_decoded_inst_get_operand_width(const xed_decoded_inst_t* p); - -/// Return the user-specified #xed_chip_enum_t chip name, or -/// XED_CHIP_INVALID if not set. -/// @ingroup DEC -static XED_INLINE xed_chip_enum_t -xed_decoded_inst_get_input_chip(const xed_decoded_inst_t* p) { - return xed3_operand_get_chip(p); -} - -/// Set a user-specified #xed_chip_enum_t chip name for restricting decode -/// @ingroup DEC -static XED_INLINE void -xed_decoded_inst_set_input_chip(xed_decoded_inst_t* p, - xed_chip_enum_t chip) { - xed3_operand_set_chip(p,chip); -} - - -/// Indicate if this decoded instruction is valid for the specified -/// #xed_chip_enum_t chip -/// @ingroup DEC -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_valid_for_chip(xed_decoded_inst_t const* const p, - xed_chip_enum_t chip); - -//@} - - - - -/// @name IFORM handling -//@{ - -/// @ingroup DEC -/// Return the instruction iform enum of type #xed_iform_enum_t . -static XED_INLINE xed_iform_enum_t -xed_decoded_inst_get_iform_enum(const xed_decoded_inst_t* p) { - xed_assert(p->_inst != 0); - return xed_inst_iform_enum(p->_inst); -} - -/// @ingroup DEC -/// Return the instruction zero-based iform number based on masking the -/// corresponding #xed_iform_enum_t. This value is suitable for -/// dispatching. The maximum value for a particular iclass is provided by -/// #xed_iform_max_per_iclass() . -static XED_INLINE unsigned int -xed_decoded_inst_get_iform_enum_dispatch(const xed_decoded_inst_t* p) { - xed_assert(p->_inst != 0); - return xed_inst_iform_enum(p->_inst) - - xed_iform_first_per_iclass(xed_inst_iclass(p->_inst)); -} -//@} - - - - -/// @name xed_decoded_inst_t Printers -//@{ -/// @ingroup PRINT -/// Print out all the information about the decoded instruction to the -/// buffer buf whose length is maximally buflen. This is for debugging. -XED_DLL_EXPORT void -xed_decoded_inst_dump(const xed_decoded_inst_t* p, char* buf, int buflen); - - - -/// @ingroup PRINT -/// Print the instruction information in a verbose format. -/// This is for debugging. -/// @param p a #xed_decoded_inst_t for a decoded instruction -/// @param buf a buffer to write the disassembly in to. -/// @param buflen maximum length of the disassembly buffer -/// @param runtime_address the address of the instruction being disassembled. If zero, the offset is printed for relative branches. If nonzero, XED attempts to print the target address for relative branches. -/// @return Returns 0 if the disassembly fails, 1 otherwise. -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_dump_xed_format(const xed_decoded_inst_t* p, - char* buf, - int buflen, - xed_uint64_t runtime_address) ; - - -/// Disassemble the decoded instruction using the specified syntax. -/// The output buffer must be at least 25 bytes long. Returns true if -/// disassembly proceeded without errors. -/// @param syntax a #xed_syntax_enum_t the specifies the disassembly format -/// @param xedd a #xed_decoded_inst_t for a decoded instruction -/// @param out_buffer a buffer to write the disassembly in to. -/// @param buffer_len maximum length of the disassembly buffer -/// @param runtime_instruction_address the address of the instruction being disassembled. If zero, the offset is printed for relative branches. If nonzero, XED attempts to print the target address for relative branches. -/// @param context A void* used only for the call back routine for symbolic disassembly if one is provided. Can be zero. -/// @param symbolic_callback A function pointer for obtaining symbolic disassembly. Can be zero. -/// @return Returns 0 if the disassembly fails, 1 otherwise. -///@ingroup PRINT -XED_DLL_EXPORT xed_bool_t -xed_format_context(xed_syntax_enum_t syntax, - const xed_decoded_inst_t* xedd, - char* out_buffer, - int buffer_len, - xed_uint64_t runtime_instruction_address, - void* context, - xed_disassembly_callback_fn_t symbolic_callback); - - -/// @ingroup PRINT -/// Disassemble the instruction information to a buffer. See the -/// #xed_print_info_t for the required public fields of the argument. -/// This is the preferred method of doing disassembly. -/// The output buffer must be at least 25 bytes long. -/// @param pi a #xed_print_info_t -/// @return Returns 0 if the disassembly fails, 1 otherwise. -XED_DLL_EXPORT xed_bool_t -xed_format_generic(xed_print_info_t* pi); - -//@} - -/// @name xed_decoded_inst_t Operand Field Details -//@{ -/// @ingroup DEC -XED_DLL_EXPORT xed_reg_enum_t -xed_decoded_inst_get_seg_reg(const xed_decoded_inst_t* p, - unsigned int mem_idx); -/// @ingroup DEC -XED_DLL_EXPORT xed_reg_enum_t -xed_decoded_inst_get_base_reg(const xed_decoded_inst_t* p, - unsigned int mem_idx); -XED_DLL_EXPORT xed_reg_enum_t -xed_decoded_inst_get_index_reg(const xed_decoded_inst_t* p, - unsigned int mem_idx); -/// @ingroup DEC -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_get_scale(const xed_decoded_inst_t* p, - unsigned int mem_idx); -/// @ingroup DEC -XED_DLL_EXPORT xed_int64_t -xed_decoded_inst_get_memory_displacement(const xed_decoded_inst_t* p, - unsigned int mem_idx); -/// @ingroup DEC -/// Result in BYTES -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_get_memory_displacement_width(const xed_decoded_inst_t* p, - unsigned int mem_idx); -/// @ingroup DEC -/// Result in BITS -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_get_memory_displacement_width_bits(const xed_decoded_inst_t* p, - unsigned int mem_idx); -/// @ingroup DEC -XED_DLL_EXPORT xed_int32_t -xed_decoded_inst_get_branch_displacement(const xed_decoded_inst_t* p); -/// @ingroup DEC -/// Result in BYTES -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_get_branch_displacement_width(const xed_decoded_inst_t* p); -/// @ingroup DEC -/// Result in BITS -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_get_branch_displacement_width_bits( - const xed_decoded_inst_t* p); -/// @ingroup DEC -XED_DLL_EXPORT xed_uint64_t -xed_decoded_inst_get_unsigned_immediate(const xed_decoded_inst_t* p); -/// @ingroup DEC -/// Return true if the first immediate (IMM0) is signed -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_get_immediate_is_signed(const xed_decoded_inst_t* p); -/// @ingroup DEC -/// Return the immediate width in BYTES. -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_get_immediate_width(const xed_decoded_inst_t* p); -/// @ingroup DEC -/// Return the immediate width in BITS. -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_get_immediate_width_bits(const xed_decoded_inst_t* p); -/// @ingroup DEC -XED_DLL_EXPORT xed_int32_t -xed_decoded_inst_get_signed_immediate(const xed_decoded_inst_t* p); -/// @ingroup DEC -/// Return the second immediate. -static XED_INLINE xed_uint8_t -xed_decoded_inst_get_second_immediate(const xed_decoded_inst_t* p) { - return xed3_operand_get_uimm1(p); -} - -/// @ingroup DEC -/// Return the specified register operand. The specifier is of type -/// #xed_operand_enum_t . -XED_DLL_EXPORT xed_reg_enum_t -xed_decoded_inst_get_reg(const xed_decoded_inst_t* p, - xed_operand_enum_t reg_operand); - - -/// See the comment on xed_decoded_inst_uses_rflags(). This can return -/// 0 if the flags are really not used by this instruction. -/// @ingroup DEC -XED_DLL_EXPORT const xed_simple_flag_t* -xed_decoded_inst_get_rflags_info( const xed_decoded_inst_t* p ); - -/// This returns 1 if the flags are read or written. This will return 0 -/// otherwise. This will return 0 if the flags are really not used by this -/// instruction. For some shifts/rotates, XED puts a flags operand in the -/// operand array before it knows if the flags are used because of -/// mode-dependent masking effects on the immediate. -/// @ingroup DEC -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_uses_rflags(const xed_decoded_inst_t* p); - -/// @ingroup DEC -XED_DLL_EXPORT xed_uint_t -xed_decoded_inst_number_of_memory_operands(const xed_decoded_inst_t* p); -/// @ingroup DEC -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_mem_read(const xed_decoded_inst_t* p, unsigned int mem_idx); -/// @ingroup DEC -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_mem_written(const xed_decoded_inst_t* p, unsigned int mem_idx); -/// @ingroup DEC -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_mem_written_only(const xed_decoded_inst_t* p, - unsigned int mem_idx); -/// @ingroup DEC -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_conditionally_writes_registers(const xed_decoded_inst_t* p); -/// returns bytes -/// @ingroup DEC -XED_DLL_EXPORT unsigned int -xed_decoded_inst_get_memory_operand_length(const xed_decoded_inst_t* p, - unsigned int memop_idx); - -/// Returns the addressing width in bits (16,32,64) for MEM0 (memop_idx==0) -/// or MEM1 (memop_idx==1). This factors in things like whether or not the -/// reference is an implicit stack push/pop reference, the machine mode and -// 67 prefixes if present. -/// @ingroup DEC -XED_DLL_EXPORT unsigned int -xed_decoded_inst_get_memop_address_width(const xed_decoded_inst_t* p, - xed_uint_t memop_idx); - - - -/// @ingroup DEC -/// Returns true if the instruction is a prefetch -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_is_prefetch(const xed_decoded_inst_t* p); - -/// @ingroup DEC -/// Return 1 for broadcast instructions or AVX512 load-op instructions using the broadcast feature -/// 0 otherwise. Logical OR of -/// #xed_decoded_inst_is_broadcast_instruction() and -/// #xed_decoded_inst_uses_embedded_broadcast(). -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_is_broadcast(const xed_decoded_inst_t* p); -/// @ingroup DEC -/// Return 1 for broadcast instruction. (NOT including AVX512 load-op instructions) -/// 0 otherwise. Just a category check. -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_is_broadcast_instruction(const xed_decoded_inst_t* p); -/// @ingroup DEC -/// Return 1 for AVX512 load-op instructions using the broadcast feature, -/// 0 otherwise. -XED_DLL_EXPORT xed_bool_t -xed_decoded_inst_uses_embedded_broadcast(const xed_decoded_inst_t* p); - -//@} - - -/// @name xed_decoded_inst_t Modification -//@{ -// Modifying decoded instructions before re-encoding -/// @ingroup DEC -XED_DLL_EXPORT void -xed_decoded_inst_set_scale(xed_decoded_inst_t* p, xed_uint_t scale); -/// @ingroup DEC -/// Set the memory displacement using a BYTE length -XED_DLL_EXPORT void -xed_decoded_inst_set_memory_displacement(xed_decoded_inst_t* p, - xed_int64_t disp, - xed_uint_t length_bytes); -/// @ingroup DEC -/// Set the branch displacement using a BYTE length -XED_DLL_EXPORT void -xed_decoded_inst_set_branch_displacement(xed_decoded_inst_t* p, - xed_int32_t disp, - xed_uint_t length_bytes); -/// @ingroup DEC -/// Set the signed immediate a BYTE length -XED_DLL_EXPORT void -xed_decoded_inst_set_immediate_signed(xed_decoded_inst_t* p, - xed_int32_t x, - xed_uint_t length_bytes); -/// @ingroup DEC -/// Set the unsigned immediate a BYTE length -XED_DLL_EXPORT void -xed_decoded_inst_set_immediate_unsigned(xed_decoded_inst_t* p, - xed_uint64_t x, - xed_uint_t length_bytes); - - -/// @ingroup DEC -/// Set the memory displacement a BITS length -XED_DLL_EXPORT void -xed_decoded_inst_set_memory_displacement_bits(xed_decoded_inst_t* p, - xed_int64_t disp, - xed_uint_t length_bits); -/// @ingroup DEC -/// Set the branch displacement a BITS length -XED_DLL_EXPORT void -xed_decoded_inst_set_branch_displacement_bits(xed_decoded_inst_t* p, - xed_int32_t disp, - xed_uint_t length_bits); -/// @ingroup DEC -/// Set the signed immediate a BITS length -XED_DLL_EXPORT void -xed_decoded_inst_set_immediate_signed_bits(xed_decoded_inst_t* p, - xed_int32_t x, - xed_uint_t length_bits); -/// @ingroup DEC -/// Set the unsigned immediate a BITS length -XED_DLL_EXPORT void -xed_decoded_inst_set_immediate_unsigned_bits(xed_decoded_inst_t* p, - xed_uint64_t x, - xed_uint_t length_bits); - -//@} - -/// @name xed_decoded_inst_t User Data Field -//@{ -/// @ingroup DEC -/// Return a user data field for arbitrary use by the user after decoding. -static XED_INLINE xed_uint64_t -xed_decoded_inst_get_user_data(xed_decoded_inst_t* p) { - return p->u.user_data; -} -/// @ingroup DEC -/// Modify the user data field. -static XED_INLINE void -xed_decoded_inst_set_user_data(xed_decoded_inst_t* p, - xed_uint64_t new_value) { - p->u.user_data = new_value; -} -//@} - -/// @name xed_decoded_inst_t Classifiers -//@{ -/// @ingroup DEC -/// True for AVX512 (EVEX-encoded) SIMD and (VEX encoded) K-mask instructions -XED_DLL_EXPORT xed_bool_t -xed_classify_avx512(const xed_decoded_inst_t* d); -/// @ingroup DEC -/// True for AVX512 (VEX-encoded) K-mask operations -XED_DLL_EXPORT xed_bool_t -xed_classify_avx512_maskop(const xed_decoded_inst_t* d); -/// @ingroup DEC -/// True for AVX/AVX2 SIMD VEX-encoded operations. Does not include BMI/BMI2 instructions. -XED_DLL_EXPORT xed_bool_t -xed_classify_avx(const xed_decoded_inst_t* d); -/// @ingroup DEC -/// True for SSE/SSE2/etc. SIMD operations. Includes AES and PCLMULQDQ -XED_DLL_EXPORT xed_bool_t -xed_classify_sse(const xed_decoded_inst_t* d); - -//@} -#endif - diff --git a/target/i386/latx/include/xed/xed-decoded-inst.h b/target/i386/latx/include/xed/xed-decoded-inst.h deleted file mode 100644 index fb8434087e4..00000000000 --- a/target/i386/latx/include/xed/xed-decoded-inst.h +++ /dev/null @@ -1,98 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-decoded-inst.h -/// - -#if !defined(XED_DECODER_STATE_H) -# define XED_DECODER_STATE_H -#include "xed-common-hdrs.h" -#include "xed-common-defs.h" -#include "xed-portability.h" -#include "xed-util.h" -#include "xed-types.h" -#include "xed-inst.h" -#include "xed-flags.h" -#if defined(XED_ENCODER) -# include "xed-encoder-gen-defs.h" //generated -#endif -#include "xed-chip-enum.h" //generated -#include "xed-operand-element-type-enum.h" // a generated file -#include "xed-operand-storage.h" // a generated file - -typedef union { - xed_uint32_t i; - struct { - xed_uint8_t has_modrm; - xed_uint8_t has_disp; - xed_uint8_t has_imm; - } s; -} xed_ild_vars_t; - -struct xed_encoder_vars_s; -struct xed_decoder_vars_s; -/// @ingroup DEC -/// The main container for instructions. After decode, it holds an array of -/// operands with derived information from decode and also valid -/// #xed_inst_t pointer which describes the operand templates and the -/// operand order. See @ref DEC for API documentation. -typedef struct xed_decoded_inst_s { - /// The _operands are storage for information discovered during - /// decoding. They are also used by encode. The accessors for these - /// operands all have the form xed3_operand_{get,set}_*(). They should - /// be considered internal and subject to change over time. It is - /// preferred that you use xed_decoded_inst_*() or the - /// xed_operand_values_*() functions when available. - xed_operand_storage_t _operands; - -#if defined(XED_ENCODER) - /// Used for encode operand ordering. Not set by decode. - xed_uint8_t _operand_order[XED_ENCODE_ORDER_MAX_OPERANDS]; - /// Length of the _operand_order[] array. - xed_uint8_t _n_operand_order; -#endif - xed_uint8_t _decoded_length; - - /// when we decode an instruction, we set the _inst and get the - /// properites of that instruction here. This also points to the - /// operands template array. - const xed_inst_t* _inst; - - // decoder does not change it, encoder does - union { - xed_uint8_t* _enc; - const xed_uint8_t* _dec; - } _byte_array; - - // The ev field is stack allocated by xed_encode(). It is per-encode - // transitory data. - union { - /* user_data is available as a user data storage field after - * decoding. It does not live across re-encodes or re-decodes. */ - xed_uint64_t user_data; - xed_ild_vars_t ild_data; -#if defined(XED_ENCODER) - struct xed_encoder_vars_s* ev; -#endif - } u; - -} xed_decoded_inst_t; - -typedef xed_decoded_inst_t xed_operand_values_t; - -#endif - diff --git a/target/i386/latx/include/xed/xed-disas.h b/target/i386/latx/include/xed/xed-disas.h deleted file mode 100644 index c43b9bdda93..00000000000 --- a/target/i386/latx/include/xed/xed-disas.h +++ /dev/null @@ -1,52 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-disas.h -/// - -#if !defined(XED_DISAS_H) -# define XED_DISAS_H - -#include "xed-types.h" - -/// @ingroup PRINT -/// A #xed_disassembly_callback_fn_t takes an address, a pointer to a -/// symbol buffer of buffer_length bytes, and a pointer to an offset. The -/// function fills in the symbol_buffer and sets the offset to the desired -/// offset for that symbol. If the function succeeds, it returns 1. -// The call back should return 0 if the buffer is not long enough to -// include the null termination.If no symbolic information is -// located, the function returns zero. -/// @param address The input address for which we want symbolic name and offset -/// @param symbol_buffer A buffer to hold the symbol name. The callback function should fill this in and terminate -/// with a null byte. -/// @param buffer_length The maximum length of the symbol_buffer including then null -/// @param offset A pointer to a xed_uint64_t to hold the offset from the provided symbol. -/// @param context This void* pointer passed to the disassembler's new interface so that the caller can identify -/// the proper context against which to resolve the symbols. -/// The disassembler passes this value to -/// the callback. The legacy formatters -/// that do not have context will pass zero for this parameter. -/// @return 0 on failure, 1 on success. -typedef int (*xed_disassembly_callback_fn_t)( - xed_uint64_t address, - char* symbol_buffer, - xed_uint32_t buffer_length, - xed_uint64_t* offset, - void* context); - -#endif diff --git a/target/i386/latx/include/xed/xed-encode-check.h b/target/i386/latx/include/xed/xed-encode-check.h deleted file mode 100644 index 622065191f2..00000000000 --- a/target/i386/latx/include/xed/xed-encode-check.h +++ /dev/null @@ -1,31 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ - - -#ifndef XED_ENCODE_CHECK_H -# define XED_ENCODE_CHECK_H -#include "xed-common-hdrs.h" -#include "xed-types.h" - - -/// turn off (or on) argument checking if using the checked encoder interface. -/// values 1, 0 -/// @ingroup ENC2 -XED_DLL_EXPORT void xed_enc2_set_check_args(xed_bool_t on); - -#endif diff --git a/target/i386/latx/include/xed/xed-encode-direct.h b/target/i386/latx/include/xed/xed-encode-direct.h deleted file mode 100644 index c823e4b1586..00000000000 --- a/target/i386/latx/include/xed/xed-encode-direct.h +++ /dev/null @@ -1,115 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ - - -#ifndef XED_ENCODE_DIRECT_H -# define XED_ENCODE_DIRECT_H -#include "xed-common-hdrs.h" -#include "xed-portability.h" -#include "xed-types.h" -#include "xed-error-enum.h" -#include -#include - -/// This structure is filled in by the various XED ENC2 functions. It -/// should not be directly manipulated by user code. -/// @ingroup ENC2 -typedef struct { - xed_uint8_t* itext; // supplied by user during init - xed_uint32_t cursor; // where we write next byte - - xed_uint32_t has_sib:1; - xed_uint32_t has_disp8:1; - xed_uint32_t has_disp16:1; - xed_uint32_t has_disp32:1; - - xed_uint32_t rexw:1; // and vex, evex - xed_uint32_t rexr:1; // and vex, evex - xed_uint32_t rexx:1; // and vex, evex - xed_uint32_t rexb:1; // and vex, evex - - xed_uint32_t need_rex:1; // for SIL,DIL,BPL,SPL - xed_uint32_t evexrr:1; - xed_uint32_t vexl:1; - xed_uint32_t evexb:1; // also sae enabler for reg-only & vl=512 - - xed_uint32_t evexvv:1; - xed_uint32_t evexz:1; - xed_uint32_t evexll:2; // also rc bits in some case - - xed_uint32_t mod:2; - xed_uint32_t reg:3; - xed_uint32_t rm:3; - xed_uint32_t sibscale:2; - xed_uint32_t sibindex:3; - xed_uint32_t sibbase:3; - xed_uint32_t evexaaa:3; - xed_uint32_t map:3; - xed_uint32_t vexpp:3; // and evex - xed_uint32_t vvvv:4; - xed_uint32_t opcode_srm:3; /// for "partial opcode" instructions - - xed_uint8_t imm8_reg; // for _SE imm8-specified registers. - -} xed_enc2_req_payload_t; - - -/// A wrapper for #xed_enc2_req_payload_t . -/// @ingroup ENC2 -typedef union { - xed_enc2_req_payload_t s; -} xed_enc2_req_t; - -/// Zero out a #xed_enc2_req_t structure and set the output pointer. -/// Required before calling and any ENC2 encoding function. -/// @ingroup ENC2 -static XED_INLINE void xed_enc2_req_t_init(xed_enc2_req_t* r, xed_uint8_t* output_buffer) { - memset(r, 0, sizeof(xed_enc2_req_t)); - r->s.itext = output_buffer; -} - -/// Returns the number of bytes that were used for the encoding. -/// @ingroup ENC2 -static XED_INLINE xed_uint32_t xed_enc2_encoded_length(xed_enc2_req_t* r) { - return r->s.cursor; -} - - -/// Emit a legacy segment prefix byte in to the specified request's output buffer. -/// @ingroup ENC2 -XED_DLL_EXPORT void xed_emit_seg_prefix(xed_enc2_req_t* r, - xed_reg_enum_t reg); - - -typedef void (xed_user_abort_handler_t)(const char* format, va_list args); - -/// Set a function taking a variable-number-of-arguments (stdarg) to handle -/// the errors and die. The argument are like printf with a format string -/// followed by a varaible number of arguments. -/// @ingroup ENC2 -XED_DLL_EXPORT void xed_enc2_set_error_handler(xed_user_abort_handler_t* fn); - -/// The error handler routine. This function is called by encoder functions -/// upon detecting argument errors. It fist attempts to call the -/// user-registered handler (configured by #xed_enc2_set_error_handler() ), -/// or if no user handler is set, then this function calls printf() and -/// then abort(). If the user handler returns, abort() is still called. -/// @ingroup ENC2 -XED_DLL_EXPORT void xed_enc2_error(const char* fmt, ...); - -#endif diff --git a/target/i386/latx/include/xed/xed-encode.h b/target/i386/latx/include/xed/xed-encode.h deleted file mode 100644 index ce18b75b5e5..00000000000 --- a/target/i386/latx/include/xed/xed-encode.h +++ /dev/null @@ -1,279 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-encode.h - - -#ifndef XED_ENCODE_H -# define XED_ENCODE_H -#include "xed-common-hdrs.h" -#include "xed-types.h" -#include "xed-error-enum.h" -#include "xed-operand-values-interface.h" -#include "xed-operand-width-enum.h" -#include "xed-encoder-iforms.h" //generated -#include "xed-encoder-gen-defs.h" //generated - -// we now (mostly) share the decode data structure -#include "xed-decoded-inst.h" - - -// establish a type equivalence for the xed_encoder_request_t and the -// corresponding xed_decoded_inst_t. - -/// @ingroup ENC -typedef struct xed_decoded_inst_s xed_encoder_request_s; -/// @ingroup ENC -typedef xed_decoded_inst_t xed_encoder_request_t; - - - -/// @ingroup ENC -XED_DLL_EXPORT xed_iclass_enum_t -xed_encoder_request_get_iclass( const xed_encoder_request_t* p); - -///////////////////////////////////////////////////////// -// set functions - -/// @ingroup ENC -XED_DLL_EXPORT void -xed_encoder_request_set_iclass( xed_encoder_request_t* p, - xed_iclass_enum_t iclass); - - -/// @name Primary Encode Functions -//@{ -/// @ingroup ENC -XED_DLL_EXPORT void -xed_encoder_request_set_effective_operand_width( xed_encoder_request_t* p, - xed_uint_t width_bits); -/// @ingroup ENC -XED_DLL_EXPORT void -xed_encoder_request_set_effective_address_size( xed_encoder_request_t* p, - xed_uint_t width_bits); -/*! @ingroup ENC - * - * Set the operands array element indexed by operand to the actual register - * name reg. - * - * @param[in] p xed_encoder_request_t - * @param[in] operand indicates which register operand storage field to use - * @param[in] reg the actual register represented (EAX, etc.) to store. - */ -XED_DLL_EXPORT void xed_encoder_request_set_reg(xed_encoder_request_t* p, - xed_operand_enum_t operand, - xed_reg_enum_t reg); -//@} - -/// @name Operand Order -//@{ -/*! @ingroup ENC - * Specify the name as the n'th operand in the operand order. - * - * The complication of this function is that the register operand names are - * specific to the position of the operand (REG0, REG1, REG2...). One can - * use this function for registers or one can use the - * xed_encoder_request_set_operand_name_reg() which takes integers instead - * of operand names. - * - * @param[in] p #xed_encoder_request_t - * @param[in] operand_index xed_uint_t representing n'th operand position - * @param[in] name #xed_operand_enum_t operand name. - */ -XED_DLL_EXPORT void -xed_encoder_request_set_operand_order(xed_encoder_request_t* p, - xed_uint_t operand_index, - xed_operand_enum_t name); - -/*! @ingroup ENC - * Retrieve the name of the n'th operand in the operand order. - * - * @param[in] p #xed_encoder_request_t - * @param[in] operand_index xed_uint_t representing n'th operand position - * @return The #xed_operand_enum_t operand name. - */ -XED_DLL_EXPORT xed_operand_enum_t -xed_encoder_request_get_operand_order(xed_encoder_request_t* p, - xed_uint_t operand_index); - - -/// @ingroup ENC -/// Retrieve the number of entries in the encoder operand order array -/// @return The number of entries in the encoder operand order array -static XED_INLINE xed_uint_t -xed_encoder_request_operand_order_entries(xed_encoder_request_t* p) -{ - return p->_n_operand_order; -} - -//@} - - -/// @name branches and far pointers -//@{ -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_set_relbr(xed_encoder_request_t* p); -/// @ingroup ENC -XED_DLL_EXPORT void -xed_encoder_request_set_branch_displacement(xed_encoder_request_t* p, - xed_int32_t brdisp, - xed_uint_t nbytes); -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_set_ptr(xed_encoder_request_t* p); -//@} - - -/// @name Immediates -//@{ -/// @ingroup ENC -/// Set the uimm0 using a BYTE width. -XED_DLL_EXPORT void xed_encoder_request_set_uimm0(xed_encoder_request_t* p, - xed_uint64_t uimm, - xed_uint_t nbytes); -/// @ingroup ENC -/// Set the uimm0 using a BIT width. -XED_DLL_EXPORT void xed_encoder_request_set_uimm0_bits(xed_encoder_request_t* p, - xed_uint64_t uimm, - xed_uint_t nbits); -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_set_uimm1(xed_encoder_request_t* p, - xed_uint8_t uimm); -/// @ingroup ENC -/// same storage as uimm0 -XED_DLL_EXPORT void xed_encoder_request_set_simm(xed_encoder_request_t* p, - xed_int32_t simm, - xed_uint_t nbytes); - -/// @name Memory -//@{ -/// @ingroup ENC -XED_DLL_EXPORT void -xed_encoder_request_set_memory_displacement(xed_encoder_request_t* p, - xed_int64_t memdisp, - xed_uint_t nbytes); - -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_set_agen(xed_encoder_request_t* p); -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_set_mem0(xed_encoder_request_t* p); -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_set_mem1(xed_encoder_request_t* p); -/// @ingroup ENC -XED_DLL_EXPORT void -xed_encoder_request_set_memory_operand_length(xed_encoder_request_t* p, - xed_uint_t nbytes); -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_set_seg0(xed_encoder_request_t* p, - xed_reg_enum_t seg_reg); -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_set_seg1(xed_encoder_request_t* p, - xed_reg_enum_t seg_reg); -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_set_base0(xed_encoder_request_t* p, - xed_reg_enum_t base_reg); -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_set_base1(xed_encoder_request_t* p, - xed_reg_enum_t base_reg) ; -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_set_index(xed_encoder_request_t* p, - xed_reg_enum_t index_reg); -/// @ingroup ENC -XED_DLL_EXPORT void -xed_encoder_request_set_scale(xed_encoder_request_t* p, - xed_uint_t scale); -//@} - -////////////////////////////////////////////// -/// @ingroup ENC -static XED_INLINE const xed_operand_values_t* -xed_encoder_request_operands_const(const xed_encoder_request_t* p) { - return p; -} -/// @ingroup ENC -static XED_INLINE xed_operand_values_t* -xed_encoder_request_operands(xed_encoder_request_t* p) { - return p; -} - -/// @name Initialization -//@{ -/*! @ingroup ENC - * clear the operand order array - * @param[in] p xed_encoder_request_t - */ -XED_DLL_EXPORT void -xed_encoder_request_zero_operand_order(xed_encoder_request_t* p); - -/// @ingroup ENC -XED_DLL_EXPORT void -xed_encoder_request_zero_set_mode(xed_encoder_request_t* p, - const xed_state_t* dstate); -/// @ingroup ENC -XED_DLL_EXPORT void xed_encoder_request_zero(xed_encoder_request_t* p) ; -//@} - -struct xed_decoded_inst_s; //fwd decl -/// @ingroup ENC -/// Converts an decoder request to a valid encoder request. -XED_DLL_EXPORT void -xed_encoder_request_init_from_decode(struct xed_decoded_inst_s* d); - -/// @name String Printing -//@{ -/// @ingroup ENC -XED_DLL_EXPORT void xed_encode_request_print(const xed_encoder_request_t* p, - char* buf, xed_uint_t buflen); -//@} - - - - -/// @name Encoding -//@{ -/// This is the main interface to the encoder. The array should be -/// at most 15 bytes long. The ilen parameter should indicate -/// this length. If the array is too short, the encoder may fail to -/// encode the request. Failure is indicated by a return value of -/// type #xed_error_enum_t that is not equal to -/// #XED_ERROR_NONE. Otherwise, #XED_ERROR_NONE is returned and the -/// length of the encoded instruction is returned in olen. -/// -/// @param r encoder request description (#xed_encoder_request_t), includes mode info -/// @param array the encoded instruction bytes are stored here -/// @param ilen the input length of array. -/// @param olen the actual length of array used for encoding -/// @return success/failure as a #xed_error_enum_t -/// @ingroup ENC -XED_DLL_EXPORT xed_error_enum_t -xed_encode(xed_encoder_request_t* r, - xed_uint8_t* array, - const unsigned int ilen, - unsigned int* olen); - -/// This function will attempt to encode a NOP of exactly ilen -/// bytes. If such a NOP is not encodeable, then false will be returned. -/// -/// @param array the encoded instruction bytes are stored here -/// @param ilen the input length array. -/// @return success/failure as a #xed_error_enum_t -/// @ingroup ENC -XED_DLL_EXPORT xed_error_enum_t -xed_encode_nop(xed_uint8_t* array, - const unsigned int ilen); -//@} - -#endif diff --git a/target/i386/latx/include/xed/xed-encoder-gen-defs.h b/target/i386/latx/include/xed/xed-encoder-gen-defs.h deleted file mode 100644 index 84b619086c6..00000000000 --- a/target/i386/latx/include/xed/xed-encoder-gen-defs.h +++ /dev/null @@ -1,32 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-encoder-gen-defs.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_ENCODER_GEN_DEFS_H) -# define XED_ENCODER_GEN_DEFS_H -#define XED_ENCODE_ORDER_MAX_ENTRIES 32 -#define XED_ENCODE_ORDER_MAX_OPERANDS 5 -#define XED_ENCODE_MAX_FB_PATTERNS 121 -#define XED_ENCODE_MAX_EMIT_PATTERNS 199 -#define XED_ENCODE_FB_VALUES_TABLE_SIZE 3880 -#define XED_ENCODE_MAX_IFORMS 7639 -#define XED_ENC_GROUPS 535 -#endif diff --git a/target/i386/latx/include/xed/xed-encoder-hl.h b/target/i386/latx/include/xed/xed-encoder-hl.h deleted file mode 100644 index 64369683f79..00000000000 --- a/target/i386/latx/include/xed/xed-encoder-hl.h +++ /dev/null @@ -1,671 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ - -#ifndef XED_ENCODER_HL_H -# define XED_ENCODER_HL_H -#include "xed-types.h" -#include "xed-reg-enum.h" -#include "xed-state.h" -#include "xed-iclass-enum.h" -#include "xed-portability.h" -#include "xed-encode.h" -#include "xed-util.h" - - -typedef struct { - xed_int64_t displacement; - xed_uint32_t displacement_bits; -} xed_enc_displacement_t; /* fixme bad name */ - -/// @name Memory Displacement -//@{ -/// @ingroup ENCHL -/// a memory displacement (not for branches) -/// @param displacement The value of the displacement -/// @param displacement_bits The width of the displacement in bits. Typically 8 or 32. -/// @returns #xed_enc_displacement_t -static XED_INLINE -xed_enc_displacement_t xed_disp(xed_int64_t displacement, - xed_uint32_t displacement_bits ) { - xed_enc_displacement_t x; - x.displacement = displacement; - x.displacement_bits = displacement_bits; - return x; -} -//@} - -typedef struct { - xed_reg_enum_t seg; - xed_reg_enum_t base; - xed_reg_enum_t index; - xed_uint32_t scale; - xed_enc_displacement_t disp; -} xed_memop_t; - - -typedef enum { - XED_ENCODER_OPERAND_TYPE_INVALID, - XED_ENCODER_OPERAND_TYPE_BRDISP, - XED_ENCODER_OPERAND_TYPE_REG, - XED_ENCODER_OPERAND_TYPE_IMM0, - XED_ENCODER_OPERAND_TYPE_SIMM0, - XED_ENCODER_OPERAND_TYPE_IMM1, - XED_ENCODER_OPERAND_TYPE_MEM, - XED_ENCODER_OPERAND_TYPE_PTR, - - /* special for things with suppressed implicit memops */ - XED_ENCODER_OPERAND_TYPE_SEG0, - - /* special for things with suppressed implicit memops */ - XED_ENCODER_OPERAND_TYPE_SEG1, - - /* specific operand storage fields -- must supply a name */ - XED_ENCODER_OPERAND_TYPE_OTHER -} xed_encoder_operand_type_t; - -typedef struct { - xed_encoder_operand_type_t type; - union { - xed_reg_enum_t reg; - xed_int32_t brdisp; - xed_uint64_t imm0; - xed_uint8_t imm1; - struct { - xed_operand_enum_t operand_name; - xed_uint32_t value; - } s; - xed_memop_t mem; - } u; - xed_uint32_t width_bits; -} xed_encoder_operand_t; - -/// @name Branch Displacement -//@{ -/// @ingroup ENCHL -/// a relative branch displacement operand -/// @param brdisp The branch displacement -/// @param width_bits The width of the displacement in bits. Typically 8 or 32. -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_relbr(xed_int32_t brdisp, - xed_uint_t width_bits) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_BRDISP; - o.u.brdisp = brdisp; - o.width_bits = width_bits; - return o; -} -//@} - -/// @name Pointer Displacement -//@{ -/// @ingroup ENCHL -/// a relative displacement for a PTR operand -- the subsequent imm0 holds -///the 16b selector -/// @param brdisp The displacement for a far pointer operand -/// @param width_bits The width of the far pointr displacement in bits. -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_ptr(xed_int32_t brdisp, - xed_uint_t width_bits) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_PTR; - o.u.brdisp = brdisp; - o.width_bits = width_bits; - return o; -} -//@} - -/// @name Register and Immediate Operands -//@{ -/// @ingroup ENCHL -/// a register operand -/// @param reg A #xed_reg_enum_t register operand -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_reg(xed_reg_enum_t reg) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_REG; - o.u.reg = reg; - o.width_bits = 0; - return o; -} - -/// @ingroup ENCHL -/// a first immediate operand (known as IMM0) -/// @param v An immdediate operand. -/// @param width_bits The immediate width in bits. -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_imm0(xed_uint64_t v, - xed_uint_t width_bits) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_IMM0; - o.u.imm0 = v; - o.width_bits = width_bits; - return o; -} -/// @ingroup ENCHL -/// an 32b signed immediate operand -/// @param v An signed immdediate operand. -/// @param width_bits The immediate width in bits. -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_simm0(xed_int32_t v, - xed_uint_t width_bits) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_SIMM0; - /* sign conversion: we store the int32 in an uint64. It gets sign - extended. Later we convert it to the right width_bits for the - instruction. The maximum width_bits of a signed immediate is currently - 32b. */ - o.u.imm0 = XED_STATIC_CAST(xed_uint64_t,xed_sign_extend32_64(v)); - o.width_bits = width_bits; - return o; -} - -/// @ingroup ENCHL -/// The 2nd immediate operand (known as IMM1) for rare instructions that require it. -/// @param v The 2nd immdediate (byte-width) operand -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_imm1(xed_uint8_t v) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_IMM1; - o.u.imm1 = v; - o.width_bits = 8; - return o; -} - - -/// @ingroup ENCHL -/// an operand storage field name and value -static XED_INLINE xed_encoder_operand_t xed_other( - xed_operand_enum_t operand_name, - xed_int32_t value) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_OTHER; - o.u.s.operand_name = operand_name; - o.u.s.value = XED_STATIC_CAST(xed_uint32_t,value); - o.width_bits = 0; - return o; -} -//@} - - -//@} - -/// @name Memory and Segment-releated Operands -//@{ - -/// @ingroup ENCHL -/// seg reg override for implicit suppressed memory ops -static XED_INLINE xed_encoder_operand_t xed_seg0(xed_reg_enum_t seg0) { - xed_encoder_operand_t o; - o.width_bits = 0; - o.type = XED_ENCODER_OPERAND_TYPE_SEG0; - o.u.reg = seg0; - return o; -} - -/// @ingroup ENCHL -/// seg reg override for implicit suppressed memory ops -static XED_INLINE xed_encoder_operand_t xed_seg1(xed_reg_enum_t seg1) { - xed_encoder_operand_t o; - o.width_bits = 0; - o.type = XED_ENCODER_OPERAND_TYPE_SEG1; - o.u.reg = seg1; - return o; -} - -/// @ingroup ENCHL -/// memory operand - base only -/// @param base The base register -/// @param width_bits The length of the memory reference in bits. -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_mem_b(xed_reg_enum_t base, - xed_uint_t width_bits) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_MEM; - o.u.mem.base = base; - o.u.mem.seg = XED_REG_INVALID; - o.u.mem.index= XED_REG_INVALID; - o.u.mem.scale = 0; - o.u.mem.disp.displacement = 0; - o.u.mem.disp.displacement_bits = 0; - o.width_bits = width_bits; - return o; -} - -/// @ingroup ENCHL -/// memory operand - base and displacement only -/// @param base The base register -/// @param disp The displacement -/// @param width_bits The length of the memory reference in bits. -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_mem_bd(xed_reg_enum_t base, - xed_enc_displacement_t disp, - xed_uint_t width_bits) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_MEM; - o.u.mem.base = base; - o.u.mem.seg = XED_REG_INVALID; - o.u.mem.index= XED_REG_INVALID; - o.u.mem.scale = 0; - o.u.mem.disp =disp; - o.width_bits = width_bits; - return o; -} - -/// @ingroup ENCHL -/// memory operand - base, index, scale, displacement -/// @param base The base register -/// @param index The index register -/// @param scale The scale for the index register value -/// @param disp The displacement -/// @param width_bits The length of the memory reference in bits. -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_mem_bisd(xed_reg_enum_t base, - xed_reg_enum_t index, - xed_uint_t scale, - xed_enc_displacement_t disp, - xed_uint_t width_bits) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_MEM; - o.u.mem.base = base; - o.u.mem.seg = XED_REG_INVALID; - o.u.mem.index= index; - o.u.mem.scale = scale; - o.u.mem.disp = disp; - o.width_bits = width_bits; - return o; -} - - -/// @ingroup ENCHL -/// memory operand - segment and base only -/// @param seg The segment override register -/// @param base The base register -/// @param width_bits The length of the memory reference in bits. -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_mem_gb(xed_reg_enum_t seg, - xed_reg_enum_t base, - xed_uint_t width_bits) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_MEM; - o.u.mem.base = base; - o.u.mem.seg = seg; - o.u.mem.index= XED_REG_INVALID; - o.u.mem.scale = 0; - o.u.mem.disp.displacement = 0; - o.u.mem.disp.displacement_bits = 0; - o.width_bits = width_bits; - return o; -} - -/// @ingroup ENCHL -/// memory operand - segment, base and displacement only -/// @param seg The segment override register -/// @param base The base register -/// @param disp The displacement -/// @param width_bits The length of the memory reference in bits. -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_mem_gbd(xed_reg_enum_t seg, - xed_reg_enum_t base, - xed_enc_displacement_t disp, - xed_uint_t width_bits) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_MEM; - o.u.mem.base = base; - o.u.mem.seg = seg; - o.u.mem.index= XED_REG_INVALID; - o.u.mem.scale = 0; - o.u.mem.disp = disp; - o.width_bits = width_bits; - return o; -} - -/// @ingroup ENCHL -/// memory operand - segment and displacement only -/// @param seg The segment override register -/// @param disp The displacement -/// @param width_bits The length of the memory reference in bits. -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_mem_gd(xed_reg_enum_t seg, - xed_enc_displacement_t disp, - xed_uint_t width_bits) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_MEM; - o.u.mem.base = XED_REG_INVALID; - o.u.mem.seg = seg; - o.u.mem.index= XED_REG_INVALID; - o.u.mem.scale = 0; - o.u.mem.disp = disp; - o.width_bits = width_bits; - return o; -} - -/// @ingroup ENCHL -/// memory operand - segment, base, index, scale, and displacement -/// @param seg The segment override register -/// @param base The base register -/// @param index The index register -/// @param scale The scale for the index register value -/// @param disp The displacement -/// @param width_bits The length of the memory reference in bits. -/// @returns xed_encoder_operand_t An operand. -static XED_INLINE xed_encoder_operand_t xed_mem_gbisd(xed_reg_enum_t seg, - xed_reg_enum_t base, - xed_reg_enum_t index, - xed_uint_t scale, - xed_enc_displacement_t disp, - xed_uint_t width_bits) { - xed_encoder_operand_t o; - o.type = XED_ENCODER_OPERAND_TYPE_MEM; - o.u.mem.base = base; - o.u.mem.seg = seg; - o.u.mem.index= index; - o.u.mem.scale = scale; - o.u.mem.disp = disp; - o.width_bits = width_bits; - return o; -} -//@} - -typedef union { - struct { - xed_uint32_t rep :1; - xed_uint32_t repne :1; - xed_uint32_t br_hint_taken :1; - xed_uint32_t br_hint_not_taken :1; - } s; - xed_uint32_t i; -} xed_encoder_prefixes_t; - -#define XED_ENCODER_OPERANDS_MAX 8 /* FIXME */ -typedef struct { - xed_state_t mode; - xed_iclass_enum_t iclass; /*FIXME: use iform instead? or allow either */ - xed_uint32_t effective_operand_width; - - /* the effective_address_width is only requires to be set for - * instructions * with implicit suppressed memops or memops with no - * base or index regs. When base or index regs are present, XED pick - * this up automatically from the register names. - - * FIXME: make effective_address_width required by all encodes for - * unifority. Add to xed_inst[0123]() APIs??? */ - xed_uint32_t effective_address_width; - - xed_encoder_prefixes_t prefixes; - xed_uint32_t noperands; - xed_encoder_operand_t operands[XED_ENCODER_OPERANDS_MAX]; -} xed_encoder_instruction_t; - -/// @name Instruction Properties and prefixes -//@{ -/// @ingroup ENCHL -/// This is to specify effective address size different than the -/// default. For things with base or index regs, XED picks it up from the -/// registers. But for things that have implicit memops, or no base or index -/// reg, we must allow the user to set the address width directly. -/// @param x The #xed_encoder_instruction_t being filled in. -/// @param width_bits The intended effective address size in bits. Values: 16, 32 or 64. -static XED_INLINE void xed_addr(xed_encoder_instruction_t* x, - xed_uint_t width_bits) { - x->effective_address_width = width_bits; -} - - -/// @ingroup ENCHL -/// To add a REP (0xF3) prefix. -/// @param x The #xed_encoder_instruction_t being filled in. -static XED_INLINE void xed_rep(xed_encoder_instruction_t* x) { - x->prefixes.s.rep=1; -} - -/// @ingroup ENCHL -/// To add a REPNE (0xF2) prefix. -/// @param x The #xed_encoder_instruction_t being filled in. -static XED_INLINE void xed_repne(xed_encoder_instruction_t* x) { - x->prefixes.s.repne=1; -} - - - - -/// @ingroup ENCHL -/// convert a #xed_encoder_instruction_t to a #xed_encoder_request_t for -/// encoding -XED_DLL_EXPORT xed_bool_t -xed_convert_to_encoder_request(xed_encoder_request_t* out, - xed_encoder_instruction_t* in); - -//@} - -/// @name Creating instructions from operands -//@{ - -/// @ingroup ENCHL -/// instruction with no operands -/// @param inst The #xed_encoder_instruction_t to be filled in -/// @param mode The xed_state_t including the machine mode and stack address width. -/// @param iclass The #xed_iclass_enum_t -/// @param effective_operand_width in bits -static XED_INLINE void xed_inst0( - xed_encoder_instruction_t* inst, - xed_state_t mode, - xed_iclass_enum_t iclass, - xed_uint_t effective_operand_width) { - - inst->mode=mode; - inst->iclass = iclass; - inst->effective_operand_width = effective_operand_width; - inst->effective_address_width = 0; - inst->prefixes.i = 0; - inst->noperands = 0; -} - -/// @ingroup ENCHL -/// instruction with one operand -/// @param inst The #xed_encoder_instruction_t to be filled in -/// @param mode The xed_state_t including the machine mode and stack address width. -/// @param iclass The #xed_iclass_enum_t -/// @param effective_operand_width in bits -/// @param op0 the operand -static XED_INLINE void xed_inst1( - xed_encoder_instruction_t* inst, - xed_state_t mode, - xed_iclass_enum_t iclass, - xed_uint_t effective_operand_width, - xed_encoder_operand_t op0) { - - inst->mode=mode; - inst->iclass = iclass; - inst->effective_operand_width = effective_operand_width; - inst->effective_address_width = 0; - inst->prefixes.i = 0; - inst->operands[0] = op0; - inst->noperands = 1; -} - -/// @ingroup ENCHL -/// instruction with two operands -/// @param inst The #xed_encoder_instruction_t to be filled in -/// @param mode The xed_state_t including the machine mode and stack address width. -/// @param iclass The #xed_iclass_enum_t -/// @param effective_operand_width in bits -/// @param op0 the 1st operand -/// @param op1 the 2nd operand -static XED_INLINE void xed_inst2( - xed_encoder_instruction_t* inst, - xed_state_t mode, - xed_iclass_enum_t iclass, - xed_uint_t effective_operand_width, - xed_encoder_operand_t op0, - xed_encoder_operand_t op1) { - - inst->mode=mode; - inst->iclass = iclass; - inst->effective_operand_width = effective_operand_width; - inst->effective_address_width = 0; - inst->prefixes.i = 0; - inst->operands[0] = op0; - inst->operands[1] = op1; - inst->noperands = 2; -} - -/// @ingroup ENCHL -/// instruction with three operands -/// @param inst The #xed_encoder_instruction_t to be filled in -/// @param mode The xed_state_t including the machine mode and stack address width. -/// @param iclass The #xed_iclass_enum_t -/// @param effective_operand_width in bits -/// @param op0 the 1st operand -/// @param op1 the 2nd operand -/// @param op2 the 3rd operand -static XED_INLINE void xed_inst3( - xed_encoder_instruction_t* inst, - xed_state_t mode, - xed_iclass_enum_t iclass, - xed_uint_t effective_operand_width, - xed_encoder_operand_t op0, - xed_encoder_operand_t op1, - xed_encoder_operand_t op2) { - - inst->mode=mode; - inst->iclass = iclass; - inst->effective_operand_width = effective_operand_width; - inst->effective_address_width = 0; - inst->prefixes.i = 0; - inst->operands[0] = op0; - inst->operands[1] = op1; - inst->operands[2] = op2; - inst->noperands = 3; -} - - -/// @ingroup ENCHL -/// instruction with four operands -/// @param inst The #xed_encoder_instruction_t to be filled in -/// @param mode The xed_state_t including the machine mode and stack address width. -/// @param iclass The #xed_iclass_enum_t -/// @param effective_operand_width in bits -/// @param op0 the 1st operand -/// @param op1 the 2nd operand -/// @param op2 the 3rd operand -/// @param op3 the 4th operand -static XED_INLINE void xed_inst4( - xed_encoder_instruction_t* inst, - xed_state_t mode, - xed_iclass_enum_t iclass, - xed_uint_t effective_operand_width, - xed_encoder_operand_t op0, - xed_encoder_operand_t op1, - xed_encoder_operand_t op2, - xed_encoder_operand_t op3) { - - inst->mode=mode; - inst->iclass = iclass; - inst->effective_operand_width = effective_operand_width; - inst->effective_address_width = 0; - inst->prefixes.i = 0; - inst->operands[0] = op0; - inst->operands[1] = op1; - inst->operands[2] = op2; - inst->operands[3] = op3; - inst->noperands = 4; -} - -/// @ingroup ENCHL -/// instruction with five operands -/// @param inst The #xed_encoder_instruction_t to be filled in -/// @param mode The xed_state_t including the machine mode and stack address width. -/// @param iclass The #xed_iclass_enum_t -/// @param effective_operand_width in bits -/// @param op0 the 1st operand -/// @param op1 the 2nd operand -/// @param op2 the 3rd operand -/// @param op3 the 4th operand -/// @param op4 the 5th operand -static XED_INLINE void xed_inst5( - xed_encoder_instruction_t* inst, - xed_state_t mode, - xed_iclass_enum_t iclass, - xed_uint_t effective_operand_width, - xed_encoder_operand_t op0, - xed_encoder_operand_t op1, - xed_encoder_operand_t op2, - xed_encoder_operand_t op3, - xed_encoder_operand_t op4) { - - inst->mode=mode; - inst->iclass = iclass; - inst->effective_operand_width = effective_operand_width; - inst->effective_address_width = 0; - inst->prefixes.i = 0; - inst->operands[0] = op0; - inst->operands[1] = op1; - inst->operands[2] = op2; - inst->operands[3] = op3; - inst->operands[4] = op4; - inst->noperands = 5; -} - - -/// @ingroup ENCHL -/// instruction with an array of operands. The maximum number is -/// XED_ENCODER_OPERANDS_MAX. The array's contents are copied. -/// @param inst The #xed_encoder_instruction_t to be filled in -/// @param mode The xed_state_t including the machine mode and stack address width. -/// @param iclass The #xed_iclass_enum_t -/// @param effective_operand_width in bits -/// @param number_of_operands length of the subsequent array -/// @param operand_array An array of #xed_encoder_operand_t objects -static XED_INLINE void xed_inst( - xed_encoder_instruction_t* inst, - xed_state_t mode, - xed_iclass_enum_t iclass, - xed_uint_t effective_operand_width, - xed_uint_t number_of_operands, - const xed_encoder_operand_t* operand_array) { - - xed_uint_t i; - inst->mode=mode; - inst->iclass = iclass; - inst->effective_operand_width = effective_operand_width; - inst->effective_address_width = 0; - inst->prefixes.i = 0; - xed_assert(number_of_operands < XED_ENCODER_OPERANDS_MAX); - for(i=0;ioperands[i] = operand_array[i]; - } - inst->noperands = number_of_operands; -} - -//@} - -/* - xed_encoder_instruction_t x,y; - - xed_inst2(&x, state, XED_ICLASS_ADD, 32, - xed_reg(XED_REG_EAX), - xed_mem_bd(XED_REG_EDX, xed_disp(0x11223344, 32), 32)); - - xed_inst2(&y, state, XED_ICLASS_ADD, 32, - xed_reg(XED_REG_EAX), - xed_mem_gbisd(XED_REG_FS, XED_REG_EAX, XED_REG_ESI,4, - xed_disp(0x11223344, 32), 32)); - - */ - -#endif diff --git a/target/i386/latx/include/xed/xed-encoder-iforms.h b/target/i386/latx/include/xed/xed-encoder-iforms.h deleted file mode 100644 index 7ec5253e586..00000000000 --- a/target/i386/latx/include/xed/xed-encoder-iforms.h +++ /dev/null @@ -1,77 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-encoder-iforms.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_ENCODER_IFORMS_H) -# define XED_ENCODER_IFORMS_H -#include "xed-types.h" -typedef struct xed_encoder_iforms_s { - xed_uint32_t x_SIBBASE_ENCODE; - xed_uint32_t x_SIBBASE_ENCODE_SIB1; - xed_uint32_t x_SIBINDEX_ENCODE; - xed_uint32_t x_MODRM_MOD_ENCODE; - xed_uint32_t x_MODRM_RM_ENCODE; - xed_uint32_t x_MODRM_RM_ENCODE_EA16_SIB0; - xed_uint32_t x_MODRM_RM_ENCODE_EA64_SIB0; - xed_uint32_t x_MODRM_RM_ENCODE_EA32_SIB0; - xed_uint32_t x_SIB_NT; - xed_uint32_t x_DISP_NT; - xed_uint32_t x_REMOVE_SEGMENT; - xed_uint32_t x_REX_PREFIX_ENC; - xed_uint32_t x_PREFIX_ENC; - xed_uint32_t x_VEXED_REX; - xed_uint32_t x_XOP_TYPE_ENC; - xed_uint32_t x_XOP_MAP_ENC; - xed_uint32_t x_XOP_REXXB_ENC; - xed_uint32_t x_VEX_TYPE_ENC; - xed_uint32_t x_VEX_REXR_ENC; - xed_uint32_t x_VEX_REXXB_ENC; - xed_uint32_t x_VEX_MAP_ENC; - xed_uint32_t x_VEX_REG_ENC; - xed_uint32_t x_VEX_ESCVL_ENC; - xed_uint32_t x_SE_IMM8; - xed_uint32_t x_VSIB_ENC_BASE; - xed_uint32_t x_VSIB_ENC; - xed_uint32_t x_EVEX_62_REXR_ENC; - xed_uint32_t x_EVEX_REXX_ENC; - xed_uint32_t x_EVEX_REXB_ENC; - xed_uint32_t x_EVEX_REXRR_ENC; - xed_uint32_t x_EVEX_MAP_ENC; - xed_uint32_t x_EVEX_REXW_VVVV_ENC; - xed_uint32_t x_EVEX_UPP_ENC; - xed_uint32_t x_AVX512_EVEX_BYTE3_ENC; - xed_uint32_t x_UIMMv; - xed_uint32_t x_SIMMz; - xed_uint32_t x_SIMM8; - xed_uint32_t x_UIMM8; - xed_uint32_t x_UIMM8_1; - xed_uint32_t x_UIMM16; - xed_uint32_t x_UIMM32; - xed_uint32_t x_BRDISP8; - xed_uint32_t x_BRDISP32; - xed_uint32_t x_BRDISPz; - xed_uint32_t x_MEMDISPv; - xed_uint32_t x_MEMDISP32; - xed_uint32_t x_MEMDISP16; - xed_uint32_t x_MEMDISP8; - xed_uint32_t x_MEMDISP; -} xed_encoder_iforms_t; -#endif diff --git a/target/i386/latx/include/xed/xed-error-enum.h b/target/i386/latx/include/xed/xed-error-enum.h deleted file mode 100644 index 889790e2376..00000000000 --- a/target/i386/latx/include/xed/xed-error-enum.h +++ /dev/null @@ -1,90 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-error-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_ERROR_ENUM_H) -# define XED_ERROR_ENUM_H -#include "xed-common-hdrs.h" -#define XED_ERROR_NONE_DEFINED 1 -#define XED_ERROR_BUFFER_TOO_SHORT_DEFINED 1 -#define XED_ERROR_GENERAL_ERROR_DEFINED 1 -#define XED_ERROR_INVALID_FOR_CHIP_DEFINED 1 -#define XED_ERROR_BAD_REGISTER_DEFINED 1 -#define XED_ERROR_BAD_LOCK_PREFIX_DEFINED 1 -#define XED_ERROR_BAD_REP_PREFIX_DEFINED 1 -#define XED_ERROR_BAD_LEGACY_PREFIX_DEFINED 1 -#define XED_ERROR_BAD_REX_PREFIX_DEFINED 1 -#define XED_ERROR_BAD_EVEX_UBIT_DEFINED 1 -#define XED_ERROR_BAD_MAP_DEFINED 1 -#define XED_ERROR_BAD_EVEX_V_PRIME_DEFINED 1 -#define XED_ERROR_BAD_EVEX_Z_NO_MASKING_DEFINED 1 -#define XED_ERROR_NO_OUTPUT_POINTER_DEFINED 1 -#define XED_ERROR_NO_AGEN_CALL_BACK_REGISTERED_DEFINED 1 -#define XED_ERROR_BAD_MEMOP_INDEX_DEFINED 1 -#define XED_ERROR_CALLBACK_PROBLEM_DEFINED 1 -#define XED_ERROR_GATHER_REGS_DEFINED 1 -#define XED_ERROR_INSTR_TOO_LONG_DEFINED 1 -#define XED_ERROR_INVALID_MODE_DEFINED 1 -#define XED_ERROR_BAD_EVEX_LL_DEFINED 1 -#define XED_ERROR_BAD_REG_MATCH_DEFINED 1 -#define XED_ERROR_LAST_DEFINED 1 -typedef enum { - XED_ERROR_NONE, ///< There was no error - XED_ERROR_BUFFER_TOO_SHORT, ///< There were not enough bytes in the given buffer - XED_ERROR_GENERAL_ERROR, ///< XED could not decode the given instruction - XED_ERROR_INVALID_FOR_CHIP, ///< The instruciton is not valid for the specified chip - XED_ERROR_BAD_REGISTER, ///< XED could not decode the given instruction because an invalid register encoding was used. - XED_ERROR_BAD_LOCK_PREFIX, ///< A lock prefix was found where none is allowed. - XED_ERROR_BAD_REP_PREFIX, ///< An F2 or F3 prefix was found where none is allowed. - XED_ERROR_BAD_LEGACY_PREFIX, ///< A 66, F2 or F3 prefix was found where none is allowed. - XED_ERROR_BAD_REX_PREFIX, ///< A REX prefix was found where none is allowed. - XED_ERROR_BAD_EVEX_UBIT, ///< An illegal value for the EVEX.U bit was present in the instruction. - XED_ERROR_BAD_MAP, ///< An illegal value for the MAP field was detected in the instruction. - XED_ERROR_BAD_EVEX_V_PRIME, ///< EVEX.V'=0 was detected in a non-64b mode instruction. - XED_ERROR_BAD_EVEX_Z_NO_MASKING, ///< EVEX.Z!=0 when EVEX.aaa==0 - XED_ERROR_NO_OUTPUT_POINTER, ///< The output pointer for xed_agen was zero - XED_ERROR_NO_AGEN_CALL_BACK_REGISTERED, ///< One or both of the callbacks for xed_agen were missing. - XED_ERROR_BAD_MEMOP_INDEX, ///< Memop indices must be 0 or 1. - XED_ERROR_CALLBACK_PROBLEM, ///< The register or segment callback for xed_agen experienced a problem - XED_ERROR_GATHER_REGS, ///< The index, dest and mask regs for AVX2 gathers must be different. - XED_ERROR_INSTR_TOO_LONG, ///< Full decode of instruction would exeed 15B. - XED_ERROR_INVALID_MODE, ///< The instruction was not valid for the specified mode - XED_ERROR_BAD_EVEX_LL, ///< EVEX.LL must not ==3 unless using embedded rounding - XED_ERROR_BAD_REG_MATCH, ///< Source registers must not match the destination register for this instruction. - XED_ERROR_LAST -} xed_error_enum_t; - -/// This converts strings to #xed_error_enum_t types. -/// @param s A C-string. -/// @return #xed_error_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_error_enum_t str2xed_error_enum_t(const char* s); -/// This converts strings to #xed_error_enum_t types. -/// @param p An enumeration element of type xed_error_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_error_enum_t2str(const xed_error_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_error_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_error_enum_t xed_error_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-exception-enum.h b/target/i386/latx/include/xed/xed-exception-enum.h deleted file mode 100644 index 7aa5e894df2..00000000000 --- a/target/i386/latx/include/xed/xed-exception-enum.h +++ /dev/null @@ -1,156 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-exception-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_EXCEPTION_ENUM_H) -# define XED_EXCEPTION_ENUM_H -#include "xed-common-hdrs.h" -#define XED_EXCEPTION_INVALID_DEFINED 1 -#define XED_EXCEPTION_AMX_E1_DEFINED 1 -#define XED_EXCEPTION_AMX_E2_DEFINED 1 -#define XED_EXCEPTION_AMX_E3_DEFINED 1 -#define XED_EXCEPTION_AMX_E4_DEFINED 1 -#define XED_EXCEPTION_AMX_E5_DEFINED 1 -#define XED_EXCEPTION_AMX_E6_DEFINED 1 -#define XED_EXCEPTION_AVX512_E1_DEFINED 1 -#define XED_EXCEPTION_AVX512_E10_DEFINED 1 -#define XED_EXCEPTION_AVX512_E10NF_DEFINED 1 -#define XED_EXCEPTION_AVX512_E11_DEFINED 1 -#define XED_EXCEPTION_AVX512_E12_DEFINED 1 -#define XED_EXCEPTION_AVX512_E12NP_DEFINED 1 -#define XED_EXCEPTION_AVX512_E1NF_DEFINED 1 -#define XED_EXCEPTION_AVX512_E2_DEFINED 1 -#define XED_EXCEPTION_AVX512_E3_DEFINED 1 -#define XED_EXCEPTION_AVX512_E3NF_DEFINED 1 -#define XED_EXCEPTION_AVX512_E4_DEFINED 1 -#define XED_EXCEPTION_AVX512_E4NF_DEFINED 1 -#define XED_EXCEPTION_AVX512_E5_DEFINED 1 -#define XED_EXCEPTION_AVX512_E5NF_DEFINED 1 -#define XED_EXCEPTION_AVX512_E6_DEFINED 1 -#define XED_EXCEPTION_AVX512_E6NF_DEFINED 1 -#define XED_EXCEPTION_AVX512_E7NM_DEFINED 1 -#define XED_EXCEPTION_AVX512_E7NM128_DEFINED 1 -#define XED_EXCEPTION_AVX512_E9NF_DEFINED 1 -#define XED_EXCEPTION_AVX512_K20_DEFINED 1 -#define XED_EXCEPTION_AVX512_K21_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_1_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_11_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_12_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_2_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_2D_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_3_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_4_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_4M_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_5_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_5L_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_6_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_7_DEFINED 1 -#define XED_EXCEPTION_AVX_TYPE_8_DEFINED 1 -#define XED_EXCEPTION_MMX_FP_DEFINED 1 -#define XED_EXCEPTION_MMX_FP_16ALIGN_DEFINED 1 -#define XED_EXCEPTION_MMX_MEM_DEFINED 1 -#define XED_EXCEPTION_MMX_NOFP_DEFINED 1 -#define XED_EXCEPTION_MMX_NOFP2_DEFINED 1 -#define XED_EXCEPTION_MMX_NOMEM_DEFINED 1 -#define XED_EXCEPTION_SSE_TYPE_1_DEFINED 1 -#define XED_EXCEPTION_SSE_TYPE_2_DEFINED 1 -#define XED_EXCEPTION_SSE_TYPE_2D_DEFINED 1 -#define XED_EXCEPTION_SSE_TYPE_3_DEFINED 1 -#define XED_EXCEPTION_SSE_TYPE_4_DEFINED 1 -#define XED_EXCEPTION_SSE_TYPE_4M_DEFINED 1 -#define XED_EXCEPTION_SSE_TYPE_5_DEFINED 1 -#define XED_EXCEPTION_SSE_TYPE_7_DEFINED 1 -#define XED_EXCEPTION_LAST_DEFINED 1 -typedef enum { - XED_EXCEPTION_INVALID, - XED_EXCEPTION_AMX_E1, - XED_EXCEPTION_AMX_E2, - XED_EXCEPTION_AMX_E3, - XED_EXCEPTION_AMX_E4, - XED_EXCEPTION_AMX_E5, - XED_EXCEPTION_AMX_E6, - XED_EXCEPTION_AVX512_E1, - XED_EXCEPTION_AVX512_E10, - XED_EXCEPTION_AVX512_E10NF, - XED_EXCEPTION_AVX512_E11, - XED_EXCEPTION_AVX512_E12, - XED_EXCEPTION_AVX512_E12NP, - XED_EXCEPTION_AVX512_E1NF, - XED_EXCEPTION_AVX512_E2, - XED_EXCEPTION_AVX512_E3, - XED_EXCEPTION_AVX512_E3NF, - XED_EXCEPTION_AVX512_E4, - XED_EXCEPTION_AVX512_E4NF, - XED_EXCEPTION_AVX512_E5, - XED_EXCEPTION_AVX512_E5NF, - XED_EXCEPTION_AVX512_E6, - XED_EXCEPTION_AVX512_E6NF, - XED_EXCEPTION_AVX512_E7NM, - XED_EXCEPTION_AVX512_E7NM128, - XED_EXCEPTION_AVX512_E9NF, - XED_EXCEPTION_AVX512_K20, - XED_EXCEPTION_AVX512_K21, - XED_EXCEPTION_AVX_TYPE_1, - XED_EXCEPTION_AVX_TYPE_11, - XED_EXCEPTION_AVX_TYPE_12, - XED_EXCEPTION_AVX_TYPE_2, - XED_EXCEPTION_AVX_TYPE_2D, - XED_EXCEPTION_AVX_TYPE_3, - XED_EXCEPTION_AVX_TYPE_4, - XED_EXCEPTION_AVX_TYPE_4M, - XED_EXCEPTION_AVX_TYPE_5, - XED_EXCEPTION_AVX_TYPE_5L, - XED_EXCEPTION_AVX_TYPE_6, - XED_EXCEPTION_AVX_TYPE_7, - XED_EXCEPTION_AVX_TYPE_8, - XED_EXCEPTION_MMX_FP, - XED_EXCEPTION_MMX_FP_16ALIGN, - XED_EXCEPTION_MMX_MEM, - XED_EXCEPTION_MMX_NOFP, - XED_EXCEPTION_MMX_NOFP2, - XED_EXCEPTION_MMX_NOMEM, - XED_EXCEPTION_SSE_TYPE_1, - XED_EXCEPTION_SSE_TYPE_2, - XED_EXCEPTION_SSE_TYPE_2D, - XED_EXCEPTION_SSE_TYPE_3, - XED_EXCEPTION_SSE_TYPE_4, - XED_EXCEPTION_SSE_TYPE_4M, - XED_EXCEPTION_SSE_TYPE_5, - XED_EXCEPTION_SSE_TYPE_7, - XED_EXCEPTION_LAST -} xed_exception_enum_t; - -/// This converts strings to #xed_exception_enum_t types. -/// @param s A C-string. -/// @return #xed_exception_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_exception_enum_t str2xed_exception_enum_t(const char* s); -/// This converts strings to #xed_exception_enum_t types. -/// @param p An enumeration element of type xed_exception_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_exception_enum_t2str(const xed_exception_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_exception_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_exception_enum_t xed_exception_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-extension-enum.h b/target/i386/latx/include/xed/xed-extension-enum.h deleted file mode 100644 index ebff560b0d2..00000000000 --- a/target/i386/latx/include/xed/xed-extension-enum.h +++ /dev/null @@ -1,226 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-extension-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_EXTENSION_ENUM_H) -# define XED_EXTENSION_ENUM_H -#include "xed-common-hdrs.h" -#define XED_EXTENSION_INVALID_DEFINED 1 -#define XED_EXTENSION_3DNOW_DEFINED 1 -#define XED_EXTENSION_3DNOW_PREFETCH_DEFINED 1 -#define XED_EXTENSION_ADOX_ADCX_DEFINED 1 -#define XED_EXTENSION_AES_DEFINED 1 -#define XED_EXTENSION_AMD_INVLPGB_DEFINED 1 -#define XED_EXTENSION_AMX_BF16_DEFINED 1 -#define XED_EXTENSION_AMX_INT8_DEFINED 1 -#define XED_EXTENSION_AMX_TILE_DEFINED 1 -#define XED_EXTENSION_AVX_DEFINED 1 -#define XED_EXTENSION_AVX2_DEFINED 1 -#define XED_EXTENSION_AVX2GATHER_DEFINED 1 -#define XED_EXTENSION_AVX512EVEX_DEFINED 1 -#define XED_EXTENSION_AVX512VEX_DEFINED 1 -#define XED_EXTENSION_AVXAES_DEFINED 1 -#define XED_EXTENSION_AVX_VNNI_DEFINED 1 -#define XED_EXTENSION_BASE_DEFINED 1 -#define XED_EXTENSION_BMI1_DEFINED 1 -#define XED_EXTENSION_BMI2_DEFINED 1 -#define XED_EXTENSION_CET_DEFINED 1 -#define XED_EXTENSION_CLDEMOTE_DEFINED 1 -#define XED_EXTENSION_CLFLUSHOPT_DEFINED 1 -#define XED_EXTENSION_CLFSH_DEFINED 1 -#define XED_EXTENSION_CLWB_DEFINED 1 -#define XED_EXTENSION_CLZERO_DEFINED 1 -#define XED_EXTENSION_ENQCMD_DEFINED 1 -#define XED_EXTENSION_F16C_DEFINED 1 -#define XED_EXTENSION_FMA_DEFINED 1 -#define XED_EXTENSION_FMA4_DEFINED 1 -#define XED_EXTENSION_GFNI_DEFINED 1 -#define XED_EXTENSION_HRESET_DEFINED 1 -#define XED_EXTENSION_INVPCID_DEFINED 1 -#define XED_EXTENSION_KEYLOCKER_DEFINED 1 -#define XED_EXTENSION_KEYLOCKER_WIDE_DEFINED 1 -#define XED_EXTENSION_LONGMODE_DEFINED 1 -#define XED_EXTENSION_LZCNT_DEFINED 1 -#define XED_EXTENSION_MCOMMIT_DEFINED 1 -#define XED_EXTENSION_MMX_DEFINED 1 -#define XED_EXTENSION_MONITOR_DEFINED 1 -#define XED_EXTENSION_MONITORX_DEFINED 1 -#define XED_EXTENSION_MOVBE_DEFINED 1 -#define XED_EXTENSION_MOVDIR_DEFINED 1 -#define XED_EXTENSION_MPX_DEFINED 1 -#define XED_EXTENSION_PAUSE_DEFINED 1 -#define XED_EXTENSION_PCLMULQDQ_DEFINED 1 -#define XED_EXTENSION_PCONFIG_DEFINED 1 -#define XED_EXTENSION_PKU_DEFINED 1 -#define XED_EXTENSION_PREFETCHWT1_DEFINED 1 -#define XED_EXTENSION_PTWRITE_DEFINED 1 -#define XED_EXTENSION_RDPID_DEFINED 1 -#define XED_EXTENSION_RDPRU_DEFINED 1 -#define XED_EXTENSION_RDRAND_DEFINED 1 -#define XED_EXTENSION_RDSEED_DEFINED 1 -#define XED_EXTENSION_RDTSCP_DEFINED 1 -#define XED_EXTENSION_RDWRFSGS_DEFINED 1 -#define XED_EXTENSION_RTM_DEFINED 1 -#define XED_EXTENSION_SERIALIZE_DEFINED 1 -#define XED_EXTENSION_SGX_DEFINED 1 -#define XED_EXTENSION_SGX_ENCLV_DEFINED 1 -#define XED_EXTENSION_SHA_DEFINED 1 -#define XED_EXTENSION_SMAP_DEFINED 1 -#define XED_EXTENSION_SMX_DEFINED 1 -#define XED_EXTENSION_SNP_DEFINED 1 -#define XED_EXTENSION_SSE_DEFINED 1 -#define XED_EXTENSION_SSE2_DEFINED 1 -#define XED_EXTENSION_SSE3_DEFINED 1 -#define XED_EXTENSION_SSE4_DEFINED 1 -#define XED_EXTENSION_SSE4A_DEFINED 1 -#define XED_EXTENSION_SSSE3_DEFINED 1 -#define XED_EXTENSION_SVM_DEFINED 1 -#define XED_EXTENSION_TBM_DEFINED 1 -#define XED_EXTENSION_TDX_DEFINED 1 -#define XED_EXTENSION_TSX_LDTRK_DEFINED 1 -#define XED_EXTENSION_UINTR_DEFINED 1 -#define XED_EXTENSION_VAES_DEFINED 1 -#define XED_EXTENSION_VIA_PADLOCK_AES_DEFINED 1 -#define XED_EXTENSION_VIA_PADLOCK_MONTMUL_DEFINED 1 -#define XED_EXTENSION_VIA_PADLOCK_RNG_DEFINED 1 -#define XED_EXTENSION_VIA_PADLOCK_SHA_DEFINED 1 -#define XED_EXTENSION_VMFUNC_DEFINED 1 -#define XED_EXTENSION_VPCLMULQDQ_DEFINED 1 -#define XED_EXTENSION_VTX_DEFINED 1 -#define XED_EXTENSION_WAITPKG_DEFINED 1 -#define XED_EXTENSION_WBNOINVD_DEFINED 1 -#define XED_EXTENSION_X87_DEFINED 1 -#define XED_EXTENSION_XOP_DEFINED 1 -#define XED_EXTENSION_XSAVE_DEFINED 1 -#define XED_EXTENSION_XSAVEC_DEFINED 1 -#define XED_EXTENSION_XSAVEOPT_DEFINED 1 -#define XED_EXTENSION_XSAVES_DEFINED 1 -#define XED_EXTENSION_LAST_DEFINED 1 -typedef enum { - XED_EXTENSION_INVALID, - XED_EXTENSION_3DNOW, - XED_EXTENSION_3DNOW_PREFETCH, - XED_EXTENSION_ADOX_ADCX, - XED_EXTENSION_AES, - XED_EXTENSION_AMD_INVLPGB, - XED_EXTENSION_AMX_BF16, - XED_EXTENSION_AMX_INT8, - XED_EXTENSION_AMX_TILE, - XED_EXTENSION_AVX, - XED_EXTENSION_AVX2, - XED_EXTENSION_AVX2GATHER, - XED_EXTENSION_AVX512EVEX, - XED_EXTENSION_AVX512VEX, - XED_EXTENSION_AVXAES, - XED_EXTENSION_AVX_VNNI, - XED_EXTENSION_BASE, - XED_EXTENSION_BMI1, - XED_EXTENSION_BMI2, - XED_EXTENSION_CET, - XED_EXTENSION_CLDEMOTE, - XED_EXTENSION_CLFLUSHOPT, - XED_EXTENSION_CLFSH, - XED_EXTENSION_CLWB, - XED_EXTENSION_CLZERO, - XED_EXTENSION_ENQCMD, - XED_EXTENSION_F16C, - XED_EXTENSION_FMA, - XED_EXTENSION_FMA4, - XED_EXTENSION_GFNI, - XED_EXTENSION_HRESET, - XED_EXTENSION_INVPCID, - XED_EXTENSION_KEYLOCKER, - XED_EXTENSION_KEYLOCKER_WIDE, - XED_EXTENSION_LONGMODE, - XED_EXTENSION_LZCNT, - XED_EXTENSION_MCOMMIT, - XED_EXTENSION_MMX, - XED_EXTENSION_MONITOR, - XED_EXTENSION_MONITORX, - XED_EXTENSION_MOVBE, - XED_EXTENSION_MOVDIR, - XED_EXTENSION_MPX, - XED_EXTENSION_PAUSE, - XED_EXTENSION_PCLMULQDQ, - XED_EXTENSION_PCONFIG, - XED_EXTENSION_PKU, - XED_EXTENSION_PREFETCHWT1, - XED_EXTENSION_PTWRITE, - XED_EXTENSION_RDPID, - XED_EXTENSION_RDPRU, - XED_EXTENSION_RDRAND, - XED_EXTENSION_RDSEED, - XED_EXTENSION_RDTSCP, - XED_EXTENSION_RDWRFSGS, - XED_EXTENSION_RTM, - XED_EXTENSION_SERIALIZE, - XED_EXTENSION_SGX, - XED_EXTENSION_SGX_ENCLV, - XED_EXTENSION_SHA, - XED_EXTENSION_SMAP, - XED_EXTENSION_SMX, - XED_EXTENSION_SNP, - XED_EXTENSION_SSE, - XED_EXTENSION_SSE2, - XED_EXTENSION_SSE3, - XED_EXTENSION_SSE4, - XED_EXTENSION_SSE4A, - XED_EXTENSION_SSSE3, - XED_EXTENSION_SVM, - XED_EXTENSION_TBM, - XED_EXTENSION_TDX, - XED_EXTENSION_TSX_LDTRK, - XED_EXTENSION_UINTR, - XED_EXTENSION_VAES, - XED_EXTENSION_VIA_PADLOCK_AES, - XED_EXTENSION_VIA_PADLOCK_MONTMUL, - XED_EXTENSION_VIA_PADLOCK_RNG, - XED_EXTENSION_VIA_PADLOCK_SHA, - XED_EXTENSION_VMFUNC, - XED_EXTENSION_VPCLMULQDQ, - XED_EXTENSION_VTX, - XED_EXTENSION_WAITPKG, - XED_EXTENSION_WBNOINVD, - XED_EXTENSION_X87, - XED_EXTENSION_XOP, - XED_EXTENSION_XSAVE, - XED_EXTENSION_XSAVEC, - XED_EXTENSION_XSAVEOPT, - XED_EXTENSION_XSAVES, - XED_EXTENSION_LAST -} xed_extension_enum_t; - -/// This converts strings to #xed_extension_enum_t types. -/// @param s A C-string. -/// @return #xed_extension_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_extension_enum_t str2xed_extension_enum_t(const char* s); -/// This converts strings to #xed_extension_enum_t types. -/// @param p An enumeration element of type xed_extension_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_extension_enum_t2str(const xed_extension_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_extension_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_extension_enum_t xed_extension_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-flag-action-enum.h b/target/i386/latx/include/xed/xed-flag-action-enum.h deleted file mode 100644 index f7413bf1ff1..00000000000 --- a/target/i386/latx/include/xed/xed-flag-action-enum.h +++ /dev/null @@ -1,62 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-flag-action-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_FLAG_ACTION_ENUM_H) -# define XED_FLAG_ACTION_ENUM_H -#include "xed-common-hdrs.h" -#define XED_FLAG_ACTION_INVALID_DEFINED 1 -#define XED_FLAG_ACTION_u_DEFINED 1 -#define XED_FLAG_ACTION_tst_DEFINED 1 -#define XED_FLAG_ACTION_mod_DEFINED 1 -#define XED_FLAG_ACTION_0_DEFINED 1 -#define XED_FLAG_ACTION_pop_DEFINED 1 -#define XED_FLAG_ACTION_ah_DEFINED 1 -#define XED_FLAG_ACTION_1_DEFINED 1 -#define XED_FLAG_ACTION_LAST_DEFINED 1 -typedef enum { - XED_FLAG_ACTION_INVALID, - XED_FLAG_ACTION_u, ///< undefined (treated as a write) - XED_FLAG_ACTION_tst, ///< test (read) - XED_FLAG_ACTION_mod, ///< modification (write) - XED_FLAG_ACTION_0, ///< value will be zero (write) - XED_FLAG_ACTION_pop, ///< value comes from the stack (write) - XED_FLAG_ACTION_ah, ///< value comes from AH (write) - XED_FLAG_ACTION_1, ///< value will be 1 (write) - XED_FLAG_ACTION_LAST -} xed_flag_action_enum_t; - -/// This converts strings to #xed_flag_action_enum_t types. -/// @param s A C-string. -/// @return #xed_flag_action_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_flag_action_enum_t str2xed_flag_action_enum_t(const char* s); -/// This converts strings to #xed_flag_action_enum_t types. -/// @param p An enumeration element of type xed_flag_action_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_flag_action_enum_t2str(const xed_flag_action_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_flag_action_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_flag_action_enum_t xed_flag_action_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-flag-enum.h b/target/i386/latx/include/xed/xed-flag-enum.h deleted file mode 100644 index c941169f7c4..00000000000 --- a/target/i386/latx/include/xed/xed-flag-enum.h +++ /dev/null @@ -1,90 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-flag-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_FLAG_ENUM_H) -# define XED_FLAG_ENUM_H -#include "xed-common-hdrs.h" -#define XED_FLAG_INVALID_DEFINED 1 -#define XED_FLAG_of_DEFINED 1 -#define XED_FLAG_sf_DEFINED 1 -#define XED_FLAG_zf_DEFINED 1 -#define XED_FLAG_af_DEFINED 1 -#define XED_FLAG_pf_DEFINED 1 -#define XED_FLAG_cf_DEFINED 1 -#define XED_FLAG_df_DEFINED 1 -#define XED_FLAG_vif_DEFINED 1 -#define XED_FLAG_iopl_DEFINED 1 -#define XED_FLAG_if_DEFINED 1 -#define XED_FLAG_ac_DEFINED 1 -#define XED_FLAG_vm_DEFINED 1 -#define XED_FLAG_rf_DEFINED 1 -#define XED_FLAG_nt_DEFINED 1 -#define XED_FLAG_tf_DEFINED 1 -#define XED_FLAG_id_DEFINED 1 -#define XED_FLAG_vip_DEFINED 1 -#define XED_FLAG_fc0_DEFINED 1 -#define XED_FLAG_fc1_DEFINED 1 -#define XED_FLAG_fc2_DEFINED 1 -#define XED_FLAG_fc3_DEFINED 1 -#define XED_FLAG_LAST_DEFINED 1 -typedef enum { - XED_FLAG_INVALID, - XED_FLAG_of, ///<< overflow flag - XED_FLAG_sf, ///< sign flag - XED_FLAG_zf, ///< zero flag - XED_FLAG_af, ///< auxiliary flag - XED_FLAG_pf, ///< parity flag - XED_FLAG_cf, ///< carry flag - XED_FLAG_df, ///< direction flag - XED_FLAG_vif, ///< virtual interrupt flag - XED_FLAG_iopl, ///< I/O privilege level - XED_FLAG_if, ///< interrupt flag - XED_FLAG_ac, ///< alignment check - XED_FLAG_vm, ///< virtual-8086 mode - XED_FLAG_rf, ///< resume flag - XED_FLAG_nt, ///< nested task - XED_FLAG_tf, ///< traf flag - XED_FLAG_id, ///< ID flag - XED_FLAG_vip, ///< virtual interrupt pending - XED_FLAG_fc0, ///< x87 FC0 flag - XED_FLAG_fc1, ///< x87 FC1 flag - XED_FLAG_fc2, ///< x87 FC2 flag - XED_FLAG_fc3, ///< x87 FC3 flag - XED_FLAG_LAST -} xed_flag_enum_t; - -/// This converts strings to #xed_flag_enum_t types. -/// @param s A C-string. -/// @return #xed_flag_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_flag_enum_t str2xed_flag_enum_t(const char* s); -/// This converts strings to #xed_flag_enum_t types. -/// @param p An enumeration element of type xed_flag_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_flag_enum_t2str(const xed_flag_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_flag_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_flag_enum_t xed_flag_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-flags.h b/target/i386/latx/include/xed/xed-flags.h deleted file mode 100644 index c568304af76..00000000000 --- a/target/i386/latx/include/xed/xed-flags.h +++ /dev/null @@ -1,233 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-flags.h -/// - -#ifndef XED_FLAGS_H -# define XED_FLAGS_H - -#include "xed-types.h" -#include "xed-portability.h" -#include "xed-flag-enum.h" -#include "xed-flag-action-enum.h" -#include "xed-gen-table-defs.h" - - -//////////////////////////////////////////////////////////////////////////// -/// @ingroup FLAGS -/// a union of flags bits -union xed_flag_set_s { - xed_uint32_t flat; - struct { - xed_uint32_t cf:1; ///< bit 0 - xed_uint32_t must_be_1:1; - xed_uint32_t pf:1; - xed_uint32_t must_be_0a:1; - - xed_uint32_t af:1; ///< bit 4 - xed_uint32_t must_be_0b:1; - xed_uint32_t zf:1; - xed_uint32_t sf:1; - - xed_uint32_t tf:1; ///< bit 8 - xed_uint32_t _if:1; ///< underscore to avoid token clash - xed_uint32_t df:1; - xed_uint32_t of:1; - - xed_uint32_t iopl:2; ///< A 2-bit field, bits 12-13 - xed_uint32_t nt:1; - xed_uint32_t must_be_0c:1; - - xed_uint32_t rf:1; ///< bit 16 - xed_uint32_t vm:1; - xed_uint32_t ac:1; - xed_uint32_t vif:1; - - xed_uint32_t vip:1; ///< bit 20 - xed_uint32_t id:1; ///< bit 21 - xed_uint32_t must_be_0d:2; ///< bits 22-23 - - xed_uint32_t must_be_0e:4; ///< bits 24-27 - - // fc0,fc1,fc2,fc3 are not really part of rflags but I put them - // here to save space. These bits are only used for x87 - // instructions. - xed_uint32_t fc0:1; ///< x87 flag FC0 (not really part of rflags) - xed_uint32_t fc1:1; ///< x87 flag FC1 (not really part of rflags) - xed_uint32_t fc2:1; ///< x87 flag FC2 (not really part of rflags) - xed_uint32_t fc3:1; ///< x87 flag FC3 (not really part of rflags) - } s; - -}; - -typedef union xed_flag_set_s xed_flag_set_t; -/// @ingroup FLAGS -/// @name Flag-set accessors -//@{ -/// @ingroup FLAGS -/// print the flag set in the supplied buffer -XED_DLL_EXPORT int xed_flag_set_print(const xed_flag_set_t* p, char* buf, int buflen); -/// @ingroup FLAGS -/// returns true if this object has a subset of the flags of the -/// "other" object. -XED_DLL_EXPORT xed_bool_t xed_flag_set_is_subset_of(const xed_flag_set_t* p, - const xed_flag_set_t* other); -//@} - - -//////////////////////////////////////////////////////////////////////////// - -/// @ingroup FLAGS -/// Associated with each flag field there can be one action. -typedef struct xed_flag_enum_s { - xed_flag_enum_t flag; - // there are at most two actions per flag. The 2nd may be invalid. - xed_flag_action_enum_t action; -} xed_flag_action_t; - - - - -/// @ingroup FLAGS -/// @name Lowest-level flag-action accessors -//@{ -/// @ingroup FLAGS -/// get the name of the flag -XED_DLL_EXPORT xed_flag_enum_t -xed_flag_action_get_flag_name(const xed_flag_action_t* p); -/// @ingroup FLAGS -/// return the action -XED_DLL_EXPORT xed_flag_action_enum_t -xed_flag_action_get_action(const xed_flag_action_t* p, unsigned int i); -/// @ingroup FLAGS -/// returns true if the specified action is invalid. Only the 2nd flag might be invalid. -XED_DLL_EXPORT xed_bool_t -xed_flag_action_action_invalid(const xed_flag_action_enum_t a); -/// @ingroup FLAGS -/// print the flag & actions -XED_DLL_EXPORT int xed_flag_action_print(const xed_flag_action_t* p, char* buf, int buflen); -/// @ingroup FLAGS -/// returns true if either action is a read -XED_DLL_EXPORT xed_bool_t -xed_flag_action_read_flag(const xed_flag_action_t* p ); -/// @ingroup FLAGS -/// returns true if either action is a write -XED_DLL_EXPORT xed_bool_t -xed_flag_action_writes_flag(const xed_flag_action_t* p); - -/// @ingroup FLAGS -/// test to see if the specific action is a read -XED_DLL_EXPORT xed_bool_t -xed_flag_action_read_action( xed_flag_action_enum_t a); -/// @ingroup FLAGS -/// test to see if a specific action is a write -XED_DLL_EXPORT xed_bool_t -xed_flag_action_write_action( xed_flag_action_enum_t a); -//@} - -//////////////////////////////////////////////////////////////////////////// - -/// @ingroup FLAGS -/// A collection of #xed_flag_action_t's and unions of read and written flags -typedef struct xed_simple_flag_s -{ - ///number of flag actions associated with this record - xed_uint8_t nflags; - - xed_uint8_t may_write; /* 1/0, only using one bit */ - xed_uint8_t must_write; /* 1/0, only using one bit */ - - ///union of read flags - xed_flag_set_t read; - - /// union of written flags (includes undefined flags); - xed_flag_set_t written; - - /// union of undefined flags; - xed_flag_set_t undefined; - - // index in to the xed_flag_action_table. nflags limits the # of entries. - xed_uint16_t fa_index; - -} xed_simple_flag_t; - -/// @ingroup FLAGS -/// @name Accessing the simple flags (Mid-level access) -//@{ -/// @ingroup FLAGS -/// returns the number of flag-actions -XED_DLL_EXPORT unsigned int -xed_simple_flag_get_nflags(const xed_simple_flag_t* p); - -/// @ingroup FLAGS -/// return union of bits for read flags -XED_DLL_EXPORT const xed_flag_set_t* -xed_simple_flag_get_read_flag_set(const xed_simple_flag_t* p); - -/// @ingroup FLAGS -/// return union of bits for written flags -XED_DLL_EXPORT const xed_flag_set_t* -xed_simple_flag_get_written_flag_set(const xed_simple_flag_t* p); - - -/// @ingroup FLAGS -/// return union of bits for undefined flags -XED_DLL_EXPORT const xed_flag_set_t* -xed_simple_flag_get_undefined_flag_set(const xed_simple_flag_t* p); - -/// @ingroup FLAGS -/// Indicates the flags are only conditionally written. Usually MAY-writes -/// of the flags instructions that are dependent on a REP count. -XED_DLL_EXPORT xed_bool_t xed_simple_flag_get_may_write(const xed_simple_flag_t* p); - -/// @ingroup FLAGS -/// the flags always written -XED_DLL_EXPORT xed_bool_t xed_simple_flag_get_must_write(const xed_simple_flag_t* p); - -/// @ingroup FLAGS -/// return the specific flag-action. Very detailed low level information -XED_DLL_EXPORT const xed_flag_action_t* -xed_simple_flag_get_flag_action(const xed_simple_flag_t* p, unsigned int i); - -/// @ingroup FLAGS -/// boolean test to see if flags are read, scans the flags -XED_DLL_EXPORT xed_bool_t -xed_simple_flag_reads_flags(const xed_simple_flag_t* p); - -/// @ingroup FLAGS -/// boolean test to see if flags are written, scans the flags -XED_DLL_EXPORT xed_bool_t xed_simple_flag_writes_flags(const xed_simple_flag_t* p); - -/// @ingroup FLAGS -/// print the flags -XED_DLL_EXPORT int xed_simple_flag_print(const xed_simple_flag_t* p, char* buf, int buflen); - -/// @ingroup FLAGS -/// Return the flags as a mask -static XED_INLINE unsigned int xed_flag_set_mask(const xed_flag_set_t* p) { - return p->flat; // FIXME: could mask out the X87 flags -} - -//@} - -//////////////////////////////////////////////////////////////////////////// - - -//////////////////////////////////////////////////////////////////////////// - -#endif diff --git a/target/i386/latx/include/xed/xed-format-options.h b/target/i386/latx/include/xed/xed-format-options.h deleted file mode 100644 index 72665aca249..00000000000 --- a/target/i386/latx/include/xed/xed-format-options.h +++ /dev/null @@ -1,68 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-format-options.h - - -#ifndef XED_FORMAT_OPTIONS_H -# define XED_FORMAT_OPTIONS_H -#include "xed-types.h" - - -/// @name Formatting options -//@{ - -/// Options for the disasembly formatting functions. Set once during -/// initialization by a calling #xed_format_set_options -/// @ingroup PRINT -typedef struct { - /// by default, XED prints the hex address before any symbolic name for - /// branch targets. If set to zero, then XED will not print the hex - /// address before a valid symbolic name. - unsigned int hex_address_before_symbolic_name; - - /// Simple XML output format for the Intel syntax disassembly. - unsigned int xml_a; - /// Include flags in the XML formatting (must also supply xml_a) - unsigned int xml_f; - - /// omit unit scale "*1" - unsigned int omit_unit_scale; - - /// do not sign extend signed immediates - unsigned int no_sign_extend_signed_immediates; - - /// write-mask-with-curly-brackets, omit k0 - unsigned int write_mask_curly_k0; - - /// lowercase hexadecimal - xed_bool_t lowercase_hex; - - /// Show negative memory displacements as - /// positive numbers. - xed_bool_t positive_memory_displacements; - -} xed_format_options_t; - -/// Optionally, customize the disassembly formatting options by passing -/// in a #xed_format_options_t structure. -/// @ingroup PRINT -XED_DLL_EXPORT void -xed_format_set_options(xed_format_options_t format_options); -//@} - -#endif diff --git a/target/i386/latx/include/xed/xed-gen-table-defs.h b/target/i386/latx/include/xed/xed-gen-table-defs.h deleted file mode 100644 index 26eb1f791b0..00000000000 --- a/target/i386/latx/include/xed/xed-gen-table-defs.h +++ /dev/null @@ -1,39 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-gen-table-defs.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_GEN_TABLE_DEFS_H) -# define XED_GEN_TABLE_DEFS_H -#define XED_ICLASS_NAME_STR_MAX 142 -#define XED_MAX_ATTRIBUTE_COUNT 93 -#define XED_MAX_INST_TABLE_NODES 7614 -#define XED_MAX_OPERAND_TABLE_NODES 1502 -#define XED_MAX_OPERAND_SEQUENCES 8974 -#define XED_MAX_REQUIRED_SIMPLE_FLAGS_ENTRIES 99 -#define XED_MAX_REQUIRED_COMPLEX_FLAGS_ENTRIES 37 -#define XED_MAX_GLOBAL_FLAG_ACTIONS 472 -#define XED_MAX_IFORMS_PER_ICLASS 28 -#define XED_MAX_REQUIRED_ATTRIBUTES 205 -#define XED_MAX_CONVERT_PATTERNS 5 -#define XED_MAX_DECORATIONS_PER_OPERAND 3 -#define XED_MAX_MAP_VEX 3 -#define XED_MAX_MAP_EVEX 6 -#endif diff --git a/target/i386/latx/include/xed/xed-get-time.h b/target/i386/latx/include/xed/xed-get-time.h deleted file mode 100644 index 9c27cdcb37f..00000000000 --- a/target/i386/latx/include/xed/xed-get-time.h +++ /dev/null @@ -1,75 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ - -#if !defined(XED_GET_TIME_H) -# define XED_GET_TIME_H - -# include "xed-portability.h" -# include "xed-types.h" -# if defined(__INTEL_COMPILER) && __INTEL_COMPILER > 810 && !defined(_M_IA64) -# include -# endif -# if defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 810 && !defined(_M_IA64) -# if __INTEL_COMPILER < 1000 -# pragma intrinsic(__rdtsc) -# endif -# endif -# if !defined(__INTEL_COMPILER) - /* MSVS8 and later */ -# if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(_M_IA64) -# include -# pragma intrinsic(__rdtsc) -# endif -# if defined(__GNUC__) -# if defined(__i386__) || defined(i386) || defined(i686) || defined(__x86_64__) -# include -# endif -# endif -# endif - - -static XED_INLINE xed_uint64_t xed_get_time(void) { - xed_union64_t ticks; -# if defined(__GNUC__) -# if defined(__i386__) || defined(i386) || defined(i686) || defined(__x86_64__) -# if __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9 && __GNUC_PATCHLEVEL__ >= 3) - ticks.u64 = __rdtsc(); -# else - __asm__ volatile ("rdtsc":"=a" (ticks.s.lo32), "=d"(ticks.s.hi32)); -# endif -# define XED_FOUND_RDTSC -# endif -# endif -# if defined(__INTEL_COMPILER) && __INTEL_COMPILER>=810 && !defined(_M_IA64) - ticks.u64 = __rdtsc(); -# define XED_FOUND_RDTSC -# endif -# if !defined(__INTEL_COMPILER) -# if !defined(XED_FOUND_RDTSC) && defined(_MSC_VER) && _MSC_VER >= 1400 && \ - !defined(_M_IA64) && !defined(_MANAGED) /* MSVS7, 8 */ - ticks.u64 = __rdtsc(); -# define XED_FOUND_RDTSC -# endif -# endif -# if !defined(XED_FOUND_RDTSC) - ticks.u64 = 0; -# endif - return ticks.u64; -} -#undef XED_FOUND_RDTSC -#endif diff --git a/target/i386/latx/include/xed/xed-iclass-enum.h b/target/i386/latx/include/xed/xed-iclass-enum.h deleted file mode 100644 index 1fd9867bdea..00000000000 --- a/target/i386/latx/include/xed/xed-iclass-enum.h +++ /dev/null @@ -1,3534 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-iclass-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_ICLASS_ENUM_H) -# define XED_ICLASS_ENUM_H -#include "xed-common-hdrs.h" -#define XED_ICLASS_INVALID_DEFINED 1 -#define XED_ICLASS_AAA_DEFINED 1 -#define XED_ICLASS_AAD_DEFINED 1 -#define XED_ICLASS_AAM_DEFINED 1 -#define XED_ICLASS_AAS_DEFINED 1 -#define XED_ICLASS_ADC_DEFINED 1 -#define XED_ICLASS_ADCX_DEFINED 1 -#define XED_ICLASS_ADC_LOCK_DEFINED 1 -#define XED_ICLASS_ADD_DEFINED 1 -#define XED_ICLASS_ADDPD_DEFINED 1 -#define XED_ICLASS_ADDPS_DEFINED 1 -#define XED_ICLASS_ADDSD_DEFINED 1 -#define XED_ICLASS_ADDSS_DEFINED 1 -#define XED_ICLASS_ADDSUBPD_DEFINED 1 -#define XED_ICLASS_ADDSUBPS_DEFINED 1 -#define XED_ICLASS_ADD_LOCK_DEFINED 1 -#define XED_ICLASS_ADOX_DEFINED 1 -#define XED_ICLASS_AESDEC_DEFINED 1 -#define XED_ICLASS_AESDEC128KL_DEFINED 1 -#define XED_ICLASS_AESDEC256KL_DEFINED 1 -#define XED_ICLASS_AESDECLAST_DEFINED 1 -#define XED_ICLASS_AESDECWIDE128KL_DEFINED 1 -#define XED_ICLASS_AESDECWIDE256KL_DEFINED 1 -#define XED_ICLASS_AESENC_DEFINED 1 -#define XED_ICLASS_AESENC128KL_DEFINED 1 -#define XED_ICLASS_AESENC256KL_DEFINED 1 -#define XED_ICLASS_AESENCLAST_DEFINED 1 -#define XED_ICLASS_AESENCWIDE128KL_DEFINED 1 -#define XED_ICLASS_AESENCWIDE256KL_DEFINED 1 -#define XED_ICLASS_AESIMC_DEFINED 1 -#define XED_ICLASS_AESKEYGENASSIST_DEFINED 1 -#define XED_ICLASS_AND_DEFINED 1 -#define XED_ICLASS_ANDN_DEFINED 1 -#define XED_ICLASS_ANDNPD_DEFINED 1 -#define XED_ICLASS_ANDNPS_DEFINED 1 -#define XED_ICLASS_ANDPD_DEFINED 1 -#define XED_ICLASS_ANDPS_DEFINED 1 -#define XED_ICLASS_AND_LOCK_DEFINED 1 -#define XED_ICLASS_ARPL_DEFINED 1 -#define XED_ICLASS_BEXTR_DEFINED 1 -#define XED_ICLASS_BEXTR_XOP_DEFINED 1 -#define XED_ICLASS_BLCFILL_DEFINED 1 -#define XED_ICLASS_BLCI_DEFINED 1 -#define XED_ICLASS_BLCIC_DEFINED 1 -#define XED_ICLASS_BLCMSK_DEFINED 1 -#define XED_ICLASS_BLCS_DEFINED 1 -#define XED_ICLASS_BLENDPD_DEFINED 1 -#define XED_ICLASS_BLENDPS_DEFINED 1 -#define XED_ICLASS_BLENDVPD_DEFINED 1 -#define XED_ICLASS_BLENDVPS_DEFINED 1 -#define XED_ICLASS_BLSFILL_DEFINED 1 -#define XED_ICLASS_BLSI_DEFINED 1 -#define XED_ICLASS_BLSIC_DEFINED 1 -#define XED_ICLASS_BLSMSK_DEFINED 1 -#define XED_ICLASS_BLSR_DEFINED 1 -#define XED_ICLASS_BNDCL_DEFINED 1 -#define XED_ICLASS_BNDCN_DEFINED 1 -#define XED_ICLASS_BNDCU_DEFINED 1 -#define XED_ICLASS_BNDLDX_DEFINED 1 -#define XED_ICLASS_BNDMK_DEFINED 1 -#define XED_ICLASS_BNDMOV_DEFINED 1 -#define XED_ICLASS_BNDSTX_DEFINED 1 -#define XED_ICLASS_BOUND_DEFINED 1 -#define XED_ICLASS_BSF_DEFINED 1 -#define XED_ICLASS_BSR_DEFINED 1 -#define XED_ICLASS_BSWAP_DEFINED 1 -#define XED_ICLASS_BT_DEFINED 1 -#define XED_ICLASS_BTC_DEFINED 1 -#define XED_ICLASS_BTC_LOCK_DEFINED 1 -#define XED_ICLASS_BTR_DEFINED 1 -#define XED_ICLASS_BTR_LOCK_DEFINED 1 -#define XED_ICLASS_BTS_DEFINED 1 -#define XED_ICLASS_BTS_LOCK_DEFINED 1 -#define XED_ICLASS_BZHI_DEFINED 1 -#define XED_ICLASS_CALL_FAR_DEFINED 1 -#define XED_ICLASS_CALL_NEAR_DEFINED 1 -#define XED_ICLASS_CBW_DEFINED 1 -#define XED_ICLASS_CDQ_DEFINED 1 -#define XED_ICLASS_CDQE_DEFINED 1 -#define XED_ICLASS_CLAC_DEFINED 1 -#define XED_ICLASS_CLC_DEFINED 1 -#define XED_ICLASS_CLD_DEFINED 1 -#define XED_ICLASS_CLDEMOTE_DEFINED 1 -#define XED_ICLASS_CLFLUSH_DEFINED 1 -#define XED_ICLASS_CLFLUSHOPT_DEFINED 1 -#define XED_ICLASS_CLGI_DEFINED 1 -#define XED_ICLASS_CLI_DEFINED 1 -#define XED_ICLASS_CLRSSBSY_DEFINED 1 -#define XED_ICLASS_CLTS_DEFINED 1 -#define XED_ICLASS_CLUI_DEFINED 1 -#define XED_ICLASS_CLWB_DEFINED 1 -#define XED_ICLASS_CLZERO_DEFINED 1 -#define XED_ICLASS_CMC_DEFINED 1 -#define XED_ICLASS_CMOVB_DEFINED 1 -#define XED_ICLASS_CMOVBE_DEFINED 1 -#define XED_ICLASS_CMOVL_DEFINED 1 -#define XED_ICLASS_CMOVLE_DEFINED 1 -#define XED_ICLASS_CMOVNB_DEFINED 1 -#define XED_ICLASS_CMOVNBE_DEFINED 1 -#define XED_ICLASS_CMOVNL_DEFINED 1 -#define XED_ICLASS_CMOVNLE_DEFINED 1 -#define XED_ICLASS_CMOVNO_DEFINED 1 -#define XED_ICLASS_CMOVNP_DEFINED 1 -#define XED_ICLASS_CMOVNS_DEFINED 1 -#define XED_ICLASS_CMOVNZ_DEFINED 1 -#define XED_ICLASS_CMOVO_DEFINED 1 -#define XED_ICLASS_CMOVP_DEFINED 1 -#define XED_ICLASS_CMOVS_DEFINED 1 -#define XED_ICLASS_CMOVZ_DEFINED 1 -#define XED_ICLASS_CMP_DEFINED 1 -#define XED_ICLASS_CMPPD_DEFINED 1 -#define XED_ICLASS_CMPPS_DEFINED 1 -#define XED_ICLASS_CMPSB_DEFINED 1 -#define XED_ICLASS_CMPSD_DEFINED 1 -#define XED_ICLASS_CMPSD_XMM_DEFINED 1 -#define XED_ICLASS_CMPSQ_DEFINED 1 -#define XED_ICLASS_CMPSS_DEFINED 1 -#define XED_ICLASS_CMPSW_DEFINED 1 -#define XED_ICLASS_CMPXCHG_DEFINED 1 -#define XED_ICLASS_CMPXCHG16B_DEFINED 1 -#define XED_ICLASS_CMPXCHG16B_LOCK_DEFINED 1 -#define XED_ICLASS_CMPXCHG8B_DEFINED 1 -#define XED_ICLASS_CMPXCHG8B_LOCK_DEFINED 1 -#define XED_ICLASS_CMPXCHG_LOCK_DEFINED 1 -#define XED_ICLASS_COMISD_DEFINED 1 -#define XED_ICLASS_COMISS_DEFINED 1 -#define XED_ICLASS_CPUID_DEFINED 1 -#define XED_ICLASS_CQO_DEFINED 1 -#define XED_ICLASS_CRC32_DEFINED 1 -#define XED_ICLASS_CVTDQ2PD_DEFINED 1 -#define XED_ICLASS_CVTDQ2PS_DEFINED 1 -#define XED_ICLASS_CVTPD2DQ_DEFINED 1 -#define XED_ICLASS_CVTPD2PI_DEFINED 1 -#define XED_ICLASS_CVTPD2PS_DEFINED 1 -#define XED_ICLASS_CVTPI2PD_DEFINED 1 -#define XED_ICLASS_CVTPI2PS_DEFINED 1 -#define XED_ICLASS_CVTPS2DQ_DEFINED 1 -#define XED_ICLASS_CVTPS2PD_DEFINED 1 -#define XED_ICLASS_CVTPS2PI_DEFINED 1 -#define XED_ICLASS_CVTSD2SI_DEFINED 1 -#define XED_ICLASS_CVTSD2SS_DEFINED 1 -#define XED_ICLASS_CVTSI2SD_DEFINED 1 -#define XED_ICLASS_CVTSI2SS_DEFINED 1 -#define XED_ICLASS_CVTSS2SD_DEFINED 1 -#define XED_ICLASS_CVTSS2SI_DEFINED 1 -#define XED_ICLASS_CVTTPD2DQ_DEFINED 1 -#define XED_ICLASS_CVTTPD2PI_DEFINED 1 -#define XED_ICLASS_CVTTPS2DQ_DEFINED 1 -#define XED_ICLASS_CVTTPS2PI_DEFINED 1 -#define XED_ICLASS_CVTTSD2SI_DEFINED 1 -#define XED_ICLASS_CVTTSS2SI_DEFINED 1 -#define XED_ICLASS_CWD_DEFINED 1 -#define XED_ICLASS_CWDE_DEFINED 1 -#define XED_ICLASS_DAA_DEFINED 1 -#define XED_ICLASS_DAS_DEFINED 1 -#define XED_ICLASS_DEC_DEFINED 1 -#define XED_ICLASS_DEC_LOCK_DEFINED 1 -#define XED_ICLASS_DIV_DEFINED 1 -#define XED_ICLASS_DIVPD_DEFINED 1 -#define XED_ICLASS_DIVPS_DEFINED 1 -#define XED_ICLASS_DIVSD_DEFINED 1 -#define XED_ICLASS_DIVSS_DEFINED 1 -#define XED_ICLASS_DPPD_DEFINED 1 -#define XED_ICLASS_DPPS_DEFINED 1 -#define XED_ICLASS_EMMS_DEFINED 1 -#define XED_ICLASS_ENCLS_DEFINED 1 -#define XED_ICLASS_ENCLU_DEFINED 1 -#define XED_ICLASS_ENCLV_DEFINED 1 -#define XED_ICLASS_ENCODEKEY128_DEFINED 1 -#define XED_ICLASS_ENCODEKEY256_DEFINED 1 -#define XED_ICLASS_ENDBR32_DEFINED 1 -#define XED_ICLASS_ENDBR64_DEFINED 1 -#define XED_ICLASS_ENQCMD_DEFINED 1 -#define XED_ICLASS_ENQCMDS_DEFINED 1 -#define XED_ICLASS_ENTER_DEFINED 1 -#define XED_ICLASS_EXTRACTPS_DEFINED 1 -#define XED_ICLASS_EXTRQ_DEFINED 1 -#define XED_ICLASS_F2XM1_DEFINED 1 -#define XED_ICLASS_FABS_DEFINED 1 -#define XED_ICLASS_FADD_DEFINED 1 -#define XED_ICLASS_FADDP_DEFINED 1 -#define XED_ICLASS_FBLD_DEFINED 1 -#define XED_ICLASS_FBSTP_DEFINED 1 -#define XED_ICLASS_FCHS_DEFINED 1 -#define XED_ICLASS_FCMOVB_DEFINED 1 -#define XED_ICLASS_FCMOVBE_DEFINED 1 -#define XED_ICLASS_FCMOVE_DEFINED 1 -#define XED_ICLASS_FCMOVNB_DEFINED 1 -#define XED_ICLASS_FCMOVNBE_DEFINED 1 -#define XED_ICLASS_FCMOVNE_DEFINED 1 -#define XED_ICLASS_FCMOVNU_DEFINED 1 -#define XED_ICLASS_FCMOVU_DEFINED 1 -#define XED_ICLASS_FCOM_DEFINED 1 -#define XED_ICLASS_FCOMI_DEFINED 1 -#define XED_ICLASS_FCOMIP_DEFINED 1 -#define XED_ICLASS_FCOMP_DEFINED 1 -#define XED_ICLASS_FCOMPP_DEFINED 1 -#define XED_ICLASS_FCOS_DEFINED 1 -#define XED_ICLASS_FDECSTP_DEFINED 1 -#define XED_ICLASS_FDISI8087_NOP_DEFINED 1 -#define XED_ICLASS_FDIV_DEFINED 1 -#define XED_ICLASS_FDIVP_DEFINED 1 -#define XED_ICLASS_FDIVR_DEFINED 1 -#define XED_ICLASS_FDIVRP_DEFINED 1 -#define XED_ICLASS_FEMMS_DEFINED 1 -#define XED_ICLASS_FENI8087_NOP_DEFINED 1 -#define XED_ICLASS_FFREE_DEFINED 1 -#define XED_ICLASS_FFREEP_DEFINED 1 -#define XED_ICLASS_FIADD_DEFINED 1 -#define XED_ICLASS_FICOM_DEFINED 1 -#define XED_ICLASS_FICOMP_DEFINED 1 -#define XED_ICLASS_FIDIV_DEFINED 1 -#define XED_ICLASS_FIDIVR_DEFINED 1 -#define XED_ICLASS_FILD_DEFINED 1 -#define XED_ICLASS_FIMUL_DEFINED 1 -#define XED_ICLASS_FINCSTP_DEFINED 1 -#define XED_ICLASS_FIST_DEFINED 1 -#define XED_ICLASS_FISTP_DEFINED 1 -#define XED_ICLASS_FISTTP_DEFINED 1 -#define XED_ICLASS_FISUB_DEFINED 1 -#define XED_ICLASS_FISUBR_DEFINED 1 -#define XED_ICLASS_FLD_DEFINED 1 -#define XED_ICLASS_FLD1_DEFINED 1 -#define XED_ICLASS_FLDCW_DEFINED 1 -#define XED_ICLASS_FLDENV_DEFINED 1 -#define XED_ICLASS_FLDL2E_DEFINED 1 -#define XED_ICLASS_FLDL2T_DEFINED 1 -#define XED_ICLASS_FLDLG2_DEFINED 1 -#define XED_ICLASS_FLDLN2_DEFINED 1 -#define XED_ICLASS_FLDPI_DEFINED 1 -#define XED_ICLASS_FLDZ_DEFINED 1 -#define XED_ICLASS_FMUL_DEFINED 1 -#define XED_ICLASS_FMULP_DEFINED 1 -#define XED_ICLASS_FNCLEX_DEFINED 1 -#define XED_ICLASS_FNINIT_DEFINED 1 -#define XED_ICLASS_FNOP_DEFINED 1 -#define XED_ICLASS_FNSAVE_DEFINED 1 -#define XED_ICLASS_FNSTCW_DEFINED 1 -#define XED_ICLASS_FNSTENV_DEFINED 1 -#define XED_ICLASS_FNSTSW_DEFINED 1 -#define XED_ICLASS_FPATAN_DEFINED 1 -#define XED_ICLASS_FPREM_DEFINED 1 -#define XED_ICLASS_FPREM1_DEFINED 1 -#define XED_ICLASS_FPTAN_DEFINED 1 -#define XED_ICLASS_FRNDINT_DEFINED 1 -#define XED_ICLASS_FRSTOR_DEFINED 1 -#define XED_ICLASS_FSCALE_DEFINED 1 -#define XED_ICLASS_FSETPM287_NOP_DEFINED 1 -#define XED_ICLASS_FSIN_DEFINED 1 -#define XED_ICLASS_FSINCOS_DEFINED 1 -#define XED_ICLASS_FSQRT_DEFINED 1 -#define XED_ICLASS_FST_DEFINED 1 -#define XED_ICLASS_FSTP_DEFINED 1 -#define XED_ICLASS_FSTPNCE_DEFINED 1 -#define XED_ICLASS_FSUB_DEFINED 1 -#define XED_ICLASS_FSUBP_DEFINED 1 -#define XED_ICLASS_FSUBR_DEFINED 1 -#define XED_ICLASS_FSUBRP_DEFINED 1 -#define XED_ICLASS_FTST_DEFINED 1 -#define XED_ICLASS_FUCOM_DEFINED 1 -#define XED_ICLASS_FUCOMI_DEFINED 1 -#define XED_ICLASS_FUCOMIP_DEFINED 1 -#define XED_ICLASS_FUCOMP_DEFINED 1 -#define XED_ICLASS_FUCOMPP_DEFINED 1 -#define XED_ICLASS_FWAIT_DEFINED 1 -#define XED_ICLASS_FXAM_DEFINED 1 -#define XED_ICLASS_FXCH_DEFINED 1 -#define XED_ICLASS_FXRSTOR_DEFINED 1 -#define XED_ICLASS_FXRSTOR64_DEFINED 1 -#define XED_ICLASS_FXSAVE_DEFINED 1 -#define XED_ICLASS_FXSAVE64_DEFINED 1 -#define XED_ICLASS_FXTRACT_DEFINED 1 -#define XED_ICLASS_FYL2X_DEFINED 1 -#define XED_ICLASS_FYL2XP1_DEFINED 1 -#define XED_ICLASS_GETSEC_DEFINED 1 -#define XED_ICLASS_GF2P8AFFINEINVQB_DEFINED 1 -#define XED_ICLASS_GF2P8AFFINEQB_DEFINED 1 -#define XED_ICLASS_GF2P8MULB_DEFINED 1 -#define XED_ICLASS_HADDPD_DEFINED 1 -#define XED_ICLASS_HADDPS_DEFINED 1 -#define XED_ICLASS_HLT_DEFINED 1 -#define XED_ICLASS_HRESET_DEFINED 1 -#define XED_ICLASS_HSUBPD_DEFINED 1 -#define XED_ICLASS_HSUBPS_DEFINED 1 -#define XED_ICLASS_IDIV_DEFINED 1 -#define XED_ICLASS_IMUL_DEFINED 1 -#define XED_ICLASS_IN_DEFINED 1 -#define XED_ICLASS_INC_DEFINED 1 -#define XED_ICLASS_INCSSPD_DEFINED 1 -#define XED_ICLASS_INCSSPQ_DEFINED 1 -#define XED_ICLASS_INC_LOCK_DEFINED 1 -#define XED_ICLASS_INSB_DEFINED 1 -#define XED_ICLASS_INSD_DEFINED 1 -#define XED_ICLASS_INSERTPS_DEFINED 1 -#define XED_ICLASS_INSERTQ_DEFINED 1 -#define XED_ICLASS_INSW_DEFINED 1 -#define XED_ICLASS_INT_DEFINED 1 -#define XED_ICLASS_INT1_DEFINED 1 -#define XED_ICLASS_INT3_DEFINED 1 -#define XED_ICLASS_INTO_DEFINED 1 -#define XED_ICLASS_INVD_DEFINED 1 -#define XED_ICLASS_INVEPT_DEFINED 1 -#define XED_ICLASS_INVLPG_DEFINED 1 -#define XED_ICLASS_INVLPGA_DEFINED 1 -#define XED_ICLASS_INVLPGB_DEFINED 1 -#define XED_ICLASS_INVPCID_DEFINED 1 -#define XED_ICLASS_INVVPID_DEFINED 1 -#define XED_ICLASS_IRET_DEFINED 1 -#define XED_ICLASS_IRETD_DEFINED 1 -#define XED_ICLASS_IRETQ_DEFINED 1 -#define XED_ICLASS_JB_DEFINED 1 -#define XED_ICLASS_JBE_DEFINED 1 -#define XED_ICLASS_JCXZ_DEFINED 1 -#define XED_ICLASS_JECXZ_DEFINED 1 -#define XED_ICLASS_JL_DEFINED 1 -#define XED_ICLASS_JLE_DEFINED 1 -#define XED_ICLASS_JMP_DEFINED 1 -#define XED_ICLASS_JMP_FAR_DEFINED 1 -#define XED_ICLASS_JNB_DEFINED 1 -#define XED_ICLASS_JNBE_DEFINED 1 -#define XED_ICLASS_JNL_DEFINED 1 -#define XED_ICLASS_JNLE_DEFINED 1 -#define XED_ICLASS_JNO_DEFINED 1 -#define XED_ICLASS_JNP_DEFINED 1 -#define XED_ICLASS_JNS_DEFINED 1 -#define XED_ICLASS_JNZ_DEFINED 1 -#define XED_ICLASS_JO_DEFINED 1 -#define XED_ICLASS_JP_DEFINED 1 -#define XED_ICLASS_JRCXZ_DEFINED 1 -#define XED_ICLASS_JS_DEFINED 1 -#define XED_ICLASS_JZ_DEFINED 1 -#define XED_ICLASS_KADDB_DEFINED 1 -#define XED_ICLASS_KADDD_DEFINED 1 -#define XED_ICLASS_KADDQ_DEFINED 1 -#define XED_ICLASS_KADDW_DEFINED 1 -#define XED_ICLASS_KANDB_DEFINED 1 -#define XED_ICLASS_KANDD_DEFINED 1 -#define XED_ICLASS_KANDNB_DEFINED 1 -#define XED_ICLASS_KANDND_DEFINED 1 -#define XED_ICLASS_KANDNQ_DEFINED 1 -#define XED_ICLASS_KANDNW_DEFINED 1 -#define XED_ICLASS_KANDQ_DEFINED 1 -#define XED_ICLASS_KANDW_DEFINED 1 -#define XED_ICLASS_KMOVB_DEFINED 1 -#define XED_ICLASS_KMOVD_DEFINED 1 -#define XED_ICLASS_KMOVQ_DEFINED 1 -#define XED_ICLASS_KMOVW_DEFINED 1 -#define XED_ICLASS_KNOTB_DEFINED 1 -#define XED_ICLASS_KNOTD_DEFINED 1 -#define XED_ICLASS_KNOTQ_DEFINED 1 -#define XED_ICLASS_KNOTW_DEFINED 1 -#define XED_ICLASS_KORB_DEFINED 1 -#define XED_ICLASS_KORD_DEFINED 1 -#define XED_ICLASS_KORQ_DEFINED 1 -#define XED_ICLASS_KORTESTB_DEFINED 1 -#define XED_ICLASS_KORTESTD_DEFINED 1 -#define XED_ICLASS_KORTESTQ_DEFINED 1 -#define XED_ICLASS_KORTESTW_DEFINED 1 -#define XED_ICLASS_KORW_DEFINED 1 -#define XED_ICLASS_KSHIFTLB_DEFINED 1 -#define XED_ICLASS_KSHIFTLD_DEFINED 1 -#define XED_ICLASS_KSHIFTLQ_DEFINED 1 -#define XED_ICLASS_KSHIFTLW_DEFINED 1 -#define XED_ICLASS_KSHIFTRB_DEFINED 1 -#define XED_ICLASS_KSHIFTRD_DEFINED 1 -#define XED_ICLASS_KSHIFTRQ_DEFINED 1 -#define XED_ICLASS_KSHIFTRW_DEFINED 1 -#define XED_ICLASS_KTESTB_DEFINED 1 -#define XED_ICLASS_KTESTD_DEFINED 1 -#define XED_ICLASS_KTESTQ_DEFINED 1 -#define XED_ICLASS_KTESTW_DEFINED 1 -#define XED_ICLASS_KUNPCKBW_DEFINED 1 -#define XED_ICLASS_KUNPCKDQ_DEFINED 1 -#define XED_ICLASS_KUNPCKWD_DEFINED 1 -#define XED_ICLASS_KXNORB_DEFINED 1 -#define XED_ICLASS_KXNORD_DEFINED 1 -#define XED_ICLASS_KXNORQ_DEFINED 1 -#define XED_ICLASS_KXNORW_DEFINED 1 -#define XED_ICLASS_KXORB_DEFINED 1 -#define XED_ICLASS_KXORD_DEFINED 1 -#define XED_ICLASS_KXORQ_DEFINED 1 -#define XED_ICLASS_KXORW_DEFINED 1 -#define XED_ICLASS_LAHF_DEFINED 1 -#define XED_ICLASS_LAR_DEFINED 1 -#define XED_ICLASS_LDDQU_DEFINED 1 -#define XED_ICLASS_LDMXCSR_DEFINED 1 -#define XED_ICLASS_LDS_DEFINED 1 -#define XED_ICLASS_LDTILECFG_DEFINED 1 -#define XED_ICLASS_LEA_DEFINED 1 -#define XED_ICLASS_LEAVE_DEFINED 1 -#define XED_ICLASS_LES_DEFINED 1 -#define XED_ICLASS_LFENCE_DEFINED 1 -#define XED_ICLASS_LFS_DEFINED 1 -#define XED_ICLASS_LGDT_DEFINED 1 -#define XED_ICLASS_LGS_DEFINED 1 -#define XED_ICLASS_LIDT_DEFINED 1 -#define XED_ICLASS_LLDT_DEFINED 1 -#define XED_ICLASS_LLWPCB_DEFINED 1 -#define XED_ICLASS_LMSW_DEFINED 1 -#define XED_ICLASS_LOADIWKEY_DEFINED 1 -#define XED_ICLASS_LODSB_DEFINED 1 -#define XED_ICLASS_LODSD_DEFINED 1 -#define XED_ICLASS_LODSQ_DEFINED 1 -#define XED_ICLASS_LODSW_DEFINED 1 -#define XED_ICLASS_LOOP_DEFINED 1 -#define XED_ICLASS_LOOPE_DEFINED 1 -#define XED_ICLASS_LOOPNE_DEFINED 1 -#define XED_ICLASS_LSL_DEFINED 1 -#define XED_ICLASS_LSS_DEFINED 1 -#define XED_ICLASS_LTR_DEFINED 1 -#define XED_ICLASS_LWPINS_DEFINED 1 -#define XED_ICLASS_LWPVAL_DEFINED 1 -#define XED_ICLASS_LZCNT_DEFINED 1 -#define XED_ICLASS_MASKMOVDQU_DEFINED 1 -#define XED_ICLASS_MASKMOVQ_DEFINED 1 -#define XED_ICLASS_MAXPD_DEFINED 1 -#define XED_ICLASS_MAXPS_DEFINED 1 -#define XED_ICLASS_MAXSD_DEFINED 1 -#define XED_ICLASS_MAXSS_DEFINED 1 -#define XED_ICLASS_MCOMMIT_DEFINED 1 -#define XED_ICLASS_MFENCE_DEFINED 1 -#define XED_ICLASS_MINPD_DEFINED 1 -#define XED_ICLASS_MINPS_DEFINED 1 -#define XED_ICLASS_MINSD_DEFINED 1 -#define XED_ICLASS_MINSS_DEFINED 1 -#define XED_ICLASS_MONITOR_DEFINED 1 -#define XED_ICLASS_MONITORX_DEFINED 1 -#define XED_ICLASS_MOV_DEFINED 1 -#define XED_ICLASS_MOVAPD_DEFINED 1 -#define XED_ICLASS_MOVAPS_DEFINED 1 -#define XED_ICLASS_MOVBE_DEFINED 1 -#define XED_ICLASS_MOVD_DEFINED 1 -#define XED_ICLASS_MOVDDUP_DEFINED 1 -#define XED_ICLASS_MOVDIR64B_DEFINED 1 -#define XED_ICLASS_MOVDIRI_DEFINED 1 -#define XED_ICLASS_MOVDQ2Q_DEFINED 1 -#define XED_ICLASS_MOVDQA_DEFINED 1 -#define XED_ICLASS_MOVDQU_DEFINED 1 -#define XED_ICLASS_MOVHLPS_DEFINED 1 -#define XED_ICLASS_MOVHPD_DEFINED 1 -#define XED_ICLASS_MOVHPS_DEFINED 1 -#define XED_ICLASS_MOVLHPS_DEFINED 1 -#define XED_ICLASS_MOVLPD_DEFINED 1 -#define XED_ICLASS_MOVLPS_DEFINED 1 -#define XED_ICLASS_MOVMSKPD_DEFINED 1 -#define XED_ICLASS_MOVMSKPS_DEFINED 1 -#define XED_ICLASS_MOVNTDQ_DEFINED 1 -#define XED_ICLASS_MOVNTDQA_DEFINED 1 -#define XED_ICLASS_MOVNTI_DEFINED 1 -#define XED_ICLASS_MOVNTPD_DEFINED 1 -#define XED_ICLASS_MOVNTPS_DEFINED 1 -#define XED_ICLASS_MOVNTQ_DEFINED 1 -#define XED_ICLASS_MOVNTSD_DEFINED 1 -#define XED_ICLASS_MOVNTSS_DEFINED 1 -#define XED_ICLASS_MOVQ_DEFINED 1 -#define XED_ICLASS_MOVQ2DQ_DEFINED 1 -#define XED_ICLASS_MOVSB_DEFINED 1 -#define XED_ICLASS_MOVSD_DEFINED 1 -#define XED_ICLASS_MOVSD_XMM_DEFINED 1 -#define XED_ICLASS_MOVSHDUP_DEFINED 1 -#define XED_ICLASS_MOVSLDUP_DEFINED 1 -#define XED_ICLASS_MOVSQ_DEFINED 1 -#define XED_ICLASS_MOVSS_DEFINED 1 -#define XED_ICLASS_MOVSW_DEFINED 1 -#define XED_ICLASS_MOVSX_DEFINED 1 -#define XED_ICLASS_MOVSXD_DEFINED 1 -#define XED_ICLASS_MOVUPD_DEFINED 1 -#define XED_ICLASS_MOVUPS_DEFINED 1 -#define XED_ICLASS_MOVZX_DEFINED 1 -#define XED_ICLASS_MOV_CR_DEFINED 1 -#define XED_ICLASS_MOV_DR_DEFINED 1 -#define XED_ICLASS_MPSADBW_DEFINED 1 -#define XED_ICLASS_MUL_DEFINED 1 -#define XED_ICLASS_MULPD_DEFINED 1 -#define XED_ICLASS_MULPS_DEFINED 1 -#define XED_ICLASS_MULSD_DEFINED 1 -#define XED_ICLASS_MULSS_DEFINED 1 -#define XED_ICLASS_MULX_DEFINED 1 -#define XED_ICLASS_MWAIT_DEFINED 1 -#define XED_ICLASS_MWAITX_DEFINED 1 -#define XED_ICLASS_NEG_DEFINED 1 -#define XED_ICLASS_NEG_LOCK_DEFINED 1 -#define XED_ICLASS_NOP_DEFINED 1 -#define XED_ICLASS_NOP2_DEFINED 1 -#define XED_ICLASS_NOP3_DEFINED 1 -#define XED_ICLASS_NOP4_DEFINED 1 -#define XED_ICLASS_NOP5_DEFINED 1 -#define XED_ICLASS_NOP6_DEFINED 1 -#define XED_ICLASS_NOP7_DEFINED 1 -#define XED_ICLASS_NOP8_DEFINED 1 -#define XED_ICLASS_NOP9_DEFINED 1 -#define XED_ICLASS_NOT_DEFINED 1 -#define XED_ICLASS_NOT_LOCK_DEFINED 1 -#define XED_ICLASS_OR_DEFINED 1 -#define XED_ICLASS_ORPD_DEFINED 1 -#define XED_ICLASS_ORPS_DEFINED 1 -#define XED_ICLASS_OR_LOCK_DEFINED 1 -#define XED_ICLASS_OUT_DEFINED 1 -#define XED_ICLASS_OUTSB_DEFINED 1 -#define XED_ICLASS_OUTSD_DEFINED 1 -#define XED_ICLASS_OUTSW_DEFINED 1 -#define XED_ICLASS_PABSB_DEFINED 1 -#define XED_ICLASS_PABSD_DEFINED 1 -#define XED_ICLASS_PABSW_DEFINED 1 -#define XED_ICLASS_PACKSSDW_DEFINED 1 -#define XED_ICLASS_PACKSSWB_DEFINED 1 -#define XED_ICLASS_PACKUSDW_DEFINED 1 -#define XED_ICLASS_PACKUSWB_DEFINED 1 -#define XED_ICLASS_PADDB_DEFINED 1 -#define XED_ICLASS_PADDD_DEFINED 1 -#define XED_ICLASS_PADDQ_DEFINED 1 -#define XED_ICLASS_PADDSB_DEFINED 1 -#define XED_ICLASS_PADDSW_DEFINED 1 -#define XED_ICLASS_PADDUSB_DEFINED 1 -#define XED_ICLASS_PADDUSW_DEFINED 1 -#define XED_ICLASS_PADDW_DEFINED 1 -#define XED_ICLASS_PALIGNR_DEFINED 1 -#define XED_ICLASS_PAND_DEFINED 1 -#define XED_ICLASS_PANDN_DEFINED 1 -#define XED_ICLASS_PAUSE_DEFINED 1 -#define XED_ICLASS_PAVGB_DEFINED 1 -#define XED_ICLASS_PAVGUSB_DEFINED 1 -#define XED_ICLASS_PAVGW_DEFINED 1 -#define XED_ICLASS_PBLENDVB_DEFINED 1 -#define XED_ICLASS_PBLENDW_DEFINED 1 -#define XED_ICLASS_PCLMULQDQ_DEFINED 1 -#define XED_ICLASS_PCMPEQB_DEFINED 1 -#define XED_ICLASS_PCMPEQD_DEFINED 1 -#define XED_ICLASS_PCMPEQQ_DEFINED 1 -#define XED_ICLASS_PCMPEQW_DEFINED 1 -#define XED_ICLASS_PCMPESTRI_DEFINED 1 -#define XED_ICLASS_PCMPESTRI64_DEFINED 1 -#define XED_ICLASS_PCMPESTRM_DEFINED 1 -#define XED_ICLASS_PCMPESTRM64_DEFINED 1 -#define XED_ICLASS_PCMPGTB_DEFINED 1 -#define XED_ICLASS_PCMPGTD_DEFINED 1 -#define XED_ICLASS_PCMPGTQ_DEFINED 1 -#define XED_ICLASS_PCMPGTW_DEFINED 1 -#define XED_ICLASS_PCMPISTRI_DEFINED 1 -#define XED_ICLASS_PCMPISTRI64_DEFINED 1 -#define XED_ICLASS_PCMPISTRM_DEFINED 1 -#define XED_ICLASS_PCONFIG_DEFINED 1 -#define XED_ICLASS_PDEP_DEFINED 1 -#define XED_ICLASS_PEXT_DEFINED 1 -#define XED_ICLASS_PEXTRB_DEFINED 1 -#define XED_ICLASS_PEXTRD_DEFINED 1 -#define XED_ICLASS_PEXTRQ_DEFINED 1 -#define XED_ICLASS_PEXTRW_DEFINED 1 -#define XED_ICLASS_PEXTRW_SSE4_DEFINED 1 -#define XED_ICLASS_PF2ID_DEFINED 1 -#define XED_ICLASS_PF2IW_DEFINED 1 -#define XED_ICLASS_PFACC_DEFINED 1 -#define XED_ICLASS_PFADD_DEFINED 1 -#define XED_ICLASS_PFCMPEQ_DEFINED 1 -#define XED_ICLASS_PFCMPGE_DEFINED 1 -#define XED_ICLASS_PFCMPGT_DEFINED 1 -#define XED_ICLASS_PFMAX_DEFINED 1 -#define XED_ICLASS_PFMIN_DEFINED 1 -#define XED_ICLASS_PFMUL_DEFINED 1 -#define XED_ICLASS_PFNACC_DEFINED 1 -#define XED_ICLASS_PFPNACC_DEFINED 1 -#define XED_ICLASS_PFRCP_DEFINED 1 -#define XED_ICLASS_PFRCPIT1_DEFINED 1 -#define XED_ICLASS_PFRCPIT2_DEFINED 1 -#define XED_ICLASS_PFRSQIT1_DEFINED 1 -#define XED_ICLASS_PFRSQRT_DEFINED 1 -#define XED_ICLASS_PFSUB_DEFINED 1 -#define XED_ICLASS_PFSUBR_DEFINED 1 -#define XED_ICLASS_PHADDD_DEFINED 1 -#define XED_ICLASS_PHADDSW_DEFINED 1 -#define XED_ICLASS_PHADDW_DEFINED 1 -#define XED_ICLASS_PHMINPOSUW_DEFINED 1 -#define XED_ICLASS_PHSUBD_DEFINED 1 -#define XED_ICLASS_PHSUBSW_DEFINED 1 -#define XED_ICLASS_PHSUBW_DEFINED 1 -#define XED_ICLASS_PI2FD_DEFINED 1 -#define XED_ICLASS_PI2FW_DEFINED 1 -#define XED_ICLASS_PINSRB_DEFINED 1 -#define XED_ICLASS_PINSRD_DEFINED 1 -#define XED_ICLASS_PINSRQ_DEFINED 1 -#define XED_ICLASS_PINSRW_DEFINED 1 -#define XED_ICLASS_PMADDUBSW_DEFINED 1 -#define XED_ICLASS_PMADDWD_DEFINED 1 -#define XED_ICLASS_PMAXSB_DEFINED 1 -#define XED_ICLASS_PMAXSD_DEFINED 1 -#define XED_ICLASS_PMAXSW_DEFINED 1 -#define XED_ICLASS_PMAXUB_DEFINED 1 -#define XED_ICLASS_PMAXUD_DEFINED 1 -#define XED_ICLASS_PMAXUW_DEFINED 1 -#define XED_ICLASS_PMINSB_DEFINED 1 -#define XED_ICLASS_PMINSD_DEFINED 1 -#define XED_ICLASS_PMINSW_DEFINED 1 -#define XED_ICLASS_PMINUB_DEFINED 1 -#define XED_ICLASS_PMINUD_DEFINED 1 -#define XED_ICLASS_PMINUW_DEFINED 1 -#define XED_ICLASS_PMOVMSKB_DEFINED 1 -#define XED_ICLASS_PMOVSXBD_DEFINED 1 -#define XED_ICLASS_PMOVSXBQ_DEFINED 1 -#define XED_ICLASS_PMOVSXBW_DEFINED 1 -#define XED_ICLASS_PMOVSXDQ_DEFINED 1 -#define XED_ICLASS_PMOVSXWD_DEFINED 1 -#define XED_ICLASS_PMOVSXWQ_DEFINED 1 -#define XED_ICLASS_PMOVZXBD_DEFINED 1 -#define XED_ICLASS_PMOVZXBQ_DEFINED 1 -#define XED_ICLASS_PMOVZXBW_DEFINED 1 -#define XED_ICLASS_PMOVZXDQ_DEFINED 1 -#define XED_ICLASS_PMOVZXWD_DEFINED 1 -#define XED_ICLASS_PMOVZXWQ_DEFINED 1 -#define XED_ICLASS_PMULDQ_DEFINED 1 -#define XED_ICLASS_PMULHRSW_DEFINED 1 -#define XED_ICLASS_PMULHRW_DEFINED 1 -#define XED_ICLASS_PMULHUW_DEFINED 1 -#define XED_ICLASS_PMULHW_DEFINED 1 -#define XED_ICLASS_PMULLD_DEFINED 1 -#define XED_ICLASS_PMULLW_DEFINED 1 -#define XED_ICLASS_PMULUDQ_DEFINED 1 -#define XED_ICLASS_POP_DEFINED 1 -#define XED_ICLASS_POPA_DEFINED 1 -#define XED_ICLASS_POPAD_DEFINED 1 -#define XED_ICLASS_POPCNT_DEFINED 1 -#define XED_ICLASS_POPF_DEFINED 1 -#define XED_ICLASS_POPFD_DEFINED 1 -#define XED_ICLASS_POPFQ_DEFINED 1 -#define XED_ICLASS_POR_DEFINED 1 -#define XED_ICLASS_PREFETCHNTA_DEFINED 1 -#define XED_ICLASS_PREFETCHT0_DEFINED 1 -#define XED_ICLASS_PREFETCHT1_DEFINED 1 -#define XED_ICLASS_PREFETCHT2_DEFINED 1 -#define XED_ICLASS_PREFETCHW_DEFINED 1 -#define XED_ICLASS_PREFETCHWT1_DEFINED 1 -#define XED_ICLASS_PREFETCH_EXCLUSIVE_DEFINED 1 -#define XED_ICLASS_PREFETCH_RESERVED_DEFINED 1 -#define XED_ICLASS_PSADBW_DEFINED 1 -#define XED_ICLASS_PSHUFB_DEFINED 1 -#define XED_ICLASS_PSHUFD_DEFINED 1 -#define XED_ICLASS_PSHUFHW_DEFINED 1 -#define XED_ICLASS_PSHUFLW_DEFINED 1 -#define XED_ICLASS_PSHUFW_DEFINED 1 -#define XED_ICLASS_PSIGNB_DEFINED 1 -#define XED_ICLASS_PSIGND_DEFINED 1 -#define XED_ICLASS_PSIGNW_DEFINED 1 -#define XED_ICLASS_PSLLD_DEFINED 1 -#define XED_ICLASS_PSLLDQ_DEFINED 1 -#define XED_ICLASS_PSLLQ_DEFINED 1 -#define XED_ICLASS_PSLLW_DEFINED 1 -#define XED_ICLASS_PSMASH_DEFINED 1 -#define XED_ICLASS_PSRAD_DEFINED 1 -#define XED_ICLASS_PSRAW_DEFINED 1 -#define XED_ICLASS_PSRLD_DEFINED 1 -#define XED_ICLASS_PSRLDQ_DEFINED 1 -#define XED_ICLASS_PSRLQ_DEFINED 1 -#define XED_ICLASS_PSRLW_DEFINED 1 -#define XED_ICLASS_PSUBB_DEFINED 1 -#define XED_ICLASS_PSUBD_DEFINED 1 -#define XED_ICLASS_PSUBQ_DEFINED 1 -#define XED_ICLASS_PSUBSB_DEFINED 1 -#define XED_ICLASS_PSUBSW_DEFINED 1 -#define XED_ICLASS_PSUBUSB_DEFINED 1 -#define XED_ICLASS_PSUBUSW_DEFINED 1 -#define XED_ICLASS_PSUBW_DEFINED 1 -#define XED_ICLASS_PSWAPD_DEFINED 1 -#define XED_ICLASS_PTEST_DEFINED 1 -#define XED_ICLASS_PTWRITE_DEFINED 1 -#define XED_ICLASS_PUNPCKHBW_DEFINED 1 -#define XED_ICLASS_PUNPCKHDQ_DEFINED 1 -#define XED_ICLASS_PUNPCKHQDQ_DEFINED 1 -#define XED_ICLASS_PUNPCKHWD_DEFINED 1 -#define XED_ICLASS_PUNPCKLBW_DEFINED 1 -#define XED_ICLASS_PUNPCKLDQ_DEFINED 1 -#define XED_ICLASS_PUNPCKLQDQ_DEFINED 1 -#define XED_ICLASS_PUNPCKLWD_DEFINED 1 -#define XED_ICLASS_PUSH_DEFINED 1 -#define XED_ICLASS_PUSHA_DEFINED 1 -#define XED_ICLASS_PUSHAD_DEFINED 1 -#define XED_ICLASS_PUSHF_DEFINED 1 -#define XED_ICLASS_PUSHFD_DEFINED 1 -#define XED_ICLASS_PUSHFQ_DEFINED 1 -#define XED_ICLASS_PVALIDATE_DEFINED 1 -#define XED_ICLASS_PXOR_DEFINED 1 -#define XED_ICLASS_RCL_DEFINED 1 -#define XED_ICLASS_RCPPS_DEFINED 1 -#define XED_ICLASS_RCPSS_DEFINED 1 -#define XED_ICLASS_RCR_DEFINED 1 -#define XED_ICLASS_RDFSBASE_DEFINED 1 -#define XED_ICLASS_RDGSBASE_DEFINED 1 -#define XED_ICLASS_RDMSR_DEFINED 1 -#define XED_ICLASS_RDPID_DEFINED 1 -#define XED_ICLASS_RDPKRU_DEFINED 1 -#define XED_ICLASS_RDPMC_DEFINED 1 -#define XED_ICLASS_RDPRU_DEFINED 1 -#define XED_ICLASS_RDRAND_DEFINED 1 -#define XED_ICLASS_RDSEED_DEFINED 1 -#define XED_ICLASS_RDSSPD_DEFINED 1 -#define XED_ICLASS_RDSSPQ_DEFINED 1 -#define XED_ICLASS_RDTSC_DEFINED 1 -#define XED_ICLASS_RDTSCP_DEFINED 1 -#define XED_ICLASS_REPE_CMPSB_DEFINED 1 -#define XED_ICLASS_REPE_CMPSD_DEFINED 1 -#define XED_ICLASS_REPE_CMPSQ_DEFINED 1 -#define XED_ICLASS_REPE_CMPSW_DEFINED 1 -#define XED_ICLASS_REPE_SCASB_DEFINED 1 -#define XED_ICLASS_REPE_SCASD_DEFINED 1 -#define XED_ICLASS_REPE_SCASQ_DEFINED 1 -#define XED_ICLASS_REPE_SCASW_DEFINED 1 -#define XED_ICLASS_REPNE_CMPSB_DEFINED 1 -#define XED_ICLASS_REPNE_CMPSD_DEFINED 1 -#define XED_ICLASS_REPNE_CMPSQ_DEFINED 1 -#define XED_ICLASS_REPNE_CMPSW_DEFINED 1 -#define XED_ICLASS_REPNE_SCASB_DEFINED 1 -#define XED_ICLASS_REPNE_SCASD_DEFINED 1 -#define XED_ICLASS_REPNE_SCASQ_DEFINED 1 -#define XED_ICLASS_REPNE_SCASW_DEFINED 1 -#define XED_ICLASS_REP_INSB_DEFINED 1 -#define XED_ICLASS_REP_INSD_DEFINED 1 -#define XED_ICLASS_REP_INSW_DEFINED 1 -#define XED_ICLASS_REP_LODSB_DEFINED 1 -#define XED_ICLASS_REP_LODSD_DEFINED 1 -#define XED_ICLASS_REP_LODSQ_DEFINED 1 -#define XED_ICLASS_REP_LODSW_DEFINED 1 -#define XED_ICLASS_REP_MONTMUL_DEFINED 1 -#define XED_ICLASS_REP_MOVSB_DEFINED 1 -#define XED_ICLASS_REP_MOVSD_DEFINED 1 -#define XED_ICLASS_REP_MOVSQ_DEFINED 1 -#define XED_ICLASS_REP_MOVSW_DEFINED 1 -#define XED_ICLASS_REP_OUTSB_DEFINED 1 -#define XED_ICLASS_REP_OUTSD_DEFINED 1 -#define XED_ICLASS_REP_OUTSW_DEFINED 1 -#define XED_ICLASS_REP_STOSB_DEFINED 1 -#define XED_ICLASS_REP_STOSD_DEFINED 1 -#define XED_ICLASS_REP_STOSQ_DEFINED 1 -#define XED_ICLASS_REP_STOSW_DEFINED 1 -#define XED_ICLASS_REP_XCRYPTCBC_DEFINED 1 -#define XED_ICLASS_REP_XCRYPTCFB_DEFINED 1 -#define XED_ICLASS_REP_XCRYPTCTR_DEFINED 1 -#define XED_ICLASS_REP_XCRYPTECB_DEFINED 1 -#define XED_ICLASS_REP_XCRYPTOFB_DEFINED 1 -#define XED_ICLASS_REP_XSHA1_DEFINED 1 -#define XED_ICLASS_REP_XSHA256_DEFINED 1 -#define XED_ICLASS_REP_XSTORE_DEFINED 1 -#define XED_ICLASS_RET_FAR_DEFINED 1 -#define XED_ICLASS_RET_NEAR_DEFINED 1 -#define XED_ICLASS_RMPADJUST_DEFINED 1 -#define XED_ICLASS_RMPUPDATE_DEFINED 1 -#define XED_ICLASS_ROL_DEFINED 1 -#define XED_ICLASS_ROR_DEFINED 1 -#define XED_ICLASS_RORX_DEFINED 1 -#define XED_ICLASS_ROUNDPD_DEFINED 1 -#define XED_ICLASS_ROUNDPS_DEFINED 1 -#define XED_ICLASS_ROUNDSD_DEFINED 1 -#define XED_ICLASS_ROUNDSS_DEFINED 1 -#define XED_ICLASS_RSM_DEFINED 1 -#define XED_ICLASS_RSQRTPS_DEFINED 1 -#define XED_ICLASS_RSQRTSS_DEFINED 1 -#define XED_ICLASS_RSTORSSP_DEFINED 1 -#define XED_ICLASS_SAHF_DEFINED 1 -#define XED_ICLASS_SALC_DEFINED 1 -#define XED_ICLASS_SAR_DEFINED 1 -#define XED_ICLASS_SARX_DEFINED 1 -#define XED_ICLASS_SAVEPREVSSP_DEFINED 1 -#define XED_ICLASS_SBB_DEFINED 1 -#define XED_ICLASS_SBB_LOCK_DEFINED 1 -#define XED_ICLASS_SCASB_DEFINED 1 -#define XED_ICLASS_SCASD_DEFINED 1 -#define XED_ICLASS_SCASQ_DEFINED 1 -#define XED_ICLASS_SCASW_DEFINED 1 -#define XED_ICLASS_SEAMCALL_DEFINED 1 -#define XED_ICLASS_SEAMOPS_DEFINED 1 -#define XED_ICLASS_SEAMRET_DEFINED 1 -#define XED_ICLASS_SENDUIPI_DEFINED 1 -#define XED_ICLASS_SERIALIZE_DEFINED 1 -#define XED_ICLASS_SETB_DEFINED 1 -#define XED_ICLASS_SETBE_DEFINED 1 -#define XED_ICLASS_SETL_DEFINED 1 -#define XED_ICLASS_SETLE_DEFINED 1 -#define XED_ICLASS_SETNB_DEFINED 1 -#define XED_ICLASS_SETNBE_DEFINED 1 -#define XED_ICLASS_SETNL_DEFINED 1 -#define XED_ICLASS_SETNLE_DEFINED 1 -#define XED_ICLASS_SETNO_DEFINED 1 -#define XED_ICLASS_SETNP_DEFINED 1 -#define XED_ICLASS_SETNS_DEFINED 1 -#define XED_ICLASS_SETNZ_DEFINED 1 -#define XED_ICLASS_SETO_DEFINED 1 -#define XED_ICLASS_SETP_DEFINED 1 -#define XED_ICLASS_SETS_DEFINED 1 -#define XED_ICLASS_SETSSBSY_DEFINED 1 -#define XED_ICLASS_SETZ_DEFINED 1 -#define XED_ICLASS_SFENCE_DEFINED 1 -#define XED_ICLASS_SGDT_DEFINED 1 -#define XED_ICLASS_SHA1MSG1_DEFINED 1 -#define XED_ICLASS_SHA1MSG2_DEFINED 1 -#define XED_ICLASS_SHA1NEXTE_DEFINED 1 -#define XED_ICLASS_SHA1RNDS4_DEFINED 1 -#define XED_ICLASS_SHA256MSG1_DEFINED 1 -#define XED_ICLASS_SHA256MSG2_DEFINED 1 -#define XED_ICLASS_SHA256RNDS2_DEFINED 1 -#define XED_ICLASS_SHL_DEFINED 1 -#define XED_ICLASS_SHLD_DEFINED 1 -#define XED_ICLASS_SHLX_DEFINED 1 -#define XED_ICLASS_SHR_DEFINED 1 -#define XED_ICLASS_SHRD_DEFINED 1 -#define XED_ICLASS_SHRX_DEFINED 1 -#define XED_ICLASS_SHUFPD_DEFINED 1 -#define XED_ICLASS_SHUFPS_DEFINED 1 -#define XED_ICLASS_SIDT_DEFINED 1 -#define XED_ICLASS_SKINIT_DEFINED 1 -#define XED_ICLASS_SLDT_DEFINED 1 -#define XED_ICLASS_SLWPCB_DEFINED 1 -#define XED_ICLASS_SMSW_DEFINED 1 -#define XED_ICLASS_SQRTPD_DEFINED 1 -#define XED_ICLASS_SQRTPS_DEFINED 1 -#define XED_ICLASS_SQRTSD_DEFINED 1 -#define XED_ICLASS_SQRTSS_DEFINED 1 -#define XED_ICLASS_STAC_DEFINED 1 -#define XED_ICLASS_STC_DEFINED 1 -#define XED_ICLASS_STD_DEFINED 1 -#define XED_ICLASS_STGI_DEFINED 1 -#define XED_ICLASS_STI_DEFINED 1 -#define XED_ICLASS_STMXCSR_DEFINED 1 -#define XED_ICLASS_STOSB_DEFINED 1 -#define XED_ICLASS_STOSD_DEFINED 1 -#define XED_ICLASS_STOSQ_DEFINED 1 -#define XED_ICLASS_STOSW_DEFINED 1 -#define XED_ICLASS_STR_DEFINED 1 -#define XED_ICLASS_STTILECFG_DEFINED 1 -#define XED_ICLASS_STUI_DEFINED 1 -#define XED_ICLASS_SUB_DEFINED 1 -#define XED_ICLASS_SUBPD_DEFINED 1 -#define XED_ICLASS_SUBPS_DEFINED 1 -#define XED_ICLASS_SUBSD_DEFINED 1 -#define XED_ICLASS_SUBSS_DEFINED 1 -#define XED_ICLASS_SUB_LOCK_DEFINED 1 -#define XED_ICLASS_SWAPGS_DEFINED 1 -#define XED_ICLASS_SYSCALL_DEFINED 1 -#define XED_ICLASS_SYSCALL_AMD_DEFINED 1 -#define XED_ICLASS_SYSENTER_DEFINED 1 -#define XED_ICLASS_SYSEXIT_DEFINED 1 -#define XED_ICLASS_SYSRET_DEFINED 1 -#define XED_ICLASS_SYSRET64_DEFINED 1 -#define XED_ICLASS_SYSRET_AMD_DEFINED 1 -#define XED_ICLASS_T1MSKC_DEFINED 1 -#define XED_ICLASS_TDCALL_DEFINED 1 -#define XED_ICLASS_TDPBF16PS_DEFINED 1 -#define XED_ICLASS_TDPBSSD_DEFINED 1 -#define XED_ICLASS_TDPBSUD_DEFINED 1 -#define XED_ICLASS_TDPBUSD_DEFINED 1 -#define XED_ICLASS_TDPBUUD_DEFINED 1 -#define XED_ICLASS_TEST_DEFINED 1 -#define XED_ICLASS_TESTUI_DEFINED 1 -#define XED_ICLASS_TILELOADD_DEFINED 1 -#define XED_ICLASS_TILELOADDT1_DEFINED 1 -#define XED_ICLASS_TILERELEASE_DEFINED 1 -#define XED_ICLASS_TILESTORED_DEFINED 1 -#define XED_ICLASS_TILEZERO_DEFINED 1 -#define XED_ICLASS_TLBSYNC_DEFINED 1 -#define XED_ICLASS_TPAUSE_DEFINED 1 -#define XED_ICLASS_TZCNT_DEFINED 1 -#define XED_ICLASS_TZMSK_DEFINED 1 -#define XED_ICLASS_UCOMISD_DEFINED 1 -#define XED_ICLASS_UCOMISS_DEFINED 1 -#define XED_ICLASS_UD0_DEFINED 1 -#define XED_ICLASS_UD1_DEFINED 1 -#define XED_ICLASS_UD2_DEFINED 1 -#define XED_ICLASS_UIRET_DEFINED 1 -#define XED_ICLASS_UMONITOR_DEFINED 1 -#define XED_ICLASS_UMWAIT_DEFINED 1 -#define XED_ICLASS_UNPCKHPD_DEFINED 1 -#define XED_ICLASS_UNPCKHPS_DEFINED 1 -#define XED_ICLASS_UNPCKLPD_DEFINED 1 -#define XED_ICLASS_UNPCKLPS_DEFINED 1 -#define XED_ICLASS_V4FMADDPS_DEFINED 1 -#define XED_ICLASS_V4FMADDSS_DEFINED 1 -#define XED_ICLASS_V4FNMADDPS_DEFINED 1 -#define XED_ICLASS_V4FNMADDSS_DEFINED 1 -#define XED_ICLASS_VADDPD_DEFINED 1 -#define XED_ICLASS_VADDPH_DEFINED 1 -#define XED_ICLASS_VADDPS_DEFINED 1 -#define XED_ICLASS_VADDSD_DEFINED 1 -#define XED_ICLASS_VADDSH_DEFINED 1 -#define XED_ICLASS_VADDSS_DEFINED 1 -#define XED_ICLASS_VADDSUBPD_DEFINED 1 -#define XED_ICLASS_VADDSUBPS_DEFINED 1 -#define XED_ICLASS_VAESDEC_DEFINED 1 -#define XED_ICLASS_VAESDECLAST_DEFINED 1 -#define XED_ICLASS_VAESENC_DEFINED 1 -#define XED_ICLASS_VAESENCLAST_DEFINED 1 -#define XED_ICLASS_VAESIMC_DEFINED 1 -#define XED_ICLASS_VAESKEYGENASSIST_DEFINED 1 -#define XED_ICLASS_VALIGND_DEFINED 1 -#define XED_ICLASS_VALIGNQ_DEFINED 1 -#define XED_ICLASS_VANDNPD_DEFINED 1 -#define XED_ICLASS_VANDNPS_DEFINED 1 -#define XED_ICLASS_VANDPD_DEFINED 1 -#define XED_ICLASS_VANDPS_DEFINED 1 -#define XED_ICLASS_VBLENDMPD_DEFINED 1 -#define XED_ICLASS_VBLENDMPS_DEFINED 1 -#define XED_ICLASS_VBLENDPD_DEFINED 1 -#define XED_ICLASS_VBLENDPS_DEFINED 1 -#define XED_ICLASS_VBLENDVPD_DEFINED 1 -#define XED_ICLASS_VBLENDVPS_DEFINED 1 -#define XED_ICLASS_VBROADCASTF128_DEFINED 1 -#define XED_ICLASS_VBROADCASTF32X2_DEFINED 1 -#define XED_ICLASS_VBROADCASTF32X4_DEFINED 1 -#define XED_ICLASS_VBROADCASTF32X8_DEFINED 1 -#define XED_ICLASS_VBROADCASTF64X2_DEFINED 1 -#define XED_ICLASS_VBROADCASTF64X4_DEFINED 1 -#define XED_ICLASS_VBROADCASTI128_DEFINED 1 -#define XED_ICLASS_VBROADCASTI32X2_DEFINED 1 -#define XED_ICLASS_VBROADCASTI32X4_DEFINED 1 -#define XED_ICLASS_VBROADCASTI32X8_DEFINED 1 -#define XED_ICLASS_VBROADCASTI64X2_DEFINED 1 -#define XED_ICLASS_VBROADCASTI64X4_DEFINED 1 -#define XED_ICLASS_VBROADCASTSD_DEFINED 1 -#define XED_ICLASS_VBROADCASTSS_DEFINED 1 -#define XED_ICLASS_VCMPPD_DEFINED 1 -#define XED_ICLASS_VCMPPH_DEFINED 1 -#define XED_ICLASS_VCMPPS_DEFINED 1 -#define XED_ICLASS_VCMPSD_DEFINED 1 -#define XED_ICLASS_VCMPSH_DEFINED 1 -#define XED_ICLASS_VCMPSS_DEFINED 1 -#define XED_ICLASS_VCOMISD_DEFINED 1 -#define XED_ICLASS_VCOMISH_DEFINED 1 -#define XED_ICLASS_VCOMISS_DEFINED 1 -#define XED_ICLASS_VCOMPRESSPD_DEFINED 1 -#define XED_ICLASS_VCOMPRESSPS_DEFINED 1 -#define XED_ICLASS_VCVTDQ2PD_DEFINED 1 -#define XED_ICLASS_VCVTDQ2PH_DEFINED 1 -#define XED_ICLASS_VCVTDQ2PS_DEFINED 1 -#define XED_ICLASS_VCVTNE2PS2BF16_DEFINED 1 -#define XED_ICLASS_VCVTNEPS2BF16_DEFINED 1 -#define XED_ICLASS_VCVTPD2DQ_DEFINED 1 -#define XED_ICLASS_VCVTPD2PH_DEFINED 1 -#define XED_ICLASS_VCVTPD2PS_DEFINED 1 -#define XED_ICLASS_VCVTPD2QQ_DEFINED 1 -#define XED_ICLASS_VCVTPD2UDQ_DEFINED 1 -#define XED_ICLASS_VCVTPD2UQQ_DEFINED 1 -#define XED_ICLASS_VCVTPH2DQ_DEFINED 1 -#define XED_ICLASS_VCVTPH2PD_DEFINED 1 -#define XED_ICLASS_VCVTPH2PS_DEFINED 1 -#define XED_ICLASS_VCVTPH2PSX_DEFINED 1 -#define XED_ICLASS_VCVTPH2QQ_DEFINED 1 -#define XED_ICLASS_VCVTPH2UDQ_DEFINED 1 -#define XED_ICLASS_VCVTPH2UQQ_DEFINED 1 -#define XED_ICLASS_VCVTPH2UW_DEFINED 1 -#define XED_ICLASS_VCVTPH2W_DEFINED 1 -#define XED_ICLASS_VCVTPS2DQ_DEFINED 1 -#define XED_ICLASS_VCVTPS2PD_DEFINED 1 -#define XED_ICLASS_VCVTPS2PH_DEFINED 1 -#define XED_ICLASS_VCVTPS2PHX_DEFINED 1 -#define XED_ICLASS_VCVTPS2QQ_DEFINED 1 -#define XED_ICLASS_VCVTPS2UDQ_DEFINED 1 -#define XED_ICLASS_VCVTPS2UQQ_DEFINED 1 -#define XED_ICLASS_VCVTQQ2PD_DEFINED 1 -#define XED_ICLASS_VCVTQQ2PH_DEFINED 1 -#define XED_ICLASS_VCVTQQ2PS_DEFINED 1 -#define XED_ICLASS_VCVTSD2SH_DEFINED 1 -#define XED_ICLASS_VCVTSD2SI_DEFINED 1 -#define XED_ICLASS_VCVTSD2SS_DEFINED 1 -#define XED_ICLASS_VCVTSD2USI_DEFINED 1 -#define XED_ICLASS_VCVTSH2SD_DEFINED 1 -#define XED_ICLASS_VCVTSH2SI_DEFINED 1 -#define XED_ICLASS_VCVTSH2SS_DEFINED 1 -#define XED_ICLASS_VCVTSH2USI_DEFINED 1 -#define XED_ICLASS_VCVTSI2SD_DEFINED 1 -#define XED_ICLASS_VCVTSI2SH_DEFINED 1 -#define XED_ICLASS_VCVTSI2SS_DEFINED 1 -#define XED_ICLASS_VCVTSS2SD_DEFINED 1 -#define XED_ICLASS_VCVTSS2SH_DEFINED 1 -#define XED_ICLASS_VCVTSS2SI_DEFINED 1 -#define XED_ICLASS_VCVTSS2USI_DEFINED 1 -#define XED_ICLASS_VCVTTPD2DQ_DEFINED 1 -#define XED_ICLASS_VCVTTPD2QQ_DEFINED 1 -#define XED_ICLASS_VCVTTPD2UDQ_DEFINED 1 -#define XED_ICLASS_VCVTTPD2UQQ_DEFINED 1 -#define XED_ICLASS_VCVTTPH2DQ_DEFINED 1 -#define XED_ICLASS_VCVTTPH2QQ_DEFINED 1 -#define XED_ICLASS_VCVTTPH2UDQ_DEFINED 1 -#define XED_ICLASS_VCVTTPH2UQQ_DEFINED 1 -#define XED_ICLASS_VCVTTPH2UW_DEFINED 1 -#define XED_ICLASS_VCVTTPH2W_DEFINED 1 -#define XED_ICLASS_VCVTTPS2DQ_DEFINED 1 -#define XED_ICLASS_VCVTTPS2QQ_DEFINED 1 -#define XED_ICLASS_VCVTTPS2UDQ_DEFINED 1 -#define XED_ICLASS_VCVTTPS2UQQ_DEFINED 1 -#define XED_ICLASS_VCVTTSD2SI_DEFINED 1 -#define XED_ICLASS_VCVTTSD2USI_DEFINED 1 -#define XED_ICLASS_VCVTTSH2SI_DEFINED 1 -#define XED_ICLASS_VCVTTSH2USI_DEFINED 1 -#define XED_ICLASS_VCVTTSS2SI_DEFINED 1 -#define XED_ICLASS_VCVTTSS2USI_DEFINED 1 -#define XED_ICLASS_VCVTUDQ2PD_DEFINED 1 -#define XED_ICLASS_VCVTUDQ2PH_DEFINED 1 -#define XED_ICLASS_VCVTUDQ2PS_DEFINED 1 -#define XED_ICLASS_VCVTUQQ2PD_DEFINED 1 -#define XED_ICLASS_VCVTUQQ2PH_DEFINED 1 -#define XED_ICLASS_VCVTUQQ2PS_DEFINED 1 -#define XED_ICLASS_VCVTUSI2SD_DEFINED 1 -#define XED_ICLASS_VCVTUSI2SH_DEFINED 1 -#define XED_ICLASS_VCVTUSI2SS_DEFINED 1 -#define XED_ICLASS_VCVTUW2PH_DEFINED 1 -#define XED_ICLASS_VCVTW2PH_DEFINED 1 -#define XED_ICLASS_VDBPSADBW_DEFINED 1 -#define XED_ICLASS_VDIVPD_DEFINED 1 -#define XED_ICLASS_VDIVPH_DEFINED 1 -#define XED_ICLASS_VDIVPS_DEFINED 1 -#define XED_ICLASS_VDIVSD_DEFINED 1 -#define XED_ICLASS_VDIVSH_DEFINED 1 -#define XED_ICLASS_VDIVSS_DEFINED 1 -#define XED_ICLASS_VDPBF16PS_DEFINED 1 -#define XED_ICLASS_VDPPD_DEFINED 1 -#define XED_ICLASS_VDPPS_DEFINED 1 -#define XED_ICLASS_VERR_DEFINED 1 -#define XED_ICLASS_VERW_DEFINED 1 -#define XED_ICLASS_VEXP2PD_DEFINED 1 -#define XED_ICLASS_VEXP2PS_DEFINED 1 -#define XED_ICLASS_VEXPANDPD_DEFINED 1 -#define XED_ICLASS_VEXPANDPS_DEFINED 1 -#define XED_ICLASS_VEXTRACTF128_DEFINED 1 -#define XED_ICLASS_VEXTRACTF32X4_DEFINED 1 -#define XED_ICLASS_VEXTRACTF32X8_DEFINED 1 -#define XED_ICLASS_VEXTRACTF64X2_DEFINED 1 -#define XED_ICLASS_VEXTRACTF64X4_DEFINED 1 -#define XED_ICLASS_VEXTRACTI128_DEFINED 1 -#define XED_ICLASS_VEXTRACTI32X4_DEFINED 1 -#define XED_ICLASS_VEXTRACTI32X8_DEFINED 1 -#define XED_ICLASS_VEXTRACTI64X2_DEFINED 1 -#define XED_ICLASS_VEXTRACTI64X4_DEFINED 1 -#define XED_ICLASS_VEXTRACTPS_DEFINED 1 -#define XED_ICLASS_VFCMADDCPH_DEFINED 1 -#define XED_ICLASS_VFCMADDCSH_DEFINED 1 -#define XED_ICLASS_VFCMULCPH_DEFINED 1 -#define XED_ICLASS_VFCMULCSH_DEFINED 1 -#define XED_ICLASS_VFIXUPIMMPD_DEFINED 1 -#define XED_ICLASS_VFIXUPIMMPS_DEFINED 1 -#define XED_ICLASS_VFIXUPIMMSD_DEFINED 1 -#define XED_ICLASS_VFIXUPIMMSS_DEFINED 1 -#define XED_ICLASS_VFMADD132PD_DEFINED 1 -#define XED_ICLASS_VFMADD132PH_DEFINED 1 -#define XED_ICLASS_VFMADD132PS_DEFINED 1 -#define XED_ICLASS_VFMADD132SD_DEFINED 1 -#define XED_ICLASS_VFMADD132SH_DEFINED 1 -#define XED_ICLASS_VFMADD132SS_DEFINED 1 -#define XED_ICLASS_VFMADD213PD_DEFINED 1 -#define XED_ICLASS_VFMADD213PH_DEFINED 1 -#define XED_ICLASS_VFMADD213PS_DEFINED 1 -#define XED_ICLASS_VFMADD213SD_DEFINED 1 -#define XED_ICLASS_VFMADD213SH_DEFINED 1 -#define XED_ICLASS_VFMADD213SS_DEFINED 1 -#define XED_ICLASS_VFMADD231PD_DEFINED 1 -#define XED_ICLASS_VFMADD231PH_DEFINED 1 -#define XED_ICLASS_VFMADD231PS_DEFINED 1 -#define XED_ICLASS_VFMADD231SD_DEFINED 1 -#define XED_ICLASS_VFMADD231SH_DEFINED 1 -#define XED_ICLASS_VFMADD231SS_DEFINED 1 -#define XED_ICLASS_VFMADDCPH_DEFINED 1 -#define XED_ICLASS_VFMADDCSH_DEFINED 1 -#define XED_ICLASS_VFMADDPD_DEFINED 1 -#define XED_ICLASS_VFMADDPS_DEFINED 1 -#define XED_ICLASS_VFMADDSD_DEFINED 1 -#define XED_ICLASS_VFMADDSS_DEFINED 1 -#define XED_ICLASS_VFMADDSUB132PD_DEFINED 1 -#define XED_ICLASS_VFMADDSUB132PH_DEFINED 1 -#define XED_ICLASS_VFMADDSUB132PS_DEFINED 1 -#define XED_ICLASS_VFMADDSUB213PD_DEFINED 1 -#define XED_ICLASS_VFMADDSUB213PH_DEFINED 1 -#define XED_ICLASS_VFMADDSUB213PS_DEFINED 1 -#define XED_ICLASS_VFMADDSUB231PD_DEFINED 1 -#define XED_ICLASS_VFMADDSUB231PH_DEFINED 1 -#define XED_ICLASS_VFMADDSUB231PS_DEFINED 1 -#define XED_ICLASS_VFMADDSUBPD_DEFINED 1 -#define XED_ICLASS_VFMADDSUBPS_DEFINED 1 -#define XED_ICLASS_VFMSUB132PD_DEFINED 1 -#define XED_ICLASS_VFMSUB132PH_DEFINED 1 -#define XED_ICLASS_VFMSUB132PS_DEFINED 1 -#define XED_ICLASS_VFMSUB132SD_DEFINED 1 -#define XED_ICLASS_VFMSUB132SH_DEFINED 1 -#define XED_ICLASS_VFMSUB132SS_DEFINED 1 -#define XED_ICLASS_VFMSUB213PD_DEFINED 1 -#define XED_ICLASS_VFMSUB213PH_DEFINED 1 -#define XED_ICLASS_VFMSUB213PS_DEFINED 1 -#define XED_ICLASS_VFMSUB213SD_DEFINED 1 -#define XED_ICLASS_VFMSUB213SH_DEFINED 1 -#define XED_ICLASS_VFMSUB213SS_DEFINED 1 -#define XED_ICLASS_VFMSUB231PD_DEFINED 1 -#define XED_ICLASS_VFMSUB231PH_DEFINED 1 -#define XED_ICLASS_VFMSUB231PS_DEFINED 1 -#define XED_ICLASS_VFMSUB231SD_DEFINED 1 -#define XED_ICLASS_VFMSUB231SH_DEFINED 1 -#define XED_ICLASS_VFMSUB231SS_DEFINED 1 -#define XED_ICLASS_VFMSUBADD132PD_DEFINED 1 -#define XED_ICLASS_VFMSUBADD132PH_DEFINED 1 -#define XED_ICLASS_VFMSUBADD132PS_DEFINED 1 -#define XED_ICLASS_VFMSUBADD213PD_DEFINED 1 -#define XED_ICLASS_VFMSUBADD213PH_DEFINED 1 -#define XED_ICLASS_VFMSUBADD213PS_DEFINED 1 -#define XED_ICLASS_VFMSUBADD231PD_DEFINED 1 -#define XED_ICLASS_VFMSUBADD231PH_DEFINED 1 -#define XED_ICLASS_VFMSUBADD231PS_DEFINED 1 -#define XED_ICLASS_VFMSUBADDPD_DEFINED 1 -#define XED_ICLASS_VFMSUBADDPS_DEFINED 1 -#define XED_ICLASS_VFMSUBPD_DEFINED 1 -#define XED_ICLASS_VFMSUBPS_DEFINED 1 -#define XED_ICLASS_VFMSUBSD_DEFINED 1 -#define XED_ICLASS_VFMSUBSS_DEFINED 1 -#define XED_ICLASS_VFMULCPH_DEFINED 1 -#define XED_ICLASS_VFMULCSH_DEFINED 1 -#define XED_ICLASS_VFNMADD132PD_DEFINED 1 -#define XED_ICLASS_VFNMADD132PH_DEFINED 1 -#define XED_ICLASS_VFNMADD132PS_DEFINED 1 -#define XED_ICLASS_VFNMADD132SD_DEFINED 1 -#define XED_ICLASS_VFNMADD132SH_DEFINED 1 -#define XED_ICLASS_VFNMADD132SS_DEFINED 1 -#define XED_ICLASS_VFNMADD213PD_DEFINED 1 -#define XED_ICLASS_VFNMADD213PH_DEFINED 1 -#define XED_ICLASS_VFNMADD213PS_DEFINED 1 -#define XED_ICLASS_VFNMADD213SD_DEFINED 1 -#define XED_ICLASS_VFNMADD213SH_DEFINED 1 -#define XED_ICLASS_VFNMADD213SS_DEFINED 1 -#define XED_ICLASS_VFNMADD231PD_DEFINED 1 -#define XED_ICLASS_VFNMADD231PH_DEFINED 1 -#define XED_ICLASS_VFNMADD231PS_DEFINED 1 -#define XED_ICLASS_VFNMADD231SD_DEFINED 1 -#define XED_ICLASS_VFNMADD231SH_DEFINED 1 -#define XED_ICLASS_VFNMADD231SS_DEFINED 1 -#define XED_ICLASS_VFNMADDPD_DEFINED 1 -#define XED_ICLASS_VFNMADDPS_DEFINED 1 -#define XED_ICLASS_VFNMADDSD_DEFINED 1 -#define XED_ICLASS_VFNMADDSS_DEFINED 1 -#define XED_ICLASS_VFNMSUB132PD_DEFINED 1 -#define XED_ICLASS_VFNMSUB132PH_DEFINED 1 -#define XED_ICLASS_VFNMSUB132PS_DEFINED 1 -#define XED_ICLASS_VFNMSUB132SD_DEFINED 1 -#define XED_ICLASS_VFNMSUB132SH_DEFINED 1 -#define XED_ICLASS_VFNMSUB132SS_DEFINED 1 -#define XED_ICLASS_VFNMSUB213PD_DEFINED 1 -#define XED_ICLASS_VFNMSUB213PH_DEFINED 1 -#define XED_ICLASS_VFNMSUB213PS_DEFINED 1 -#define XED_ICLASS_VFNMSUB213SD_DEFINED 1 -#define XED_ICLASS_VFNMSUB213SH_DEFINED 1 -#define XED_ICLASS_VFNMSUB213SS_DEFINED 1 -#define XED_ICLASS_VFNMSUB231PD_DEFINED 1 -#define XED_ICLASS_VFNMSUB231PH_DEFINED 1 -#define XED_ICLASS_VFNMSUB231PS_DEFINED 1 -#define XED_ICLASS_VFNMSUB231SD_DEFINED 1 -#define XED_ICLASS_VFNMSUB231SH_DEFINED 1 -#define XED_ICLASS_VFNMSUB231SS_DEFINED 1 -#define XED_ICLASS_VFNMSUBPD_DEFINED 1 -#define XED_ICLASS_VFNMSUBPS_DEFINED 1 -#define XED_ICLASS_VFNMSUBSD_DEFINED 1 -#define XED_ICLASS_VFNMSUBSS_DEFINED 1 -#define XED_ICLASS_VFPCLASSPD_DEFINED 1 -#define XED_ICLASS_VFPCLASSPH_DEFINED 1 -#define XED_ICLASS_VFPCLASSPS_DEFINED 1 -#define XED_ICLASS_VFPCLASSSD_DEFINED 1 -#define XED_ICLASS_VFPCLASSSH_DEFINED 1 -#define XED_ICLASS_VFPCLASSSS_DEFINED 1 -#define XED_ICLASS_VFRCZPD_DEFINED 1 -#define XED_ICLASS_VFRCZPS_DEFINED 1 -#define XED_ICLASS_VFRCZSD_DEFINED 1 -#define XED_ICLASS_VFRCZSS_DEFINED 1 -#define XED_ICLASS_VGATHERDPD_DEFINED 1 -#define XED_ICLASS_VGATHERDPS_DEFINED 1 -#define XED_ICLASS_VGATHERPF0DPD_DEFINED 1 -#define XED_ICLASS_VGATHERPF0DPS_DEFINED 1 -#define XED_ICLASS_VGATHERPF0QPD_DEFINED 1 -#define XED_ICLASS_VGATHERPF0QPS_DEFINED 1 -#define XED_ICLASS_VGATHERPF1DPD_DEFINED 1 -#define XED_ICLASS_VGATHERPF1DPS_DEFINED 1 -#define XED_ICLASS_VGATHERPF1QPD_DEFINED 1 -#define XED_ICLASS_VGATHERPF1QPS_DEFINED 1 -#define XED_ICLASS_VGATHERQPD_DEFINED 1 -#define XED_ICLASS_VGATHERQPS_DEFINED 1 -#define XED_ICLASS_VGETEXPPD_DEFINED 1 -#define XED_ICLASS_VGETEXPPH_DEFINED 1 -#define XED_ICLASS_VGETEXPPS_DEFINED 1 -#define XED_ICLASS_VGETEXPSD_DEFINED 1 -#define XED_ICLASS_VGETEXPSH_DEFINED 1 -#define XED_ICLASS_VGETEXPSS_DEFINED 1 -#define XED_ICLASS_VGETMANTPD_DEFINED 1 -#define XED_ICLASS_VGETMANTPH_DEFINED 1 -#define XED_ICLASS_VGETMANTPS_DEFINED 1 -#define XED_ICLASS_VGETMANTSD_DEFINED 1 -#define XED_ICLASS_VGETMANTSH_DEFINED 1 -#define XED_ICLASS_VGETMANTSS_DEFINED 1 -#define XED_ICLASS_VGF2P8AFFINEINVQB_DEFINED 1 -#define XED_ICLASS_VGF2P8AFFINEQB_DEFINED 1 -#define XED_ICLASS_VGF2P8MULB_DEFINED 1 -#define XED_ICLASS_VHADDPD_DEFINED 1 -#define XED_ICLASS_VHADDPS_DEFINED 1 -#define XED_ICLASS_VHSUBPD_DEFINED 1 -#define XED_ICLASS_VHSUBPS_DEFINED 1 -#define XED_ICLASS_VINSERTF128_DEFINED 1 -#define XED_ICLASS_VINSERTF32X4_DEFINED 1 -#define XED_ICLASS_VINSERTF32X8_DEFINED 1 -#define XED_ICLASS_VINSERTF64X2_DEFINED 1 -#define XED_ICLASS_VINSERTF64X4_DEFINED 1 -#define XED_ICLASS_VINSERTI128_DEFINED 1 -#define XED_ICLASS_VINSERTI32X4_DEFINED 1 -#define XED_ICLASS_VINSERTI32X8_DEFINED 1 -#define XED_ICLASS_VINSERTI64X2_DEFINED 1 -#define XED_ICLASS_VINSERTI64X4_DEFINED 1 -#define XED_ICLASS_VINSERTPS_DEFINED 1 -#define XED_ICLASS_VLDDQU_DEFINED 1 -#define XED_ICLASS_VLDMXCSR_DEFINED 1 -#define XED_ICLASS_VMASKMOVDQU_DEFINED 1 -#define XED_ICLASS_VMASKMOVPD_DEFINED 1 -#define XED_ICLASS_VMASKMOVPS_DEFINED 1 -#define XED_ICLASS_VMAXPD_DEFINED 1 -#define XED_ICLASS_VMAXPH_DEFINED 1 -#define XED_ICLASS_VMAXPS_DEFINED 1 -#define XED_ICLASS_VMAXSD_DEFINED 1 -#define XED_ICLASS_VMAXSH_DEFINED 1 -#define XED_ICLASS_VMAXSS_DEFINED 1 -#define XED_ICLASS_VMCALL_DEFINED 1 -#define XED_ICLASS_VMCLEAR_DEFINED 1 -#define XED_ICLASS_VMFUNC_DEFINED 1 -#define XED_ICLASS_VMINPD_DEFINED 1 -#define XED_ICLASS_VMINPH_DEFINED 1 -#define XED_ICLASS_VMINPS_DEFINED 1 -#define XED_ICLASS_VMINSD_DEFINED 1 -#define XED_ICLASS_VMINSH_DEFINED 1 -#define XED_ICLASS_VMINSS_DEFINED 1 -#define XED_ICLASS_VMLAUNCH_DEFINED 1 -#define XED_ICLASS_VMLOAD_DEFINED 1 -#define XED_ICLASS_VMMCALL_DEFINED 1 -#define XED_ICLASS_VMOVAPD_DEFINED 1 -#define XED_ICLASS_VMOVAPS_DEFINED 1 -#define XED_ICLASS_VMOVD_DEFINED 1 -#define XED_ICLASS_VMOVDDUP_DEFINED 1 -#define XED_ICLASS_VMOVDQA_DEFINED 1 -#define XED_ICLASS_VMOVDQA32_DEFINED 1 -#define XED_ICLASS_VMOVDQA64_DEFINED 1 -#define XED_ICLASS_VMOVDQU_DEFINED 1 -#define XED_ICLASS_VMOVDQU16_DEFINED 1 -#define XED_ICLASS_VMOVDQU32_DEFINED 1 -#define XED_ICLASS_VMOVDQU64_DEFINED 1 -#define XED_ICLASS_VMOVDQU8_DEFINED 1 -#define XED_ICLASS_VMOVHLPS_DEFINED 1 -#define XED_ICLASS_VMOVHPD_DEFINED 1 -#define XED_ICLASS_VMOVHPS_DEFINED 1 -#define XED_ICLASS_VMOVLHPS_DEFINED 1 -#define XED_ICLASS_VMOVLPD_DEFINED 1 -#define XED_ICLASS_VMOVLPS_DEFINED 1 -#define XED_ICLASS_VMOVMSKPD_DEFINED 1 -#define XED_ICLASS_VMOVMSKPS_DEFINED 1 -#define XED_ICLASS_VMOVNTDQ_DEFINED 1 -#define XED_ICLASS_VMOVNTDQA_DEFINED 1 -#define XED_ICLASS_VMOVNTPD_DEFINED 1 -#define XED_ICLASS_VMOVNTPS_DEFINED 1 -#define XED_ICLASS_VMOVQ_DEFINED 1 -#define XED_ICLASS_VMOVSD_DEFINED 1 -#define XED_ICLASS_VMOVSH_DEFINED 1 -#define XED_ICLASS_VMOVSHDUP_DEFINED 1 -#define XED_ICLASS_VMOVSLDUP_DEFINED 1 -#define XED_ICLASS_VMOVSS_DEFINED 1 -#define XED_ICLASS_VMOVUPD_DEFINED 1 -#define XED_ICLASS_VMOVUPS_DEFINED 1 -#define XED_ICLASS_VMOVW_DEFINED 1 -#define XED_ICLASS_VMPSADBW_DEFINED 1 -#define XED_ICLASS_VMPTRLD_DEFINED 1 -#define XED_ICLASS_VMPTRST_DEFINED 1 -#define XED_ICLASS_VMREAD_DEFINED 1 -#define XED_ICLASS_VMRESUME_DEFINED 1 -#define XED_ICLASS_VMRUN_DEFINED 1 -#define XED_ICLASS_VMSAVE_DEFINED 1 -#define XED_ICLASS_VMULPD_DEFINED 1 -#define XED_ICLASS_VMULPH_DEFINED 1 -#define XED_ICLASS_VMULPS_DEFINED 1 -#define XED_ICLASS_VMULSD_DEFINED 1 -#define XED_ICLASS_VMULSH_DEFINED 1 -#define XED_ICLASS_VMULSS_DEFINED 1 -#define XED_ICLASS_VMWRITE_DEFINED 1 -#define XED_ICLASS_VMXOFF_DEFINED 1 -#define XED_ICLASS_VMXON_DEFINED 1 -#define XED_ICLASS_VORPD_DEFINED 1 -#define XED_ICLASS_VORPS_DEFINED 1 -#define XED_ICLASS_VP2INTERSECTD_DEFINED 1 -#define XED_ICLASS_VP2INTERSECTQ_DEFINED 1 -#define XED_ICLASS_VP4DPWSSD_DEFINED 1 -#define XED_ICLASS_VP4DPWSSDS_DEFINED 1 -#define XED_ICLASS_VPABSB_DEFINED 1 -#define XED_ICLASS_VPABSD_DEFINED 1 -#define XED_ICLASS_VPABSQ_DEFINED 1 -#define XED_ICLASS_VPABSW_DEFINED 1 -#define XED_ICLASS_VPACKSSDW_DEFINED 1 -#define XED_ICLASS_VPACKSSWB_DEFINED 1 -#define XED_ICLASS_VPACKUSDW_DEFINED 1 -#define XED_ICLASS_VPACKUSWB_DEFINED 1 -#define XED_ICLASS_VPADDB_DEFINED 1 -#define XED_ICLASS_VPADDD_DEFINED 1 -#define XED_ICLASS_VPADDQ_DEFINED 1 -#define XED_ICLASS_VPADDSB_DEFINED 1 -#define XED_ICLASS_VPADDSW_DEFINED 1 -#define XED_ICLASS_VPADDUSB_DEFINED 1 -#define XED_ICLASS_VPADDUSW_DEFINED 1 -#define XED_ICLASS_VPADDW_DEFINED 1 -#define XED_ICLASS_VPALIGNR_DEFINED 1 -#define XED_ICLASS_VPAND_DEFINED 1 -#define XED_ICLASS_VPANDD_DEFINED 1 -#define XED_ICLASS_VPANDN_DEFINED 1 -#define XED_ICLASS_VPANDND_DEFINED 1 -#define XED_ICLASS_VPANDNQ_DEFINED 1 -#define XED_ICLASS_VPANDQ_DEFINED 1 -#define XED_ICLASS_VPAVGB_DEFINED 1 -#define XED_ICLASS_VPAVGW_DEFINED 1 -#define XED_ICLASS_VPBLENDD_DEFINED 1 -#define XED_ICLASS_VPBLENDMB_DEFINED 1 -#define XED_ICLASS_VPBLENDMD_DEFINED 1 -#define XED_ICLASS_VPBLENDMQ_DEFINED 1 -#define XED_ICLASS_VPBLENDMW_DEFINED 1 -#define XED_ICLASS_VPBLENDVB_DEFINED 1 -#define XED_ICLASS_VPBLENDW_DEFINED 1 -#define XED_ICLASS_VPBROADCASTB_DEFINED 1 -#define XED_ICLASS_VPBROADCASTD_DEFINED 1 -#define XED_ICLASS_VPBROADCASTMB2Q_DEFINED 1 -#define XED_ICLASS_VPBROADCASTMW2D_DEFINED 1 -#define XED_ICLASS_VPBROADCASTQ_DEFINED 1 -#define XED_ICLASS_VPBROADCASTW_DEFINED 1 -#define XED_ICLASS_VPCLMULQDQ_DEFINED 1 -#define XED_ICLASS_VPCMOV_DEFINED 1 -#define XED_ICLASS_VPCMPB_DEFINED 1 -#define XED_ICLASS_VPCMPD_DEFINED 1 -#define XED_ICLASS_VPCMPEQB_DEFINED 1 -#define XED_ICLASS_VPCMPEQD_DEFINED 1 -#define XED_ICLASS_VPCMPEQQ_DEFINED 1 -#define XED_ICLASS_VPCMPEQW_DEFINED 1 -#define XED_ICLASS_VPCMPESTRI_DEFINED 1 -#define XED_ICLASS_VPCMPESTRI64_DEFINED 1 -#define XED_ICLASS_VPCMPESTRM_DEFINED 1 -#define XED_ICLASS_VPCMPESTRM64_DEFINED 1 -#define XED_ICLASS_VPCMPGTB_DEFINED 1 -#define XED_ICLASS_VPCMPGTD_DEFINED 1 -#define XED_ICLASS_VPCMPGTQ_DEFINED 1 -#define XED_ICLASS_VPCMPGTW_DEFINED 1 -#define XED_ICLASS_VPCMPISTRI_DEFINED 1 -#define XED_ICLASS_VPCMPISTRI64_DEFINED 1 -#define XED_ICLASS_VPCMPISTRM_DEFINED 1 -#define XED_ICLASS_VPCMPQ_DEFINED 1 -#define XED_ICLASS_VPCMPUB_DEFINED 1 -#define XED_ICLASS_VPCMPUD_DEFINED 1 -#define XED_ICLASS_VPCMPUQ_DEFINED 1 -#define XED_ICLASS_VPCMPUW_DEFINED 1 -#define XED_ICLASS_VPCMPW_DEFINED 1 -#define XED_ICLASS_VPCOMB_DEFINED 1 -#define XED_ICLASS_VPCOMD_DEFINED 1 -#define XED_ICLASS_VPCOMPRESSB_DEFINED 1 -#define XED_ICLASS_VPCOMPRESSD_DEFINED 1 -#define XED_ICLASS_VPCOMPRESSQ_DEFINED 1 -#define XED_ICLASS_VPCOMPRESSW_DEFINED 1 -#define XED_ICLASS_VPCOMQ_DEFINED 1 -#define XED_ICLASS_VPCOMUB_DEFINED 1 -#define XED_ICLASS_VPCOMUD_DEFINED 1 -#define XED_ICLASS_VPCOMUQ_DEFINED 1 -#define XED_ICLASS_VPCOMUW_DEFINED 1 -#define XED_ICLASS_VPCOMW_DEFINED 1 -#define XED_ICLASS_VPCONFLICTD_DEFINED 1 -#define XED_ICLASS_VPCONFLICTQ_DEFINED 1 -#define XED_ICLASS_VPDPBUSD_DEFINED 1 -#define XED_ICLASS_VPDPBUSDS_DEFINED 1 -#define XED_ICLASS_VPDPWSSD_DEFINED 1 -#define XED_ICLASS_VPDPWSSDS_DEFINED 1 -#define XED_ICLASS_VPERM2F128_DEFINED 1 -#define XED_ICLASS_VPERM2I128_DEFINED 1 -#define XED_ICLASS_VPERMB_DEFINED 1 -#define XED_ICLASS_VPERMD_DEFINED 1 -#define XED_ICLASS_VPERMI2B_DEFINED 1 -#define XED_ICLASS_VPERMI2D_DEFINED 1 -#define XED_ICLASS_VPERMI2PD_DEFINED 1 -#define XED_ICLASS_VPERMI2PS_DEFINED 1 -#define XED_ICLASS_VPERMI2Q_DEFINED 1 -#define XED_ICLASS_VPERMI2W_DEFINED 1 -#define XED_ICLASS_VPERMIL2PD_DEFINED 1 -#define XED_ICLASS_VPERMIL2PS_DEFINED 1 -#define XED_ICLASS_VPERMILPD_DEFINED 1 -#define XED_ICLASS_VPERMILPS_DEFINED 1 -#define XED_ICLASS_VPERMPD_DEFINED 1 -#define XED_ICLASS_VPERMPS_DEFINED 1 -#define XED_ICLASS_VPERMQ_DEFINED 1 -#define XED_ICLASS_VPERMT2B_DEFINED 1 -#define XED_ICLASS_VPERMT2D_DEFINED 1 -#define XED_ICLASS_VPERMT2PD_DEFINED 1 -#define XED_ICLASS_VPERMT2PS_DEFINED 1 -#define XED_ICLASS_VPERMT2Q_DEFINED 1 -#define XED_ICLASS_VPERMT2W_DEFINED 1 -#define XED_ICLASS_VPERMW_DEFINED 1 -#define XED_ICLASS_VPEXPANDB_DEFINED 1 -#define XED_ICLASS_VPEXPANDD_DEFINED 1 -#define XED_ICLASS_VPEXPANDQ_DEFINED 1 -#define XED_ICLASS_VPEXPANDW_DEFINED 1 -#define XED_ICLASS_VPEXTRB_DEFINED 1 -#define XED_ICLASS_VPEXTRD_DEFINED 1 -#define XED_ICLASS_VPEXTRQ_DEFINED 1 -#define XED_ICLASS_VPEXTRW_DEFINED 1 -#define XED_ICLASS_VPEXTRW_C5_DEFINED 1 -#define XED_ICLASS_VPGATHERDD_DEFINED 1 -#define XED_ICLASS_VPGATHERDQ_DEFINED 1 -#define XED_ICLASS_VPGATHERQD_DEFINED 1 -#define XED_ICLASS_VPGATHERQQ_DEFINED 1 -#define XED_ICLASS_VPHADDBD_DEFINED 1 -#define XED_ICLASS_VPHADDBQ_DEFINED 1 -#define XED_ICLASS_VPHADDBW_DEFINED 1 -#define XED_ICLASS_VPHADDD_DEFINED 1 -#define XED_ICLASS_VPHADDDQ_DEFINED 1 -#define XED_ICLASS_VPHADDSW_DEFINED 1 -#define XED_ICLASS_VPHADDUBD_DEFINED 1 -#define XED_ICLASS_VPHADDUBQ_DEFINED 1 -#define XED_ICLASS_VPHADDUBW_DEFINED 1 -#define XED_ICLASS_VPHADDUDQ_DEFINED 1 -#define XED_ICLASS_VPHADDUWD_DEFINED 1 -#define XED_ICLASS_VPHADDUWQ_DEFINED 1 -#define XED_ICLASS_VPHADDW_DEFINED 1 -#define XED_ICLASS_VPHADDWD_DEFINED 1 -#define XED_ICLASS_VPHADDWQ_DEFINED 1 -#define XED_ICLASS_VPHMINPOSUW_DEFINED 1 -#define XED_ICLASS_VPHSUBBW_DEFINED 1 -#define XED_ICLASS_VPHSUBD_DEFINED 1 -#define XED_ICLASS_VPHSUBDQ_DEFINED 1 -#define XED_ICLASS_VPHSUBSW_DEFINED 1 -#define XED_ICLASS_VPHSUBW_DEFINED 1 -#define XED_ICLASS_VPHSUBWD_DEFINED 1 -#define XED_ICLASS_VPINSRB_DEFINED 1 -#define XED_ICLASS_VPINSRD_DEFINED 1 -#define XED_ICLASS_VPINSRQ_DEFINED 1 -#define XED_ICLASS_VPINSRW_DEFINED 1 -#define XED_ICLASS_VPLZCNTD_DEFINED 1 -#define XED_ICLASS_VPLZCNTQ_DEFINED 1 -#define XED_ICLASS_VPMACSDD_DEFINED 1 -#define XED_ICLASS_VPMACSDQH_DEFINED 1 -#define XED_ICLASS_VPMACSDQL_DEFINED 1 -#define XED_ICLASS_VPMACSSDD_DEFINED 1 -#define XED_ICLASS_VPMACSSDQH_DEFINED 1 -#define XED_ICLASS_VPMACSSDQL_DEFINED 1 -#define XED_ICLASS_VPMACSSWD_DEFINED 1 -#define XED_ICLASS_VPMACSSWW_DEFINED 1 -#define XED_ICLASS_VPMACSWD_DEFINED 1 -#define XED_ICLASS_VPMACSWW_DEFINED 1 -#define XED_ICLASS_VPMADCSSWD_DEFINED 1 -#define XED_ICLASS_VPMADCSWD_DEFINED 1 -#define XED_ICLASS_VPMADD52HUQ_DEFINED 1 -#define XED_ICLASS_VPMADD52LUQ_DEFINED 1 -#define XED_ICLASS_VPMADDUBSW_DEFINED 1 -#define XED_ICLASS_VPMADDWD_DEFINED 1 -#define XED_ICLASS_VPMASKMOVD_DEFINED 1 -#define XED_ICLASS_VPMASKMOVQ_DEFINED 1 -#define XED_ICLASS_VPMAXSB_DEFINED 1 -#define XED_ICLASS_VPMAXSD_DEFINED 1 -#define XED_ICLASS_VPMAXSQ_DEFINED 1 -#define XED_ICLASS_VPMAXSW_DEFINED 1 -#define XED_ICLASS_VPMAXUB_DEFINED 1 -#define XED_ICLASS_VPMAXUD_DEFINED 1 -#define XED_ICLASS_VPMAXUQ_DEFINED 1 -#define XED_ICLASS_VPMAXUW_DEFINED 1 -#define XED_ICLASS_VPMINSB_DEFINED 1 -#define XED_ICLASS_VPMINSD_DEFINED 1 -#define XED_ICLASS_VPMINSQ_DEFINED 1 -#define XED_ICLASS_VPMINSW_DEFINED 1 -#define XED_ICLASS_VPMINUB_DEFINED 1 -#define XED_ICLASS_VPMINUD_DEFINED 1 -#define XED_ICLASS_VPMINUQ_DEFINED 1 -#define XED_ICLASS_VPMINUW_DEFINED 1 -#define XED_ICLASS_VPMOVB2M_DEFINED 1 -#define XED_ICLASS_VPMOVD2M_DEFINED 1 -#define XED_ICLASS_VPMOVDB_DEFINED 1 -#define XED_ICLASS_VPMOVDW_DEFINED 1 -#define XED_ICLASS_VPMOVM2B_DEFINED 1 -#define XED_ICLASS_VPMOVM2D_DEFINED 1 -#define XED_ICLASS_VPMOVM2Q_DEFINED 1 -#define XED_ICLASS_VPMOVM2W_DEFINED 1 -#define XED_ICLASS_VPMOVMSKB_DEFINED 1 -#define XED_ICLASS_VPMOVQ2M_DEFINED 1 -#define XED_ICLASS_VPMOVQB_DEFINED 1 -#define XED_ICLASS_VPMOVQD_DEFINED 1 -#define XED_ICLASS_VPMOVQW_DEFINED 1 -#define XED_ICLASS_VPMOVSDB_DEFINED 1 -#define XED_ICLASS_VPMOVSDW_DEFINED 1 -#define XED_ICLASS_VPMOVSQB_DEFINED 1 -#define XED_ICLASS_VPMOVSQD_DEFINED 1 -#define XED_ICLASS_VPMOVSQW_DEFINED 1 -#define XED_ICLASS_VPMOVSWB_DEFINED 1 -#define XED_ICLASS_VPMOVSXBD_DEFINED 1 -#define XED_ICLASS_VPMOVSXBQ_DEFINED 1 -#define XED_ICLASS_VPMOVSXBW_DEFINED 1 -#define XED_ICLASS_VPMOVSXDQ_DEFINED 1 -#define XED_ICLASS_VPMOVSXWD_DEFINED 1 -#define XED_ICLASS_VPMOVSXWQ_DEFINED 1 -#define XED_ICLASS_VPMOVUSDB_DEFINED 1 -#define XED_ICLASS_VPMOVUSDW_DEFINED 1 -#define XED_ICLASS_VPMOVUSQB_DEFINED 1 -#define XED_ICLASS_VPMOVUSQD_DEFINED 1 -#define XED_ICLASS_VPMOVUSQW_DEFINED 1 -#define XED_ICLASS_VPMOVUSWB_DEFINED 1 -#define XED_ICLASS_VPMOVW2M_DEFINED 1 -#define XED_ICLASS_VPMOVWB_DEFINED 1 -#define XED_ICLASS_VPMOVZXBD_DEFINED 1 -#define XED_ICLASS_VPMOVZXBQ_DEFINED 1 -#define XED_ICLASS_VPMOVZXBW_DEFINED 1 -#define XED_ICLASS_VPMOVZXDQ_DEFINED 1 -#define XED_ICLASS_VPMOVZXWD_DEFINED 1 -#define XED_ICLASS_VPMOVZXWQ_DEFINED 1 -#define XED_ICLASS_VPMULDQ_DEFINED 1 -#define XED_ICLASS_VPMULHRSW_DEFINED 1 -#define XED_ICLASS_VPMULHUW_DEFINED 1 -#define XED_ICLASS_VPMULHW_DEFINED 1 -#define XED_ICLASS_VPMULLD_DEFINED 1 -#define XED_ICLASS_VPMULLQ_DEFINED 1 -#define XED_ICLASS_VPMULLW_DEFINED 1 -#define XED_ICLASS_VPMULTISHIFTQB_DEFINED 1 -#define XED_ICLASS_VPMULUDQ_DEFINED 1 -#define XED_ICLASS_VPOPCNTB_DEFINED 1 -#define XED_ICLASS_VPOPCNTD_DEFINED 1 -#define XED_ICLASS_VPOPCNTQ_DEFINED 1 -#define XED_ICLASS_VPOPCNTW_DEFINED 1 -#define XED_ICLASS_VPOR_DEFINED 1 -#define XED_ICLASS_VPORD_DEFINED 1 -#define XED_ICLASS_VPORQ_DEFINED 1 -#define XED_ICLASS_VPPERM_DEFINED 1 -#define XED_ICLASS_VPROLD_DEFINED 1 -#define XED_ICLASS_VPROLQ_DEFINED 1 -#define XED_ICLASS_VPROLVD_DEFINED 1 -#define XED_ICLASS_VPROLVQ_DEFINED 1 -#define XED_ICLASS_VPRORD_DEFINED 1 -#define XED_ICLASS_VPRORQ_DEFINED 1 -#define XED_ICLASS_VPRORVD_DEFINED 1 -#define XED_ICLASS_VPRORVQ_DEFINED 1 -#define XED_ICLASS_VPROTB_DEFINED 1 -#define XED_ICLASS_VPROTD_DEFINED 1 -#define XED_ICLASS_VPROTQ_DEFINED 1 -#define XED_ICLASS_VPROTW_DEFINED 1 -#define XED_ICLASS_VPSADBW_DEFINED 1 -#define XED_ICLASS_VPSCATTERDD_DEFINED 1 -#define XED_ICLASS_VPSCATTERDQ_DEFINED 1 -#define XED_ICLASS_VPSCATTERQD_DEFINED 1 -#define XED_ICLASS_VPSCATTERQQ_DEFINED 1 -#define XED_ICLASS_VPSHAB_DEFINED 1 -#define XED_ICLASS_VPSHAD_DEFINED 1 -#define XED_ICLASS_VPSHAQ_DEFINED 1 -#define XED_ICLASS_VPSHAW_DEFINED 1 -#define XED_ICLASS_VPSHLB_DEFINED 1 -#define XED_ICLASS_VPSHLD_DEFINED 1 -#define XED_ICLASS_VPSHLDD_DEFINED 1 -#define XED_ICLASS_VPSHLDQ_DEFINED 1 -#define XED_ICLASS_VPSHLDVD_DEFINED 1 -#define XED_ICLASS_VPSHLDVQ_DEFINED 1 -#define XED_ICLASS_VPSHLDVW_DEFINED 1 -#define XED_ICLASS_VPSHLDW_DEFINED 1 -#define XED_ICLASS_VPSHLQ_DEFINED 1 -#define XED_ICLASS_VPSHLW_DEFINED 1 -#define XED_ICLASS_VPSHRDD_DEFINED 1 -#define XED_ICLASS_VPSHRDQ_DEFINED 1 -#define XED_ICLASS_VPSHRDVD_DEFINED 1 -#define XED_ICLASS_VPSHRDVQ_DEFINED 1 -#define XED_ICLASS_VPSHRDVW_DEFINED 1 -#define XED_ICLASS_VPSHRDW_DEFINED 1 -#define XED_ICLASS_VPSHUFB_DEFINED 1 -#define XED_ICLASS_VPSHUFBITQMB_DEFINED 1 -#define XED_ICLASS_VPSHUFD_DEFINED 1 -#define XED_ICLASS_VPSHUFHW_DEFINED 1 -#define XED_ICLASS_VPSHUFLW_DEFINED 1 -#define XED_ICLASS_VPSIGNB_DEFINED 1 -#define XED_ICLASS_VPSIGND_DEFINED 1 -#define XED_ICLASS_VPSIGNW_DEFINED 1 -#define XED_ICLASS_VPSLLD_DEFINED 1 -#define XED_ICLASS_VPSLLDQ_DEFINED 1 -#define XED_ICLASS_VPSLLQ_DEFINED 1 -#define XED_ICLASS_VPSLLVD_DEFINED 1 -#define XED_ICLASS_VPSLLVQ_DEFINED 1 -#define XED_ICLASS_VPSLLVW_DEFINED 1 -#define XED_ICLASS_VPSLLW_DEFINED 1 -#define XED_ICLASS_VPSRAD_DEFINED 1 -#define XED_ICLASS_VPSRAQ_DEFINED 1 -#define XED_ICLASS_VPSRAVD_DEFINED 1 -#define XED_ICLASS_VPSRAVQ_DEFINED 1 -#define XED_ICLASS_VPSRAVW_DEFINED 1 -#define XED_ICLASS_VPSRAW_DEFINED 1 -#define XED_ICLASS_VPSRLD_DEFINED 1 -#define XED_ICLASS_VPSRLDQ_DEFINED 1 -#define XED_ICLASS_VPSRLQ_DEFINED 1 -#define XED_ICLASS_VPSRLVD_DEFINED 1 -#define XED_ICLASS_VPSRLVQ_DEFINED 1 -#define XED_ICLASS_VPSRLVW_DEFINED 1 -#define XED_ICLASS_VPSRLW_DEFINED 1 -#define XED_ICLASS_VPSUBB_DEFINED 1 -#define XED_ICLASS_VPSUBD_DEFINED 1 -#define XED_ICLASS_VPSUBQ_DEFINED 1 -#define XED_ICLASS_VPSUBSB_DEFINED 1 -#define XED_ICLASS_VPSUBSW_DEFINED 1 -#define XED_ICLASS_VPSUBUSB_DEFINED 1 -#define XED_ICLASS_VPSUBUSW_DEFINED 1 -#define XED_ICLASS_VPSUBW_DEFINED 1 -#define XED_ICLASS_VPTERNLOGD_DEFINED 1 -#define XED_ICLASS_VPTERNLOGQ_DEFINED 1 -#define XED_ICLASS_VPTEST_DEFINED 1 -#define XED_ICLASS_VPTESTMB_DEFINED 1 -#define XED_ICLASS_VPTESTMD_DEFINED 1 -#define XED_ICLASS_VPTESTMQ_DEFINED 1 -#define XED_ICLASS_VPTESTMW_DEFINED 1 -#define XED_ICLASS_VPTESTNMB_DEFINED 1 -#define XED_ICLASS_VPTESTNMD_DEFINED 1 -#define XED_ICLASS_VPTESTNMQ_DEFINED 1 -#define XED_ICLASS_VPTESTNMW_DEFINED 1 -#define XED_ICLASS_VPUNPCKHBW_DEFINED 1 -#define XED_ICLASS_VPUNPCKHDQ_DEFINED 1 -#define XED_ICLASS_VPUNPCKHQDQ_DEFINED 1 -#define XED_ICLASS_VPUNPCKHWD_DEFINED 1 -#define XED_ICLASS_VPUNPCKLBW_DEFINED 1 -#define XED_ICLASS_VPUNPCKLDQ_DEFINED 1 -#define XED_ICLASS_VPUNPCKLQDQ_DEFINED 1 -#define XED_ICLASS_VPUNPCKLWD_DEFINED 1 -#define XED_ICLASS_VPXOR_DEFINED 1 -#define XED_ICLASS_VPXORD_DEFINED 1 -#define XED_ICLASS_VPXORQ_DEFINED 1 -#define XED_ICLASS_VRANGEPD_DEFINED 1 -#define XED_ICLASS_VRANGEPS_DEFINED 1 -#define XED_ICLASS_VRANGESD_DEFINED 1 -#define XED_ICLASS_VRANGESS_DEFINED 1 -#define XED_ICLASS_VRCP14PD_DEFINED 1 -#define XED_ICLASS_VRCP14PS_DEFINED 1 -#define XED_ICLASS_VRCP14SD_DEFINED 1 -#define XED_ICLASS_VRCP14SS_DEFINED 1 -#define XED_ICLASS_VRCP28PD_DEFINED 1 -#define XED_ICLASS_VRCP28PS_DEFINED 1 -#define XED_ICLASS_VRCP28SD_DEFINED 1 -#define XED_ICLASS_VRCP28SS_DEFINED 1 -#define XED_ICLASS_VRCPPH_DEFINED 1 -#define XED_ICLASS_VRCPPS_DEFINED 1 -#define XED_ICLASS_VRCPSH_DEFINED 1 -#define XED_ICLASS_VRCPSS_DEFINED 1 -#define XED_ICLASS_VREDUCEPD_DEFINED 1 -#define XED_ICLASS_VREDUCEPH_DEFINED 1 -#define XED_ICLASS_VREDUCEPS_DEFINED 1 -#define XED_ICLASS_VREDUCESD_DEFINED 1 -#define XED_ICLASS_VREDUCESH_DEFINED 1 -#define XED_ICLASS_VREDUCESS_DEFINED 1 -#define XED_ICLASS_VRNDSCALEPD_DEFINED 1 -#define XED_ICLASS_VRNDSCALEPH_DEFINED 1 -#define XED_ICLASS_VRNDSCALEPS_DEFINED 1 -#define XED_ICLASS_VRNDSCALESD_DEFINED 1 -#define XED_ICLASS_VRNDSCALESH_DEFINED 1 -#define XED_ICLASS_VRNDSCALESS_DEFINED 1 -#define XED_ICLASS_VROUNDPD_DEFINED 1 -#define XED_ICLASS_VROUNDPS_DEFINED 1 -#define XED_ICLASS_VROUNDSD_DEFINED 1 -#define XED_ICLASS_VROUNDSS_DEFINED 1 -#define XED_ICLASS_VRSQRT14PD_DEFINED 1 -#define XED_ICLASS_VRSQRT14PS_DEFINED 1 -#define XED_ICLASS_VRSQRT14SD_DEFINED 1 -#define XED_ICLASS_VRSQRT14SS_DEFINED 1 -#define XED_ICLASS_VRSQRT28PD_DEFINED 1 -#define XED_ICLASS_VRSQRT28PS_DEFINED 1 -#define XED_ICLASS_VRSQRT28SD_DEFINED 1 -#define XED_ICLASS_VRSQRT28SS_DEFINED 1 -#define XED_ICLASS_VRSQRTPH_DEFINED 1 -#define XED_ICLASS_VRSQRTPS_DEFINED 1 -#define XED_ICLASS_VRSQRTSH_DEFINED 1 -#define XED_ICLASS_VRSQRTSS_DEFINED 1 -#define XED_ICLASS_VSCALEFPD_DEFINED 1 -#define XED_ICLASS_VSCALEFPH_DEFINED 1 -#define XED_ICLASS_VSCALEFPS_DEFINED 1 -#define XED_ICLASS_VSCALEFSD_DEFINED 1 -#define XED_ICLASS_VSCALEFSH_DEFINED 1 -#define XED_ICLASS_VSCALEFSS_DEFINED 1 -#define XED_ICLASS_VSCATTERDPD_DEFINED 1 -#define XED_ICLASS_VSCATTERDPS_DEFINED 1 -#define XED_ICLASS_VSCATTERPF0DPD_DEFINED 1 -#define XED_ICLASS_VSCATTERPF0DPS_DEFINED 1 -#define XED_ICLASS_VSCATTERPF0QPD_DEFINED 1 -#define XED_ICLASS_VSCATTERPF0QPS_DEFINED 1 -#define XED_ICLASS_VSCATTERPF1DPD_DEFINED 1 -#define XED_ICLASS_VSCATTERPF1DPS_DEFINED 1 -#define XED_ICLASS_VSCATTERPF1QPD_DEFINED 1 -#define XED_ICLASS_VSCATTERPF1QPS_DEFINED 1 -#define XED_ICLASS_VSCATTERQPD_DEFINED 1 -#define XED_ICLASS_VSCATTERQPS_DEFINED 1 -#define XED_ICLASS_VSHUFF32X4_DEFINED 1 -#define XED_ICLASS_VSHUFF64X2_DEFINED 1 -#define XED_ICLASS_VSHUFI32X4_DEFINED 1 -#define XED_ICLASS_VSHUFI64X2_DEFINED 1 -#define XED_ICLASS_VSHUFPD_DEFINED 1 -#define XED_ICLASS_VSHUFPS_DEFINED 1 -#define XED_ICLASS_VSQRTPD_DEFINED 1 -#define XED_ICLASS_VSQRTPH_DEFINED 1 -#define XED_ICLASS_VSQRTPS_DEFINED 1 -#define XED_ICLASS_VSQRTSD_DEFINED 1 -#define XED_ICLASS_VSQRTSH_DEFINED 1 -#define XED_ICLASS_VSQRTSS_DEFINED 1 -#define XED_ICLASS_VSTMXCSR_DEFINED 1 -#define XED_ICLASS_VSUBPD_DEFINED 1 -#define XED_ICLASS_VSUBPH_DEFINED 1 -#define XED_ICLASS_VSUBPS_DEFINED 1 -#define XED_ICLASS_VSUBSD_DEFINED 1 -#define XED_ICLASS_VSUBSH_DEFINED 1 -#define XED_ICLASS_VSUBSS_DEFINED 1 -#define XED_ICLASS_VTESTPD_DEFINED 1 -#define XED_ICLASS_VTESTPS_DEFINED 1 -#define XED_ICLASS_VUCOMISD_DEFINED 1 -#define XED_ICLASS_VUCOMISH_DEFINED 1 -#define XED_ICLASS_VUCOMISS_DEFINED 1 -#define XED_ICLASS_VUNPCKHPD_DEFINED 1 -#define XED_ICLASS_VUNPCKHPS_DEFINED 1 -#define XED_ICLASS_VUNPCKLPD_DEFINED 1 -#define XED_ICLASS_VUNPCKLPS_DEFINED 1 -#define XED_ICLASS_VXORPD_DEFINED 1 -#define XED_ICLASS_VXORPS_DEFINED 1 -#define XED_ICLASS_VZEROALL_DEFINED 1 -#define XED_ICLASS_VZEROUPPER_DEFINED 1 -#define XED_ICLASS_WBINVD_DEFINED 1 -#define XED_ICLASS_WBNOINVD_DEFINED 1 -#define XED_ICLASS_WRFSBASE_DEFINED 1 -#define XED_ICLASS_WRGSBASE_DEFINED 1 -#define XED_ICLASS_WRMSR_DEFINED 1 -#define XED_ICLASS_WRPKRU_DEFINED 1 -#define XED_ICLASS_WRSSD_DEFINED 1 -#define XED_ICLASS_WRSSQ_DEFINED 1 -#define XED_ICLASS_WRUSSD_DEFINED 1 -#define XED_ICLASS_WRUSSQ_DEFINED 1 -#define XED_ICLASS_XABORT_DEFINED 1 -#define XED_ICLASS_XADD_DEFINED 1 -#define XED_ICLASS_XADD_LOCK_DEFINED 1 -#define XED_ICLASS_XBEGIN_DEFINED 1 -#define XED_ICLASS_XCHG_DEFINED 1 -#define XED_ICLASS_XEND_DEFINED 1 -#define XED_ICLASS_XGETBV_DEFINED 1 -#define XED_ICLASS_XLAT_DEFINED 1 -#define XED_ICLASS_XOR_DEFINED 1 -#define XED_ICLASS_XORPD_DEFINED 1 -#define XED_ICLASS_XORPS_DEFINED 1 -#define XED_ICLASS_XOR_LOCK_DEFINED 1 -#define XED_ICLASS_XRESLDTRK_DEFINED 1 -#define XED_ICLASS_XRSTOR_DEFINED 1 -#define XED_ICLASS_XRSTOR64_DEFINED 1 -#define XED_ICLASS_XRSTORS_DEFINED 1 -#define XED_ICLASS_XRSTORS64_DEFINED 1 -#define XED_ICLASS_XSAVE_DEFINED 1 -#define XED_ICLASS_XSAVE64_DEFINED 1 -#define XED_ICLASS_XSAVEC_DEFINED 1 -#define XED_ICLASS_XSAVEC64_DEFINED 1 -#define XED_ICLASS_XSAVEOPT_DEFINED 1 -#define XED_ICLASS_XSAVEOPT64_DEFINED 1 -#define XED_ICLASS_XSAVES_DEFINED 1 -#define XED_ICLASS_XSAVES64_DEFINED 1 -#define XED_ICLASS_XSETBV_DEFINED 1 -#define XED_ICLASS_XSTORE_DEFINED 1 -#define XED_ICLASS_XSUSLDTRK_DEFINED 1 -#define XED_ICLASS_XTEST_DEFINED 1 -#define XED_ICLASS_LAST_DEFINED 1 -typedef enum { - XED_ICLASS_INVALID, - XED_ICLASS_AAA, - XED_ICLASS_AAD, - XED_ICLASS_AAM, - XED_ICLASS_AAS, - XED_ICLASS_ADC, - XED_ICLASS_ADCX, - XED_ICLASS_ADC_LOCK, - XED_ICLASS_ADD, - XED_ICLASS_ADDPD, - XED_ICLASS_ADDPS, - XED_ICLASS_ADDSD, - XED_ICLASS_ADDSS, - XED_ICLASS_ADDSUBPD, - XED_ICLASS_ADDSUBPS, - XED_ICLASS_ADD_LOCK, - XED_ICLASS_ADOX, - XED_ICLASS_AESDEC, - XED_ICLASS_AESDEC128KL, - XED_ICLASS_AESDEC256KL, - XED_ICLASS_AESDECLAST, - XED_ICLASS_AESDECWIDE128KL, - XED_ICLASS_AESDECWIDE256KL, - XED_ICLASS_AESENC, - XED_ICLASS_AESENC128KL, - XED_ICLASS_AESENC256KL, - XED_ICLASS_AESENCLAST, - XED_ICLASS_AESENCWIDE128KL, - XED_ICLASS_AESENCWIDE256KL, - XED_ICLASS_AESIMC, - XED_ICLASS_AESKEYGENASSIST, - XED_ICLASS_AND, - XED_ICLASS_ANDN, - XED_ICLASS_ANDNPD, - XED_ICLASS_ANDNPS, - XED_ICLASS_ANDPD, - XED_ICLASS_ANDPS, - XED_ICLASS_AND_LOCK, - XED_ICLASS_ARPL, - XED_ICLASS_BEXTR, - XED_ICLASS_BEXTR_XOP, - XED_ICLASS_BLCFILL, - XED_ICLASS_BLCI, - XED_ICLASS_BLCIC, - XED_ICLASS_BLCMSK, - XED_ICLASS_BLCS, - XED_ICLASS_BLENDPD, - XED_ICLASS_BLENDPS, - XED_ICLASS_BLENDVPD, - XED_ICLASS_BLENDVPS, - XED_ICLASS_BLSFILL, - XED_ICLASS_BLSI, - XED_ICLASS_BLSIC, - XED_ICLASS_BLSMSK, - XED_ICLASS_BLSR, - XED_ICLASS_BNDCL, - XED_ICLASS_BNDCN, - XED_ICLASS_BNDCU, - XED_ICLASS_BNDLDX, - XED_ICLASS_BNDMK, - XED_ICLASS_BNDMOV, - XED_ICLASS_BNDSTX, - XED_ICLASS_BOUND, - XED_ICLASS_BSF, - XED_ICLASS_BSR, - XED_ICLASS_BSWAP, - XED_ICLASS_BT, - XED_ICLASS_BTC, - XED_ICLASS_BTC_LOCK, - XED_ICLASS_BTR, - XED_ICLASS_BTR_LOCK, - XED_ICLASS_BTS, - XED_ICLASS_BTS_LOCK, - XED_ICLASS_BZHI, - XED_ICLASS_CALL_FAR, - XED_ICLASS_CALL_NEAR, - XED_ICLASS_CBW, - XED_ICLASS_CDQ, - XED_ICLASS_CDQE, - XED_ICLASS_CLAC, - XED_ICLASS_CLC, - XED_ICLASS_CLD, - XED_ICLASS_CLDEMOTE, - XED_ICLASS_CLFLUSH, - XED_ICLASS_CLFLUSHOPT, - XED_ICLASS_CLGI, - XED_ICLASS_CLI, - XED_ICLASS_CLRSSBSY, - XED_ICLASS_CLTS, - XED_ICLASS_CLUI, - XED_ICLASS_CLWB, - XED_ICLASS_CLZERO, - XED_ICLASS_CMC, - XED_ICLASS_CMOVB, - XED_ICLASS_CMOVBE, - XED_ICLASS_CMOVL, - XED_ICLASS_CMOVLE, - XED_ICLASS_CMOVNB, - XED_ICLASS_CMOVNBE, - XED_ICLASS_CMOVNL, - XED_ICLASS_CMOVNLE, - XED_ICLASS_CMOVNO, - XED_ICLASS_CMOVNP, - XED_ICLASS_CMOVNS, - XED_ICLASS_CMOVNZ, - XED_ICLASS_CMOVO, - XED_ICLASS_CMOVP, - XED_ICLASS_CMOVS, - XED_ICLASS_CMOVZ, - XED_ICLASS_CMP, - XED_ICLASS_CMPPD, - XED_ICLASS_CMPPS, - XED_ICLASS_CMPSB, - XED_ICLASS_CMPSD, - XED_ICLASS_CMPSD_XMM, - XED_ICLASS_CMPSQ, - XED_ICLASS_CMPSS, - XED_ICLASS_CMPSW, - XED_ICLASS_CMPXCHG, - XED_ICLASS_CMPXCHG16B, - XED_ICLASS_CMPXCHG16B_LOCK, - XED_ICLASS_CMPXCHG8B, - XED_ICLASS_CMPXCHG8B_LOCK, - XED_ICLASS_CMPXCHG_LOCK, - XED_ICLASS_COMISD, - XED_ICLASS_COMISS, - XED_ICLASS_CPUID, - XED_ICLASS_CQO, - XED_ICLASS_CRC32, - XED_ICLASS_CVTDQ2PD, - XED_ICLASS_CVTDQ2PS, - XED_ICLASS_CVTPD2DQ, - XED_ICLASS_CVTPD2PI, - XED_ICLASS_CVTPD2PS, - XED_ICLASS_CVTPI2PD, - XED_ICLASS_CVTPI2PS, - XED_ICLASS_CVTPS2DQ, - XED_ICLASS_CVTPS2PD, - XED_ICLASS_CVTPS2PI, - XED_ICLASS_CVTSD2SI, - XED_ICLASS_CVTSD2SS, - XED_ICLASS_CVTSI2SD, - XED_ICLASS_CVTSI2SS, - XED_ICLASS_CVTSS2SD, - XED_ICLASS_CVTSS2SI, - XED_ICLASS_CVTTPD2DQ, - XED_ICLASS_CVTTPD2PI, - XED_ICLASS_CVTTPS2DQ, - XED_ICLASS_CVTTPS2PI, - XED_ICLASS_CVTTSD2SI, - XED_ICLASS_CVTTSS2SI, - XED_ICLASS_CWD, - XED_ICLASS_CWDE, - XED_ICLASS_DAA, - XED_ICLASS_DAS, - XED_ICLASS_DEC, - XED_ICLASS_DEC_LOCK, - XED_ICLASS_DIV, - XED_ICLASS_DIVPD, - XED_ICLASS_DIVPS, - XED_ICLASS_DIVSD, - XED_ICLASS_DIVSS, - XED_ICLASS_DPPD, - XED_ICLASS_DPPS, - XED_ICLASS_EMMS, - XED_ICLASS_ENCLS, - XED_ICLASS_ENCLU, - XED_ICLASS_ENCLV, - XED_ICLASS_ENCODEKEY128, - XED_ICLASS_ENCODEKEY256, - XED_ICLASS_ENDBR32, - XED_ICLASS_ENDBR64, - XED_ICLASS_ENQCMD, - XED_ICLASS_ENQCMDS, - XED_ICLASS_ENTER, - XED_ICLASS_EXTRACTPS, - XED_ICLASS_EXTRQ, - XED_ICLASS_F2XM1, - XED_ICLASS_FABS, - XED_ICLASS_FADD, - XED_ICLASS_FADDP, - XED_ICLASS_FBLD, - XED_ICLASS_FBSTP, - XED_ICLASS_FCHS, - XED_ICLASS_FCMOVB, - XED_ICLASS_FCMOVBE, - XED_ICLASS_FCMOVE, - XED_ICLASS_FCMOVNB, - XED_ICLASS_FCMOVNBE, - XED_ICLASS_FCMOVNE, - XED_ICLASS_FCMOVNU, - XED_ICLASS_FCMOVU, - XED_ICLASS_FCOM, - XED_ICLASS_FCOMI, - XED_ICLASS_FCOMIP, - XED_ICLASS_FCOMP, - XED_ICLASS_FCOMPP, - XED_ICLASS_FCOS, - XED_ICLASS_FDECSTP, - XED_ICLASS_FDISI8087_NOP, - XED_ICLASS_FDIV, - XED_ICLASS_FDIVP, - XED_ICLASS_FDIVR, - XED_ICLASS_FDIVRP, - XED_ICLASS_FEMMS, - XED_ICLASS_FENI8087_NOP, - XED_ICLASS_FFREE, - XED_ICLASS_FFREEP, - XED_ICLASS_FIADD, - XED_ICLASS_FICOM, - XED_ICLASS_FICOMP, - XED_ICLASS_FIDIV, - XED_ICLASS_FIDIVR, - XED_ICLASS_FILD, - XED_ICLASS_FIMUL, - XED_ICLASS_FINCSTP, - XED_ICLASS_FIST, - XED_ICLASS_FISTP, - XED_ICLASS_FISTTP, - XED_ICLASS_FISUB, - XED_ICLASS_FISUBR, - XED_ICLASS_FLD, - XED_ICLASS_FLD1, - XED_ICLASS_FLDCW, - XED_ICLASS_FLDENV, - XED_ICLASS_FLDL2E, - XED_ICLASS_FLDL2T, - XED_ICLASS_FLDLG2, - XED_ICLASS_FLDLN2, - XED_ICLASS_FLDPI, - XED_ICLASS_FLDZ, - XED_ICLASS_FMUL, - XED_ICLASS_FMULP, - XED_ICLASS_FNCLEX, - XED_ICLASS_FNINIT, - XED_ICLASS_FNOP, - XED_ICLASS_FNSAVE, - XED_ICLASS_FNSTCW, - XED_ICLASS_FNSTENV, - XED_ICLASS_FNSTSW, - XED_ICLASS_FPATAN, - XED_ICLASS_FPREM, - XED_ICLASS_FPREM1, - XED_ICLASS_FPTAN, - XED_ICLASS_FRNDINT, - XED_ICLASS_FRSTOR, - XED_ICLASS_FSCALE, - XED_ICLASS_FSETPM287_NOP, - XED_ICLASS_FSIN, - XED_ICLASS_FSINCOS, - XED_ICLASS_FSQRT, - XED_ICLASS_FST, - XED_ICLASS_FSTP, - XED_ICLASS_FSTPNCE, - XED_ICLASS_FSUB, - XED_ICLASS_FSUBP, - XED_ICLASS_FSUBR, - XED_ICLASS_FSUBRP, - XED_ICLASS_FTST, - XED_ICLASS_FUCOM, - XED_ICLASS_FUCOMI, - XED_ICLASS_FUCOMIP, - XED_ICLASS_FUCOMP, - XED_ICLASS_FUCOMPP, - XED_ICLASS_FWAIT, - XED_ICLASS_FXAM, - XED_ICLASS_FXCH, - XED_ICLASS_FXRSTOR, - XED_ICLASS_FXRSTOR64, - XED_ICLASS_FXSAVE, - XED_ICLASS_FXSAVE64, - XED_ICLASS_FXTRACT, - XED_ICLASS_FYL2X, - XED_ICLASS_FYL2XP1, - XED_ICLASS_GETSEC, - XED_ICLASS_GF2P8AFFINEINVQB, - XED_ICLASS_GF2P8AFFINEQB, - XED_ICLASS_GF2P8MULB, - XED_ICLASS_HADDPD, - XED_ICLASS_HADDPS, - XED_ICLASS_HLT, - XED_ICLASS_HRESET, - XED_ICLASS_HSUBPD, - XED_ICLASS_HSUBPS, - XED_ICLASS_IDIV, - XED_ICLASS_IMUL, - XED_ICLASS_IN, - XED_ICLASS_INC, - XED_ICLASS_INCSSPD, - XED_ICLASS_INCSSPQ, - XED_ICLASS_INC_LOCK, - XED_ICLASS_INSB, - XED_ICLASS_INSD, - XED_ICLASS_INSERTPS, - XED_ICLASS_INSERTQ, - XED_ICLASS_INSW, - XED_ICLASS_INT, - XED_ICLASS_INT1, - XED_ICLASS_INT3, - XED_ICLASS_INTO, - XED_ICLASS_INVD, - XED_ICLASS_INVEPT, - XED_ICLASS_INVLPG, - XED_ICLASS_INVLPGA, - XED_ICLASS_INVLPGB, - XED_ICLASS_INVPCID, - XED_ICLASS_INVVPID, - XED_ICLASS_IRET, - XED_ICLASS_IRETD, - XED_ICLASS_IRETQ, - XED_ICLASS_JB, - XED_ICLASS_JBE, - XED_ICLASS_JCXZ, - XED_ICLASS_JECXZ, - XED_ICLASS_JL, - XED_ICLASS_JLE, - XED_ICLASS_JMP, - XED_ICLASS_JMP_FAR, - XED_ICLASS_JNB, - XED_ICLASS_JNBE, - XED_ICLASS_JNL, - XED_ICLASS_JNLE, - XED_ICLASS_JNO, - XED_ICLASS_JNP, - XED_ICLASS_JNS, - XED_ICLASS_JNZ, - XED_ICLASS_JO, - XED_ICLASS_JP, - XED_ICLASS_JRCXZ, - XED_ICLASS_JS, - XED_ICLASS_JZ, - XED_ICLASS_KADDB, - XED_ICLASS_KADDD, - XED_ICLASS_KADDQ, - XED_ICLASS_KADDW, - XED_ICLASS_KANDB, - XED_ICLASS_KANDD, - XED_ICLASS_KANDNB, - XED_ICLASS_KANDND, - XED_ICLASS_KANDNQ, - XED_ICLASS_KANDNW, - XED_ICLASS_KANDQ, - XED_ICLASS_KANDW, - XED_ICLASS_KMOVB, - XED_ICLASS_KMOVD, - XED_ICLASS_KMOVQ, - XED_ICLASS_KMOVW, - XED_ICLASS_KNOTB, - XED_ICLASS_KNOTD, - XED_ICLASS_KNOTQ, - XED_ICLASS_KNOTW, - XED_ICLASS_KORB, - XED_ICLASS_KORD, - XED_ICLASS_KORQ, - XED_ICLASS_KORTESTB, - XED_ICLASS_KORTESTD, - XED_ICLASS_KORTESTQ, - XED_ICLASS_KORTESTW, - XED_ICLASS_KORW, - XED_ICLASS_KSHIFTLB, - XED_ICLASS_KSHIFTLD, - XED_ICLASS_KSHIFTLQ, - XED_ICLASS_KSHIFTLW, - XED_ICLASS_KSHIFTRB, - XED_ICLASS_KSHIFTRD, - XED_ICLASS_KSHIFTRQ, - XED_ICLASS_KSHIFTRW, - XED_ICLASS_KTESTB, - XED_ICLASS_KTESTD, - XED_ICLASS_KTESTQ, - XED_ICLASS_KTESTW, - XED_ICLASS_KUNPCKBW, - XED_ICLASS_KUNPCKDQ, - XED_ICLASS_KUNPCKWD, - XED_ICLASS_KXNORB, - XED_ICLASS_KXNORD, - XED_ICLASS_KXNORQ, - XED_ICLASS_KXNORW, - XED_ICLASS_KXORB, - XED_ICLASS_KXORD, - XED_ICLASS_KXORQ, - XED_ICLASS_KXORW, - XED_ICLASS_LAHF, - XED_ICLASS_LAR, - XED_ICLASS_LDDQU, - XED_ICLASS_LDMXCSR, - XED_ICLASS_LDS, - XED_ICLASS_LDTILECFG, - XED_ICLASS_LEA, - XED_ICLASS_LEAVE, - XED_ICLASS_LES, - XED_ICLASS_LFENCE, - XED_ICLASS_LFS, - XED_ICLASS_LGDT, - XED_ICLASS_LGS, - XED_ICLASS_LIDT, - XED_ICLASS_LLDT, - XED_ICLASS_LLWPCB, - XED_ICLASS_LMSW, - XED_ICLASS_LOADIWKEY, - XED_ICLASS_LODSB, - XED_ICLASS_LODSD, - XED_ICLASS_LODSQ, - XED_ICLASS_LODSW, - XED_ICLASS_LOOP, - XED_ICLASS_LOOPE, - XED_ICLASS_LOOPNE, - XED_ICLASS_LSL, - XED_ICLASS_LSS, - XED_ICLASS_LTR, - XED_ICLASS_LWPINS, - XED_ICLASS_LWPVAL, - XED_ICLASS_LZCNT, - XED_ICLASS_MASKMOVDQU, - XED_ICLASS_MASKMOVQ, - XED_ICLASS_MAXPD, - XED_ICLASS_MAXPS, - XED_ICLASS_MAXSD, - XED_ICLASS_MAXSS, - XED_ICLASS_MCOMMIT, - XED_ICLASS_MFENCE, - XED_ICLASS_MINPD, - XED_ICLASS_MINPS, - XED_ICLASS_MINSD, - XED_ICLASS_MINSS, - XED_ICLASS_MONITOR, - XED_ICLASS_MONITORX, - XED_ICLASS_MOV, - XED_ICLASS_MOVAPD, - XED_ICLASS_MOVAPS, - XED_ICLASS_MOVBE, - XED_ICLASS_MOVD, - XED_ICLASS_MOVDDUP, - XED_ICLASS_MOVDIR64B, - XED_ICLASS_MOVDIRI, - XED_ICLASS_MOVDQ2Q, - XED_ICLASS_MOVDQA, - XED_ICLASS_MOVDQU, - XED_ICLASS_MOVHLPS, - XED_ICLASS_MOVHPD, - XED_ICLASS_MOVHPS, - XED_ICLASS_MOVLHPS, - XED_ICLASS_MOVLPD, - XED_ICLASS_MOVLPS, - XED_ICLASS_MOVMSKPD, - XED_ICLASS_MOVMSKPS, - XED_ICLASS_MOVNTDQ, - XED_ICLASS_MOVNTDQA, - XED_ICLASS_MOVNTI, - XED_ICLASS_MOVNTPD, - XED_ICLASS_MOVNTPS, - XED_ICLASS_MOVNTQ, - XED_ICLASS_MOVNTSD, - XED_ICLASS_MOVNTSS, - XED_ICLASS_MOVQ, - XED_ICLASS_MOVQ2DQ, - XED_ICLASS_MOVSB, - XED_ICLASS_MOVSD, - XED_ICLASS_MOVSD_XMM, - XED_ICLASS_MOVSHDUP, - XED_ICLASS_MOVSLDUP, - XED_ICLASS_MOVSQ, - XED_ICLASS_MOVSS, - XED_ICLASS_MOVSW, - XED_ICLASS_MOVSX, - XED_ICLASS_MOVSXD, - XED_ICLASS_MOVUPD, - XED_ICLASS_MOVUPS, - XED_ICLASS_MOVZX, - XED_ICLASS_MOV_CR, - XED_ICLASS_MOV_DR, - XED_ICLASS_MPSADBW, - XED_ICLASS_MUL, - XED_ICLASS_MULPD, - XED_ICLASS_MULPS, - XED_ICLASS_MULSD, - XED_ICLASS_MULSS, - XED_ICLASS_MULX, - XED_ICLASS_MWAIT, - XED_ICLASS_MWAITX, - XED_ICLASS_NEG, - XED_ICLASS_NEG_LOCK, - XED_ICLASS_NOP, - XED_ICLASS_NOP2, - XED_ICLASS_NOP3, - XED_ICLASS_NOP4, - XED_ICLASS_NOP5, - XED_ICLASS_NOP6, - XED_ICLASS_NOP7, - XED_ICLASS_NOP8, - XED_ICLASS_NOP9, - XED_ICLASS_NOT, - XED_ICLASS_NOT_LOCK, - XED_ICLASS_OR, - XED_ICLASS_ORPD, - XED_ICLASS_ORPS, - XED_ICLASS_OR_LOCK, - XED_ICLASS_OUT, - XED_ICLASS_OUTSB, - XED_ICLASS_OUTSD, - XED_ICLASS_OUTSW, - XED_ICLASS_PABSB, - XED_ICLASS_PABSD, - XED_ICLASS_PABSW, - XED_ICLASS_PACKSSDW, - XED_ICLASS_PACKSSWB, - XED_ICLASS_PACKUSDW, - XED_ICLASS_PACKUSWB, - XED_ICLASS_PADDB, - XED_ICLASS_PADDD, - XED_ICLASS_PADDQ, - XED_ICLASS_PADDSB, - XED_ICLASS_PADDSW, - XED_ICLASS_PADDUSB, - XED_ICLASS_PADDUSW, - XED_ICLASS_PADDW, - XED_ICLASS_PALIGNR, - XED_ICLASS_PAND, - XED_ICLASS_PANDN, - XED_ICLASS_PAUSE, - XED_ICLASS_PAVGB, - XED_ICLASS_PAVGUSB, - XED_ICLASS_PAVGW, - XED_ICLASS_PBLENDVB, - XED_ICLASS_PBLENDW, - XED_ICLASS_PCLMULQDQ, - XED_ICLASS_PCMPEQB, - XED_ICLASS_PCMPEQD, - XED_ICLASS_PCMPEQQ, - XED_ICLASS_PCMPEQW, - XED_ICLASS_PCMPESTRI, - XED_ICLASS_PCMPESTRI64, - XED_ICLASS_PCMPESTRM, - XED_ICLASS_PCMPESTRM64, - XED_ICLASS_PCMPGTB, - XED_ICLASS_PCMPGTD, - XED_ICLASS_PCMPGTQ, - XED_ICLASS_PCMPGTW, - XED_ICLASS_PCMPISTRI, - XED_ICLASS_PCMPISTRI64, - XED_ICLASS_PCMPISTRM, - XED_ICLASS_PCONFIG, - XED_ICLASS_PDEP, - XED_ICLASS_PEXT, - XED_ICLASS_PEXTRB, - XED_ICLASS_PEXTRD, - XED_ICLASS_PEXTRQ, - XED_ICLASS_PEXTRW, - XED_ICLASS_PEXTRW_SSE4, - XED_ICLASS_PF2ID, - XED_ICLASS_PF2IW, - XED_ICLASS_PFACC, - XED_ICLASS_PFADD, - XED_ICLASS_PFCMPEQ, - XED_ICLASS_PFCMPGE, - XED_ICLASS_PFCMPGT, - XED_ICLASS_PFMAX, - XED_ICLASS_PFMIN, - XED_ICLASS_PFMUL, - XED_ICLASS_PFNACC, - XED_ICLASS_PFPNACC, - XED_ICLASS_PFRCP, - XED_ICLASS_PFRCPIT1, - XED_ICLASS_PFRCPIT2, - XED_ICLASS_PFRSQIT1, - XED_ICLASS_PFRSQRT, - XED_ICLASS_PFSUB, - XED_ICLASS_PFSUBR, - XED_ICLASS_PHADDD, - XED_ICLASS_PHADDSW, - XED_ICLASS_PHADDW, - XED_ICLASS_PHMINPOSUW, - XED_ICLASS_PHSUBD, - XED_ICLASS_PHSUBSW, - XED_ICLASS_PHSUBW, - XED_ICLASS_PI2FD, - XED_ICLASS_PI2FW, - XED_ICLASS_PINSRB, - XED_ICLASS_PINSRD, - XED_ICLASS_PINSRQ, - XED_ICLASS_PINSRW, - XED_ICLASS_PMADDUBSW, - XED_ICLASS_PMADDWD, - XED_ICLASS_PMAXSB, - XED_ICLASS_PMAXSD, - XED_ICLASS_PMAXSW, - XED_ICLASS_PMAXUB, - XED_ICLASS_PMAXUD, - XED_ICLASS_PMAXUW, - XED_ICLASS_PMINSB, - XED_ICLASS_PMINSD, - XED_ICLASS_PMINSW, - XED_ICLASS_PMINUB, - XED_ICLASS_PMINUD, - XED_ICLASS_PMINUW, - XED_ICLASS_PMOVMSKB, - XED_ICLASS_PMOVSXBD, - XED_ICLASS_PMOVSXBQ, - XED_ICLASS_PMOVSXBW, - XED_ICLASS_PMOVSXDQ, - XED_ICLASS_PMOVSXWD, - XED_ICLASS_PMOVSXWQ, - XED_ICLASS_PMOVZXBD, - XED_ICLASS_PMOVZXBQ, - XED_ICLASS_PMOVZXBW, - XED_ICLASS_PMOVZXDQ, - XED_ICLASS_PMOVZXWD, - XED_ICLASS_PMOVZXWQ, - XED_ICLASS_PMULDQ, - XED_ICLASS_PMULHRSW, - XED_ICLASS_PMULHRW, - XED_ICLASS_PMULHUW, - XED_ICLASS_PMULHW, - XED_ICLASS_PMULLD, - XED_ICLASS_PMULLW, - XED_ICLASS_PMULUDQ, - XED_ICLASS_POP, - XED_ICLASS_POPA, - XED_ICLASS_POPAD, - XED_ICLASS_POPCNT, - XED_ICLASS_POPF, - XED_ICLASS_POPFD, - XED_ICLASS_POPFQ, - XED_ICLASS_POR, - XED_ICLASS_PREFETCHNTA, - XED_ICLASS_PREFETCHT0, - XED_ICLASS_PREFETCHT1, - XED_ICLASS_PREFETCHT2, - XED_ICLASS_PREFETCHW, - XED_ICLASS_PREFETCHWT1, - XED_ICLASS_PREFETCH_EXCLUSIVE, - XED_ICLASS_PREFETCH_RESERVED, - XED_ICLASS_PSADBW, - XED_ICLASS_PSHUFB, - XED_ICLASS_PSHUFD, - XED_ICLASS_PSHUFHW, - XED_ICLASS_PSHUFLW, - XED_ICLASS_PSHUFW, - XED_ICLASS_PSIGNB, - XED_ICLASS_PSIGND, - XED_ICLASS_PSIGNW, - XED_ICLASS_PSLLD, - XED_ICLASS_PSLLDQ, - XED_ICLASS_PSLLQ, - XED_ICLASS_PSLLW, - XED_ICLASS_PSMASH, - XED_ICLASS_PSRAD, - XED_ICLASS_PSRAW, - XED_ICLASS_PSRLD, - XED_ICLASS_PSRLDQ, - XED_ICLASS_PSRLQ, - XED_ICLASS_PSRLW, - XED_ICLASS_PSUBB, - XED_ICLASS_PSUBD, - XED_ICLASS_PSUBQ, - XED_ICLASS_PSUBSB, - XED_ICLASS_PSUBSW, - XED_ICLASS_PSUBUSB, - XED_ICLASS_PSUBUSW, - XED_ICLASS_PSUBW, - XED_ICLASS_PSWAPD, - XED_ICLASS_PTEST, - XED_ICLASS_PTWRITE, - XED_ICLASS_PUNPCKHBW, - XED_ICLASS_PUNPCKHDQ, - XED_ICLASS_PUNPCKHQDQ, - XED_ICLASS_PUNPCKHWD, - XED_ICLASS_PUNPCKLBW, - XED_ICLASS_PUNPCKLDQ, - XED_ICLASS_PUNPCKLQDQ, - XED_ICLASS_PUNPCKLWD, - XED_ICLASS_PUSH, - XED_ICLASS_PUSHA, - XED_ICLASS_PUSHAD, - XED_ICLASS_PUSHF, - XED_ICLASS_PUSHFD, - XED_ICLASS_PUSHFQ, - XED_ICLASS_PVALIDATE, - XED_ICLASS_PXOR, - XED_ICLASS_RCL, - XED_ICLASS_RCPPS, - XED_ICLASS_RCPSS, - XED_ICLASS_RCR, - XED_ICLASS_RDFSBASE, - XED_ICLASS_RDGSBASE, - XED_ICLASS_RDMSR, - XED_ICLASS_RDPID, - XED_ICLASS_RDPKRU, - XED_ICLASS_RDPMC, - XED_ICLASS_RDPRU, - XED_ICLASS_RDRAND, - XED_ICLASS_RDSEED, - XED_ICLASS_RDSSPD, - XED_ICLASS_RDSSPQ, - XED_ICLASS_RDTSC, - XED_ICLASS_RDTSCP, - XED_ICLASS_REPE_CMPSB, - XED_ICLASS_REPE_CMPSD, - XED_ICLASS_REPE_CMPSQ, - XED_ICLASS_REPE_CMPSW, - XED_ICLASS_REPE_SCASB, - XED_ICLASS_REPE_SCASD, - XED_ICLASS_REPE_SCASQ, - XED_ICLASS_REPE_SCASW, - XED_ICLASS_REPNE_CMPSB, - XED_ICLASS_REPNE_CMPSD, - XED_ICLASS_REPNE_CMPSQ, - XED_ICLASS_REPNE_CMPSW, - XED_ICLASS_REPNE_SCASB, - XED_ICLASS_REPNE_SCASD, - XED_ICLASS_REPNE_SCASQ, - XED_ICLASS_REPNE_SCASW, - XED_ICLASS_REP_INSB, - XED_ICLASS_REP_INSD, - XED_ICLASS_REP_INSW, - XED_ICLASS_REP_LODSB, - XED_ICLASS_REP_LODSD, - XED_ICLASS_REP_LODSQ, - XED_ICLASS_REP_LODSW, - XED_ICLASS_REP_MONTMUL, - XED_ICLASS_REP_MOVSB, - XED_ICLASS_REP_MOVSD, - XED_ICLASS_REP_MOVSQ, - XED_ICLASS_REP_MOVSW, - XED_ICLASS_REP_OUTSB, - XED_ICLASS_REP_OUTSD, - XED_ICLASS_REP_OUTSW, - XED_ICLASS_REP_STOSB, - XED_ICLASS_REP_STOSD, - XED_ICLASS_REP_STOSQ, - XED_ICLASS_REP_STOSW, - XED_ICLASS_REP_XCRYPTCBC, - XED_ICLASS_REP_XCRYPTCFB, - XED_ICLASS_REP_XCRYPTCTR, - XED_ICLASS_REP_XCRYPTECB, - XED_ICLASS_REP_XCRYPTOFB, - XED_ICLASS_REP_XSHA1, - XED_ICLASS_REP_XSHA256, - XED_ICLASS_REP_XSTORE, - XED_ICLASS_RET_FAR, - XED_ICLASS_RET_NEAR, - XED_ICLASS_RMPADJUST, - XED_ICLASS_RMPUPDATE, - XED_ICLASS_ROL, - XED_ICLASS_ROR, - XED_ICLASS_RORX, - XED_ICLASS_ROUNDPD, - XED_ICLASS_ROUNDPS, - XED_ICLASS_ROUNDSD, - XED_ICLASS_ROUNDSS, - XED_ICLASS_RSM, - XED_ICLASS_RSQRTPS, - XED_ICLASS_RSQRTSS, - XED_ICLASS_RSTORSSP, - XED_ICLASS_SAHF, - XED_ICLASS_SALC, - XED_ICLASS_SAR, - XED_ICLASS_SARX, - XED_ICLASS_SAVEPREVSSP, - XED_ICLASS_SBB, - XED_ICLASS_SBB_LOCK, - XED_ICLASS_SCASB, - XED_ICLASS_SCASD, - XED_ICLASS_SCASQ, - XED_ICLASS_SCASW, - XED_ICLASS_SEAMCALL, - XED_ICLASS_SEAMOPS, - XED_ICLASS_SEAMRET, - XED_ICLASS_SENDUIPI, - XED_ICLASS_SERIALIZE, - XED_ICLASS_SETB, - XED_ICLASS_SETBE, - XED_ICLASS_SETL, - XED_ICLASS_SETLE, - XED_ICLASS_SETNB, - XED_ICLASS_SETNBE, - XED_ICLASS_SETNL, - XED_ICLASS_SETNLE, - XED_ICLASS_SETNO, - XED_ICLASS_SETNP, - XED_ICLASS_SETNS, - XED_ICLASS_SETNZ, - XED_ICLASS_SETO, - XED_ICLASS_SETP, - XED_ICLASS_SETS, - XED_ICLASS_SETSSBSY, - XED_ICLASS_SETZ, - XED_ICLASS_SFENCE, - XED_ICLASS_SGDT, - XED_ICLASS_SHA1MSG1, - XED_ICLASS_SHA1MSG2, - XED_ICLASS_SHA1NEXTE, - XED_ICLASS_SHA1RNDS4, - XED_ICLASS_SHA256MSG1, - XED_ICLASS_SHA256MSG2, - XED_ICLASS_SHA256RNDS2, - XED_ICLASS_SHL, - XED_ICLASS_SHLD, - XED_ICLASS_SHLX, - XED_ICLASS_SHR, - XED_ICLASS_SHRD, - XED_ICLASS_SHRX, - XED_ICLASS_SHUFPD, - XED_ICLASS_SHUFPS, - XED_ICLASS_SIDT, - XED_ICLASS_SKINIT, - XED_ICLASS_SLDT, - XED_ICLASS_SLWPCB, - XED_ICLASS_SMSW, - XED_ICLASS_SQRTPD, - XED_ICLASS_SQRTPS, - XED_ICLASS_SQRTSD, - XED_ICLASS_SQRTSS, - XED_ICLASS_STAC, - XED_ICLASS_STC, - XED_ICLASS_STD, - XED_ICLASS_STGI, - XED_ICLASS_STI, - XED_ICLASS_STMXCSR, - XED_ICLASS_STOSB, - XED_ICLASS_STOSD, - XED_ICLASS_STOSQ, - XED_ICLASS_STOSW, - XED_ICLASS_STR, - XED_ICLASS_STTILECFG, - XED_ICLASS_STUI, - XED_ICLASS_SUB, - XED_ICLASS_SUBPD, - XED_ICLASS_SUBPS, - XED_ICLASS_SUBSD, - XED_ICLASS_SUBSS, - XED_ICLASS_SUB_LOCK, - XED_ICLASS_SWAPGS, - XED_ICLASS_SYSCALL, - XED_ICLASS_SYSCALL_AMD, - XED_ICLASS_SYSENTER, - XED_ICLASS_SYSEXIT, - XED_ICLASS_SYSRET, - XED_ICLASS_SYSRET64, - XED_ICLASS_SYSRET_AMD, - XED_ICLASS_T1MSKC, - XED_ICLASS_TDCALL, - XED_ICLASS_TDPBF16PS, - XED_ICLASS_TDPBSSD, - XED_ICLASS_TDPBSUD, - XED_ICLASS_TDPBUSD, - XED_ICLASS_TDPBUUD, - XED_ICLASS_TEST, - XED_ICLASS_TESTUI, - XED_ICLASS_TILELOADD, - XED_ICLASS_TILELOADDT1, - XED_ICLASS_TILERELEASE, - XED_ICLASS_TILESTORED, - XED_ICLASS_TILEZERO, - XED_ICLASS_TLBSYNC, - XED_ICLASS_TPAUSE, - XED_ICLASS_TZCNT, - XED_ICLASS_TZMSK, - XED_ICLASS_UCOMISD, - XED_ICLASS_UCOMISS, - XED_ICLASS_UD0, - XED_ICLASS_UD1, - XED_ICLASS_UD2, - XED_ICLASS_UIRET, - XED_ICLASS_UMONITOR, - XED_ICLASS_UMWAIT, - XED_ICLASS_UNPCKHPD, - XED_ICLASS_UNPCKHPS, - XED_ICLASS_UNPCKLPD, - XED_ICLASS_UNPCKLPS, - XED_ICLASS_V4FMADDPS, - XED_ICLASS_V4FMADDSS, - XED_ICLASS_V4FNMADDPS, - XED_ICLASS_V4FNMADDSS, - XED_ICLASS_VADDPD, - XED_ICLASS_VADDPH, - XED_ICLASS_VADDPS, - XED_ICLASS_VADDSD, - XED_ICLASS_VADDSH, - XED_ICLASS_VADDSS, - XED_ICLASS_VADDSUBPD, - XED_ICLASS_VADDSUBPS, - XED_ICLASS_VAESDEC, - XED_ICLASS_VAESDECLAST, - XED_ICLASS_VAESENC, - XED_ICLASS_VAESENCLAST, - XED_ICLASS_VAESIMC, - XED_ICLASS_VAESKEYGENASSIST, - XED_ICLASS_VALIGND, - XED_ICLASS_VALIGNQ, - XED_ICLASS_VANDNPD, - XED_ICLASS_VANDNPS, - XED_ICLASS_VANDPD, - XED_ICLASS_VANDPS, - XED_ICLASS_VBLENDMPD, - XED_ICLASS_VBLENDMPS, - XED_ICLASS_VBLENDPD, - XED_ICLASS_VBLENDPS, - XED_ICLASS_VBLENDVPD, - XED_ICLASS_VBLENDVPS, - XED_ICLASS_VBROADCASTF128, - XED_ICLASS_VBROADCASTF32X2, - XED_ICLASS_VBROADCASTF32X4, - XED_ICLASS_VBROADCASTF32X8, - XED_ICLASS_VBROADCASTF64X2, - XED_ICLASS_VBROADCASTF64X4, - XED_ICLASS_VBROADCASTI128, - XED_ICLASS_VBROADCASTI32X2, - XED_ICLASS_VBROADCASTI32X4, - XED_ICLASS_VBROADCASTI32X8, - XED_ICLASS_VBROADCASTI64X2, - XED_ICLASS_VBROADCASTI64X4, - XED_ICLASS_VBROADCASTSD, - XED_ICLASS_VBROADCASTSS, - XED_ICLASS_VCMPPD, - XED_ICLASS_VCMPPH, - XED_ICLASS_VCMPPS, - XED_ICLASS_VCMPSD, - XED_ICLASS_VCMPSH, - XED_ICLASS_VCMPSS, - XED_ICLASS_VCOMISD, - XED_ICLASS_VCOMISH, - XED_ICLASS_VCOMISS, - XED_ICLASS_VCOMPRESSPD, - XED_ICLASS_VCOMPRESSPS, - XED_ICLASS_VCVTDQ2PD, - XED_ICLASS_VCVTDQ2PH, - XED_ICLASS_VCVTDQ2PS, - XED_ICLASS_VCVTNE2PS2BF16, - XED_ICLASS_VCVTNEPS2BF16, - XED_ICLASS_VCVTPD2DQ, - XED_ICLASS_VCVTPD2PH, - XED_ICLASS_VCVTPD2PS, - XED_ICLASS_VCVTPD2QQ, - XED_ICLASS_VCVTPD2UDQ, - XED_ICLASS_VCVTPD2UQQ, - XED_ICLASS_VCVTPH2DQ, - XED_ICLASS_VCVTPH2PD, - XED_ICLASS_VCVTPH2PS, - XED_ICLASS_VCVTPH2PSX, - XED_ICLASS_VCVTPH2QQ, - XED_ICLASS_VCVTPH2UDQ, - XED_ICLASS_VCVTPH2UQQ, - XED_ICLASS_VCVTPH2UW, - XED_ICLASS_VCVTPH2W, - XED_ICLASS_VCVTPS2DQ, - XED_ICLASS_VCVTPS2PD, - XED_ICLASS_VCVTPS2PH, - XED_ICLASS_VCVTPS2PHX, - XED_ICLASS_VCVTPS2QQ, - XED_ICLASS_VCVTPS2UDQ, - XED_ICLASS_VCVTPS2UQQ, - XED_ICLASS_VCVTQQ2PD, - XED_ICLASS_VCVTQQ2PH, - XED_ICLASS_VCVTQQ2PS, - XED_ICLASS_VCVTSD2SH, - XED_ICLASS_VCVTSD2SI, - XED_ICLASS_VCVTSD2SS, - XED_ICLASS_VCVTSD2USI, - XED_ICLASS_VCVTSH2SD, - XED_ICLASS_VCVTSH2SI, - XED_ICLASS_VCVTSH2SS, - XED_ICLASS_VCVTSH2USI, - XED_ICLASS_VCVTSI2SD, - XED_ICLASS_VCVTSI2SH, - XED_ICLASS_VCVTSI2SS, - XED_ICLASS_VCVTSS2SD, - XED_ICLASS_VCVTSS2SH, - XED_ICLASS_VCVTSS2SI, - XED_ICLASS_VCVTSS2USI, - XED_ICLASS_VCVTTPD2DQ, - XED_ICLASS_VCVTTPD2QQ, - XED_ICLASS_VCVTTPD2UDQ, - XED_ICLASS_VCVTTPD2UQQ, - XED_ICLASS_VCVTTPH2DQ, - XED_ICLASS_VCVTTPH2QQ, - XED_ICLASS_VCVTTPH2UDQ, - XED_ICLASS_VCVTTPH2UQQ, - XED_ICLASS_VCVTTPH2UW, - XED_ICLASS_VCVTTPH2W, - XED_ICLASS_VCVTTPS2DQ, - XED_ICLASS_VCVTTPS2QQ, - XED_ICLASS_VCVTTPS2UDQ, - XED_ICLASS_VCVTTPS2UQQ, - XED_ICLASS_VCVTTSD2SI, - XED_ICLASS_VCVTTSD2USI, - XED_ICLASS_VCVTTSH2SI, - XED_ICLASS_VCVTTSH2USI, - XED_ICLASS_VCVTTSS2SI, - XED_ICLASS_VCVTTSS2USI, - XED_ICLASS_VCVTUDQ2PD, - XED_ICLASS_VCVTUDQ2PH, - XED_ICLASS_VCVTUDQ2PS, - XED_ICLASS_VCVTUQQ2PD, - XED_ICLASS_VCVTUQQ2PH, - XED_ICLASS_VCVTUQQ2PS, - XED_ICLASS_VCVTUSI2SD, - XED_ICLASS_VCVTUSI2SH, - XED_ICLASS_VCVTUSI2SS, - XED_ICLASS_VCVTUW2PH, - XED_ICLASS_VCVTW2PH, - XED_ICLASS_VDBPSADBW, - XED_ICLASS_VDIVPD, - XED_ICLASS_VDIVPH, - XED_ICLASS_VDIVPS, - XED_ICLASS_VDIVSD, - XED_ICLASS_VDIVSH, - XED_ICLASS_VDIVSS, - XED_ICLASS_VDPBF16PS, - XED_ICLASS_VDPPD, - XED_ICLASS_VDPPS, - XED_ICLASS_VERR, - XED_ICLASS_VERW, - XED_ICLASS_VEXP2PD, - XED_ICLASS_VEXP2PS, - XED_ICLASS_VEXPANDPD, - XED_ICLASS_VEXPANDPS, - XED_ICLASS_VEXTRACTF128, - XED_ICLASS_VEXTRACTF32X4, - XED_ICLASS_VEXTRACTF32X8, - XED_ICLASS_VEXTRACTF64X2, - XED_ICLASS_VEXTRACTF64X4, - XED_ICLASS_VEXTRACTI128, - XED_ICLASS_VEXTRACTI32X4, - XED_ICLASS_VEXTRACTI32X8, - XED_ICLASS_VEXTRACTI64X2, - XED_ICLASS_VEXTRACTI64X4, - XED_ICLASS_VEXTRACTPS, - XED_ICLASS_VFCMADDCPH, - XED_ICLASS_VFCMADDCSH, - XED_ICLASS_VFCMULCPH, - XED_ICLASS_VFCMULCSH, - XED_ICLASS_VFIXUPIMMPD, - XED_ICLASS_VFIXUPIMMPS, - XED_ICLASS_VFIXUPIMMSD, - XED_ICLASS_VFIXUPIMMSS, - XED_ICLASS_VFMADD132PD, - XED_ICLASS_VFMADD132PH, - XED_ICLASS_VFMADD132PS, - XED_ICLASS_VFMADD132SD, - XED_ICLASS_VFMADD132SH, - XED_ICLASS_VFMADD132SS, - XED_ICLASS_VFMADD213PD, - XED_ICLASS_VFMADD213PH, - XED_ICLASS_VFMADD213PS, - XED_ICLASS_VFMADD213SD, - XED_ICLASS_VFMADD213SH, - XED_ICLASS_VFMADD213SS, - XED_ICLASS_VFMADD231PD, - XED_ICLASS_VFMADD231PH, - XED_ICLASS_VFMADD231PS, - XED_ICLASS_VFMADD231SD, - XED_ICLASS_VFMADD231SH, - XED_ICLASS_VFMADD231SS, - XED_ICLASS_VFMADDCPH, - XED_ICLASS_VFMADDCSH, - XED_ICLASS_VFMADDPD, - XED_ICLASS_VFMADDPS, - XED_ICLASS_VFMADDSD, - XED_ICLASS_VFMADDSS, - XED_ICLASS_VFMADDSUB132PD, - XED_ICLASS_VFMADDSUB132PH, - XED_ICLASS_VFMADDSUB132PS, - XED_ICLASS_VFMADDSUB213PD, - XED_ICLASS_VFMADDSUB213PH, - XED_ICLASS_VFMADDSUB213PS, - XED_ICLASS_VFMADDSUB231PD, - XED_ICLASS_VFMADDSUB231PH, - XED_ICLASS_VFMADDSUB231PS, - XED_ICLASS_VFMADDSUBPD, - XED_ICLASS_VFMADDSUBPS, - XED_ICLASS_VFMSUB132PD, - XED_ICLASS_VFMSUB132PH, - XED_ICLASS_VFMSUB132PS, - XED_ICLASS_VFMSUB132SD, - XED_ICLASS_VFMSUB132SH, - XED_ICLASS_VFMSUB132SS, - XED_ICLASS_VFMSUB213PD, - XED_ICLASS_VFMSUB213PH, - XED_ICLASS_VFMSUB213PS, - XED_ICLASS_VFMSUB213SD, - XED_ICLASS_VFMSUB213SH, - XED_ICLASS_VFMSUB213SS, - XED_ICLASS_VFMSUB231PD, - XED_ICLASS_VFMSUB231PH, - XED_ICLASS_VFMSUB231PS, - XED_ICLASS_VFMSUB231SD, - XED_ICLASS_VFMSUB231SH, - XED_ICLASS_VFMSUB231SS, - XED_ICLASS_VFMSUBADD132PD, - XED_ICLASS_VFMSUBADD132PH, - XED_ICLASS_VFMSUBADD132PS, - XED_ICLASS_VFMSUBADD213PD, - XED_ICLASS_VFMSUBADD213PH, - XED_ICLASS_VFMSUBADD213PS, - XED_ICLASS_VFMSUBADD231PD, - XED_ICLASS_VFMSUBADD231PH, - XED_ICLASS_VFMSUBADD231PS, - XED_ICLASS_VFMSUBADDPD, - XED_ICLASS_VFMSUBADDPS, - XED_ICLASS_VFMSUBPD, - XED_ICLASS_VFMSUBPS, - XED_ICLASS_VFMSUBSD, - XED_ICLASS_VFMSUBSS, - XED_ICLASS_VFMULCPH, - XED_ICLASS_VFMULCSH, - XED_ICLASS_VFNMADD132PD, - XED_ICLASS_VFNMADD132PH, - XED_ICLASS_VFNMADD132PS, - XED_ICLASS_VFNMADD132SD, - XED_ICLASS_VFNMADD132SH, - XED_ICLASS_VFNMADD132SS, - XED_ICLASS_VFNMADD213PD, - XED_ICLASS_VFNMADD213PH, - XED_ICLASS_VFNMADD213PS, - XED_ICLASS_VFNMADD213SD, - XED_ICLASS_VFNMADD213SH, - XED_ICLASS_VFNMADD213SS, - XED_ICLASS_VFNMADD231PD, - XED_ICLASS_VFNMADD231PH, - XED_ICLASS_VFNMADD231PS, - XED_ICLASS_VFNMADD231SD, - XED_ICLASS_VFNMADD231SH, - XED_ICLASS_VFNMADD231SS, - XED_ICLASS_VFNMADDPD, - XED_ICLASS_VFNMADDPS, - XED_ICLASS_VFNMADDSD, - XED_ICLASS_VFNMADDSS, - XED_ICLASS_VFNMSUB132PD, - XED_ICLASS_VFNMSUB132PH, - XED_ICLASS_VFNMSUB132PS, - XED_ICLASS_VFNMSUB132SD, - XED_ICLASS_VFNMSUB132SH, - XED_ICLASS_VFNMSUB132SS, - XED_ICLASS_VFNMSUB213PD, - XED_ICLASS_VFNMSUB213PH, - XED_ICLASS_VFNMSUB213PS, - XED_ICLASS_VFNMSUB213SD, - XED_ICLASS_VFNMSUB213SH, - XED_ICLASS_VFNMSUB213SS, - XED_ICLASS_VFNMSUB231PD, - XED_ICLASS_VFNMSUB231PH, - XED_ICLASS_VFNMSUB231PS, - XED_ICLASS_VFNMSUB231SD, - XED_ICLASS_VFNMSUB231SH, - XED_ICLASS_VFNMSUB231SS, - XED_ICLASS_VFNMSUBPD, - XED_ICLASS_VFNMSUBPS, - XED_ICLASS_VFNMSUBSD, - XED_ICLASS_VFNMSUBSS, - XED_ICLASS_VFPCLASSPD, - XED_ICLASS_VFPCLASSPH, - XED_ICLASS_VFPCLASSPS, - XED_ICLASS_VFPCLASSSD, - XED_ICLASS_VFPCLASSSH, - XED_ICLASS_VFPCLASSSS, - XED_ICLASS_VFRCZPD, - XED_ICLASS_VFRCZPS, - XED_ICLASS_VFRCZSD, - XED_ICLASS_VFRCZSS, - XED_ICLASS_VGATHERDPD, - XED_ICLASS_VGATHERDPS, - XED_ICLASS_VGATHERPF0DPD, - XED_ICLASS_VGATHERPF0DPS, - XED_ICLASS_VGATHERPF0QPD, - XED_ICLASS_VGATHERPF0QPS, - XED_ICLASS_VGATHERPF1DPD, - XED_ICLASS_VGATHERPF1DPS, - XED_ICLASS_VGATHERPF1QPD, - XED_ICLASS_VGATHERPF1QPS, - XED_ICLASS_VGATHERQPD, - XED_ICLASS_VGATHERQPS, - XED_ICLASS_VGETEXPPD, - XED_ICLASS_VGETEXPPH, - XED_ICLASS_VGETEXPPS, - XED_ICLASS_VGETEXPSD, - XED_ICLASS_VGETEXPSH, - XED_ICLASS_VGETEXPSS, - XED_ICLASS_VGETMANTPD, - XED_ICLASS_VGETMANTPH, - XED_ICLASS_VGETMANTPS, - XED_ICLASS_VGETMANTSD, - XED_ICLASS_VGETMANTSH, - XED_ICLASS_VGETMANTSS, - XED_ICLASS_VGF2P8AFFINEINVQB, - XED_ICLASS_VGF2P8AFFINEQB, - XED_ICLASS_VGF2P8MULB, - XED_ICLASS_VHADDPD, - XED_ICLASS_VHADDPS, - XED_ICLASS_VHSUBPD, - XED_ICLASS_VHSUBPS, - XED_ICLASS_VINSERTF128, - XED_ICLASS_VINSERTF32X4, - XED_ICLASS_VINSERTF32X8, - XED_ICLASS_VINSERTF64X2, - XED_ICLASS_VINSERTF64X4, - XED_ICLASS_VINSERTI128, - XED_ICLASS_VINSERTI32X4, - XED_ICLASS_VINSERTI32X8, - XED_ICLASS_VINSERTI64X2, - XED_ICLASS_VINSERTI64X4, - XED_ICLASS_VINSERTPS, - XED_ICLASS_VLDDQU, - XED_ICLASS_VLDMXCSR, - XED_ICLASS_VMASKMOVDQU, - XED_ICLASS_VMASKMOVPD, - XED_ICLASS_VMASKMOVPS, - XED_ICLASS_VMAXPD, - XED_ICLASS_VMAXPH, - XED_ICLASS_VMAXPS, - XED_ICLASS_VMAXSD, - XED_ICLASS_VMAXSH, - XED_ICLASS_VMAXSS, - XED_ICLASS_VMCALL, - XED_ICLASS_VMCLEAR, - XED_ICLASS_VMFUNC, - XED_ICLASS_VMINPD, - XED_ICLASS_VMINPH, - XED_ICLASS_VMINPS, - XED_ICLASS_VMINSD, - XED_ICLASS_VMINSH, - XED_ICLASS_VMINSS, - XED_ICLASS_VMLAUNCH, - XED_ICLASS_VMLOAD, - XED_ICLASS_VMMCALL, - XED_ICLASS_VMOVAPD, - XED_ICLASS_VMOVAPS, - XED_ICLASS_VMOVD, - XED_ICLASS_VMOVDDUP, - XED_ICLASS_VMOVDQA, - XED_ICLASS_VMOVDQA32, - XED_ICLASS_VMOVDQA64, - XED_ICLASS_VMOVDQU, - XED_ICLASS_VMOVDQU16, - XED_ICLASS_VMOVDQU32, - XED_ICLASS_VMOVDQU64, - XED_ICLASS_VMOVDQU8, - XED_ICLASS_VMOVHLPS, - XED_ICLASS_VMOVHPD, - XED_ICLASS_VMOVHPS, - XED_ICLASS_VMOVLHPS, - XED_ICLASS_VMOVLPD, - XED_ICLASS_VMOVLPS, - XED_ICLASS_VMOVMSKPD, - XED_ICLASS_VMOVMSKPS, - XED_ICLASS_VMOVNTDQ, - XED_ICLASS_VMOVNTDQA, - XED_ICLASS_VMOVNTPD, - XED_ICLASS_VMOVNTPS, - XED_ICLASS_VMOVQ, - XED_ICLASS_VMOVSD, - XED_ICLASS_VMOVSH, - XED_ICLASS_VMOVSHDUP, - XED_ICLASS_VMOVSLDUP, - XED_ICLASS_VMOVSS, - XED_ICLASS_VMOVUPD, - XED_ICLASS_VMOVUPS, - XED_ICLASS_VMOVW, - XED_ICLASS_VMPSADBW, - XED_ICLASS_VMPTRLD, - XED_ICLASS_VMPTRST, - XED_ICLASS_VMREAD, - XED_ICLASS_VMRESUME, - XED_ICLASS_VMRUN, - XED_ICLASS_VMSAVE, - XED_ICLASS_VMULPD, - XED_ICLASS_VMULPH, - XED_ICLASS_VMULPS, - XED_ICLASS_VMULSD, - XED_ICLASS_VMULSH, - XED_ICLASS_VMULSS, - XED_ICLASS_VMWRITE, - XED_ICLASS_VMXOFF, - XED_ICLASS_VMXON, - XED_ICLASS_VORPD, - XED_ICLASS_VORPS, - XED_ICLASS_VP2INTERSECTD, - XED_ICLASS_VP2INTERSECTQ, - XED_ICLASS_VP4DPWSSD, - XED_ICLASS_VP4DPWSSDS, - XED_ICLASS_VPABSB, - XED_ICLASS_VPABSD, - XED_ICLASS_VPABSQ, - XED_ICLASS_VPABSW, - XED_ICLASS_VPACKSSDW, - XED_ICLASS_VPACKSSWB, - XED_ICLASS_VPACKUSDW, - XED_ICLASS_VPACKUSWB, - XED_ICLASS_VPADDB, - XED_ICLASS_VPADDD, - XED_ICLASS_VPADDQ, - XED_ICLASS_VPADDSB, - XED_ICLASS_VPADDSW, - XED_ICLASS_VPADDUSB, - XED_ICLASS_VPADDUSW, - XED_ICLASS_VPADDW, - XED_ICLASS_VPALIGNR, - XED_ICLASS_VPAND, - XED_ICLASS_VPANDD, - XED_ICLASS_VPANDN, - XED_ICLASS_VPANDND, - XED_ICLASS_VPANDNQ, - XED_ICLASS_VPANDQ, - XED_ICLASS_VPAVGB, - XED_ICLASS_VPAVGW, - XED_ICLASS_VPBLENDD, - XED_ICLASS_VPBLENDMB, - XED_ICLASS_VPBLENDMD, - XED_ICLASS_VPBLENDMQ, - XED_ICLASS_VPBLENDMW, - XED_ICLASS_VPBLENDVB, - XED_ICLASS_VPBLENDW, - XED_ICLASS_VPBROADCASTB, - XED_ICLASS_VPBROADCASTD, - XED_ICLASS_VPBROADCASTMB2Q, - XED_ICLASS_VPBROADCASTMW2D, - XED_ICLASS_VPBROADCASTQ, - XED_ICLASS_VPBROADCASTW, - XED_ICLASS_VPCLMULQDQ, - XED_ICLASS_VPCMOV, - XED_ICLASS_VPCMPB, - XED_ICLASS_VPCMPD, - XED_ICLASS_VPCMPEQB, - XED_ICLASS_VPCMPEQD, - XED_ICLASS_VPCMPEQQ, - XED_ICLASS_VPCMPEQW, - XED_ICLASS_VPCMPESTRI, - XED_ICLASS_VPCMPESTRI64, - XED_ICLASS_VPCMPESTRM, - XED_ICLASS_VPCMPESTRM64, - XED_ICLASS_VPCMPGTB, - XED_ICLASS_VPCMPGTD, - XED_ICLASS_VPCMPGTQ, - XED_ICLASS_VPCMPGTW, - XED_ICLASS_VPCMPISTRI, - XED_ICLASS_VPCMPISTRI64, - XED_ICLASS_VPCMPISTRM, - XED_ICLASS_VPCMPQ, - XED_ICLASS_VPCMPUB, - XED_ICLASS_VPCMPUD, - XED_ICLASS_VPCMPUQ, - XED_ICLASS_VPCMPUW, - XED_ICLASS_VPCMPW, - XED_ICLASS_VPCOMB, - XED_ICLASS_VPCOMD, - XED_ICLASS_VPCOMPRESSB, - XED_ICLASS_VPCOMPRESSD, - XED_ICLASS_VPCOMPRESSQ, - XED_ICLASS_VPCOMPRESSW, - XED_ICLASS_VPCOMQ, - XED_ICLASS_VPCOMUB, - XED_ICLASS_VPCOMUD, - XED_ICLASS_VPCOMUQ, - XED_ICLASS_VPCOMUW, - XED_ICLASS_VPCOMW, - XED_ICLASS_VPCONFLICTD, - XED_ICLASS_VPCONFLICTQ, - XED_ICLASS_VPDPBUSD, - XED_ICLASS_VPDPBUSDS, - XED_ICLASS_VPDPWSSD, - XED_ICLASS_VPDPWSSDS, - XED_ICLASS_VPERM2F128, - XED_ICLASS_VPERM2I128, - XED_ICLASS_VPERMB, - XED_ICLASS_VPERMD, - XED_ICLASS_VPERMI2B, - XED_ICLASS_VPERMI2D, - XED_ICLASS_VPERMI2PD, - XED_ICLASS_VPERMI2PS, - XED_ICLASS_VPERMI2Q, - XED_ICLASS_VPERMI2W, - XED_ICLASS_VPERMIL2PD, - XED_ICLASS_VPERMIL2PS, - XED_ICLASS_VPERMILPD, - XED_ICLASS_VPERMILPS, - XED_ICLASS_VPERMPD, - XED_ICLASS_VPERMPS, - XED_ICLASS_VPERMQ, - XED_ICLASS_VPERMT2B, - XED_ICLASS_VPERMT2D, - XED_ICLASS_VPERMT2PD, - XED_ICLASS_VPERMT2PS, - XED_ICLASS_VPERMT2Q, - XED_ICLASS_VPERMT2W, - XED_ICLASS_VPERMW, - XED_ICLASS_VPEXPANDB, - XED_ICLASS_VPEXPANDD, - XED_ICLASS_VPEXPANDQ, - XED_ICLASS_VPEXPANDW, - XED_ICLASS_VPEXTRB, - XED_ICLASS_VPEXTRD, - XED_ICLASS_VPEXTRQ, - XED_ICLASS_VPEXTRW, - XED_ICLASS_VPEXTRW_C5, - XED_ICLASS_VPGATHERDD, - XED_ICLASS_VPGATHERDQ, - XED_ICLASS_VPGATHERQD, - XED_ICLASS_VPGATHERQQ, - XED_ICLASS_VPHADDBD, - XED_ICLASS_VPHADDBQ, - XED_ICLASS_VPHADDBW, - XED_ICLASS_VPHADDD, - XED_ICLASS_VPHADDDQ, - XED_ICLASS_VPHADDSW, - XED_ICLASS_VPHADDUBD, - XED_ICLASS_VPHADDUBQ, - XED_ICLASS_VPHADDUBW, - XED_ICLASS_VPHADDUDQ, - XED_ICLASS_VPHADDUWD, - XED_ICLASS_VPHADDUWQ, - XED_ICLASS_VPHADDW, - XED_ICLASS_VPHADDWD, - XED_ICLASS_VPHADDWQ, - XED_ICLASS_VPHMINPOSUW, - XED_ICLASS_VPHSUBBW, - XED_ICLASS_VPHSUBD, - XED_ICLASS_VPHSUBDQ, - XED_ICLASS_VPHSUBSW, - XED_ICLASS_VPHSUBW, - XED_ICLASS_VPHSUBWD, - XED_ICLASS_VPINSRB, - XED_ICLASS_VPINSRD, - XED_ICLASS_VPINSRQ, - XED_ICLASS_VPINSRW, - XED_ICLASS_VPLZCNTD, - XED_ICLASS_VPLZCNTQ, - XED_ICLASS_VPMACSDD, - XED_ICLASS_VPMACSDQH, - XED_ICLASS_VPMACSDQL, - XED_ICLASS_VPMACSSDD, - XED_ICLASS_VPMACSSDQH, - XED_ICLASS_VPMACSSDQL, - XED_ICLASS_VPMACSSWD, - XED_ICLASS_VPMACSSWW, - XED_ICLASS_VPMACSWD, - XED_ICLASS_VPMACSWW, - XED_ICLASS_VPMADCSSWD, - XED_ICLASS_VPMADCSWD, - XED_ICLASS_VPMADD52HUQ, - XED_ICLASS_VPMADD52LUQ, - XED_ICLASS_VPMADDUBSW, - XED_ICLASS_VPMADDWD, - XED_ICLASS_VPMASKMOVD, - XED_ICLASS_VPMASKMOVQ, - XED_ICLASS_VPMAXSB, - XED_ICLASS_VPMAXSD, - XED_ICLASS_VPMAXSQ, - XED_ICLASS_VPMAXSW, - XED_ICLASS_VPMAXUB, - XED_ICLASS_VPMAXUD, - XED_ICLASS_VPMAXUQ, - XED_ICLASS_VPMAXUW, - XED_ICLASS_VPMINSB, - XED_ICLASS_VPMINSD, - XED_ICLASS_VPMINSQ, - XED_ICLASS_VPMINSW, - XED_ICLASS_VPMINUB, - XED_ICLASS_VPMINUD, - XED_ICLASS_VPMINUQ, - XED_ICLASS_VPMINUW, - XED_ICLASS_VPMOVB2M, - XED_ICLASS_VPMOVD2M, - XED_ICLASS_VPMOVDB, - XED_ICLASS_VPMOVDW, - XED_ICLASS_VPMOVM2B, - XED_ICLASS_VPMOVM2D, - XED_ICLASS_VPMOVM2Q, - XED_ICLASS_VPMOVM2W, - XED_ICLASS_VPMOVMSKB, - XED_ICLASS_VPMOVQ2M, - XED_ICLASS_VPMOVQB, - XED_ICLASS_VPMOVQD, - XED_ICLASS_VPMOVQW, - XED_ICLASS_VPMOVSDB, - XED_ICLASS_VPMOVSDW, - XED_ICLASS_VPMOVSQB, - XED_ICLASS_VPMOVSQD, - XED_ICLASS_VPMOVSQW, - XED_ICLASS_VPMOVSWB, - XED_ICLASS_VPMOVSXBD, - XED_ICLASS_VPMOVSXBQ, - XED_ICLASS_VPMOVSXBW, - XED_ICLASS_VPMOVSXDQ, - XED_ICLASS_VPMOVSXWD, - XED_ICLASS_VPMOVSXWQ, - XED_ICLASS_VPMOVUSDB, - XED_ICLASS_VPMOVUSDW, - XED_ICLASS_VPMOVUSQB, - XED_ICLASS_VPMOVUSQD, - XED_ICLASS_VPMOVUSQW, - XED_ICLASS_VPMOVUSWB, - XED_ICLASS_VPMOVW2M, - XED_ICLASS_VPMOVWB, - XED_ICLASS_VPMOVZXBD, - XED_ICLASS_VPMOVZXBQ, - XED_ICLASS_VPMOVZXBW, - XED_ICLASS_VPMOVZXDQ, - XED_ICLASS_VPMOVZXWD, - XED_ICLASS_VPMOVZXWQ, - XED_ICLASS_VPMULDQ, - XED_ICLASS_VPMULHRSW, - XED_ICLASS_VPMULHUW, - XED_ICLASS_VPMULHW, - XED_ICLASS_VPMULLD, - XED_ICLASS_VPMULLQ, - XED_ICLASS_VPMULLW, - XED_ICLASS_VPMULTISHIFTQB, - XED_ICLASS_VPMULUDQ, - XED_ICLASS_VPOPCNTB, - XED_ICLASS_VPOPCNTD, - XED_ICLASS_VPOPCNTQ, - XED_ICLASS_VPOPCNTW, - XED_ICLASS_VPOR, - XED_ICLASS_VPORD, - XED_ICLASS_VPORQ, - XED_ICLASS_VPPERM, - XED_ICLASS_VPROLD, - XED_ICLASS_VPROLQ, - XED_ICLASS_VPROLVD, - XED_ICLASS_VPROLVQ, - XED_ICLASS_VPRORD, - XED_ICLASS_VPRORQ, - XED_ICLASS_VPRORVD, - XED_ICLASS_VPRORVQ, - XED_ICLASS_VPROTB, - XED_ICLASS_VPROTD, - XED_ICLASS_VPROTQ, - XED_ICLASS_VPROTW, - XED_ICLASS_VPSADBW, - XED_ICLASS_VPSCATTERDD, - XED_ICLASS_VPSCATTERDQ, - XED_ICLASS_VPSCATTERQD, - XED_ICLASS_VPSCATTERQQ, - XED_ICLASS_VPSHAB, - XED_ICLASS_VPSHAD, - XED_ICLASS_VPSHAQ, - XED_ICLASS_VPSHAW, - XED_ICLASS_VPSHLB, - XED_ICLASS_VPSHLD, - XED_ICLASS_VPSHLDD, - XED_ICLASS_VPSHLDQ, - XED_ICLASS_VPSHLDVD, - XED_ICLASS_VPSHLDVQ, - XED_ICLASS_VPSHLDVW, - XED_ICLASS_VPSHLDW, - XED_ICLASS_VPSHLQ, - XED_ICLASS_VPSHLW, - XED_ICLASS_VPSHRDD, - XED_ICLASS_VPSHRDQ, - XED_ICLASS_VPSHRDVD, - XED_ICLASS_VPSHRDVQ, - XED_ICLASS_VPSHRDVW, - XED_ICLASS_VPSHRDW, - XED_ICLASS_VPSHUFB, - XED_ICLASS_VPSHUFBITQMB, - XED_ICLASS_VPSHUFD, - XED_ICLASS_VPSHUFHW, - XED_ICLASS_VPSHUFLW, - XED_ICLASS_VPSIGNB, - XED_ICLASS_VPSIGND, - XED_ICLASS_VPSIGNW, - XED_ICLASS_VPSLLD, - XED_ICLASS_VPSLLDQ, - XED_ICLASS_VPSLLQ, - XED_ICLASS_VPSLLVD, - XED_ICLASS_VPSLLVQ, - XED_ICLASS_VPSLLVW, - XED_ICLASS_VPSLLW, - XED_ICLASS_VPSRAD, - XED_ICLASS_VPSRAQ, - XED_ICLASS_VPSRAVD, - XED_ICLASS_VPSRAVQ, - XED_ICLASS_VPSRAVW, - XED_ICLASS_VPSRAW, - XED_ICLASS_VPSRLD, - XED_ICLASS_VPSRLDQ, - XED_ICLASS_VPSRLQ, - XED_ICLASS_VPSRLVD, - XED_ICLASS_VPSRLVQ, - XED_ICLASS_VPSRLVW, - XED_ICLASS_VPSRLW, - XED_ICLASS_VPSUBB, - XED_ICLASS_VPSUBD, - XED_ICLASS_VPSUBQ, - XED_ICLASS_VPSUBSB, - XED_ICLASS_VPSUBSW, - XED_ICLASS_VPSUBUSB, - XED_ICLASS_VPSUBUSW, - XED_ICLASS_VPSUBW, - XED_ICLASS_VPTERNLOGD, - XED_ICLASS_VPTERNLOGQ, - XED_ICLASS_VPTEST, - XED_ICLASS_VPTESTMB, - XED_ICLASS_VPTESTMD, - XED_ICLASS_VPTESTMQ, - XED_ICLASS_VPTESTMW, - XED_ICLASS_VPTESTNMB, - XED_ICLASS_VPTESTNMD, - XED_ICLASS_VPTESTNMQ, - XED_ICLASS_VPTESTNMW, - XED_ICLASS_VPUNPCKHBW, - XED_ICLASS_VPUNPCKHDQ, - XED_ICLASS_VPUNPCKHQDQ, - XED_ICLASS_VPUNPCKHWD, - XED_ICLASS_VPUNPCKLBW, - XED_ICLASS_VPUNPCKLDQ, - XED_ICLASS_VPUNPCKLQDQ, - XED_ICLASS_VPUNPCKLWD, - XED_ICLASS_VPXOR, - XED_ICLASS_VPXORD, - XED_ICLASS_VPXORQ, - XED_ICLASS_VRANGEPD, - XED_ICLASS_VRANGEPS, - XED_ICLASS_VRANGESD, - XED_ICLASS_VRANGESS, - XED_ICLASS_VRCP14PD, - XED_ICLASS_VRCP14PS, - XED_ICLASS_VRCP14SD, - XED_ICLASS_VRCP14SS, - XED_ICLASS_VRCP28PD, - XED_ICLASS_VRCP28PS, - XED_ICLASS_VRCP28SD, - XED_ICLASS_VRCP28SS, - XED_ICLASS_VRCPPH, - XED_ICLASS_VRCPPS, - XED_ICLASS_VRCPSH, - XED_ICLASS_VRCPSS, - XED_ICLASS_VREDUCEPD, - XED_ICLASS_VREDUCEPH, - XED_ICLASS_VREDUCEPS, - XED_ICLASS_VREDUCESD, - XED_ICLASS_VREDUCESH, - XED_ICLASS_VREDUCESS, - XED_ICLASS_VRNDSCALEPD, - XED_ICLASS_VRNDSCALEPH, - XED_ICLASS_VRNDSCALEPS, - XED_ICLASS_VRNDSCALESD, - XED_ICLASS_VRNDSCALESH, - XED_ICLASS_VRNDSCALESS, - XED_ICLASS_VROUNDPD, - XED_ICLASS_VROUNDPS, - XED_ICLASS_VROUNDSD, - XED_ICLASS_VROUNDSS, - XED_ICLASS_VRSQRT14PD, - XED_ICLASS_VRSQRT14PS, - XED_ICLASS_VRSQRT14SD, - XED_ICLASS_VRSQRT14SS, - XED_ICLASS_VRSQRT28PD, - XED_ICLASS_VRSQRT28PS, - XED_ICLASS_VRSQRT28SD, - XED_ICLASS_VRSQRT28SS, - XED_ICLASS_VRSQRTPH, - XED_ICLASS_VRSQRTPS, - XED_ICLASS_VRSQRTSH, - XED_ICLASS_VRSQRTSS, - XED_ICLASS_VSCALEFPD, - XED_ICLASS_VSCALEFPH, - XED_ICLASS_VSCALEFPS, - XED_ICLASS_VSCALEFSD, - XED_ICLASS_VSCALEFSH, - XED_ICLASS_VSCALEFSS, - XED_ICLASS_VSCATTERDPD, - XED_ICLASS_VSCATTERDPS, - XED_ICLASS_VSCATTERPF0DPD, - XED_ICLASS_VSCATTERPF0DPS, - XED_ICLASS_VSCATTERPF0QPD, - XED_ICLASS_VSCATTERPF0QPS, - XED_ICLASS_VSCATTERPF1DPD, - XED_ICLASS_VSCATTERPF1DPS, - XED_ICLASS_VSCATTERPF1QPD, - XED_ICLASS_VSCATTERPF1QPS, - XED_ICLASS_VSCATTERQPD, - XED_ICLASS_VSCATTERQPS, - XED_ICLASS_VSHUFF32X4, - XED_ICLASS_VSHUFF64X2, - XED_ICLASS_VSHUFI32X4, - XED_ICLASS_VSHUFI64X2, - XED_ICLASS_VSHUFPD, - XED_ICLASS_VSHUFPS, - XED_ICLASS_VSQRTPD, - XED_ICLASS_VSQRTPH, - XED_ICLASS_VSQRTPS, - XED_ICLASS_VSQRTSD, - XED_ICLASS_VSQRTSH, - XED_ICLASS_VSQRTSS, - XED_ICLASS_VSTMXCSR, - XED_ICLASS_VSUBPD, - XED_ICLASS_VSUBPH, - XED_ICLASS_VSUBPS, - XED_ICLASS_VSUBSD, - XED_ICLASS_VSUBSH, - XED_ICLASS_VSUBSS, - XED_ICLASS_VTESTPD, - XED_ICLASS_VTESTPS, - XED_ICLASS_VUCOMISD, - XED_ICLASS_VUCOMISH, - XED_ICLASS_VUCOMISS, - XED_ICLASS_VUNPCKHPD, - XED_ICLASS_VUNPCKHPS, - XED_ICLASS_VUNPCKLPD, - XED_ICLASS_VUNPCKLPS, - XED_ICLASS_VXORPD, - XED_ICLASS_VXORPS, - XED_ICLASS_VZEROALL, - XED_ICLASS_VZEROUPPER, - XED_ICLASS_WBINVD, - XED_ICLASS_WBNOINVD, - XED_ICLASS_WRFSBASE, - XED_ICLASS_WRGSBASE, - XED_ICLASS_WRMSR, - XED_ICLASS_WRPKRU, - XED_ICLASS_WRSSD, - XED_ICLASS_WRSSQ, - XED_ICLASS_WRUSSD, - XED_ICLASS_WRUSSQ, - XED_ICLASS_XABORT, - XED_ICLASS_XADD, - XED_ICLASS_XADD_LOCK, - XED_ICLASS_XBEGIN, - XED_ICLASS_XCHG, - XED_ICLASS_XEND, - XED_ICLASS_XGETBV, - XED_ICLASS_XLAT, - XED_ICLASS_XOR, - XED_ICLASS_XORPD, - XED_ICLASS_XORPS, - XED_ICLASS_XOR_LOCK, - XED_ICLASS_XRESLDTRK, - XED_ICLASS_XRSTOR, - XED_ICLASS_XRSTOR64, - XED_ICLASS_XRSTORS, - XED_ICLASS_XRSTORS64, - XED_ICLASS_XSAVE, - XED_ICLASS_XSAVE64, - XED_ICLASS_XSAVEC, - XED_ICLASS_XSAVEC64, - XED_ICLASS_XSAVEOPT, - XED_ICLASS_XSAVEOPT64, - XED_ICLASS_XSAVES, - XED_ICLASS_XSAVES64, - XED_ICLASS_XSETBV, - XED_ICLASS_XSTORE, - XED_ICLASS_XSUSLDTRK, - XED_ICLASS_XTEST, - XED_ICLASS_LAST -} xed_iclass_enum_t; - -/// This converts strings to #xed_iclass_enum_t types. -/// @param s A C-string. -/// @return #xed_iclass_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_iclass_enum_t str2xed_iclass_enum_t(const char* s); -/// This converts strings to #xed_iclass_enum_t types. -/// @param p An enumeration element of type xed_iclass_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_iclass_enum_t2str(const xed_iclass_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_iclass_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_iclass_enum_t xed_iclass_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-iform-enum.h b/target/i386/latx/include/xed/xed-iform-enum.h deleted file mode 100644 index 3decd82ba8d..00000000000 --- a/target/i386/latx/include/xed/xed-iform-enum.h +++ /dev/null @@ -1,13779 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-iform-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_IFORM_ENUM_H) -# define XED_IFORM_ENUM_H -#include "xed-common-hdrs.h" -#include "xed-iclass-enum.h" -#define XED_IFORM_INVALID_DEFINED 1 -#define XED_IFORM_AAA_DEFINED 1 -#define XED_IFORM_AAD_IMMb_DEFINED 1 -#define XED_IFORM_AAM_IMMb_DEFINED 1 -#define XED_IFORM_AAS_DEFINED 1 -#define XED_IFORM_ADC_AL_IMMb_DEFINED 1 -#define XED_IFORM_ADC_GPR8_GPR8_10_DEFINED 1 -#define XED_IFORM_ADC_GPR8_GPR8_12_DEFINED 1 -#define XED_IFORM_ADC_GPR8_IMMb_80r2_DEFINED 1 -#define XED_IFORM_ADC_GPR8_IMMb_82r2_DEFINED 1 -#define XED_IFORM_ADC_GPR8_MEMb_DEFINED 1 -#define XED_IFORM_ADC_GPRv_GPRv_11_DEFINED 1 -#define XED_IFORM_ADC_GPRv_GPRv_13_DEFINED 1 -#define XED_IFORM_ADC_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_ADC_GPRv_IMMz_DEFINED 1 -#define XED_IFORM_ADC_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_ADC_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_ADC_MEMb_IMMb_80r2_DEFINED 1 -#define XED_IFORM_ADC_MEMb_IMMb_82r2_DEFINED 1 -#define XED_IFORM_ADC_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_ADC_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_ADC_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_ADC_OrAX_IMMz_DEFINED 1 -#define XED_IFORM_ADCX_GPR32d_GPR32d_DEFINED 1 -#define XED_IFORM_ADCX_GPR32d_MEMd_DEFINED 1 -#define XED_IFORM_ADCX_GPR64q_GPR64q_DEFINED 1 -#define XED_IFORM_ADCX_GPR64q_MEMq_DEFINED 1 -#define XED_IFORM_ADC_LOCK_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_ADC_LOCK_MEMb_IMMb_80r2_DEFINED 1 -#define XED_IFORM_ADC_LOCK_MEMb_IMMb_82r2_DEFINED 1 -#define XED_IFORM_ADC_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_ADC_LOCK_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_ADC_LOCK_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_ADD_AL_IMMb_DEFINED 1 -#define XED_IFORM_ADD_GPR8_GPR8_00_DEFINED 1 -#define XED_IFORM_ADD_GPR8_GPR8_02_DEFINED 1 -#define XED_IFORM_ADD_GPR8_IMMb_80r0_DEFINED 1 -#define XED_IFORM_ADD_GPR8_IMMb_82r0_DEFINED 1 -#define XED_IFORM_ADD_GPR8_MEMb_DEFINED 1 -#define XED_IFORM_ADD_GPRv_GPRv_01_DEFINED 1 -#define XED_IFORM_ADD_GPRv_GPRv_03_DEFINED 1 -#define XED_IFORM_ADD_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_ADD_GPRv_IMMz_DEFINED 1 -#define XED_IFORM_ADD_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_ADD_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_ADD_MEMb_IMMb_80r0_DEFINED 1 -#define XED_IFORM_ADD_MEMb_IMMb_82r0_DEFINED 1 -#define XED_IFORM_ADD_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_ADD_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_ADD_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_ADD_OrAX_IMMz_DEFINED 1 -#define XED_IFORM_ADDPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_ADDPD_XMMpd_XMMpd_DEFINED 1 -#define XED_IFORM_ADDPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_ADDPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_ADDSD_XMMsd_MEMsd_DEFINED 1 -#define XED_IFORM_ADDSD_XMMsd_XMMsd_DEFINED 1 -#define XED_IFORM_ADDSS_XMMss_MEMss_DEFINED 1 -#define XED_IFORM_ADDSS_XMMss_XMMss_DEFINED 1 -#define XED_IFORM_ADDSUBPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_ADDSUBPD_XMMpd_XMMpd_DEFINED 1 -#define XED_IFORM_ADDSUBPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_ADDSUBPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_ADD_LOCK_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_ADD_LOCK_MEMb_IMMb_80r0_DEFINED 1 -#define XED_IFORM_ADD_LOCK_MEMb_IMMb_82r0_DEFINED 1 -#define XED_IFORM_ADD_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_ADD_LOCK_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_ADD_LOCK_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_ADOX_GPR32d_GPR32d_DEFINED 1 -#define XED_IFORM_ADOX_GPR32d_MEMd_DEFINED 1 -#define XED_IFORM_ADOX_GPR64q_GPR64q_DEFINED 1 -#define XED_IFORM_ADOX_GPR64q_MEMq_DEFINED 1 -#define XED_IFORM_AESDEC_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_AESDEC_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_AESDEC128KL_XMMu8_MEMu8_DEFINED 1 -#define XED_IFORM_AESDEC256KL_XMMu8_MEMu8_DEFINED 1 -#define XED_IFORM_AESDECLAST_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_AESDECLAST_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_AESDECWIDE128KL_MEMu8_DEFINED 1 -#define XED_IFORM_AESDECWIDE256KL_MEMu8_DEFINED 1 -#define XED_IFORM_AESENC_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_AESENC_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_AESENC128KL_XMMu8_MEMu8_DEFINED 1 -#define XED_IFORM_AESENC256KL_XMMu8_MEMu8_DEFINED 1 -#define XED_IFORM_AESENCLAST_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_AESENCLAST_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_AESENCWIDE128KL_MEMu8_DEFINED 1 -#define XED_IFORM_AESENCWIDE256KL_MEMu8_DEFINED 1 -#define XED_IFORM_AESIMC_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_AESIMC_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_AESKEYGENASSIST_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_AESKEYGENASSIST_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_AND_AL_IMMb_DEFINED 1 -#define XED_IFORM_AND_GPR8_GPR8_20_DEFINED 1 -#define XED_IFORM_AND_GPR8_GPR8_22_DEFINED 1 -#define XED_IFORM_AND_GPR8_IMMb_80r4_DEFINED 1 -#define XED_IFORM_AND_GPR8_IMMb_82r4_DEFINED 1 -#define XED_IFORM_AND_GPR8_MEMb_DEFINED 1 -#define XED_IFORM_AND_GPRv_GPRv_21_DEFINED 1 -#define XED_IFORM_AND_GPRv_GPRv_23_DEFINED 1 -#define XED_IFORM_AND_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_AND_GPRv_IMMz_DEFINED 1 -#define XED_IFORM_AND_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_AND_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_AND_MEMb_IMMb_80r4_DEFINED 1 -#define XED_IFORM_AND_MEMb_IMMb_82r4_DEFINED 1 -#define XED_IFORM_AND_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_AND_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_AND_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_AND_OrAX_IMMz_DEFINED 1 -#define XED_IFORM_ANDN_VGPR32d_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_ANDN_VGPR32d_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_ANDN_VGPR64q_VGPR64q_MEMq_DEFINED 1 -#define XED_IFORM_ANDN_VGPR64q_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_ANDNPD_XMMxuq_MEMxuq_DEFINED 1 -#define XED_IFORM_ANDNPD_XMMxuq_XMMxuq_DEFINED 1 -#define XED_IFORM_ANDNPS_XMMxud_MEMxud_DEFINED 1 -#define XED_IFORM_ANDNPS_XMMxud_XMMxud_DEFINED 1 -#define XED_IFORM_ANDPD_XMMxuq_MEMxuq_DEFINED 1 -#define XED_IFORM_ANDPD_XMMxuq_XMMxuq_DEFINED 1 -#define XED_IFORM_ANDPS_XMMxud_MEMxud_DEFINED 1 -#define XED_IFORM_ANDPS_XMMxud_XMMxud_DEFINED 1 -#define XED_IFORM_AND_LOCK_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_AND_LOCK_MEMb_IMMb_80r4_DEFINED 1 -#define XED_IFORM_AND_LOCK_MEMb_IMMb_82r4_DEFINED 1 -#define XED_IFORM_AND_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_AND_LOCK_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_AND_LOCK_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_ARPL_GPR16_GPR16_DEFINED 1 -#define XED_IFORM_ARPL_MEMw_GPR16_DEFINED 1 -#define XED_IFORM_BEXTR_VGPR32d_MEMd_VGPR32d_DEFINED 1 -#define XED_IFORM_BEXTR_VGPR32d_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BEXTR_VGPR64q_MEMq_VGPR64q_DEFINED 1 -#define XED_IFORM_BEXTR_VGPR64q_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_BEXTR_XOP_VGPR32d_MEMd_IMMd_DEFINED 1 -#define XED_IFORM_BEXTR_XOP_VGPR32d_VGPR32d_IMMd_DEFINED 1 -#define XED_IFORM_BEXTR_XOP_VGPRyy_MEMy_IMMd_DEFINED 1 -#define XED_IFORM_BEXTR_XOP_VGPRyy_VGPRyy_IMMd_DEFINED 1 -#define XED_IFORM_BLCFILL_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_BLCFILL_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BLCFILL_VGPRyy_MEMy_DEFINED 1 -#define XED_IFORM_BLCFILL_VGPRyy_VGPRyy_DEFINED 1 -#define XED_IFORM_BLCI_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_BLCI_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BLCI_VGPRyy_MEMy_DEFINED 1 -#define XED_IFORM_BLCI_VGPRyy_VGPRyy_DEFINED 1 -#define XED_IFORM_BLCIC_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_BLCIC_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BLCIC_VGPRyy_MEMy_DEFINED 1 -#define XED_IFORM_BLCIC_VGPRyy_VGPRyy_DEFINED 1 -#define XED_IFORM_BLCMSK_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_BLCMSK_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BLCMSK_VGPRyy_MEMy_DEFINED 1 -#define XED_IFORM_BLCMSK_VGPRyy_VGPRyy_DEFINED 1 -#define XED_IFORM_BLCS_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_BLCS_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BLCS_VGPRyy_MEMy_DEFINED 1 -#define XED_IFORM_BLCS_VGPRyy_VGPRyy_DEFINED 1 -#define XED_IFORM_BLENDPD_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_BLENDPD_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_BLENDPS_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_BLENDPS_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_BLENDVPD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_BLENDVPD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_BLENDVPS_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_BLENDVPS_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_BLSFILL_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_BLSFILL_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BLSFILL_VGPRyy_MEMy_DEFINED 1 -#define XED_IFORM_BLSFILL_VGPRyy_VGPRyy_DEFINED 1 -#define XED_IFORM_BLSI_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_BLSI_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BLSI_VGPR64q_MEMq_DEFINED 1 -#define XED_IFORM_BLSI_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_BLSIC_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_BLSIC_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BLSIC_VGPRyy_MEMy_DEFINED 1 -#define XED_IFORM_BLSIC_VGPRyy_VGPRyy_DEFINED 1 -#define XED_IFORM_BLSMSK_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_BLSMSK_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BLSMSK_VGPR64q_MEMq_DEFINED 1 -#define XED_IFORM_BLSMSK_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_BLSR_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_BLSR_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BLSR_VGPR64q_MEMq_DEFINED 1 -#define XED_IFORM_BLSR_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_BNDCL_BND_AGEN_DEFINED 1 -#define XED_IFORM_BNDCL_BND_GPR32_DEFINED 1 -#define XED_IFORM_BNDCL_BND_GPR64_DEFINED 1 -#define XED_IFORM_BNDCN_BND_AGEN_DEFINED 1 -#define XED_IFORM_BNDCN_BND_GPR32_DEFINED 1 -#define XED_IFORM_BNDCN_BND_GPR64_DEFINED 1 -#define XED_IFORM_BNDCU_BND_AGEN_DEFINED 1 -#define XED_IFORM_BNDCU_BND_GPR32_DEFINED 1 -#define XED_IFORM_BNDCU_BND_GPR64_DEFINED 1 -#define XED_IFORM_BNDLDX_BND_MEMbnd32_DEFINED 1 -#define XED_IFORM_BNDLDX_BND_MEMbnd64_DEFINED 1 -#define XED_IFORM_BNDMK_BND_AGEN_DEFINED 1 -#define XED_IFORM_BNDMOV_BND_BND_DEFINED 1 -#define XED_IFORM_BNDMOV_BND_MEMdq_DEFINED 1 -#define XED_IFORM_BNDMOV_BND_MEMq_DEFINED 1 -#define XED_IFORM_BNDMOV_MEMdq_BND_DEFINED 1 -#define XED_IFORM_BNDMOV_MEMq_BND_DEFINED 1 -#define XED_IFORM_BNDSTX_MEMbnd32_BND_DEFINED 1 -#define XED_IFORM_BNDSTX_MEMbnd64_BND_DEFINED 1 -#define XED_IFORM_BOUND_GPRv_MEMa16_DEFINED 1 -#define XED_IFORM_BOUND_GPRv_MEMa32_DEFINED 1 -#define XED_IFORM_BSF_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_BSF_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_BSR_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_BSR_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_BSWAP_GPRv_DEFINED 1 -#define XED_IFORM_BT_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_BT_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_BT_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_BT_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_BTC_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_BTC_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_BTC_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_BTC_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_BTC_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_BTC_LOCK_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_BTR_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_BTR_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_BTR_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_BTR_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_BTR_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_BTR_LOCK_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_BTS_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_BTS_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_BTS_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_BTS_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_BTS_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_BTS_LOCK_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_BZHI_VGPR32d_MEMd_VGPR32d_DEFINED 1 -#define XED_IFORM_BZHI_VGPR32d_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_BZHI_VGPR64q_MEMq_VGPR64q_DEFINED 1 -#define XED_IFORM_BZHI_VGPR64q_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_CALL_FAR_MEMp2_DEFINED 1 -#define XED_IFORM_CALL_FAR_PTRp_IMMw_DEFINED 1 -#define XED_IFORM_CALL_NEAR_GPRv_DEFINED 1 -#define XED_IFORM_CALL_NEAR_MEMv_DEFINED 1 -#define XED_IFORM_CALL_NEAR_RELBRd_DEFINED 1 -#define XED_IFORM_CALL_NEAR_RELBRz_DEFINED 1 -#define XED_IFORM_CBW_DEFINED 1 -#define XED_IFORM_CDQ_DEFINED 1 -#define XED_IFORM_CDQE_DEFINED 1 -#define XED_IFORM_CLAC_DEFINED 1 -#define XED_IFORM_CLC_DEFINED 1 -#define XED_IFORM_CLD_DEFINED 1 -#define XED_IFORM_CLDEMOTE_MEMu8_DEFINED 1 -#define XED_IFORM_CLFLUSH_MEMmprefetch_DEFINED 1 -#define XED_IFORM_CLFLUSHOPT_MEMmprefetch_DEFINED 1 -#define XED_IFORM_CLGI_DEFINED 1 -#define XED_IFORM_CLI_DEFINED 1 -#define XED_IFORM_CLRSSBSY_MEMu64_DEFINED 1 -#define XED_IFORM_CLTS_DEFINED 1 -#define XED_IFORM_CLUI_DEFINED 1 -#define XED_IFORM_CLWB_MEMmprefetch_DEFINED 1 -#define XED_IFORM_CLZERO_DEFINED 1 -#define XED_IFORM_CMC_DEFINED 1 -#define XED_IFORM_CMOVB_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVB_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVBE_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVBE_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVL_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVL_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVLE_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVLE_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVNB_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVNB_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVNBE_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVNBE_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVNL_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVNL_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVNLE_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVNLE_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVNO_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVNO_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVNP_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVNP_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVNS_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVNS_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVNZ_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVNZ_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVO_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVO_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVP_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVP_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVS_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVS_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMOVZ_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMOVZ_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMP_AL_IMMb_DEFINED 1 -#define XED_IFORM_CMP_GPR8_GPR8_38_DEFINED 1 -#define XED_IFORM_CMP_GPR8_GPR8_3A_DEFINED 1 -#define XED_IFORM_CMP_GPR8_IMMb_80r7_DEFINED 1 -#define XED_IFORM_CMP_GPR8_IMMb_82r7_DEFINED 1 -#define XED_IFORM_CMP_GPR8_MEMb_DEFINED 1 -#define XED_IFORM_CMP_GPRv_GPRv_39_DEFINED 1 -#define XED_IFORM_CMP_GPRv_GPRv_3B_DEFINED 1 -#define XED_IFORM_CMP_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_CMP_GPRv_IMMz_DEFINED 1 -#define XED_IFORM_CMP_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_CMP_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_CMP_MEMb_IMMb_80r7_DEFINED 1 -#define XED_IFORM_CMP_MEMb_IMMb_82r7_DEFINED 1 -#define XED_IFORM_CMP_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_CMP_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_CMP_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_CMP_OrAX_IMMz_DEFINED 1 -#define XED_IFORM_CMPPD_XMMpd_MEMpd_IMMb_DEFINED 1 -#define XED_IFORM_CMPPD_XMMpd_XMMpd_IMMb_DEFINED 1 -#define XED_IFORM_CMPPS_XMMps_MEMps_IMMb_DEFINED 1 -#define XED_IFORM_CMPPS_XMMps_XMMps_IMMb_DEFINED 1 -#define XED_IFORM_CMPSB_DEFINED 1 -#define XED_IFORM_CMPSD_DEFINED 1 -#define XED_IFORM_CMPSD_XMM_XMMsd_MEMsd_IMMb_DEFINED 1 -#define XED_IFORM_CMPSD_XMM_XMMsd_XMMsd_IMMb_DEFINED 1 -#define XED_IFORM_CMPSQ_DEFINED 1 -#define XED_IFORM_CMPSS_XMMss_MEMss_IMMb_DEFINED 1 -#define XED_IFORM_CMPSS_XMMss_XMMss_IMMb_DEFINED 1 -#define XED_IFORM_CMPSW_DEFINED 1 -#define XED_IFORM_CMPXCHG_GPR8_GPR8_DEFINED 1 -#define XED_IFORM_CMPXCHG_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_CMPXCHG_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_CMPXCHG_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_CMPXCHG16B_MEMdq_DEFINED 1 -#define XED_IFORM_CMPXCHG16B_LOCK_MEMdq_DEFINED 1 -#define XED_IFORM_CMPXCHG8B_MEMq_DEFINED 1 -#define XED_IFORM_CMPXCHG8B_LOCK_MEMq_DEFINED 1 -#define XED_IFORM_CMPXCHG_LOCK_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_CMPXCHG_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_COMISD_XMMsd_MEMsd_DEFINED 1 -#define XED_IFORM_COMISD_XMMsd_XMMsd_DEFINED 1 -#define XED_IFORM_COMISS_XMMss_MEMss_DEFINED 1 -#define XED_IFORM_COMISS_XMMss_XMMss_DEFINED 1 -#define XED_IFORM_CPUID_DEFINED 1 -#define XED_IFORM_CQO_DEFINED 1 -#define XED_IFORM_CRC32_GPRyy_GPR8b_DEFINED 1 -#define XED_IFORM_CRC32_GPRyy_GPRv_DEFINED 1 -#define XED_IFORM_CRC32_GPRyy_MEMb_DEFINED 1 -#define XED_IFORM_CRC32_GPRyy_MEMv_DEFINED 1 -#define XED_IFORM_CVTDQ2PD_XMMpd_MEMq_DEFINED 1 -#define XED_IFORM_CVTDQ2PD_XMMpd_XMMq_DEFINED 1 -#define XED_IFORM_CVTDQ2PS_XMMps_MEMdq_DEFINED 1 -#define XED_IFORM_CVTDQ2PS_XMMps_XMMdq_DEFINED 1 -#define XED_IFORM_CVTPD2DQ_XMMdq_MEMpd_DEFINED 1 -#define XED_IFORM_CVTPD2DQ_XMMdq_XMMpd_DEFINED 1 -#define XED_IFORM_CVTPD2PI_MMXq_MEMpd_DEFINED 1 -#define XED_IFORM_CVTPD2PI_MMXq_XMMpd_DEFINED 1 -#define XED_IFORM_CVTPD2PS_XMMps_MEMpd_DEFINED 1 -#define XED_IFORM_CVTPD2PS_XMMps_XMMpd_DEFINED 1 -#define XED_IFORM_CVTPI2PD_XMMpd_MEMq_DEFINED 1 -#define XED_IFORM_CVTPI2PD_XMMpd_MMXq_DEFINED 1 -#define XED_IFORM_CVTPI2PS_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_CVTPI2PS_XMMq_MMXq_DEFINED 1 -#define XED_IFORM_CVTPS2DQ_XMMdq_MEMps_DEFINED 1 -#define XED_IFORM_CVTPS2DQ_XMMdq_XMMps_DEFINED 1 -#define XED_IFORM_CVTPS2PD_XMMpd_MEMq_DEFINED 1 -#define XED_IFORM_CVTPS2PD_XMMpd_XMMq_DEFINED 1 -#define XED_IFORM_CVTPS2PI_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_CVTPS2PI_MMXq_XMMq_DEFINED 1 -#define XED_IFORM_CVTSD2SI_GPR32d_MEMsd_DEFINED 1 -#define XED_IFORM_CVTSD2SI_GPR32d_XMMsd_DEFINED 1 -#define XED_IFORM_CVTSD2SI_GPR64q_MEMsd_DEFINED 1 -#define XED_IFORM_CVTSD2SI_GPR64q_XMMsd_DEFINED 1 -#define XED_IFORM_CVTSD2SS_XMMss_MEMsd_DEFINED 1 -#define XED_IFORM_CVTSD2SS_XMMss_XMMsd_DEFINED 1 -#define XED_IFORM_CVTSI2SD_XMMsd_GPR32d_DEFINED 1 -#define XED_IFORM_CVTSI2SD_XMMsd_GPR64q_DEFINED 1 -#define XED_IFORM_CVTSI2SD_XMMsd_MEMd_DEFINED 1 -#define XED_IFORM_CVTSI2SD_XMMsd_MEMq_DEFINED 1 -#define XED_IFORM_CVTSI2SS_XMMss_GPR32d_DEFINED 1 -#define XED_IFORM_CVTSI2SS_XMMss_GPR64q_DEFINED 1 -#define XED_IFORM_CVTSI2SS_XMMss_MEMd_DEFINED 1 -#define XED_IFORM_CVTSI2SS_XMMss_MEMq_DEFINED 1 -#define XED_IFORM_CVTSS2SD_XMMsd_MEMss_DEFINED 1 -#define XED_IFORM_CVTSS2SD_XMMsd_XMMss_DEFINED 1 -#define XED_IFORM_CVTSS2SI_GPR32d_MEMss_DEFINED 1 -#define XED_IFORM_CVTSS2SI_GPR32d_XMMss_DEFINED 1 -#define XED_IFORM_CVTSS2SI_GPR64q_MEMss_DEFINED 1 -#define XED_IFORM_CVTSS2SI_GPR64q_XMMss_DEFINED 1 -#define XED_IFORM_CVTTPD2DQ_XMMdq_MEMpd_DEFINED 1 -#define XED_IFORM_CVTTPD2DQ_XMMdq_XMMpd_DEFINED 1 -#define XED_IFORM_CVTTPD2PI_MMXq_MEMpd_DEFINED 1 -#define XED_IFORM_CVTTPD2PI_MMXq_XMMpd_DEFINED 1 -#define XED_IFORM_CVTTPS2DQ_XMMdq_MEMps_DEFINED 1 -#define XED_IFORM_CVTTPS2DQ_XMMdq_XMMps_DEFINED 1 -#define XED_IFORM_CVTTPS2PI_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_CVTTPS2PI_MMXq_XMMq_DEFINED 1 -#define XED_IFORM_CVTTSD2SI_GPR32d_MEMsd_DEFINED 1 -#define XED_IFORM_CVTTSD2SI_GPR32d_XMMsd_DEFINED 1 -#define XED_IFORM_CVTTSD2SI_GPR64q_MEMsd_DEFINED 1 -#define XED_IFORM_CVTTSD2SI_GPR64q_XMMsd_DEFINED 1 -#define XED_IFORM_CVTTSS2SI_GPR32d_MEMss_DEFINED 1 -#define XED_IFORM_CVTTSS2SI_GPR32d_XMMss_DEFINED 1 -#define XED_IFORM_CVTTSS2SI_GPR64q_MEMss_DEFINED 1 -#define XED_IFORM_CVTTSS2SI_GPR64q_XMMss_DEFINED 1 -#define XED_IFORM_CWD_DEFINED 1 -#define XED_IFORM_CWDE_DEFINED 1 -#define XED_IFORM_DAA_DEFINED 1 -#define XED_IFORM_DAS_DEFINED 1 -#define XED_IFORM_DEC_GPR8_DEFINED 1 -#define XED_IFORM_DEC_GPRv_48_DEFINED 1 -#define XED_IFORM_DEC_GPRv_FFr1_DEFINED 1 -#define XED_IFORM_DEC_MEMb_DEFINED 1 -#define XED_IFORM_DEC_MEMv_DEFINED 1 -#define XED_IFORM_DEC_LOCK_MEMb_DEFINED 1 -#define XED_IFORM_DEC_LOCK_MEMv_DEFINED 1 -#define XED_IFORM_DIV_GPR8_DEFINED 1 -#define XED_IFORM_DIV_GPRv_DEFINED 1 -#define XED_IFORM_DIV_MEMb_DEFINED 1 -#define XED_IFORM_DIV_MEMv_DEFINED 1 -#define XED_IFORM_DIVPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_DIVPD_XMMpd_XMMpd_DEFINED 1 -#define XED_IFORM_DIVPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_DIVPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_DIVSD_XMMsd_MEMsd_DEFINED 1 -#define XED_IFORM_DIVSD_XMMsd_XMMsd_DEFINED 1 -#define XED_IFORM_DIVSS_XMMss_MEMss_DEFINED 1 -#define XED_IFORM_DIVSS_XMMss_XMMss_DEFINED 1 -#define XED_IFORM_DPPD_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_DPPD_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_DPPS_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_DPPS_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_EMMS_DEFINED 1 -#define XED_IFORM_ENCLS_DEFINED 1 -#define XED_IFORM_ENCLU_DEFINED 1 -#define XED_IFORM_ENCLV_DEFINED 1 -#define XED_IFORM_ENCODEKEY128_GPR32u8_GPR32u8_DEFINED 1 -#define XED_IFORM_ENCODEKEY256_GPR32u8_GPR32u8_DEFINED 1 -#define XED_IFORM_ENDBR32_DEFINED 1 -#define XED_IFORM_ENDBR64_DEFINED 1 -#define XED_IFORM_ENQCMD_GPRa_MEMu32_DEFINED 1 -#define XED_IFORM_ENQCMDS_GPRa_MEMu32_DEFINED 1 -#define XED_IFORM_ENTER_IMMw_IMMb_DEFINED 1 -#define XED_IFORM_EXTRACTPS_GPR32d_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_EXTRACTPS_MEMd_XMMps_IMMb_DEFINED 1 -#define XED_IFORM_EXTRQ_XMMq_IMMb_IMMb_DEFINED 1 -#define XED_IFORM_EXTRQ_XMMq_XMMdq_DEFINED 1 -#define XED_IFORM_F2XM1_DEFINED 1 -#define XED_IFORM_FABS_DEFINED 1 -#define XED_IFORM_FADD_ST0_MEMm64real_DEFINED 1 -#define XED_IFORM_FADD_ST0_MEMmem32real_DEFINED 1 -#define XED_IFORM_FADD_ST0_X87_DEFINED 1 -#define XED_IFORM_FADD_X87_ST0_DEFINED 1 -#define XED_IFORM_FADDP_X87_ST0_DEFINED 1 -#define XED_IFORM_FBLD_ST0_MEMmem80dec_DEFINED 1 -#define XED_IFORM_FBSTP_MEMmem80dec_ST0_DEFINED 1 -#define XED_IFORM_FCHS_DEFINED 1 -#define XED_IFORM_FCMOVB_ST0_X87_DEFINED 1 -#define XED_IFORM_FCMOVBE_ST0_X87_DEFINED 1 -#define XED_IFORM_FCMOVE_ST0_X87_DEFINED 1 -#define XED_IFORM_FCMOVNB_ST0_X87_DEFINED 1 -#define XED_IFORM_FCMOVNBE_ST0_X87_DEFINED 1 -#define XED_IFORM_FCMOVNE_ST0_X87_DEFINED 1 -#define XED_IFORM_FCMOVNU_ST0_X87_DEFINED 1 -#define XED_IFORM_FCMOVU_ST0_X87_DEFINED 1 -#define XED_IFORM_FCOM_ST0_MEMm64real_DEFINED 1 -#define XED_IFORM_FCOM_ST0_MEMmem32real_DEFINED 1 -#define XED_IFORM_FCOM_ST0_X87_DEFINED 1 -#define XED_IFORM_FCOM_ST0_X87_DCD0_DEFINED 1 -#define XED_IFORM_FCOMI_ST0_X87_DEFINED 1 -#define XED_IFORM_FCOMIP_ST0_X87_DEFINED 1 -#define XED_IFORM_FCOMP_ST0_MEMm64real_DEFINED 1 -#define XED_IFORM_FCOMP_ST0_MEMmem32real_DEFINED 1 -#define XED_IFORM_FCOMP_ST0_X87_DEFINED 1 -#define XED_IFORM_FCOMP_ST0_X87_DCD1_DEFINED 1 -#define XED_IFORM_FCOMP_ST0_X87_DED0_DEFINED 1 -#define XED_IFORM_FCOMPP_DEFINED 1 -#define XED_IFORM_FCOS_DEFINED 1 -#define XED_IFORM_FDECSTP_DEFINED 1 -#define XED_IFORM_FDISI8087_NOP_DEFINED 1 -#define XED_IFORM_FDIV_ST0_MEMm64real_DEFINED 1 -#define XED_IFORM_FDIV_ST0_MEMmem32real_DEFINED 1 -#define XED_IFORM_FDIV_ST0_X87_DEFINED 1 -#define XED_IFORM_FDIV_X87_ST0_DEFINED 1 -#define XED_IFORM_FDIVP_X87_ST0_DEFINED 1 -#define XED_IFORM_FDIVR_ST0_MEMm64real_DEFINED 1 -#define XED_IFORM_FDIVR_ST0_MEMmem32real_DEFINED 1 -#define XED_IFORM_FDIVR_ST0_X87_DEFINED 1 -#define XED_IFORM_FDIVR_X87_ST0_DEFINED 1 -#define XED_IFORM_FDIVRP_X87_ST0_DEFINED 1 -#define XED_IFORM_FEMMS_DEFINED 1 -#define XED_IFORM_FENI8087_NOP_DEFINED 1 -#define XED_IFORM_FFREE_X87_DEFINED 1 -#define XED_IFORM_FFREEP_X87_DEFINED 1 -#define XED_IFORM_FIADD_ST0_MEMmem16int_DEFINED 1 -#define XED_IFORM_FIADD_ST0_MEMmem32int_DEFINED 1 -#define XED_IFORM_FICOM_ST0_MEMmem16int_DEFINED 1 -#define XED_IFORM_FICOM_ST0_MEMmem32int_DEFINED 1 -#define XED_IFORM_FICOMP_ST0_MEMmem16int_DEFINED 1 -#define XED_IFORM_FICOMP_ST0_MEMmem32int_DEFINED 1 -#define XED_IFORM_FIDIV_ST0_MEMmem16int_DEFINED 1 -#define XED_IFORM_FIDIV_ST0_MEMmem32int_DEFINED 1 -#define XED_IFORM_FIDIVR_ST0_MEMmem16int_DEFINED 1 -#define XED_IFORM_FIDIVR_ST0_MEMmem32int_DEFINED 1 -#define XED_IFORM_FILD_ST0_MEMm64int_DEFINED 1 -#define XED_IFORM_FILD_ST0_MEMmem16int_DEFINED 1 -#define XED_IFORM_FILD_ST0_MEMmem32int_DEFINED 1 -#define XED_IFORM_FIMUL_ST0_MEMmem16int_DEFINED 1 -#define XED_IFORM_FIMUL_ST0_MEMmem32int_DEFINED 1 -#define XED_IFORM_FINCSTP_DEFINED 1 -#define XED_IFORM_FIST_MEMmem16int_ST0_DEFINED 1 -#define XED_IFORM_FIST_MEMmem32int_ST0_DEFINED 1 -#define XED_IFORM_FISTP_MEMm64int_ST0_DEFINED 1 -#define XED_IFORM_FISTP_MEMmem16int_ST0_DEFINED 1 -#define XED_IFORM_FISTP_MEMmem32int_ST0_DEFINED 1 -#define XED_IFORM_FISTTP_MEMm64int_ST0_DEFINED 1 -#define XED_IFORM_FISTTP_MEMmem16int_ST0_DEFINED 1 -#define XED_IFORM_FISTTP_MEMmem32int_ST0_DEFINED 1 -#define XED_IFORM_FISUB_ST0_MEMmem16int_DEFINED 1 -#define XED_IFORM_FISUB_ST0_MEMmem32int_DEFINED 1 -#define XED_IFORM_FISUBR_ST0_MEMmem16int_DEFINED 1 -#define XED_IFORM_FISUBR_ST0_MEMmem32int_DEFINED 1 -#define XED_IFORM_FLD_ST0_MEMm64real_DEFINED 1 -#define XED_IFORM_FLD_ST0_MEMmem32real_DEFINED 1 -#define XED_IFORM_FLD_ST0_MEMmem80real_DEFINED 1 -#define XED_IFORM_FLD_ST0_X87_DEFINED 1 -#define XED_IFORM_FLD1_DEFINED 1 -#define XED_IFORM_FLDCW_MEMmem16_DEFINED 1 -#define XED_IFORM_FLDENV_MEMmem14_DEFINED 1 -#define XED_IFORM_FLDENV_MEMmem28_DEFINED 1 -#define XED_IFORM_FLDL2E_DEFINED 1 -#define XED_IFORM_FLDL2T_DEFINED 1 -#define XED_IFORM_FLDLG2_DEFINED 1 -#define XED_IFORM_FLDLN2_DEFINED 1 -#define XED_IFORM_FLDPI_DEFINED 1 -#define XED_IFORM_FLDZ_DEFINED 1 -#define XED_IFORM_FMUL_ST0_MEMm64real_DEFINED 1 -#define XED_IFORM_FMUL_ST0_MEMmem32real_DEFINED 1 -#define XED_IFORM_FMUL_ST0_X87_DEFINED 1 -#define XED_IFORM_FMUL_X87_ST0_DEFINED 1 -#define XED_IFORM_FMULP_X87_ST0_DEFINED 1 -#define XED_IFORM_FNCLEX_DEFINED 1 -#define XED_IFORM_FNINIT_DEFINED 1 -#define XED_IFORM_FNOP_DEFINED 1 -#define XED_IFORM_FNSAVE_MEMmem108_DEFINED 1 -#define XED_IFORM_FNSAVE_MEMmem94_DEFINED 1 -#define XED_IFORM_FNSTCW_MEMmem16_DEFINED 1 -#define XED_IFORM_FNSTENV_MEMmem14_DEFINED 1 -#define XED_IFORM_FNSTENV_MEMmem28_DEFINED 1 -#define XED_IFORM_FNSTSW_AX_DEFINED 1 -#define XED_IFORM_FNSTSW_MEMmem16_DEFINED 1 -#define XED_IFORM_FPATAN_DEFINED 1 -#define XED_IFORM_FPREM_DEFINED 1 -#define XED_IFORM_FPREM1_DEFINED 1 -#define XED_IFORM_FPTAN_DEFINED 1 -#define XED_IFORM_FRNDINT_DEFINED 1 -#define XED_IFORM_FRSTOR_MEMmem108_DEFINED 1 -#define XED_IFORM_FRSTOR_MEMmem94_DEFINED 1 -#define XED_IFORM_FSCALE_DEFINED 1 -#define XED_IFORM_FSETPM287_NOP_DEFINED 1 -#define XED_IFORM_FSIN_DEFINED 1 -#define XED_IFORM_FSINCOS_DEFINED 1 -#define XED_IFORM_FSQRT_DEFINED 1 -#define XED_IFORM_FST_MEMm64real_ST0_DEFINED 1 -#define XED_IFORM_FST_MEMmem32real_ST0_DEFINED 1 -#define XED_IFORM_FST_X87_ST0_DEFINED 1 -#define XED_IFORM_FSTP_MEMm64real_ST0_DEFINED 1 -#define XED_IFORM_FSTP_MEMmem32real_ST0_DEFINED 1 -#define XED_IFORM_FSTP_MEMmem80real_ST0_DEFINED 1 -#define XED_IFORM_FSTP_X87_ST0_DEFINED 1 -#define XED_IFORM_FSTP_X87_ST0_DFD0_DEFINED 1 -#define XED_IFORM_FSTP_X87_ST0_DFD1_DEFINED 1 -#define XED_IFORM_FSTPNCE_X87_ST0_DEFINED 1 -#define XED_IFORM_FSUB_ST0_MEMm64real_DEFINED 1 -#define XED_IFORM_FSUB_ST0_MEMmem32real_DEFINED 1 -#define XED_IFORM_FSUB_ST0_X87_DEFINED 1 -#define XED_IFORM_FSUB_X87_ST0_DEFINED 1 -#define XED_IFORM_FSUBP_X87_ST0_DEFINED 1 -#define XED_IFORM_FSUBR_ST0_MEMm64real_DEFINED 1 -#define XED_IFORM_FSUBR_ST0_MEMmem32real_DEFINED 1 -#define XED_IFORM_FSUBR_ST0_X87_DEFINED 1 -#define XED_IFORM_FSUBR_X87_ST0_DEFINED 1 -#define XED_IFORM_FSUBRP_X87_ST0_DEFINED 1 -#define XED_IFORM_FTST_DEFINED 1 -#define XED_IFORM_FUCOM_ST0_X87_DEFINED 1 -#define XED_IFORM_FUCOMI_ST0_X87_DEFINED 1 -#define XED_IFORM_FUCOMIP_ST0_X87_DEFINED 1 -#define XED_IFORM_FUCOMP_ST0_X87_DEFINED 1 -#define XED_IFORM_FUCOMPP_DEFINED 1 -#define XED_IFORM_FWAIT_DEFINED 1 -#define XED_IFORM_FXAM_DEFINED 1 -#define XED_IFORM_FXCH_ST0_X87_DEFINED 1 -#define XED_IFORM_FXCH_ST0_X87_DDC1_DEFINED 1 -#define XED_IFORM_FXCH_ST0_X87_DFC1_DEFINED 1 -#define XED_IFORM_FXRSTOR_MEMmfpxenv_DEFINED 1 -#define XED_IFORM_FXRSTOR64_MEMmfpxenv_DEFINED 1 -#define XED_IFORM_FXSAVE_MEMmfpxenv_DEFINED 1 -#define XED_IFORM_FXSAVE64_MEMmfpxenv_DEFINED 1 -#define XED_IFORM_FXTRACT_DEFINED 1 -#define XED_IFORM_FYL2X_DEFINED 1 -#define XED_IFORM_FYL2XP1_DEFINED 1 -#define XED_IFORM_GETSEC_DEFINED 1 -#define XED_IFORM_GF2P8AFFINEINVQB_XMMu8_MEMu64_IMM8_DEFINED 1 -#define XED_IFORM_GF2P8AFFINEINVQB_XMMu8_XMMu64_IMM8_DEFINED 1 -#define XED_IFORM_GF2P8AFFINEQB_XMMu8_MEMu64_IMM8_DEFINED 1 -#define XED_IFORM_GF2P8AFFINEQB_XMMu8_XMMu64_IMM8_DEFINED 1 -#define XED_IFORM_GF2P8MULB_XMMu8_MEMu8_DEFINED 1 -#define XED_IFORM_GF2P8MULB_XMMu8_XMMu8_DEFINED 1 -#define XED_IFORM_HADDPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_HADDPD_XMMpd_XMMpd_DEFINED 1 -#define XED_IFORM_HADDPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_HADDPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_HLT_DEFINED 1 -#define XED_IFORM_HRESET_IMM8_DEFINED 1 -#define XED_IFORM_HSUBPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_HSUBPD_XMMpd_XMMpd_DEFINED 1 -#define XED_IFORM_HSUBPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_HSUBPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_IDIV_GPR8_DEFINED 1 -#define XED_IFORM_IDIV_GPRv_DEFINED 1 -#define XED_IFORM_IDIV_MEMb_DEFINED 1 -#define XED_IFORM_IDIV_MEMv_DEFINED 1 -#define XED_IFORM_IMUL_GPR8_DEFINED 1 -#define XED_IFORM_IMUL_GPRv_DEFINED 1 -#define XED_IFORM_IMUL_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_IMUL_GPRv_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_IMUL_GPRv_GPRv_IMMz_DEFINED 1 -#define XED_IFORM_IMUL_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_IMUL_GPRv_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_IMUL_GPRv_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_IMUL_MEMb_DEFINED 1 -#define XED_IFORM_IMUL_MEMv_DEFINED 1 -#define XED_IFORM_IN_AL_DX_DEFINED 1 -#define XED_IFORM_IN_AL_IMMb_DEFINED 1 -#define XED_IFORM_IN_OeAX_DX_DEFINED 1 -#define XED_IFORM_IN_OeAX_IMMb_DEFINED 1 -#define XED_IFORM_INC_GPR8_DEFINED 1 -#define XED_IFORM_INC_GPRv_40_DEFINED 1 -#define XED_IFORM_INC_GPRv_FFr0_DEFINED 1 -#define XED_IFORM_INC_MEMb_DEFINED 1 -#define XED_IFORM_INC_MEMv_DEFINED 1 -#define XED_IFORM_INCSSPD_GPR32u8_DEFINED 1 -#define XED_IFORM_INCSSPQ_GPR64u8_DEFINED 1 -#define XED_IFORM_INC_LOCK_MEMb_DEFINED 1 -#define XED_IFORM_INC_LOCK_MEMv_DEFINED 1 -#define XED_IFORM_INSB_DEFINED 1 -#define XED_IFORM_INSD_DEFINED 1 -#define XED_IFORM_INSERTPS_XMMps_MEMd_IMMb_DEFINED 1 -#define XED_IFORM_INSERTPS_XMMps_XMMps_IMMb_DEFINED 1 -#define XED_IFORM_INSERTQ_XMMq_XMMdq_DEFINED 1 -#define XED_IFORM_INSERTQ_XMMq_XMMq_IMMb_IMMb_DEFINED 1 -#define XED_IFORM_INSW_DEFINED 1 -#define XED_IFORM_INT_IMMb_DEFINED 1 -#define XED_IFORM_INT1_DEFINED 1 -#define XED_IFORM_INT3_DEFINED 1 -#define XED_IFORM_INTO_DEFINED 1 -#define XED_IFORM_INVD_DEFINED 1 -#define XED_IFORM_INVEPT_GPR32_MEMdq_DEFINED 1 -#define XED_IFORM_INVEPT_GPR64_MEMdq_DEFINED 1 -#define XED_IFORM_INVLPG_MEMb_DEFINED 1 -#define XED_IFORM_INVLPGA_ArAX_ECX_DEFINED 1 -#define XED_IFORM_INVLPGB_EAX_EDX_ECX_DEFINED 1 -#define XED_IFORM_INVLPGB_RAX_EDX_ECX_DEFINED 1 -#define XED_IFORM_INVPCID_GPR32_MEMdq_DEFINED 1 -#define XED_IFORM_INVPCID_GPR64_MEMdq_DEFINED 1 -#define XED_IFORM_INVVPID_GPR32_MEMdq_DEFINED 1 -#define XED_IFORM_INVVPID_GPR64_MEMdq_DEFINED 1 -#define XED_IFORM_IRET_DEFINED 1 -#define XED_IFORM_IRETD_DEFINED 1 -#define XED_IFORM_IRETQ_DEFINED 1 -#define XED_IFORM_JB_RELBRb_DEFINED 1 -#define XED_IFORM_JB_RELBRd_DEFINED 1 -#define XED_IFORM_JB_RELBRz_DEFINED 1 -#define XED_IFORM_JBE_RELBRb_DEFINED 1 -#define XED_IFORM_JBE_RELBRd_DEFINED 1 -#define XED_IFORM_JBE_RELBRz_DEFINED 1 -#define XED_IFORM_JCXZ_RELBRb_DEFINED 1 -#define XED_IFORM_JECXZ_RELBRb_DEFINED 1 -#define XED_IFORM_JL_RELBRb_DEFINED 1 -#define XED_IFORM_JL_RELBRd_DEFINED 1 -#define XED_IFORM_JL_RELBRz_DEFINED 1 -#define XED_IFORM_JLE_RELBRb_DEFINED 1 -#define XED_IFORM_JLE_RELBRd_DEFINED 1 -#define XED_IFORM_JLE_RELBRz_DEFINED 1 -#define XED_IFORM_JMP_GPRv_DEFINED 1 -#define XED_IFORM_JMP_MEMv_DEFINED 1 -#define XED_IFORM_JMP_RELBRb_DEFINED 1 -#define XED_IFORM_JMP_RELBRd_DEFINED 1 -#define XED_IFORM_JMP_RELBRz_DEFINED 1 -#define XED_IFORM_JMP_FAR_MEMp2_DEFINED 1 -#define XED_IFORM_JMP_FAR_PTRp_IMMw_DEFINED 1 -#define XED_IFORM_JNB_RELBRb_DEFINED 1 -#define XED_IFORM_JNB_RELBRd_DEFINED 1 -#define XED_IFORM_JNB_RELBRz_DEFINED 1 -#define XED_IFORM_JNBE_RELBRb_DEFINED 1 -#define XED_IFORM_JNBE_RELBRd_DEFINED 1 -#define XED_IFORM_JNBE_RELBRz_DEFINED 1 -#define XED_IFORM_JNL_RELBRb_DEFINED 1 -#define XED_IFORM_JNL_RELBRd_DEFINED 1 -#define XED_IFORM_JNL_RELBRz_DEFINED 1 -#define XED_IFORM_JNLE_RELBRb_DEFINED 1 -#define XED_IFORM_JNLE_RELBRd_DEFINED 1 -#define XED_IFORM_JNLE_RELBRz_DEFINED 1 -#define XED_IFORM_JNO_RELBRb_DEFINED 1 -#define XED_IFORM_JNO_RELBRd_DEFINED 1 -#define XED_IFORM_JNO_RELBRz_DEFINED 1 -#define XED_IFORM_JNP_RELBRb_DEFINED 1 -#define XED_IFORM_JNP_RELBRd_DEFINED 1 -#define XED_IFORM_JNP_RELBRz_DEFINED 1 -#define XED_IFORM_JNS_RELBRb_DEFINED 1 -#define XED_IFORM_JNS_RELBRd_DEFINED 1 -#define XED_IFORM_JNS_RELBRz_DEFINED 1 -#define XED_IFORM_JNZ_RELBRb_DEFINED 1 -#define XED_IFORM_JNZ_RELBRd_DEFINED 1 -#define XED_IFORM_JNZ_RELBRz_DEFINED 1 -#define XED_IFORM_JO_RELBRb_DEFINED 1 -#define XED_IFORM_JO_RELBRd_DEFINED 1 -#define XED_IFORM_JO_RELBRz_DEFINED 1 -#define XED_IFORM_JP_RELBRb_DEFINED 1 -#define XED_IFORM_JP_RELBRd_DEFINED 1 -#define XED_IFORM_JP_RELBRz_DEFINED 1 -#define XED_IFORM_JRCXZ_RELBRb_DEFINED 1 -#define XED_IFORM_JS_RELBRb_DEFINED 1 -#define XED_IFORM_JS_RELBRd_DEFINED 1 -#define XED_IFORM_JS_RELBRz_DEFINED 1 -#define XED_IFORM_JZ_RELBRb_DEFINED 1 -#define XED_IFORM_JZ_RELBRd_DEFINED 1 -#define XED_IFORM_JZ_RELBRz_DEFINED 1 -#define XED_IFORM_KADDB_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KADDD_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KADDQ_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KADDW_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KANDB_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KANDD_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KANDNB_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KANDND_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KANDNQ_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KANDNW_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KANDQ_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KANDW_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KMOVB_GPR32u32_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KMOVB_MASKmskw_GPR32u32_AVX512_DEFINED 1 -#define XED_IFORM_KMOVB_MASKmskw_MASKu8_AVX512_DEFINED 1 -#define XED_IFORM_KMOVB_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_KMOVB_MEMu8_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KMOVD_GPR32u32_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KMOVD_MASKmskw_GPR32u32_AVX512_DEFINED 1 -#define XED_IFORM_KMOVD_MASKmskw_MASKu32_AVX512_DEFINED 1 -#define XED_IFORM_KMOVD_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_KMOVD_MEMu32_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KMOVQ_GPR64u64_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KMOVQ_MASKmskw_GPR64u64_AVX512_DEFINED 1 -#define XED_IFORM_KMOVQ_MASKmskw_MASKu64_AVX512_DEFINED 1 -#define XED_IFORM_KMOVQ_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_KMOVQ_MEMu64_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KMOVW_GPR32u32_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KMOVW_MASKmskw_GPR32u32_AVX512_DEFINED 1 -#define XED_IFORM_KMOVW_MASKmskw_MASKu16_AVX512_DEFINED 1 -#define XED_IFORM_KMOVW_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_KMOVW_MEMu16_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KNOTB_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KNOTD_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KNOTQ_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KNOTW_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KORB_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KORD_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KORQ_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KORTESTB_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KORTESTD_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KORTESTQ_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KORTESTW_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KORW_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KSHIFTLB_MASKmskw_MASKmskw_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_KSHIFTLD_MASKmskw_MASKmskw_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_KSHIFTLQ_MASKmskw_MASKmskw_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_KSHIFTLW_MASKmskw_MASKmskw_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_KSHIFTRB_MASKmskw_MASKmskw_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_KSHIFTRD_MASKmskw_MASKmskw_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_KSHIFTRQ_MASKmskw_MASKmskw_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_KSHIFTRW_MASKmskw_MASKmskw_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_KTESTB_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KTESTD_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KTESTQ_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KTESTW_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KUNPCKBW_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KUNPCKDQ_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KUNPCKWD_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KXNORB_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KXNORD_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KXNORQ_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KXNORW_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KXORB_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KXORD_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KXORQ_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_KXORW_MASKmskw_MASKmskw_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_LAHF_DEFINED 1 -#define XED_IFORM_LAR_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_LAR_GPRv_MEMw_DEFINED 1 -#define XED_IFORM_LDDQU_XMMpd_MEMdq_DEFINED 1 -#define XED_IFORM_LDMXCSR_MEMd_DEFINED 1 -#define XED_IFORM_LDS_GPRz_MEMp_DEFINED 1 -#define XED_IFORM_LDTILECFG_MEM_DEFINED 1 -#define XED_IFORM_LEA_GPRv_AGEN_DEFINED 1 -#define XED_IFORM_LEAVE_DEFINED 1 -#define XED_IFORM_LES_GPRz_MEMp_DEFINED 1 -#define XED_IFORM_LFENCE_DEFINED 1 -#define XED_IFORM_LFS_GPRv_MEMp2_DEFINED 1 -#define XED_IFORM_LGDT_MEMs_DEFINED 1 -#define XED_IFORM_LGDT_MEMs64_DEFINED 1 -#define XED_IFORM_LGS_GPRv_MEMp2_DEFINED 1 -#define XED_IFORM_LIDT_MEMs_DEFINED 1 -#define XED_IFORM_LIDT_MEMs64_DEFINED 1 -#define XED_IFORM_LLDT_GPR16_DEFINED 1 -#define XED_IFORM_LLDT_MEMw_DEFINED 1 -#define XED_IFORM_LLWPCB_VGPRyy_DEFINED 1 -#define XED_IFORM_LMSW_GPR16_DEFINED 1 -#define XED_IFORM_LMSW_MEMw_DEFINED 1 -#define XED_IFORM_LOADIWKEY_XMMu8_XMMu8_DEFINED 1 -#define XED_IFORM_LODSB_DEFINED 1 -#define XED_IFORM_LODSD_DEFINED 1 -#define XED_IFORM_LODSQ_DEFINED 1 -#define XED_IFORM_LODSW_DEFINED 1 -#define XED_IFORM_LOOP_RELBRb_DEFINED 1 -#define XED_IFORM_LOOPE_RELBRb_DEFINED 1 -#define XED_IFORM_LOOPNE_RELBRb_DEFINED 1 -#define XED_IFORM_LSL_GPRv_GPRz_DEFINED 1 -#define XED_IFORM_LSL_GPRv_MEMw_DEFINED 1 -#define XED_IFORM_LSS_GPRv_MEMp2_DEFINED 1 -#define XED_IFORM_LTR_GPR16_DEFINED 1 -#define XED_IFORM_LTR_MEMw_DEFINED 1 -#define XED_IFORM_LWPINS_VGPRyy_MEMd_IMMd_DEFINED 1 -#define XED_IFORM_LWPINS_VGPRyy_VGPR32y_IMMd_DEFINED 1 -#define XED_IFORM_LWPVAL_VGPRyy_MEMd_IMMd_DEFINED 1 -#define XED_IFORM_LWPVAL_VGPRyy_VGPR32y_IMMd_DEFINED 1 -#define XED_IFORM_LZCNT_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_LZCNT_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_MASKMOVDQU_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_MASKMOVQ_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_MAXPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_MAXPD_XMMpd_XMMpd_DEFINED 1 -#define XED_IFORM_MAXPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_MAXPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_MAXSD_XMMsd_MEMsd_DEFINED 1 -#define XED_IFORM_MAXSD_XMMsd_XMMsd_DEFINED 1 -#define XED_IFORM_MAXSS_XMMss_MEMss_DEFINED 1 -#define XED_IFORM_MAXSS_XMMss_XMMss_DEFINED 1 -#define XED_IFORM_MCOMMIT_DEFINED 1 -#define XED_IFORM_MFENCE_DEFINED 1 -#define XED_IFORM_MINPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_MINPD_XMMpd_XMMpd_DEFINED 1 -#define XED_IFORM_MINPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_MINPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_MINSD_XMMsd_MEMsd_DEFINED 1 -#define XED_IFORM_MINSD_XMMsd_XMMsd_DEFINED 1 -#define XED_IFORM_MINSS_XMMss_MEMss_DEFINED 1 -#define XED_IFORM_MINSS_XMMss_XMMss_DEFINED 1 -#define XED_IFORM_MONITOR_DEFINED 1 -#define XED_IFORM_MONITORX_DEFINED 1 -#define XED_IFORM_MOV_AL_MEMb_DEFINED 1 -#define XED_IFORM_MOV_GPR8_GPR8_88_DEFINED 1 -#define XED_IFORM_MOV_GPR8_GPR8_8A_DEFINED 1 -#define XED_IFORM_MOV_GPR8_IMMb_B0_DEFINED 1 -#define XED_IFORM_MOV_GPR8_IMMb_C6r0_DEFINED 1 -#define XED_IFORM_MOV_GPR8_MEMb_DEFINED 1 -#define XED_IFORM_MOV_GPRv_GPRv_89_DEFINED 1 -#define XED_IFORM_MOV_GPRv_GPRv_8B_DEFINED 1 -#define XED_IFORM_MOV_GPRv_IMMv_DEFINED 1 -#define XED_IFORM_MOV_GPRv_IMMz_DEFINED 1 -#define XED_IFORM_MOV_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_MOV_GPRv_SEG_DEFINED 1 -#define XED_IFORM_MOV_MEMb_AL_DEFINED 1 -#define XED_IFORM_MOV_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_MOV_MEMb_IMMb_DEFINED 1 -#define XED_IFORM_MOV_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_MOV_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_MOV_MEMv_OrAX_DEFINED 1 -#define XED_IFORM_MOV_MEMw_SEG_DEFINED 1 -#define XED_IFORM_MOV_OrAX_MEMv_DEFINED 1 -#define XED_IFORM_MOV_SEG_GPR16_DEFINED 1 -#define XED_IFORM_MOV_SEG_MEMw_DEFINED 1 -#define XED_IFORM_MOVAPD_MEMpd_XMMpd_DEFINED 1 -#define XED_IFORM_MOVAPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_MOVAPD_XMMpd_XMMpd_0F28_DEFINED 1 -#define XED_IFORM_MOVAPD_XMMpd_XMMpd_0F29_DEFINED 1 -#define XED_IFORM_MOVAPS_MEMps_XMMps_DEFINED 1 -#define XED_IFORM_MOVAPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_MOVAPS_XMMps_XMMps_0F28_DEFINED 1 -#define XED_IFORM_MOVAPS_XMMps_XMMps_0F29_DEFINED 1 -#define XED_IFORM_MOVBE_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_MOVBE_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_MOVD_GPR32_MMXd_DEFINED 1 -#define XED_IFORM_MOVD_GPR32_XMMd_DEFINED 1 -#define XED_IFORM_MOVD_MEMd_MMXd_DEFINED 1 -#define XED_IFORM_MOVD_MEMd_XMMd_DEFINED 1 -#define XED_IFORM_MOVD_MMXq_GPR32_DEFINED 1 -#define XED_IFORM_MOVD_MMXq_MEMd_DEFINED 1 -#define XED_IFORM_MOVD_XMMdq_GPR32_DEFINED 1 -#define XED_IFORM_MOVD_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_MOVDDUP_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_MOVDDUP_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_MOVDIR64B_GPRa_MEM_DEFINED 1 -#define XED_IFORM_MOVDIRI_MEMu32_GPR32u32_DEFINED 1 -#define XED_IFORM_MOVDIRI_MEMu64_GPR64u64_DEFINED 1 -#define XED_IFORM_MOVDQ2Q_MMXq_XMMq_DEFINED 1 -#define XED_IFORM_MOVDQA_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_MOVDQA_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_MOVDQA_XMMdq_XMMdq_0F6F_DEFINED 1 -#define XED_IFORM_MOVDQA_XMMdq_XMMdq_0F7F_DEFINED 1 -#define XED_IFORM_MOVDQU_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_MOVDQU_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_MOVDQU_XMMdq_XMMdq_0F6F_DEFINED 1 -#define XED_IFORM_MOVDQU_XMMdq_XMMdq_0F7F_DEFINED 1 -#define XED_IFORM_MOVHLPS_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_MOVHPD_MEMq_XMMsd_DEFINED 1 -#define XED_IFORM_MOVHPD_XMMsd_MEMq_DEFINED 1 -#define XED_IFORM_MOVHPS_MEMq_XMMps_DEFINED 1 -#define XED_IFORM_MOVHPS_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_MOVLHPS_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_MOVLPD_MEMq_XMMsd_DEFINED 1 -#define XED_IFORM_MOVLPD_XMMsd_MEMq_DEFINED 1 -#define XED_IFORM_MOVLPS_MEMq_XMMq_DEFINED 1 -#define XED_IFORM_MOVLPS_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_MOVMSKPD_GPR32_XMMpd_DEFINED 1 -#define XED_IFORM_MOVMSKPS_GPR32_XMMps_DEFINED 1 -#define XED_IFORM_MOVNTDQ_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_MOVNTDQA_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_MOVNTI_MEMd_GPR32_DEFINED 1 -#define XED_IFORM_MOVNTI_MEMq_GPR64_DEFINED 1 -#define XED_IFORM_MOVNTPD_MEMdq_XMMpd_DEFINED 1 -#define XED_IFORM_MOVNTPS_MEMdq_XMMps_DEFINED 1 -#define XED_IFORM_MOVNTQ_MEMq_MMXq_DEFINED 1 -#define XED_IFORM_MOVNTSD_MEMq_XMMq_DEFINED 1 -#define XED_IFORM_MOVNTSS_MEMd_XMMd_DEFINED 1 -#define XED_IFORM_MOVQ_GPR64_MMXq_DEFINED 1 -#define XED_IFORM_MOVQ_GPR64_XMMq_DEFINED 1 -#define XED_IFORM_MOVQ_MEMq_MMXq_0F7E_DEFINED 1 -#define XED_IFORM_MOVQ_MEMq_MMXq_0F7F_DEFINED 1 -#define XED_IFORM_MOVQ_MEMq_XMMq_0F7E_DEFINED 1 -#define XED_IFORM_MOVQ_MEMq_XMMq_0FD6_DEFINED 1 -#define XED_IFORM_MOVQ_MMXq_GPR64_DEFINED 1 -#define XED_IFORM_MOVQ_MMXq_MEMq_0F6E_DEFINED 1 -#define XED_IFORM_MOVQ_MMXq_MEMq_0F6F_DEFINED 1 -#define XED_IFORM_MOVQ_MMXq_MMXq_0F6F_DEFINED 1 -#define XED_IFORM_MOVQ_MMXq_MMXq_0F7F_DEFINED 1 -#define XED_IFORM_MOVQ_XMMdq_GPR64_DEFINED 1 -#define XED_IFORM_MOVQ_XMMdq_MEMq_0F6E_DEFINED 1 -#define XED_IFORM_MOVQ_XMMdq_MEMq_0F7E_DEFINED 1 -#define XED_IFORM_MOVQ_XMMdq_XMMq_0F7E_DEFINED 1 -#define XED_IFORM_MOVQ_XMMdq_XMMq_0FD6_DEFINED 1 -#define XED_IFORM_MOVQ2DQ_XMMdq_MMXq_DEFINED 1 -#define XED_IFORM_MOVSB_DEFINED 1 -#define XED_IFORM_MOVSD_DEFINED 1 -#define XED_IFORM_MOVSD_XMM_MEMsd_XMMsd_DEFINED 1 -#define XED_IFORM_MOVSD_XMM_XMMdq_MEMsd_DEFINED 1 -#define XED_IFORM_MOVSD_XMM_XMMsd_XMMsd_0F10_DEFINED 1 -#define XED_IFORM_MOVSD_XMM_XMMsd_XMMsd_0F11_DEFINED 1 -#define XED_IFORM_MOVSHDUP_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_MOVSHDUP_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_MOVSLDUP_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_MOVSLDUP_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_MOVSQ_DEFINED 1 -#define XED_IFORM_MOVSS_MEMss_XMMss_DEFINED 1 -#define XED_IFORM_MOVSS_XMMdq_MEMss_DEFINED 1 -#define XED_IFORM_MOVSS_XMMss_XMMss_0F10_DEFINED 1 -#define XED_IFORM_MOVSS_XMMss_XMMss_0F11_DEFINED 1 -#define XED_IFORM_MOVSW_DEFINED 1 -#define XED_IFORM_MOVSX_GPRv_GPR16_DEFINED 1 -#define XED_IFORM_MOVSX_GPRv_GPR8_DEFINED 1 -#define XED_IFORM_MOVSX_GPRv_MEMb_DEFINED 1 -#define XED_IFORM_MOVSX_GPRv_MEMw_DEFINED 1 -#define XED_IFORM_MOVSXD_GPRv_GPRz_DEFINED 1 -#define XED_IFORM_MOVSXD_GPRv_MEMz_DEFINED 1 -#define XED_IFORM_MOVUPD_MEMpd_XMMpd_DEFINED 1 -#define XED_IFORM_MOVUPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_MOVUPD_XMMpd_XMMpd_0F10_DEFINED 1 -#define XED_IFORM_MOVUPD_XMMpd_XMMpd_0F11_DEFINED 1 -#define XED_IFORM_MOVUPS_MEMps_XMMps_DEFINED 1 -#define XED_IFORM_MOVUPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_MOVUPS_XMMps_XMMps_0F10_DEFINED 1 -#define XED_IFORM_MOVUPS_XMMps_XMMps_0F11_DEFINED 1 -#define XED_IFORM_MOVZX_GPRv_GPR16_DEFINED 1 -#define XED_IFORM_MOVZX_GPRv_GPR8_DEFINED 1 -#define XED_IFORM_MOVZX_GPRv_MEMb_DEFINED 1 -#define XED_IFORM_MOVZX_GPRv_MEMw_DEFINED 1 -#define XED_IFORM_MOV_CR_CR_GPR32_DEFINED 1 -#define XED_IFORM_MOV_CR_CR_GPR64_DEFINED 1 -#define XED_IFORM_MOV_CR_GPR32_CR_DEFINED 1 -#define XED_IFORM_MOV_CR_GPR64_CR_DEFINED 1 -#define XED_IFORM_MOV_DR_DR_GPR32_DEFINED 1 -#define XED_IFORM_MOV_DR_DR_GPR64_DEFINED 1 -#define XED_IFORM_MOV_DR_GPR32_DR_DEFINED 1 -#define XED_IFORM_MOV_DR_GPR64_DR_DEFINED 1 -#define XED_IFORM_MPSADBW_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_MPSADBW_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_MUL_GPR8_DEFINED 1 -#define XED_IFORM_MUL_GPRv_DEFINED 1 -#define XED_IFORM_MUL_MEMb_DEFINED 1 -#define XED_IFORM_MUL_MEMv_DEFINED 1 -#define XED_IFORM_MULPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_MULPD_XMMpd_XMMpd_DEFINED 1 -#define XED_IFORM_MULPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_MULPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_MULSD_XMMsd_MEMsd_DEFINED 1 -#define XED_IFORM_MULSD_XMMsd_XMMsd_DEFINED 1 -#define XED_IFORM_MULSS_XMMss_MEMss_DEFINED 1 -#define XED_IFORM_MULSS_XMMss_XMMss_DEFINED 1 -#define XED_IFORM_MULX_VGPR32d_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_MULX_VGPR32d_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_MULX_VGPR64q_VGPR64q_MEMq_DEFINED 1 -#define XED_IFORM_MULX_VGPR64q_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_MWAIT_DEFINED 1 -#define XED_IFORM_MWAITX_DEFINED 1 -#define XED_IFORM_NEG_GPR8_DEFINED 1 -#define XED_IFORM_NEG_GPRv_DEFINED 1 -#define XED_IFORM_NEG_MEMb_DEFINED 1 -#define XED_IFORM_NEG_MEMv_DEFINED 1 -#define XED_IFORM_NEG_LOCK_MEMb_DEFINED 1 -#define XED_IFORM_NEG_LOCK_MEMv_DEFINED 1 -#define XED_IFORM_NOP_90_DEFINED 1 -#define XED_IFORM_NOP_GPRv_0F18r0_DEFINED 1 -#define XED_IFORM_NOP_GPRv_0F18r1_DEFINED 1 -#define XED_IFORM_NOP_GPRv_0F18r2_DEFINED 1 -#define XED_IFORM_NOP_GPRv_0F18r3_DEFINED 1 -#define XED_IFORM_NOP_GPRv_0F18r4_DEFINED 1 -#define XED_IFORM_NOP_GPRv_0F18r5_DEFINED 1 -#define XED_IFORM_NOP_GPRv_0F18r6_DEFINED 1 -#define XED_IFORM_NOP_GPRv_0F18r7_DEFINED 1 -#define XED_IFORM_NOP_GPRv_GPRv_0F0D_DEFINED 1 -#define XED_IFORM_NOP_GPRv_GPRv_0F19_DEFINED 1 -#define XED_IFORM_NOP_GPRv_GPRv_0F1A_DEFINED 1 -#define XED_IFORM_NOP_GPRv_GPRv_0F1B_DEFINED 1 -#define XED_IFORM_NOP_GPRv_GPRv_0F1C_DEFINED 1 -#define XED_IFORM_NOP_GPRv_GPRv_0F1D_DEFINED 1 -#define XED_IFORM_NOP_GPRv_GPRv_0F1E_DEFINED 1 -#define XED_IFORM_NOP_GPRv_GPRv_0F1F_DEFINED 1 -#define XED_IFORM_NOP_GPRv_MEM_0F1B_DEFINED 1 -#define XED_IFORM_NOP_GPRv_MEMv_0F1A_DEFINED 1 -#define XED_IFORM_NOP_MEMv_0F18r4_DEFINED 1 -#define XED_IFORM_NOP_MEMv_0F18r5_DEFINED 1 -#define XED_IFORM_NOP_MEMv_0F18r6_DEFINED 1 -#define XED_IFORM_NOP_MEMv_0F18r7_DEFINED 1 -#define XED_IFORM_NOP_MEMv_GPRv_0F19_DEFINED 1 -#define XED_IFORM_NOP_MEMv_GPRv_0F1C_DEFINED 1 -#define XED_IFORM_NOP_MEMv_GPRv_0F1D_DEFINED 1 -#define XED_IFORM_NOP_MEMv_GPRv_0F1E_DEFINED 1 -#define XED_IFORM_NOP_MEMv_GPRv_0F1F_DEFINED 1 -#define XED_IFORM_NOT_GPR8_DEFINED 1 -#define XED_IFORM_NOT_GPRv_DEFINED 1 -#define XED_IFORM_NOT_MEMb_DEFINED 1 -#define XED_IFORM_NOT_MEMv_DEFINED 1 -#define XED_IFORM_NOT_LOCK_MEMb_DEFINED 1 -#define XED_IFORM_NOT_LOCK_MEMv_DEFINED 1 -#define XED_IFORM_OR_AL_IMMb_DEFINED 1 -#define XED_IFORM_OR_GPR8_GPR8_08_DEFINED 1 -#define XED_IFORM_OR_GPR8_GPR8_0A_DEFINED 1 -#define XED_IFORM_OR_GPR8_IMMb_80r1_DEFINED 1 -#define XED_IFORM_OR_GPR8_IMMb_82r1_DEFINED 1 -#define XED_IFORM_OR_GPR8_MEMb_DEFINED 1 -#define XED_IFORM_OR_GPRv_GPRv_09_DEFINED 1 -#define XED_IFORM_OR_GPRv_GPRv_0B_DEFINED 1 -#define XED_IFORM_OR_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_OR_GPRv_IMMz_DEFINED 1 -#define XED_IFORM_OR_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_OR_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_OR_MEMb_IMMb_80r1_DEFINED 1 -#define XED_IFORM_OR_MEMb_IMMb_82r1_DEFINED 1 -#define XED_IFORM_OR_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_OR_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_OR_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_OR_OrAX_IMMz_DEFINED 1 -#define XED_IFORM_ORPD_XMMxuq_MEMxuq_DEFINED 1 -#define XED_IFORM_ORPD_XMMxuq_XMMxuq_DEFINED 1 -#define XED_IFORM_ORPS_XMMxud_MEMxud_DEFINED 1 -#define XED_IFORM_ORPS_XMMxud_XMMxud_DEFINED 1 -#define XED_IFORM_OR_LOCK_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_OR_LOCK_MEMb_IMMb_80r1_DEFINED 1 -#define XED_IFORM_OR_LOCK_MEMb_IMMb_82r1_DEFINED 1 -#define XED_IFORM_OR_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_OR_LOCK_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_OR_LOCK_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_OUT_DX_AL_DEFINED 1 -#define XED_IFORM_OUT_DX_OeAX_DEFINED 1 -#define XED_IFORM_OUT_IMMb_AL_DEFINED 1 -#define XED_IFORM_OUT_IMMb_OeAX_DEFINED 1 -#define XED_IFORM_OUTSB_DEFINED 1 -#define XED_IFORM_OUTSD_DEFINED 1 -#define XED_IFORM_OUTSW_DEFINED 1 -#define XED_IFORM_PABSB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PABSB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PABSB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PABSB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PABSD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PABSD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PABSD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PABSD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PABSW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PABSW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PABSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PABSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PACKSSDW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PACKSSDW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PACKSSDW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PACKSSDW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PACKSSWB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PACKSSWB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PACKSSWB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PACKSSWB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PACKUSDW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PACKUSDW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PACKUSWB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PACKUSWB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PACKUSWB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PACKUSWB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PADDB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PADDB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PADDB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PADDB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PADDD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PADDD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PADDD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PADDD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PADDQ_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PADDQ_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PADDQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PADDQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PADDSB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PADDSB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PADDSB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PADDSB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PADDSW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PADDSW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PADDSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PADDSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PADDUSB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PADDUSB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PADDUSB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PADDUSB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PADDUSW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PADDUSW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PADDUSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PADDUSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PADDW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PADDW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PADDW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PADDW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PALIGNR_MMXq_MEMq_IMMb_DEFINED 1 -#define XED_IFORM_PALIGNR_MMXq_MMXq_IMMb_DEFINED 1 -#define XED_IFORM_PALIGNR_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PALIGNR_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PAND_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PAND_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PAND_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PAND_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PANDN_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PANDN_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PANDN_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PANDN_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PAUSE_DEFINED 1 -#define XED_IFORM_PAVGB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PAVGB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PAVGB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PAVGB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PAVGUSB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PAVGUSB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PAVGW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PAVGW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PAVGW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PAVGW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PBLENDVB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PBLENDVB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PBLENDW_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PBLENDW_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCLMULQDQ_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCLMULQDQ_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPEQB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PCMPEQB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PCMPEQB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PCMPEQB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PCMPEQD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PCMPEQD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PCMPEQD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PCMPEQD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PCMPEQQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PCMPEQQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PCMPEQW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PCMPEQW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PCMPEQW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PCMPEQW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PCMPESTRI_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPESTRI_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPESTRI64_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPESTRI64_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPESTRM_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPESTRM_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPESTRM64_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPESTRM64_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPGTB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PCMPGTB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PCMPGTB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PCMPGTB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PCMPGTD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PCMPGTD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PCMPGTD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PCMPGTD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PCMPGTQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PCMPGTQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PCMPGTW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PCMPGTW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PCMPGTW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PCMPGTW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PCMPISTRI_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPISTRI_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPISTRI64_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPISTRI64_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPISTRM_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCMPISTRM_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PCONFIG_DEFINED 1 -#define XED_IFORM_PCONFIG64_DEFINED 1 -#define XED_IFORM_PDEP_VGPR32d_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_PDEP_VGPR32d_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_PDEP_VGPR64q_VGPR64q_MEMq_DEFINED 1 -#define XED_IFORM_PDEP_VGPR64q_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_PEXT_VGPR32d_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_PEXT_VGPR32d_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_PEXT_VGPR64q_VGPR64q_MEMq_DEFINED 1 -#define XED_IFORM_PEXT_VGPR64q_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_PEXTRB_GPR32d_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PEXTRB_MEMb_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PEXTRD_GPR32d_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PEXTRD_MEMd_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PEXTRQ_GPR64q_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PEXTRQ_MEMq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PEXTRW_GPR32_MMXq_IMMb_DEFINED 1 -#define XED_IFORM_PEXTRW_GPR32_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PEXTRW_SSE4_GPR32_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PEXTRW_SSE4_MEMw_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PF2ID_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PF2ID_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PF2IW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PF2IW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFACC_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFACC_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFADD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFADD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFCMPEQ_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFCMPEQ_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFCMPGE_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFCMPGE_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFCMPGT_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFCMPGT_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFMAX_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFMAX_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFMIN_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFMIN_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFMUL_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFMUL_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFNACC_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFNACC_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFPNACC_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFPNACC_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFRCP_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFRCP_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFRCPIT1_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFRCPIT1_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFRCPIT2_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFRCPIT2_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFRSQIT1_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFRSQIT1_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFRSQRT_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFRSQRT_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFSUB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFSUB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PFSUBR_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PFSUBR_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PHADDD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PHADDD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PHADDD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PHADDD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PHADDSW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PHADDSW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PHADDSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PHADDSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PHADDW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PHADDW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PHADDW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PHADDW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PHMINPOSUW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PHMINPOSUW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PHSUBD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PHSUBD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PHSUBD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PHSUBD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PHSUBSW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PHSUBSW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PHSUBSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PHSUBSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PHSUBW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PHSUBW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PHSUBW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PHSUBW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PI2FD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PI2FD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PI2FW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PI2FW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PINSRB_XMMdq_GPR32d_IMMb_DEFINED 1 -#define XED_IFORM_PINSRB_XMMdq_MEMb_IMMb_DEFINED 1 -#define XED_IFORM_PINSRD_XMMdq_GPR32d_IMMb_DEFINED 1 -#define XED_IFORM_PINSRD_XMMdq_MEMd_IMMb_DEFINED 1 -#define XED_IFORM_PINSRQ_XMMdq_GPR64q_IMMb_DEFINED 1 -#define XED_IFORM_PINSRQ_XMMdq_MEMq_IMMb_DEFINED 1 -#define XED_IFORM_PINSRW_MMXq_GPR32_IMMb_DEFINED 1 -#define XED_IFORM_PINSRW_MMXq_MEMw_IMMb_DEFINED 1 -#define XED_IFORM_PINSRW_XMMdq_GPR32_IMMb_DEFINED 1 -#define XED_IFORM_PINSRW_XMMdq_MEMw_IMMb_DEFINED 1 -#define XED_IFORM_PMADDUBSW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMADDUBSW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMADDUBSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMADDUBSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMADDWD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMADDWD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMADDWD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMADDWD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMAXSB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMAXSB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMAXSD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMAXSD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMAXSW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMAXSW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMAXSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMAXSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMAXUB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMAXUB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMAXUB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMAXUB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMAXUD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMAXUD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMAXUW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMAXUW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMINSB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMINSB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMINSD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMINSD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMINSW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMINSW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMINSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMINSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMINUB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMINUB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMINUB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMINUB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMINUD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMINUD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMINUW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMINUW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMOVMSKB_GPR32_MMXq_DEFINED 1 -#define XED_IFORM_PMOVMSKB_GPR32_XMMdq_DEFINED 1 -#define XED_IFORM_PMOVSXBD_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_PMOVSXBD_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_PMOVSXBQ_XMMdq_MEMw_DEFINED 1 -#define XED_IFORM_PMOVSXBQ_XMMdq_XMMw_DEFINED 1 -#define XED_IFORM_PMOVSXBW_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_PMOVSXBW_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PMOVSXDQ_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_PMOVSXDQ_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PMOVSXWD_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_PMOVSXWD_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PMOVSXWQ_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_PMOVSXWQ_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_PMOVZXBD_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_PMOVZXBD_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_PMOVZXBQ_XMMdq_MEMw_DEFINED 1 -#define XED_IFORM_PMOVZXBQ_XMMdq_XMMw_DEFINED 1 -#define XED_IFORM_PMOVZXBW_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_PMOVZXBW_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PMOVZXDQ_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_PMOVZXDQ_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PMOVZXWD_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_PMOVZXWD_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PMOVZXWQ_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_PMOVZXWQ_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_PMULDQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMULDQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMULHRSW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMULHRSW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMULHRSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMULHRSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMULHRW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMULHRW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMULHUW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMULHUW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMULHUW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMULHUW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMULHW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMULHW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMULHW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMULHW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMULLD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMULLD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMULLW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMULLW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMULLW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMULLW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PMULUDQ_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PMULUDQ_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PMULUDQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PMULUDQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_POP_DS_DEFINED 1 -#define XED_IFORM_POP_ES_DEFINED 1 -#define XED_IFORM_POP_FS_DEFINED 1 -#define XED_IFORM_POP_GPRv_58_DEFINED 1 -#define XED_IFORM_POP_GPRv_8F_DEFINED 1 -#define XED_IFORM_POP_GS_DEFINED 1 -#define XED_IFORM_POP_MEMv_DEFINED 1 -#define XED_IFORM_POP_SS_DEFINED 1 -#define XED_IFORM_POPA_DEFINED 1 -#define XED_IFORM_POPAD_DEFINED 1 -#define XED_IFORM_POPCNT_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_POPCNT_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_POPF_DEFINED 1 -#define XED_IFORM_POPFD_DEFINED 1 -#define XED_IFORM_POPFQ_DEFINED 1 -#define XED_IFORM_POR_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_POR_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_POR_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_POR_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PREFETCHNTA_MEMmprefetch_DEFINED 1 -#define XED_IFORM_PREFETCHT0_MEMmprefetch_DEFINED 1 -#define XED_IFORM_PREFETCHT1_MEMmprefetch_DEFINED 1 -#define XED_IFORM_PREFETCHT2_MEMmprefetch_DEFINED 1 -#define XED_IFORM_PREFETCHW_0F0Dr1_DEFINED 1 -#define XED_IFORM_PREFETCHW_0F0Dr3_DEFINED 1 -#define XED_IFORM_PREFETCHWT1_MEMu8_DEFINED 1 -#define XED_IFORM_PREFETCH_EXCLUSIVE_MEMmprefetch_DEFINED 1 -#define XED_IFORM_PREFETCH_RESERVED_0F0Dr4_DEFINED 1 -#define XED_IFORM_PREFETCH_RESERVED_0F0Dr5_DEFINED 1 -#define XED_IFORM_PREFETCH_RESERVED_0F0Dr6_DEFINED 1 -#define XED_IFORM_PREFETCH_RESERVED_0F0Dr7_DEFINED 1 -#define XED_IFORM_PSADBW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSADBW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSADBW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSADBW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSHUFB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSHUFB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSHUFB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSHUFB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSHUFD_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSHUFD_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSHUFHW_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSHUFHW_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSHUFLW_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSHUFLW_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSHUFW_MMXq_MEMq_IMMb_DEFINED 1 -#define XED_IFORM_PSHUFW_MMXq_MMXq_IMMb_DEFINED 1 -#define XED_IFORM_PSIGNB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSIGNB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSIGNB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSIGNB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSIGND_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSIGND_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSIGND_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSIGND_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSIGNW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSIGNW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSIGNW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSIGNW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSLLD_MMXq_IMMb_DEFINED 1 -#define XED_IFORM_PSLLD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSLLD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSLLD_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSLLD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSLLD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSLLDQ_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSLLQ_MMXq_IMMb_DEFINED 1 -#define XED_IFORM_PSLLQ_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSLLQ_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSLLQ_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSLLQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSLLQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSLLW_MMXq_IMMb_DEFINED 1 -#define XED_IFORM_PSLLW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSLLW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSLLW_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSLLW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSLLW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSMASH_RAX_DEFINED 1 -#define XED_IFORM_PSRAD_MMXq_IMMb_DEFINED 1 -#define XED_IFORM_PSRAD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSRAD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSRAD_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSRAD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSRAD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSRAW_MMXq_IMMb_DEFINED 1 -#define XED_IFORM_PSRAW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSRAW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSRAW_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSRAW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSRAW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSRLD_MMXq_IMMb_DEFINED 1 -#define XED_IFORM_PSRLD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSRLD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSRLD_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSRLD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSRLD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSRLDQ_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSRLQ_MMXq_IMMb_DEFINED 1 -#define XED_IFORM_PSRLQ_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSRLQ_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSRLQ_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSRLQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSRLQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSRLW_MMXq_IMMb_DEFINED 1 -#define XED_IFORM_PSRLW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSRLW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSRLW_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_PSRLW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSRLW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSUBB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSUBB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSUBB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSUBB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSUBD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSUBD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSUBD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSUBD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSUBQ_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSUBQ_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSUBQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSUBQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSUBSB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSUBSB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSUBSB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSUBSB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSUBSW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSUBSW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSUBSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSUBSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSUBUSB_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSUBUSB_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSUBUSB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSUBUSB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSUBUSW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSUBUSW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSUBUSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSUBUSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSUBW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSUBW_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PSUBW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PSUBW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PSWAPD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PSWAPD_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PTEST_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PTEST_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_PTWRITE_GPRy_DEFINED 1 -#define XED_IFORM_PTWRITE_MEMy_DEFINED 1 -#define XED_IFORM_PUNPCKHBW_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PUNPCKHBW_MMXq_MMXd_DEFINED 1 -#define XED_IFORM_PUNPCKHBW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PUNPCKHBW_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PUNPCKHDQ_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PUNPCKHDQ_MMXq_MMXd_DEFINED 1 -#define XED_IFORM_PUNPCKHDQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PUNPCKHDQ_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PUNPCKHQDQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PUNPCKHQDQ_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PUNPCKHWD_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PUNPCKHWD_MMXq_MMXd_DEFINED 1 -#define XED_IFORM_PUNPCKHWD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PUNPCKHWD_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PUNPCKLBW_MMXq_MEMd_DEFINED 1 -#define XED_IFORM_PUNPCKLBW_MMXq_MMXd_DEFINED 1 -#define XED_IFORM_PUNPCKLBW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PUNPCKLBW_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PUNPCKLDQ_MMXq_MEMd_DEFINED 1 -#define XED_IFORM_PUNPCKLDQ_MMXq_MMXd_DEFINED 1 -#define XED_IFORM_PUNPCKLDQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PUNPCKLDQ_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PUNPCKLQDQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PUNPCKLQDQ_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PUNPCKLWD_MMXq_MEMd_DEFINED 1 -#define XED_IFORM_PUNPCKLWD_MMXq_MMXd_DEFINED 1 -#define XED_IFORM_PUNPCKLWD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PUNPCKLWD_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_PUSH_CS_DEFINED 1 -#define XED_IFORM_PUSH_DS_DEFINED 1 -#define XED_IFORM_PUSH_ES_DEFINED 1 -#define XED_IFORM_PUSH_FS_DEFINED 1 -#define XED_IFORM_PUSH_GPRv_50_DEFINED 1 -#define XED_IFORM_PUSH_GPRv_FFr6_DEFINED 1 -#define XED_IFORM_PUSH_GS_DEFINED 1 -#define XED_IFORM_PUSH_IMMb_DEFINED 1 -#define XED_IFORM_PUSH_IMMz_DEFINED 1 -#define XED_IFORM_PUSH_MEMv_DEFINED 1 -#define XED_IFORM_PUSH_SS_DEFINED 1 -#define XED_IFORM_PUSHA_DEFINED 1 -#define XED_IFORM_PUSHAD_DEFINED 1 -#define XED_IFORM_PUSHF_DEFINED 1 -#define XED_IFORM_PUSHFD_DEFINED 1 -#define XED_IFORM_PUSHFQ_DEFINED 1 -#define XED_IFORM_PVALIDATE_RAX_ECX_EDX_DEFINED 1 -#define XED_IFORM_PXOR_MMXq_MEMq_DEFINED 1 -#define XED_IFORM_PXOR_MMXq_MMXq_DEFINED 1 -#define XED_IFORM_PXOR_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_PXOR_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_RCL_GPR8_CL_DEFINED 1 -#define XED_IFORM_RCL_GPR8_IMMb_DEFINED 1 -#define XED_IFORM_RCL_GPR8_ONE_DEFINED 1 -#define XED_IFORM_RCL_GPRv_CL_DEFINED 1 -#define XED_IFORM_RCL_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_RCL_GPRv_ONE_DEFINED 1 -#define XED_IFORM_RCL_MEMb_CL_DEFINED 1 -#define XED_IFORM_RCL_MEMb_IMMb_DEFINED 1 -#define XED_IFORM_RCL_MEMb_ONE_DEFINED 1 -#define XED_IFORM_RCL_MEMv_CL_DEFINED 1 -#define XED_IFORM_RCL_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_RCL_MEMv_ONE_DEFINED 1 -#define XED_IFORM_RCPPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_RCPPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_RCPSS_XMMss_MEMss_DEFINED 1 -#define XED_IFORM_RCPSS_XMMss_XMMss_DEFINED 1 -#define XED_IFORM_RCR_GPR8_CL_DEFINED 1 -#define XED_IFORM_RCR_GPR8_IMMb_DEFINED 1 -#define XED_IFORM_RCR_GPR8_ONE_DEFINED 1 -#define XED_IFORM_RCR_GPRv_CL_DEFINED 1 -#define XED_IFORM_RCR_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_RCR_GPRv_ONE_DEFINED 1 -#define XED_IFORM_RCR_MEMb_CL_DEFINED 1 -#define XED_IFORM_RCR_MEMb_IMMb_DEFINED 1 -#define XED_IFORM_RCR_MEMb_ONE_DEFINED 1 -#define XED_IFORM_RCR_MEMv_CL_DEFINED 1 -#define XED_IFORM_RCR_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_RCR_MEMv_ONE_DEFINED 1 -#define XED_IFORM_RDFSBASE_GPRy_DEFINED 1 -#define XED_IFORM_RDGSBASE_GPRy_DEFINED 1 -#define XED_IFORM_RDMSR_DEFINED 1 -#define XED_IFORM_RDPID_GPR32u32_DEFINED 1 -#define XED_IFORM_RDPID_GPR64u64_DEFINED 1 -#define XED_IFORM_RDPKRU_DEFINED 1 -#define XED_IFORM_RDPMC_DEFINED 1 -#define XED_IFORM_RDPRU_DEFINED 1 -#define XED_IFORM_RDRAND_GPRv_DEFINED 1 -#define XED_IFORM_RDSEED_GPRv_DEFINED 1 -#define XED_IFORM_RDSSPD_GPR32u32_DEFINED 1 -#define XED_IFORM_RDSSPQ_GPR64u64_DEFINED 1 -#define XED_IFORM_RDTSC_DEFINED 1 -#define XED_IFORM_RDTSCP_DEFINED 1 -#define XED_IFORM_REPE_CMPSB_DEFINED 1 -#define XED_IFORM_REPE_CMPSD_DEFINED 1 -#define XED_IFORM_REPE_CMPSQ_DEFINED 1 -#define XED_IFORM_REPE_CMPSW_DEFINED 1 -#define XED_IFORM_REPE_SCASB_DEFINED 1 -#define XED_IFORM_REPE_SCASD_DEFINED 1 -#define XED_IFORM_REPE_SCASQ_DEFINED 1 -#define XED_IFORM_REPE_SCASW_DEFINED 1 -#define XED_IFORM_REPNE_CMPSB_DEFINED 1 -#define XED_IFORM_REPNE_CMPSD_DEFINED 1 -#define XED_IFORM_REPNE_CMPSQ_DEFINED 1 -#define XED_IFORM_REPNE_CMPSW_DEFINED 1 -#define XED_IFORM_REPNE_SCASB_DEFINED 1 -#define XED_IFORM_REPNE_SCASD_DEFINED 1 -#define XED_IFORM_REPNE_SCASQ_DEFINED 1 -#define XED_IFORM_REPNE_SCASW_DEFINED 1 -#define XED_IFORM_REP_INSB_DEFINED 1 -#define XED_IFORM_REP_INSD_DEFINED 1 -#define XED_IFORM_REP_INSW_DEFINED 1 -#define XED_IFORM_REP_LODSB_DEFINED 1 -#define XED_IFORM_REP_LODSD_DEFINED 1 -#define XED_IFORM_REP_LODSQ_DEFINED 1 -#define XED_IFORM_REP_LODSW_DEFINED 1 -#define XED_IFORM_REP_MONTMUL_DEFINED 1 -#define XED_IFORM_REP_MOVSB_DEFINED 1 -#define XED_IFORM_REP_MOVSD_DEFINED 1 -#define XED_IFORM_REP_MOVSQ_DEFINED 1 -#define XED_IFORM_REP_MOVSW_DEFINED 1 -#define XED_IFORM_REP_OUTSB_DEFINED 1 -#define XED_IFORM_REP_OUTSD_DEFINED 1 -#define XED_IFORM_REP_OUTSW_DEFINED 1 -#define XED_IFORM_REP_STOSB_DEFINED 1 -#define XED_IFORM_REP_STOSD_DEFINED 1 -#define XED_IFORM_REP_STOSQ_DEFINED 1 -#define XED_IFORM_REP_STOSW_DEFINED 1 -#define XED_IFORM_REP_XCRYPTCBC_DEFINED 1 -#define XED_IFORM_REP_XCRYPTCFB_DEFINED 1 -#define XED_IFORM_REP_XCRYPTCTR_DEFINED 1 -#define XED_IFORM_REP_XCRYPTECB_DEFINED 1 -#define XED_IFORM_REP_XCRYPTOFB_DEFINED 1 -#define XED_IFORM_REP_XSHA1_DEFINED 1 -#define XED_IFORM_REP_XSHA256_DEFINED 1 -#define XED_IFORM_REP_XSTORE_DEFINED 1 -#define XED_IFORM_RET_FAR_DEFINED 1 -#define XED_IFORM_RET_FAR_IMMw_DEFINED 1 -#define XED_IFORM_RET_NEAR_DEFINED 1 -#define XED_IFORM_RET_NEAR_IMMw_DEFINED 1 -#define XED_IFORM_RMPADJUST_RAX_RCX_RDX_DEFINED 1 -#define XED_IFORM_RMPUPDATE_RAX_RCX_DEFINED 1 -#define XED_IFORM_ROL_GPR8_CL_DEFINED 1 -#define XED_IFORM_ROL_GPR8_IMMb_DEFINED 1 -#define XED_IFORM_ROL_GPR8_ONE_DEFINED 1 -#define XED_IFORM_ROL_GPRv_CL_DEFINED 1 -#define XED_IFORM_ROL_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_ROL_GPRv_ONE_DEFINED 1 -#define XED_IFORM_ROL_MEMb_CL_DEFINED 1 -#define XED_IFORM_ROL_MEMb_IMMb_DEFINED 1 -#define XED_IFORM_ROL_MEMb_ONE_DEFINED 1 -#define XED_IFORM_ROL_MEMv_CL_DEFINED 1 -#define XED_IFORM_ROL_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_ROL_MEMv_ONE_DEFINED 1 -#define XED_IFORM_ROR_GPR8_CL_DEFINED 1 -#define XED_IFORM_ROR_GPR8_IMMb_DEFINED 1 -#define XED_IFORM_ROR_GPR8_ONE_DEFINED 1 -#define XED_IFORM_ROR_GPRv_CL_DEFINED 1 -#define XED_IFORM_ROR_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_ROR_GPRv_ONE_DEFINED 1 -#define XED_IFORM_ROR_MEMb_CL_DEFINED 1 -#define XED_IFORM_ROR_MEMb_IMMb_DEFINED 1 -#define XED_IFORM_ROR_MEMb_ONE_DEFINED 1 -#define XED_IFORM_ROR_MEMv_CL_DEFINED 1 -#define XED_IFORM_ROR_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_ROR_MEMv_ONE_DEFINED 1 -#define XED_IFORM_RORX_VGPR32d_MEMd_IMMb_DEFINED 1 -#define XED_IFORM_RORX_VGPR32d_VGPR32d_IMMb_DEFINED 1 -#define XED_IFORM_RORX_VGPR64q_MEMq_IMMb_DEFINED 1 -#define XED_IFORM_RORX_VGPR64q_VGPR64q_IMMb_DEFINED 1 -#define XED_IFORM_ROUNDPD_XMMpd_MEMpd_IMMb_DEFINED 1 -#define XED_IFORM_ROUNDPD_XMMpd_XMMpd_IMMb_DEFINED 1 -#define XED_IFORM_ROUNDPS_XMMps_MEMps_IMMb_DEFINED 1 -#define XED_IFORM_ROUNDPS_XMMps_XMMps_IMMb_DEFINED 1 -#define XED_IFORM_ROUNDSD_XMMq_MEMq_IMMb_DEFINED 1 -#define XED_IFORM_ROUNDSD_XMMq_XMMq_IMMb_DEFINED 1 -#define XED_IFORM_ROUNDSS_XMMd_MEMd_IMMb_DEFINED 1 -#define XED_IFORM_ROUNDSS_XMMd_XMMd_IMMb_DEFINED 1 -#define XED_IFORM_RSM_DEFINED 1 -#define XED_IFORM_RSQRTPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_RSQRTPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_RSQRTSS_XMMss_MEMss_DEFINED 1 -#define XED_IFORM_RSQRTSS_XMMss_XMMss_DEFINED 1 -#define XED_IFORM_RSTORSSP_MEMu64_DEFINED 1 -#define XED_IFORM_SAHF_DEFINED 1 -#define XED_IFORM_SALC_DEFINED 1 -#define XED_IFORM_SAR_GPR8_CL_DEFINED 1 -#define XED_IFORM_SAR_GPR8_IMMb_DEFINED 1 -#define XED_IFORM_SAR_GPR8_ONE_DEFINED 1 -#define XED_IFORM_SAR_GPRv_CL_DEFINED 1 -#define XED_IFORM_SAR_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_SAR_GPRv_ONE_DEFINED 1 -#define XED_IFORM_SAR_MEMb_CL_DEFINED 1 -#define XED_IFORM_SAR_MEMb_IMMb_DEFINED 1 -#define XED_IFORM_SAR_MEMb_ONE_DEFINED 1 -#define XED_IFORM_SAR_MEMv_CL_DEFINED 1 -#define XED_IFORM_SAR_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_SAR_MEMv_ONE_DEFINED 1 -#define XED_IFORM_SARX_VGPR32d_MEMd_VGPR32d_DEFINED 1 -#define XED_IFORM_SARX_VGPR32d_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_SARX_VGPR64q_MEMq_VGPR64q_DEFINED 1 -#define XED_IFORM_SARX_VGPR64q_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_SAVEPREVSSP_DEFINED 1 -#define XED_IFORM_SBB_AL_IMMb_DEFINED 1 -#define XED_IFORM_SBB_GPR8_GPR8_18_DEFINED 1 -#define XED_IFORM_SBB_GPR8_GPR8_1A_DEFINED 1 -#define XED_IFORM_SBB_GPR8_IMMb_80r3_DEFINED 1 -#define XED_IFORM_SBB_GPR8_IMMb_82r3_DEFINED 1 -#define XED_IFORM_SBB_GPR8_MEMb_DEFINED 1 -#define XED_IFORM_SBB_GPRv_GPRv_19_DEFINED 1 -#define XED_IFORM_SBB_GPRv_GPRv_1B_DEFINED 1 -#define XED_IFORM_SBB_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_SBB_GPRv_IMMz_DEFINED 1 -#define XED_IFORM_SBB_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_SBB_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_SBB_MEMb_IMMb_80r3_DEFINED 1 -#define XED_IFORM_SBB_MEMb_IMMb_82r3_DEFINED 1 -#define XED_IFORM_SBB_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_SBB_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_SBB_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_SBB_OrAX_IMMz_DEFINED 1 -#define XED_IFORM_SBB_LOCK_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_SBB_LOCK_MEMb_IMMb_80r3_DEFINED 1 -#define XED_IFORM_SBB_LOCK_MEMb_IMMb_82r3_DEFINED 1 -#define XED_IFORM_SBB_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_SBB_LOCK_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_SBB_LOCK_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_SCASB_DEFINED 1 -#define XED_IFORM_SCASD_DEFINED 1 -#define XED_IFORM_SCASQ_DEFINED 1 -#define XED_IFORM_SCASW_DEFINED 1 -#define XED_IFORM_SEAMCALL_DEFINED 1 -#define XED_IFORM_SEAMOPS_DEFINED 1 -#define XED_IFORM_SEAMRET_DEFINED 1 -#define XED_IFORM_SENDUIPI_GPR32u32_DEFINED 1 -#define XED_IFORM_SERIALIZE_DEFINED 1 -#define XED_IFORM_SETB_GPR8_DEFINED 1 -#define XED_IFORM_SETB_MEMb_DEFINED 1 -#define XED_IFORM_SETBE_GPR8_DEFINED 1 -#define XED_IFORM_SETBE_MEMb_DEFINED 1 -#define XED_IFORM_SETL_GPR8_DEFINED 1 -#define XED_IFORM_SETL_MEMb_DEFINED 1 -#define XED_IFORM_SETLE_GPR8_DEFINED 1 -#define XED_IFORM_SETLE_MEMb_DEFINED 1 -#define XED_IFORM_SETNB_GPR8_DEFINED 1 -#define XED_IFORM_SETNB_MEMb_DEFINED 1 -#define XED_IFORM_SETNBE_GPR8_DEFINED 1 -#define XED_IFORM_SETNBE_MEMb_DEFINED 1 -#define XED_IFORM_SETNL_GPR8_DEFINED 1 -#define XED_IFORM_SETNL_MEMb_DEFINED 1 -#define XED_IFORM_SETNLE_GPR8_DEFINED 1 -#define XED_IFORM_SETNLE_MEMb_DEFINED 1 -#define XED_IFORM_SETNO_GPR8_DEFINED 1 -#define XED_IFORM_SETNO_MEMb_DEFINED 1 -#define XED_IFORM_SETNP_GPR8_DEFINED 1 -#define XED_IFORM_SETNP_MEMb_DEFINED 1 -#define XED_IFORM_SETNS_GPR8_DEFINED 1 -#define XED_IFORM_SETNS_MEMb_DEFINED 1 -#define XED_IFORM_SETNZ_GPR8_DEFINED 1 -#define XED_IFORM_SETNZ_MEMb_DEFINED 1 -#define XED_IFORM_SETO_GPR8_DEFINED 1 -#define XED_IFORM_SETO_MEMb_DEFINED 1 -#define XED_IFORM_SETP_GPR8_DEFINED 1 -#define XED_IFORM_SETP_MEMb_DEFINED 1 -#define XED_IFORM_SETS_GPR8_DEFINED 1 -#define XED_IFORM_SETS_MEMb_DEFINED 1 -#define XED_IFORM_SETSSBSY_DEFINED 1 -#define XED_IFORM_SETZ_GPR8_DEFINED 1 -#define XED_IFORM_SETZ_MEMb_DEFINED 1 -#define XED_IFORM_SFENCE_DEFINED 1 -#define XED_IFORM_SGDT_MEMs_DEFINED 1 -#define XED_IFORM_SGDT_MEMs64_DEFINED 1 -#define XED_IFORM_SHA1MSG1_XMMi32_MEMi32_SHA_DEFINED 1 -#define XED_IFORM_SHA1MSG1_XMMi32_XMMi32_SHA_DEFINED 1 -#define XED_IFORM_SHA1MSG2_XMMi32_MEMi32_SHA_DEFINED 1 -#define XED_IFORM_SHA1MSG2_XMMi32_XMMi32_SHA_DEFINED 1 -#define XED_IFORM_SHA1NEXTE_XMMi32_MEMi32_SHA_DEFINED 1 -#define XED_IFORM_SHA1NEXTE_XMMi32_XMMi32_SHA_DEFINED 1 -#define XED_IFORM_SHA1RNDS4_XMMi32_MEMi32_IMM8_SHA_DEFINED 1 -#define XED_IFORM_SHA1RNDS4_XMMi32_XMMi32_IMM8_SHA_DEFINED 1 -#define XED_IFORM_SHA256MSG1_XMMi32_MEMi32_SHA_DEFINED 1 -#define XED_IFORM_SHA256MSG1_XMMi32_XMMi32_SHA_DEFINED 1 -#define XED_IFORM_SHA256MSG2_XMMi32_MEMi32_SHA_DEFINED 1 -#define XED_IFORM_SHA256MSG2_XMMi32_XMMi32_SHA_DEFINED 1 -#define XED_IFORM_SHA256RNDS2_XMMi32_MEMi32_SHA_DEFINED 1 -#define XED_IFORM_SHA256RNDS2_XMMi32_XMMi32_SHA_DEFINED 1 -#define XED_IFORM_SHL_GPR8_CL_D2r4_DEFINED 1 -#define XED_IFORM_SHL_GPR8_CL_D2r6_DEFINED 1 -#define XED_IFORM_SHL_GPR8_IMMb_C0r4_DEFINED 1 -#define XED_IFORM_SHL_GPR8_IMMb_C0r6_DEFINED 1 -#define XED_IFORM_SHL_GPR8_ONE_D0r4_DEFINED 1 -#define XED_IFORM_SHL_GPR8_ONE_D0r6_DEFINED 1 -#define XED_IFORM_SHL_GPRv_CL_D3r4_DEFINED 1 -#define XED_IFORM_SHL_GPRv_CL_D3r6_DEFINED 1 -#define XED_IFORM_SHL_GPRv_IMMb_C1r4_DEFINED 1 -#define XED_IFORM_SHL_GPRv_IMMb_C1r6_DEFINED 1 -#define XED_IFORM_SHL_GPRv_ONE_D1r4_DEFINED 1 -#define XED_IFORM_SHL_GPRv_ONE_D1r6_DEFINED 1 -#define XED_IFORM_SHL_MEMb_CL_D2r4_DEFINED 1 -#define XED_IFORM_SHL_MEMb_CL_D2r6_DEFINED 1 -#define XED_IFORM_SHL_MEMb_IMMb_C0r4_DEFINED 1 -#define XED_IFORM_SHL_MEMb_IMMb_C0r6_DEFINED 1 -#define XED_IFORM_SHL_MEMb_ONE_D0r4_DEFINED 1 -#define XED_IFORM_SHL_MEMb_ONE_D0r6_DEFINED 1 -#define XED_IFORM_SHL_MEMv_CL_D3r4_DEFINED 1 -#define XED_IFORM_SHL_MEMv_CL_D3r6_DEFINED 1 -#define XED_IFORM_SHL_MEMv_IMMb_C1r4_DEFINED 1 -#define XED_IFORM_SHL_MEMv_IMMb_C1r6_DEFINED 1 -#define XED_IFORM_SHL_MEMv_ONE_D1r4_DEFINED 1 -#define XED_IFORM_SHL_MEMv_ONE_D1r6_DEFINED 1 -#define XED_IFORM_SHLD_GPRv_GPRv_CL_DEFINED 1 -#define XED_IFORM_SHLD_GPRv_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_SHLD_MEMv_GPRv_CL_DEFINED 1 -#define XED_IFORM_SHLD_MEMv_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_SHLX_VGPR32d_MEMd_VGPR32d_DEFINED 1 -#define XED_IFORM_SHLX_VGPR32d_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_SHLX_VGPR64q_MEMq_VGPR64q_DEFINED 1 -#define XED_IFORM_SHLX_VGPR64q_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_SHR_GPR8_CL_DEFINED 1 -#define XED_IFORM_SHR_GPR8_IMMb_DEFINED 1 -#define XED_IFORM_SHR_GPR8_ONE_DEFINED 1 -#define XED_IFORM_SHR_GPRv_CL_DEFINED 1 -#define XED_IFORM_SHR_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_SHR_GPRv_ONE_DEFINED 1 -#define XED_IFORM_SHR_MEMb_CL_DEFINED 1 -#define XED_IFORM_SHR_MEMb_IMMb_DEFINED 1 -#define XED_IFORM_SHR_MEMb_ONE_DEFINED 1 -#define XED_IFORM_SHR_MEMv_CL_DEFINED 1 -#define XED_IFORM_SHR_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_SHR_MEMv_ONE_DEFINED 1 -#define XED_IFORM_SHRD_GPRv_GPRv_CL_DEFINED 1 -#define XED_IFORM_SHRD_GPRv_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_SHRD_MEMv_GPRv_CL_DEFINED 1 -#define XED_IFORM_SHRD_MEMv_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_SHRX_VGPR32d_MEMd_VGPR32d_DEFINED 1 -#define XED_IFORM_SHRX_VGPR32d_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_SHRX_VGPR64q_MEMq_VGPR64q_DEFINED 1 -#define XED_IFORM_SHRX_VGPR64q_VGPR64q_VGPR64q_DEFINED 1 -#define XED_IFORM_SHUFPD_XMMpd_MEMpd_IMMb_DEFINED 1 -#define XED_IFORM_SHUFPD_XMMpd_XMMpd_IMMb_DEFINED 1 -#define XED_IFORM_SHUFPS_XMMps_MEMps_IMMb_DEFINED 1 -#define XED_IFORM_SHUFPS_XMMps_XMMps_IMMb_DEFINED 1 -#define XED_IFORM_SIDT_MEMs_DEFINED 1 -#define XED_IFORM_SIDT_MEMs64_DEFINED 1 -#define XED_IFORM_SKINIT_EAX_DEFINED 1 -#define XED_IFORM_SLDT_GPRv_DEFINED 1 -#define XED_IFORM_SLDT_MEMw_DEFINED 1 -#define XED_IFORM_SLWPCB_VGPRyy_DEFINED 1 -#define XED_IFORM_SMSW_GPRv_DEFINED 1 -#define XED_IFORM_SMSW_MEMw_DEFINED 1 -#define XED_IFORM_SQRTPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_SQRTPD_XMMpd_XMMpd_DEFINED 1 -#define XED_IFORM_SQRTPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_SQRTPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_SQRTSD_XMMsd_MEMsd_DEFINED 1 -#define XED_IFORM_SQRTSD_XMMsd_XMMsd_DEFINED 1 -#define XED_IFORM_SQRTSS_XMMss_MEMss_DEFINED 1 -#define XED_IFORM_SQRTSS_XMMss_XMMss_DEFINED 1 -#define XED_IFORM_STAC_DEFINED 1 -#define XED_IFORM_STC_DEFINED 1 -#define XED_IFORM_STD_DEFINED 1 -#define XED_IFORM_STGI_DEFINED 1 -#define XED_IFORM_STI_DEFINED 1 -#define XED_IFORM_STMXCSR_MEMd_DEFINED 1 -#define XED_IFORM_STOSB_DEFINED 1 -#define XED_IFORM_STOSD_DEFINED 1 -#define XED_IFORM_STOSQ_DEFINED 1 -#define XED_IFORM_STOSW_DEFINED 1 -#define XED_IFORM_STR_GPRv_DEFINED 1 -#define XED_IFORM_STR_MEMw_DEFINED 1 -#define XED_IFORM_STTILECFG_MEM_DEFINED 1 -#define XED_IFORM_STUI_DEFINED 1 -#define XED_IFORM_SUB_AL_IMMb_DEFINED 1 -#define XED_IFORM_SUB_GPR8_GPR8_28_DEFINED 1 -#define XED_IFORM_SUB_GPR8_GPR8_2A_DEFINED 1 -#define XED_IFORM_SUB_GPR8_IMMb_80r5_DEFINED 1 -#define XED_IFORM_SUB_GPR8_IMMb_82r5_DEFINED 1 -#define XED_IFORM_SUB_GPR8_MEMb_DEFINED 1 -#define XED_IFORM_SUB_GPRv_GPRv_29_DEFINED 1 -#define XED_IFORM_SUB_GPRv_GPRv_2B_DEFINED 1 -#define XED_IFORM_SUB_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_SUB_GPRv_IMMz_DEFINED 1 -#define XED_IFORM_SUB_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_SUB_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_SUB_MEMb_IMMb_80r5_DEFINED 1 -#define XED_IFORM_SUB_MEMb_IMMb_82r5_DEFINED 1 -#define XED_IFORM_SUB_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_SUB_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_SUB_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_SUB_OrAX_IMMz_DEFINED 1 -#define XED_IFORM_SUBPD_XMMpd_MEMpd_DEFINED 1 -#define XED_IFORM_SUBPD_XMMpd_XMMpd_DEFINED 1 -#define XED_IFORM_SUBPS_XMMps_MEMps_DEFINED 1 -#define XED_IFORM_SUBPS_XMMps_XMMps_DEFINED 1 -#define XED_IFORM_SUBSD_XMMsd_MEMsd_DEFINED 1 -#define XED_IFORM_SUBSD_XMMsd_XMMsd_DEFINED 1 -#define XED_IFORM_SUBSS_XMMss_MEMss_DEFINED 1 -#define XED_IFORM_SUBSS_XMMss_XMMss_DEFINED 1 -#define XED_IFORM_SUB_LOCK_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_SUB_LOCK_MEMb_IMMb_80r5_DEFINED 1 -#define XED_IFORM_SUB_LOCK_MEMb_IMMb_82r5_DEFINED 1 -#define XED_IFORM_SUB_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_SUB_LOCK_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_SUB_LOCK_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_SWAPGS_DEFINED 1 -#define XED_IFORM_SYSCALL_DEFINED 1 -#define XED_IFORM_SYSCALL_AMD_DEFINED 1 -#define XED_IFORM_SYSENTER_DEFINED 1 -#define XED_IFORM_SYSEXIT_DEFINED 1 -#define XED_IFORM_SYSRET_DEFINED 1 -#define XED_IFORM_SYSRET64_DEFINED 1 -#define XED_IFORM_SYSRET_AMD_DEFINED 1 -#define XED_IFORM_T1MSKC_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_T1MSKC_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_T1MSKC_VGPRyy_MEMy_DEFINED 1 -#define XED_IFORM_T1MSKC_VGPRyy_VGPRyy_DEFINED 1 -#define XED_IFORM_TDCALL_DEFINED 1 -#define XED_IFORM_TDPBF16PS_TMMf32_TMMu32_TMMu32_DEFINED 1 -#define XED_IFORM_TDPBSSD_TMMi32_TMMu32_TMMu32_DEFINED 1 -#define XED_IFORM_TDPBSUD_TMMi32_TMMu32_TMMu32_DEFINED 1 -#define XED_IFORM_TDPBUSD_TMMi32_TMMu32_TMMu32_DEFINED 1 -#define XED_IFORM_TDPBUUD_TMMu32_TMMu32_TMMu32_DEFINED 1 -#define XED_IFORM_TEST_AL_IMMb_DEFINED 1 -#define XED_IFORM_TEST_GPR8_GPR8_DEFINED 1 -#define XED_IFORM_TEST_GPR8_IMMb_F6r0_DEFINED 1 -#define XED_IFORM_TEST_GPR8_IMMb_F6r1_DEFINED 1 -#define XED_IFORM_TEST_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_TEST_GPRv_IMMz_F7r0_DEFINED 1 -#define XED_IFORM_TEST_GPRv_IMMz_F7r1_DEFINED 1 -#define XED_IFORM_TEST_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_TEST_MEMb_IMMb_F6r0_DEFINED 1 -#define XED_IFORM_TEST_MEMb_IMMb_F6r1_DEFINED 1 -#define XED_IFORM_TEST_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_TEST_MEMv_IMMz_F7r0_DEFINED 1 -#define XED_IFORM_TEST_MEMv_IMMz_F7r1_DEFINED 1 -#define XED_IFORM_TEST_OrAX_IMMz_DEFINED 1 -#define XED_IFORM_TESTUI_DEFINED 1 -#define XED_IFORM_TILELOADD_TMMu32_MEMu32_DEFINED 1 -#define XED_IFORM_TILELOADDT1_TMMu32_MEMu32_DEFINED 1 -#define XED_IFORM_TILERELEASE_DEFINED 1 -#define XED_IFORM_TILESTORED_MEMu32_TMMu32_DEFINED 1 -#define XED_IFORM_TILEZERO_TMMu32_DEFINED 1 -#define XED_IFORM_TLBSYNC_DEFINED 1 -#define XED_IFORM_TPAUSE_GPR32u32_DEFINED 1 -#define XED_IFORM_TZCNT_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_TZCNT_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_TZMSK_VGPR32d_MEMd_DEFINED 1 -#define XED_IFORM_TZMSK_VGPR32d_VGPR32d_DEFINED 1 -#define XED_IFORM_TZMSK_VGPRyy_MEMy_DEFINED 1 -#define XED_IFORM_TZMSK_VGPRyy_VGPRyy_DEFINED 1 -#define XED_IFORM_UCOMISD_XMMsd_MEMsd_DEFINED 1 -#define XED_IFORM_UCOMISD_XMMsd_XMMsd_DEFINED 1 -#define XED_IFORM_UCOMISS_XMMss_MEMss_DEFINED 1 -#define XED_IFORM_UCOMISS_XMMss_XMMss_DEFINED 1 -#define XED_IFORM_UD0_DEFINED 1 -#define XED_IFORM_UD0_GPR32_GPR32_DEFINED 1 -#define XED_IFORM_UD0_GPR32_MEMd_DEFINED 1 -#define XED_IFORM_UD1_GPR32_GPR32_DEFINED 1 -#define XED_IFORM_UD1_GPR32_MEMd_DEFINED 1 -#define XED_IFORM_UD2_DEFINED 1 -#define XED_IFORM_UIRET_DEFINED 1 -#define XED_IFORM_UMONITOR_GPRa_DEFINED 1 -#define XED_IFORM_UMWAIT_GPR32_DEFINED 1 -#define XED_IFORM_UNPCKHPD_XMMpd_MEMdq_DEFINED 1 -#define XED_IFORM_UNPCKHPD_XMMpd_XMMq_DEFINED 1 -#define XED_IFORM_UNPCKHPS_XMMps_MEMdq_DEFINED 1 -#define XED_IFORM_UNPCKHPS_XMMps_XMMdq_DEFINED 1 -#define XED_IFORM_UNPCKLPD_XMMpd_MEMdq_DEFINED 1 -#define XED_IFORM_UNPCKLPD_XMMpd_XMMq_DEFINED 1 -#define XED_IFORM_UNPCKLPS_XMMps_MEMdq_DEFINED 1 -#define XED_IFORM_UNPCKLPS_XMMps_XMMq_DEFINED 1 -#define XED_IFORM_V4FMADDPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_V4FMADDSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_V4FNMADDPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_V4FNMADDSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VADDPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VADDPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VADDPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VADDPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VADDPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VADDPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VADDPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VADDPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VADDPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VADDPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VADDPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VADDPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VADDPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VADDPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VADDPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VADDPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VADDPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VADDPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VADDPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VADDPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VADDPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VADDPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VADDPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VADDPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VADDPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VADDPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VADDSD_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VADDSD_XMMdq_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VADDSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VADDSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VADDSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VADDSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VADDSS_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VADDSS_XMMdq_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VADDSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VADDSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VADDSUBPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VADDSUBPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VADDSUBPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VADDSUBPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VADDSUBPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VADDSUBPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VADDSUBPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VADDSUBPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VAESDEC_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VAESDEC_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VAESDEC_XMMu128_XMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESDEC_XMMu128_XMMu128_XMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESDEC_YMMu128_YMMu128_MEMu128_DEFINED 1 -#define XED_IFORM_VAESDEC_YMMu128_YMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESDEC_YMMu128_YMMu128_YMMu128_DEFINED 1 -#define XED_IFORM_VAESDEC_YMMu128_YMMu128_YMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESDEC_ZMMu128_ZMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESDEC_ZMMu128_ZMMu128_ZMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESDECLAST_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VAESDECLAST_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VAESDECLAST_XMMu128_XMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESDECLAST_XMMu128_XMMu128_XMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESDECLAST_YMMu128_YMMu128_MEMu128_DEFINED 1 -#define XED_IFORM_VAESDECLAST_YMMu128_YMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESDECLAST_YMMu128_YMMu128_YMMu128_DEFINED 1 -#define XED_IFORM_VAESDECLAST_YMMu128_YMMu128_YMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESDECLAST_ZMMu128_ZMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESDECLAST_ZMMu128_ZMMu128_ZMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENC_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VAESENC_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VAESENC_XMMu128_XMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENC_XMMu128_XMMu128_XMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENC_YMMu128_YMMu128_MEMu128_DEFINED 1 -#define XED_IFORM_VAESENC_YMMu128_YMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENC_YMMu128_YMMu128_YMMu128_DEFINED 1 -#define XED_IFORM_VAESENC_YMMu128_YMMu128_YMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENC_ZMMu128_ZMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENC_ZMMu128_ZMMu128_ZMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENCLAST_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VAESENCLAST_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VAESENCLAST_XMMu128_XMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENCLAST_XMMu128_XMMu128_XMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENCLAST_YMMu128_YMMu128_MEMu128_DEFINED 1 -#define XED_IFORM_VAESENCLAST_YMMu128_YMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENCLAST_YMMu128_YMMu128_YMMu128_DEFINED 1 -#define XED_IFORM_VAESENCLAST_YMMu128_YMMu128_YMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENCLAST_ZMMu128_ZMMu128_MEMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESENCLAST_ZMMu128_ZMMu128_ZMMu128_AVX512_DEFINED 1 -#define XED_IFORM_VAESIMC_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VAESIMC_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VAESKEYGENASSIST_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VAESKEYGENASSIST_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VALIGND_XMMu32_MASKmskw_XMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VALIGND_XMMu32_MASKmskw_XMMu32_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VALIGND_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VALIGND_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VALIGND_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VALIGND_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VALIGNQ_XMMu64_MASKmskw_XMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VALIGNQ_XMMu64_MASKmskw_XMMu64_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VALIGNQ_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VALIGNQ_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VALIGNQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VALIGNQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VANDNPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VANDNPD_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPD_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VANDNPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VANDNPD_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPD_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPD_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPD_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VANDNPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VANDNPS_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPS_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VANDNPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VANDNPS_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPS_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPS_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VANDNPS_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VANDPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VANDPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VANDPD_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDPD_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VANDPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VANDPD_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDPD_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDPD_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDPD_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VANDPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VANDPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VANDPS_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VANDPS_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VANDPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VANDPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VANDPS_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VANDPS_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VANDPS_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VANDPS_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDMPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBLENDPD_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VBLENDPD_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VBLENDPD_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VBLENDPD_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VBLENDPS_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VBLENDPS_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VBLENDPS_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VBLENDPS_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VBLENDVPD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VBLENDVPD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VBLENDVPD_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VBLENDVPD_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VBLENDVPS_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VBLENDVPS_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VBLENDVPS_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VBLENDVPS_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VBROADCASTF128_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VBROADCASTF32X2_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTF32X2_YMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTF32X2_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTF32X2_ZMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTF32X4_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTF32X4_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTF32X8_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTF64X2_YMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTF64X2_ZMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTF64X4_ZMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI128_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VBROADCASTI32X2_XMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI32X2_XMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI32X2_YMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI32X2_YMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI32X2_ZMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI32X2_ZMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI32X4_YMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI32X4_ZMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI32X8_ZMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI64X2_YMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI64X2_ZMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTI64X4_ZMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTSD_YMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTSD_YMMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTSD_YMMqq_MEMq_DEFINED 1 -#define XED_IFORM_VBROADCASTSD_YMMqq_XMMdq_DEFINED 1 -#define XED_IFORM_VBROADCASTSD_ZMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTSD_ZMMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTSS_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VBROADCASTSS_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VBROADCASTSS_XMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTSS_XMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTSS_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTSS_YMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTSS_YMMqq_MEMd_DEFINED 1 -#define XED_IFORM_VBROADCASTSS_YMMqq_XMMdq_DEFINED 1 -#define XED_IFORM_VBROADCASTSS_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VBROADCASTSS_ZMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPD_MASKmskw_MASKmskw_XMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPD_MASKmskw_MASKmskw_XMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPD_MASKmskw_MASKmskw_YMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPD_MASKmskw_MASKmskw_YMMf64_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPD_MASKmskw_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPD_MASKmskw_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPD_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VCMPPD_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VCMPPD_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VCMPPD_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VCMPPH_MASKmskw_MASKmskw_XMMf16_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPH_MASKmskw_MASKmskw_XMMf16_XMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPH_MASKmskw_MASKmskw_YMMf16_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPH_MASKmskw_MASKmskw_YMMf16_YMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPH_MASKmskw_MASKmskw_ZMMf16_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPH_MASKmskw_MASKmskw_ZMMf16_ZMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPS_MASKmskw_MASKmskw_XMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPS_MASKmskw_MASKmskw_XMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPS_MASKmskw_MASKmskw_YMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPS_MASKmskw_MASKmskw_YMMf32_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPS_MASKmskw_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPS_MASKmskw_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPPS_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VCMPPS_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VCMPPS_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VCMPPS_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VCMPSD_MASKmskw_MASKmskw_XMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPSD_MASKmskw_MASKmskw_XMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPSD_XMMdq_XMMdq_MEMq_IMMb_DEFINED 1 -#define XED_IFORM_VCMPSD_XMMdq_XMMdq_XMMq_IMMb_DEFINED 1 -#define XED_IFORM_VCMPSH_MASKmskw_MASKmskw_XMMf16_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPSH_MASKmskw_MASKmskw_XMMf16_XMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPSS_MASKmskw_MASKmskw_XMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPSS_MASKmskw_MASKmskw_XMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCMPSS_XMMdq_XMMdq_MEMd_IMMb_DEFINED 1 -#define XED_IFORM_VCMPSS_XMMdq_XMMdq_XMMd_IMMb_DEFINED 1 -#define XED_IFORM_VCOMISD_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCOMISD_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCOMISD_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VCOMISD_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VCOMISH_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCOMISH_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCOMISS_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VCOMISS_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VCOMISS_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCOMISS_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPD_MEMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPD_MEMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPD_MEMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPD_XMMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPD_YMMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPD_ZMMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPS_MEMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPS_MEMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPS_MEMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPS_XMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPS_YMMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCOMPRESSPS_ZMMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PD_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VCVTDQ2PD_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VCVTDQ2PD_XMMf64_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PD_XMMf64_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PD_YMMf64_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PD_YMMf64_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PD_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VCVTDQ2PD_YMMqq_XMMdq_DEFINED 1 -#define XED_IFORM_VCVTDQ2PD_ZMMf64_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PD_ZMMf64_MASKmskw_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PH_XMMf16_MASKmskw_MEMi32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTDQ2PH_XMMf16_MASKmskw_MEMi32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTDQ2PH_XMMf16_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PH_XMMf16_MASKmskw_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PH_YMMf16_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PH_YMMf16_MASKmskw_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PS_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VCVTDQ2PS_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VCVTDQ2PS_XMMf32_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PS_XMMf32_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PS_YMMf32_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PS_YMMf32_MASKmskw_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PS_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VCVTDQ2PS_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VCVTDQ2PS_ZMMf32_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTDQ2PS_ZMMf32_MASKmskw_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTNE2PS2BF16_XMMbf16_MASKmskw_XMMf32_MEMf32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTNE2PS2BF16_XMMbf16_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTNE2PS2BF16_YMMbf16_MASKmskw_YMMf32_MEMf32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTNE2PS2BF16_YMMbf16_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTNE2PS2BF16_ZMMbf16_MASKmskw_ZMMf32_MEMf32_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTNE2PS2BF16_ZMMbf16_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTNEPS2BF16_XMMbf16_MASKmskw_MEMf32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTNEPS2BF16_XMMbf16_MASKmskw_MEMf32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTNEPS2BF16_XMMbf16_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTNEPS2BF16_XMMbf16_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTNEPS2BF16_YMMbf16_MASKmskw_MEMf32_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTNEPS2BF16_YMMbf16_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2DQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VCVTPD2DQ_XMMdq_MEMqq_DEFINED 1 -#define XED_IFORM_VCVTPD2DQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VCVTPD2DQ_XMMdq_YMMqq_DEFINED 1 -#define XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_XMMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_YMMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTPD2DQ_YMMi32_MASKmskw_MEMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTPD2DQ_YMMi32_MASKmskw_ZMMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_MEMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_MEMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_MEMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2PS_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VCVTPD2PS_XMMdq_MEMqq_DEFINED 1 -#define XED_IFORM_VCVTPD2PS_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VCVTPD2PS_XMMdq_YMMqq_DEFINED 1 -#define XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_MEMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_MEMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_XMMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_YMMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTPD2PS_YMMf32_MASKmskw_MEMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTPD2PS_YMMf32_MASKmskw_ZMMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTPD2QQ_XMMi64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2QQ_XMMi64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2QQ_YMMi64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2QQ_YMMi64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2QQ_ZMMi64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2QQ_ZMMi64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_XMMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_YMMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTPD2UDQ_YMMu32_MASKmskw_MEMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTPD2UDQ_YMMu32_MASKmskw_ZMMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTPD2UQQ_XMMu64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2UQQ_XMMu64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2UQQ_YMMu64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2UQQ_YMMu64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2UQQ_ZMMu64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPD2UQQ_ZMMu64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2DQ_XMMi32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2DQ_XMMi32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2DQ_YMMi32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2DQ_YMMi32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2DQ_ZMMi32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2DQ_ZMMi32_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PD_XMMf64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PD_XMMf64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PD_YMMf64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PD_YMMf64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PD_ZMMf64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PD_ZMMf64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PS_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VCVTPH2PS_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VCVTPH2PS_XMMf32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PS_XMMf32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PS_YMMf32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PS_YMMf32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PS_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VCVTPH2PS_YMMqq_XMMdq_DEFINED 1 -#define XED_IFORM_VCVTPH2PS_ZMMf32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PS_ZMMf32_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PSX_XMMf32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PSX_XMMf32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PSX_YMMf32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PSX_YMMf32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PSX_ZMMf32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2PSX_ZMMf32_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2QQ_XMMi64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2QQ_XMMi64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2QQ_YMMi64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2QQ_YMMi64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2QQ_ZMMi64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2QQ_ZMMi64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UDQ_XMMu32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UDQ_XMMu32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UDQ_YMMu32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UDQ_YMMu32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UDQ_ZMMu32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UDQ_ZMMu32_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UQQ_XMMu64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UQQ_XMMu64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UQQ_YMMu64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UQQ_YMMu64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UQQ_ZMMu64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UQQ_ZMMu64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UW_XMMu16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UW_XMMu16_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UW_YMMu16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UW_YMMu16_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UW_ZMMu16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2UW_ZMMu16_MASKmskw_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2W_XMMi16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2W_XMMi16_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2W_YMMi16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2W_YMMi16_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2W_ZMMi16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPH2W_ZMMi16_MASKmskw_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2DQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VCVTPS2DQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VCVTPS2DQ_XMMi32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2DQ_XMMi32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2DQ_YMMi32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2DQ_YMMi32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2DQ_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VCVTPS2DQ_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VCVTPS2DQ_ZMMi32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2DQ_ZMMi32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PD_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VCVTPS2PD_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VCVTPS2PD_XMMf64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PD_XMMf64_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PD_YMMf64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PD_YMMf64_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PD_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VCVTPS2PD_YMMqq_XMMdq_DEFINED 1 -#define XED_IFORM_VCVTPS2PD_ZMMf64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PD_ZMMf64_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PH_MEMdq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VCVTPS2PH_MEMf16_MASKmskw_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PH_MEMf16_MASKmskw_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PH_MEMf16_MASKmskw_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PH_MEMq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VCVTPS2PH_XMMdq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VCVTPS2PH_XMMf16_MASKmskw_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PH_XMMf16_MASKmskw_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PH_XMMq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VCVTPS2PH_YMMf16_MASKmskw_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PHX_XMMf16_MASKmskw_MEMf32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTPS2PHX_XMMf16_MASKmskw_MEMf32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTPS2PHX_XMMf16_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PHX_XMMf16_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2PHX_YMMf16_MASKmskw_MEMf32_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTPS2PHX_YMMf16_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2QQ_XMMi64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2QQ_XMMi64_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2QQ_YMMi64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2QQ_YMMi64_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2QQ_ZMMi64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2QQ_ZMMi64_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UDQ_XMMu32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UDQ_XMMu32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UDQ_YMMu32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UDQ_YMMu32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UDQ_ZMMu32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UDQ_ZMMu32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UQQ_XMMu64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UQQ_XMMu64_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UQQ_YMMu64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UQQ_YMMu64_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UQQ_ZMMu64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTPS2UQQ_ZMMu64_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PD_XMMi64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PD_XMMi64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PD_YMMi64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PD_YMMi64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PD_ZMMi64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PD_ZMMi64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_XMMu64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_YMMu64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTQQ2PS_YMMf32_MASKmskw_MEMu64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTQQ2PS_YMMf32_MASKmskw_ZMMu64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTSD2SH_XMMf16_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSD2SH_XMMf16_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSD2SI_GPR32d_MEMq_DEFINED 1 -#define XED_IFORM_VCVTSD2SI_GPR32d_XMMq_DEFINED 1 -#define XED_IFORM_VCVTSD2SI_GPR32i32_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSD2SI_GPR32i32_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSD2SI_GPR64i64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSD2SI_GPR64i64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSD2SI_GPR64q_MEMq_DEFINED 1 -#define XED_IFORM_VCVTSD2SI_GPR64q_XMMq_DEFINED 1 -#define XED_IFORM_VCVTSD2SS_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VCVTSD2SS_XMMdq_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VCVTSD2SS_XMMf32_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSD2SS_XMMf32_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSD2USI_GPR32u32_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSD2USI_GPR32u32_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSD2USI_GPR64u64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSD2USI_GPR64u64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2SD_XMMf64_MASKmskw_XMMf64_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2SD_XMMf64_MASKmskw_XMMf64_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2SI_GPR32i32_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2SI_GPR32i32_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2SI_GPR64i64_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2SI_GPR64i64_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2SS_XMMf32_MASKmskw_XMMf32_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2SS_XMMf32_MASKmskw_XMMf32_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2USI_GPR32u32_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2USI_GPR32u32_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2USI_GPR64u64_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSH2USI_GPR64u64_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_GPR32d_DEFINED 1 -#define XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_GPR64q_DEFINED 1 -#define XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_GPR32i32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_GPR64i64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SH_XMMf16_XMMf16_GPR32i32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SH_XMMf16_XMMf16_GPR64i64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SH_XMMf16_XMMf16_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SH_XMMf16_XMMf16_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_GPR32d_DEFINED 1 -#define XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_GPR64q_DEFINED 1 -#define XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_GPR32i32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_GPR64i64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2SD_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VCVTSS2SD_XMMdq_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VCVTSS2SD_XMMf64_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2SD_XMMf64_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2SH_XMMf16_MASKmskw_XMMf16_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2SH_XMMf16_MASKmskw_XMMf16_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2SI_GPR32d_MEMd_DEFINED 1 -#define XED_IFORM_VCVTSS2SI_GPR32d_XMMd_DEFINED 1 -#define XED_IFORM_VCVTSS2SI_GPR32i32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2SI_GPR32i32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2SI_GPR64i64_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2SI_GPR64i64_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2SI_GPR64q_MEMd_DEFINED 1 -#define XED_IFORM_VCVTSS2SI_GPR64q_XMMd_DEFINED 1 -#define XED_IFORM_VCVTSS2USI_GPR32u32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2USI_GPR32u32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2USI_GPR64u64_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTSS2USI_GPR64u64_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2DQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VCVTTPD2DQ_XMMdq_MEMqq_DEFINED 1 -#define XED_IFORM_VCVTTPD2DQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VCVTTPD2DQ_XMMdq_YMMqq_DEFINED 1 -#define XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_XMMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_YMMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTTPD2DQ_YMMi32_MASKmskw_MEMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTTPD2DQ_YMMi32_MASKmskw_ZMMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTTPD2QQ_XMMi64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2QQ_XMMi64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2QQ_YMMi64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2QQ_YMMi64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2QQ_ZMMi64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2QQ_ZMMi64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_XMMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_YMMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTTPD2UDQ_YMMu32_MASKmskw_MEMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTTPD2UDQ_YMMu32_MASKmskw_ZMMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTTPD2UQQ_XMMu64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2UQQ_XMMu64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2UQQ_YMMu64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2UQQ_YMMu64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2UQQ_ZMMu64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPD2UQQ_ZMMu64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2DQ_XMMi32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2DQ_XMMi32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2DQ_YMMi32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2DQ_YMMi32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2DQ_ZMMi32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2DQ_ZMMi32_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2QQ_XMMi64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2QQ_XMMi64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2QQ_YMMi64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2QQ_YMMi64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2QQ_ZMMi64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2QQ_ZMMi64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UDQ_XMMu32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UDQ_XMMu32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UDQ_YMMu32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UDQ_YMMu32_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UDQ_ZMMu32_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UDQ_ZMMu32_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UQQ_XMMu64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UQQ_XMMu64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UQQ_YMMu64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UQQ_YMMu64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UQQ_ZMMu64_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UQQ_ZMMu64_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UW_XMMu16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UW_XMMu16_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UW_YMMu16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UW_YMMu16_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UW_ZMMu16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2UW_ZMMu16_MASKmskw_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2W_XMMi16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2W_XMMi16_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2W_YMMi16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2W_YMMi16_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2W_ZMMi16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPH2W_ZMMi16_MASKmskw_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2DQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VCVTTPS2DQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VCVTTPS2DQ_XMMi32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2DQ_XMMi32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2DQ_YMMi32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2DQ_YMMi32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2DQ_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VCVTTPS2DQ_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VCVTTPS2DQ_ZMMi32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2DQ_ZMMi32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2QQ_XMMi64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2QQ_XMMi64_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2QQ_YMMi64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2QQ_YMMi64_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2QQ_ZMMi64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2QQ_ZMMi64_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UDQ_XMMu32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UDQ_XMMu32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UDQ_YMMu32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UDQ_YMMu32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UDQ_ZMMu32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UDQ_ZMMu32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UQQ_XMMu64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UQQ_XMMu64_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UQQ_YMMu64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UQQ_YMMu64_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UQQ_ZMMu64_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTPS2UQQ_ZMMu64_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSD2SI_GPR32d_MEMq_DEFINED 1 -#define XED_IFORM_VCVTTSD2SI_GPR32d_XMMq_DEFINED 1 -#define XED_IFORM_VCVTTSD2SI_GPR32i32_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSD2SI_GPR32i32_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSD2SI_GPR64i64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSD2SI_GPR64i64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSD2SI_GPR64q_MEMq_DEFINED 1 -#define XED_IFORM_VCVTTSD2SI_GPR64q_XMMq_DEFINED 1 -#define XED_IFORM_VCVTTSD2USI_GPR32u32_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSD2USI_GPR32u32_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSD2USI_GPR64u64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSD2USI_GPR64u64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSH2SI_GPR32i32_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSH2SI_GPR32i32_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSH2SI_GPR64i64_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSH2SI_GPR64i64_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSH2USI_GPR32u32_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSH2USI_GPR32u32_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSH2USI_GPR64u64_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSH2USI_GPR64u64_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSS2SI_GPR32d_MEMd_DEFINED 1 -#define XED_IFORM_VCVTTSS2SI_GPR32d_XMMd_DEFINED 1 -#define XED_IFORM_VCVTTSS2SI_GPR32i32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSS2SI_GPR32i32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSS2SI_GPR64i64_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSS2SI_GPR64i64_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSS2SI_GPR64q_MEMd_DEFINED 1 -#define XED_IFORM_VCVTTSS2SI_GPR64q_XMMd_DEFINED 1 -#define XED_IFORM_VCVTTSS2USI_GPR32u32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSS2USI_GPR32u32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSS2USI_GPR64u64_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTTSS2USI_GPR64u64_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PD_XMMf64_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PD_XMMf64_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PD_YMMf64_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PD_YMMf64_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PD_ZMMf64_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PD_ZMMf64_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PH_XMMf16_MASKmskw_MEMu32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PH_XMMf16_MASKmskw_MEMu32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PH_XMMf16_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PH_XMMf16_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PH_YMMf16_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PH_YMMf16_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PS_XMMf32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PS_XMMf32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PS_YMMf32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PS_YMMf32_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PS_ZMMf32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUDQ2PS_ZMMf32_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PD_XMMf64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PD_XMMf64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PD_YMMf64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PD_YMMf64_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PD_ZMMf64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PD_ZMMf64_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_XMMu64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_YMMu64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PS_YMMf32_MASKmskw_MEMu64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTUQQ2PS_YMMf32_MASKmskw_ZMMu64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_GPR32u32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_GPR64u64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SH_XMMf16_XMMf16_GPR32u32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SH_XMMf16_XMMf16_GPR64u64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SH_XMMf16_XMMf16_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SH_XMMf16_XMMf16_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_GPR32u32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_GPR64u64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUW2PH_XMMf16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUW2PH_XMMf16_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUW2PH_YMMf16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUW2PH_YMMf16_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUW2PH_ZMMf16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTUW2PH_ZMMf16_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTW2PH_XMMf16_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTW2PH_XMMf16_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTW2PH_YMMf16_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTW2PH_YMMf16_MASKmskw_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTW2PH_ZMMf16_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VCVTW2PH_ZMMf16_MASKmskw_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VDBPSADBW_XMMu16_MASKmskw_XMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VDBPSADBW_XMMu16_MASKmskw_XMMu8_XMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VDBPSADBW_YMMu16_MASKmskw_YMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VDBPSADBW_YMMu16_MASKmskw_YMMu8_YMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VDBPSADBW_ZMMu16_MASKmskw_ZMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VDBPSADBW_ZMMu16_MASKmskw_ZMMu8_ZMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VDIVPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VDIVPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VDIVPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VDIVPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VDIVPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VDIVPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VDIVPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VDIVPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VDIVPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VDIVSD_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VDIVSD_XMMdq_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VDIVSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VDIVSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VDIVSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VDIVSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VDIVSS_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VDIVSS_XMMdq_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VDIVSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VDIVSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VDPBF16PS_XMMf32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VDPBF16PS_XMMf32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VDPBF16PS_YMMf32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VDPBF16PS_YMMf32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VDPBF16PS_ZMMf32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VDPBF16PS_ZMMf32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VDPPD_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VDPPD_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VDPPS_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VDPPS_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VDPPS_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VDPPS_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VERR_GPR16_DEFINED 1 -#define XED_IFORM_VERR_MEMw_DEFINED 1 -#define XED_IFORM_VERW_GPR16_DEFINED 1 -#define XED_IFORM_VERW_MEMw_DEFINED 1 -#define XED_IFORM_VEXP2PD_ZMMf64_MASKmskw_MEMf64_AVX512ER_DEFINED 1 -#define XED_IFORM_VEXP2PD_ZMMf64_MASKmskw_ZMMf64_AVX512ER_DEFINED 1 -#define XED_IFORM_VEXP2PS_ZMMf32_MASKmskw_MEMf32_AVX512ER_DEFINED 1 -#define XED_IFORM_VEXP2PS_ZMMf32_MASKmskw_ZMMf32_AVX512ER_DEFINED 1 -#define XED_IFORM_VEXPANDPD_XMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VEXPANDPD_XMMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VEXPANDPD_YMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VEXPANDPD_YMMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VEXPANDPD_ZMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VEXPANDPD_ZMMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VEXPANDPS_XMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VEXPANDPS_XMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VEXPANDPS_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VEXPANDPS_YMMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VEXPANDPS_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VEXPANDPS_ZMMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF128_MEMdq_YMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VEXTRACTF128_XMMdq_YMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VEXTRACTF32X4_MEMf32_MASKmskw_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF32X4_MEMf32_MASKmskw_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF32X4_XMMf32_MASKmskw_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF32X4_XMMf32_MASKmskw_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF32X8_MEMf32_MASKmskw_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF32X8_YMMf32_MASKmskw_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF64X2_MEMf64_MASKmskw_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF64X2_MEMf64_MASKmskw_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF64X2_XMMf64_MASKmskw_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF64X2_XMMf64_MASKmskw_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF64X4_MEMf64_MASKmskw_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTF64X4_YMMf64_MASKmskw_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI128_MEMdq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VEXTRACTI128_XMMdq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VEXTRACTI32X4_MEMu32_MASKmskw_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI32X4_MEMu32_MASKmskw_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI32X4_XMMu32_MASKmskw_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI32X4_XMMu32_MASKmskw_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI32X8_MEMu32_MASKmskw_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI32X8_YMMu32_MASKmskw_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI64X2_MEMu64_MASKmskw_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI64X2_MEMu64_MASKmskw_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI64X2_XMMu64_MASKmskw_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI64X2_XMMu64_MASKmskw_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI64X4_MEMu64_MASKmskw_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTI64X4_YMMu64_MASKmskw_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTPS_GPR32_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VEXTRACTPS_GPR32f32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VEXTRACTPS_MEMd_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VEXTRACTPS_MEMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFCMADDCPH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMADDCPH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMADDCPH_YMM2f16_MASKmskw_YMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMADDCPH_YMM2f16_MASKmskw_YMM2f16_YMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMADDCPH_ZMM2f16_MASKmskw_ZMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMADDCPH_ZMM2f16_MASKmskw_ZMM2f16_ZMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMADDCSH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMADDCSH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMULCPH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMULCPH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMULCPH_YMM2f16_MASKmskw_YMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMULCPH_YMM2f16_MASKmskw_YMM2f16_YMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMULCPH_ZMM2f16_MASKmskw_ZMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMULCPH_ZMM2f16_MASKmskw_ZMM2f16_ZMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMULCSH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFCMULCSH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPD_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPD_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPS_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPS_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMSD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMSD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMSS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFIXUPIMMSS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADD132PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADD132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADD132PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADD132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADD132PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADD132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADD132PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADD132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFMADD132SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFMADD132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFMADD132SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFMADD132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADD213PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADD213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADD213PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADD213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADD213PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADD213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADD213PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADD213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFMADD213SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFMADD213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFMADD213SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFMADD213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADD231PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADD231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADD231PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADD231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADD231PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADD231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADD231PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADD231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFMADD231SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFMADD231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFMADD231SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFMADD231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADD231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDCPH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDCPH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDCPH_YMM2f16_MASKmskw_YMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDCPH_YMM2f16_MASKmskw_YMM2f16_YMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDCPH_ZMM2f16_MASKmskw_ZMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDCPH_ZMM2f16_MASKmskw_ZMM2f16_ZMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDCSH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDCSH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDPD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDPD_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADDPD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDPD_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDPD_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADDPD_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDPS_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDPS_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADDPS_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDPS_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDPS_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADDPS_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDSD_XMMdq_XMMq_MEMq_XMMq_DEFINED 1 -#define XED_IFORM_VFMADDSD_XMMdq_XMMq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFMADDSD_XMMdq_XMMq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFMADDSS_XMMdq_XMMd_MEMd_XMMd_DEFINED 1 -#define XED_IFORM_VFMADDSS_XMMdq_XMMd_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFMADDSS_XMMdq_XMMd_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUB231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMADDSUBPD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUBPD_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUBPD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUBPD_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUBPD_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUBPD_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUBPS_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUBPS_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUBPS_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMADDSUBPS_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUBPS_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMADDSUBPS_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUB132PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUB132PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUB132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUB132PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUB132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUB132PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUB132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUB132PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUB132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFMSUB132SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFMSUB132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFMSUB132SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFMSUB132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUB213PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUB213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUB213PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUB213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUB213PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUB213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUB213PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUB213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFMSUB213SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFMSUB213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFMSUB213SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFMSUB213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUB231PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUB231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUB231PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUB231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUB231PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUB231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUB231PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUB231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFMSUB231SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFMSUB231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFMSUB231SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFMSUB231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUB231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADD231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFMSUBADDPD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADDPD_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADDPD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADDPD_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADDPD_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADDPD_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADDPS_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADDPS_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADDPS_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBADDPS_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADDPS_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUBADDPS_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBPD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBPD_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUBPD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBPD_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBPD_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUBPD_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBPS_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBPS_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFMSUBPS_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFMSUBPS_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBPS_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFMSUBPS_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFMSUBSD_XMMdq_XMMq_MEMq_XMMq_DEFINED 1 -#define XED_IFORM_VFMSUBSD_XMMdq_XMMq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFMSUBSD_XMMdq_XMMq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFMSUBSS_XMMdq_XMMd_MEMd_XMMd_DEFINED 1 -#define XED_IFORM_VFMSUBSS_XMMdq_XMMd_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFMSUBSS_XMMdq_XMMd_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFMULCPH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMULCPH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMULCPH_YMM2f16_MASKmskw_YMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMULCPH_YMM2f16_MASKmskw_YMM2f16_YMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMULCPH_ZMM2f16_MASKmskw_ZMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMULCPH_ZMM2f16_MASKmskw_ZMM2f16_ZMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMULCSH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFMULCSH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMADD132PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMADD132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMADD132PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMADD132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMADD132PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMADD132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMADD132PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMADD132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFNMADD132SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFNMADD132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFNMADD132SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFNMADD132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMADD213PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMADD213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMADD213PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMADD213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMADD213PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMADD213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMADD213PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMADD213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFNMADD213SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFNMADD213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFNMADD213SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFNMADD213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMADD231PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMADD231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMADD231PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMADD231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMADD231PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMADD231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMADD231PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMADD231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFNMADD231SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFNMADD231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFNMADD231SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFNMADD231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADD231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMADDPD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMADDPD_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMADDPD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMADDPD_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMADDPD_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMADDPD_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMADDPS_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMADDPS_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMADDPS_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMADDPS_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMADDPS_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMADDPS_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMADDSD_XMMdq_XMMq_MEMq_XMMq_DEFINED 1 -#define XED_IFORM_VFNMADDSD_XMMdq_XMMq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFNMADDSD_XMMdq_XMMq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFNMADDSS_XMMdq_XMMd_MEMd_XMMd_DEFINED 1 -#define XED_IFORM_VFNMADDSS_XMMdq_XMMd_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFNMADDSS_XMMdq_XMMd_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFNMSUB132PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB132PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB132PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB132PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB132PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFNMSUB132SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFNMSUB132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFNMSUB132SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFNMSUB132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB213PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB213PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB213PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB213PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFNMSUB213SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFNMSUB213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFNMSUB213SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFNMSUB213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB231PD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB231PD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB231PS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMSUB231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB231PS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMSUB231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231SD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFNMSUB231SD_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFNMSUB231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231SS_XMMdq_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFNMSUB231SS_XMMdq_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFNMSUB231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUB231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VFNMSUBPD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMSUBPD_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMSUBPD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMSUBPD_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMSUBPD_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMSUBPD_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMSUBPS_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMSUBPS_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFNMSUBPS_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFNMSUBPS_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMSUBPS_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFNMSUBPS_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFNMSUBSD_XMMdq_XMMq_MEMq_XMMq_DEFINED 1 -#define XED_IFORM_VFNMSUBSD_XMMdq_XMMq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VFNMSUBSD_XMMdq_XMMq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VFNMSUBSS_XMMdq_XMMd_MEMd_XMMd_DEFINED 1 -#define XED_IFORM_VFNMSUBSS_XMMdq_XMMd_XMMd_MEMd_DEFINED 1 -#define XED_IFORM_VFNMSUBSS_XMMdq_XMMd_XMMd_XMMd_DEFINED 1 -#define XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_MEMf64_IMM8_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_MEMf64_IMM8_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_MEMf64_IMM8_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_MEMf16_IMM8_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_MEMf16_IMM8_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_MEMf16_IMM8_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_XMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_YMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_ZMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_MEMf32_IMM8_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_MEMf32_IMM8_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_MEMf32_IMM8_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSSD_MASKmskw_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSSD_MASKmskw_MASKmskw_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSSH_MASKmskw_MASKmskw_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSSH_MASKmskw_MASKmskw_XMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSSS_MASKmskw_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFPCLASSSS_MASKmskw_MASKmskw_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VFRCZPD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFRCZPD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFRCZPD_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFRCZPD_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFRCZPS_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VFRCZPS_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VFRCZPS_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VFRCZPS_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VFRCZSD_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VFRCZSD_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VFRCZSS_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VFRCZSS_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VGATHERDPD_XMMf64_MASKmskw_MEMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VGATHERDPD_XMMf64_MEMf64_XMMi64_VL128_DEFINED 1 -#define XED_IFORM_VGATHERDPD_YMMf64_MASKmskw_MEMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VGATHERDPD_YMMf64_MEMf64_YMMi64_VL256_DEFINED 1 -#define XED_IFORM_VGATHERDPD_ZMMf64_MASKmskw_MEMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VGATHERDPS_XMMf32_MASKmskw_MEMf32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VGATHERDPS_XMMf32_MEMf32_XMMi32_VL128_DEFINED 1 -#define XED_IFORM_VGATHERDPS_YMMf32_MASKmskw_MEMf32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VGATHERDPS_YMMf32_MEMf32_YMMi32_VL256_DEFINED 1 -#define XED_IFORM_VGATHERDPS_ZMMf32_MASKmskw_MEMf32_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VGATHERPF0DPD_MEMf64_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VGATHERPF0DPS_MEMf32_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VGATHERPF0QPD_MEMf64_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VGATHERPF0QPS_MEMf32_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VGATHERPF1DPD_MEMf64_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VGATHERPF1DPS_MEMf32_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VGATHERPF1QPD_MEMf64_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VGATHERPF1QPS_MEMf32_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VGATHERQPD_XMMf64_MASKmskw_MEMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VGATHERQPD_XMMf64_MEMf64_XMMi64_VL128_DEFINED 1 -#define XED_IFORM_VGATHERQPD_YMMf64_MASKmskw_MEMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VGATHERQPD_YMMf64_MEMf64_YMMi64_VL256_DEFINED 1 -#define XED_IFORM_VGATHERQPD_ZMMf64_MASKmskw_MEMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VGATHERQPS_XMMf32_MASKmskw_MEMf32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VGATHERQPS_XMMf32_MASKmskw_MEMf32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VGATHERQPS_XMMf32_MEMf32_XMMi32_VL128_DEFINED 1 -#define XED_IFORM_VGATHERQPS_XMMf32_MEMf32_XMMi32_VL256_DEFINED 1 -#define XED_IFORM_VGATHERQPS_YMMf32_MASKmskw_MEMf32_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VGETEXPPD_XMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPD_XMMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPD_YMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPD_YMMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPD_ZMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPD_ZMMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPH_XMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPH_XMMf16_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPH_YMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPH_YMMf16_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPH_ZMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPH_ZMMf16_MASKmskw_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPS_XMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPS_XMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPS_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPS_YMMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPS_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPPS_ZMMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VGETEXPSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPH_XMMf16_MASKmskw_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPH_XMMf16_MASKmskw_XMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPH_YMMf16_MASKmskw_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPH_YMMf16_MASKmskw_YMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPH_ZMMf16_MASKmskw_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPH_ZMMf16_MASKmskw_ZMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTSD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTSD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTSH_XMMf16_MASKmskw_XMMf16_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTSH_XMMf16_MASKmskw_XMMf16_XMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTSS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGETMANTSS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEINVQB_XMMu8_MASKmskw_XMMu8_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEINVQB_XMMu8_MASKmskw_XMMu8_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEINVQB_XMMu8_XMMu8_MEMu64_IMM8_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEINVQB_XMMu8_XMMu8_XMMu64_IMM8_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEINVQB_YMMu8_MASKmskw_YMMu8_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEINVQB_YMMu8_MASKmskw_YMMu8_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEINVQB_YMMu8_YMMu8_MEMu64_IMM8_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEINVQB_YMMu8_YMMu8_YMMu64_IMM8_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEINVQB_ZMMu8_MASKmskw_ZMMu8_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEINVQB_ZMMu8_MASKmskw_ZMMu8_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEQB_XMMu8_MASKmskw_XMMu8_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEQB_XMMu8_MASKmskw_XMMu8_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEQB_XMMu8_XMMu8_MEMu64_IMM8_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEQB_XMMu8_XMMu8_XMMu64_IMM8_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEQB_YMMu8_MASKmskw_YMMu8_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEQB_YMMu8_MASKmskw_YMMu8_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEQB_YMMu8_YMMu8_MEMu64_IMM8_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEQB_YMMu8_YMMu8_YMMu64_IMM8_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEQB_ZMMu8_MASKmskw_ZMMu8_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8AFFINEQB_ZMMu8_MASKmskw_ZMMu8_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8MULB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8MULB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8MULB_XMMu8_XMMu8_MEMu8_DEFINED 1 -#define XED_IFORM_VGF2P8MULB_XMMu8_XMMu8_XMMu8_DEFINED 1 -#define XED_IFORM_VGF2P8MULB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8MULB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8MULB_YMMu8_YMMu8_MEMu8_DEFINED 1 -#define XED_IFORM_VGF2P8MULB_YMMu8_YMMu8_YMMu8_DEFINED 1 -#define XED_IFORM_VGF2P8MULB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VGF2P8MULB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VHADDPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VHADDPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VHADDPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VHADDPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VHADDPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VHADDPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VHADDPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VHADDPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VHSUBPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VHSUBPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VHSUBPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VHSUBPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VHSUBPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VHSUBPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VHSUBPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VHSUBPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VINSERTF128_YMMqq_YMMqq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VINSERTF128_YMMqq_YMMqq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VINSERTF32X4_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTF32X4_YMMf32_MASKmskw_YMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTF32X4_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTF32X4_ZMMf32_MASKmskw_ZMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTF32X8_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTF32X8_ZMMf32_MASKmskw_ZMMf32_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTF64X2_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTF64X2_YMMf64_MASKmskw_YMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTF64X2_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTF64X2_ZMMf64_MASKmskw_ZMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTF64X4_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTF64X4_ZMMf64_MASKmskw_ZMMf64_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI128_YMMqq_YMMqq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VINSERTI128_YMMqq_YMMqq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VINSERTI32X4_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI32X4_YMMu32_MASKmskw_YMMu32_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI32X4_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI32X4_ZMMu32_MASKmskw_ZMMu32_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI32X8_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI32X8_ZMMu32_MASKmskw_ZMMu32_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI64X2_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI64X2_YMMu64_MASKmskw_YMMu64_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI64X2_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI64X2_ZMMu64_MASKmskw_ZMMu64_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI64X4_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTI64X4_ZMMu64_MASKmskw_ZMMu64_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTPS_XMMdq_XMMdq_MEMd_IMMb_DEFINED 1 -#define XED_IFORM_VINSERTPS_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VINSERTPS_XMMf32_XMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VINSERTPS_XMMf32_XMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VLDDQU_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VLDDQU_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VLDMXCSR_MEMd_DEFINED 1 -#define XED_IFORM_VMASKMOVDQU_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMASKMOVPD_MEMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMASKMOVPD_MEMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMASKMOVPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMASKMOVPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMASKMOVPS_MEMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMASKMOVPS_MEMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMASKMOVPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMASKMOVPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMAXPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMAXPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMAXPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMAXPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMAXPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMAXPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMAXPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMAXPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMAXPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMAXPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMAXSD_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VMAXSD_XMMdq_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VMAXSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMAXSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMAXSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMAXSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMAXSS_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VMAXSS_XMMdq_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VMAXSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMAXSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMCALL_DEFINED 1 -#define XED_IFORM_VMCLEAR_MEMq_DEFINED 1 -#define XED_IFORM_VMFUNC_DEFINED 1 -#define XED_IFORM_VMINPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMINPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMINPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMINPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMINPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMINPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMINPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMINPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMINPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMINPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMINPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMINPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMINPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMINPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMINPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMINPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMINPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMINPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMINPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMINPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMINPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMINPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMINPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMINPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMINPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMINPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMINSD_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VMINSD_XMMdq_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VMINSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMINSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMINSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMINSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMINSS_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VMINSS_XMMdq_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VMINSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMINSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMLAUNCH_DEFINED 1 -#define XED_IFORM_VMLOAD_ArAX_DEFINED 1 -#define XED_IFORM_VMMCALL_DEFINED 1 -#define XED_IFORM_VMOVAPD_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVAPD_MEMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPD_MEMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPD_MEMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPD_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVAPD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMOVAPD_XMMdq_XMMdq_28_DEFINED 1 -#define XED_IFORM_VMOVAPD_XMMdq_XMMdq_29_DEFINED 1 -#define XED_IFORM_VMOVAPD_XMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPD_XMMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPD_YMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPD_YMMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPD_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMOVAPD_YMMqq_YMMqq_28_DEFINED 1 -#define XED_IFORM_VMOVAPD_YMMqq_YMMqq_29_DEFINED 1 -#define XED_IFORM_VMOVAPD_ZMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPD_ZMMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPS_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVAPS_MEMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPS_MEMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPS_MEMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPS_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVAPS_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMOVAPS_XMMdq_XMMdq_28_DEFINED 1 -#define XED_IFORM_VMOVAPS_XMMdq_XMMdq_29_DEFINED 1 -#define XED_IFORM_VMOVAPS_XMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPS_XMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPS_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPS_YMMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPS_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMOVAPS_YMMqq_YMMqq_28_DEFINED 1 -#define XED_IFORM_VMOVAPS_YMMqq_YMMqq_29_DEFINED 1 -#define XED_IFORM_VMOVAPS_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVAPS_ZMMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVD_GPR32d_XMMd_DEFINED 1 -#define XED_IFORM_VMOVD_GPR32u32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVD_MEMd_XMMd_DEFINED 1 -#define XED_IFORM_VMOVD_MEMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVD_XMMdq_GPR32d_DEFINED 1 -#define XED_IFORM_VMOVD_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VMOVD_XMMu32_GPR32u32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVD_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDDUP_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VMOVDDUP_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VMOVDDUP_XMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDDUP_XMMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDDUP_YMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDDUP_YMMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDDUP_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMOVDDUP_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVDDUP_ZMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDDUP_ZMMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVDQA_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVDQA_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMOVDQA_XMMdq_XMMdq_6F_DEFINED 1 -#define XED_IFORM_VMOVDQA_XMMdq_XMMdq_7F_DEFINED 1 -#define XED_IFORM_VMOVDQA_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMOVDQA_YMMqq_YMMqq_6F_DEFINED 1 -#define XED_IFORM_VMOVDQA_YMMqq_YMMqq_7F_DEFINED 1 -#define XED_IFORM_VMOVDQA32_MEMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA32_MEMu32_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA32_MEMu32_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA32_XMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA32_XMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA32_YMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA32_YMMu32_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA32_ZMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA32_ZMMu32_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA64_MEMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA64_MEMu64_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA64_MEMu64_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA64_XMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA64_XMMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA64_YMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA64_YMMu64_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA64_ZMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQA64_ZMMu64_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVDQU_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVDQU_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMOVDQU_XMMdq_XMMdq_6F_DEFINED 1 -#define XED_IFORM_VMOVDQU_XMMdq_XMMdq_7F_DEFINED 1 -#define XED_IFORM_VMOVDQU_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMOVDQU_YMMqq_YMMqq_6F_DEFINED 1 -#define XED_IFORM_VMOVDQU_YMMqq_YMMqq_7F_DEFINED 1 -#define XED_IFORM_VMOVDQU16_MEMu16_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU16_MEMu16_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU16_MEMu16_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU16_XMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU16_XMMu16_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU16_YMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU16_YMMu16_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU16_ZMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU16_ZMMu16_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU32_MEMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU32_MEMu32_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU32_MEMu32_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU32_XMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU32_XMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU32_YMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU32_YMMu32_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU32_ZMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU32_ZMMu32_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU64_MEMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU64_MEMu64_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU64_MEMu64_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU64_XMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU64_XMMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU64_YMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU64_YMMu64_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU64_ZMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU64_ZMMu64_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU8_MEMu8_MASKmskw_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU8_MEMu8_MASKmskw_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU8_MEMu8_MASKmskw_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU8_XMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU8_XMMu8_MASKmskw_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU8_YMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU8_YMMu8_MASKmskw_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU8_ZMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VMOVDQU8_ZMMu8_MASKmskw_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VMOVHLPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVHLPS_XMMf32_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVHPD_MEMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVHPD_MEMq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVHPD_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VMOVHPD_XMMf64_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVHPS_MEMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVHPS_MEMq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVHPS_XMMdq_XMMq_MEMq_DEFINED 1 -#define XED_IFORM_VMOVHPS_XMMf32_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVLHPS_XMMdq_XMMq_XMMq_DEFINED 1 -#define XED_IFORM_VMOVLHPS_XMMf32_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVLPD_MEMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVLPD_MEMq_XMMq_DEFINED 1 -#define XED_IFORM_VMOVLPD_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VMOVLPD_XMMf64_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVLPS_MEMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVLPS_MEMq_XMMq_DEFINED 1 -#define XED_IFORM_VMOVLPS_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VMOVLPS_XMMf32_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVMSKPD_GPR32d_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVMSKPD_GPR32d_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVMSKPS_GPR32d_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVMSKPS_GPR32d_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVNTDQ_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVNTDQ_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVNTDQ_MEMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTDQ_MEMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTDQ_MEMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTDQA_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMOVNTDQA_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTDQA_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMOVNTDQA_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTDQA_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTPD_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVNTPD_MEMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTPD_MEMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTPD_MEMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTPD_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVNTPS_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVNTPS_MEMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTPS_MEMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTPS_MEMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVNTPS_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVQ_GPR64q_XMMq_DEFINED 1 -#define XED_IFORM_VMOVQ_GPR64u64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVQ_MEMq_XMMq_7E_DEFINED 1 -#define XED_IFORM_VMOVQ_MEMq_XMMq_D6_DEFINED 1 -#define XED_IFORM_VMOVQ_MEMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVQ_XMMdq_GPR64q_DEFINED 1 -#define XED_IFORM_VMOVQ_XMMdq_MEMq_6E_DEFINED 1 -#define XED_IFORM_VMOVQ_XMMdq_MEMq_7E_DEFINED 1 -#define XED_IFORM_VMOVQ_XMMdq_XMMq_7E_DEFINED 1 -#define XED_IFORM_VMOVQ_XMMdq_XMMq_D6_DEFINED 1 -#define XED_IFORM_VMOVQ_XMMu64_GPR64u64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVQ_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVQ_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSD_MEMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSD_MEMq_XMMq_DEFINED 1 -#define XED_IFORM_VMOVSD_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VMOVSD_XMMdq_XMMdq_XMMq_10_DEFINED 1 -#define XED_IFORM_VMOVSD_XMMdq_XMMdq_XMMq_11_DEFINED 1 -#define XED_IFORM_VMOVSD_XMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSH_MEMf16_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSH_XMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSHDUP_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMOVSHDUP_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVSHDUP_XMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSHDUP_XMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSHDUP_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSHDUP_YMMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSHDUP_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMOVSHDUP_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVSHDUP_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSHDUP_ZMMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSLDUP_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMOVSLDUP_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVSLDUP_XMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSLDUP_XMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSLDUP_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSLDUP_YMMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSLDUP_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMOVSLDUP_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVSLDUP_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSLDUP_ZMMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSS_MEMd_XMMd_DEFINED 1 -#define XED_IFORM_VMOVSS_MEMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSS_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VMOVSS_XMMdq_XMMdq_XMMd_10_DEFINED 1 -#define XED_IFORM_VMOVSS_XMMdq_XMMdq_XMMd_11_DEFINED 1 -#define XED_IFORM_VMOVSS_XMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPD_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVUPD_MEMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPD_MEMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPD_MEMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPD_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVUPD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMOVUPD_XMMdq_XMMdq_10_DEFINED 1 -#define XED_IFORM_VMOVUPD_XMMdq_XMMdq_11_DEFINED 1 -#define XED_IFORM_VMOVUPD_XMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPD_XMMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPD_YMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPD_YMMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPD_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMOVUPD_YMMqq_YMMqq_10_DEFINED 1 -#define XED_IFORM_VMOVUPD_YMMqq_YMMqq_11_DEFINED 1 -#define XED_IFORM_VMOVUPD_ZMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPD_ZMMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPS_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMOVUPS_MEMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPS_MEMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPS_MEMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPS_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMOVUPS_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMOVUPS_XMMdq_XMMdq_10_DEFINED 1 -#define XED_IFORM_VMOVUPS_XMMdq_XMMdq_11_DEFINED 1 -#define XED_IFORM_VMOVUPS_XMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPS_XMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPS_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPS_YMMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPS_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMOVUPS_YMMqq_YMMqq_10_DEFINED 1 -#define XED_IFORM_VMOVUPS_YMMqq_YMMqq_11_DEFINED 1 -#define XED_IFORM_VMOVUPS_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVUPS_ZMMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMOVW_GPR32f16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVW_MEMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVW_XMMf16_GPR32f16_AVX512_DEFINED 1 -#define XED_IFORM_VMOVW_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMPSADBW_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VMPSADBW_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VMPSADBW_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VMPSADBW_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VMPTRLD_MEMq_DEFINED 1 -#define XED_IFORM_VMPTRST_MEMq_DEFINED 1 -#define XED_IFORM_VMREAD_GPR32_GPR32_DEFINED 1 -#define XED_IFORM_VMREAD_GPR64_GPR64_DEFINED 1 -#define XED_IFORM_VMREAD_MEMd_GPR32_DEFINED 1 -#define XED_IFORM_VMREAD_MEMq_GPR64_DEFINED 1 -#define XED_IFORM_VMRESUME_DEFINED 1 -#define XED_IFORM_VMRUN_ArAX_DEFINED 1 -#define XED_IFORM_VMSAVE_DEFINED 1 -#define XED_IFORM_VMULPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMULPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMULPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMULPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMULPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMULPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMULPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMULPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMULPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMULPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMULPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMULPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMULPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMULPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMULPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMULPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMULPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VMULPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VMULPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMULPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMULPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMULPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMULPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VMULPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VMULPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMULPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMULSD_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VMULSD_XMMdq_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VMULSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMULSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VMULSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMULSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VMULSS_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VMULSS_XMMdq_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VMULSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMULSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VMWRITE_GPR32_GPR32_DEFINED 1 -#define XED_IFORM_VMWRITE_GPR32_MEMd_DEFINED 1 -#define XED_IFORM_VMWRITE_GPR64_GPR64_DEFINED 1 -#define XED_IFORM_VMWRITE_GPR64_MEMq_DEFINED 1 -#define XED_IFORM_VMXOFF_DEFINED 1 -#define XED_IFORM_VMXON_MEMq_DEFINED 1 -#define XED_IFORM_VORPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VORPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VORPD_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VORPD_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VORPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VORPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VORPD_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VORPD_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VORPD_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VORPD_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VORPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VORPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VORPS_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VORPS_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VORPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VORPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VORPS_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VORPS_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VORPS_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VORPS_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTD_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTD_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTD_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTD_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTD_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTD_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTQ_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTQ_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTQ_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTQ_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTQ_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VP2INTERSECTQ_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VP4DPWSSD_ZMMi32_MASKmskw_ZMMi16_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VP4DPWSSDS_ZMMi32_MASKmskw_ZMMi16_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPABSB_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPABSB_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPABSB_XMMi8_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPABSB_XMMi8_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPABSB_YMMi8_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPABSB_YMMi8_MASKmskw_YMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPABSB_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPABSB_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPABSB_ZMMi8_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPABSB_ZMMi8_MASKmskw_ZMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPABSD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPABSD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPABSD_XMMi32_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPABSD_XMMi32_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPABSD_YMMi32_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPABSD_YMMi32_MASKmskw_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPABSD_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPABSD_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPABSD_ZMMi32_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPABSD_ZMMi32_MASKmskw_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPABSQ_XMMi64_MASKmskw_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPABSQ_XMMi64_MASKmskw_XMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPABSQ_YMMi64_MASKmskw_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPABSQ_YMMi64_MASKmskw_YMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPABSQ_ZMMi64_MASKmskw_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPABSQ_ZMMi64_MASKmskw_ZMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPABSW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPABSW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPABSW_XMMi16_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPABSW_XMMi16_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPABSW_YMMi16_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPABSW_YMMi16_MASKmskw_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPABSW_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPABSW_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPABSW_ZMMi16_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPABSW_ZMMi16_MASKmskw_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSDW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPACKSSDW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPACKSSDW_XMMi16_MASKmskw_XMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSDW_XMMi16_MASKmskw_XMMi32_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSDW_YMMi16_MASKmskw_YMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSDW_YMMi16_MASKmskw_YMMi32_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSDW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPACKSSDW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPACKSSDW_ZMMi16_MASKmskw_ZMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSDW_ZMMi16_MASKmskw_ZMMi32_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSWB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPACKSSWB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPACKSSWB_XMMi8_MASKmskw_XMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSWB_XMMi8_MASKmskw_XMMi16_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSWB_YMMi8_MASKmskw_YMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSWB_YMMi8_MASKmskw_YMMi16_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSWB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPACKSSWB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPACKSSWB_ZMMi8_MASKmskw_ZMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKSSWB_ZMMi8_MASKmskw_ZMMi16_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSDW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPACKUSDW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPACKUSDW_XMMu16_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSDW_XMMu16_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSDW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPACKUSDW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPACKUSDW_YMMu16_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSDW_YMMu16_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSDW_ZMMu16_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSDW_ZMMu16_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSWB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPACKUSWB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPACKUSWB_XMMu8_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSWB_XMMu8_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSWB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPACKUSWB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPACKUSWB_YMMu8_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSWB_YMMu8_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSWB_ZMMu8_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPACKUSWB_ZMMu8_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPADDB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPADDB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPADDB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPADDB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPADDD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPADDD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPADDD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPADDD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPADDD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPADDD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPADDD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPADDD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPADDD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPADDQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPADDQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPADDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPADDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPADDQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPADDQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPADDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPADDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPADDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPADDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPADDSB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPADDSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPADDSB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPADDSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPADDSW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPADDSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPADDSW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPADDSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPADDUSB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPADDUSB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPADDUSB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPADDUSB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPADDUSW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPADDUSW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPADDUSW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPADDUSW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDUSW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPADDW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPADDW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPADDW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPADDW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPADDW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPALIGNR_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPALIGNR_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPALIGNR_XMMu8_MASKmskw_XMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPALIGNR_XMMu8_MASKmskw_XMMu8_XMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPALIGNR_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPALIGNR_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPALIGNR_YMMu8_MASKmskw_YMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPALIGNR_YMMu8_MASKmskw_YMMu8_YMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPALIGNR_ZMMu8_MASKmskw_ZMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPALIGNR_ZMMu8_MASKmskw_ZMMu8_ZMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPAND_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPAND_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPAND_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPAND_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPANDD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDN_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPANDN_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPANDN_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPANDN_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPANDND_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDND_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDND_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDND_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDND_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDND_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPANDNQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPANDNQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPANDNQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPANDNQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPANDNQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPANDNQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPANDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPANDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPANDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPANDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPANDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPANDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPAVGB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPAVGB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPAVGB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPAVGB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPAVGW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPAVGW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPAVGW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPAVGW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPAVGW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDD_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPBLENDD_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPBLENDD_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPBLENDD_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPBLENDMB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDMW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBLENDVB_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPBLENDVB_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPBLENDVB_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPBLENDVB_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPBLENDW_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPBLENDW_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPBLENDW_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPBLENDW_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_XMMdq_MEMb_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_XMMdq_XMMb_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_XMMu8_MASKmskw_GPR32u8_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_XMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_XMMu8_MASKmskw_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_YMMqq_MEMb_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_YMMqq_XMMb_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_YMMu8_MASKmskw_GPR32u8_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_YMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_YMMu8_MASKmskw_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_ZMMu8_MASKmskw_GPR32u8_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_ZMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTB_ZMMu8_MASKmskw_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_XMMu32_MASKmskw_GPR32u32_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_XMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_XMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_YMMqq_MEMd_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_YMMqq_XMMd_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_YMMu32_MASKmskw_GPR32u32_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_YMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_YMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_ZMMu32_MASKmskw_GPR32u32_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_ZMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTD_ZMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTMB2Q_XMMu64_MASKu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTMB2Q_YMMu64_MASKu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTMB2Q_ZMMu64_MASKu64_AVX512CD_DEFINED 1 -#define XED_IFORM_VPBROADCASTMW2D_XMMu32_MASKu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTMW2D_YMMu32_MASKu32_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTMW2D_ZMMu32_MASKu32_AVX512CD_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_XMMu64_MASKmskw_GPR64u64_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_XMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_XMMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_YMMqq_MEMq_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_YMMu64_MASKmskw_GPR64u64_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_YMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_YMMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_ZMMu64_MASKmskw_GPR64u64_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_ZMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTQ_ZMMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_XMMdq_MEMw_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_XMMdq_XMMw_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_XMMu16_MASKmskw_GPR32u16_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_XMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_XMMu16_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_YMMqq_MEMw_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_YMMqq_XMMw_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_YMMu16_MASKmskw_GPR32u16_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_YMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_YMMu16_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_ZMMu16_MASKmskw_GPR32u16_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_ZMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPBROADCASTW_ZMMu16_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCLMULQDQ_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCLMULQDQ_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCLMULQDQ_XMMu128_XMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCLMULQDQ_XMMu128_XMMu64_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCLMULQDQ_YMMu128_YMMu64_MEMu64_IMM8_DEFINED 1 -#define XED_IFORM_VPCLMULQDQ_YMMu128_YMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCLMULQDQ_YMMu128_YMMu64_YMMu64_IMM8_DEFINED 1 -#define XED_IFORM_VPCLMULQDQ_YMMu128_YMMu64_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCLMULQDQ_ZMMu128_ZMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCLMULQDQ_ZMMu128_ZMMu64_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMOV_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPCMOV_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPCMOV_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPCMOV_YMMqq_YMMqq_MEMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPCMOV_YMMqq_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPCMOV_YMMqq_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPCMPB_MASKmskw_MASKmskw_XMMi8_MEMi8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPB_MASKmskw_MASKmskw_XMMi8_XMMi8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPB_MASKmskw_MASKmskw_YMMi8_MEMi8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPB_MASKmskw_MASKmskw_YMMi8_YMMi8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPB_MASKmskw_MASKmskw_ZMMi8_MEMi8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPB_MASKmskw_MASKmskw_ZMMi8_ZMMi8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPD_MASKmskw_MASKmskw_XMMi32_MEMi32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPD_MASKmskw_MASKmskw_XMMi32_XMMi32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPD_MASKmskw_MASKmskw_YMMi32_MEMi32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPD_MASKmskw_MASKmskw_YMMi32_YMMi32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPD_MASKmskw_MASKmskw_ZMMi32_MEMi32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPD_MASKmskw_MASKmskw_ZMMi32_ZMMi32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPCMPEQB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPCMPEQB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPCMPEQB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPCMPEQD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPCMPEQD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPCMPEQD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPCMPEQQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPCMPEQQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPCMPEQQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPEQW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPCMPEQW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPCMPEQW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPCMPEQW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPCMPESTRI_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPESTRI_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPESTRI64_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPESTRI64_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPESTRM_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPESTRM_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPESTRM64_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPESTRM64_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPCMPGTB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPCMPGTB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPCMPGTB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_XMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_XMMi32_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_YMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_YMMi32_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_ZMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_ZMMi32_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPCMPGTD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPCMPGTD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPCMPGTD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_XMMi64_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_XMMi64_XMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_YMMi64_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_YMMi64_YMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_ZMMi64_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_ZMMi64_ZMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPCMPGTQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPCMPGTQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPCMPGTQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPGTW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPCMPGTW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPCMPGTW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPCMPGTW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPCMPISTRI_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPISTRI_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPISTRI64_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPISTRI64_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPISTRM_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPISTRM_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_XMMi64_MEMi64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_XMMi64_XMMi64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_YMMi64_MEMi64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_YMMi64_YMMi64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_ZMMi64_MEMi64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_ZMMi64_ZMMi64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_XMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_XMMu8_XMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_YMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_YMMu8_YMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_ZMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_XMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_XMMu32_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_YMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_YMMu32_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_XMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_XMMu64_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_YMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_YMMu64_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_XMMu16_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_XMMu16_XMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_YMMu16_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_YMMu16_YMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_ZMMu16_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPW_MASKmskw_MASKmskw_XMMi16_MEMi16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPW_MASKmskw_MASKmskw_XMMi16_XMMi16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPW_MASKmskw_MASKmskw_YMMi16_MEMi16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPW_MASKmskw_MASKmskw_YMMi16_YMMi16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPW_MASKmskw_MASKmskw_ZMMi16_MEMi16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCMPW_MASKmskw_MASKmskw_ZMMi16_ZMMi16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMB_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMB_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMD_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMD_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMPRESSB_MEMu8_MASKmskw_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSB_MEMu8_MASKmskw_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSB_MEMu8_MASKmskw_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSB_XMMu8_MASKmskw_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSB_YMMu8_MASKmskw_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSB_ZMMu8_MASKmskw_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSD_MEMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSD_MEMu32_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSD_MEMu32_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSD_XMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSD_YMMu32_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSD_ZMMu32_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSQ_MEMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSQ_MEMu64_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSQ_MEMu64_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSQ_XMMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSQ_YMMu64_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSQ_ZMMu64_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSW_MEMu16_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSW_MEMu16_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSW_MEMu16_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSW_XMMu16_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSW_YMMu16_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMPRESSW_ZMMu16_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPCOMQ_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMQ_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMUB_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMUB_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMUD_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMUD_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMUQ_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMUQ_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMUW_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMUW_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMW_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCOMW_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPCONFLICTD_XMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCONFLICTD_XMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCONFLICTD_YMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCONFLICTD_YMMu32_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPCONFLICTD_ZMMu32_MASKmskw_MEMu32_AVX512CD_DEFINED 1 -#define XED_IFORM_VPCONFLICTD_ZMMu32_MASKmskw_ZMMu32_AVX512CD_DEFINED 1 -#define XED_IFORM_VPCONFLICTQ_XMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCONFLICTQ_XMMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCONFLICTQ_YMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCONFLICTQ_YMMu64_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPCONFLICTQ_ZMMu64_MASKmskw_MEMu64_AVX512CD_DEFINED 1 -#define XED_IFORM_VPCONFLICTQ_ZMMu64_MASKmskw_ZMMu64_AVX512CD_DEFINED 1 -#define XED_IFORM_VPDPBUSD_XMMi32_MASKmskw_XMMu8_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPBUSD_XMMi32_MASKmskw_XMMu8_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPBUSD_XMMi32_XMMu32_MEMu32_DEFINED 1 -#define XED_IFORM_VPDPBUSD_XMMi32_XMMu32_XMMu32_DEFINED 1 -#define XED_IFORM_VPDPBUSD_YMMi32_MASKmskw_YMMu8_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPBUSD_YMMi32_MASKmskw_YMMu8_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPBUSD_YMMi32_YMMu32_MEMu32_DEFINED 1 -#define XED_IFORM_VPDPBUSD_YMMi32_YMMu32_YMMu32_DEFINED 1 -#define XED_IFORM_VPDPBUSD_ZMMi32_MASKmskw_ZMMu8_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPBUSD_ZMMi32_MASKmskw_ZMMu8_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPBUSDS_XMMi32_MASKmskw_XMMu8_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPBUSDS_XMMi32_MASKmskw_XMMu8_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPBUSDS_XMMi32_XMMu32_MEMu32_DEFINED 1 -#define XED_IFORM_VPDPBUSDS_XMMi32_XMMu32_XMMu32_DEFINED 1 -#define XED_IFORM_VPDPBUSDS_YMMi32_MASKmskw_YMMu8_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPBUSDS_YMMi32_MASKmskw_YMMu8_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPBUSDS_YMMi32_YMMu32_MEMu32_DEFINED 1 -#define XED_IFORM_VPDPBUSDS_YMMi32_YMMu32_YMMu32_DEFINED 1 -#define XED_IFORM_VPDPBUSDS_ZMMi32_MASKmskw_ZMMu8_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPBUSDS_ZMMi32_MASKmskw_ZMMu8_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSD_XMMi32_MASKmskw_XMMi16_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSD_XMMi32_MASKmskw_XMMi16_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSD_XMMi32_XMMu32_MEMu32_DEFINED 1 -#define XED_IFORM_VPDPWSSD_XMMi32_XMMu32_XMMu32_DEFINED 1 -#define XED_IFORM_VPDPWSSD_YMMi32_MASKmskw_YMMi16_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSD_YMMi32_MASKmskw_YMMi16_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSD_YMMi32_YMMu32_MEMu32_DEFINED 1 -#define XED_IFORM_VPDPWSSD_YMMi32_YMMu32_YMMu32_DEFINED 1 -#define XED_IFORM_VPDPWSSD_ZMMi32_MASKmskw_ZMMi16_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSD_ZMMi32_MASKmskw_ZMMi16_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSDS_XMMi32_MASKmskw_XMMi16_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSDS_XMMi32_MASKmskw_XMMi16_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSDS_XMMi32_XMMu32_MEMu32_DEFINED 1 -#define XED_IFORM_VPDPWSSDS_XMMi32_XMMu32_XMMu32_DEFINED 1 -#define XED_IFORM_VPDPWSSDS_YMMi32_MASKmskw_YMMi16_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSDS_YMMi32_MASKmskw_YMMi16_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSDS_YMMi32_YMMu32_MEMu32_DEFINED 1 -#define XED_IFORM_VPDPWSSDS_YMMi32_YMMu32_YMMu32_DEFINED 1 -#define XED_IFORM_VPDPWSSDS_ZMMi32_MASKmskw_ZMMi16_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPDPWSSDS_ZMMi32_MASKmskw_ZMMi16_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERM2F128_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERM2F128_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERM2I128_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERM2I128_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPERMD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPERMD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2B_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2B_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2B_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2B_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2B_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2B_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2D_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2D_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2D_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2D_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2D_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2D_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2Q_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2Q_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2Q_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2Q_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2Q_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2Q_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2W_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2W_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2W_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2W_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2W_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMI2W_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMIL2PD_XMMdq_XMMdq_MEMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMIL2PD_XMMdq_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMIL2PD_XMMdq_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMIL2PD_YMMqq_YMMqq_MEMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMIL2PD_YMMqq_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMIL2PD_YMMqq_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMIL2PS_XMMdq_XMMdq_MEMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMIL2PS_XMMdq_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMIL2PS_XMMdq_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMIL2PS_YMMqq_YMMqq_MEMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMIL2PS_YMMqq_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMIL2PS_YMMqq_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMILPD_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMILPD_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMILPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPERMILPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPERMILPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPD_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMILPD_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMILPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPERMILPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMILPS_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMILPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPERMILPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPERMILPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMILPS_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMILPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPERMILPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPD_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMPD_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPERMPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPERMPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMQ_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMQ_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPERMQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2B_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2B_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2B_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2B_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2B_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2B_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2D_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2D_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2D_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2D_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2D_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2D_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2Q_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2Q_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2Q_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2Q_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2Q_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2Q_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2W_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2W_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2W_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2W_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2W_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMT2W_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPERMW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDB_XMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDB_XMMu8_MASKmskw_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDB_YMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDB_YMMu8_MASKmskw_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDB_ZMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDB_ZMMu8_MASKmskw_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDD_XMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDD_XMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDD_YMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDD_YMMu32_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDD_ZMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDD_ZMMu32_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDQ_XMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDQ_XMMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDQ_YMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDQ_YMMu64_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDQ_ZMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDQ_ZMMu64_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDW_XMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDW_XMMu16_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDW_YMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDW_YMMu16_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDW_ZMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPEXPANDW_ZMMu16_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPEXTRB_GPR32d_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPEXTRB_GPR32u8_XMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXTRB_MEMb_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPEXTRB_MEMu8_XMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXTRD_GPR32d_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPEXTRD_GPR32u32_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXTRD_MEMd_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPEXTRD_MEMu32_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXTRQ_GPR64q_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPEXTRQ_GPR64u64_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXTRQ_MEMq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPEXTRQ_MEMu64_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXTRW_GPR32d_XMMdq_IMMb_15_DEFINED 1 -#define XED_IFORM_VPEXTRW_GPR32d_XMMdq_IMMb_C5_DEFINED 1 -#define XED_IFORM_VPEXTRW_GPR32u16_XMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXTRW_MEMu16_XMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPEXTRW_MEMw_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPEXTRW_GPR32u16_XMMu16_IMM8_AVX512_C5_DEFINED 1 -#define XED_IFORM_VPGATHERDD_XMMu32_MASKmskw_MEMu32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VPGATHERDD_XMMu32_MEMd_XMMi32_VL128_DEFINED 1 -#define XED_IFORM_VPGATHERDD_YMMu32_MASKmskw_MEMu32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VPGATHERDD_YMMu32_MEMd_YMMi32_VL256_DEFINED 1 -#define XED_IFORM_VPGATHERDD_ZMMu32_MASKmskw_MEMu32_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VPGATHERDQ_XMMu64_MASKmskw_MEMu64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VPGATHERDQ_XMMu64_MEMq_XMMi64_VL128_DEFINED 1 -#define XED_IFORM_VPGATHERDQ_YMMu64_MASKmskw_MEMu64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VPGATHERDQ_YMMu64_MEMq_YMMi64_VL256_DEFINED 1 -#define XED_IFORM_VPGATHERDQ_ZMMu64_MASKmskw_MEMu64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VPGATHERQD_XMMu32_MASKmskw_MEMu32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VPGATHERQD_XMMu32_MASKmskw_MEMu32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VPGATHERQD_XMMu32_MEMd_XMMi32_VL128_DEFINED 1 -#define XED_IFORM_VPGATHERQD_XMMu32_MEMd_XMMi32_VL256_DEFINED 1 -#define XED_IFORM_VPGATHERQD_YMMu32_MASKmskw_MEMu32_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VPGATHERQQ_XMMu64_MASKmskw_MEMu64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VPGATHERQQ_XMMu64_MEMq_XMMi64_VL128_DEFINED 1 -#define XED_IFORM_VPGATHERQQ_YMMu64_MASKmskw_MEMu64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VPGATHERQQ_YMMu64_MEMq_YMMi64_VL256_DEFINED 1 -#define XED_IFORM_VPGATHERQQ_ZMMu64_MASKmskw_MEMu64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VPHADDBD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDBD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDBQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDBQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDBW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDBW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPHADDD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPHADDDQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDDQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDSW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDSW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDSW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPHADDSW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPHADDUBD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDUBD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDUBQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDUBQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDUBW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDUBW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDUDQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDUDQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDUWD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDUWD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDUWQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDUWQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPHADDW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPHADDWD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDWD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHADDWQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHADDWQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHMINPOSUW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHMINPOSUW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHSUBBW_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHSUBBW_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHSUBD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHSUBD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHSUBD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPHSUBD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPHSUBDQ_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHSUBDQ_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHSUBSW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHSUBSW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHSUBSW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPHSUBSW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPHSUBW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHSUBW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPHSUBW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPHSUBW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPHSUBWD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPHSUBWD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPINSRB_XMMdq_XMMdq_GPR32d_IMMb_DEFINED 1 -#define XED_IFORM_VPINSRB_XMMdq_XMMdq_MEMb_IMMb_DEFINED 1 -#define XED_IFORM_VPINSRB_XMMu8_XMMu8_GPR32u8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPINSRB_XMMu8_XMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPINSRD_XMMdq_XMMdq_GPR32d_IMMb_DEFINED 1 -#define XED_IFORM_VPINSRD_XMMdq_XMMdq_MEMd_IMMb_DEFINED 1 -#define XED_IFORM_VPINSRD_XMMu32_XMMu32_GPR32u32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPINSRD_XMMu32_XMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPINSRQ_XMMdq_XMMdq_GPR64q_IMMb_DEFINED 1 -#define XED_IFORM_VPINSRQ_XMMdq_XMMdq_MEMq_IMMb_DEFINED 1 -#define XED_IFORM_VPINSRQ_XMMu64_XMMu64_GPR64u64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPINSRQ_XMMu64_XMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPINSRW_XMMdq_XMMdq_GPR32d_IMMb_DEFINED 1 -#define XED_IFORM_VPINSRW_XMMdq_XMMdq_MEMw_IMMb_DEFINED 1 -#define XED_IFORM_VPINSRW_XMMu16_XMMu16_GPR32u16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPINSRW_XMMu16_XMMu16_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPLZCNTD_XMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPLZCNTD_XMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPLZCNTD_YMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPLZCNTD_YMMu32_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPLZCNTD_ZMMu32_MASKmskw_MEMu32_AVX512CD_DEFINED 1 -#define XED_IFORM_VPLZCNTD_ZMMu32_MASKmskw_ZMMu32_AVX512CD_DEFINED 1 -#define XED_IFORM_VPLZCNTQ_XMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPLZCNTQ_XMMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPLZCNTQ_YMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPLZCNTQ_YMMu64_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPLZCNTQ_ZMMu64_MASKmskw_MEMu64_AVX512CD_DEFINED 1 -#define XED_IFORM_VPLZCNTQ_ZMMu64_MASKmskw_ZMMu64_AVX512CD_DEFINED 1 -#define XED_IFORM_VPMACSDD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSDD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSDQH_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSDQH_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSDQL_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSDQL_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSSDD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSSDD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSSDQH_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSSDQH_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSSDQL_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSSDQL_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSSWD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSSWD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSSWW_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSSWW_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSWD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSWD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSWW_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMACSWW_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMADCSSWD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMADCSSWD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMADCSWD_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMADCSWD_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMADD52HUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADD52HUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADD52HUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADD52HUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADD52HUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADD52HUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADD52LUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADD52LUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADD52LUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADD52LUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADD52LUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADD52LUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDUBSW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMADDUBSW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMADDUBSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDUBSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDUBSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDUBSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDUBSW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMADDUBSW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMADDUBSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDUBSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDWD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMADDWD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMADDWD_XMMi32_MASKmskw_XMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDWD_XMMi32_MASKmskw_XMMi16_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDWD_YMMi32_MASKmskw_YMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDWD_YMMi32_MASKmskw_YMMi16_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDWD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMADDWD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMADDWD_ZMMi32_MASKmskw_ZMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMADDWD_ZMMi32_MASKmskw_ZMMi16_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMASKMOVD_MEMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMASKMOVD_MEMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMASKMOVD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMASKMOVD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMASKMOVQ_MEMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMASKMOVQ_MEMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMASKMOVQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMASKMOVQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMAXSB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMAXSB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMAXSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMAXSB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMAXSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMAXSD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMAXSD_XMMi32_MASKmskw_XMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSD_XMMi32_MASKmskw_XMMi32_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSD_YMMi32_MASKmskw_YMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSD_YMMi32_MASKmskw_YMMi32_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMAXSD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMAXSD_ZMMi32_MASKmskw_ZMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSD_ZMMi32_MASKmskw_ZMMi32_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSQ_XMMi64_MASKmskw_XMMi64_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSQ_XMMi64_MASKmskw_XMMi64_XMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSQ_YMMi64_MASKmskw_YMMi64_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSQ_YMMi64_MASKmskw_YMMi64_YMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSQ_ZMMi64_MASKmskw_ZMMi64_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSQ_ZMMi64_MASKmskw_ZMMi64_ZMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMAXSW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMAXSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMAXSW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMAXSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMAXUB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMAXUB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMAXUB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMAXUB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMAXUD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMAXUD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMAXUD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMAXUD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMAXUW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMAXUW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMAXUW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMAXUW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMAXUW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMINSB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMINSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMINSB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMINSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMINSD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMINSD_XMMi32_MASKmskw_XMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSD_XMMi32_MASKmskw_XMMi32_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSD_YMMi32_MASKmskw_YMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSD_YMMi32_MASKmskw_YMMi32_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMINSD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMINSD_ZMMi32_MASKmskw_ZMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSD_ZMMi32_MASKmskw_ZMMi32_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSQ_XMMi64_MASKmskw_XMMi64_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSQ_XMMi64_MASKmskw_XMMi64_XMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSQ_YMMi64_MASKmskw_YMMi64_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSQ_YMMi64_MASKmskw_YMMi64_YMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSQ_ZMMi64_MASKmskw_ZMMi64_MEMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSQ_ZMMi64_MASKmskw_ZMMi64_ZMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMINSW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMINSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMINSW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMINSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMINUB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMINUB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMINUB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMINUB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMINUD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMINUD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMINUD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMINUD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMINUW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMINUW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMINUW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMINUW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMINUW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVB2M_MASKmskw_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVB2M_MASKmskw_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVB2M_MASKmskw_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVD2M_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVD2M_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVD2M_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDB_MEMu8_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDB_MEMu8_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDB_MEMu8_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDB_XMMu8_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDB_XMMu8_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDB_XMMu8_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDW_MEMu16_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDW_MEMu16_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDW_MEMu16_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDW_XMMu16_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDW_XMMu16_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVDW_YMMu16_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2B_XMMu8_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2B_YMMu8_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2B_ZMMu8_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2D_XMMu32_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2D_YMMu32_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2D_ZMMu32_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2Q_XMMu64_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2Q_YMMu64_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2Q_ZMMu64_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2W_XMMu16_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2W_YMMu16_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVM2W_ZMMu16_MASKmskw_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVMSKB_GPR32d_XMMdq_DEFINED 1 -#define XED_IFORM_VPMOVMSKB_GPR32d_YMMqq_DEFINED 1 -#define XED_IFORM_VPMOVQ2M_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQ2M_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQ2M_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQB_MEMu8_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQB_MEMu8_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQB_MEMu8_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQB_XMMu8_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQB_XMMu8_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQB_XMMu8_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQD_MEMu32_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQD_MEMu32_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQD_MEMu32_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQD_XMMu32_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQD_XMMu32_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQD_YMMu32_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQW_MEMu16_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQW_MEMu16_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQW_MEMu16_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQW_XMMu16_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQW_XMMu16_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVQW_XMMu16_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDB_MEMi8_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDB_MEMi8_MASKmskw_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDB_MEMi8_MASKmskw_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDB_XMMi8_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDB_XMMi8_MASKmskw_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDB_XMMi8_MASKmskw_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDW_MEMi16_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDW_MEMi16_MASKmskw_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDW_MEMi16_MASKmskw_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDW_XMMi16_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDW_XMMi16_MASKmskw_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSDW_YMMi16_MASKmskw_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQB_MEMi8_MASKmskw_XMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQB_MEMi8_MASKmskw_YMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQB_MEMi8_MASKmskw_ZMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQB_XMMi8_MASKmskw_XMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQB_XMMi8_MASKmskw_YMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQB_XMMi8_MASKmskw_ZMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQD_MEMi32_MASKmskw_XMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQD_MEMi32_MASKmskw_YMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQD_MEMi32_MASKmskw_ZMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQD_XMMi32_MASKmskw_XMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQD_XMMi32_MASKmskw_YMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQD_YMMi32_MASKmskw_ZMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQW_MEMi16_MASKmskw_XMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQW_MEMi16_MASKmskw_YMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQW_MEMi16_MASKmskw_ZMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQW_XMMi16_MASKmskw_XMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQW_XMMi16_MASKmskw_YMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSQW_XMMi16_MASKmskw_ZMMi64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSWB_MEMi8_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSWB_MEMi8_MASKmskw_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSWB_MEMi8_MASKmskw_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSWB_XMMi8_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSWB_XMMi8_MASKmskw_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSWB_YMMi8_MASKmskw_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBD_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VPMOVSXBD_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VPMOVSXBD_XMMi32_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBD_XMMi32_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBD_YMMi32_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBD_YMMi32_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBD_YMMqq_MEMq_DEFINED 1 -#define XED_IFORM_VPMOVSXBD_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPMOVSXBD_ZMMi32_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBD_ZMMi32_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBQ_XMMdq_MEMw_DEFINED 1 -#define XED_IFORM_VPMOVSXBQ_XMMdq_XMMw_DEFINED 1 -#define XED_IFORM_VPMOVSXBQ_XMMi64_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBQ_XMMi64_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBQ_YMMi64_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBQ_YMMi64_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBQ_YMMqq_MEMd_DEFINED 1 -#define XED_IFORM_VPMOVSXBQ_YMMqq_XMMd_DEFINED 1 -#define XED_IFORM_VPMOVSXBQ_ZMMi64_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBQ_ZMMi64_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBW_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VPMOVSXBW_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VPMOVSXBW_XMMi16_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBW_XMMi16_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBW_YMMi16_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBW_YMMi16_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBW_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMOVSXBW_YMMqq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMOVSXBW_ZMMi16_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXBW_ZMMi16_MASKmskw_YMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXDQ_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VPMOVSXDQ_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VPMOVSXDQ_XMMi64_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXDQ_XMMi64_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXDQ_YMMi64_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXDQ_YMMi64_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXDQ_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMOVSXDQ_YMMqq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMOVSXDQ_ZMMi64_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXDQ_ZMMi64_MASKmskw_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWD_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VPMOVSXWD_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VPMOVSXWD_XMMi32_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWD_XMMi32_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWD_YMMi32_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWD_YMMi32_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWD_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMOVSXWD_YMMqq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMOVSXWD_ZMMi32_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWD_ZMMi32_MASKmskw_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWQ_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VPMOVSXWQ_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VPMOVSXWQ_XMMi64_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWQ_XMMi64_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWQ_YMMi64_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWQ_YMMi64_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWQ_YMMqq_MEMq_DEFINED 1 -#define XED_IFORM_VPMOVSXWQ_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPMOVSXWQ_ZMMi64_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVSXWQ_ZMMi64_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDB_MEMu8_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDB_MEMu8_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDB_MEMu8_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDB_XMMu8_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDB_XMMu8_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDB_XMMu8_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDW_MEMu16_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDW_MEMu16_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDW_MEMu16_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDW_XMMu16_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDW_XMMu16_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSDW_YMMu16_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQB_MEMu8_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQB_MEMu8_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQB_MEMu8_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQB_XMMu8_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQB_XMMu8_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQB_XMMu8_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQD_MEMu32_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQD_MEMu32_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQD_MEMu32_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQD_XMMu32_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQD_XMMu32_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQD_YMMu32_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQW_MEMu16_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQW_MEMu16_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQW_MEMu16_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQW_XMMu16_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQW_XMMu16_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSQW_XMMu16_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSWB_MEMu8_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSWB_MEMu8_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSWB_MEMu8_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSWB_XMMu8_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSWB_XMMu8_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVUSWB_YMMu8_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVW2M_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVW2M_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVW2M_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVWB_MEMu8_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVWB_MEMu8_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVWB_MEMu8_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVWB_XMMu8_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVWB_XMMu8_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVWB_YMMu8_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBD_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VPMOVZXBD_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VPMOVZXBD_XMMi32_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBD_XMMi32_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBD_YMMi32_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBD_YMMi32_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBD_YMMqq_MEMq_DEFINED 1 -#define XED_IFORM_VPMOVZXBD_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPMOVZXBD_ZMMi32_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBD_ZMMi32_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBQ_XMMdq_MEMw_DEFINED 1 -#define XED_IFORM_VPMOVZXBQ_XMMdq_XMMw_DEFINED 1 -#define XED_IFORM_VPMOVZXBQ_XMMi64_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBQ_XMMi64_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBQ_YMMi64_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBQ_YMMi64_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBQ_YMMqq_MEMd_DEFINED 1 -#define XED_IFORM_VPMOVZXBQ_YMMqq_XMMd_DEFINED 1 -#define XED_IFORM_VPMOVZXBQ_ZMMi64_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBQ_ZMMi64_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBW_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VPMOVZXBW_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VPMOVZXBW_XMMi16_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBW_XMMi16_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBW_YMMi16_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBW_YMMi16_MASKmskw_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBW_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMOVZXBW_YMMqq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMOVZXBW_ZMMi16_MASKmskw_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXBW_ZMMi16_MASKmskw_YMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXDQ_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VPMOVZXDQ_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VPMOVZXDQ_XMMi64_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXDQ_XMMi64_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXDQ_YMMi64_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXDQ_YMMi64_MASKmskw_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXDQ_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMOVZXDQ_YMMqq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMOVZXDQ_ZMMi64_MASKmskw_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXDQ_ZMMi64_MASKmskw_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWD_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VPMOVZXWD_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VPMOVZXWD_XMMi32_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWD_XMMi32_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWD_YMMi32_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWD_YMMi32_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWD_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMOVZXWD_YMMqq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMOVZXWD_ZMMi32_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWD_ZMMi32_MASKmskw_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWQ_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VPMOVZXWQ_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VPMOVZXWQ_XMMi64_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWQ_XMMi64_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWQ_YMMi64_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWQ_YMMi64_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWQ_YMMqq_MEMq_DEFINED 1 -#define XED_IFORM_VPMOVZXWQ_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPMOVZXWQ_ZMMi64_MASKmskw_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMOVZXWQ_ZMMi64_MASKmskw_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULDQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMULDQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMULDQ_XMMi64_MASKmskw_XMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULDQ_XMMi64_MASKmskw_XMMi32_XMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULDQ_YMMi64_MASKmskw_YMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULDQ_YMMi64_MASKmskw_YMMi32_YMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULDQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMULDQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMULDQ_ZMMi64_MASKmskw_ZMMi32_MEMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULDQ_ZMMi64_MASKmskw_ZMMi32_ZMMi32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHRSW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMULHRSW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMULHRSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHRSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHRSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHRSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHRSW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMULHRSW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMULHRSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHRSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHUW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMULHUW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMULHUW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHUW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHUW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMULHUW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMULHUW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHUW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHUW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHUW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMULHW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMULHW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMULHW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMULHW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULHW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMULLD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMULLD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMULLD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMULLD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMULLW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMULLW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMULLW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMULLW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULLW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPMULTISHIFTQB_XMMu8_MASKmskw_XMMu8_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULTISHIFTQB_XMMu8_MASKmskw_XMMu8_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULTISHIFTQB_YMMu8_MASKmskw_YMMu8_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULTISHIFTQB_YMMu8_MASKmskw_YMMu8_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULTISHIFTQB_ZMMu8_MASKmskw_ZMMu8_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULTISHIFTQB_ZMMu8_MASKmskw_ZMMu8_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPMULUDQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPMULUDQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPMULUDQ_XMMu64_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULUDQ_XMMu64_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULUDQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPMULUDQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPMULUDQ_YMMu64_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULUDQ_YMMu64_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULUDQ_ZMMu64_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPMULUDQ_ZMMu64_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTB_XMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTB_XMMu8_MASKmskw_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTB_YMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTB_YMMu8_MASKmskw_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTB_ZMMu8_MASKmskw_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTB_ZMMu8_MASKmskw_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTD_XMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTD_XMMu32_MASKmskw_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTD_YMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTD_YMMu32_MASKmskw_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTD_ZMMu32_MASKmskw_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTD_ZMMu32_MASKmskw_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTQ_XMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTQ_XMMu64_MASKmskw_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTQ_YMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTQ_YMMu64_MASKmskw_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTQ_ZMMu64_MASKmskw_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTQ_ZMMu64_MASKmskw_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTW_XMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTW_XMMu16_MASKmskw_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTW_YMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTW_YMMu16_MASKmskw_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTW_ZMMu16_MASKmskw_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPOPCNTW_ZMMu16_MASKmskw_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPOR_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPOR_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPOR_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPOR_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPORD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPORD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPORD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPORD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPORD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPORD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPORQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPORQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPORQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPORQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPORQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPORQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPPERM_XMMdq_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPPERM_XMMdq_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPPERM_XMMdq_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPROLD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPROLVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPRORD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPRORVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPROTB_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPROTB_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPROTB_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPROTB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPROTB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPROTD_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPROTD_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPROTD_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPROTD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPROTD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPROTQ_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPROTQ_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPROTQ_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPROTQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPROTQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPROTW_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPROTW_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPROTW_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPROTW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPROTW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSADBW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSADBW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSADBW_XMMu16_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSADBW_XMMu16_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSADBW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSADBW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSADBW_YMMu16_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSADBW_YMMu16_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSADBW_ZMMu16_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSADBW_ZMMu16_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSCATTERDD_MEMu32_MASKmskw_XMMu32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VPSCATTERDD_MEMu32_MASKmskw_YMMu32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VPSCATTERDD_MEMu32_MASKmskw_ZMMu32_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VPSCATTERDQ_MEMu64_MASKmskw_XMMu64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VPSCATTERDQ_MEMu64_MASKmskw_YMMu64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VPSCATTERDQ_MEMu64_MASKmskw_ZMMu64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VPSCATTERQD_MEMu32_MASKmskw_XMMu32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VPSCATTERQD_MEMu32_MASKmskw_XMMu32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VPSCATTERQD_MEMu32_MASKmskw_YMMu32_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VPSCATTERQQ_MEMu64_MASKmskw_XMMu64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VPSCATTERQQ_MEMu64_MASKmskw_YMMu64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VPSCATTERQQ_MEMu64_MASKmskw_ZMMu64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VPSHAB_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHAB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSHAB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHAD_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHAD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSHAD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHAQ_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHAQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSHAQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHAW_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHAW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSHAW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHLB_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHLB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSHLB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHLD_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHLD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSHLD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHLDD_XMMu32_MASKmskw_XMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDD_XMMu32_MASKmskw_XMMu32_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDD_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDD_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDD_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDQ_XMMu64_MASKmskw_XMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDQ_XMMu64_MASKmskw_XMMu64_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDQ_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDQ_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDW_XMMu16_MASKmskw_XMMu16_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDW_XMMu16_MASKmskw_XMMu16_XMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDW_YMMu16_MASKmskw_YMMu16_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDW_YMMu16_MASKmskw_YMMu16_YMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDW_ZMMu16_MASKmskw_ZMMu16_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLDW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHLQ_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHLQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSHLQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHLW_XMMdq_MEMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHLW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSHLW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHRDD_XMMu32_MASKmskw_XMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDD_XMMu32_MASKmskw_XMMu32_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDD_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDD_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDD_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDQ_XMMu64_MASKmskw_XMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDQ_XMMu64_MASKmskw_XMMu64_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDQ_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDQ_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDW_XMMu16_MASKmskw_XMMu16_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDW_XMMu16_MASKmskw_XMMu16_XMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDW_YMMu16_MASKmskw_YMMu16_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDW_YMMu16_MASKmskw_YMMu16_YMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDW_ZMMu16_MASKmskw_ZMMu16_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHRDW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSHUFB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSHUFB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSHUFB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSHUFB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_XMMu64_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_XMMu64_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_YMMu64_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_YMMu64_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_ZMMu64_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_ZMMu64_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFD_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFD_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFD_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFD_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFHW_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFHW_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFHW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFHW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFHW_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFHW_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFHW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFHW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFHW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFHW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFLW_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFLW_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFLW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFLW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFLW_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFLW_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSHUFLW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFLW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFLW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSHUFLW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSIGNB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSIGNB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSIGNB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSIGNB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSIGND_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSIGND_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSIGND_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSIGND_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSIGNW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSIGNW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSIGNW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSIGNW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSLLD_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSLLD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSLLD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSLLD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLD_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSLLD_YMMqq_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSLLD_YMMqq_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPSLLD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLD_YMMu32_MASKmskw_YMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLD_ZMMu32_MASKmskw_ZMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLDQ_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSLLDQ_XMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLDQ_XMMu8_XMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLDQ_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSLLDQ_YMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLDQ_YMMu8_YMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLDQ_ZMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLDQ_ZMMu8_ZMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSLLQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSLLQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSLLQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSLLQ_YMMqq_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSLLQ_YMMqq_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPSLLQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_YMMu64_MASKmskw_YMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_ZMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSLLVD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSLLVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSLLVD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSLLVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSLLVQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSLLVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSLLVQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSLLVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSLLW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSLLW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSLLW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSLLW_YMMqq_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSLLW_YMMqq_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPSLLW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_YMMu16_MASKmskw_YMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSLLW_ZMMu16_MASKmskw_ZMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRAD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRAD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSRAD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRAD_YMMqq_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRAD_YMMqq_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPSRAD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_YMMu32_MASKmskw_YMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAD_ZMMu32_MASKmskw_ZMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_YMMu64_MASKmskw_YMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_ZMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRAVD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSRAVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSRAVD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSRAVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRAW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRAW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSRAW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRAW_YMMqq_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRAW_YMMqq_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPSRAW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_YMMu16_MASKmskw_YMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRAW_ZMMu16_MASKmskw_ZMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRLD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRLD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSRLD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRLD_YMMqq_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRLD_YMMqq_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPSRLD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_YMMu32_MASKmskw_YMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLD_ZMMu32_MASKmskw_ZMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLDQ_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRLDQ_XMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLDQ_XMMu8_XMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLDQ_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRLDQ_YMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLDQ_YMMu8_YMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLDQ_ZMMu8_MEMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLDQ_ZMMu8_ZMMu8_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRLQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRLQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSRLQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRLQ_YMMqq_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRLQ_YMMqq_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPSRLQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_YMMu64_MASKmskw_YMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_ZMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRLVD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSRLVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSRLVD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSRLVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRLVQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSRLVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSRLVQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSRLVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRLW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRLW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSRLW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VPSRLW_YMMqq_YMMqq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSRLW_YMMqq_YMMqq_XMMq_DEFINED 1 -#define XED_IFORM_VPSRLW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_YMMu16_MASKmskw_YMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSRLW_ZMMu16_MASKmskw_ZMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSUBB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSUBB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSUBB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSUBB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSUBD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSUBD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSUBD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSUBD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSUBQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSUBQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSUBQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSUBQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSUBSB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSUBSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSUBSB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSUBSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSUBSW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSUBSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSUBSW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSUBSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSB_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSUBUSB_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSUBUSB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSB_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSUBUSB_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSUBUSB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSUBUSW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSUBUSW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSUBUSW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSUBUSW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBUSW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPSUBW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPSUBW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPSUBW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPSUBW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPSUBW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGD_XMMu32_MASKmskw_XMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGD_XMMu32_MASKmskw_XMMu32_XMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGD_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGD_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGD_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGQ_XMMu64_MASKmskw_XMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGQ_XMMu64_MASKmskw_XMMu64_XMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGQ_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGQ_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTERNLOGQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VPTEST_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPTEST_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPTEST_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPTEST_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHBW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKHBW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKHBW_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHBW_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHBW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKHBW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKHBW_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHBW_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHBW_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHBW_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHDQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKHDQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKHDQ_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHDQ_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHDQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKHDQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKHDQ_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHDQ_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHDQ_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHDQ_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHQDQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKHQDQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKHQDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHQDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHQDQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKHQDQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKHQDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHQDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHQDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHQDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHWD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKHWD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKHWD_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHWD_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHWD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKHWD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKHWD_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHWD_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHWD_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKHWD_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLBW_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKLBW_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKLBW_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLBW_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLBW_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKLBW_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKLBW_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLBW_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLBW_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLBW_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLDQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKLDQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKLDQ_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLDQ_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLDQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKLDQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKLDQ_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLDQ_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLDQ_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLDQ_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLQDQ_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKLQDQ_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKLQDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLQDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLQDQ_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKLQDQ_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKLQDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLQDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLQDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLQDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLWD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKLWD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPUNPCKLWD_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLWD_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLWD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKLWD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPUNPCKLWD_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLWD_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLWD_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPUNPCKLWD_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512_DEFINED 1 -#define XED_IFORM_VPXOR_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VPXOR_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VPXOR_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VPXOR_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VPXORD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPXORD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPXORD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPXORD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPXORD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPXORD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VPXORQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPXORQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPXORQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPXORQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPXORQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VPXORQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPD_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPD_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPS_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPS_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGEPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGESD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGESD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGESS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRANGESS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PD_XMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PD_XMMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PD_YMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PD_YMMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PD_ZMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PD_ZMMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PS_XMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PS_XMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PS_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PS_YMMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PS_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14PS_ZMMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRCP14SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRCP28PD_ZMMf64_MASKmskw_MEMf64_AVX512ER_DEFINED 1 -#define XED_IFORM_VRCP28PD_ZMMf64_MASKmskw_ZMMf64_AVX512ER_DEFINED 1 -#define XED_IFORM_VRCP28PS_ZMMf32_MASKmskw_MEMf32_AVX512ER_DEFINED 1 -#define XED_IFORM_VRCP28PS_ZMMf32_MASKmskw_ZMMf32_AVX512ER_DEFINED 1 -#define XED_IFORM_VRCP28SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512ER_DEFINED 1 -#define XED_IFORM_VRCP28SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512ER_DEFINED 1 -#define XED_IFORM_VRCP28SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512ER_DEFINED 1 -#define XED_IFORM_VRCP28SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512ER_DEFINED 1 -#define XED_IFORM_VRCPPH_XMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRCPPH_XMMf16_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRCPPH_YMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRCPPH_YMMf16_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRCPPH_ZMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRCPPH_ZMMf16_MASKmskw_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRCPPS_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VRCPPS_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VRCPPS_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VRCPPS_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VRCPSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRCPSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRCPSS_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VRCPSS_XMMdq_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VREDUCEPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPH_XMMf16_MASKmskw_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPH_XMMf16_MASKmskw_XMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPH_YMMf16_MASKmskw_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPH_YMMf16_MASKmskw_YMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPH_ZMMf16_MASKmskw_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPH_ZMMf16_MASKmskw_ZMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCEPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCESD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCESD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCESH_XMMf16_MASKmskw_XMMf16_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCESH_XMMf16_MASKmskw_XMMf16_XMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCESS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VREDUCESS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPH_XMMf16_MASKmskw_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPH_XMMf16_MASKmskw_XMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPH_YMMf16_MASKmskw_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPH_YMMf16_MASKmskw_YMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPH_ZMMf16_MASKmskw_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPH_ZMMf16_MASKmskw_ZMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALEPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALESD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALESD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALESH_XMMf16_MASKmskw_XMMf16_MEMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALESH_XMMf16_MASKmskw_XMMf16_XMMf16_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALESS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VRNDSCALESS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VROUNDPD_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VROUNDPD_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VROUNDPD_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VROUNDPD_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VROUNDPS_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VROUNDPS_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VROUNDPS_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VROUNDPS_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VROUNDSD_XMMdq_XMMdq_MEMq_IMMb_DEFINED 1 -#define XED_IFORM_VROUNDSD_XMMdq_XMMdq_XMMq_IMMb_DEFINED 1 -#define XED_IFORM_VROUNDSS_XMMdq_XMMdq_MEMd_IMMb_DEFINED 1 -#define XED_IFORM_VROUNDSS_XMMdq_XMMdq_XMMd_IMMb_DEFINED 1 -#define XED_IFORM_VRSQRT14PD_XMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14PD_XMMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14PD_YMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14PD_YMMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14PD_ZMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14PD_ZMMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14PS_XMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14PS_XMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14PS_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14PS_YMMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14PS_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14PS_ZMMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT14SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRT28PD_ZMMf64_MASKmskw_MEMf64_AVX512ER_DEFINED 1 -#define XED_IFORM_VRSQRT28PD_ZMMf64_MASKmskw_ZMMf64_AVX512ER_DEFINED 1 -#define XED_IFORM_VRSQRT28PS_ZMMf32_MASKmskw_MEMf32_AVX512ER_DEFINED 1 -#define XED_IFORM_VRSQRT28PS_ZMMf32_MASKmskw_ZMMf32_AVX512ER_DEFINED 1 -#define XED_IFORM_VRSQRT28SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512ER_DEFINED 1 -#define XED_IFORM_VRSQRT28SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512ER_DEFINED 1 -#define XED_IFORM_VRSQRT28SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512ER_DEFINED 1 -#define XED_IFORM_VRSQRT28SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512ER_DEFINED 1 -#define XED_IFORM_VRSQRTPH_XMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRTPH_XMMf16_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRTPH_YMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRTPH_YMMf16_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRTPH_ZMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRTPH_ZMMf16_MASKmskw_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRTPS_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VRSQRTPS_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VRSQRTPS_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VRSQRTPS_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VRSQRTSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRTSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VRSQRTSS_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VRSQRTSS_XMMdq_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VSCALEFPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSCALEFSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSCATTERDPD_MEMf64_MASKmskw_XMMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VSCATTERDPD_MEMf64_MASKmskw_YMMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VSCATTERDPD_MEMf64_MASKmskw_ZMMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VSCATTERDPS_MEMf32_MASKmskw_XMMf32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VSCATTERDPS_MEMf32_MASKmskw_YMMf32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VSCATTERDPS_MEMf32_MASKmskw_ZMMf32_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VSCATTERPF0DPD_MEMf64_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VSCATTERPF0DPS_MEMf32_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VSCATTERPF0QPD_MEMf64_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VSCATTERPF0QPS_MEMf32_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VSCATTERPF1DPD_MEMf64_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VSCATTERPF1DPS_MEMf32_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VSCATTERPF1QPD_MEMf64_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VSCATTERPF1QPS_MEMf32_MASKmskw_AVX512PF_VL512_DEFINED 1 -#define XED_IFORM_VSCATTERQPD_MEMf64_MASKmskw_XMMf64_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VSCATTERQPD_MEMf64_MASKmskw_YMMf64_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VSCATTERQPD_MEMf64_MASKmskw_ZMMf64_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VSCATTERQPS_MEMf32_MASKmskw_XMMf32_AVX512_VL128_DEFINED 1 -#define XED_IFORM_VSCATTERQPS_MEMf32_MASKmskw_XMMf32_AVX512_VL256_DEFINED 1 -#define XED_IFORM_VSCATTERQPS_MEMf32_MASKmskw_YMMf32_AVX512_VL512_DEFINED 1 -#define XED_IFORM_VSHUFF32X4_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFF32X4_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFF32X4_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFF32X4_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFF64X2_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFF64X2_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFF64X2_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFF64X2_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFI32X4_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFI32X4_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFI32X4_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFI32X4_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFI64X2_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFI64X2_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFI64X2_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFI64X2_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPD_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VSHUFPD_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VSHUFPD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPD_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPD_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPD_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VSHUFPD_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VSHUFPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPS_XMMdq_XMMdq_MEMdq_IMMb_DEFINED 1 -#define XED_IFORM_VSHUFPS_XMMdq_XMMdq_XMMdq_IMMb_DEFINED 1 -#define XED_IFORM_VSHUFPS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPS_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPS_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPS_YMMqq_YMMqq_MEMqq_IMMb_DEFINED 1 -#define XED_IFORM_VSHUFPS_YMMqq_YMMqq_YMMqq_IMMb_DEFINED 1 -#define XED_IFORM_VSHUFPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSHUFPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VSQRTPD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VSQRTPD_XMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPD_XMMf64_MASKmskw_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPD_YMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPD_YMMf64_MASKmskw_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPD_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VSQRTPD_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VSQRTPD_ZMMf64_MASKmskw_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPD_ZMMf64_MASKmskw_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPH_XMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPH_XMMf16_MASKmskw_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPH_YMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPH_YMMf16_MASKmskw_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPH_ZMMf16_MASKmskw_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPH_ZMMf16_MASKmskw_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPS_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VSQRTPS_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VSQRTPS_XMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPS_XMMf32_MASKmskw_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPS_YMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPS_YMMf32_MASKmskw_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPS_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VSQRTPS_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VSQRTPS_ZMMf32_MASKmskw_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTPS_ZMMf32_MASKmskw_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTSD_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VSQRTSD_XMMdq_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VSQRTSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTSS_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VSQRTSS_XMMdq_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VSQRTSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSQRTSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSTMXCSR_MEMd_DEFINED 1 -#define XED_IFORM_VSUBPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VSUBPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VSUBPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VSUBPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VSUBPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VSUBPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VSUBPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VSUBPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VSUBPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSUBPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSUBSD_XMMdq_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VSUBSD_XMMdq_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VSUBSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSUBSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VSUBSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSUBSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VSUBSS_XMMdq_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VSUBSS_XMMdq_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VSUBSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VSUBSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VTESTPD_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VTESTPD_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VTESTPD_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VTESTPD_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VTESTPS_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VTESTPS_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VTESTPS_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VTESTPS_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VUCOMISD_XMMdq_MEMq_DEFINED 1 -#define XED_IFORM_VUCOMISD_XMMdq_XMMq_DEFINED 1 -#define XED_IFORM_VUCOMISD_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUCOMISD_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUCOMISH_XMMf16_MEMf16_AVX512_DEFINED 1 -#define XED_IFORM_VUCOMISH_XMMf16_XMMf16_AVX512_DEFINED 1 -#define XED_IFORM_VUCOMISS_XMMdq_MEMd_DEFINED 1 -#define XED_IFORM_VUCOMISS_XMMdq_XMMd_DEFINED 1 -#define XED_IFORM_VUCOMISS_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUCOMISS_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VUNPCKHPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VUNPCKHPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VUNPCKHPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VUNPCKHPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VUNPCKHPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VUNPCKHPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VUNPCKHPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VUNPCKHPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKHPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VUNPCKLPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VUNPCKLPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VUNPCKLPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VUNPCKLPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VUNPCKLPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VUNPCKLPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VUNPCKLPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VUNPCKLPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512_DEFINED 1 -#define XED_IFORM_VUNPCKLPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512_DEFINED 1 -#define XED_IFORM_VXORPD_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VXORPD_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VXORPD_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VXORPD_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VXORPD_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VXORPD_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VXORPD_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VXORPD_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VXORPD_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512_DEFINED 1 -#define XED_IFORM_VXORPD_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512_DEFINED 1 -#define XED_IFORM_VXORPS_XMMdq_XMMdq_MEMdq_DEFINED 1 -#define XED_IFORM_VXORPS_XMMdq_XMMdq_XMMdq_DEFINED 1 -#define XED_IFORM_VXORPS_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VXORPS_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VXORPS_YMMqq_YMMqq_MEMqq_DEFINED 1 -#define XED_IFORM_VXORPS_YMMqq_YMMqq_YMMqq_DEFINED 1 -#define XED_IFORM_VXORPS_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VXORPS_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VXORPS_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512_DEFINED 1 -#define XED_IFORM_VXORPS_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512_DEFINED 1 -#define XED_IFORM_VZEROALL_DEFINED 1 -#define XED_IFORM_VZEROUPPER_DEFINED 1 -#define XED_IFORM_WBINVD_DEFINED 1 -#define XED_IFORM_WBNOINVD_DEFINED 1 -#define XED_IFORM_WRFSBASE_GPRy_DEFINED 1 -#define XED_IFORM_WRGSBASE_GPRy_DEFINED 1 -#define XED_IFORM_WRMSR_DEFINED 1 -#define XED_IFORM_WRPKRU_DEFINED 1 -#define XED_IFORM_WRSSD_MEMu32_GPR32u32_DEFINED 1 -#define XED_IFORM_WRSSQ_MEMu64_GPR64u64_DEFINED 1 -#define XED_IFORM_WRUSSD_MEMu32_GPR32u32_DEFINED 1 -#define XED_IFORM_WRUSSQ_MEMu64_GPR64u64_DEFINED 1 -#define XED_IFORM_XABORT_IMMb_DEFINED 1 -#define XED_IFORM_XADD_GPR8_GPR8_DEFINED 1 -#define XED_IFORM_XADD_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_XADD_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_XADD_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_XADD_LOCK_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_XADD_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_XBEGIN_RELBRz_DEFINED 1 -#define XED_IFORM_XCHG_GPR8_GPR8_DEFINED 1 -#define XED_IFORM_XCHG_GPRv_GPRv_DEFINED 1 -#define XED_IFORM_XCHG_GPRv_OrAX_DEFINED 1 -#define XED_IFORM_XCHG_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_XCHG_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_XEND_DEFINED 1 -#define XED_IFORM_XGETBV_DEFINED 1 -#define XED_IFORM_XLAT_DEFINED 1 -#define XED_IFORM_XOR_AL_IMMb_DEFINED 1 -#define XED_IFORM_XOR_GPR8_GPR8_30_DEFINED 1 -#define XED_IFORM_XOR_GPR8_GPR8_32_DEFINED 1 -#define XED_IFORM_XOR_GPR8_IMMb_80r6_DEFINED 1 -#define XED_IFORM_XOR_GPR8_IMMb_82r6_DEFINED 1 -#define XED_IFORM_XOR_GPR8_MEMb_DEFINED 1 -#define XED_IFORM_XOR_GPRv_GPRv_31_DEFINED 1 -#define XED_IFORM_XOR_GPRv_GPRv_33_DEFINED 1 -#define XED_IFORM_XOR_GPRv_IMMb_DEFINED 1 -#define XED_IFORM_XOR_GPRv_IMMz_DEFINED 1 -#define XED_IFORM_XOR_GPRv_MEMv_DEFINED 1 -#define XED_IFORM_XOR_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_XOR_MEMb_IMMb_80r6_DEFINED 1 -#define XED_IFORM_XOR_MEMb_IMMb_82r6_DEFINED 1 -#define XED_IFORM_XOR_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_XOR_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_XOR_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_XOR_OrAX_IMMz_DEFINED 1 -#define XED_IFORM_XORPD_XMMxuq_MEMxuq_DEFINED 1 -#define XED_IFORM_XORPD_XMMxuq_XMMxuq_DEFINED 1 -#define XED_IFORM_XORPS_XMMxud_MEMxud_DEFINED 1 -#define XED_IFORM_XORPS_XMMxud_XMMxud_DEFINED 1 -#define XED_IFORM_XOR_LOCK_MEMb_GPR8_DEFINED 1 -#define XED_IFORM_XOR_LOCK_MEMb_IMMb_80r6_DEFINED 1 -#define XED_IFORM_XOR_LOCK_MEMb_IMMb_82r6_DEFINED 1 -#define XED_IFORM_XOR_LOCK_MEMv_GPRv_DEFINED 1 -#define XED_IFORM_XOR_LOCK_MEMv_IMMb_DEFINED 1 -#define XED_IFORM_XOR_LOCK_MEMv_IMMz_DEFINED 1 -#define XED_IFORM_XRESLDTRK_DEFINED 1 -#define XED_IFORM_XRSTOR_MEMmxsave_DEFINED 1 -#define XED_IFORM_XRSTOR64_MEMmxsave_DEFINED 1 -#define XED_IFORM_XRSTORS_MEMmxsave_DEFINED 1 -#define XED_IFORM_XRSTORS64_MEMmxsave_DEFINED 1 -#define XED_IFORM_XSAVE_MEMmxsave_DEFINED 1 -#define XED_IFORM_XSAVE64_MEMmxsave_DEFINED 1 -#define XED_IFORM_XSAVEC_MEMmxsave_DEFINED 1 -#define XED_IFORM_XSAVEC64_MEMmxsave_DEFINED 1 -#define XED_IFORM_XSAVEOPT_MEMmxsave_DEFINED 1 -#define XED_IFORM_XSAVEOPT64_MEMmxsave_DEFINED 1 -#define XED_IFORM_XSAVES_MEMmxsave_DEFINED 1 -#define XED_IFORM_XSAVES64_MEMmxsave_DEFINED 1 -#define XED_IFORM_XSETBV_DEFINED 1 -#define XED_IFORM_XSTORE_DEFINED 1 -#define XED_IFORM_XSUSLDTRK_DEFINED 1 -#define XED_IFORM_XTEST_DEFINED 1 -#define XED_IFORM_LAST_DEFINED 1 -typedef enum { - XED_IFORM_INVALID=0, - XED_IFORM_AAA=1, - XED_IFORM_AAD_IMMb=2, - XED_IFORM_AAM_IMMb=3, - XED_IFORM_AAS=4, - XED_IFORM_ADC_AL_IMMb=5, - XED_IFORM_ADC_GPR8_GPR8_10=6, - XED_IFORM_ADC_GPR8_GPR8_12=7, - XED_IFORM_ADC_GPR8_IMMb_80r2=8, - XED_IFORM_ADC_GPR8_IMMb_82r2=9, - XED_IFORM_ADC_GPR8_MEMb=10, - XED_IFORM_ADC_GPRv_GPRv_11=11, - XED_IFORM_ADC_GPRv_GPRv_13=12, - XED_IFORM_ADC_GPRv_IMMb=13, - XED_IFORM_ADC_GPRv_IMMz=14, - XED_IFORM_ADC_GPRv_MEMv=15, - XED_IFORM_ADC_MEMb_GPR8=16, - XED_IFORM_ADC_MEMb_IMMb_80r2=17, - XED_IFORM_ADC_MEMb_IMMb_82r2=18, - XED_IFORM_ADC_MEMv_GPRv=19, - XED_IFORM_ADC_MEMv_IMMb=20, - XED_IFORM_ADC_MEMv_IMMz=21, - XED_IFORM_ADC_OrAX_IMMz=22, - XED_IFORM_ADCX_GPR32d_GPR32d=23, - XED_IFORM_ADCX_GPR32d_MEMd=24, - XED_IFORM_ADCX_GPR64q_GPR64q=25, - XED_IFORM_ADCX_GPR64q_MEMq=26, - XED_IFORM_ADC_LOCK_MEMb_GPR8=27, - XED_IFORM_ADC_LOCK_MEMb_IMMb_80r2=28, - XED_IFORM_ADC_LOCK_MEMb_IMMb_82r2=29, - XED_IFORM_ADC_LOCK_MEMv_GPRv=30, - XED_IFORM_ADC_LOCK_MEMv_IMMb=31, - XED_IFORM_ADC_LOCK_MEMv_IMMz=32, - XED_IFORM_ADD_AL_IMMb=33, - XED_IFORM_ADD_GPR8_GPR8_00=34, - XED_IFORM_ADD_GPR8_GPR8_02=35, - XED_IFORM_ADD_GPR8_IMMb_80r0=36, - XED_IFORM_ADD_GPR8_IMMb_82r0=37, - XED_IFORM_ADD_GPR8_MEMb=38, - XED_IFORM_ADD_GPRv_GPRv_01=39, - XED_IFORM_ADD_GPRv_GPRv_03=40, - XED_IFORM_ADD_GPRv_IMMb=41, - XED_IFORM_ADD_GPRv_IMMz=42, - XED_IFORM_ADD_GPRv_MEMv=43, - XED_IFORM_ADD_MEMb_GPR8=44, - XED_IFORM_ADD_MEMb_IMMb_80r0=45, - XED_IFORM_ADD_MEMb_IMMb_82r0=46, - XED_IFORM_ADD_MEMv_GPRv=47, - XED_IFORM_ADD_MEMv_IMMb=48, - XED_IFORM_ADD_MEMv_IMMz=49, - XED_IFORM_ADD_OrAX_IMMz=50, - XED_IFORM_ADDPD_XMMpd_MEMpd=51, - XED_IFORM_ADDPD_XMMpd_XMMpd=52, - XED_IFORM_ADDPS_XMMps_MEMps=53, - XED_IFORM_ADDPS_XMMps_XMMps=54, - XED_IFORM_ADDSD_XMMsd_MEMsd=55, - XED_IFORM_ADDSD_XMMsd_XMMsd=56, - XED_IFORM_ADDSS_XMMss_MEMss=57, - XED_IFORM_ADDSS_XMMss_XMMss=58, - XED_IFORM_ADDSUBPD_XMMpd_MEMpd=59, - XED_IFORM_ADDSUBPD_XMMpd_XMMpd=60, - XED_IFORM_ADDSUBPS_XMMps_MEMps=61, - XED_IFORM_ADDSUBPS_XMMps_XMMps=62, - XED_IFORM_ADD_LOCK_MEMb_GPR8=63, - XED_IFORM_ADD_LOCK_MEMb_IMMb_80r0=64, - XED_IFORM_ADD_LOCK_MEMb_IMMb_82r0=65, - XED_IFORM_ADD_LOCK_MEMv_GPRv=66, - XED_IFORM_ADD_LOCK_MEMv_IMMb=67, - XED_IFORM_ADD_LOCK_MEMv_IMMz=68, - XED_IFORM_ADOX_GPR32d_GPR32d=69, - XED_IFORM_ADOX_GPR32d_MEMd=70, - XED_IFORM_ADOX_GPR64q_GPR64q=71, - XED_IFORM_ADOX_GPR64q_MEMq=72, - XED_IFORM_AESDEC_XMMdq_MEMdq=73, - XED_IFORM_AESDEC_XMMdq_XMMdq=74, - XED_IFORM_AESDEC128KL_XMMu8_MEMu8=75, - XED_IFORM_AESDEC256KL_XMMu8_MEMu8=76, - XED_IFORM_AESDECLAST_XMMdq_MEMdq=77, - XED_IFORM_AESDECLAST_XMMdq_XMMdq=78, - XED_IFORM_AESDECWIDE128KL_MEMu8=79, - XED_IFORM_AESDECWIDE256KL_MEMu8=80, - XED_IFORM_AESENC_XMMdq_MEMdq=81, - XED_IFORM_AESENC_XMMdq_XMMdq=82, - XED_IFORM_AESENC128KL_XMMu8_MEMu8=83, - XED_IFORM_AESENC256KL_XMMu8_MEMu8=84, - XED_IFORM_AESENCLAST_XMMdq_MEMdq=85, - XED_IFORM_AESENCLAST_XMMdq_XMMdq=86, - XED_IFORM_AESENCWIDE128KL_MEMu8=87, - XED_IFORM_AESENCWIDE256KL_MEMu8=88, - XED_IFORM_AESIMC_XMMdq_MEMdq=89, - XED_IFORM_AESIMC_XMMdq_XMMdq=90, - XED_IFORM_AESKEYGENASSIST_XMMdq_MEMdq_IMMb=91, - XED_IFORM_AESKEYGENASSIST_XMMdq_XMMdq_IMMb=92, - XED_IFORM_AND_AL_IMMb=93, - XED_IFORM_AND_GPR8_GPR8_20=94, - XED_IFORM_AND_GPR8_GPR8_22=95, - XED_IFORM_AND_GPR8_IMMb_80r4=96, - XED_IFORM_AND_GPR8_IMMb_82r4=97, - XED_IFORM_AND_GPR8_MEMb=98, - XED_IFORM_AND_GPRv_GPRv_21=99, - XED_IFORM_AND_GPRv_GPRv_23=100, - XED_IFORM_AND_GPRv_IMMb=101, - XED_IFORM_AND_GPRv_IMMz=102, - XED_IFORM_AND_GPRv_MEMv=103, - XED_IFORM_AND_MEMb_GPR8=104, - XED_IFORM_AND_MEMb_IMMb_80r4=105, - XED_IFORM_AND_MEMb_IMMb_82r4=106, - XED_IFORM_AND_MEMv_GPRv=107, - XED_IFORM_AND_MEMv_IMMb=108, - XED_IFORM_AND_MEMv_IMMz=109, - XED_IFORM_AND_OrAX_IMMz=110, - XED_IFORM_ANDN_VGPR32d_VGPR32d_MEMd=111, - XED_IFORM_ANDN_VGPR32d_VGPR32d_VGPR32d=112, - XED_IFORM_ANDN_VGPR64q_VGPR64q_MEMq=113, - XED_IFORM_ANDN_VGPR64q_VGPR64q_VGPR64q=114, - XED_IFORM_ANDNPD_XMMxuq_MEMxuq=115, - XED_IFORM_ANDNPD_XMMxuq_XMMxuq=116, - XED_IFORM_ANDNPS_XMMxud_MEMxud=117, - XED_IFORM_ANDNPS_XMMxud_XMMxud=118, - XED_IFORM_ANDPD_XMMxuq_MEMxuq=119, - XED_IFORM_ANDPD_XMMxuq_XMMxuq=120, - XED_IFORM_ANDPS_XMMxud_MEMxud=121, - XED_IFORM_ANDPS_XMMxud_XMMxud=122, - XED_IFORM_AND_LOCK_MEMb_GPR8=123, - XED_IFORM_AND_LOCK_MEMb_IMMb_80r4=124, - XED_IFORM_AND_LOCK_MEMb_IMMb_82r4=125, - XED_IFORM_AND_LOCK_MEMv_GPRv=126, - XED_IFORM_AND_LOCK_MEMv_IMMb=127, - XED_IFORM_AND_LOCK_MEMv_IMMz=128, - XED_IFORM_ARPL_GPR16_GPR16=129, - XED_IFORM_ARPL_MEMw_GPR16=130, - XED_IFORM_BEXTR_VGPR32d_MEMd_VGPR32d=131, - XED_IFORM_BEXTR_VGPR32d_VGPR32d_VGPR32d=132, - XED_IFORM_BEXTR_VGPR64q_MEMq_VGPR64q=133, - XED_IFORM_BEXTR_VGPR64q_VGPR64q_VGPR64q=134, - XED_IFORM_BEXTR_XOP_VGPR32d_MEMd_IMMd=135, - XED_IFORM_BEXTR_XOP_VGPR32d_VGPR32d_IMMd=136, - XED_IFORM_BEXTR_XOP_VGPRyy_MEMy_IMMd=137, - XED_IFORM_BEXTR_XOP_VGPRyy_VGPRyy_IMMd=138, - XED_IFORM_BLCFILL_VGPR32d_MEMd=139, - XED_IFORM_BLCFILL_VGPR32d_VGPR32d=140, - XED_IFORM_BLCFILL_VGPRyy_MEMy=141, - XED_IFORM_BLCFILL_VGPRyy_VGPRyy=142, - XED_IFORM_BLCI_VGPR32d_MEMd=143, - XED_IFORM_BLCI_VGPR32d_VGPR32d=144, - XED_IFORM_BLCI_VGPRyy_MEMy=145, - XED_IFORM_BLCI_VGPRyy_VGPRyy=146, - XED_IFORM_BLCIC_VGPR32d_MEMd=147, - XED_IFORM_BLCIC_VGPR32d_VGPR32d=148, - XED_IFORM_BLCIC_VGPRyy_MEMy=149, - XED_IFORM_BLCIC_VGPRyy_VGPRyy=150, - XED_IFORM_BLCMSK_VGPR32d_MEMd=151, - XED_IFORM_BLCMSK_VGPR32d_VGPR32d=152, - XED_IFORM_BLCMSK_VGPRyy_MEMy=153, - XED_IFORM_BLCMSK_VGPRyy_VGPRyy=154, - XED_IFORM_BLCS_VGPR32d_MEMd=155, - XED_IFORM_BLCS_VGPR32d_VGPR32d=156, - XED_IFORM_BLCS_VGPRyy_MEMy=157, - XED_IFORM_BLCS_VGPRyy_VGPRyy=158, - XED_IFORM_BLENDPD_XMMdq_MEMdq_IMMb=159, - XED_IFORM_BLENDPD_XMMdq_XMMdq_IMMb=160, - XED_IFORM_BLENDPS_XMMdq_MEMdq_IMMb=161, - XED_IFORM_BLENDPS_XMMdq_XMMdq_IMMb=162, - XED_IFORM_BLENDVPD_XMMdq_MEMdq=163, - XED_IFORM_BLENDVPD_XMMdq_XMMdq=164, - XED_IFORM_BLENDVPS_XMMdq_MEMdq=165, - XED_IFORM_BLENDVPS_XMMdq_XMMdq=166, - XED_IFORM_BLSFILL_VGPR32d_MEMd=167, - XED_IFORM_BLSFILL_VGPR32d_VGPR32d=168, - XED_IFORM_BLSFILL_VGPRyy_MEMy=169, - XED_IFORM_BLSFILL_VGPRyy_VGPRyy=170, - XED_IFORM_BLSI_VGPR32d_MEMd=171, - XED_IFORM_BLSI_VGPR32d_VGPR32d=172, - XED_IFORM_BLSI_VGPR64q_MEMq=173, - XED_IFORM_BLSI_VGPR64q_VGPR64q=174, - XED_IFORM_BLSIC_VGPR32d_MEMd=175, - XED_IFORM_BLSIC_VGPR32d_VGPR32d=176, - XED_IFORM_BLSIC_VGPRyy_MEMy=177, - XED_IFORM_BLSIC_VGPRyy_VGPRyy=178, - XED_IFORM_BLSMSK_VGPR32d_MEMd=179, - XED_IFORM_BLSMSK_VGPR32d_VGPR32d=180, - XED_IFORM_BLSMSK_VGPR64q_MEMq=181, - XED_IFORM_BLSMSK_VGPR64q_VGPR64q=182, - XED_IFORM_BLSR_VGPR32d_MEMd=183, - XED_IFORM_BLSR_VGPR32d_VGPR32d=184, - XED_IFORM_BLSR_VGPR64q_MEMq=185, - XED_IFORM_BLSR_VGPR64q_VGPR64q=186, - XED_IFORM_BNDCL_BND_AGEN=187, - XED_IFORM_BNDCL_BND_GPR32=188, - XED_IFORM_BNDCL_BND_GPR64=189, - XED_IFORM_BNDCN_BND_AGEN=190, - XED_IFORM_BNDCN_BND_GPR32=191, - XED_IFORM_BNDCN_BND_GPR64=192, - XED_IFORM_BNDCU_BND_AGEN=193, - XED_IFORM_BNDCU_BND_GPR32=194, - XED_IFORM_BNDCU_BND_GPR64=195, - XED_IFORM_BNDLDX_BND_MEMbnd32=196, - XED_IFORM_BNDLDX_BND_MEMbnd64=197, - XED_IFORM_BNDMK_BND_AGEN=198, - XED_IFORM_BNDMOV_BND_BND=199, - XED_IFORM_BNDMOV_BND_MEMdq=200, - XED_IFORM_BNDMOV_BND_MEMq=201, - XED_IFORM_BNDMOV_MEMdq_BND=202, - XED_IFORM_BNDMOV_MEMq_BND=203, - XED_IFORM_BNDSTX_MEMbnd32_BND=204, - XED_IFORM_BNDSTX_MEMbnd64_BND=205, - XED_IFORM_BOUND_GPRv_MEMa16=206, - XED_IFORM_BOUND_GPRv_MEMa32=207, - XED_IFORM_BSF_GPRv_GPRv=208, - XED_IFORM_BSF_GPRv_MEMv=209, - XED_IFORM_BSR_GPRv_GPRv=210, - XED_IFORM_BSR_GPRv_MEMv=211, - XED_IFORM_BSWAP_GPRv=212, - XED_IFORM_BT_GPRv_GPRv=213, - XED_IFORM_BT_GPRv_IMMb=214, - XED_IFORM_BT_MEMv_GPRv=215, - XED_IFORM_BT_MEMv_IMMb=216, - XED_IFORM_BTC_GPRv_GPRv=217, - XED_IFORM_BTC_GPRv_IMMb=218, - XED_IFORM_BTC_MEMv_GPRv=219, - XED_IFORM_BTC_MEMv_IMMb=220, - XED_IFORM_BTC_LOCK_MEMv_GPRv=221, - XED_IFORM_BTC_LOCK_MEMv_IMMb=222, - XED_IFORM_BTR_GPRv_GPRv=223, - XED_IFORM_BTR_GPRv_IMMb=224, - XED_IFORM_BTR_MEMv_GPRv=225, - XED_IFORM_BTR_MEMv_IMMb=226, - XED_IFORM_BTR_LOCK_MEMv_GPRv=227, - XED_IFORM_BTR_LOCK_MEMv_IMMb=228, - XED_IFORM_BTS_GPRv_GPRv=229, - XED_IFORM_BTS_GPRv_IMMb=230, - XED_IFORM_BTS_MEMv_GPRv=231, - XED_IFORM_BTS_MEMv_IMMb=232, - XED_IFORM_BTS_LOCK_MEMv_GPRv=233, - XED_IFORM_BTS_LOCK_MEMv_IMMb=234, - XED_IFORM_BZHI_VGPR32d_MEMd_VGPR32d=235, - XED_IFORM_BZHI_VGPR32d_VGPR32d_VGPR32d=236, - XED_IFORM_BZHI_VGPR64q_MEMq_VGPR64q=237, - XED_IFORM_BZHI_VGPR64q_VGPR64q_VGPR64q=238, - XED_IFORM_CALL_FAR_MEMp2=239, - XED_IFORM_CALL_FAR_PTRp_IMMw=240, - XED_IFORM_CALL_NEAR_GPRv=241, - XED_IFORM_CALL_NEAR_MEMv=242, - XED_IFORM_CALL_NEAR_RELBRd=243, - XED_IFORM_CALL_NEAR_RELBRz=244, - XED_IFORM_CBW=245, - XED_IFORM_CDQ=246, - XED_IFORM_CDQE=247, - XED_IFORM_CLAC=248, - XED_IFORM_CLC=249, - XED_IFORM_CLD=250, - XED_IFORM_CLDEMOTE_MEMu8=251, - XED_IFORM_CLFLUSH_MEMmprefetch=252, - XED_IFORM_CLFLUSHOPT_MEMmprefetch=253, - XED_IFORM_CLGI=254, - XED_IFORM_CLI=255, - XED_IFORM_CLRSSBSY_MEMu64=256, - XED_IFORM_CLTS=257, - XED_IFORM_CLUI=258, - XED_IFORM_CLWB_MEMmprefetch=259, - XED_IFORM_CLZERO=260, - XED_IFORM_CMC=261, - XED_IFORM_CMOVB_GPRv_GPRv=262, - XED_IFORM_CMOVB_GPRv_MEMv=263, - XED_IFORM_CMOVBE_GPRv_GPRv=264, - XED_IFORM_CMOVBE_GPRv_MEMv=265, - XED_IFORM_CMOVL_GPRv_GPRv=266, - XED_IFORM_CMOVL_GPRv_MEMv=267, - XED_IFORM_CMOVLE_GPRv_GPRv=268, - XED_IFORM_CMOVLE_GPRv_MEMv=269, - XED_IFORM_CMOVNB_GPRv_GPRv=270, - XED_IFORM_CMOVNB_GPRv_MEMv=271, - XED_IFORM_CMOVNBE_GPRv_GPRv=272, - XED_IFORM_CMOVNBE_GPRv_MEMv=273, - XED_IFORM_CMOVNL_GPRv_GPRv=274, - XED_IFORM_CMOVNL_GPRv_MEMv=275, - XED_IFORM_CMOVNLE_GPRv_GPRv=276, - XED_IFORM_CMOVNLE_GPRv_MEMv=277, - XED_IFORM_CMOVNO_GPRv_GPRv=278, - XED_IFORM_CMOVNO_GPRv_MEMv=279, - XED_IFORM_CMOVNP_GPRv_GPRv=280, - XED_IFORM_CMOVNP_GPRv_MEMv=281, - XED_IFORM_CMOVNS_GPRv_GPRv=282, - XED_IFORM_CMOVNS_GPRv_MEMv=283, - XED_IFORM_CMOVNZ_GPRv_GPRv=284, - XED_IFORM_CMOVNZ_GPRv_MEMv=285, - XED_IFORM_CMOVO_GPRv_GPRv=286, - XED_IFORM_CMOVO_GPRv_MEMv=287, - XED_IFORM_CMOVP_GPRv_GPRv=288, - XED_IFORM_CMOVP_GPRv_MEMv=289, - XED_IFORM_CMOVS_GPRv_GPRv=290, - XED_IFORM_CMOVS_GPRv_MEMv=291, - XED_IFORM_CMOVZ_GPRv_GPRv=292, - XED_IFORM_CMOVZ_GPRv_MEMv=293, - XED_IFORM_CMP_AL_IMMb=294, - XED_IFORM_CMP_GPR8_GPR8_38=295, - XED_IFORM_CMP_GPR8_GPR8_3A=296, - XED_IFORM_CMP_GPR8_IMMb_80r7=297, - XED_IFORM_CMP_GPR8_IMMb_82r7=298, - XED_IFORM_CMP_GPR8_MEMb=299, - XED_IFORM_CMP_GPRv_GPRv_39=300, - XED_IFORM_CMP_GPRv_GPRv_3B=301, - XED_IFORM_CMP_GPRv_IMMb=302, - XED_IFORM_CMP_GPRv_IMMz=303, - XED_IFORM_CMP_GPRv_MEMv=304, - XED_IFORM_CMP_MEMb_GPR8=305, - XED_IFORM_CMP_MEMb_IMMb_80r7=306, - XED_IFORM_CMP_MEMb_IMMb_82r7=307, - XED_IFORM_CMP_MEMv_GPRv=308, - XED_IFORM_CMP_MEMv_IMMb=309, - XED_IFORM_CMP_MEMv_IMMz=310, - XED_IFORM_CMP_OrAX_IMMz=311, - XED_IFORM_CMPPD_XMMpd_MEMpd_IMMb=312, - XED_IFORM_CMPPD_XMMpd_XMMpd_IMMb=313, - XED_IFORM_CMPPS_XMMps_MEMps_IMMb=314, - XED_IFORM_CMPPS_XMMps_XMMps_IMMb=315, - XED_IFORM_CMPSB=316, - XED_IFORM_CMPSD=317, - XED_IFORM_CMPSD_XMM_XMMsd_MEMsd_IMMb=318, - XED_IFORM_CMPSD_XMM_XMMsd_XMMsd_IMMb=319, - XED_IFORM_CMPSQ=320, - XED_IFORM_CMPSS_XMMss_MEMss_IMMb=321, - XED_IFORM_CMPSS_XMMss_XMMss_IMMb=322, - XED_IFORM_CMPSW=323, - XED_IFORM_CMPXCHG_GPR8_GPR8=324, - XED_IFORM_CMPXCHG_GPRv_GPRv=325, - XED_IFORM_CMPXCHG_MEMb_GPR8=326, - XED_IFORM_CMPXCHG_MEMv_GPRv=327, - XED_IFORM_CMPXCHG16B_MEMdq=328, - XED_IFORM_CMPXCHG16B_LOCK_MEMdq=329, - XED_IFORM_CMPXCHG8B_MEMq=330, - XED_IFORM_CMPXCHG8B_LOCK_MEMq=331, - XED_IFORM_CMPXCHG_LOCK_MEMb_GPR8=332, - XED_IFORM_CMPXCHG_LOCK_MEMv_GPRv=333, - XED_IFORM_COMISD_XMMsd_MEMsd=334, - XED_IFORM_COMISD_XMMsd_XMMsd=335, - XED_IFORM_COMISS_XMMss_MEMss=336, - XED_IFORM_COMISS_XMMss_XMMss=337, - XED_IFORM_CPUID=338, - XED_IFORM_CQO=339, - XED_IFORM_CRC32_GPRyy_GPR8b=340, - XED_IFORM_CRC32_GPRyy_GPRv=341, - XED_IFORM_CRC32_GPRyy_MEMb=342, - XED_IFORM_CRC32_GPRyy_MEMv=343, - XED_IFORM_CVTDQ2PD_XMMpd_MEMq=344, - XED_IFORM_CVTDQ2PD_XMMpd_XMMq=345, - XED_IFORM_CVTDQ2PS_XMMps_MEMdq=346, - XED_IFORM_CVTDQ2PS_XMMps_XMMdq=347, - XED_IFORM_CVTPD2DQ_XMMdq_MEMpd=348, - XED_IFORM_CVTPD2DQ_XMMdq_XMMpd=349, - XED_IFORM_CVTPD2PI_MMXq_MEMpd=350, - XED_IFORM_CVTPD2PI_MMXq_XMMpd=351, - XED_IFORM_CVTPD2PS_XMMps_MEMpd=352, - XED_IFORM_CVTPD2PS_XMMps_XMMpd=353, - XED_IFORM_CVTPI2PD_XMMpd_MEMq=354, - XED_IFORM_CVTPI2PD_XMMpd_MMXq=355, - XED_IFORM_CVTPI2PS_XMMq_MEMq=356, - XED_IFORM_CVTPI2PS_XMMq_MMXq=357, - XED_IFORM_CVTPS2DQ_XMMdq_MEMps=358, - XED_IFORM_CVTPS2DQ_XMMdq_XMMps=359, - XED_IFORM_CVTPS2PD_XMMpd_MEMq=360, - XED_IFORM_CVTPS2PD_XMMpd_XMMq=361, - XED_IFORM_CVTPS2PI_MMXq_MEMq=362, - XED_IFORM_CVTPS2PI_MMXq_XMMq=363, - XED_IFORM_CVTSD2SI_GPR32d_MEMsd=364, - XED_IFORM_CVTSD2SI_GPR32d_XMMsd=365, - XED_IFORM_CVTSD2SI_GPR64q_MEMsd=366, - XED_IFORM_CVTSD2SI_GPR64q_XMMsd=367, - XED_IFORM_CVTSD2SS_XMMss_MEMsd=368, - XED_IFORM_CVTSD2SS_XMMss_XMMsd=369, - XED_IFORM_CVTSI2SD_XMMsd_GPR32d=370, - XED_IFORM_CVTSI2SD_XMMsd_GPR64q=371, - XED_IFORM_CVTSI2SD_XMMsd_MEMd=372, - XED_IFORM_CVTSI2SD_XMMsd_MEMq=373, - XED_IFORM_CVTSI2SS_XMMss_GPR32d=374, - XED_IFORM_CVTSI2SS_XMMss_GPR64q=375, - XED_IFORM_CVTSI2SS_XMMss_MEMd=376, - XED_IFORM_CVTSI2SS_XMMss_MEMq=377, - XED_IFORM_CVTSS2SD_XMMsd_MEMss=378, - XED_IFORM_CVTSS2SD_XMMsd_XMMss=379, - XED_IFORM_CVTSS2SI_GPR32d_MEMss=380, - XED_IFORM_CVTSS2SI_GPR32d_XMMss=381, - XED_IFORM_CVTSS2SI_GPR64q_MEMss=382, - XED_IFORM_CVTSS2SI_GPR64q_XMMss=383, - XED_IFORM_CVTTPD2DQ_XMMdq_MEMpd=384, - XED_IFORM_CVTTPD2DQ_XMMdq_XMMpd=385, - XED_IFORM_CVTTPD2PI_MMXq_MEMpd=386, - XED_IFORM_CVTTPD2PI_MMXq_XMMpd=387, - XED_IFORM_CVTTPS2DQ_XMMdq_MEMps=388, - XED_IFORM_CVTTPS2DQ_XMMdq_XMMps=389, - XED_IFORM_CVTTPS2PI_MMXq_MEMq=390, - XED_IFORM_CVTTPS2PI_MMXq_XMMq=391, - XED_IFORM_CVTTSD2SI_GPR32d_MEMsd=392, - XED_IFORM_CVTTSD2SI_GPR32d_XMMsd=393, - XED_IFORM_CVTTSD2SI_GPR64q_MEMsd=394, - XED_IFORM_CVTTSD2SI_GPR64q_XMMsd=395, - XED_IFORM_CVTTSS2SI_GPR32d_MEMss=396, - XED_IFORM_CVTTSS2SI_GPR32d_XMMss=397, - XED_IFORM_CVTTSS2SI_GPR64q_MEMss=398, - XED_IFORM_CVTTSS2SI_GPR64q_XMMss=399, - XED_IFORM_CWD=400, - XED_IFORM_CWDE=401, - XED_IFORM_DAA=402, - XED_IFORM_DAS=403, - XED_IFORM_DEC_GPR8=404, - XED_IFORM_DEC_GPRv_48=405, - XED_IFORM_DEC_GPRv_FFr1=406, - XED_IFORM_DEC_MEMb=407, - XED_IFORM_DEC_MEMv=408, - XED_IFORM_DEC_LOCK_MEMb=409, - XED_IFORM_DEC_LOCK_MEMv=410, - XED_IFORM_DIV_GPR8=411, - XED_IFORM_DIV_GPRv=412, - XED_IFORM_DIV_MEMb=413, - XED_IFORM_DIV_MEMv=414, - XED_IFORM_DIVPD_XMMpd_MEMpd=415, - XED_IFORM_DIVPD_XMMpd_XMMpd=416, - XED_IFORM_DIVPS_XMMps_MEMps=417, - XED_IFORM_DIVPS_XMMps_XMMps=418, - XED_IFORM_DIVSD_XMMsd_MEMsd=419, - XED_IFORM_DIVSD_XMMsd_XMMsd=420, - XED_IFORM_DIVSS_XMMss_MEMss=421, - XED_IFORM_DIVSS_XMMss_XMMss=422, - XED_IFORM_DPPD_XMMdq_MEMdq_IMMb=423, - XED_IFORM_DPPD_XMMdq_XMMdq_IMMb=424, - XED_IFORM_DPPS_XMMdq_MEMdq_IMMb=425, - XED_IFORM_DPPS_XMMdq_XMMdq_IMMb=426, - XED_IFORM_EMMS=427, - XED_IFORM_ENCLS=428, - XED_IFORM_ENCLU=429, - XED_IFORM_ENCLV=430, - XED_IFORM_ENCODEKEY128_GPR32u8_GPR32u8=431, - XED_IFORM_ENCODEKEY256_GPR32u8_GPR32u8=432, - XED_IFORM_ENDBR32=433, - XED_IFORM_ENDBR64=434, - XED_IFORM_ENQCMD_GPRa_MEMu32=435, - XED_IFORM_ENQCMDS_GPRa_MEMu32=436, - XED_IFORM_ENTER_IMMw_IMMb=437, - XED_IFORM_EXTRACTPS_GPR32d_XMMdq_IMMb=438, - XED_IFORM_EXTRACTPS_MEMd_XMMps_IMMb=439, - XED_IFORM_EXTRQ_XMMq_IMMb_IMMb=440, - XED_IFORM_EXTRQ_XMMq_XMMdq=441, - XED_IFORM_F2XM1=442, - XED_IFORM_FABS=443, - XED_IFORM_FADD_ST0_MEMm64real=444, - XED_IFORM_FADD_ST0_MEMmem32real=445, - XED_IFORM_FADD_ST0_X87=446, - XED_IFORM_FADD_X87_ST0=447, - XED_IFORM_FADDP_X87_ST0=448, - XED_IFORM_FBLD_ST0_MEMmem80dec=449, - XED_IFORM_FBSTP_MEMmem80dec_ST0=450, - XED_IFORM_FCHS=451, - XED_IFORM_FCMOVB_ST0_X87=452, - XED_IFORM_FCMOVBE_ST0_X87=453, - XED_IFORM_FCMOVE_ST0_X87=454, - XED_IFORM_FCMOVNB_ST0_X87=455, - XED_IFORM_FCMOVNBE_ST0_X87=456, - XED_IFORM_FCMOVNE_ST0_X87=457, - XED_IFORM_FCMOVNU_ST0_X87=458, - XED_IFORM_FCMOVU_ST0_X87=459, - XED_IFORM_FCOM_ST0_MEMm64real=460, - XED_IFORM_FCOM_ST0_MEMmem32real=461, - XED_IFORM_FCOM_ST0_X87=462, - XED_IFORM_FCOM_ST0_X87_DCD0=463, - XED_IFORM_FCOMI_ST0_X87=464, - XED_IFORM_FCOMIP_ST0_X87=465, - XED_IFORM_FCOMP_ST0_MEMm64real=466, - XED_IFORM_FCOMP_ST0_MEMmem32real=467, - XED_IFORM_FCOMP_ST0_X87=468, - XED_IFORM_FCOMP_ST0_X87_DCD1=469, - XED_IFORM_FCOMP_ST0_X87_DED0=470, - XED_IFORM_FCOMPP=471, - XED_IFORM_FCOS=472, - XED_IFORM_FDECSTP=473, - XED_IFORM_FDISI8087_NOP=474, - XED_IFORM_FDIV_ST0_MEMm64real=475, - XED_IFORM_FDIV_ST0_MEMmem32real=476, - XED_IFORM_FDIV_ST0_X87=477, - XED_IFORM_FDIV_X87_ST0=478, - XED_IFORM_FDIVP_X87_ST0=479, - XED_IFORM_FDIVR_ST0_MEMm64real=480, - XED_IFORM_FDIVR_ST0_MEMmem32real=481, - XED_IFORM_FDIVR_ST0_X87=482, - XED_IFORM_FDIVR_X87_ST0=483, - XED_IFORM_FDIVRP_X87_ST0=484, - XED_IFORM_FEMMS=485, - XED_IFORM_FENI8087_NOP=486, - XED_IFORM_FFREE_X87=487, - XED_IFORM_FFREEP_X87=488, - XED_IFORM_FIADD_ST0_MEMmem16int=489, - XED_IFORM_FIADD_ST0_MEMmem32int=490, - XED_IFORM_FICOM_ST0_MEMmem16int=491, - XED_IFORM_FICOM_ST0_MEMmem32int=492, - XED_IFORM_FICOMP_ST0_MEMmem16int=493, - XED_IFORM_FICOMP_ST0_MEMmem32int=494, - XED_IFORM_FIDIV_ST0_MEMmem16int=495, - XED_IFORM_FIDIV_ST0_MEMmem32int=496, - XED_IFORM_FIDIVR_ST0_MEMmem16int=497, - XED_IFORM_FIDIVR_ST0_MEMmem32int=498, - XED_IFORM_FILD_ST0_MEMm64int=499, - XED_IFORM_FILD_ST0_MEMmem16int=500, - XED_IFORM_FILD_ST0_MEMmem32int=501, - XED_IFORM_FIMUL_ST0_MEMmem16int=502, - XED_IFORM_FIMUL_ST0_MEMmem32int=503, - XED_IFORM_FINCSTP=504, - XED_IFORM_FIST_MEMmem16int_ST0=505, - XED_IFORM_FIST_MEMmem32int_ST0=506, - XED_IFORM_FISTP_MEMm64int_ST0=507, - XED_IFORM_FISTP_MEMmem16int_ST0=508, - XED_IFORM_FISTP_MEMmem32int_ST0=509, - XED_IFORM_FISTTP_MEMm64int_ST0=510, - XED_IFORM_FISTTP_MEMmem16int_ST0=511, - XED_IFORM_FISTTP_MEMmem32int_ST0=512, - XED_IFORM_FISUB_ST0_MEMmem16int=513, - XED_IFORM_FISUB_ST0_MEMmem32int=514, - XED_IFORM_FISUBR_ST0_MEMmem16int=515, - XED_IFORM_FISUBR_ST0_MEMmem32int=516, - XED_IFORM_FLD_ST0_MEMm64real=517, - XED_IFORM_FLD_ST0_MEMmem32real=518, - XED_IFORM_FLD_ST0_MEMmem80real=519, - XED_IFORM_FLD_ST0_X87=520, - XED_IFORM_FLD1=521, - XED_IFORM_FLDCW_MEMmem16=522, - XED_IFORM_FLDENV_MEMmem14=523, - XED_IFORM_FLDENV_MEMmem28=524, - XED_IFORM_FLDL2E=525, - XED_IFORM_FLDL2T=526, - XED_IFORM_FLDLG2=527, - XED_IFORM_FLDLN2=528, - XED_IFORM_FLDPI=529, - XED_IFORM_FLDZ=530, - XED_IFORM_FMUL_ST0_MEMm64real=531, - XED_IFORM_FMUL_ST0_MEMmem32real=532, - XED_IFORM_FMUL_ST0_X87=533, - XED_IFORM_FMUL_X87_ST0=534, - XED_IFORM_FMULP_X87_ST0=535, - XED_IFORM_FNCLEX=536, - XED_IFORM_FNINIT=537, - XED_IFORM_FNOP=538, - XED_IFORM_FNSAVE_MEMmem108=539, - XED_IFORM_FNSAVE_MEMmem94=540, - XED_IFORM_FNSTCW_MEMmem16=541, - XED_IFORM_FNSTENV_MEMmem14=542, - XED_IFORM_FNSTENV_MEMmem28=543, - XED_IFORM_FNSTSW_AX=544, - XED_IFORM_FNSTSW_MEMmem16=545, - XED_IFORM_FPATAN=546, - XED_IFORM_FPREM=547, - XED_IFORM_FPREM1=548, - XED_IFORM_FPTAN=549, - XED_IFORM_FRNDINT=550, - XED_IFORM_FRSTOR_MEMmem108=551, - XED_IFORM_FRSTOR_MEMmem94=552, - XED_IFORM_FSCALE=553, - XED_IFORM_FSETPM287_NOP=554, - XED_IFORM_FSIN=555, - XED_IFORM_FSINCOS=556, - XED_IFORM_FSQRT=557, - XED_IFORM_FST_MEMm64real_ST0=558, - XED_IFORM_FST_MEMmem32real_ST0=559, - XED_IFORM_FST_X87_ST0=560, - XED_IFORM_FSTP_MEMm64real_ST0=561, - XED_IFORM_FSTP_MEMmem32real_ST0=562, - XED_IFORM_FSTP_MEMmem80real_ST0=563, - XED_IFORM_FSTP_X87_ST0=564, - XED_IFORM_FSTP_X87_ST0_DFD0=565, - XED_IFORM_FSTP_X87_ST0_DFD1=566, - XED_IFORM_FSTPNCE_X87_ST0=567, - XED_IFORM_FSUB_ST0_MEMm64real=568, - XED_IFORM_FSUB_ST0_MEMmem32real=569, - XED_IFORM_FSUB_ST0_X87=570, - XED_IFORM_FSUB_X87_ST0=571, - XED_IFORM_FSUBP_X87_ST0=572, - XED_IFORM_FSUBR_ST0_MEMm64real=573, - XED_IFORM_FSUBR_ST0_MEMmem32real=574, - XED_IFORM_FSUBR_ST0_X87=575, - XED_IFORM_FSUBR_X87_ST0=576, - XED_IFORM_FSUBRP_X87_ST0=577, - XED_IFORM_FTST=578, - XED_IFORM_FUCOM_ST0_X87=579, - XED_IFORM_FUCOMI_ST0_X87=580, - XED_IFORM_FUCOMIP_ST0_X87=581, - XED_IFORM_FUCOMP_ST0_X87=582, - XED_IFORM_FUCOMPP=583, - XED_IFORM_FWAIT=584, - XED_IFORM_FXAM=585, - XED_IFORM_FXCH_ST0_X87=586, - XED_IFORM_FXCH_ST0_X87_DDC1=587, - XED_IFORM_FXCH_ST0_X87_DFC1=588, - XED_IFORM_FXRSTOR_MEMmfpxenv=589, - XED_IFORM_FXRSTOR64_MEMmfpxenv=590, - XED_IFORM_FXSAVE_MEMmfpxenv=591, - XED_IFORM_FXSAVE64_MEMmfpxenv=592, - XED_IFORM_FXTRACT=593, - XED_IFORM_FYL2X=594, - XED_IFORM_FYL2XP1=595, - XED_IFORM_GETSEC=596, - XED_IFORM_GF2P8AFFINEINVQB_XMMu8_MEMu64_IMM8=597, - XED_IFORM_GF2P8AFFINEINVQB_XMMu8_XMMu64_IMM8=598, - XED_IFORM_GF2P8AFFINEQB_XMMu8_MEMu64_IMM8=599, - XED_IFORM_GF2P8AFFINEQB_XMMu8_XMMu64_IMM8=600, - XED_IFORM_GF2P8MULB_XMMu8_MEMu8=601, - XED_IFORM_GF2P8MULB_XMMu8_XMMu8=602, - XED_IFORM_HADDPD_XMMpd_MEMpd=603, - XED_IFORM_HADDPD_XMMpd_XMMpd=604, - XED_IFORM_HADDPS_XMMps_MEMps=605, - XED_IFORM_HADDPS_XMMps_XMMps=606, - XED_IFORM_HLT=607, - XED_IFORM_HRESET_IMM8=608, - XED_IFORM_HSUBPD_XMMpd_MEMpd=609, - XED_IFORM_HSUBPD_XMMpd_XMMpd=610, - XED_IFORM_HSUBPS_XMMps_MEMps=611, - XED_IFORM_HSUBPS_XMMps_XMMps=612, - XED_IFORM_IDIV_GPR8=613, - XED_IFORM_IDIV_GPRv=614, - XED_IFORM_IDIV_MEMb=615, - XED_IFORM_IDIV_MEMv=616, - XED_IFORM_IMUL_GPR8=617, - XED_IFORM_IMUL_GPRv=618, - XED_IFORM_IMUL_GPRv_GPRv=619, - XED_IFORM_IMUL_GPRv_GPRv_IMMb=620, - XED_IFORM_IMUL_GPRv_GPRv_IMMz=621, - XED_IFORM_IMUL_GPRv_MEMv=622, - XED_IFORM_IMUL_GPRv_MEMv_IMMb=623, - XED_IFORM_IMUL_GPRv_MEMv_IMMz=624, - XED_IFORM_IMUL_MEMb=625, - XED_IFORM_IMUL_MEMv=626, - XED_IFORM_IN_AL_DX=627, - XED_IFORM_IN_AL_IMMb=628, - XED_IFORM_IN_OeAX_DX=629, - XED_IFORM_IN_OeAX_IMMb=630, - XED_IFORM_INC_GPR8=631, - XED_IFORM_INC_GPRv_40=632, - XED_IFORM_INC_GPRv_FFr0=633, - XED_IFORM_INC_MEMb=634, - XED_IFORM_INC_MEMv=635, - XED_IFORM_INCSSPD_GPR32u8=636, - XED_IFORM_INCSSPQ_GPR64u8=637, - XED_IFORM_INC_LOCK_MEMb=638, - XED_IFORM_INC_LOCK_MEMv=639, - XED_IFORM_INSB=640, - XED_IFORM_INSD=641, - XED_IFORM_INSERTPS_XMMps_MEMd_IMMb=642, - XED_IFORM_INSERTPS_XMMps_XMMps_IMMb=643, - XED_IFORM_INSERTQ_XMMq_XMMdq=644, - XED_IFORM_INSERTQ_XMMq_XMMq_IMMb_IMMb=645, - XED_IFORM_INSW=646, - XED_IFORM_INT_IMMb=647, - XED_IFORM_INT1=648, - XED_IFORM_INT3=649, - XED_IFORM_INTO=650, - XED_IFORM_INVD=651, - XED_IFORM_INVEPT_GPR32_MEMdq=652, - XED_IFORM_INVEPT_GPR64_MEMdq=653, - XED_IFORM_INVLPG_MEMb=654, - XED_IFORM_INVLPGA_ArAX_ECX=655, - XED_IFORM_INVLPGB_EAX_EDX_ECX=656, - XED_IFORM_INVLPGB_RAX_EDX_ECX=657, - XED_IFORM_INVPCID_GPR32_MEMdq=658, - XED_IFORM_INVPCID_GPR64_MEMdq=659, - XED_IFORM_INVVPID_GPR32_MEMdq=660, - XED_IFORM_INVVPID_GPR64_MEMdq=661, - XED_IFORM_IRET=662, - XED_IFORM_IRETD=663, - XED_IFORM_IRETQ=664, - XED_IFORM_JB_RELBRb=665, - XED_IFORM_JB_RELBRd=666, - XED_IFORM_JB_RELBRz=667, - XED_IFORM_JBE_RELBRb=668, - XED_IFORM_JBE_RELBRd=669, - XED_IFORM_JBE_RELBRz=670, - XED_IFORM_JCXZ_RELBRb=671, - XED_IFORM_JECXZ_RELBRb=672, - XED_IFORM_JL_RELBRb=673, - XED_IFORM_JL_RELBRd=674, - XED_IFORM_JL_RELBRz=675, - XED_IFORM_JLE_RELBRb=676, - XED_IFORM_JLE_RELBRd=677, - XED_IFORM_JLE_RELBRz=678, - XED_IFORM_JMP_GPRv=679, - XED_IFORM_JMP_MEMv=680, - XED_IFORM_JMP_RELBRb=681, - XED_IFORM_JMP_RELBRd=682, - XED_IFORM_JMP_RELBRz=683, - XED_IFORM_JMP_FAR_MEMp2=684, - XED_IFORM_JMP_FAR_PTRp_IMMw=685, - XED_IFORM_JNB_RELBRb=686, - XED_IFORM_JNB_RELBRd=687, - XED_IFORM_JNB_RELBRz=688, - XED_IFORM_JNBE_RELBRb=689, - XED_IFORM_JNBE_RELBRd=690, - XED_IFORM_JNBE_RELBRz=691, - XED_IFORM_JNL_RELBRb=692, - XED_IFORM_JNL_RELBRd=693, - XED_IFORM_JNL_RELBRz=694, - XED_IFORM_JNLE_RELBRb=695, - XED_IFORM_JNLE_RELBRd=696, - XED_IFORM_JNLE_RELBRz=697, - XED_IFORM_JNO_RELBRb=698, - XED_IFORM_JNO_RELBRd=699, - XED_IFORM_JNO_RELBRz=700, - XED_IFORM_JNP_RELBRb=701, - XED_IFORM_JNP_RELBRd=702, - XED_IFORM_JNP_RELBRz=703, - XED_IFORM_JNS_RELBRb=704, - XED_IFORM_JNS_RELBRd=705, - XED_IFORM_JNS_RELBRz=706, - XED_IFORM_JNZ_RELBRb=707, - XED_IFORM_JNZ_RELBRd=708, - XED_IFORM_JNZ_RELBRz=709, - XED_IFORM_JO_RELBRb=710, - XED_IFORM_JO_RELBRd=711, - XED_IFORM_JO_RELBRz=712, - XED_IFORM_JP_RELBRb=713, - XED_IFORM_JP_RELBRd=714, - XED_IFORM_JP_RELBRz=715, - XED_IFORM_JRCXZ_RELBRb=716, - XED_IFORM_JS_RELBRb=717, - XED_IFORM_JS_RELBRd=718, - XED_IFORM_JS_RELBRz=719, - XED_IFORM_JZ_RELBRb=720, - XED_IFORM_JZ_RELBRd=721, - XED_IFORM_JZ_RELBRz=722, - XED_IFORM_KADDB_MASKmskw_MASKmskw_MASKmskw_AVX512=723, - XED_IFORM_KADDD_MASKmskw_MASKmskw_MASKmskw_AVX512=724, - XED_IFORM_KADDQ_MASKmskw_MASKmskw_MASKmskw_AVX512=725, - XED_IFORM_KADDW_MASKmskw_MASKmskw_MASKmskw_AVX512=726, - XED_IFORM_KANDB_MASKmskw_MASKmskw_MASKmskw_AVX512=727, - XED_IFORM_KANDD_MASKmskw_MASKmskw_MASKmskw_AVX512=728, - XED_IFORM_KANDNB_MASKmskw_MASKmskw_MASKmskw_AVX512=729, - XED_IFORM_KANDND_MASKmskw_MASKmskw_MASKmskw_AVX512=730, - XED_IFORM_KANDNQ_MASKmskw_MASKmskw_MASKmskw_AVX512=731, - XED_IFORM_KANDNW_MASKmskw_MASKmskw_MASKmskw_AVX512=732, - XED_IFORM_KANDQ_MASKmskw_MASKmskw_MASKmskw_AVX512=733, - XED_IFORM_KANDW_MASKmskw_MASKmskw_MASKmskw_AVX512=734, - XED_IFORM_KMOVB_GPR32u32_MASKmskw_AVX512=735, - XED_IFORM_KMOVB_MASKmskw_GPR32u32_AVX512=736, - XED_IFORM_KMOVB_MASKmskw_MASKu8_AVX512=737, - XED_IFORM_KMOVB_MASKmskw_MEMu8_AVX512=738, - XED_IFORM_KMOVB_MEMu8_MASKmskw_AVX512=739, - XED_IFORM_KMOVD_GPR32u32_MASKmskw_AVX512=740, - XED_IFORM_KMOVD_MASKmskw_GPR32u32_AVX512=741, - XED_IFORM_KMOVD_MASKmskw_MASKu32_AVX512=742, - XED_IFORM_KMOVD_MASKmskw_MEMu32_AVX512=743, - XED_IFORM_KMOVD_MEMu32_MASKmskw_AVX512=744, - XED_IFORM_KMOVQ_GPR64u64_MASKmskw_AVX512=745, - XED_IFORM_KMOVQ_MASKmskw_GPR64u64_AVX512=746, - XED_IFORM_KMOVQ_MASKmskw_MASKu64_AVX512=747, - XED_IFORM_KMOVQ_MASKmskw_MEMu64_AVX512=748, - XED_IFORM_KMOVQ_MEMu64_MASKmskw_AVX512=749, - XED_IFORM_KMOVW_GPR32u32_MASKmskw_AVX512=750, - XED_IFORM_KMOVW_MASKmskw_GPR32u32_AVX512=751, - XED_IFORM_KMOVW_MASKmskw_MASKu16_AVX512=752, - XED_IFORM_KMOVW_MASKmskw_MEMu16_AVX512=753, - XED_IFORM_KMOVW_MEMu16_MASKmskw_AVX512=754, - XED_IFORM_KNOTB_MASKmskw_MASKmskw_AVX512=755, - XED_IFORM_KNOTD_MASKmskw_MASKmskw_AVX512=756, - XED_IFORM_KNOTQ_MASKmskw_MASKmskw_AVX512=757, - XED_IFORM_KNOTW_MASKmskw_MASKmskw_AVX512=758, - XED_IFORM_KORB_MASKmskw_MASKmskw_MASKmskw_AVX512=759, - XED_IFORM_KORD_MASKmskw_MASKmskw_MASKmskw_AVX512=760, - XED_IFORM_KORQ_MASKmskw_MASKmskw_MASKmskw_AVX512=761, - XED_IFORM_KORTESTB_MASKmskw_MASKmskw_AVX512=762, - XED_IFORM_KORTESTD_MASKmskw_MASKmskw_AVX512=763, - XED_IFORM_KORTESTQ_MASKmskw_MASKmskw_AVX512=764, - XED_IFORM_KORTESTW_MASKmskw_MASKmskw_AVX512=765, - XED_IFORM_KORW_MASKmskw_MASKmskw_MASKmskw_AVX512=766, - XED_IFORM_KSHIFTLB_MASKmskw_MASKmskw_IMM8_AVX512=767, - XED_IFORM_KSHIFTLD_MASKmskw_MASKmskw_IMM8_AVX512=768, - XED_IFORM_KSHIFTLQ_MASKmskw_MASKmskw_IMM8_AVX512=769, - XED_IFORM_KSHIFTLW_MASKmskw_MASKmskw_IMM8_AVX512=770, - XED_IFORM_KSHIFTRB_MASKmskw_MASKmskw_IMM8_AVX512=771, - XED_IFORM_KSHIFTRD_MASKmskw_MASKmskw_IMM8_AVX512=772, - XED_IFORM_KSHIFTRQ_MASKmskw_MASKmskw_IMM8_AVX512=773, - XED_IFORM_KSHIFTRW_MASKmskw_MASKmskw_IMM8_AVX512=774, - XED_IFORM_KTESTB_MASKmskw_MASKmskw_AVX512=775, - XED_IFORM_KTESTD_MASKmskw_MASKmskw_AVX512=776, - XED_IFORM_KTESTQ_MASKmskw_MASKmskw_AVX512=777, - XED_IFORM_KTESTW_MASKmskw_MASKmskw_AVX512=778, - XED_IFORM_KUNPCKBW_MASKmskw_MASKmskw_MASKmskw_AVX512=779, - XED_IFORM_KUNPCKDQ_MASKmskw_MASKmskw_MASKmskw_AVX512=780, - XED_IFORM_KUNPCKWD_MASKmskw_MASKmskw_MASKmskw_AVX512=781, - XED_IFORM_KXNORB_MASKmskw_MASKmskw_MASKmskw_AVX512=782, - XED_IFORM_KXNORD_MASKmskw_MASKmskw_MASKmskw_AVX512=783, - XED_IFORM_KXNORQ_MASKmskw_MASKmskw_MASKmskw_AVX512=784, - XED_IFORM_KXNORW_MASKmskw_MASKmskw_MASKmskw_AVX512=785, - XED_IFORM_KXORB_MASKmskw_MASKmskw_MASKmskw_AVX512=786, - XED_IFORM_KXORD_MASKmskw_MASKmskw_MASKmskw_AVX512=787, - XED_IFORM_KXORQ_MASKmskw_MASKmskw_MASKmskw_AVX512=788, - XED_IFORM_KXORW_MASKmskw_MASKmskw_MASKmskw_AVX512=789, - XED_IFORM_LAHF=790, - XED_IFORM_LAR_GPRv_GPRv=791, - XED_IFORM_LAR_GPRv_MEMw=792, - XED_IFORM_LDDQU_XMMpd_MEMdq=793, - XED_IFORM_LDMXCSR_MEMd=794, - XED_IFORM_LDS_GPRz_MEMp=795, - XED_IFORM_LDTILECFG_MEM=796, - XED_IFORM_LEA_GPRv_AGEN=797, - XED_IFORM_LEAVE=798, - XED_IFORM_LES_GPRz_MEMp=799, - XED_IFORM_LFENCE=800, - XED_IFORM_LFS_GPRv_MEMp2=801, - XED_IFORM_LGDT_MEMs=802, - XED_IFORM_LGDT_MEMs64=803, - XED_IFORM_LGS_GPRv_MEMp2=804, - XED_IFORM_LIDT_MEMs=805, - XED_IFORM_LIDT_MEMs64=806, - XED_IFORM_LLDT_GPR16=807, - XED_IFORM_LLDT_MEMw=808, - XED_IFORM_LLWPCB_VGPRyy=809, - XED_IFORM_LMSW_GPR16=810, - XED_IFORM_LMSW_MEMw=811, - XED_IFORM_LOADIWKEY_XMMu8_XMMu8=812, - XED_IFORM_LODSB=813, - XED_IFORM_LODSD=814, - XED_IFORM_LODSQ=815, - XED_IFORM_LODSW=816, - XED_IFORM_LOOP_RELBRb=817, - XED_IFORM_LOOPE_RELBRb=818, - XED_IFORM_LOOPNE_RELBRb=819, - XED_IFORM_LSL_GPRv_GPRz=820, - XED_IFORM_LSL_GPRv_MEMw=821, - XED_IFORM_LSS_GPRv_MEMp2=822, - XED_IFORM_LTR_GPR16=823, - XED_IFORM_LTR_MEMw=824, - XED_IFORM_LWPINS_VGPRyy_MEMd_IMMd=825, - XED_IFORM_LWPINS_VGPRyy_VGPR32y_IMMd=826, - XED_IFORM_LWPVAL_VGPRyy_MEMd_IMMd=827, - XED_IFORM_LWPVAL_VGPRyy_VGPR32y_IMMd=828, - XED_IFORM_LZCNT_GPRv_GPRv=829, - XED_IFORM_LZCNT_GPRv_MEMv=830, - XED_IFORM_MASKMOVDQU_XMMdq_XMMdq=831, - XED_IFORM_MASKMOVQ_MMXq_MMXq=832, - XED_IFORM_MAXPD_XMMpd_MEMpd=833, - XED_IFORM_MAXPD_XMMpd_XMMpd=834, - XED_IFORM_MAXPS_XMMps_MEMps=835, - XED_IFORM_MAXPS_XMMps_XMMps=836, - XED_IFORM_MAXSD_XMMsd_MEMsd=837, - XED_IFORM_MAXSD_XMMsd_XMMsd=838, - XED_IFORM_MAXSS_XMMss_MEMss=839, - XED_IFORM_MAXSS_XMMss_XMMss=840, - XED_IFORM_MCOMMIT=841, - XED_IFORM_MFENCE=842, - XED_IFORM_MINPD_XMMpd_MEMpd=843, - XED_IFORM_MINPD_XMMpd_XMMpd=844, - XED_IFORM_MINPS_XMMps_MEMps=845, - XED_IFORM_MINPS_XMMps_XMMps=846, - XED_IFORM_MINSD_XMMsd_MEMsd=847, - XED_IFORM_MINSD_XMMsd_XMMsd=848, - XED_IFORM_MINSS_XMMss_MEMss=849, - XED_IFORM_MINSS_XMMss_XMMss=850, - XED_IFORM_MONITOR=851, - XED_IFORM_MONITORX=852, - XED_IFORM_MOV_AL_MEMb=853, - XED_IFORM_MOV_GPR8_GPR8_88=854, - XED_IFORM_MOV_GPR8_GPR8_8A=855, - XED_IFORM_MOV_GPR8_IMMb_B0=856, - XED_IFORM_MOV_GPR8_IMMb_C6r0=857, - XED_IFORM_MOV_GPR8_MEMb=858, - XED_IFORM_MOV_GPRv_GPRv_89=859, - XED_IFORM_MOV_GPRv_GPRv_8B=860, - XED_IFORM_MOV_GPRv_IMMv=861, - XED_IFORM_MOV_GPRv_IMMz=862, - XED_IFORM_MOV_GPRv_MEMv=863, - XED_IFORM_MOV_GPRv_SEG=864, - XED_IFORM_MOV_MEMb_AL=865, - XED_IFORM_MOV_MEMb_GPR8=866, - XED_IFORM_MOV_MEMb_IMMb=867, - XED_IFORM_MOV_MEMv_GPRv=868, - XED_IFORM_MOV_MEMv_IMMz=869, - XED_IFORM_MOV_MEMv_OrAX=870, - XED_IFORM_MOV_MEMw_SEG=871, - XED_IFORM_MOV_OrAX_MEMv=872, - XED_IFORM_MOV_SEG_GPR16=873, - XED_IFORM_MOV_SEG_MEMw=874, - XED_IFORM_MOVAPD_MEMpd_XMMpd=875, - XED_IFORM_MOVAPD_XMMpd_MEMpd=876, - XED_IFORM_MOVAPD_XMMpd_XMMpd_0F28=877, - XED_IFORM_MOVAPD_XMMpd_XMMpd_0F29=878, - XED_IFORM_MOVAPS_MEMps_XMMps=879, - XED_IFORM_MOVAPS_XMMps_MEMps=880, - XED_IFORM_MOVAPS_XMMps_XMMps_0F28=881, - XED_IFORM_MOVAPS_XMMps_XMMps_0F29=882, - XED_IFORM_MOVBE_GPRv_MEMv=883, - XED_IFORM_MOVBE_MEMv_GPRv=884, - XED_IFORM_MOVD_GPR32_MMXd=885, - XED_IFORM_MOVD_GPR32_XMMd=886, - XED_IFORM_MOVD_MEMd_MMXd=887, - XED_IFORM_MOVD_MEMd_XMMd=888, - XED_IFORM_MOVD_MMXq_GPR32=889, - XED_IFORM_MOVD_MMXq_MEMd=890, - XED_IFORM_MOVD_XMMdq_GPR32=891, - XED_IFORM_MOVD_XMMdq_MEMd=892, - XED_IFORM_MOVDDUP_XMMdq_MEMq=893, - XED_IFORM_MOVDDUP_XMMdq_XMMq=894, - XED_IFORM_MOVDIR64B_GPRa_MEM=895, - XED_IFORM_MOVDIRI_MEMu32_GPR32u32=896, - XED_IFORM_MOVDIRI_MEMu64_GPR64u64=897, - XED_IFORM_MOVDQ2Q_MMXq_XMMq=898, - XED_IFORM_MOVDQA_MEMdq_XMMdq=899, - XED_IFORM_MOVDQA_XMMdq_MEMdq=900, - XED_IFORM_MOVDQA_XMMdq_XMMdq_0F6F=901, - XED_IFORM_MOVDQA_XMMdq_XMMdq_0F7F=902, - XED_IFORM_MOVDQU_MEMdq_XMMdq=903, - XED_IFORM_MOVDQU_XMMdq_MEMdq=904, - XED_IFORM_MOVDQU_XMMdq_XMMdq_0F6F=905, - XED_IFORM_MOVDQU_XMMdq_XMMdq_0F7F=906, - XED_IFORM_MOVHLPS_XMMq_XMMq=907, - XED_IFORM_MOVHPD_MEMq_XMMsd=908, - XED_IFORM_MOVHPD_XMMsd_MEMq=909, - XED_IFORM_MOVHPS_MEMq_XMMps=910, - XED_IFORM_MOVHPS_XMMq_MEMq=911, - XED_IFORM_MOVLHPS_XMMq_XMMq=912, - XED_IFORM_MOVLPD_MEMq_XMMsd=913, - XED_IFORM_MOVLPD_XMMsd_MEMq=914, - XED_IFORM_MOVLPS_MEMq_XMMq=915, - XED_IFORM_MOVLPS_XMMq_MEMq=916, - XED_IFORM_MOVMSKPD_GPR32_XMMpd=917, - XED_IFORM_MOVMSKPS_GPR32_XMMps=918, - XED_IFORM_MOVNTDQ_MEMdq_XMMdq=919, - XED_IFORM_MOVNTDQA_XMMdq_MEMdq=920, - XED_IFORM_MOVNTI_MEMd_GPR32=921, - XED_IFORM_MOVNTI_MEMq_GPR64=922, - XED_IFORM_MOVNTPD_MEMdq_XMMpd=923, - XED_IFORM_MOVNTPS_MEMdq_XMMps=924, - XED_IFORM_MOVNTQ_MEMq_MMXq=925, - XED_IFORM_MOVNTSD_MEMq_XMMq=926, - XED_IFORM_MOVNTSS_MEMd_XMMd=927, - XED_IFORM_MOVQ_GPR64_MMXq=928, - XED_IFORM_MOVQ_GPR64_XMMq=929, - XED_IFORM_MOVQ_MEMq_MMXq_0F7E=930, - XED_IFORM_MOVQ_MEMq_MMXq_0F7F=931, - XED_IFORM_MOVQ_MEMq_XMMq_0F7E=932, - XED_IFORM_MOVQ_MEMq_XMMq_0FD6=933, - XED_IFORM_MOVQ_MMXq_GPR64=934, - XED_IFORM_MOVQ_MMXq_MEMq_0F6E=935, - XED_IFORM_MOVQ_MMXq_MEMq_0F6F=936, - XED_IFORM_MOVQ_MMXq_MMXq_0F6F=937, - XED_IFORM_MOVQ_MMXq_MMXq_0F7F=938, - XED_IFORM_MOVQ_XMMdq_GPR64=939, - XED_IFORM_MOVQ_XMMdq_MEMq_0F6E=940, - XED_IFORM_MOVQ_XMMdq_MEMq_0F7E=941, - XED_IFORM_MOVQ_XMMdq_XMMq_0F7E=942, - XED_IFORM_MOVQ_XMMdq_XMMq_0FD6=943, - XED_IFORM_MOVQ2DQ_XMMdq_MMXq=944, - XED_IFORM_MOVSB=945, - XED_IFORM_MOVSD=946, - XED_IFORM_MOVSD_XMM_MEMsd_XMMsd=947, - XED_IFORM_MOVSD_XMM_XMMdq_MEMsd=948, - XED_IFORM_MOVSD_XMM_XMMsd_XMMsd_0F10=949, - XED_IFORM_MOVSD_XMM_XMMsd_XMMsd_0F11=950, - XED_IFORM_MOVSHDUP_XMMps_MEMps=951, - XED_IFORM_MOVSHDUP_XMMps_XMMps=952, - XED_IFORM_MOVSLDUP_XMMps_MEMps=953, - XED_IFORM_MOVSLDUP_XMMps_XMMps=954, - XED_IFORM_MOVSQ=955, - XED_IFORM_MOVSS_MEMss_XMMss=956, - XED_IFORM_MOVSS_XMMdq_MEMss=957, - XED_IFORM_MOVSS_XMMss_XMMss_0F10=958, - XED_IFORM_MOVSS_XMMss_XMMss_0F11=959, - XED_IFORM_MOVSW=960, - XED_IFORM_MOVSX_GPRv_GPR16=961, - XED_IFORM_MOVSX_GPRv_GPR8=962, - XED_IFORM_MOVSX_GPRv_MEMb=963, - XED_IFORM_MOVSX_GPRv_MEMw=964, - XED_IFORM_MOVSXD_GPRv_GPRz=965, - XED_IFORM_MOVSXD_GPRv_MEMz=966, - XED_IFORM_MOVUPD_MEMpd_XMMpd=967, - XED_IFORM_MOVUPD_XMMpd_MEMpd=968, - XED_IFORM_MOVUPD_XMMpd_XMMpd_0F10=969, - XED_IFORM_MOVUPD_XMMpd_XMMpd_0F11=970, - XED_IFORM_MOVUPS_MEMps_XMMps=971, - XED_IFORM_MOVUPS_XMMps_MEMps=972, - XED_IFORM_MOVUPS_XMMps_XMMps_0F10=973, - XED_IFORM_MOVUPS_XMMps_XMMps_0F11=974, - XED_IFORM_MOVZX_GPRv_GPR16=975, - XED_IFORM_MOVZX_GPRv_GPR8=976, - XED_IFORM_MOVZX_GPRv_MEMb=977, - XED_IFORM_MOVZX_GPRv_MEMw=978, - XED_IFORM_MOV_CR_CR_GPR32=979, - XED_IFORM_MOV_CR_CR_GPR64=980, - XED_IFORM_MOV_CR_GPR32_CR=981, - XED_IFORM_MOV_CR_GPR64_CR=982, - XED_IFORM_MOV_DR_DR_GPR32=983, - XED_IFORM_MOV_DR_DR_GPR64=984, - XED_IFORM_MOV_DR_GPR32_DR=985, - XED_IFORM_MOV_DR_GPR64_DR=986, - XED_IFORM_MPSADBW_XMMdq_MEMdq_IMMb=987, - XED_IFORM_MPSADBW_XMMdq_XMMdq_IMMb=988, - XED_IFORM_MUL_GPR8=989, - XED_IFORM_MUL_GPRv=990, - XED_IFORM_MUL_MEMb=991, - XED_IFORM_MUL_MEMv=992, - XED_IFORM_MULPD_XMMpd_MEMpd=993, - XED_IFORM_MULPD_XMMpd_XMMpd=994, - XED_IFORM_MULPS_XMMps_MEMps=995, - XED_IFORM_MULPS_XMMps_XMMps=996, - XED_IFORM_MULSD_XMMsd_MEMsd=997, - XED_IFORM_MULSD_XMMsd_XMMsd=998, - XED_IFORM_MULSS_XMMss_MEMss=999, - XED_IFORM_MULSS_XMMss_XMMss=1000, - XED_IFORM_MULX_VGPR32d_VGPR32d_MEMd=1001, - XED_IFORM_MULX_VGPR32d_VGPR32d_VGPR32d=1002, - XED_IFORM_MULX_VGPR64q_VGPR64q_MEMq=1003, - XED_IFORM_MULX_VGPR64q_VGPR64q_VGPR64q=1004, - XED_IFORM_MWAIT=1005, - XED_IFORM_MWAITX=1006, - XED_IFORM_NEG_GPR8=1007, - XED_IFORM_NEG_GPRv=1008, - XED_IFORM_NEG_MEMb=1009, - XED_IFORM_NEG_MEMv=1010, - XED_IFORM_NEG_LOCK_MEMb=1011, - XED_IFORM_NEG_LOCK_MEMv=1012, - XED_IFORM_NOP_90=1013, - XED_IFORM_NOP_GPRv_0F18r0=1014, - XED_IFORM_NOP_GPRv_0F18r1=1015, - XED_IFORM_NOP_GPRv_0F18r2=1016, - XED_IFORM_NOP_GPRv_0F18r3=1017, - XED_IFORM_NOP_GPRv_0F18r4=1018, - XED_IFORM_NOP_GPRv_0F18r5=1019, - XED_IFORM_NOP_GPRv_0F18r6=1020, - XED_IFORM_NOP_GPRv_0F18r7=1021, - XED_IFORM_NOP_GPRv_GPRv_0F0D=1022, - XED_IFORM_NOP_GPRv_GPRv_0F19=1023, - XED_IFORM_NOP_GPRv_GPRv_0F1A=1024, - XED_IFORM_NOP_GPRv_GPRv_0F1B=1025, - XED_IFORM_NOP_GPRv_GPRv_0F1C=1026, - XED_IFORM_NOP_GPRv_GPRv_0F1D=1027, - XED_IFORM_NOP_GPRv_GPRv_0F1E=1028, - XED_IFORM_NOP_GPRv_GPRv_0F1F=1029, - XED_IFORM_NOP_GPRv_MEM_0F1B=1030, - XED_IFORM_NOP_GPRv_MEMv_0F1A=1031, - XED_IFORM_NOP_MEMv_0F18r4=1032, - XED_IFORM_NOP_MEMv_0F18r5=1033, - XED_IFORM_NOP_MEMv_0F18r6=1034, - XED_IFORM_NOP_MEMv_0F18r7=1035, - XED_IFORM_NOP_MEMv_GPRv_0F19=1036, - XED_IFORM_NOP_MEMv_GPRv_0F1C=1037, - XED_IFORM_NOP_MEMv_GPRv_0F1D=1038, - XED_IFORM_NOP_MEMv_GPRv_0F1E=1039, - XED_IFORM_NOP_MEMv_GPRv_0F1F=1040, - XED_IFORM_NOT_GPR8=1041, - XED_IFORM_NOT_GPRv=1042, - XED_IFORM_NOT_MEMb=1043, - XED_IFORM_NOT_MEMv=1044, - XED_IFORM_NOT_LOCK_MEMb=1045, - XED_IFORM_NOT_LOCK_MEMv=1046, - XED_IFORM_OR_AL_IMMb=1047, - XED_IFORM_OR_GPR8_GPR8_08=1048, - XED_IFORM_OR_GPR8_GPR8_0A=1049, - XED_IFORM_OR_GPR8_IMMb_80r1=1050, - XED_IFORM_OR_GPR8_IMMb_82r1=1051, - XED_IFORM_OR_GPR8_MEMb=1052, - XED_IFORM_OR_GPRv_GPRv_09=1053, - XED_IFORM_OR_GPRv_GPRv_0B=1054, - XED_IFORM_OR_GPRv_IMMb=1055, - XED_IFORM_OR_GPRv_IMMz=1056, - XED_IFORM_OR_GPRv_MEMv=1057, - XED_IFORM_OR_MEMb_GPR8=1058, - XED_IFORM_OR_MEMb_IMMb_80r1=1059, - XED_IFORM_OR_MEMb_IMMb_82r1=1060, - XED_IFORM_OR_MEMv_GPRv=1061, - XED_IFORM_OR_MEMv_IMMb=1062, - XED_IFORM_OR_MEMv_IMMz=1063, - XED_IFORM_OR_OrAX_IMMz=1064, - XED_IFORM_ORPD_XMMxuq_MEMxuq=1065, - XED_IFORM_ORPD_XMMxuq_XMMxuq=1066, - XED_IFORM_ORPS_XMMxud_MEMxud=1067, - XED_IFORM_ORPS_XMMxud_XMMxud=1068, - XED_IFORM_OR_LOCK_MEMb_GPR8=1069, - XED_IFORM_OR_LOCK_MEMb_IMMb_80r1=1070, - XED_IFORM_OR_LOCK_MEMb_IMMb_82r1=1071, - XED_IFORM_OR_LOCK_MEMv_GPRv=1072, - XED_IFORM_OR_LOCK_MEMv_IMMb=1073, - XED_IFORM_OR_LOCK_MEMv_IMMz=1074, - XED_IFORM_OUT_DX_AL=1075, - XED_IFORM_OUT_DX_OeAX=1076, - XED_IFORM_OUT_IMMb_AL=1077, - XED_IFORM_OUT_IMMb_OeAX=1078, - XED_IFORM_OUTSB=1079, - XED_IFORM_OUTSD=1080, - XED_IFORM_OUTSW=1081, - XED_IFORM_PABSB_MMXq_MEMq=1082, - XED_IFORM_PABSB_MMXq_MMXq=1083, - XED_IFORM_PABSB_XMMdq_MEMdq=1084, - XED_IFORM_PABSB_XMMdq_XMMdq=1085, - XED_IFORM_PABSD_MMXq_MEMq=1086, - XED_IFORM_PABSD_MMXq_MMXq=1087, - XED_IFORM_PABSD_XMMdq_MEMdq=1088, - XED_IFORM_PABSD_XMMdq_XMMdq=1089, - XED_IFORM_PABSW_MMXq_MEMq=1090, - XED_IFORM_PABSW_MMXq_MMXq=1091, - XED_IFORM_PABSW_XMMdq_MEMdq=1092, - XED_IFORM_PABSW_XMMdq_XMMdq=1093, - XED_IFORM_PACKSSDW_MMXq_MEMq=1094, - XED_IFORM_PACKSSDW_MMXq_MMXq=1095, - XED_IFORM_PACKSSDW_XMMdq_MEMdq=1096, - XED_IFORM_PACKSSDW_XMMdq_XMMdq=1097, - XED_IFORM_PACKSSWB_MMXq_MEMq=1098, - XED_IFORM_PACKSSWB_MMXq_MMXq=1099, - XED_IFORM_PACKSSWB_XMMdq_MEMdq=1100, - XED_IFORM_PACKSSWB_XMMdq_XMMdq=1101, - XED_IFORM_PACKUSDW_XMMdq_MEMdq=1102, - XED_IFORM_PACKUSDW_XMMdq_XMMdq=1103, - XED_IFORM_PACKUSWB_MMXq_MEMq=1104, - XED_IFORM_PACKUSWB_MMXq_MMXq=1105, - XED_IFORM_PACKUSWB_XMMdq_MEMdq=1106, - XED_IFORM_PACKUSWB_XMMdq_XMMdq=1107, - XED_IFORM_PADDB_MMXq_MEMq=1108, - XED_IFORM_PADDB_MMXq_MMXq=1109, - XED_IFORM_PADDB_XMMdq_MEMdq=1110, - XED_IFORM_PADDB_XMMdq_XMMdq=1111, - XED_IFORM_PADDD_MMXq_MEMq=1112, - XED_IFORM_PADDD_MMXq_MMXq=1113, - XED_IFORM_PADDD_XMMdq_MEMdq=1114, - XED_IFORM_PADDD_XMMdq_XMMdq=1115, - XED_IFORM_PADDQ_MMXq_MEMq=1116, - XED_IFORM_PADDQ_MMXq_MMXq=1117, - XED_IFORM_PADDQ_XMMdq_MEMdq=1118, - XED_IFORM_PADDQ_XMMdq_XMMdq=1119, - XED_IFORM_PADDSB_MMXq_MEMq=1120, - XED_IFORM_PADDSB_MMXq_MMXq=1121, - XED_IFORM_PADDSB_XMMdq_MEMdq=1122, - XED_IFORM_PADDSB_XMMdq_XMMdq=1123, - XED_IFORM_PADDSW_MMXq_MEMq=1124, - XED_IFORM_PADDSW_MMXq_MMXq=1125, - XED_IFORM_PADDSW_XMMdq_MEMdq=1126, - XED_IFORM_PADDSW_XMMdq_XMMdq=1127, - XED_IFORM_PADDUSB_MMXq_MEMq=1128, - XED_IFORM_PADDUSB_MMXq_MMXq=1129, - XED_IFORM_PADDUSB_XMMdq_MEMdq=1130, - XED_IFORM_PADDUSB_XMMdq_XMMdq=1131, - XED_IFORM_PADDUSW_MMXq_MEMq=1132, - XED_IFORM_PADDUSW_MMXq_MMXq=1133, - XED_IFORM_PADDUSW_XMMdq_MEMdq=1134, - XED_IFORM_PADDUSW_XMMdq_XMMdq=1135, - XED_IFORM_PADDW_MMXq_MEMq=1136, - XED_IFORM_PADDW_MMXq_MMXq=1137, - XED_IFORM_PADDW_XMMdq_MEMdq=1138, - XED_IFORM_PADDW_XMMdq_XMMdq=1139, - XED_IFORM_PALIGNR_MMXq_MEMq_IMMb=1140, - XED_IFORM_PALIGNR_MMXq_MMXq_IMMb=1141, - XED_IFORM_PALIGNR_XMMdq_MEMdq_IMMb=1142, - XED_IFORM_PALIGNR_XMMdq_XMMdq_IMMb=1143, - XED_IFORM_PAND_MMXq_MEMq=1144, - XED_IFORM_PAND_MMXq_MMXq=1145, - XED_IFORM_PAND_XMMdq_MEMdq=1146, - XED_IFORM_PAND_XMMdq_XMMdq=1147, - XED_IFORM_PANDN_MMXq_MEMq=1148, - XED_IFORM_PANDN_MMXq_MMXq=1149, - XED_IFORM_PANDN_XMMdq_MEMdq=1150, - XED_IFORM_PANDN_XMMdq_XMMdq=1151, - XED_IFORM_PAUSE=1152, - XED_IFORM_PAVGB_MMXq_MEMq=1153, - XED_IFORM_PAVGB_MMXq_MMXq=1154, - XED_IFORM_PAVGB_XMMdq_MEMdq=1155, - XED_IFORM_PAVGB_XMMdq_XMMdq=1156, - XED_IFORM_PAVGUSB_MMXq_MEMq=1157, - XED_IFORM_PAVGUSB_MMXq_MMXq=1158, - XED_IFORM_PAVGW_MMXq_MEMq=1159, - XED_IFORM_PAVGW_MMXq_MMXq=1160, - XED_IFORM_PAVGW_XMMdq_MEMdq=1161, - XED_IFORM_PAVGW_XMMdq_XMMdq=1162, - XED_IFORM_PBLENDVB_XMMdq_MEMdq=1163, - XED_IFORM_PBLENDVB_XMMdq_XMMdq=1164, - XED_IFORM_PBLENDW_XMMdq_MEMdq_IMMb=1165, - XED_IFORM_PBLENDW_XMMdq_XMMdq_IMMb=1166, - XED_IFORM_PCLMULQDQ_XMMdq_MEMdq_IMMb=1167, - XED_IFORM_PCLMULQDQ_XMMdq_XMMdq_IMMb=1168, - XED_IFORM_PCMPEQB_MMXq_MEMq=1169, - XED_IFORM_PCMPEQB_MMXq_MMXq=1170, - XED_IFORM_PCMPEQB_XMMdq_MEMdq=1171, - XED_IFORM_PCMPEQB_XMMdq_XMMdq=1172, - XED_IFORM_PCMPEQD_MMXq_MEMq=1173, - XED_IFORM_PCMPEQD_MMXq_MMXq=1174, - XED_IFORM_PCMPEQD_XMMdq_MEMdq=1175, - XED_IFORM_PCMPEQD_XMMdq_XMMdq=1176, - XED_IFORM_PCMPEQQ_XMMdq_MEMdq=1177, - XED_IFORM_PCMPEQQ_XMMdq_XMMdq=1178, - XED_IFORM_PCMPEQW_MMXq_MEMq=1179, - XED_IFORM_PCMPEQW_MMXq_MMXq=1180, - XED_IFORM_PCMPEQW_XMMdq_MEMdq=1181, - XED_IFORM_PCMPEQW_XMMdq_XMMdq=1182, - XED_IFORM_PCMPESTRI_XMMdq_MEMdq_IMMb=1183, - XED_IFORM_PCMPESTRI_XMMdq_XMMdq_IMMb=1184, - XED_IFORM_PCMPESTRI64_XMMdq_MEMdq_IMMb=1185, - XED_IFORM_PCMPESTRI64_XMMdq_XMMdq_IMMb=1186, - XED_IFORM_PCMPESTRM_XMMdq_MEMdq_IMMb=1187, - XED_IFORM_PCMPESTRM_XMMdq_XMMdq_IMMb=1188, - XED_IFORM_PCMPESTRM64_XMMdq_MEMdq_IMMb=1189, - XED_IFORM_PCMPESTRM64_XMMdq_XMMdq_IMMb=1190, - XED_IFORM_PCMPGTB_MMXq_MEMq=1191, - XED_IFORM_PCMPGTB_MMXq_MMXq=1192, - XED_IFORM_PCMPGTB_XMMdq_MEMdq=1193, - XED_IFORM_PCMPGTB_XMMdq_XMMdq=1194, - XED_IFORM_PCMPGTD_MMXq_MEMq=1195, - XED_IFORM_PCMPGTD_MMXq_MMXq=1196, - XED_IFORM_PCMPGTD_XMMdq_MEMdq=1197, - XED_IFORM_PCMPGTD_XMMdq_XMMdq=1198, - XED_IFORM_PCMPGTQ_XMMdq_MEMdq=1199, - XED_IFORM_PCMPGTQ_XMMdq_XMMdq=1200, - XED_IFORM_PCMPGTW_MMXq_MEMq=1201, - XED_IFORM_PCMPGTW_MMXq_MMXq=1202, - XED_IFORM_PCMPGTW_XMMdq_MEMdq=1203, - XED_IFORM_PCMPGTW_XMMdq_XMMdq=1204, - XED_IFORM_PCMPISTRI_XMMdq_MEMdq_IMMb=1205, - XED_IFORM_PCMPISTRI_XMMdq_XMMdq_IMMb=1206, - XED_IFORM_PCMPISTRI64_XMMdq_MEMdq_IMMb=1207, - XED_IFORM_PCMPISTRI64_XMMdq_XMMdq_IMMb=1208, - XED_IFORM_PCMPISTRM_XMMdq_MEMdq_IMMb=1209, - XED_IFORM_PCMPISTRM_XMMdq_XMMdq_IMMb=1210, - XED_IFORM_PCONFIG=1211, - XED_IFORM_PCONFIG64=1212, - XED_IFORM_PDEP_VGPR32d_VGPR32d_MEMd=1213, - XED_IFORM_PDEP_VGPR32d_VGPR32d_VGPR32d=1214, - XED_IFORM_PDEP_VGPR64q_VGPR64q_MEMq=1215, - XED_IFORM_PDEP_VGPR64q_VGPR64q_VGPR64q=1216, - XED_IFORM_PEXT_VGPR32d_VGPR32d_MEMd=1217, - XED_IFORM_PEXT_VGPR32d_VGPR32d_VGPR32d=1218, - XED_IFORM_PEXT_VGPR64q_VGPR64q_MEMq=1219, - XED_IFORM_PEXT_VGPR64q_VGPR64q_VGPR64q=1220, - XED_IFORM_PEXTRB_GPR32d_XMMdq_IMMb=1221, - XED_IFORM_PEXTRB_MEMb_XMMdq_IMMb=1222, - XED_IFORM_PEXTRD_GPR32d_XMMdq_IMMb=1223, - XED_IFORM_PEXTRD_MEMd_XMMdq_IMMb=1224, - XED_IFORM_PEXTRQ_GPR64q_XMMdq_IMMb=1225, - XED_IFORM_PEXTRQ_MEMq_XMMdq_IMMb=1226, - XED_IFORM_PEXTRW_GPR32_MMXq_IMMb=1227, - XED_IFORM_PEXTRW_GPR32_XMMdq_IMMb=1228, - XED_IFORM_PEXTRW_SSE4_GPR32_XMMdq_IMMb=1229, - XED_IFORM_PEXTRW_SSE4_MEMw_XMMdq_IMMb=1230, - XED_IFORM_PF2ID_MMXq_MEMq=1231, - XED_IFORM_PF2ID_MMXq_MMXq=1232, - XED_IFORM_PF2IW_MMXq_MEMq=1233, - XED_IFORM_PF2IW_MMXq_MMXq=1234, - XED_IFORM_PFACC_MMXq_MEMq=1235, - XED_IFORM_PFACC_MMXq_MMXq=1236, - XED_IFORM_PFADD_MMXq_MEMq=1237, - XED_IFORM_PFADD_MMXq_MMXq=1238, - XED_IFORM_PFCMPEQ_MMXq_MEMq=1239, - XED_IFORM_PFCMPEQ_MMXq_MMXq=1240, - XED_IFORM_PFCMPGE_MMXq_MEMq=1241, - XED_IFORM_PFCMPGE_MMXq_MMXq=1242, - XED_IFORM_PFCMPGT_MMXq_MEMq=1243, - XED_IFORM_PFCMPGT_MMXq_MMXq=1244, - XED_IFORM_PFMAX_MMXq_MEMq=1245, - XED_IFORM_PFMAX_MMXq_MMXq=1246, - XED_IFORM_PFMIN_MMXq_MEMq=1247, - XED_IFORM_PFMIN_MMXq_MMXq=1248, - XED_IFORM_PFMUL_MMXq_MEMq=1249, - XED_IFORM_PFMUL_MMXq_MMXq=1250, - XED_IFORM_PFNACC_MMXq_MEMq=1251, - XED_IFORM_PFNACC_MMXq_MMXq=1252, - XED_IFORM_PFPNACC_MMXq_MEMq=1253, - XED_IFORM_PFPNACC_MMXq_MMXq=1254, - XED_IFORM_PFRCP_MMXq_MEMq=1255, - XED_IFORM_PFRCP_MMXq_MMXq=1256, - XED_IFORM_PFRCPIT1_MMXq_MEMq=1257, - XED_IFORM_PFRCPIT1_MMXq_MMXq=1258, - XED_IFORM_PFRCPIT2_MMXq_MEMq=1259, - XED_IFORM_PFRCPIT2_MMXq_MMXq=1260, - XED_IFORM_PFRSQIT1_MMXq_MEMq=1261, - XED_IFORM_PFRSQIT1_MMXq_MMXq=1262, - XED_IFORM_PFRSQRT_MMXq_MEMq=1263, - XED_IFORM_PFRSQRT_MMXq_MMXq=1264, - XED_IFORM_PFSUB_MMXq_MEMq=1265, - XED_IFORM_PFSUB_MMXq_MMXq=1266, - XED_IFORM_PFSUBR_MMXq_MEMq=1267, - XED_IFORM_PFSUBR_MMXq_MMXq=1268, - XED_IFORM_PHADDD_MMXq_MEMq=1269, - XED_IFORM_PHADDD_MMXq_MMXq=1270, - XED_IFORM_PHADDD_XMMdq_MEMdq=1271, - XED_IFORM_PHADDD_XMMdq_XMMdq=1272, - XED_IFORM_PHADDSW_MMXq_MEMq=1273, - XED_IFORM_PHADDSW_MMXq_MMXq=1274, - XED_IFORM_PHADDSW_XMMdq_MEMdq=1275, - XED_IFORM_PHADDSW_XMMdq_XMMdq=1276, - XED_IFORM_PHADDW_MMXq_MEMq=1277, - XED_IFORM_PHADDW_MMXq_MMXq=1278, - XED_IFORM_PHADDW_XMMdq_MEMdq=1279, - XED_IFORM_PHADDW_XMMdq_XMMdq=1280, - XED_IFORM_PHMINPOSUW_XMMdq_MEMdq=1281, - XED_IFORM_PHMINPOSUW_XMMdq_XMMdq=1282, - XED_IFORM_PHSUBD_MMXq_MEMq=1283, - XED_IFORM_PHSUBD_MMXq_MMXq=1284, - XED_IFORM_PHSUBD_XMMdq_MEMdq=1285, - XED_IFORM_PHSUBD_XMMdq_XMMdq=1286, - XED_IFORM_PHSUBSW_MMXq_MEMq=1287, - XED_IFORM_PHSUBSW_MMXq_MMXq=1288, - XED_IFORM_PHSUBSW_XMMdq_MEMdq=1289, - XED_IFORM_PHSUBSW_XMMdq_XMMdq=1290, - XED_IFORM_PHSUBW_MMXq_MEMq=1291, - XED_IFORM_PHSUBW_MMXq_MMXq=1292, - XED_IFORM_PHSUBW_XMMdq_MEMdq=1293, - XED_IFORM_PHSUBW_XMMdq_XMMdq=1294, - XED_IFORM_PI2FD_MMXq_MEMq=1295, - XED_IFORM_PI2FD_MMXq_MMXq=1296, - XED_IFORM_PI2FW_MMXq_MEMq=1297, - XED_IFORM_PI2FW_MMXq_MMXq=1298, - XED_IFORM_PINSRB_XMMdq_GPR32d_IMMb=1299, - XED_IFORM_PINSRB_XMMdq_MEMb_IMMb=1300, - XED_IFORM_PINSRD_XMMdq_GPR32d_IMMb=1301, - XED_IFORM_PINSRD_XMMdq_MEMd_IMMb=1302, - XED_IFORM_PINSRQ_XMMdq_GPR64q_IMMb=1303, - XED_IFORM_PINSRQ_XMMdq_MEMq_IMMb=1304, - XED_IFORM_PINSRW_MMXq_GPR32_IMMb=1305, - XED_IFORM_PINSRW_MMXq_MEMw_IMMb=1306, - XED_IFORM_PINSRW_XMMdq_GPR32_IMMb=1307, - XED_IFORM_PINSRW_XMMdq_MEMw_IMMb=1308, - XED_IFORM_PMADDUBSW_MMXq_MEMq=1309, - XED_IFORM_PMADDUBSW_MMXq_MMXq=1310, - XED_IFORM_PMADDUBSW_XMMdq_MEMdq=1311, - XED_IFORM_PMADDUBSW_XMMdq_XMMdq=1312, - XED_IFORM_PMADDWD_MMXq_MEMq=1313, - XED_IFORM_PMADDWD_MMXq_MMXq=1314, - XED_IFORM_PMADDWD_XMMdq_MEMdq=1315, - XED_IFORM_PMADDWD_XMMdq_XMMdq=1316, - XED_IFORM_PMAXSB_XMMdq_MEMdq=1317, - XED_IFORM_PMAXSB_XMMdq_XMMdq=1318, - XED_IFORM_PMAXSD_XMMdq_MEMdq=1319, - XED_IFORM_PMAXSD_XMMdq_XMMdq=1320, - XED_IFORM_PMAXSW_MMXq_MEMq=1321, - XED_IFORM_PMAXSW_MMXq_MMXq=1322, - XED_IFORM_PMAXSW_XMMdq_MEMdq=1323, - XED_IFORM_PMAXSW_XMMdq_XMMdq=1324, - XED_IFORM_PMAXUB_MMXq_MEMq=1325, - XED_IFORM_PMAXUB_MMXq_MMXq=1326, - XED_IFORM_PMAXUB_XMMdq_MEMdq=1327, - XED_IFORM_PMAXUB_XMMdq_XMMdq=1328, - XED_IFORM_PMAXUD_XMMdq_MEMdq=1329, - XED_IFORM_PMAXUD_XMMdq_XMMdq=1330, - XED_IFORM_PMAXUW_XMMdq_MEMdq=1331, - XED_IFORM_PMAXUW_XMMdq_XMMdq=1332, - XED_IFORM_PMINSB_XMMdq_MEMdq=1333, - XED_IFORM_PMINSB_XMMdq_XMMdq=1334, - XED_IFORM_PMINSD_XMMdq_MEMdq=1335, - XED_IFORM_PMINSD_XMMdq_XMMdq=1336, - XED_IFORM_PMINSW_MMXq_MEMq=1337, - XED_IFORM_PMINSW_MMXq_MMXq=1338, - XED_IFORM_PMINSW_XMMdq_MEMdq=1339, - XED_IFORM_PMINSW_XMMdq_XMMdq=1340, - XED_IFORM_PMINUB_MMXq_MEMq=1341, - XED_IFORM_PMINUB_MMXq_MMXq=1342, - XED_IFORM_PMINUB_XMMdq_MEMdq=1343, - XED_IFORM_PMINUB_XMMdq_XMMdq=1344, - XED_IFORM_PMINUD_XMMdq_MEMdq=1345, - XED_IFORM_PMINUD_XMMdq_XMMdq=1346, - XED_IFORM_PMINUW_XMMdq_MEMdq=1347, - XED_IFORM_PMINUW_XMMdq_XMMdq=1348, - XED_IFORM_PMOVMSKB_GPR32_MMXq=1349, - XED_IFORM_PMOVMSKB_GPR32_XMMdq=1350, - XED_IFORM_PMOVSXBD_XMMdq_MEMd=1351, - XED_IFORM_PMOVSXBD_XMMdq_XMMd=1352, - XED_IFORM_PMOVSXBQ_XMMdq_MEMw=1353, - XED_IFORM_PMOVSXBQ_XMMdq_XMMw=1354, - XED_IFORM_PMOVSXBW_XMMdq_MEMq=1355, - XED_IFORM_PMOVSXBW_XMMdq_XMMq=1356, - XED_IFORM_PMOVSXDQ_XMMdq_MEMq=1357, - XED_IFORM_PMOVSXDQ_XMMdq_XMMq=1358, - XED_IFORM_PMOVSXWD_XMMdq_MEMq=1359, - XED_IFORM_PMOVSXWD_XMMdq_XMMq=1360, - XED_IFORM_PMOVSXWQ_XMMdq_MEMd=1361, - XED_IFORM_PMOVSXWQ_XMMdq_XMMd=1362, - XED_IFORM_PMOVZXBD_XMMdq_MEMd=1363, - XED_IFORM_PMOVZXBD_XMMdq_XMMd=1364, - XED_IFORM_PMOVZXBQ_XMMdq_MEMw=1365, - XED_IFORM_PMOVZXBQ_XMMdq_XMMw=1366, - XED_IFORM_PMOVZXBW_XMMdq_MEMq=1367, - XED_IFORM_PMOVZXBW_XMMdq_XMMq=1368, - XED_IFORM_PMOVZXDQ_XMMdq_MEMq=1369, - XED_IFORM_PMOVZXDQ_XMMdq_XMMq=1370, - XED_IFORM_PMOVZXWD_XMMdq_MEMq=1371, - XED_IFORM_PMOVZXWD_XMMdq_XMMq=1372, - XED_IFORM_PMOVZXWQ_XMMdq_MEMd=1373, - XED_IFORM_PMOVZXWQ_XMMdq_XMMd=1374, - XED_IFORM_PMULDQ_XMMdq_MEMdq=1375, - XED_IFORM_PMULDQ_XMMdq_XMMdq=1376, - XED_IFORM_PMULHRSW_MMXq_MEMq=1377, - XED_IFORM_PMULHRSW_MMXq_MMXq=1378, - XED_IFORM_PMULHRSW_XMMdq_MEMdq=1379, - XED_IFORM_PMULHRSW_XMMdq_XMMdq=1380, - XED_IFORM_PMULHRW_MMXq_MEMq=1381, - XED_IFORM_PMULHRW_MMXq_MMXq=1382, - XED_IFORM_PMULHUW_MMXq_MEMq=1383, - XED_IFORM_PMULHUW_MMXq_MMXq=1384, - XED_IFORM_PMULHUW_XMMdq_MEMdq=1385, - XED_IFORM_PMULHUW_XMMdq_XMMdq=1386, - XED_IFORM_PMULHW_MMXq_MEMq=1387, - XED_IFORM_PMULHW_MMXq_MMXq=1388, - XED_IFORM_PMULHW_XMMdq_MEMdq=1389, - XED_IFORM_PMULHW_XMMdq_XMMdq=1390, - XED_IFORM_PMULLD_XMMdq_MEMdq=1391, - XED_IFORM_PMULLD_XMMdq_XMMdq=1392, - XED_IFORM_PMULLW_MMXq_MEMq=1393, - XED_IFORM_PMULLW_MMXq_MMXq=1394, - XED_IFORM_PMULLW_XMMdq_MEMdq=1395, - XED_IFORM_PMULLW_XMMdq_XMMdq=1396, - XED_IFORM_PMULUDQ_MMXq_MEMq=1397, - XED_IFORM_PMULUDQ_MMXq_MMXq=1398, - XED_IFORM_PMULUDQ_XMMdq_MEMdq=1399, - XED_IFORM_PMULUDQ_XMMdq_XMMdq=1400, - XED_IFORM_POP_DS=1401, - XED_IFORM_POP_ES=1402, - XED_IFORM_POP_FS=1403, - XED_IFORM_POP_GPRv_58=1404, - XED_IFORM_POP_GPRv_8F=1405, - XED_IFORM_POP_GS=1406, - XED_IFORM_POP_MEMv=1407, - XED_IFORM_POP_SS=1408, - XED_IFORM_POPA=1409, - XED_IFORM_POPAD=1410, - XED_IFORM_POPCNT_GPRv_GPRv=1411, - XED_IFORM_POPCNT_GPRv_MEMv=1412, - XED_IFORM_POPF=1413, - XED_IFORM_POPFD=1414, - XED_IFORM_POPFQ=1415, - XED_IFORM_POR_MMXq_MEMq=1416, - XED_IFORM_POR_MMXq_MMXq=1417, - XED_IFORM_POR_XMMdq_MEMdq=1418, - XED_IFORM_POR_XMMdq_XMMdq=1419, - XED_IFORM_PREFETCHNTA_MEMmprefetch=1420, - XED_IFORM_PREFETCHT0_MEMmprefetch=1421, - XED_IFORM_PREFETCHT1_MEMmprefetch=1422, - XED_IFORM_PREFETCHT2_MEMmprefetch=1423, - XED_IFORM_PREFETCHW_0F0Dr1=1424, - XED_IFORM_PREFETCHW_0F0Dr3=1425, - XED_IFORM_PREFETCHWT1_MEMu8=1426, - XED_IFORM_PREFETCH_EXCLUSIVE_MEMmprefetch=1427, - XED_IFORM_PREFETCH_RESERVED_0F0Dr4=1428, - XED_IFORM_PREFETCH_RESERVED_0F0Dr5=1429, - XED_IFORM_PREFETCH_RESERVED_0F0Dr6=1430, - XED_IFORM_PREFETCH_RESERVED_0F0Dr7=1431, - XED_IFORM_PSADBW_MMXq_MEMq=1432, - XED_IFORM_PSADBW_MMXq_MMXq=1433, - XED_IFORM_PSADBW_XMMdq_MEMdq=1434, - XED_IFORM_PSADBW_XMMdq_XMMdq=1435, - XED_IFORM_PSHUFB_MMXq_MEMq=1436, - XED_IFORM_PSHUFB_MMXq_MMXq=1437, - XED_IFORM_PSHUFB_XMMdq_MEMdq=1438, - XED_IFORM_PSHUFB_XMMdq_XMMdq=1439, - XED_IFORM_PSHUFD_XMMdq_MEMdq_IMMb=1440, - XED_IFORM_PSHUFD_XMMdq_XMMdq_IMMb=1441, - XED_IFORM_PSHUFHW_XMMdq_MEMdq_IMMb=1442, - XED_IFORM_PSHUFHW_XMMdq_XMMdq_IMMb=1443, - XED_IFORM_PSHUFLW_XMMdq_MEMdq_IMMb=1444, - XED_IFORM_PSHUFLW_XMMdq_XMMdq_IMMb=1445, - XED_IFORM_PSHUFW_MMXq_MEMq_IMMb=1446, - XED_IFORM_PSHUFW_MMXq_MMXq_IMMb=1447, - XED_IFORM_PSIGNB_MMXq_MEMq=1448, - XED_IFORM_PSIGNB_MMXq_MMXq=1449, - XED_IFORM_PSIGNB_XMMdq_MEMdq=1450, - XED_IFORM_PSIGNB_XMMdq_XMMdq=1451, - XED_IFORM_PSIGND_MMXq_MEMq=1452, - XED_IFORM_PSIGND_MMXq_MMXq=1453, - XED_IFORM_PSIGND_XMMdq_MEMdq=1454, - XED_IFORM_PSIGND_XMMdq_XMMdq=1455, - XED_IFORM_PSIGNW_MMXq_MEMq=1456, - XED_IFORM_PSIGNW_MMXq_MMXq=1457, - XED_IFORM_PSIGNW_XMMdq_MEMdq=1458, - XED_IFORM_PSIGNW_XMMdq_XMMdq=1459, - XED_IFORM_PSLLD_MMXq_IMMb=1460, - XED_IFORM_PSLLD_MMXq_MEMq=1461, - XED_IFORM_PSLLD_MMXq_MMXq=1462, - XED_IFORM_PSLLD_XMMdq_IMMb=1463, - XED_IFORM_PSLLD_XMMdq_MEMdq=1464, - XED_IFORM_PSLLD_XMMdq_XMMdq=1465, - XED_IFORM_PSLLDQ_XMMdq_IMMb=1466, - XED_IFORM_PSLLQ_MMXq_IMMb=1467, - XED_IFORM_PSLLQ_MMXq_MEMq=1468, - XED_IFORM_PSLLQ_MMXq_MMXq=1469, - XED_IFORM_PSLLQ_XMMdq_IMMb=1470, - XED_IFORM_PSLLQ_XMMdq_MEMdq=1471, - XED_IFORM_PSLLQ_XMMdq_XMMdq=1472, - XED_IFORM_PSLLW_MMXq_IMMb=1473, - XED_IFORM_PSLLW_MMXq_MEMq=1474, - XED_IFORM_PSLLW_MMXq_MMXq=1475, - XED_IFORM_PSLLW_XMMdq_IMMb=1476, - XED_IFORM_PSLLW_XMMdq_MEMdq=1477, - XED_IFORM_PSLLW_XMMdq_XMMdq=1478, - XED_IFORM_PSMASH_RAX=1479, - XED_IFORM_PSRAD_MMXq_IMMb=1480, - XED_IFORM_PSRAD_MMXq_MEMq=1481, - XED_IFORM_PSRAD_MMXq_MMXq=1482, - XED_IFORM_PSRAD_XMMdq_IMMb=1483, - XED_IFORM_PSRAD_XMMdq_MEMdq=1484, - XED_IFORM_PSRAD_XMMdq_XMMdq=1485, - XED_IFORM_PSRAW_MMXq_IMMb=1486, - XED_IFORM_PSRAW_MMXq_MEMq=1487, - XED_IFORM_PSRAW_MMXq_MMXq=1488, - XED_IFORM_PSRAW_XMMdq_IMMb=1489, - XED_IFORM_PSRAW_XMMdq_MEMdq=1490, - XED_IFORM_PSRAW_XMMdq_XMMdq=1491, - XED_IFORM_PSRLD_MMXq_IMMb=1492, - XED_IFORM_PSRLD_MMXq_MEMq=1493, - XED_IFORM_PSRLD_MMXq_MMXq=1494, - XED_IFORM_PSRLD_XMMdq_IMMb=1495, - XED_IFORM_PSRLD_XMMdq_MEMdq=1496, - XED_IFORM_PSRLD_XMMdq_XMMdq=1497, - XED_IFORM_PSRLDQ_XMMdq_IMMb=1498, - XED_IFORM_PSRLQ_MMXq_IMMb=1499, - XED_IFORM_PSRLQ_MMXq_MEMq=1500, - XED_IFORM_PSRLQ_MMXq_MMXq=1501, - XED_IFORM_PSRLQ_XMMdq_IMMb=1502, - XED_IFORM_PSRLQ_XMMdq_MEMdq=1503, - XED_IFORM_PSRLQ_XMMdq_XMMdq=1504, - XED_IFORM_PSRLW_MMXq_IMMb=1505, - XED_IFORM_PSRLW_MMXq_MEMq=1506, - XED_IFORM_PSRLW_MMXq_MMXq=1507, - XED_IFORM_PSRLW_XMMdq_IMMb=1508, - XED_IFORM_PSRLW_XMMdq_MEMdq=1509, - XED_IFORM_PSRLW_XMMdq_XMMdq=1510, - XED_IFORM_PSUBB_MMXq_MEMq=1511, - XED_IFORM_PSUBB_MMXq_MMXq=1512, - XED_IFORM_PSUBB_XMMdq_MEMdq=1513, - XED_IFORM_PSUBB_XMMdq_XMMdq=1514, - XED_IFORM_PSUBD_MMXq_MEMq=1515, - XED_IFORM_PSUBD_MMXq_MMXq=1516, - XED_IFORM_PSUBD_XMMdq_MEMdq=1517, - XED_IFORM_PSUBD_XMMdq_XMMdq=1518, - XED_IFORM_PSUBQ_MMXq_MEMq=1519, - XED_IFORM_PSUBQ_MMXq_MMXq=1520, - XED_IFORM_PSUBQ_XMMdq_MEMdq=1521, - XED_IFORM_PSUBQ_XMMdq_XMMdq=1522, - XED_IFORM_PSUBSB_MMXq_MEMq=1523, - XED_IFORM_PSUBSB_MMXq_MMXq=1524, - XED_IFORM_PSUBSB_XMMdq_MEMdq=1525, - XED_IFORM_PSUBSB_XMMdq_XMMdq=1526, - XED_IFORM_PSUBSW_MMXq_MEMq=1527, - XED_IFORM_PSUBSW_MMXq_MMXq=1528, - XED_IFORM_PSUBSW_XMMdq_MEMdq=1529, - XED_IFORM_PSUBSW_XMMdq_XMMdq=1530, - XED_IFORM_PSUBUSB_MMXq_MEMq=1531, - XED_IFORM_PSUBUSB_MMXq_MMXq=1532, - XED_IFORM_PSUBUSB_XMMdq_MEMdq=1533, - XED_IFORM_PSUBUSB_XMMdq_XMMdq=1534, - XED_IFORM_PSUBUSW_MMXq_MEMq=1535, - XED_IFORM_PSUBUSW_MMXq_MMXq=1536, - XED_IFORM_PSUBUSW_XMMdq_MEMdq=1537, - XED_IFORM_PSUBUSW_XMMdq_XMMdq=1538, - XED_IFORM_PSUBW_MMXq_MEMq=1539, - XED_IFORM_PSUBW_MMXq_MMXq=1540, - XED_IFORM_PSUBW_XMMdq_MEMdq=1541, - XED_IFORM_PSUBW_XMMdq_XMMdq=1542, - XED_IFORM_PSWAPD_MMXq_MEMq=1543, - XED_IFORM_PSWAPD_MMXq_MMXq=1544, - XED_IFORM_PTEST_XMMdq_MEMdq=1545, - XED_IFORM_PTEST_XMMdq_XMMdq=1546, - XED_IFORM_PTWRITE_GPRy=1547, - XED_IFORM_PTWRITE_MEMy=1548, - XED_IFORM_PUNPCKHBW_MMXq_MEMq=1549, - XED_IFORM_PUNPCKHBW_MMXq_MMXd=1550, - XED_IFORM_PUNPCKHBW_XMMdq_MEMdq=1551, - XED_IFORM_PUNPCKHBW_XMMdq_XMMq=1552, - XED_IFORM_PUNPCKHDQ_MMXq_MEMq=1553, - XED_IFORM_PUNPCKHDQ_MMXq_MMXd=1554, - XED_IFORM_PUNPCKHDQ_XMMdq_MEMdq=1555, - XED_IFORM_PUNPCKHDQ_XMMdq_XMMq=1556, - XED_IFORM_PUNPCKHQDQ_XMMdq_MEMdq=1557, - XED_IFORM_PUNPCKHQDQ_XMMdq_XMMq=1558, - XED_IFORM_PUNPCKHWD_MMXq_MEMq=1559, - XED_IFORM_PUNPCKHWD_MMXq_MMXd=1560, - XED_IFORM_PUNPCKHWD_XMMdq_MEMdq=1561, - XED_IFORM_PUNPCKHWD_XMMdq_XMMq=1562, - XED_IFORM_PUNPCKLBW_MMXq_MEMd=1563, - XED_IFORM_PUNPCKLBW_MMXq_MMXd=1564, - XED_IFORM_PUNPCKLBW_XMMdq_MEMdq=1565, - XED_IFORM_PUNPCKLBW_XMMdq_XMMq=1566, - XED_IFORM_PUNPCKLDQ_MMXq_MEMd=1567, - XED_IFORM_PUNPCKLDQ_MMXq_MMXd=1568, - XED_IFORM_PUNPCKLDQ_XMMdq_MEMdq=1569, - XED_IFORM_PUNPCKLDQ_XMMdq_XMMq=1570, - XED_IFORM_PUNPCKLQDQ_XMMdq_MEMdq=1571, - XED_IFORM_PUNPCKLQDQ_XMMdq_XMMq=1572, - XED_IFORM_PUNPCKLWD_MMXq_MEMd=1573, - XED_IFORM_PUNPCKLWD_MMXq_MMXd=1574, - XED_IFORM_PUNPCKLWD_XMMdq_MEMdq=1575, - XED_IFORM_PUNPCKLWD_XMMdq_XMMq=1576, - XED_IFORM_PUSH_CS=1577, - XED_IFORM_PUSH_DS=1578, - XED_IFORM_PUSH_ES=1579, - XED_IFORM_PUSH_FS=1580, - XED_IFORM_PUSH_GPRv_50=1581, - XED_IFORM_PUSH_GPRv_FFr6=1582, - XED_IFORM_PUSH_GS=1583, - XED_IFORM_PUSH_IMMb=1584, - XED_IFORM_PUSH_IMMz=1585, - XED_IFORM_PUSH_MEMv=1586, - XED_IFORM_PUSH_SS=1587, - XED_IFORM_PUSHA=1588, - XED_IFORM_PUSHAD=1589, - XED_IFORM_PUSHF=1590, - XED_IFORM_PUSHFD=1591, - XED_IFORM_PUSHFQ=1592, - XED_IFORM_PVALIDATE_RAX_ECX_EDX=1593, - XED_IFORM_PXOR_MMXq_MEMq=1594, - XED_IFORM_PXOR_MMXq_MMXq=1595, - XED_IFORM_PXOR_XMMdq_MEMdq=1596, - XED_IFORM_PXOR_XMMdq_XMMdq=1597, - XED_IFORM_RCL_GPR8_CL=1598, - XED_IFORM_RCL_GPR8_IMMb=1599, - XED_IFORM_RCL_GPR8_ONE=1600, - XED_IFORM_RCL_GPRv_CL=1601, - XED_IFORM_RCL_GPRv_IMMb=1602, - XED_IFORM_RCL_GPRv_ONE=1603, - XED_IFORM_RCL_MEMb_CL=1604, - XED_IFORM_RCL_MEMb_IMMb=1605, - XED_IFORM_RCL_MEMb_ONE=1606, - XED_IFORM_RCL_MEMv_CL=1607, - XED_IFORM_RCL_MEMv_IMMb=1608, - XED_IFORM_RCL_MEMv_ONE=1609, - XED_IFORM_RCPPS_XMMps_MEMps=1610, - XED_IFORM_RCPPS_XMMps_XMMps=1611, - XED_IFORM_RCPSS_XMMss_MEMss=1612, - XED_IFORM_RCPSS_XMMss_XMMss=1613, - XED_IFORM_RCR_GPR8_CL=1614, - XED_IFORM_RCR_GPR8_IMMb=1615, - XED_IFORM_RCR_GPR8_ONE=1616, - XED_IFORM_RCR_GPRv_CL=1617, - XED_IFORM_RCR_GPRv_IMMb=1618, - XED_IFORM_RCR_GPRv_ONE=1619, - XED_IFORM_RCR_MEMb_CL=1620, - XED_IFORM_RCR_MEMb_IMMb=1621, - XED_IFORM_RCR_MEMb_ONE=1622, - XED_IFORM_RCR_MEMv_CL=1623, - XED_IFORM_RCR_MEMv_IMMb=1624, - XED_IFORM_RCR_MEMv_ONE=1625, - XED_IFORM_RDFSBASE_GPRy=1626, - XED_IFORM_RDGSBASE_GPRy=1627, - XED_IFORM_RDMSR=1628, - XED_IFORM_RDPID_GPR32u32=1629, - XED_IFORM_RDPID_GPR64u64=1630, - XED_IFORM_RDPKRU=1631, - XED_IFORM_RDPMC=1632, - XED_IFORM_RDPRU=1633, - XED_IFORM_RDRAND_GPRv=1634, - XED_IFORM_RDSEED_GPRv=1635, - XED_IFORM_RDSSPD_GPR32u32=1636, - XED_IFORM_RDSSPQ_GPR64u64=1637, - XED_IFORM_RDTSC=1638, - XED_IFORM_RDTSCP=1639, - XED_IFORM_REPE_CMPSB=1640, - XED_IFORM_REPE_CMPSD=1641, - XED_IFORM_REPE_CMPSQ=1642, - XED_IFORM_REPE_CMPSW=1643, - XED_IFORM_REPE_SCASB=1644, - XED_IFORM_REPE_SCASD=1645, - XED_IFORM_REPE_SCASQ=1646, - XED_IFORM_REPE_SCASW=1647, - XED_IFORM_REPNE_CMPSB=1648, - XED_IFORM_REPNE_CMPSD=1649, - XED_IFORM_REPNE_CMPSQ=1650, - XED_IFORM_REPNE_CMPSW=1651, - XED_IFORM_REPNE_SCASB=1652, - XED_IFORM_REPNE_SCASD=1653, - XED_IFORM_REPNE_SCASQ=1654, - XED_IFORM_REPNE_SCASW=1655, - XED_IFORM_REP_INSB=1656, - XED_IFORM_REP_INSD=1657, - XED_IFORM_REP_INSW=1658, - XED_IFORM_REP_LODSB=1659, - XED_IFORM_REP_LODSD=1660, - XED_IFORM_REP_LODSQ=1661, - XED_IFORM_REP_LODSW=1662, - XED_IFORM_REP_MONTMUL=1663, - XED_IFORM_REP_MOVSB=1664, - XED_IFORM_REP_MOVSD=1665, - XED_IFORM_REP_MOVSQ=1666, - XED_IFORM_REP_MOVSW=1667, - XED_IFORM_REP_OUTSB=1668, - XED_IFORM_REP_OUTSD=1669, - XED_IFORM_REP_OUTSW=1670, - XED_IFORM_REP_STOSB=1671, - XED_IFORM_REP_STOSD=1672, - XED_IFORM_REP_STOSQ=1673, - XED_IFORM_REP_STOSW=1674, - XED_IFORM_REP_XCRYPTCBC=1675, - XED_IFORM_REP_XCRYPTCFB=1676, - XED_IFORM_REP_XCRYPTCTR=1677, - XED_IFORM_REP_XCRYPTECB=1678, - XED_IFORM_REP_XCRYPTOFB=1679, - XED_IFORM_REP_XSHA1=1680, - XED_IFORM_REP_XSHA256=1681, - XED_IFORM_REP_XSTORE=1682, - XED_IFORM_RET_FAR=1683, - XED_IFORM_RET_FAR_IMMw=1684, - XED_IFORM_RET_NEAR=1685, - XED_IFORM_RET_NEAR_IMMw=1686, - XED_IFORM_RMPADJUST_RAX_RCX_RDX=1687, - XED_IFORM_RMPUPDATE_RAX_RCX=1688, - XED_IFORM_ROL_GPR8_CL=1689, - XED_IFORM_ROL_GPR8_IMMb=1690, - XED_IFORM_ROL_GPR8_ONE=1691, - XED_IFORM_ROL_GPRv_CL=1692, - XED_IFORM_ROL_GPRv_IMMb=1693, - XED_IFORM_ROL_GPRv_ONE=1694, - XED_IFORM_ROL_MEMb_CL=1695, - XED_IFORM_ROL_MEMb_IMMb=1696, - XED_IFORM_ROL_MEMb_ONE=1697, - XED_IFORM_ROL_MEMv_CL=1698, - XED_IFORM_ROL_MEMv_IMMb=1699, - XED_IFORM_ROL_MEMv_ONE=1700, - XED_IFORM_ROR_GPR8_CL=1701, - XED_IFORM_ROR_GPR8_IMMb=1702, - XED_IFORM_ROR_GPR8_ONE=1703, - XED_IFORM_ROR_GPRv_CL=1704, - XED_IFORM_ROR_GPRv_IMMb=1705, - XED_IFORM_ROR_GPRv_ONE=1706, - XED_IFORM_ROR_MEMb_CL=1707, - XED_IFORM_ROR_MEMb_IMMb=1708, - XED_IFORM_ROR_MEMb_ONE=1709, - XED_IFORM_ROR_MEMv_CL=1710, - XED_IFORM_ROR_MEMv_IMMb=1711, - XED_IFORM_ROR_MEMv_ONE=1712, - XED_IFORM_RORX_VGPR32d_MEMd_IMMb=1713, - XED_IFORM_RORX_VGPR32d_VGPR32d_IMMb=1714, - XED_IFORM_RORX_VGPR64q_MEMq_IMMb=1715, - XED_IFORM_RORX_VGPR64q_VGPR64q_IMMb=1716, - XED_IFORM_ROUNDPD_XMMpd_MEMpd_IMMb=1717, - XED_IFORM_ROUNDPD_XMMpd_XMMpd_IMMb=1718, - XED_IFORM_ROUNDPS_XMMps_MEMps_IMMb=1719, - XED_IFORM_ROUNDPS_XMMps_XMMps_IMMb=1720, - XED_IFORM_ROUNDSD_XMMq_MEMq_IMMb=1721, - XED_IFORM_ROUNDSD_XMMq_XMMq_IMMb=1722, - XED_IFORM_ROUNDSS_XMMd_MEMd_IMMb=1723, - XED_IFORM_ROUNDSS_XMMd_XMMd_IMMb=1724, - XED_IFORM_RSM=1725, - XED_IFORM_RSQRTPS_XMMps_MEMps=1726, - XED_IFORM_RSQRTPS_XMMps_XMMps=1727, - XED_IFORM_RSQRTSS_XMMss_MEMss=1728, - XED_IFORM_RSQRTSS_XMMss_XMMss=1729, - XED_IFORM_RSTORSSP_MEMu64=1730, - XED_IFORM_SAHF=1731, - XED_IFORM_SALC=1732, - XED_IFORM_SAR_GPR8_CL=1733, - XED_IFORM_SAR_GPR8_IMMb=1734, - XED_IFORM_SAR_GPR8_ONE=1735, - XED_IFORM_SAR_GPRv_CL=1736, - XED_IFORM_SAR_GPRv_IMMb=1737, - XED_IFORM_SAR_GPRv_ONE=1738, - XED_IFORM_SAR_MEMb_CL=1739, - XED_IFORM_SAR_MEMb_IMMb=1740, - XED_IFORM_SAR_MEMb_ONE=1741, - XED_IFORM_SAR_MEMv_CL=1742, - XED_IFORM_SAR_MEMv_IMMb=1743, - XED_IFORM_SAR_MEMv_ONE=1744, - XED_IFORM_SARX_VGPR32d_MEMd_VGPR32d=1745, - XED_IFORM_SARX_VGPR32d_VGPR32d_VGPR32d=1746, - XED_IFORM_SARX_VGPR64q_MEMq_VGPR64q=1747, - XED_IFORM_SARX_VGPR64q_VGPR64q_VGPR64q=1748, - XED_IFORM_SAVEPREVSSP=1749, - XED_IFORM_SBB_AL_IMMb=1750, - XED_IFORM_SBB_GPR8_GPR8_18=1751, - XED_IFORM_SBB_GPR8_GPR8_1A=1752, - XED_IFORM_SBB_GPR8_IMMb_80r3=1753, - XED_IFORM_SBB_GPR8_IMMb_82r3=1754, - XED_IFORM_SBB_GPR8_MEMb=1755, - XED_IFORM_SBB_GPRv_GPRv_19=1756, - XED_IFORM_SBB_GPRv_GPRv_1B=1757, - XED_IFORM_SBB_GPRv_IMMb=1758, - XED_IFORM_SBB_GPRv_IMMz=1759, - XED_IFORM_SBB_GPRv_MEMv=1760, - XED_IFORM_SBB_MEMb_GPR8=1761, - XED_IFORM_SBB_MEMb_IMMb_80r3=1762, - XED_IFORM_SBB_MEMb_IMMb_82r3=1763, - XED_IFORM_SBB_MEMv_GPRv=1764, - XED_IFORM_SBB_MEMv_IMMb=1765, - XED_IFORM_SBB_MEMv_IMMz=1766, - XED_IFORM_SBB_OrAX_IMMz=1767, - XED_IFORM_SBB_LOCK_MEMb_GPR8=1768, - XED_IFORM_SBB_LOCK_MEMb_IMMb_80r3=1769, - XED_IFORM_SBB_LOCK_MEMb_IMMb_82r3=1770, - XED_IFORM_SBB_LOCK_MEMv_GPRv=1771, - XED_IFORM_SBB_LOCK_MEMv_IMMb=1772, - XED_IFORM_SBB_LOCK_MEMv_IMMz=1773, - XED_IFORM_SCASB=1774, - XED_IFORM_SCASD=1775, - XED_IFORM_SCASQ=1776, - XED_IFORM_SCASW=1777, - XED_IFORM_SEAMCALL=1778, - XED_IFORM_SEAMOPS=1779, - XED_IFORM_SEAMRET=1780, - XED_IFORM_SENDUIPI_GPR32u32=1781, - XED_IFORM_SERIALIZE=1782, - XED_IFORM_SETB_GPR8=1783, - XED_IFORM_SETB_MEMb=1784, - XED_IFORM_SETBE_GPR8=1785, - XED_IFORM_SETBE_MEMb=1786, - XED_IFORM_SETL_GPR8=1787, - XED_IFORM_SETL_MEMb=1788, - XED_IFORM_SETLE_GPR8=1789, - XED_IFORM_SETLE_MEMb=1790, - XED_IFORM_SETNB_GPR8=1791, - XED_IFORM_SETNB_MEMb=1792, - XED_IFORM_SETNBE_GPR8=1793, - XED_IFORM_SETNBE_MEMb=1794, - XED_IFORM_SETNL_GPR8=1795, - XED_IFORM_SETNL_MEMb=1796, - XED_IFORM_SETNLE_GPR8=1797, - XED_IFORM_SETNLE_MEMb=1798, - XED_IFORM_SETNO_GPR8=1799, - XED_IFORM_SETNO_MEMb=1800, - XED_IFORM_SETNP_GPR8=1801, - XED_IFORM_SETNP_MEMb=1802, - XED_IFORM_SETNS_GPR8=1803, - XED_IFORM_SETNS_MEMb=1804, - XED_IFORM_SETNZ_GPR8=1805, - XED_IFORM_SETNZ_MEMb=1806, - XED_IFORM_SETO_GPR8=1807, - XED_IFORM_SETO_MEMb=1808, - XED_IFORM_SETP_GPR8=1809, - XED_IFORM_SETP_MEMb=1810, - XED_IFORM_SETS_GPR8=1811, - XED_IFORM_SETS_MEMb=1812, - XED_IFORM_SETSSBSY=1813, - XED_IFORM_SETZ_GPR8=1814, - XED_IFORM_SETZ_MEMb=1815, - XED_IFORM_SFENCE=1816, - XED_IFORM_SGDT_MEMs=1817, - XED_IFORM_SGDT_MEMs64=1818, - XED_IFORM_SHA1MSG1_XMMi32_MEMi32_SHA=1819, - XED_IFORM_SHA1MSG1_XMMi32_XMMi32_SHA=1820, - XED_IFORM_SHA1MSG2_XMMi32_MEMi32_SHA=1821, - XED_IFORM_SHA1MSG2_XMMi32_XMMi32_SHA=1822, - XED_IFORM_SHA1NEXTE_XMMi32_MEMi32_SHA=1823, - XED_IFORM_SHA1NEXTE_XMMi32_XMMi32_SHA=1824, - XED_IFORM_SHA1RNDS4_XMMi32_MEMi32_IMM8_SHA=1825, - XED_IFORM_SHA1RNDS4_XMMi32_XMMi32_IMM8_SHA=1826, - XED_IFORM_SHA256MSG1_XMMi32_MEMi32_SHA=1827, - XED_IFORM_SHA256MSG1_XMMi32_XMMi32_SHA=1828, - XED_IFORM_SHA256MSG2_XMMi32_MEMi32_SHA=1829, - XED_IFORM_SHA256MSG2_XMMi32_XMMi32_SHA=1830, - XED_IFORM_SHA256RNDS2_XMMi32_MEMi32_SHA=1831, - XED_IFORM_SHA256RNDS2_XMMi32_XMMi32_SHA=1832, - XED_IFORM_SHL_GPR8_CL_D2r4=1833, - XED_IFORM_SHL_GPR8_CL_D2r6=1834, - XED_IFORM_SHL_GPR8_IMMb_C0r4=1835, - XED_IFORM_SHL_GPR8_IMMb_C0r6=1836, - XED_IFORM_SHL_GPR8_ONE_D0r4=1837, - XED_IFORM_SHL_GPR8_ONE_D0r6=1838, - XED_IFORM_SHL_GPRv_CL_D3r4=1839, - XED_IFORM_SHL_GPRv_CL_D3r6=1840, - XED_IFORM_SHL_GPRv_IMMb_C1r4=1841, - XED_IFORM_SHL_GPRv_IMMb_C1r6=1842, - XED_IFORM_SHL_GPRv_ONE_D1r4=1843, - XED_IFORM_SHL_GPRv_ONE_D1r6=1844, - XED_IFORM_SHL_MEMb_CL_D2r4=1845, - XED_IFORM_SHL_MEMb_CL_D2r6=1846, - XED_IFORM_SHL_MEMb_IMMb_C0r4=1847, - XED_IFORM_SHL_MEMb_IMMb_C0r6=1848, - XED_IFORM_SHL_MEMb_ONE_D0r4=1849, - XED_IFORM_SHL_MEMb_ONE_D0r6=1850, - XED_IFORM_SHL_MEMv_CL_D3r4=1851, - XED_IFORM_SHL_MEMv_CL_D3r6=1852, - XED_IFORM_SHL_MEMv_IMMb_C1r4=1853, - XED_IFORM_SHL_MEMv_IMMb_C1r6=1854, - XED_IFORM_SHL_MEMv_ONE_D1r4=1855, - XED_IFORM_SHL_MEMv_ONE_D1r6=1856, - XED_IFORM_SHLD_GPRv_GPRv_CL=1857, - XED_IFORM_SHLD_GPRv_GPRv_IMMb=1858, - XED_IFORM_SHLD_MEMv_GPRv_CL=1859, - XED_IFORM_SHLD_MEMv_GPRv_IMMb=1860, - XED_IFORM_SHLX_VGPR32d_MEMd_VGPR32d=1861, - XED_IFORM_SHLX_VGPR32d_VGPR32d_VGPR32d=1862, - XED_IFORM_SHLX_VGPR64q_MEMq_VGPR64q=1863, - XED_IFORM_SHLX_VGPR64q_VGPR64q_VGPR64q=1864, - XED_IFORM_SHR_GPR8_CL=1865, - XED_IFORM_SHR_GPR8_IMMb=1866, - XED_IFORM_SHR_GPR8_ONE=1867, - XED_IFORM_SHR_GPRv_CL=1868, - XED_IFORM_SHR_GPRv_IMMb=1869, - XED_IFORM_SHR_GPRv_ONE=1870, - XED_IFORM_SHR_MEMb_CL=1871, - XED_IFORM_SHR_MEMb_IMMb=1872, - XED_IFORM_SHR_MEMb_ONE=1873, - XED_IFORM_SHR_MEMv_CL=1874, - XED_IFORM_SHR_MEMv_IMMb=1875, - XED_IFORM_SHR_MEMv_ONE=1876, - XED_IFORM_SHRD_GPRv_GPRv_CL=1877, - XED_IFORM_SHRD_GPRv_GPRv_IMMb=1878, - XED_IFORM_SHRD_MEMv_GPRv_CL=1879, - XED_IFORM_SHRD_MEMv_GPRv_IMMb=1880, - XED_IFORM_SHRX_VGPR32d_MEMd_VGPR32d=1881, - XED_IFORM_SHRX_VGPR32d_VGPR32d_VGPR32d=1882, - XED_IFORM_SHRX_VGPR64q_MEMq_VGPR64q=1883, - XED_IFORM_SHRX_VGPR64q_VGPR64q_VGPR64q=1884, - XED_IFORM_SHUFPD_XMMpd_MEMpd_IMMb=1885, - XED_IFORM_SHUFPD_XMMpd_XMMpd_IMMb=1886, - XED_IFORM_SHUFPS_XMMps_MEMps_IMMb=1887, - XED_IFORM_SHUFPS_XMMps_XMMps_IMMb=1888, - XED_IFORM_SIDT_MEMs=1889, - XED_IFORM_SIDT_MEMs64=1890, - XED_IFORM_SKINIT_EAX=1891, - XED_IFORM_SLDT_GPRv=1892, - XED_IFORM_SLDT_MEMw=1893, - XED_IFORM_SLWPCB_VGPRyy=1894, - XED_IFORM_SMSW_GPRv=1895, - XED_IFORM_SMSW_MEMw=1896, - XED_IFORM_SQRTPD_XMMpd_MEMpd=1897, - XED_IFORM_SQRTPD_XMMpd_XMMpd=1898, - XED_IFORM_SQRTPS_XMMps_MEMps=1899, - XED_IFORM_SQRTPS_XMMps_XMMps=1900, - XED_IFORM_SQRTSD_XMMsd_MEMsd=1901, - XED_IFORM_SQRTSD_XMMsd_XMMsd=1902, - XED_IFORM_SQRTSS_XMMss_MEMss=1903, - XED_IFORM_SQRTSS_XMMss_XMMss=1904, - XED_IFORM_STAC=1905, - XED_IFORM_STC=1906, - XED_IFORM_STD=1907, - XED_IFORM_STGI=1908, - XED_IFORM_STI=1909, - XED_IFORM_STMXCSR_MEMd=1910, - XED_IFORM_STOSB=1911, - XED_IFORM_STOSD=1912, - XED_IFORM_STOSQ=1913, - XED_IFORM_STOSW=1914, - XED_IFORM_STR_GPRv=1915, - XED_IFORM_STR_MEMw=1916, - XED_IFORM_STTILECFG_MEM=1917, - XED_IFORM_STUI=1918, - XED_IFORM_SUB_AL_IMMb=1919, - XED_IFORM_SUB_GPR8_GPR8_28=1920, - XED_IFORM_SUB_GPR8_GPR8_2A=1921, - XED_IFORM_SUB_GPR8_IMMb_80r5=1922, - XED_IFORM_SUB_GPR8_IMMb_82r5=1923, - XED_IFORM_SUB_GPR8_MEMb=1924, - XED_IFORM_SUB_GPRv_GPRv_29=1925, - XED_IFORM_SUB_GPRv_GPRv_2B=1926, - XED_IFORM_SUB_GPRv_IMMb=1927, - XED_IFORM_SUB_GPRv_IMMz=1928, - XED_IFORM_SUB_GPRv_MEMv=1929, - XED_IFORM_SUB_MEMb_GPR8=1930, - XED_IFORM_SUB_MEMb_IMMb_80r5=1931, - XED_IFORM_SUB_MEMb_IMMb_82r5=1932, - XED_IFORM_SUB_MEMv_GPRv=1933, - XED_IFORM_SUB_MEMv_IMMb=1934, - XED_IFORM_SUB_MEMv_IMMz=1935, - XED_IFORM_SUB_OrAX_IMMz=1936, - XED_IFORM_SUBPD_XMMpd_MEMpd=1937, - XED_IFORM_SUBPD_XMMpd_XMMpd=1938, - XED_IFORM_SUBPS_XMMps_MEMps=1939, - XED_IFORM_SUBPS_XMMps_XMMps=1940, - XED_IFORM_SUBSD_XMMsd_MEMsd=1941, - XED_IFORM_SUBSD_XMMsd_XMMsd=1942, - XED_IFORM_SUBSS_XMMss_MEMss=1943, - XED_IFORM_SUBSS_XMMss_XMMss=1944, - XED_IFORM_SUB_LOCK_MEMb_GPR8=1945, - XED_IFORM_SUB_LOCK_MEMb_IMMb_80r5=1946, - XED_IFORM_SUB_LOCK_MEMb_IMMb_82r5=1947, - XED_IFORM_SUB_LOCK_MEMv_GPRv=1948, - XED_IFORM_SUB_LOCK_MEMv_IMMb=1949, - XED_IFORM_SUB_LOCK_MEMv_IMMz=1950, - XED_IFORM_SWAPGS=1951, - XED_IFORM_SYSCALL=1952, - XED_IFORM_SYSCALL_AMD=1953, - XED_IFORM_SYSENTER=1954, - XED_IFORM_SYSEXIT=1955, - XED_IFORM_SYSRET=1956, - XED_IFORM_SYSRET64=1957, - XED_IFORM_SYSRET_AMD=1958, - XED_IFORM_T1MSKC_VGPR32d_MEMd=1959, - XED_IFORM_T1MSKC_VGPR32d_VGPR32d=1960, - XED_IFORM_T1MSKC_VGPRyy_MEMy=1961, - XED_IFORM_T1MSKC_VGPRyy_VGPRyy=1962, - XED_IFORM_TDCALL=1963, - XED_IFORM_TDPBF16PS_TMMf32_TMMu32_TMMu32=1964, - XED_IFORM_TDPBSSD_TMMi32_TMMu32_TMMu32=1965, - XED_IFORM_TDPBSUD_TMMi32_TMMu32_TMMu32=1966, - XED_IFORM_TDPBUSD_TMMi32_TMMu32_TMMu32=1967, - XED_IFORM_TDPBUUD_TMMu32_TMMu32_TMMu32=1968, - XED_IFORM_TEST_AL_IMMb=1969, - XED_IFORM_TEST_GPR8_GPR8=1970, - XED_IFORM_TEST_GPR8_IMMb_F6r0=1971, - XED_IFORM_TEST_GPR8_IMMb_F6r1=1972, - XED_IFORM_TEST_GPRv_GPRv=1973, - XED_IFORM_TEST_GPRv_IMMz_F7r0=1974, - XED_IFORM_TEST_GPRv_IMMz_F7r1=1975, - XED_IFORM_TEST_MEMb_GPR8=1976, - XED_IFORM_TEST_MEMb_IMMb_F6r0=1977, - XED_IFORM_TEST_MEMb_IMMb_F6r1=1978, - XED_IFORM_TEST_MEMv_GPRv=1979, - XED_IFORM_TEST_MEMv_IMMz_F7r0=1980, - XED_IFORM_TEST_MEMv_IMMz_F7r1=1981, - XED_IFORM_TEST_OrAX_IMMz=1982, - XED_IFORM_TESTUI=1983, - XED_IFORM_TILELOADD_TMMu32_MEMu32=1984, - XED_IFORM_TILELOADDT1_TMMu32_MEMu32=1985, - XED_IFORM_TILERELEASE=1986, - XED_IFORM_TILESTORED_MEMu32_TMMu32=1987, - XED_IFORM_TILEZERO_TMMu32=1988, - XED_IFORM_TLBSYNC=1989, - XED_IFORM_TPAUSE_GPR32u32=1990, - XED_IFORM_TZCNT_GPRv_GPRv=1991, - XED_IFORM_TZCNT_GPRv_MEMv=1992, - XED_IFORM_TZMSK_VGPR32d_MEMd=1993, - XED_IFORM_TZMSK_VGPR32d_VGPR32d=1994, - XED_IFORM_TZMSK_VGPRyy_MEMy=1995, - XED_IFORM_TZMSK_VGPRyy_VGPRyy=1996, - XED_IFORM_UCOMISD_XMMsd_MEMsd=1997, - XED_IFORM_UCOMISD_XMMsd_XMMsd=1998, - XED_IFORM_UCOMISS_XMMss_MEMss=1999, - XED_IFORM_UCOMISS_XMMss_XMMss=2000, - XED_IFORM_UD0=2001, - XED_IFORM_UD0_GPR32_GPR32=2002, - XED_IFORM_UD0_GPR32_MEMd=2003, - XED_IFORM_UD1_GPR32_GPR32=2004, - XED_IFORM_UD1_GPR32_MEMd=2005, - XED_IFORM_UD2=2006, - XED_IFORM_UIRET=2007, - XED_IFORM_UMONITOR_GPRa=2008, - XED_IFORM_UMWAIT_GPR32=2009, - XED_IFORM_UNPCKHPD_XMMpd_MEMdq=2010, - XED_IFORM_UNPCKHPD_XMMpd_XMMq=2011, - XED_IFORM_UNPCKHPS_XMMps_MEMdq=2012, - XED_IFORM_UNPCKHPS_XMMps_XMMdq=2013, - XED_IFORM_UNPCKLPD_XMMpd_MEMdq=2014, - XED_IFORM_UNPCKLPD_XMMpd_XMMq=2015, - XED_IFORM_UNPCKLPS_XMMps_MEMdq=2016, - XED_IFORM_UNPCKLPS_XMMps_XMMq=2017, - XED_IFORM_V4FMADDPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2018, - XED_IFORM_V4FMADDSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2019, - XED_IFORM_V4FNMADDPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2020, - XED_IFORM_V4FNMADDSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2021, - XED_IFORM_VADDPD_XMMdq_XMMdq_MEMdq=2022, - XED_IFORM_VADDPD_XMMdq_XMMdq_XMMdq=2023, - XED_IFORM_VADDPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2024, - XED_IFORM_VADDPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2025, - XED_IFORM_VADDPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2026, - XED_IFORM_VADDPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2027, - XED_IFORM_VADDPD_YMMqq_YMMqq_MEMqq=2028, - XED_IFORM_VADDPD_YMMqq_YMMqq_YMMqq=2029, - XED_IFORM_VADDPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2030, - XED_IFORM_VADDPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2031, - XED_IFORM_VADDPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=2032, - XED_IFORM_VADDPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=2033, - XED_IFORM_VADDPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=2034, - XED_IFORM_VADDPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=2035, - XED_IFORM_VADDPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=2036, - XED_IFORM_VADDPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=2037, - XED_IFORM_VADDPS_XMMdq_XMMdq_MEMdq=2038, - XED_IFORM_VADDPS_XMMdq_XMMdq_XMMdq=2039, - XED_IFORM_VADDPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2040, - XED_IFORM_VADDPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2041, - XED_IFORM_VADDPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2042, - XED_IFORM_VADDPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2043, - XED_IFORM_VADDPS_YMMqq_YMMqq_MEMqq=2044, - XED_IFORM_VADDPS_YMMqq_YMMqq_YMMqq=2045, - XED_IFORM_VADDPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2046, - XED_IFORM_VADDPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2047, - XED_IFORM_VADDSD_XMMdq_XMMdq_MEMq=2048, - XED_IFORM_VADDSD_XMMdq_XMMdq_XMMq=2049, - XED_IFORM_VADDSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2050, - XED_IFORM_VADDSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2051, - XED_IFORM_VADDSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=2052, - XED_IFORM_VADDSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=2053, - XED_IFORM_VADDSS_XMMdq_XMMdq_MEMd=2054, - XED_IFORM_VADDSS_XMMdq_XMMdq_XMMd=2055, - XED_IFORM_VADDSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2056, - XED_IFORM_VADDSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2057, - XED_IFORM_VADDSUBPD_XMMdq_XMMdq_MEMdq=2058, - XED_IFORM_VADDSUBPD_XMMdq_XMMdq_XMMdq=2059, - XED_IFORM_VADDSUBPD_YMMqq_YMMqq_MEMqq=2060, - XED_IFORM_VADDSUBPD_YMMqq_YMMqq_YMMqq=2061, - XED_IFORM_VADDSUBPS_XMMdq_XMMdq_MEMdq=2062, - XED_IFORM_VADDSUBPS_XMMdq_XMMdq_XMMdq=2063, - XED_IFORM_VADDSUBPS_YMMqq_YMMqq_MEMqq=2064, - XED_IFORM_VADDSUBPS_YMMqq_YMMqq_YMMqq=2065, - XED_IFORM_VAESDEC_XMMdq_XMMdq_MEMdq=2066, - XED_IFORM_VAESDEC_XMMdq_XMMdq_XMMdq=2067, - XED_IFORM_VAESDEC_XMMu128_XMMu128_MEMu128_AVX512=2068, - XED_IFORM_VAESDEC_XMMu128_XMMu128_XMMu128_AVX512=2069, - XED_IFORM_VAESDEC_YMMu128_YMMu128_MEMu128=2070, - XED_IFORM_VAESDEC_YMMu128_YMMu128_MEMu128_AVX512=2071, - XED_IFORM_VAESDEC_YMMu128_YMMu128_YMMu128=2072, - XED_IFORM_VAESDEC_YMMu128_YMMu128_YMMu128_AVX512=2073, - XED_IFORM_VAESDEC_ZMMu128_ZMMu128_MEMu128_AVX512=2074, - XED_IFORM_VAESDEC_ZMMu128_ZMMu128_ZMMu128_AVX512=2075, - XED_IFORM_VAESDECLAST_XMMdq_XMMdq_MEMdq=2076, - XED_IFORM_VAESDECLAST_XMMdq_XMMdq_XMMdq=2077, - XED_IFORM_VAESDECLAST_XMMu128_XMMu128_MEMu128_AVX512=2078, - XED_IFORM_VAESDECLAST_XMMu128_XMMu128_XMMu128_AVX512=2079, - XED_IFORM_VAESDECLAST_YMMu128_YMMu128_MEMu128=2080, - XED_IFORM_VAESDECLAST_YMMu128_YMMu128_MEMu128_AVX512=2081, - XED_IFORM_VAESDECLAST_YMMu128_YMMu128_YMMu128=2082, - XED_IFORM_VAESDECLAST_YMMu128_YMMu128_YMMu128_AVX512=2083, - XED_IFORM_VAESDECLAST_ZMMu128_ZMMu128_MEMu128_AVX512=2084, - XED_IFORM_VAESDECLAST_ZMMu128_ZMMu128_ZMMu128_AVX512=2085, - XED_IFORM_VAESENC_XMMdq_XMMdq_MEMdq=2086, - XED_IFORM_VAESENC_XMMdq_XMMdq_XMMdq=2087, - XED_IFORM_VAESENC_XMMu128_XMMu128_MEMu128_AVX512=2088, - XED_IFORM_VAESENC_XMMu128_XMMu128_XMMu128_AVX512=2089, - XED_IFORM_VAESENC_YMMu128_YMMu128_MEMu128=2090, - XED_IFORM_VAESENC_YMMu128_YMMu128_MEMu128_AVX512=2091, - XED_IFORM_VAESENC_YMMu128_YMMu128_YMMu128=2092, - XED_IFORM_VAESENC_YMMu128_YMMu128_YMMu128_AVX512=2093, - XED_IFORM_VAESENC_ZMMu128_ZMMu128_MEMu128_AVX512=2094, - XED_IFORM_VAESENC_ZMMu128_ZMMu128_ZMMu128_AVX512=2095, - XED_IFORM_VAESENCLAST_XMMdq_XMMdq_MEMdq=2096, - XED_IFORM_VAESENCLAST_XMMdq_XMMdq_XMMdq=2097, - XED_IFORM_VAESENCLAST_XMMu128_XMMu128_MEMu128_AVX512=2098, - XED_IFORM_VAESENCLAST_XMMu128_XMMu128_XMMu128_AVX512=2099, - XED_IFORM_VAESENCLAST_YMMu128_YMMu128_MEMu128=2100, - XED_IFORM_VAESENCLAST_YMMu128_YMMu128_MEMu128_AVX512=2101, - XED_IFORM_VAESENCLAST_YMMu128_YMMu128_YMMu128=2102, - XED_IFORM_VAESENCLAST_YMMu128_YMMu128_YMMu128_AVX512=2103, - XED_IFORM_VAESENCLAST_ZMMu128_ZMMu128_MEMu128_AVX512=2104, - XED_IFORM_VAESENCLAST_ZMMu128_ZMMu128_ZMMu128_AVX512=2105, - XED_IFORM_VAESIMC_XMMdq_MEMdq=2106, - XED_IFORM_VAESIMC_XMMdq_XMMdq=2107, - XED_IFORM_VAESKEYGENASSIST_XMMdq_MEMdq_IMMb=2108, - XED_IFORM_VAESKEYGENASSIST_XMMdq_XMMdq_IMMb=2109, - XED_IFORM_VALIGND_XMMu32_MASKmskw_XMMu32_MEMu32_IMM8_AVX512=2110, - XED_IFORM_VALIGND_XMMu32_MASKmskw_XMMu32_XMMu32_IMM8_AVX512=2111, - XED_IFORM_VALIGND_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=2112, - XED_IFORM_VALIGND_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512=2113, - XED_IFORM_VALIGND_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=2114, - XED_IFORM_VALIGND_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512=2115, - XED_IFORM_VALIGNQ_XMMu64_MASKmskw_XMMu64_MEMu64_IMM8_AVX512=2116, - XED_IFORM_VALIGNQ_XMMu64_MASKmskw_XMMu64_XMMu64_IMM8_AVX512=2117, - XED_IFORM_VALIGNQ_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=2118, - XED_IFORM_VALIGNQ_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512=2119, - XED_IFORM_VALIGNQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=2120, - XED_IFORM_VALIGNQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512=2121, - XED_IFORM_VANDNPD_XMMdq_XMMdq_MEMdq=2122, - XED_IFORM_VANDNPD_XMMdq_XMMdq_XMMdq=2123, - XED_IFORM_VANDNPD_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=2124, - XED_IFORM_VANDNPD_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=2125, - XED_IFORM_VANDNPD_YMMqq_YMMqq_MEMqq=2126, - XED_IFORM_VANDNPD_YMMqq_YMMqq_YMMqq=2127, - XED_IFORM_VANDNPD_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=2128, - XED_IFORM_VANDNPD_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=2129, - XED_IFORM_VANDNPD_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=2130, - XED_IFORM_VANDNPD_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=2131, - XED_IFORM_VANDNPS_XMMdq_XMMdq_MEMdq=2132, - XED_IFORM_VANDNPS_XMMdq_XMMdq_XMMdq=2133, - XED_IFORM_VANDNPS_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=2134, - XED_IFORM_VANDNPS_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=2135, - XED_IFORM_VANDNPS_YMMqq_YMMqq_MEMqq=2136, - XED_IFORM_VANDNPS_YMMqq_YMMqq_YMMqq=2137, - XED_IFORM_VANDNPS_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=2138, - XED_IFORM_VANDNPS_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=2139, - XED_IFORM_VANDNPS_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=2140, - XED_IFORM_VANDNPS_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=2141, - XED_IFORM_VANDPD_XMMdq_XMMdq_MEMdq=2142, - XED_IFORM_VANDPD_XMMdq_XMMdq_XMMdq=2143, - XED_IFORM_VANDPD_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=2144, - XED_IFORM_VANDPD_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=2145, - XED_IFORM_VANDPD_YMMqq_YMMqq_MEMqq=2146, - XED_IFORM_VANDPD_YMMqq_YMMqq_YMMqq=2147, - XED_IFORM_VANDPD_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=2148, - XED_IFORM_VANDPD_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=2149, - XED_IFORM_VANDPD_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=2150, - XED_IFORM_VANDPD_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=2151, - XED_IFORM_VANDPS_XMMdq_XMMdq_MEMdq=2152, - XED_IFORM_VANDPS_XMMdq_XMMdq_XMMdq=2153, - XED_IFORM_VANDPS_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=2154, - XED_IFORM_VANDPS_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=2155, - XED_IFORM_VANDPS_YMMqq_YMMqq_MEMqq=2156, - XED_IFORM_VANDPS_YMMqq_YMMqq_YMMqq=2157, - XED_IFORM_VANDPS_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=2158, - XED_IFORM_VANDPS_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=2159, - XED_IFORM_VANDPS_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=2160, - XED_IFORM_VANDPS_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=2161, - XED_IFORM_VBLENDMPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2162, - XED_IFORM_VBLENDMPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2163, - XED_IFORM_VBLENDMPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2164, - XED_IFORM_VBLENDMPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2165, - XED_IFORM_VBLENDMPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2166, - XED_IFORM_VBLENDMPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2167, - XED_IFORM_VBLENDMPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2168, - XED_IFORM_VBLENDMPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2169, - XED_IFORM_VBLENDMPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2170, - XED_IFORM_VBLENDMPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2171, - XED_IFORM_VBLENDMPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2172, - XED_IFORM_VBLENDMPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2173, - XED_IFORM_VBLENDPD_XMMdq_XMMdq_MEMdq_IMMb=2174, - XED_IFORM_VBLENDPD_XMMdq_XMMdq_XMMdq_IMMb=2175, - XED_IFORM_VBLENDPD_YMMqq_YMMqq_MEMqq_IMMb=2176, - XED_IFORM_VBLENDPD_YMMqq_YMMqq_YMMqq_IMMb=2177, - XED_IFORM_VBLENDPS_XMMdq_XMMdq_MEMdq_IMMb=2178, - XED_IFORM_VBLENDPS_XMMdq_XMMdq_XMMdq_IMMb=2179, - XED_IFORM_VBLENDPS_YMMqq_YMMqq_MEMqq_IMMb=2180, - XED_IFORM_VBLENDPS_YMMqq_YMMqq_YMMqq_IMMb=2181, - XED_IFORM_VBLENDVPD_XMMdq_XMMdq_MEMdq_XMMdq=2182, - XED_IFORM_VBLENDVPD_XMMdq_XMMdq_XMMdq_XMMdq=2183, - XED_IFORM_VBLENDVPD_YMMqq_YMMqq_MEMqq_YMMqq=2184, - XED_IFORM_VBLENDVPD_YMMqq_YMMqq_YMMqq_YMMqq=2185, - XED_IFORM_VBLENDVPS_XMMdq_XMMdq_MEMdq_XMMdq=2186, - XED_IFORM_VBLENDVPS_XMMdq_XMMdq_XMMdq_XMMdq=2187, - XED_IFORM_VBLENDVPS_YMMqq_YMMqq_MEMqq_YMMqq=2188, - XED_IFORM_VBLENDVPS_YMMqq_YMMqq_YMMqq_YMMqq=2189, - XED_IFORM_VBROADCASTF128_YMMqq_MEMdq=2190, - XED_IFORM_VBROADCASTF32X2_YMMf32_MASKmskw_MEMf32_AVX512=2191, - XED_IFORM_VBROADCASTF32X2_YMMf32_MASKmskw_XMMf32_AVX512=2192, - XED_IFORM_VBROADCASTF32X2_ZMMf32_MASKmskw_MEMf32_AVX512=2193, - XED_IFORM_VBROADCASTF32X2_ZMMf32_MASKmskw_XMMf32_AVX512=2194, - XED_IFORM_VBROADCASTF32X4_YMMf32_MASKmskw_MEMf32_AVX512=2195, - XED_IFORM_VBROADCASTF32X4_ZMMf32_MASKmskw_MEMf32_AVX512=2196, - XED_IFORM_VBROADCASTF32X8_ZMMf32_MASKmskw_MEMf32_AVX512=2197, - XED_IFORM_VBROADCASTF64X2_YMMf64_MASKmskw_MEMf64_AVX512=2198, - XED_IFORM_VBROADCASTF64X2_ZMMf64_MASKmskw_MEMf64_AVX512=2199, - XED_IFORM_VBROADCASTF64X4_ZMMf64_MASKmskw_MEMf64_AVX512=2200, - XED_IFORM_VBROADCASTI128_YMMqq_MEMdq=2201, - XED_IFORM_VBROADCASTI32X2_XMMu32_MASKmskw_MEMu32_AVX512=2202, - XED_IFORM_VBROADCASTI32X2_XMMu32_MASKmskw_XMMu32_AVX512=2203, - XED_IFORM_VBROADCASTI32X2_YMMu32_MASKmskw_MEMu32_AVX512=2204, - XED_IFORM_VBROADCASTI32X2_YMMu32_MASKmskw_XMMu32_AVX512=2205, - XED_IFORM_VBROADCASTI32X2_ZMMu32_MASKmskw_MEMu32_AVX512=2206, - XED_IFORM_VBROADCASTI32X2_ZMMu32_MASKmskw_XMMu32_AVX512=2207, - XED_IFORM_VBROADCASTI32X4_YMMu32_MASKmskw_MEMu32_AVX512=2208, - XED_IFORM_VBROADCASTI32X4_ZMMu32_MASKmskw_MEMu32_AVX512=2209, - XED_IFORM_VBROADCASTI32X8_ZMMu32_MASKmskw_MEMu32_AVX512=2210, - XED_IFORM_VBROADCASTI64X2_YMMu64_MASKmskw_MEMu64_AVX512=2211, - XED_IFORM_VBROADCASTI64X2_ZMMu64_MASKmskw_MEMu64_AVX512=2212, - XED_IFORM_VBROADCASTI64X4_ZMMu64_MASKmskw_MEMu64_AVX512=2213, - XED_IFORM_VBROADCASTSD_YMMf64_MASKmskw_MEMf64_AVX512=2214, - XED_IFORM_VBROADCASTSD_YMMf64_MASKmskw_XMMf64_AVX512=2215, - XED_IFORM_VBROADCASTSD_YMMqq_MEMq=2216, - XED_IFORM_VBROADCASTSD_YMMqq_XMMdq=2217, - XED_IFORM_VBROADCASTSD_ZMMf64_MASKmskw_MEMf64_AVX512=2218, - XED_IFORM_VBROADCASTSD_ZMMf64_MASKmskw_XMMf64_AVX512=2219, - XED_IFORM_VBROADCASTSS_XMMdq_MEMd=2220, - XED_IFORM_VBROADCASTSS_XMMdq_XMMdq=2221, - XED_IFORM_VBROADCASTSS_XMMf32_MASKmskw_MEMf32_AVX512=2222, - XED_IFORM_VBROADCASTSS_XMMf32_MASKmskw_XMMf32_AVX512=2223, - XED_IFORM_VBROADCASTSS_YMMf32_MASKmskw_MEMf32_AVX512=2224, - XED_IFORM_VBROADCASTSS_YMMf32_MASKmskw_XMMf32_AVX512=2225, - XED_IFORM_VBROADCASTSS_YMMqq_MEMd=2226, - XED_IFORM_VBROADCASTSS_YMMqq_XMMdq=2227, - XED_IFORM_VBROADCASTSS_ZMMf32_MASKmskw_MEMf32_AVX512=2228, - XED_IFORM_VBROADCASTSS_ZMMf32_MASKmskw_XMMf32_AVX512=2229, - XED_IFORM_VCMPPD_MASKmskw_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=2230, - XED_IFORM_VCMPPD_MASKmskw_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=2231, - XED_IFORM_VCMPPD_MASKmskw_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=2232, - XED_IFORM_VCMPPD_MASKmskw_MASKmskw_YMMf64_YMMf64_IMM8_AVX512=2233, - XED_IFORM_VCMPPD_MASKmskw_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=2234, - XED_IFORM_VCMPPD_MASKmskw_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512=2235, - XED_IFORM_VCMPPD_XMMdq_XMMdq_MEMdq_IMMb=2236, - XED_IFORM_VCMPPD_XMMdq_XMMdq_XMMdq_IMMb=2237, - XED_IFORM_VCMPPD_YMMqq_YMMqq_MEMqq_IMMb=2238, - XED_IFORM_VCMPPD_YMMqq_YMMqq_YMMqq_IMMb=2239, - XED_IFORM_VCMPPH_MASKmskw_MASKmskw_XMMf16_MEMf16_IMM8_AVX512=2240, - XED_IFORM_VCMPPH_MASKmskw_MASKmskw_XMMf16_XMMf16_IMM8_AVX512=2241, - XED_IFORM_VCMPPH_MASKmskw_MASKmskw_YMMf16_MEMf16_IMM8_AVX512=2242, - XED_IFORM_VCMPPH_MASKmskw_MASKmskw_YMMf16_YMMf16_IMM8_AVX512=2243, - XED_IFORM_VCMPPH_MASKmskw_MASKmskw_ZMMf16_MEMf16_IMM8_AVX512=2244, - XED_IFORM_VCMPPH_MASKmskw_MASKmskw_ZMMf16_ZMMf16_IMM8_AVX512=2245, - XED_IFORM_VCMPPS_MASKmskw_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=2246, - XED_IFORM_VCMPPS_MASKmskw_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=2247, - XED_IFORM_VCMPPS_MASKmskw_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=2248, - XED_IFORM_VCMPPS_MASKmskw_MASKmskw_YMMf32_YMMf32_IMM8_AVX512=2249, - XED_IFORM_VCMPPS_MASKmskw_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=2250, - XED_IFORM_VCMPPS_MASKmskw_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512=2251, - XED_IFORM_VCMPPS_XMMdq_XMMdq_MEMdq_IMMb=2252, - XED_IFORM_VCMPPS_XMMdq_XMMdq_XMMdq_IMMb=2253, - XED_IFORM_VCMPPS_YMMqq_YMMqq_MEMqq_IMMb=2254, - XED_IFORM_VCMPPS_YMMqq_YMMqq_YMMqq_IMMb=2255, - XED_IFORM_VCMPSD_MASKmskw_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=2256, - XED_IFORM_VCMPSD_MASKmskw_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=2257, - XED_IFORM_VCMPSD_XMMdq_XMMdq_MEMq_IMMb=2258, - XED_IFORM_VCMPSD_XMMdq_XMMdq_XMMq_IMMb=2259, - XED_IFORM_VCMPSH_MASKmskw_MASKmskw_XMMf16_MEMf16_IMM8_AVX512=2260, - XED_IFORM_VCMPSH_MASKmskw_MASKmskw_XMMf16_XMMf16_IMM8_AVX512=2261, - XED_IFORM_VCMPSS_MASKmskw_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=2262, - XED_IFORM_VCMPSS_MASKmskw_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=2263, - XED_IFORM_VCMPSS_XMMdq_XMMdq_MEMd_IMMb=2264, - XED_IFORM_VCMPSS_XMMdq_XMMdq_XMMd_IMMb=2265, - XED_IFORM_VCOMISD_XMMf64_MEMf64_AVX512=2266, - XED_IFORM_VCOMISD_XMMf64_XMMf64_AVX512=2267, - XED_IFORM_VCOMISD_XMMq_MEMq=2268, - XED_IFORM_VCOMISD_XMMq_XMMq=2269, - XED_IFORM_VCOMISH_XMMf16_MEMf16_AVX512=2270, - XED_IFORM_VCOMISH_XMMf16_XMMf16_AVX512=2271, - XED_IFORM_VCOMISS_XMMd_MEMd=2272, - XED_IFORM_VCOMISS_XMMd_XMMd=2273, - XED_IFORM_VCOMISS_XMMf32_MEMf32_AVX512=2274, - XED_IFORM_VCOMISS_XMMf32_XMMf32_AVX512=2275, - XED_IFORM_VCOMPRESSPD_MEMf64_MASKmskw_XMMf64_AVX512=2276, - XED_IFORM_VCOMPRESSPD_MEMf64_MASKmskw_YMMf64_AVX512=2277, - XED_IFORM_VCOMPRESSPD_MEMf64_MASKmskw_ZMMf64_AVX512=2278, - XED_IFORM_VCOMPRESSPD_XMMf64_MASKmskw_XMMf64_AVX512=2279, - XED_IFORM_VCOMPRESSPD_YMMf64_MASKmskw_YMMf64_AVX512=2280, - XED_IFORM_VCOMPRESSPD_ZMMf64_MASKmskw_ZMMf64_AVX512=2281, - XED_IFORM_VCOMPRESSPS_MEMf32_MASKmskw_XMMf32_AVX512=2282, - XED_IFORM_VCOMPRESSPS_MEMf32_MASKmskw_YMMf32_AVX512=2283, - XED_IFORM_VCOMPRESSPS_MEMf32_MASKmskw_ZMMf32_AVX512=2284, - XED_IFORM_VCOMPRESSPS_XMMf32_MASKmskw_XMMf32_AVX512=2285, - XED_IFORM_VCOMPRESSPS_YMMf32_MASKmskw_YMMf32_AVX512=2286, - XED_IFORM_VCOMPRESSPS_ZMMf32_MASKmskw_ZMMf32_AVX512=2287, - XED_IFORM_VCVTDQ2PD_XMMdq_MEMq=2288, - XED_IFORM_VCVTDQ2PD_XMMdq_XMMq=2289, - XED_IFORM_VCVTDQ2PD_XMMf64_MASKmskw_MEMi32_AVX512=2290, - XED_IFORM_VCVTDQ2PD_XMMf64_MASKmskw_XMMi32_AVX512=2291, - XED_IFORM_VCVTDQ2PD_YMMf64_MASKmskw_MEMi32_AVX512=2292, - XED_IFORM_VCVTDQ2PD_YMMf64_MASKmskw_XMMi32_AVX512=2293, - XED_IFORM_VCVTDQ2PD_YMMqq_MEMdq=2294, - XED_IFORM_VCVTDQ2PD_YMMqq_XMMdq=2295, - XED_IFORM_VCVTDQ2PD_ZMMf64_MASKmskw_MEMi32_AVX512=2296, - XED_IFORM_VCVTDQ2PD_ZMMf64_MASKmskw_YMMi32_AVX512=2297, - XED_IFORM_VCVTDQ2PH_XMMf16_MASKmskw_MEMi32_AVX512_VL128=2298, - XED_IFORM_VCVTDQ2PH_XMMf16_MASKmskw_MEMi32_AVX512_VL256=2299, - XED_IFORM_VCVTDQ2PH_XMMf16_MASKmskw_XMMi32_AVX512=2300, - XED_IFORM_VCVTDQ2PH_XMMf16_MASKmskw_YMMi32_AVX512=2301, - XED_IFORM_VCVTDQ2PH_YMMf16_MASKmskw_MEMi32_AVX512=2302, - XED_IFORM_VCVTDQ2PH_YMMf16_MASKmskw_ZMMi32_AVX512=2303, - XED_IFORM_VCVTDQ2PS_XMMdq_MEMdq=2304, - XED_IFORM_VCVTDQ2PS_XMMdq_XMMdq=2305, - XED_IFORM_VCVTDQ2PS_XMMf32_MASKmskw_MEMi32_AVX512=2306, - XED_IFORM_VCVTDQ2PS_XMMf32_MASKmskw_XMMi32_AVX512=2307, - XED_IFORM_VCVTDQ2PS_YMMf32_MASKmskw_MEMi32_AVX512=2308, - XED_IFORM_VCVTDQ2PS_YMMf32_MASKmskw_YMMi32_AVX512=2309, - XED_IFORM_VCVTDQ2PS_YMMqq_MEMqq=2310, - XED_IFORM_VCVTDQ2PS_YMMqq_YMMqq=2311, - XED_IFORM_VCVTDQ2PS_ZMMf32_MASKmskw_MEMi32_AVX512=2312, - XED_IFORM_VCVTDQ2PS_ZMMf32_MASKmskw_ZMMi32_AVX512=2313, - XED_IFORM_VCVTNE2PS2BF16_XMMbf16_MASKmskw_XMMf32_MEMf32_AVX512_VL128=2314, - XED_IFORM_VCVTNE2PS2BF16_XMMbf16_MASKmskw_XMMf32_XMMf32_AVX512=2315, - XED_IFORM_VCVTNE2PS2BF16_YMMbf16_MASKmskw_YMMf32_MEMf32_AVX512_VL256=2316, - XED_IFORM_VCVTNE2PS2BF16_YMMbf16_MASKmskw_YMMf32_YMMf32_AVX512=2317, - XED_IFORM_VCVTNE2PS2BF16_ZMMbf16_MASKmskw_ZMMf32_MEMf32_AVX512_VL512=2318, - XED_IFORM_VCVTNE2PS2BF16_ZMMbf16_MASKmskw_ZMMf32_ZMMf32_AVX512=2319, - XED_IFORM_VCVTNEPS2BF16_XMMbf16_MASKmskw_MEMf32_AVX512_VL128=2320, - XED_IFORM_VCVTNEPS2BF16_XMMbf16_MASKmskw_MEMf32_AVX512_VL256=2321, - XED_IFORM_VCVTNEPS2BF16_XMMbf16_MASKmskw_XMMf32_AVX512=2322, - XED_IFORM_VCVTNEPS2BF16_XMMbf16_MASKmskw_YMMf32_AVX512=2323, - XED_IFORM_VCVTNEPS2BF16_YMMbf16_MASKmskw_MEMf32_AVX512_VL512=2324, - XED_IFORM_VCVTNEPS2BF16_YMMbf16_MASKmskw_ZMMf32_AVX512=2325, - XED_IFORM_VCVTPD2DQ_XMMdq_MEMdq=2326, - XED_IFORM_VCVTPD2DQ_XMMdq_MEMqq=2327, - XED_IFORM_VCVTPD2DQ_XMMdq_XMMdq=2328, - XED_IFORM_VCVTPD2DQ_XMMdq_YMMqq=2329, - XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL128=2330, - XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL256=2331, - XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_XMMf64_AVX512_VL128=2332, - XED_IFORM_VCVTPD2DQ_XMMi32_MASKmskw_YMMf64_AVX512_VL256=2333, - XED_IFORM_VCVTPD2DQ_YMMi32_MASKmskw_MEMf64_AVX512_VL512=2334, - XED_IFORM_VCVTPD2DQ_YMMi32_MASKmskw_ZMMf64_AVX512_VL512=2335, - XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_MEMf64_AVX512_VL128=2336, - XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_MEMf64_AVX512_VL256=2337, - XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_MEMf64_AVX512_VL512=2338, - XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_XMMf64_AVX512=2339, - XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_YMMf64_AVX512=2340, - XED_IFORM_VCVTPD2PH_XMMf16_MASKmskw_ZMMf64_AVX512=2341, - XED_IFORM_VCVTPD2PS_XMMdq_MEMdq=2342, - XED_IFORM_VCVTPD2PS_XMMdq_MEMqq=2343, - XED_IFORM_VCVTPD2PS_XMMdq_XMMdq=2344, - XED_IFORM_VCVTPD2PS_XMMdq_YMMqq=2345, - XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_MEMf64_AVX512_VL128=2346, - XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_MEMf64_AVX512_VL256=2347, - XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_XMMf64_AVX512_VL128=2348, - XED_IFORM_VCVTPD2PS_XMMf32_MASKmskw_YMMf64_AVX512_VL256=2349, - XED_IFORM_VCVTPD2PS_YMMf32_MASKmskw_MEMf64_AVX512_VL512=2350, - XED_IFORM_VCVTPD2PS_YMMf32_MASKmskw_ZMMf64_AVX512_VL512=2351, - XED_IFORM_VCVTPD2QQ_XMMi64_MASKmskw_MEMf64_AVX512=2352, - XED_IFORM_VCVTPD2QQ_XMMi64_MASKmskw_XMMf64_AVX512=2353, - XED_IFORM_VCVTPD2QQ_YMMi64_MASKmskw_MEMf64_AVX512=2354, - XED_IFORM_VCVTPD2QQ_YMMi64_MASKmskw_YMMf64_AVX512=2355, - XED_IFORM_VCVTPD2QQ_ZMMi64_MASKmskw_MEMf64_AVX512=2356, - XED_IFORM_VCVTPD2QQ_ZMMi64_MASKmskw_ZMMf64_AVX512=2357, - XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL128=2358, - XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL256=2359, - XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_XMMf64_AVX512_VL128=2360, - XED_IFORM_VCVTPD2UDQ_XMMu32_MASKmskw_YMMf64_AVX512_VL256=2361, - XED_IFORM_VCVTPD2UDQ_YMMu32_MASKmskw_MEMf64_AVX512_VL512=2362, - XED_IFORM_VCVTPD2UDQ_YMMu32_MASKmskw_ZMMf64_AVX512_VL512=2363, - XED_IFORM_VCVTPD2UQQ_XMMu64_MASKmskw_MEMf64_AVX512=2364, - XED_IFORM_VCVTPD2UQQ_XMMu64_MASKmskw_XMMf64_AVX512=2365, - XED_IFORM_VCVTPD2UQQ_YMMu64_MASKmskw_MEMf64_AVX512=2366, - XED_IFORM_VCVTPD2UQQ_YMMu64_MASKmskw_YMMf64_AVX512=2367, - XED_IFORM_VCVTPD2UQQ_ZMMu64_MASKmskw_MEMf64_AVX512=2368, - XED_IFORM_VCVTPD2UQQ_ZMMu64_MASKmskw_ZMMf64_AVX512=2369, - XED_IFORM_VCVTPH2DQ_XMMi32_MASKmskw_MEMf16_AVX512=2370, - XED_IFORM_VCVTPH2DQ_XMMi32_MASKmskw_XMMf16_AVX512=2371, - XED_IFORM_VCVTPH2DQ_YMMi32_MASKmskw_MEMf16_AVX512=2372, - XED_IFORM_VCVTPH2DQ_YMMi32_MASKmskw_XMMf16_AVX512=2373, - XED_IFORM_VCVTPH2DQ_ZMMi32_MASKmskw_MEMf16_AVX512=2374, - XED_IFORM_VCVTPH2DQ_ZMMi32_MASKmskw_YMMf16_AVX512=2375, - XED_IFORM_VCVTPH2PD_XMMf64_MASKmskw_MEMf16_AVX512=2376, - XED_IFORM_VCVTPH2PD_XMMf64_MASKmskw_XMMf16_AVX512=2377, - XED_IFORM_VCVTPH2PD_YMMf64_MASKmskw_MEMf16_AVX512=2378, - XED_IFORM_VCVTPH2PD_YMMf64_MASKmskw_XMMf16_AVX512=2379, - XED_IFORM_VCVTPH2PD_ZMMf64_MASKmskw_MEMf16_AVX512=2380, - XED_IFORM_VCVTPH2PD_ZMMf64_MASKmskw_XMMf16_AVX512=2381, - XED_IFORM_VCVTPH2PS_XMMdq_MEMq=2382, - XED_IFORM_VCVTPH2PS_XMMdq_XMMq=2383, - XED_IFORM_VCVTPH2PS_XMMf32_MASKmskw_MEMf16_AVX512=2384, - XED_IFORM_VCVTPH2PS_XMMf32_MASKmskw_XMMf16_AVX512=2385, - XED_IFORM_VCVTPH2PS_YMMf32_MASKmskw_MEMf16_AVX512=2386, - XED_IFORM_VCVTPH2PS_YMMf32_MASKmskw_XMMf16_AVX512=2387, - XED_IFORM_VCVTPH2PS_YMMqq_MEMdq=2388, - XED_IFORM_VCVTPH2PS_YMMqq_XMMdq=2389, - XED_IFORM_VCVTPH2PS_ZMMf32_MASKmskw_MEMf16_AVX512=2390, - XED_IFORM_VCVTPH2PS_ZMMf32_MASKmskw_YMMf16_AVX512=2391, - XED_IFORM_VCVTPH2PSX_XMMf32_MASKmskw_MEMf16_AVX512=2392, - XED_IFORM_VCVTPH2PSX_XMMf32_MASKmskw_XMMf16_AVX512=2393, - XED_IFORM_VCVTPH2PSX_YMMf32_MASKmskw_MEMf16_AVX512=2394, - XED_IFORM_VCVTPH2PSX_YMMf32_MASKmskw_XMMf16_AVX512=2395, - XED_IFORM_VCVTPH2PSX_ZMMf32_MASKmskw_MEMf16_AVX512=2396, - XED_IFORM_VCVTPH2PSX_ZMMf32_MASKmskw_YMMf16_AVX512=2397, - XED_IFORM_VCVTPH2QQ_XMMi64_MASKmskw_MEMf16_AVX512=2398, - XED_IFORM_VCVTPH2QQ_XMMi64_MASKmskw_XMMf16_AVX512=2399, - XED_IFORM_VCVTPH2QQ_YMMi64_MASKmskw_MEMf16_AVX512=2400, - XED_IFORM_VCVTPH2QQ_YMMi64_MASKmskw_XMMf16_AVX512=2401, - XED_IFORM_VCVTPH2QQ_ZMMi64_MASKmskw_MEMf16_AVX512=2402, - XED_IFORM_VCVTPH2QQ_ZMMi64_MASKmskw_XMMf16_AVX512=2403, - XED_IFORM_VCVTPH2UDQ_XMMu32_MASKmskw_MEMf16_AVX512=2404, - XED_IFORM_VCVTPH2UDQ_XMMu32_MASKmskw_XMMf16_AVX512=2405, - XED_IFORM_VCVTPH2UDQ_YMMu32_MASKmskw_MEMf16_AVX512=2406, - XED_IFORM_VCVTPH2UDQ_YMMu32_MASKmskw_XMMf16_AVX512=2407, - XED_IFORM_VCVTPH2UDQ_ZMMu32_MASKmskw_MEMf16_AVX512=2408, - XED_IFORM_VCVTPH2UDQ_ZMMu32_MASKmskw_YMMf16_AVX512=2409, - XED_IFORM_VCVTPH2UQQ_XMMu64_MASKmskw_MEMf16_AVX512=2410, - XED_IFORM_VCVTPH2UQQ_XMMu64_MASKmskw_XMMf16_AVX512=2411, - XED_IFORM_VCVTPH2UQQ_YMMu64_MASKmskw_MEMf16_AVX512=2412, - XED_IFORM_VCVTPH2UQQ_YMMu64_MASKmskw_XMMf16_AVX512=2413, - XED_IFORM_VCVTPH2UQQ_ZMMu64_MASKmskw_MEMf16_AVX512=2414, - XED_IFORM_VCVTPH2UQQ_ZMMu64_MASKmskw_XMMf16_AVX512=2415, - XED_IFORM_VCVTPH2UW_XMMu16_MASKmskw_MEMf16_AVX512=2416, - XED_IFORM_VCVTPH2UW_XMMu16_MASKmskw_XMMf16_AVX512=2417, - XED_IFORM_VCVTPH2UW_YMMu16_MASKmskw_MEMf16_AVX512=2418, - XED_IFORM_VCVTPH2UW_YMMu16_MASKmskw_YMMf16_AVX512=2419, - XED_IFORM_VCVTPH2UW_ZMMu16_MASKmskw_MEMf16_AVX512=2420, - XED_IFORM_VCVTPH2UW_ZMMu16_MASKmskw_ZMMf16_AVX512=2421, - XED_IFORM_VCVTPH2W_XMMi16_MASKmskw_MEMf16_AVX512=2422, - XED_IFORM_VCVTPH2W_XMMi16_MASKmskw_XMMf16_AVX512=2423, - XED_IFORM_VCVTPH2W_YMMi16_MASKmskw_MEMf16_AVX512=2424, - XED_IFORM_VCVTPH2W_YMMi16_MASKmskw_YMMf16_AVX512=2425, - XED_IFORM_VCVTPH2W_ZMMi16_MASKmskw_MEMf16_AVX512=2426, - XED_IFORM_VCVTPH2W_ZMMi16_MASKmskw_ZMMf16_AVX512=2427, - XED_IFORM_VCVTPS2DQ_XMMdq_MEMdq=2428, - XED_IFORM_VCVTPS2DQ_XMMdq_XMMdq=2429, - XED_IFORM_VCVTPS2DQ_XMMi32_MASKmskw_MEMf32_AVX512=2430, - XED_IFORM_VCVTPS2DQ_XMMi32_MASKmskw_XMMf32_AVX512=2431, - XED_IFORM_VCVTPS2DQ_YMMi32_MASKmskw_MEMf32_AVX512=2432, - XED_IFORM_VCVTPS2DQ_YMMi32_MASKmskw_YMMf32_AVX512=2433, - XED_IFORM_VCVTPS2DQ_YMMqq_MEMqq=2434, - XED_IFORM_VCVTPS2DQ_YMMqq_YMMqq=2435, - XED_IFORM_VCVTPS2DQ_ZMMi32_MASKmskw_MEMf32_AVX512=2436, - XED_IFORM_VCVTPS2DQ_ZMMi32_MASKmskw_ZMMf32_AVX512=2437, - XED_IFORM_VCVTPS2PD_XMMdq_MEMq=2438, - XED_IFORM_VCVTPS2PD_XMMdq_XMMq=2439, - XED_IFORM_VCVTPS2PD_XMMf64_MASKmskw_MEMf32_AVX512=2440, - XED_IFORM_VCVTPS2PD_XMMf64_MASKmskw_XMMf32_AVX512=2441, - XED_IFORM_VCVTPS2PD_YMMf64_MASKmskw_MEMf32_AVX512=2442, - XED_IFORM_VCVTPS2PD_YMMf64_MASKmskw_XMMf32_AVX512=2443, - XED_IFORM_VCVTPS2PD_YMMqq_MEMdq=2444, - XED_IFORM_VCVTPS2PD_YMMqq_XMMdq=2445, - XED_IFORM_VCVTPS2PD_ZMMf64_MASKmskw_MEMf32_AVX512=2446, - XED_IFORM_VCVTPS2PD_ZMMf64_MASKmskw_YMMf32_AVX512=2447, - XED_IFORM_VCVTPS2PH_MEMdq_YMMqq_IMMb=2448, - XED_IFORM_VCVTPS2PH_MEMf16_MASKmskw_XMMf32_IMM8_AVX512=2449, - XED_IFORM_VCVTPS2PH_MEMf16_MASKmskw_YMMf32_IMM8_AVX512=2450, - XED_IFORM_VCVTPS2PH_MEMf16_MASKmskw_ZMMf32_IMM8_AVX512=2451, - XED_IFORM_VCVTPS2PH_MEMq_XMMdq_IMMb=2452, - XED_IFORM_VCVTPS2PH_XMMdq_YMMqq_IMMb=2453, - XED_IFORM_VCVTPS2PH_XMMf16_MASKmskw_XMMf32_IMM8_AVX512=2454, - XED_IFORM_VCVTPS2PH_XMMf16_MASKmskw_YMMf32_IMM8_AVX512=2455, - XED_IFORM_VCVTPS2PH_XMMq_XMMdq_IMMb=2456, - XED_IFORM_VCVTPS2PH_YMMf16_MASKmskw_ZMMf32_IMM8_AVX512=2457, - XED_IFORM_VCVTPS2PHX_XMMf16_MASKmskw_MEMf32_AVX512_VL128=2458, - XED_IFORM_VCVTPS2PHX_XMMf16_MASKmskw_MEMf32_AVX512_VL256=2459, - XED_IFORM_VCVTPS2PHX_XMMf16_MASKmskw_XMMf32_AVX512=2460, - XED_IFORM_VCVTPS2PHX_XMMf16_MASKmskw_YMMf32_AVX512=2461, - XED_IFORM_VCVTPS2PHX_YMMf16_MASKmskw_MEMf32_AVX512_VL512=2462, - XED_IFORM_VCVTPS2PHX_YMMf16_MASKmskw_ZMMf32_AVX512=2463, - XED_IFORM_VCVTPS2QQ_XMMi64_MASKmskw_MEMf32_AVX512=2464, - XED_IFORM_VCVTPS2QQ_XMMi64_MASKmskw_XMMf32_AVX512=2465, - XED_IFORM_VCVTPS2QQ_YMMi64_MASKmskw_MEMf32_AVX512=2466, - XED_IFORM_VCVTPS2QQ_YMMi64_MASKmskw_XMMf32_AVX512=2467, - XED_IFORM_VCVTPS2QQ_ZMMi64_MASKmskw_MEMf32_AVX512=2468, - XED_IFORM_VCVTPS2QQ_ZMMi64_MASKmskw_YMMf32_AVX512=2469, - XED_IFORM_VCVTPS2UDQ_XMMu32_MASKmskw_MEMf32_AVX512=2470, - XED_IFORM_VCVTPS2UDQ_XMMu32_MASKmskw_XMMf32_AVX512=2471, - XED_IFORM_VCVTPS2UDQ_YMMu32_MASKmskw_MEMf32_AVX512=2472, - XED_IFORM_VCVTPS2UDQ_YMMu32_MASKmskw_YMMf32_AVX512=2473, - XED_IFORM_VCVTPS2UDQ_ZMMu32_MASKmskw_MEMf32_AVX512=2474, - XED_IFORM_VCVTPS2UDQ_ZMMu32_MASKmskw_ZMMf32_AVX512=2475, - XED_IFORM_VCVTPS2UQQ_XMMu64_MASKmskw_MEMf32_AVX512=2476, - XED_IFORM_VCVTPS2UQQ_XMMu64_MASKmskw_XMMf32_AVX512=2477, - XED_IFORM_VCVTPS2UQQ_YMMu64_MASKmskw_MEMf32_AVX512=2478, - XED_IFORM_VCVTPS2UQQ_YMMu64_MASKmskw_XMMf32_AVX512=2479, - XED_IFORM_VCVTPS2UQQ_ZMMu64_MASKmskw_MEMf32_AVX512=2480, - XED_IFORM_VCVTPS2UQQ_ZMMu64_MASKmskw_YMMf32_AVX512=2481, - XED_IFORM_VCVTQQ2PD_XMMi64_MASKmskw_MEMf64_AVX512=2482, - XED_IFORM_VCVTQQ2PD_XMMi64_MASKmskw_XMMf64_AVX512=2483, - XED_IFORM_VCVTQQ2PD_YMMi64_MASKmskw_MEMf64_AVX512=2484, - XED_IFORM_VCVTQQ2PD_YMMi64_MASKmskw_YMMf64_AVX512=2485, - XED_IFORM_VCVTQQ2PD_ZMMi64_MASKmskw_MEMf64_AVX512=2486, - XED_IFORM_VCVTQQ2PD_ZMMi64_MASKmskw_ZMMf64_AVX512=2487, - XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL128=2488, - XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL256=2489, - XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL512=2490, - XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_XMMu64_AVX512=2491, - XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_YMMu64_AVX512=2492, - XED_IFORM_VCVTQQ2PH_XMMf16_MASKmskw_ZMMu64_AVX512=2493, - XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL128=2494, - XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL256=2495, - XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_XMMu64_AVX512_VL128=2496, - XED_IFORM_VCVTQQ2PS_XMMf32_MASKmskw_YMMu64_AVX512_VL256=2497, - XED_IFORM_VCVTQQ2PS_YMMf32_MASKmskw_MEMu64_AVX512_VL512=2498, - XED_IFORM_VCVTQQ2PS_YMMf32_MASKmskw_ZMMu64_AVX512_VL512=2499, - XED_IFORM_VCVTSD2SH_XMMf16_MASKmskw_XMMf64_MEMf64_AVX512=2500, - XED_IFORM_VCVTSD2SH_XMMf16_MASKmskw_XMMf64_XMMf64_AVX512=2501, - XED_IFORM_VCVTSD2SI_GPR32d_MEMq=2502, - XED_IFORM_VCVTSD2SI_GPR32d_XMMq=2503, - XED_IFORM_VCVTSD2SI_GPR32i32_MEMf64_AVX512=2504, - XED_IFORM_VCVTSD2SI_GPR32i32_XMMf64_AVX512=2505, - XED_IFORM_VCVTSD2SI_GPR64i64_MEMf64_AVX512=2506, - XED_IFORM_VCVTSD2SI_GPR64i64_XMMf64_AVX512=2507, - XED_IFORM_VCVTSD2SI_GPR64q_MEMq=2508, - XED_IFORM_VCVTSD2SI_GPR64q_XMMq=2509, - XED_IFORM_VCVTSD2SS_XMMdq_XMMdq_MEMq=2510, - XED_IFORM_VCVTSD2SS_XMMdq_XMMdq_XMMq=2511, - XED_IFORM_VCVTSD2SS_XMMf32_MASKmskw_XMMf64_MEMf64_AVX512=2512, - XED_IFORM_VCVTSD2SS_XMMf32_MASKmskw_XMMf64_XMMf64_AVX512=2513, - XED_IFORM_VCVTSD2USI_GPR32u32_MEMf64_AVX512=2514, - XED_IFORM_VCVTSD2USI_GPR32u32_XMMf64_AVX512=2515, - XED_IFORM_VCVTSD2USI_GPR64u64_MEMf64_AVX512=2516, - XED_IFORM_VCVTSD2USI_GPR64u64_XMMf64_AVX512=2517, - XED_IFORM_VCVTSH2SD_XMMf64_MASKmskw_XMMf64_MEMf16_AVX512=2518, - XED_IFORM_VCVTSH2SD_XMMf64_MASKmskw_XMMf64_XMMf16_AVX512=2519, - XED_IFORM_VCVTSH2SI_GPR32i32_MEMf16_AVX512=2520, - XED_IFORM_VCVTSH2SI_GPR32i32_XMMf16_AVX512=2521, - XED_IFORM_VCVTSH2SI_GPR64i64_MEMf16_AVX512=2522, - XED_IFORM_VCVTSH2SI_GPR64i64_XMMf16_AVX512=2523, - XED_IFORM_VCVTSH2SS_XMMf32_MASKmskw_XMMf32_MEMf16_AVX512=2524, - XED_IFORM_VCVTSH2SS_XMMf32_MASKmskw_XMMf32_XMMf16_AVX512=2525, - XED_IFORM_VCVTSH2USI_GPR32u32_MEMf16_AVX512=2526, - XED_IFORM_VCVTSH2USI_GPR32u32_XMMf16_AVX512=2527, - XED_IFORM_VCVTSH2USI_GPR64u64_MEMf16_AVX512=2528, - XED_IFORM_VCVTSH2USI_GPR64u64_XMMf16_AVX512=2529, - XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_GPR32d=2530, - XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_GPR64q=2531, - XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_MEMd=2532, - XED_IFORM_VCVTSI2SD_XMMdq_XMMdq_MEMq=2533, - XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_GPR32i32_AVX512=2534, - XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_GPR64i64_AVX512=2535, - XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_MEMi32_AVX512=2536, - XED_IFORM_VCVTSI2SD_XMMf64_XMMf64_MEMi64_AVX512=2537, - XED_IFORM_VCVTSI2SH_XMMf16_XMMf16_GPR32i32_AVX512=2538, - XED_IFORM_VCVTSI2SH_XMMf16_XMMf16_GPR64i64_AVX512=2539, - XED_IFORM_VCVTSI2SH_XMMf16_XMMf16_MEMi32_AVX512=2540, - XED_IFORM_VCVTSI2SH_XMMf16_XMMf16_MEMi64_AVX512=2541, - XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_GPR32d=2542, - XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_GPR64q=2543, - XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_MEMd=2544, - XED_IFORM_VCVTSI2SS_XMMdq_XMMdq_MEMq=2545, - XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_GPR32i32_AVX512=2546, - XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_GPR64i64_AVX512=2547, - XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_MEMi32_AVX512=2548, - XED_IFORM_VCVTSI2SS_XMMf32_XMMf32_MEMi64_AVX512=2549, - XED_IFORM_VCVTSS2SD_XMMdq_XMMdq_MEMd=2550, - XED_IFORM_VCVTSS2SD_XMMdq_XMMdq_XMMd=2551, - XED_IFORM_VCVTSS2SD_XMMf64_MASKmskw_XMMf32_MEMf32_AVX512=2552, - XED_IFORM_VCVTSS2SD_XMMf64_MASKmskw_XMMf32_XMMf32_AVX512=2553, - XED_IFORM_VCVTSS2SH_XMMf16_MASKmskw_XMMf16_MEMf32_AVX512=2554, - XED_IFORM_VCVTSS2SH_XMMf16_MASKmskw_XMMf16_XMMf32_AVX512=2555, - XED_IFORM_VCVTSS2SI_GPR32d_MEMd=2556, - XED_IFORM_VCVTSS2SI_GPR32d_XMMd=2557, - XED_IFORM_VCVTSS2SI_GPR32i32_MEMf32_AVX512=2558, - XED_IFORM_VCVTSS2SI_GPR32i32_XMMf32_AVX512=2559, - XED_IFORM_VCVTSS2SI_GPR64i64_MEMf32_AVX512=2560, - XED_IFORM_VCVTSS2SI_GPR64i64_XMMf32_AVX512=2561, - XED_IFORM_VCVTSS2SI_GPR64q_MEMd=2562, - XED_IFORM_VCVTSS2SI_GPR64q_XMMd=2563, - XED_IFORM_VCVTSS2USI_GPR32u32_MEMf32_AVX512=2564, - XED_IFORM_VCVTSS2USI_GPR32u32_XMMf32_AVX512=2565, - XED_IFORM_VCVTSS2USI_GPR64u64_MEMf32_AVX512=2566, - XED_IFORM_VCVTSS2USI_GPR64u64_XMMf32_AVX512=2567, - XED_IFORM_VCVTTPD2DQ_XMMdq_MEMdq=2568, - XED_IFORM_VCVTTPD2DQ_XMMdq_MEMqq=2569, - XED_IFORM_VCVTTPD2DQ_XMMdq_XMMdq=2570, - XED_IFORM_VCVTTPD2DQ_XMMdq_YMMqq=2571, - XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL128=2572, - XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_MEMf64_AVX512_VL256=2573, - XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_XMMf64_AVX512_VL128=2574, - XED_IFORM_VCVTTPD2DQ_XMMi32_MASKmskw_YMMf64_AVX512_VL256=2575, - XED_IFORM_VCVTTPD2DQ_YMMi32_MASKmskw_MEMf64_AVX512_VL512=2576, - XED_IFORM_VCVTTPD2DQ_YMMi32_MASKmskw_ZMMf64_AVX512_VL512=2577, - XED_IFORM_VCVTTPD2QQ_XMMi64_MASKmskw_MEMf64_AVX512=2578, - XED_IFORM_VCVTTPD2QQ_XMMi64_MASKmskw_XMMf64_AVX512=2579, - XED_IFORM_VCVTTPD2QQ_YMMi64_MASKmskw_MEMf64_AVX512=2580, - XED_IFORM_VCVTTPD2QQ_YMMi64_MASKmskw_YMMf64_AVX512=2581, - XED_IFORM_VCVTTPD2QQ_ZMMi64_MASKmskw_MEMf64_AVX512=2582, - XED_IFORM_VCVTTPD2QQ_ZMMi64_MASKmskw_ZMMf64_AVX512=2583, - XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL128=2584, - XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_MEMf64_AVX512_VL256=2585, - XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_XMMf64_AVX512_VL128=2586, - XED_IFORM_VCVTTPD2UDQ_XMMu32_MASKmskw_YMMf64_AVX512_VL256=2587, - XED_IFORM_VCVTTPD2UDQ_YMMu32_MASKmskw_MEMf64_AVX512_VL512=2588, - XED_IFORM_VCVTTPD2UDQ_YMMu32_MASKmskw_ZMMf64_AVX512_VL512=2589, - XED_IFORM_VCVTTPD2UQQ_XMMu64_MASKmskw_MEMf64_AVX512=2590, - XED_IFORM_VCVTTPD2UQQ_XMMu64_MASKmskw_XMMf64_AVX512=2591, - XED_IFORM_VCVTTPD2UQQ_YMMu64_MASKmskw_MEMf64_AVX512=2592, - XED_IFORM_VCVTTPD2UQQ_YMMu64_MASKmskw_YMMf64_AVX512=2593, - XED_IFORM_VCVTTPD2UQQ_ZMMu64_MASKmskw_MEMf64_AVX512=2594, - XED_IFORM_VCVTTPD2UQQ_ZMMu64_MASKmskw_ZMMf64_AVX512=2595, - XED_IFORM_VCVTTPH2DQ_XMMi32_MASKmskw_MEMf16_AVX512=2596, - XED_IFORM_VCVTTPH2DQ_XMMi32_MASKmskw_XMMf16_AVX512=2597, - XED_IFORM_VCVTTPH2DQ_YMMi32_MASKmskw_MEMf16_AVX512=2598, - XED_IFORM_VCVTTPH2DQ_YMMi32_MASKmskw_XMMf16_AVX512=2599, - XED_IFORM_VCVTTPH2DQ_ZMMi32_MASKmskw_MEMf16_AVX512=2600, - XED_IFORM_VCVTTPH2DQ_ZMMi32_MASKmskw_YMMf16_AVX512=2601, - XED_IFORM_VCVTTPH2QQ_XMMi64_MASKmskw_MEMf16_AVX512=2602, - XED_IFORM_VCVTTPH2QQ_XMMi64_MASKmskw_XMMf16_AVX512=2603, - XED_IFORM_VCVTTPH2QQ_YMMi64_MASKmskw_MEMf16_AVX512=2604, - XED_IFORM_VCVTTPH2QQ_YMMi64_MASKmskw_XMMf16_AVX512=2605, - XED_IFORM_VCVTTPH2QQ_ZMMi64_MASKmskw_MEMf16_AVX512=2606, - XED_IFORM_VCVTTPH2QQ_ZMMi64_MASKmskw_XMMf16_AVX512=2607, - XED_IFORM_VCVTTPH2UDQ_XMMu32_MASKmskw_MEMf16_AVX512=2608, - XED_IFORM_VCVTTPH2UDQ_XMMu32_MASKmskw_XMMf16_AVX512=2609, - XED_IFORM_VCVTTPH2UDQ_YMMu32_MASKmskw_MEMf16_AVX512=2610, - XED_IFORM_VCVTTPH2UDQ_YMMu32_MASKmskw_XMMf16_AVX512=2611, - XED_IFORM_VCVTTPH2UDQ_ZMMu32_MASKmskw_MEMf16_AVX512=2612, - XED_IFORM_VCVTTPH2UDQ_ZMMu32_MASKmskw_YMMf16_AVX512=2613, - XED_IFORM_VCVTTPH2UQQ_XMMu64_MASKmskw_MEMf16_AVX512=2614, - XED_IFORM_VCVTTPH2UQQ_XMMu64_MASKmskw_XMMf16_AVX512=2615, - XED_IFORM_VCVTTPH2UQQ_YMMu64_MASKmskw_MEMf16_AVX512=2616, - XED_IFORM_VCVTTPH2UQQ_YMMu64_MASKmskw_XMMf16_AVX512=2617, - XED_IFORM_VCVTTPH2UQQ_ZMMu64_MASKmskw_MEMf16_AVX512=2618, - XED_IFORM_VCVTTPH2UQQ_ZMMu64_MASKmskw_XMMf16_AVX512=2619, - XED_IFORM_VCVTTPH2UW_XMMu16_MASKmskw_MEMf16_AVX512=2620, - XED_IFORM_VCVTTPH2UW_XMMu16_MASKmskw_XMMf16_AVX512=2621, - XED_IFORM_VCVTTPH2UW_YMMu16_MASKmskw_MEMf16_AVX512=2622, - XED_IFORM_VCVTTPH2UW_YMMu16_MASKmskw_YMMf16_AVX512=2623, - XED_IFORM_VCVTTPH2UW_ZMMu16_MASKmskw_MEMf16_AVX512=2624, - XED_IFORM_VCVTTPH2UW_ZMMu16_MASKmskw_ZMMf16_AVX512=2625, - XED_IFORM_VCVTTPH2W_XMMi16_MASKmskw_MEMf16_AVX512=2626, - XED_IFORM_VCVTTPH2W_XMMi16_MASKmskw_XMMf16_AVX512=2627, - XED_IFORM_VCVTTPH2W_YMMi16_MASKmskw_MEMf16_AVX512=2628, - XED_IFORM_VCVTTPH2W_YMMi16_MASKmskw_YMMf16_AVX512=2629, - XED_IFORM_VCVTTPH2W_ZMMi16_MASKmskw_MEMf16_AVX512=2630, - XED_IFORM_VCVTTPH2W_ZMMi16_MASKmskw_ZMMf16_AVX512=2631, - XED_IFORM_VCVTTPS2DQ_XMMdq_MEMdq=2632, - XED_IFORM_VCVTTPS2DQ_XMMdq_XMMdq=2633, - XED_IFORM_VCVTTPS2DQ_XMMi32_MASKmskw_MEMf32_AVX512=2634, - XED_IFORM_VCVTTPS2DQ_XMMi32_MASKmskw_XMMf32_AVX512=2635, - XED_IFORM_VCVTTPS2DQ_YMMi32_MASKmskw_MEMf32_AVX512=2636, - XED_IFORM_VCVTTPS2DQ_YMMi32_MASKmskw_YMMf32_AVX512=2637, - XED_IFORM_VCVTTPS2DQ_YMMqq_MEMqq=2638, - XED_IFORM_VCVTTPS2DQ_YMMqq_YMMqq=2639, - XED_IFORM_VCVTTPS2DQ_ZMMi32_MASKmskw_MEMf32_AVX512=2640, - XED_IFORM_VCVTTPS2DQ_ZMMi32_MASKmskw_ZMMf32_AVX512=2641, - XED_IFORM_VCVTTPS2QQ_XMMi64_MASKmskw_MEMf32_AVX512=2642, - XED_IFORM_VCVTTPS2QQ_XMMi64_MASKmskw_XMMf32_AVX512=2643, - XED_IFORM_VCVTTPS2QQ_YMMi64_MASKmskw_MEMf32_AVX512=2644, - XED_IFORM_VCVTTPS2QQ_YMMi64_MASKmskw_XMMf32_AVX512=2645, - XED_IFORM_VCVTTPS2QQ_ZMMi64_MASKmskw_MEMf32_AVX512=2646, - XED_IFORM_VCVTTPS2QQ_ZMMi64_MASKmskw_YMMf32_AVX512=2647, - XED_IFORM_VCVTTPS2UDQ_XMMu32_MASKmskw_MEMf32_AVX512=2648, - XED_IFORM_VCVTTPS2UDQ_XMMu32_MASKmskw_XMMf32_AVX512=2649, - XED_IFORM_VCVTTPS2UDQ_YMMu32_MASKmskw_MEMf32_AVX512=2650, - XED_IFORM_VCVTTPS2UDQ_YMMu32_MASKmskw_YMMf32_AVX512=2651, - XED_IFORM_VCVTTPS2UDQ_ZMMu32_MASKmskw_MEMf32_AVX512=2652, - XED_IFORM_VCVTTPS2UDQ_ZMMu32_MASKmskw_ZMMf32_AVX512=2653, - XED_IFORM_VCVTTPS2UQQ_XMMu64_MASKmskw_MEMf32_AVX512=2654, - XED_IFORM_VCVTTPS2UQQ_XMMu64_MASKmskw_XMMf32_AVX512=2655, - XED_IFORM_VCVTTPS2UQQ_YMMu64_MASKmskw_MEMf32_AVX512=2656, - XED_IFORM_VCVTTPS2UQQ_YMMu64_MASKmskw_XMMf32_AVX512=2657, - XED_IFORM_VCVTTPS2UQQ_ZMMu64_MASKmskw_MEMf32_AVX512=2658, - XED_IFORM_VCVTTPS2UQQ_ZMMu64_MASKmskw_YMMf32_AVX512=2659, - XED_IFORM_VCVTTSD2SI_GPR32d_MEMq=2660, - XED_IFORM_VCVTTSD2SI_GPR32d_XMMq=2661, - XED_IFORM_VCVTTSD2SI_GPR32i32_MEMf64_AVX512=2662, - XED_IFORM_VCVTTSD2SI_GPR32i32_XMMf64_AVX512=2663, - XED_IFORM_VCVTTSD2SI_GPR64i64_MEMf64_AVX512=2664, - XED_IFORM_VCVTTSD2SI_GPR64i64_XMMf64_AVX512=2665, - XED_IFORM_VCVTTSD2SI_GPR64q_MEMq=2666, - XED_IFORM_VCVTTSD2SI_GPR64q_XMMq=2667, - XED_IFORM_VCVTTSD2USI_GPR32u32_MEMf64_AVX512=2668, - XED_IFORM_VCVTTSD2USI_GPR32u32_XMMf64_AVX512=2669, - XED_IFORM_VCVTTSD2USI_GPR64u64_MEMf64_AVX512=2670, - XED_IFORM_VCVTTSD2USI_GPR64u64_XMMf64_AVX512=2671, - XED_IFORM_VCVTTSH2SI_GPR32i32_MEMf16_AVX512=2672, - XED_IFORM_VCVTTSH2SI_GPR32i32_XMMf16_AVX512=2673, - XED_IFORM_VCVTTSH2SI_GPR64i64_MEMf16_AVX512=2674, - XED_IFORM_VCVTTSH2SI_GPR64i64_XMMf16_AVX512=2675, - XED_IFORM_VCVTTSH2USI_GPR32u32_MEMf16_AVX512=2676, - XED_IFORM_VCVTTSH2USI_GPR32u32_XMMf16_AVX512=2677, - XED_IFORM_VCVTTSH2USI_GPR64u64_MEMf16_AVX512=2678, - XED_IFORM_VCVTTSH2USI_GPR64u64_XMMf16_AVX512=2679, - XED_IFORM_VCVTTSS2SI_GPR32d_MEMd=2680, - XED_IFORM_VCVTTSS2SI_GPR32d_XMMd=2681, - XED_IFORM_VCVTTSS2SI_GPR32i32_MEMf32_AVX512=2682, - XED_IFORM_VCVTTSS2SI_GPR32i32_XMMf32_AVX512=2683, - XED_IFORM_VCVTTSS2SI_GPR64i64_MEMf32_AVX512=2684, - XED_IFORM_VCVTTSS2SI_GPR64i64_XMMf32_AVX512=2685, - XED_IFORM_VCVTTSS2SI_GPR64q_MEMd=2686, - XED_IFORM_VCVTTSS2SI_GPR64q_XMMd=2687, - XED_IFORM_VCVTTSS2USI_GPR32u32_MEMf32_AVX512=2688, - XED_IFORM_VCVTTSS2USI_GPR32u32_XMMf32_AVX512=2689, - XED_IFORM_VCVTTSS2USI_GPR64u64_MEMf32_AVX512=2690, - XED_IFORM_VCVTTSS2USI_GPR64u64_XMMf32_AVX512=2691, - XED_IFORM_VCVTUDQ2PD_XMMf64_MASKmskw_MEMu32_AVX512=2692, - XED_IFORM_VCVTUDQ2PD_XMMf64_MASKmskw_XMMu32_AVX512=2693, - XED_IFORM_VCVTUDQ2PD_YMMf64_MASKmskw_MEMu32_AVX512=2694, - XED_IFORM_VCVTUDQ2PD_YMMf64_MASKmskw_XMMu32_AVX512=2695, - XED_IFORM_VCVTUDQ2PD_ZMMf64_MASKmskw_MEMu32_AVX512=2696, - XED_IFORM_VCVTUDQ2PD_ZMMf64_MASKmskw_YMMu32_AVX512=2697, - XED_IFORM_VCVTUDQ2PH_XMMf16_MASKmskw_MEMu32_AVX512_VL128=2698, - XED_IFORM_VCVTUDQ2PH_XMMf16_MASKmskw_MEMu32_AVX512_VL256=2699, - XED_IFORM_VCVTUDQ2PH_XMMf16_MASKmskw_XMMu32_AVX512=2700, - XED_IFORM_VCVTUDQ2PH_XMMf16_MASKmskw_YMMu32_AVX512=2701, - XED_IFORM_VCVTUDQ2PH_YMMf16_MASKmskw_MEMu32_AVX512=2702, - XED_IFORM_VCVTUDQ2PH_YMMf16_MASKmskw_ZMMu32_AVX512=2703, - XED_IFORM_VCVTUDQ2PS_XMMf32_MASKmskw_MEMu32_AVX512=2704, - XED_IFORM_VCVTUDQ2PS_XMMf32_MASKmskw_XMMu32_AVX512=2705, - XED_IFORM_VCVTUDQ2PS_YMMf32_MASKmskw_MEMu32_AVX512=2706, - XED_IFORM_VCVTUDQ2PS_YMMf32_MASKmskw_YMMu32_AVX512=2707, - XED_IFORM_VCVTUDQ2PS_ZMMf32_MASKmskw_MEMu32_AVX512=2708, - XED_IFORM_VCVTUDQ2PS_ZMMf32_MASKmskw_ZMMu32_AVX512=2709, - XED_IFORM_VCVTUQQ2PD_XMMf64_MASKmskw_MEMu64_AVX512=2710, - XED_IFORM_VCVTUQQ2PD_XMMf64_MASKmskw_XMMu64_AVX512=2711, - XED_IFORM_VCVTUQQ2PD_YMMf64_MASKmskw_MEMu64_AVX512=2712, - XED_IFORM_VCVTUQQ2PD_YMMf64_MASKmskw_YMMu64_AVX512=2713, - XED_IFORM_VCVTUQQ2PD_ZMMf64_MASKmskw_MEMu64_AVX512=2714, - XED_IFORM_VCVTUQQ2PD_ZMMf64_MASKmskw_ZMMu64_AVX512=2715, - XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL128=2716, - XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL256=2717, - XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_MEMu64_AVX512_VL512=2718, - XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_XMMu64_AVX512=2719, - XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_YMMu64_AVX512=2720, - XED_IFORM_VCVTUQQ2PH_XMMf16_MASKmskw_ZMMu64_AVX512=2721, - XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL128=2722, - XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_MEMu64_AVX512_VL256=2723, - XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_XMMu64_AVX512_VL128=2724, - XED_IFORM_VCVTUQQ2PS_XMMf32_MASKmskw_YMMu64_AVX512_VL256=2725, - XED_IFORM_VCVTUQQ2PS_YMMf32_MASKmskw_MEMu64_AVX512_VL512=2726, - XED_IFORM_VCVTUQQ2PS_YMMf32_MASKmskw_ZMMu64_AVX512_VL512=2727, - XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_GPR32u32_AVX512=2728, - XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_GPR64u64_AVX512=2729, - XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_MEMu32_AVX512=2730, - XED_IFORM_VCVTUSI2SD_XMMf64_XMMf64_MEMu64_AVX512=2731, - XED_IFORM_VCVTUSI2SH_XMMf16_XMMf16_GPR32u32_AVX512=2732, - XED_IFORM_VCVTUSI2SH_XMMf16_XMMf16_GPR64u64_AVX512=2733, - XED_IFORM_VCVTUSI2SH_XMMf16_XMMf16_MEMu32_AVX512=2734, - XED_IFORM_VCVTUSI2SH_XMMf16_XMMf16_MEMu64_AVX512=2735, - XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_GPR32u32_AVX512=2736, - XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_GPR64u64_AVX512=2737, - XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_MEMu32_AVX512=2738, - XED_IFORM_VCVTUSI2SS_XMMf32_XMMf32_MEMu64_AVX512=2739, - XED_IFORM_VCVTUW2PH_XMMf16_MASKmskw_MEMu16_AVX512=2740, - XED_IFORM_VCVTUW2PH_XMMf16_MASKmskw_XMMu16_AVX512=2741, - XED_IFORM_VCVTUW2PH_YMMf16_MASKmskw_MEMu16_AVX512=2742, - XED_IFORM_VCVTUW2PH_YMMf16_MASKmskw_YMMu16_AVX512=2743, - XED_IFORM_VCVTUW2PH_ZMMf16_MASKmskw_MEMu16_AVX512=2744, - XED_IFORM_VCVTUW2PH_ZMMf16_MASKmskw_ZMMu16_AVX512=2745, - XED_IFORM_VCVTW2PH_XMMf16_MASKmskw_MEMi16_AVX512=2746, - XED_IFORM_VCVTW2PH_XMMf16_MASKmskw_XMMi16_AVX512=2747, - XED_IFORM_VCVTW2PH_YMMf16_MASKmskw_MEMi16_AVX512=2748, - XED_IFORM_VCVTW2PH_YMMf16_MASKmskw_YMMi16_AVX512=2749, - XED_IFORM_VCVTW2PH_ZMMf16_MASKmskw_MEMi16_AVX512=2750, - XED_IFORM_VCVTW2PH_ZMMf16_MASKmskw_ZMMi16_AVX512=2751, - XED_IFORM_VDBPSADBW_XMMu16_MASKmskw_XMMu8_MEMu8_IMM8_AVX512=2752, - XED_IFORM_VDBPSADBW_XMMu16_MASKmskw_XMMu8_XMMu8_IMM8_AVX512=2753, - XED_IFORM_VDBPSADBW_YMMu16_MASKmskw_YMMu8_MEMu8_IMM8_AVX512=2754, - XED_IFORM_VDBPSADBW_YMMu16_MASKmskw_YMMu8_YMMu8_IMM8_AVX512=2755, - XED_IFORM_VDBPSADBW_ZMMu16_MASKmskw_ZMMu8_MEMu8_IMM8_AVX512=2756, - XED_IFORM_VDBPSADBW_ZMMu16_MASKmskw_ZMMu8_ZMMu8_IMM8_AVX512=2757, - XED_IFORM_VDIVPD_XMMdq_XMMdq_MEMdq=2758, - XED_IFORM_VDIVPD_XMMdq_XMMdq_XMMdq=2759, - XED_IFORM_VDIVPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2760, - XED_IFORM_VDIVPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2761, - XED_IFORM_VDIVPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2762, - XED_IFORM_VDIVPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2763, - XED_IFORM_VDIVPD_YMMqq_YMMqq_MEMqq=2764, - XED_IFORM_VDIVPD_YMMqq_YMMqq_YMMqq=2765, - XED_IFORM_VDIVPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2766, - XED_IFORM_VDIVPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2767, - XED_IFORM_VDIVPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=2768, - XED_IFORM_VDIVPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=2769, - XED_IFORM_VDIVPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=2770, - XED_IFORM_VDIVPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=2771, - XED_IFORM_VDIVPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=2772, - XED_IFORM_VDIVPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=2773, - XED_IFORM_VDIVPS_XMMdq_XMMdq_MEMdq=2774, - XED_IFORM_VDIVPS_XMMdq_XMMdq_XMMdq=2775, - XED_IFORM_VDIVPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2776, - XED_IFORM_VDIVPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2777, - XED_IFORM_VDIVPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2778, - XED_IFORM_VDIVPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2779, - XED_IFORM_VDIVPS_YMMqq_YMMqq_MEMqq=2780, - XED_IFORM_VDIVPS_YMMqq_YMMqq_YMMqq=2781, - XED_IFORM_VDIVPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2782, - XED_IFORM_VDIVPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2783, - XED_IFORM_VDIVSD_XMMdq_XMMdq_MEMq=2784, - XED_IFORM_VDIVSD_XMMdq_XMMdq_XMMq=2785, - XED_IFORM_VDIVSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2786, - XED_IFORM_VDIVSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2787, - XED_IFORM_VDIVSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=2788, - XED_IFORM_VDIVSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=2789, - XED_IFORM_VDIVSS_XMMdq_XMMdq_MEMd=2790, - XED_IFORM_VDIVSS_XMMdq_XMMdq_XMMd=2791, - XED_IFORM_VDIVSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2792, - XED_IFORM_VDIVSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2793, - XED_IFORM_VDPBF16PS_XMMf32_MASKmskw_XMMu32_MEMu32_AVX512=2794, - XED_IFORM_VDPBF16PS_XMMf32_MASKmskw_XMMu32_XMMu32_AVX512=2795, - XED_IFORM_VDPBF16PS_YMMf32_MASKmskw_YMMu32_MEMu32_AVX512=2796, - XED_IFORM_VDPBF16PS_YMMf32_MASKmskw_YMMu32_YMMu32_AVX512=2797, - XED_IFORM_VDPBF16PS_ZMMf32_MASKmskw_ZMMu32_MEMu32_AVX512=2798, - XED_IFORM_VDPBF16PS_ZMMf32_MASKmskw_ZMMu32_ZMMu32_AVX512=2799, - XED_IFORM_VDPPD_XMMdq_XMMdq_MEMdq_IMMb=2800, - XED_IFORM_VDPPD_XMMdq_XMMdq_XMMdq_IMMb=2801, - XED_IFORM_VDPPS_XMMdq_XMMdq_MEMdq_IMMb=2802, - XED_IFORM_VDPPS_XMMdq_XMMdq_XMMdq_IMMb=2803, - XED_IFORM_VDPPS_YMMqq_YMMqq_MEMqq_IMMb=2804, - XED_IFORM_VDPPS_YMMqq_YMMqq_YMMqq_IMMb=2805, - XED_IFORM_VERR_GPR16=2806, - XED_IFORM_VERR_MEMw=2807, - XED_IFORM_VERW_GPR16=2808, - XED_IFORM_VERW_MEMw=2809, - XED_IFORM_VEXP2PD_ZMMf64_MASKmskw_MEMf64_AVX512ER=2810, - XED_IFORM_VEXP2PD_ZMMf64_MASKmskw_ZMMf64_AVX512ER=2811, - XED_IFORM_VEXP2PS_ZMMf32_MASKmskw_MEMf32_AVX512ER=2812, - XED_IFORM_VEXP2PS_ZMMf32_MASKmskw_ZMMf32_AVX512ER=2813, - XED_IFORM_VEXPANDPD_XMMf64_MASKmskw_MEMf64_AVX512=2814, - XED_IFORM_VEXPANDPD_XMMf64_MASKmskw_XMMf64_AVX512=2815, - XED_IFORM_VEXPANDPD_YMMf64_MASKmskw_MEMf64_AVX512=2816, - XED_IFORM_VEXPANDPD_YMMf64_MASKmskw_YMMf64_AVX512=2817, - XED_IFORM_VEXPANDPD_ZMMf64_MASKmskw_MEMf64_AVX512=2818, - XED_IFORM_VEXPANDPD_ZMMf64_MASKmskw_ZMMf64_AVX512=2819, - XED_IFORM_VEXPANDPS_XMMf32_MASKmskw_MEMf32_AVX512=2820, - XED_IFORM_VEXPANDPS_XMMf32_MASKmskw_XMMf32_AVX512=2821, - XED_IFORM_VEXPANDPS_YMMf32_MASKmskw_MEMf32_AVX512=2822, - XED_IFORM_VEXPANDPS_YMMf32_MASKmskw_YMMf32_AVX512=2823, - XED_IFORM_VEXPANDPS_ZMMf32_MASKmskw_MEMf32_AVX512=2824, - XED_IFORM_VEXPANDPS_ZMMf32_MASKmskw_ZMMf32_AVX512=2825, - XED_IFORM_VEXTRACTF128_MEMdq_YMMdq_IMMb=2826, - XED_IFORM_VEXTRACTF128_XMMdq_YMMdq_IMMb=2827, - XED_IFORM_VEXTRACTF32X4_MEMf32_MASKmskw_YMMf32_IMM8_AVX512=2828, - XED_IFORM_VEXTRACTF32X4_MEMf32_MASKmskw_ZMMf32_IMM8_AVX512=2829, - XED_IFORM_VEXTRACTF32X4_XMMf32_MASKmskw_YMMf32_IMM8_AVX512=2830, - XED_IFORM_VEXTRACTF32X4_XMMf32_MASKmskw_ZMMf32_IMM8_AVX512=2831, - XED_IFORM_VEXTRACTF32X8_MEMf32_MASKmskw_ZMMf32_IMM8_AVX512=2832, - XED_IFORM_VEXTRACTF32X8_YMMf32_MASKmskw_ZMMf32_IMM8_AVX512=2833, - XED_IFORM_VEXTRACTF64X2_MEMf64_MASKmskw_YMMf64_IMM8_AVX512=2834, - XED_IFORM_VEXTRACTF64X2_MEMf64_MASKmskw_ZMMf64_IMM8_AVX512=2835, - XED_IFORM_VEXTRACTF64X2_XMMf64_MASKmskw_YMMf64_IMM8_AVX512=2836, - XED_IFORM_VEXTRACTF64X2_XMMf64_MASKmskw_ZMMf64_IMM8_AVX512=2837, - XED_IFORM_VEXTRACTF64X4_MEMf64_MASKmskw_ZMMf64_IMM8_AVX512=2838, - XED_IFORM_VEXTRACTF64X4_YMMf64_MASKmskw_ZMMf64_IMM8_AVX512=2839, - XED_IFORM_VEXTRACTI128_MEMdq_YMMqq_IMMb=2840, - XED_IFORM_VEXTRACTI128_XMMdq_YMMqq_IMMb=2841, - XED_IFORM_VEXTRACTI32X4_MEMu32_MASKmskw_YMMu32_IMM8_AVX512=2842, - XED_IFORM_VEXTRACTI32X4_MEMu32_MASKmskw_ZMMu32_IMM8_AVX512=2843, - XED_IFORM_VEXTRACTI32X4_XMMu32_MASKmskw_YMMu32_IMM8_AVX512=2844, - XED_IFORM_VEXTRACTI32X4_XMMu32_MASKmskw_ZMMu32_IMM8_AVX512=2845, - XED_IFORM_VEXTRACTI32X8_MEMu32_MASKmskw_ZMMu32_IMM8_AVX512=2846, - XED_IFORM_VEXTRACTI32X8_YMMu32_MASKmskw_ZMMu32_IMM8_AVX512=2847, - XED_IFORM_VEXTRACTI64X2_MEMu64_MASKmskw_YMMu64_IMM8_AVX512=2848, - XED_IFORM_VEXTRACTI64X2_MEMu64_MASKmskw_ZMMu64_IMM8_AVX512=2849, - XED_IFORM_VEXTRACTI64X2_XMMu64_MASKmskw_YMMu64_IMM8_AVX512=2850, - XED_IFORM_VEXTRACTI64X2_XMMu64_MASKmskw_ZMMu64_IMM8_AVX512=2851, - XED_IFORM_VEXTRACTI64X4_MEMu64_MASKmskw_ZMMu64_IMM8_AVX512=2852, - XED_IFORM_VEXTRACTI64X4_YMMu64_MASKmskw_ZMMu64_IMM8_AVX512=2853, - XED_IFORM_VEXTRACTPS_GPR32_XMMdq_IMMb=2854, - XED_IFORM_VEXTRACTPS_GPR32f32_XMMf32_IMM8_AVX512=2855, - XED_IFORM_VEXTRACTPS_MEMd_XMMdq_IMMb=2856, - XED_IFORM_VEXTRACTPS_MEMf32_XMMf32_IMM8_AVX512=2857, - XED_IFORM_VFCMADDCPH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512=2858, - XED_IFORM_VFCMADDCPH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512=2859, - XED_IFORM_VFCMADDCPH_YMM2f16_MASKmskw_YMM2f16_MEM2f16_AVX512=2860, - XED_IFORM_VFCMADDCPH_YMM2f16_MASKmskw_YMM2f16_YMM2f16_AVX512=2861, - XED_IFORM_VFCMADDCPH_ZMM2f16_MASKmskw_ZMM2f16_MEM2f16_AVX512=2862, - XED_IFORM_VFCMADDCPH_ZMM2f16_MASKmskw_ZMM2f16_ZMM2f16_AVX512=2863, - XED_IFORM_VFCMADDCSH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512=2864, - XED_IFORM_VFCMADDCSH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512=2865, - XED_IFORM_VFCMULCPH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512=2866, - XED_IFORM_VFCMULCPH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512=2867, - XED_IFORM_VFCMULCPH_YMM2f16_MASKmskw_YMM2f16_MEM2f16_AVX512=2868, - XED_IFORM_VFCMULCPH_YMM2f16_MASKmskw_YMM2f16_YMM2f16_AVX512=2869, - XED_IFORM_VFCMULCPH_ZMM2f16_MASKmskw_ZMM2f16_MEM2f16_AVX512=2870, - XED_IFORM_VFCMULCPH_ZMM2f16_MASKmskw_ZMM2f16_ZMM2f16_AVX512=2871, - XED_IFORM_VFCMULCSH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512=2872, - XED_IFORM_VFCMULCSH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512=2873, - XED_IFORM_VFIXUPIMMPD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=2874, - XED_IFORM_VFIXUPIMMPD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=2875, - XED_IFORM_VFIXUPIMMPD_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=2876, - XED_IFORM_VFIXUPIMMPD_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512=2877, - XED_IFORM_VFIXUPIMMPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=2878, - XED_IFORM_VFIXUPIMMPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512=2879, - XED_IFORM_VFIXUPIMMPS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=2880, - XED_IFORM_VFIXUPIMMPS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=2881, - XED_IFORM_VFIXUPIMMPS_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=2882, - XED_IFORM_VFIXUPIMMPS_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512=2883, - XED_IFORM_VFIXUPIMMPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=2884, - XED_IFORM_VFIXUPIMMPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512=2885, - XED_IFORM_VFIXUPIMMSD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=2886, - XED_IFORM_VFIXUPIMMSD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=2887, - XED_IFORM_VFIXUPIMMSS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=2888, - XED_IFORM_VFIXUPIMMSS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=2889, - XED_IFORM_VFMADD132PD_XMMdq_XMMdq_MEMdq=2890, - XED_IFORM_VFMADD132PD_XMMdq_XMMdq_XMMdq=2891, - XED_IFORM_VFMADD132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2892, - XED_IFORM_VFMADD132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2893, - XED_IFORM_VFMADD132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2894, - XED_IFORM_VFMADD132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2895, - XED_IFORM_VFMADD132PD_YMMqq_YMMqq_MEMqq=2896, - XED_IFORM_VFMADD132PD_YMMqq_YMMqq_YMMqq=2897, - XED_IFORM_VFMADD132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2898, - XED_IFORM_VFMADD132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2899, - XED_IFORM_VFMADD132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=2900, - XED_IFORM_VFMADD132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=2901, - XED_IFORM_VFMADD132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=2902, - XED_IFORM_VFMADD132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=2903, - XED_IFORM_VFMADD132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=2904, - XED_IFORM_VFMADD132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=2905, - XED_IFORM_VFMADD132PS_XMMdq_XMMdq_MEMdq=2906, - XED_IFORM_VFMADD132PS_XMMdq_XMMdq_XMMdq=2907, - XED_IFORM_VFMADD132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2908, - XED_IFORM_VFMADD132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2909, - XED_IFORM_VFMADD132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2910, - XED_IFORM_VFMADD132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2911, - XED_IFORM_VFMADD132PS_YMMqq_YMMqq_MEMqq=2912, - XED_IFORM_VFMADD132PS_YMMqq_YMMqq_YMMqq=2913, - XED_IFORM_VFMADD132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2914, - XED_IFORM_VFMADD132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2915, - XED_IFORM_VFMADD132SD_XMMdq_XMMq_MEMq=2916, - XED_IFORM_VFMADD132SD_XMMdq_XMMq_XMMq=2917, - XED_IFORM_VFMADD132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2918, - XED_IFORM_VFMADD132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2919, - XED_IFORM_VFMADD132SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=2920, - XED_IFORM_VFMADD132SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=2921, - XED_IFORM_VFMADD132SS_XMMdq_XMMd_MEMd=2922, - XED_IFORM_VFMADD132SS_XMMdq_XMMd_XMMd=2923, - XED_IFORM_VFMADD132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2924, - XED_IFORM_VFMADD132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2925, - XED_IFORM_VFMADD213PD_XMMdq_XMMdq_MEMdq=2926, - XED_IFORM_VFMADD213PD_XMMdq_XMMdq_XMMdq=2927, - XED_IFORM_VFMADD213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2928, - XED_IFORM_VFMADD213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2929, - XED_IFORM_VFMADD213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2930, - XED_IFORM_VFMADD213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2931, - XED_IFORM_VFMADD213PD_YMMqq_YMMqq_MEMqq=2932, - XED_IFORM_VFMADD213PD_YMMqq_YMMqq_YMMqq=2933, - XED_IFORM_VFMADD213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2934, - XED_IFORM_VFMADD213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2935, - XED_IFORM_VFMADD213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=2936, - XED_IFORM_VFMADD213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=2937, - XED_IFORM_VFMADD213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=2938, - XED_IFORM_VFMADD213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=2939, - XED_IFORM_VFMADD213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=2940, - XED_IFORM_VFMADD213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=2941, - XED_IFORM_VFMADD213PS_XMMdq_XMMdq_MEMdq=2942, - XED_IFORM_VFMADD213PS_XMMdq_XMMdq_XMMdq=2943, - XED_IFORM_VFMADD213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2944, - XED_IFORM_VFMADD213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2945, - XED_IFORM_VFMADD213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2946, - XED_IFORM_VFMADD213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2947, - XED_IFORM_VFMADD213PS_YMMqq_YMMqq_MEMqq=2948, - XED_IFORM_VFMADD213PS_YMMqq_YMMqq_YMMqq=2949, - XED_IFORM_VFMADD213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2950, - XED_IFORM_VFMADD213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2951, - XED_IFORM_VFMADD213SD_XMMdq_XMMq_MEMq=2952, - XED_IFORM_VFMADD213SD_XMMdq_XMMq_XMMq=2953, - XED_IFORM_VFMADD213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2954, - XED_IFORM_VFMADD213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2955, - XED_IFORM_VFMADD213SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=2956, - XED_IFORM_VFMADD213SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=2957, - XED_IFORM_VFMADD213SS_XMMdq_XMMd_MEMd=2958, - XED_IFORM_VFMADD213SS_XMMdq_XMMd_XMMd=2959, - XED_IFORM_VFMADD213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2960, - XED_IFORM_VFMADD213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2961, - XED_IFORM_VFMADD231PD_XMMdq_XMMdq_MEMdq=2962, - XED_IFORM_VFMADD231PD_XMMdq_XMMdq_XMMdq=2963, - XED_IFORM_VFMADD231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2964, - XED_IFORM_VFMADD231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2965, - XED_IFORM_VFMADD231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=2966, - XED_IFORM_VFMADD231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=2967, - XED_IFORM_VFMADD231PD_YMMqq_YMMqq_MEMqq=2968, - XED_IFORM_VFMADD231PD_YMMqq_YMMqq_YMMqq=2969, - XED_IFORM_VFMADD231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=2970, - XED_IFORM_VFMADD231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=2971, - XED_IFORM_VFMADD231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=2972, - XED_IFORM_VFMADD231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=2973, - XED_IFORM_VFMADD231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=2974, - XED_IFORM_VFMADD231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=2975, - XED_IFORM_VFMADD231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=2976, - XED_IFORM_VFMADD231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=2977, - XED_IFORM_VFMADD231PS_XMMdq_XMMdq_MEMdq=2978, - XED_IFORM_VFMADD231PS_XMMdq_XMMdq_XMMdq=2979, - XED_IFORM_VFMADD231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2980, - XED_IFORM_VFMADD231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2981, - XED_IFORM_VFMADD231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=2982, - XED_IFORM_VFMADD231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=2983, - XED_IFORM_VFMADD231PS_YMMqq_YMMqq_MEMqq=2984, - XED_IFORM_VFMADD231PS_YMMqq_YMMqq_YMMqq=2985, - XED_IFORM_VFMADD231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=2986, - XED_IFORM_VFMADD231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=2987, - XED_IFORM_VFMADD231SD_XMMdq_XMMq_MEMq=2988, - XED_IFORM_VFMADD231SD_XMMdq_XMMq_XMMq=2989, - XED_IFORM_VFMADD231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=2990, - XED_IFORM_VFMADD231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=2991, - XED_IFORM_VFMADD231SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=2992, - XED_IFORM_VFMADD231SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=2993, - XED_IFORM_VFMADD231SS_XMMdq_XMMd_MEMd=2994, - XED_IFORM_VFMADD231SS_XMMdq_XMMd_XMMd=2995, - XED_IFORM_VFMADD231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=2996, - XED_IFORM_VFMADD231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=2997, - XED_IFORM_VFMADDCPH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512=2998, - XED_IFORM_VFMADDCPH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512=2999, - XED_IFORM_VFMADDCPH_YMM2f16_MASKmskw_YMM2f16_MEM2f16_AVX512=3000, - XED_IFORM_VFMADDCPH_YMM2f16_MASKmskw_YMM2f16_YMM2f16_AVX512=3001, - XED_IFORM_VFMADDCPH_ZMM2f16_MASKmskw_ZMM2f16_MEM2f16_AVX512=3002, - XED_IFORM_VFMADDCPH_ZMM2f16_MASKmskw_ZMM2f16_ZMM2f16_AVX512=3003, - XED_IFORM_VFMADDCSH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512=3004, - XED_IFORM_VFMADDCSH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512=3005, - XED_IFORM_VFMADDPD_XMMdq_XMMdq_MEMdq_XMMdq=3006, - XED_IFORM_VFMADDPD_XMMdq_XMMdq_XMMdq_MEMdq=3007, - XED_IFORM_VFMADDPD_XMMdq_XMMdq_XMMdq_XMMdq=3008, - XED_IFORM_VFMADDPD_YMMqq_YMMqq_MEMqq_YMMqq=3009, - XED_IFORM_VFMADDPD_YMMqq_YMMqq_YMMqq_MEMqq=3010, - XED_IFORM_VFMADDPD_YMMqq_YMMqq_YMMqq_YMMqq=3011, - XED_IFORM_VFMADDPS_XMMdq_XMMdq_MEMdq_XMMdq=3012, - XED_IFORM_VFMADDPS_XMMdq_XMMdq_XMMdq_MEMdq=3013, - XED_IFORM_VFMADDPS_XMMdq_XMMdq_XMMdq_XMMdq=3014, - XED_IFORM_VFMADDPS_YMMqq_YMMqq_MEMqq_YMMqq=3015, - XED_IFORM_VFMADDPS_YMMqq_YMMqq_YMMqq_MEMqq=3016, - XED_IFORM_VFMADDPS_YMMqq_YMMqq_YMMqq_YMMqq=3017, - XED_IFORM_VFMADDSD_XMMdq_XMMq_MEMq_XMMq=3018, - XED_IFORM_VFMADDSD_XMMdq_XMMq_XMMq_MEMq=3019, - XED_IFORM_VFMADDSD_XMMdq_XMMq_XMMq_XMMq=3020, - XED_IFORM_VFMADDSS_XMMdq_XMMd_MEMd_XMMd=3021, - XED_IFORM_VFMADDSS_XMMdq_XMMd_XMMd_MEMd=3022, - XED_IFORM_VFMADDSS_XMMdq_XMMd_XMMd_XMMd=3023, - XED_IFORM_VFMADDSUB132PD_XMMdq_XMMdq_MEMdq=3024, - XED_IFORM_VFMADDSUB132PD_XMMdq_XMMdq_XMMdq=3025, - XED_IFORM_VFMADDSUB132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3026, - XED_IFORM_VFMADDSUB132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3027, - XED_IFORM_VFMADDSUB132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3028, - XED_IFORM_VFMADDSUB132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3029, - XED_IFORM_VFMADDSUB132PD_YMMqq_YMMqq_MEMqq=3030, - XED_IFORM_VFMADDSUB132PD_YMMqq_YMMqq_YMMqq=3031, - XED_IFORM_VFMADDSUB132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3032, - XED_IFORM_VFMADDSUB132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3033, - XED_IFORM_VFMADDSUB132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3034, - XED_IFORM_VFMADDSUB132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3035, - XED_IFORM_VFMADDSUB132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3036, - XED_IFORM_VFMADDSUB132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3037, - XED_IFORM_VFMADDSUB132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3038, - XED_IFORM_VFMADDSUB132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3039, - XED_IFORM_VFMADDSUB132PS_XMMdq_XMMdq_MEMdq=3040, - XED_IFORM_VFMADDSUB132PS_XMMdq_XMMdq_XMMdq=3041, - XED_IFORM_VFMADDSUB132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3042, - XED_IFORM_VFMADDSUB132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3043, - XED_IFORM_VFMADDSUB132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3044, - XED_IFORM_VFMADDSUB132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3045, - XED_IFORM_VFMADDSUB132PS_YMMqq_YMMqq_MEMqq=3046, - XED_IFORM_VFMADDSUB132PS_YMMqq_YMMqq_YMMqq=3047, - XED_IFORM_VFMADDSUB132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3048, - XED_IFORM_VFMADDSUB132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3049, - XED_IFORM_VFMADDSUB213PD_XMMdq_XMMdq_MEMdq=3050, - XED_IFORM_VFMADDSUB213PD_XMMdq_XMMdq_XMMdq=3051, - XED_IFORM_VFMADDSUB213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3052, - XED_IFORM_VFMADDSUB213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3053, - XED_IFORM_VFMADDSUB213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3054, - XED_IFORM_VFMADDSUB213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3055, - XED_IFORM_VFMADDSUB213PD_YMMqq_YMMqq_MEMqq=3056, - XED_IFORM_VFMADDSUB213PD_YMMqq_YMMqq_YMMqq=3057, - XED_IFORM_VFMADDSUB213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3058, - XED_IFORM_VFMADDSUB213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3059, - XED_IFORM_VFMADDSUB213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3060, - XED_IFORM_VFMADDSUB213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3061, - XED_IFORM_VFMADDSUB213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3062, - XED_IFORM_VFMADDSUB213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3063, - XED_IFORM_VFMADDSUB213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3064, - XED_IFORM_VFMADDSUB213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3065, - XED_IFORM_VFMADDSUB213PS_XMMdq_XMMdq_MEMdq=3066, - XED_IFORM_VFMADDSUB213PS_XMMdq_XMMdq_XMMdq=3067, - XED_IFORM_VFMADDSUB213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3068, - XED_IFORM_VFMADDSUB213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3069, - XED_IFORM_VFMADDSUB213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3070, - XED_IFORM_VFMADDSUB213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3071, - XED_IFORM_VFMADDSUB213PS_YMMqq_YMMqq_MEMqq=3072, - XED_IFORM_VFMADDSUB213PS_YMMqq_YMMqq_YMMqq=3073, - XED_IFORM_VFMADDSUB213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3074, - XED_IFORM_VFMADDSUB213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3075, - XED_IFORM_VFMADDSUB231PD_XMMdq_XMMdq_MEMdq=3076, - XED_IFORM_VFMADDSUB231PD_XMMdq_XMMdq_XMMdq=3077, - XED_IFORM_VFMADDSUB231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3078, - XED_IFORM_VFMADDSUB231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3079, - XED_IFORM_VFMADDSUB231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3080, - XED_IFORM_VFMADDSUB231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3081, - XED_IFORM_VFMADDSUB231PD_YMMqq_YMMqq_MEMqq=3082, - XED_IFORM_VFMADDSUB231PD_YMMqq_YMMqq_YMMqq=3083, - XED_IFORM_VFMADDSUB231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3084, - XED_IFORM_VFMADDSUB231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3085, - XED_IFORM_VFMADDSUB231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3086, - XED_IFORM_VFMADDSUB231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3087, - XED_IFORM_VFMADDSUB231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3088, - XED_IFORM_VFMADDSUB231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3089, - XED_IFORM_VFMADDSUB231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3090, - XED_IFORM_VFMADDSUB231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3091, - XED_IFORM_VFMADDSUB231PS_XMMdq_XMMdq_MEMdq=3092, - XED_IFORM_VFMADDSUB231PS_XMMdq_XMMdq_XMMdq=3093, - XED_IFORM_VFMADDSUB231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3094, - XED_IFORM_VFMADDSUB231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3095, - XED_IFORM_VFMADDSUB231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3096, - XED_IFORM_VFMADDSUB231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3097, - XED_IFORM_VFMADDSUB231PS_YMMqq_YMMqq_MEMqq=3098, - XED_IFORM_VFMADDSUB231PS_YMMqq_YMMqq_YMMqq=3099, - XED_IFORM_VFMADDSUB231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3100, - XED_IFORM_VFMADDSUB231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3101, - XED_IFORM_VFMADDSUBPD_XMMdq_XMMdq_MEMdq_XMMdq=3102, - XED_IFORM_VFMADDSUBPD_XMMdq_XMMdq_XMMdq_MEMdq=3103, - XED_IFORM_VFMADDSUBPD_XMMdq_XMMdq_XMMdq_XMMdq=3104, - XED_IFORM_VFMADDSUBPD_YMMqq_YMMqq_MEMqq_YMMqq=3105, - XED_IFORM_VFMADDSUBPD_YMMqq_YMMqq_YMMqq_MEMqq=3106, - XED_IFORM_VFMADDSUBPD_YMMqq_YMMqq_YMMqq_YMMqq=3107, - XED_IFORM_VFMADDSUBPS_XMMdq_XMMdq_MEMdq_XMMdq=3108, - XED_IFORM_VFMADDSUBPS_XMMdq_XMMdq_XMMdq_MEMdq=3109, - XED_IFORM_VFMADDSUBPS_XMMdq_XMMdq_XMMdq_XMMdq=3110, - XED_IFORM_VFMADDSUBPS_YMMqq_YMMqq_MEMqq_YMMqq=3111, - XED_IFORM_VFMADDSUBPS_YMMqq_YMMqq_YMMqq_MEMqq=3112, - XED_IFORM_VFMADDSUBPS_YMMqq_YMMqq_YMMqq_YMMqq=3113, - XED_IFORM_VFMSUB132PD_XMMdq_XMMdq_MEMdq=3114, - XED_IFORM_VFMSUB132PD_XMMdq_XMMdq_XMMdq=3115, - XED_IFORM_VFMSUB132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3116, - XED_IFORM_VFMSUB132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3117, - XED_IFORM_VFMSUB132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3118, - XED_IFORM_VFMSUB132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3119, - XED_IFORM_VFMSUB132PD_YMMqq_YMMqq_MEMqq=3120, - XED_IFORM_VFMSUB132PD_YMMqq_YMMqq_YMMqq=3121, - XED_IFORM_VFMSUB132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3122, - XED_IFORM_VFMSUB132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3123, - XED_IFORM_VFMSUB132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3124, - XED_IFORM_VFMSUB132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3125, - XED_IFORM_VFMSUB132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3126, - XED_IFORM_VFMSUB132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3127, - XED_IFORM_VFMSUB132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3128, - XED_IFORM_VFMSUB132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3129, - XED_IFORM_VFMSUB132PS_XMMdq_XMMdq_MEMdq=3130, - XED_IFORM_VFMSUB132PS_XMMdq_XMMdq_XMMdq=3131, - XED_IFORM_VFMSUB132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3132, - XED_IFORM_VFMSUB132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3133, - XED_IFORM_VFMSUB132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3134, - XED_IFORM_VFMSUB132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3135, - XED_IFORM_VFMSUB132PS_YMMqq_YMMqq_MEMqq=3136, - XED_IFORM_VFMSUB132PS_YMMqq_YMMqq_YMMqq=3137, - XED_IFORM_VFMSUB132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3138, - XED_IFORM_VFMSUB132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3139, - XED_IFORM_VFMSUB132SD_XMMdq_XMMq_MEMq=3140, - XED_IFORM_VFMSUB132SD_XMMdq_XMMq_XMMq=3141, - XED_IFORM_VFMSUB132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3142, - XED_IFORM_VFMSUB132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3143, - XED_IFORM_VFMSUB132SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3144, - XED_IFORM_VFMSUB132SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3145, - XED_IFORM_VFMSUB132SS_XMMdq_XMMd_MEMd=3146, - XED_IFORM_VFMSUB132SS_XMMdq_XMMd_XMMd=3147, - XED_IFORM_VFMSUB132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3148, - XED_IFORM_VFMSUB132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3149, - XED_IFORM_VFMSUB213PD_XMMdq_XMMdq_MEMdq=3150, - XED_IFORM_VFMSUB213PD_XMMdq_XMMdq_XMMdq=3151, - XED_IFORM_VFMSUB213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3152, - XED_IFORM_VFMSUB213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3153, - XED_IFORM_VFMSUB213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3154, - XED_IFORM_VFMSUB213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3155, - XED_IFORM_VFMSUB213PD_YMMqq_YMMqq_MEMqq=3156, - XED_IFORM_VFMSUB213PD_YMMqq_YMMqq_YMMqq=3157, - XED_IFORM_VFMSUB213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3158, - XED_IFORM_VFMSUB213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3159, - XED_IFORM_VFMSUB213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3160, - XED_IFORM_VFMSUB213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3161, - XED_IFORM_VFMSUB213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3162, - XED_IFORM_VFMSUB213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3163, - XED_IFORM_VFMSUB213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3164, - XED_IFORM_VFMSUB213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3165, - XED_IFORM_VFMSUB213PS_XMMdq_XMMdq_MEMdq=3166, - XED_IFORM_VFMSUB213PS_XMMdq_XMMdq_XMMdq=3167, - XED_IFORM_VFMSUB213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3168, - XED_IFORM_VFMSUB213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3169, - XED_IFORM_VFMSUB213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3170, - XED_IFORM_VFMSUB213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3171, - XED_IFORM_VFMSUB213PS_YMMqq_YMMqq_MEMqq=3172, - XED_IFORM_VFMSUB213PS_YMMqq_YMMqq_YMMqq=3173, - XED_IFORM_VFMSUB213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3174, - XED_IFORM_VFMSUB213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3175, - XED_IFORM_VFMSUB213SD_XMMdq_XMMq_MEMq=3176, - XED_IFORM_VFMSUB213SD_XMMdq_XMMq_XMMq=3177, - XED_IFORM_VFMSUB213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3178, - XED_IFORM_VFMSUB213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3179, - XED_IFORM_VFMSUB213SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3180, - XED_IFORM_VFMSUB213SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3181, - XED_IFORM_VFMSUB213SS_XMMdq_XMMd_MEMd=3182, - XED_IFORM_VFMSUB213SS_XMMdq_XMMd_XMMd=3183, - XED_IFORM_VFMSUB213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3184, - XED_IFORM_VFMSUB213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3185, - XED_IFORM_VFMSUB231PD_XMMdq_XMMdq_MEMdq=3186, - XED_IFORM_VFMSUB231PD_XMMdq_XMMdq_XMMdq=3187, - XED_IFORM_VFMSUB231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3188, - XED_IFORM_VFMSUB231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3189, - XED_IFORM_VFMSUB231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3190, - XED_IFORM_VFMSUB231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3191, - XED_IFORM_VFMSUB231PD_YMMqq_YMMqq_MEMqq=3192, - XED_IFORM_VFMSUB231PD_YMMqq_YMMqq_YMMqq=3193, - XED_IFORM_VFMSUB231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3194, - XED_IFORM_VFMSUB231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3195, - XED_IFORM_VFMSUB231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3196, - XED_IFORM_VFMSUB231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3197, - XED_IFORM_VFMSUB231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3198, - XED_IFORM_VFMSUB231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3199, - XED_IFORM_VFMSUB231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3200, - XED_IFORM_VFMSUB231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3201, - XED_IFORM_VFMSUB231PS_XMMdq_XMMdq_MEMdq=3202, - XED_IFORM_VFMSUB231PS_XMMdq_XMMdq_XMMdq=3203, - XED_IFORM_VFMSUB231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3204, - XED_IFORM_VFMSUB231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3205, - XED_IFORM_VFMSUB231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3206, - XED_IFORM_VFMSUB231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3207, - XED_IFORM_VFMSUB231PS_YMMqq_YMMqq_MEMqq=3208, - XED_IFORM_VFMSUB231PS_YMMqq_YMMqq_YMMqq=3209, - XED_IFORM_VFMSUB231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3210, - XED_IFORM_VFMSUB231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3211, - XED_IFORM_VFMSUB231SD_XMMdq_XMMq_MEMq=3212, - XED_IFORM_VFMSUB231SD_XMMdq_XMMq_XMMq=3213, - XED_IFORM_VFMSUB231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3214, - XED_IFORM_VFMSUB231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3215, - XED_IFORM_VFMSUB231SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3216, - XED_IFORM_VFMSUB231SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3217, - XED_IFORM_VFMSUB231SS_XMMdq_XMMd_MEMd=3218, - XED_IFORM_VFMSUB231SS_XMMdq_XMMd_XMMd=3219, - XED_IFORM_VFMSUB231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3220, - XED_IFORM_VFMSUB231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3221, - XED_IFORM_VFMSUBADD132PD_XMMdq_XMMdq_MEMdq=3222, - XED_IFORM_VFMSUBADD132PD_XMMdq_XMMdq_XMMdq=3223, - XED_IFORM_VFMSUBADD132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3224, - XED_IFORM_VFMSUBADD132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3225, - XED_IFORM_VFMSUBADD132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3226, - XED_IFORM_VFMSUBADD132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3227, - XED_IFORM_VFMSUBADD132PD_YMMqq_YMMqq_MEMqq=3228, - XED_IFORM_VFMSUBADD132PD_YMMqq_YMMqq_YMMqq=3229, - XED_IFORM_VFMSUBADD132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3230, - XED_IFORM_VFMSUBADD132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3231, - XED_IFORM_VFMSUBADD132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3232, - XED_IFORM_VFMSUBADD132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3233, - XED_IFORM_VFMSUBADD132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3234, - XED_IFORM_VFMSUBADD132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3235, - XED_IFORM_VFMSUBADD132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3236, - XED_IFORM_VFMSUBADD132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3237, - XED_IFORM_VFMSUBADD132PS_XMMdq_XMMdq_MEMdq=3238, - XED_IFORM_VFMSUBADD132PS_XMMdq_XMMdq_XMMdq=3239, - XED_IFORM_VFMSUBADD132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3240, - XED_IFORM_VFMSUBADD132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3241, - XED_IFORM_VFMSUBADD132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3242, - XED_IFORM_VFMSUBADD132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3243, - XED_IFORM_VFMSUBADD132PS_YMMqq_YMMqq_MEMqq=3244, - XED_IFORM_VFMSUBADD132PS_YMMqq_YMMqq_YMMqq=3245, - XED_IFORM_VFMSUBADD132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3246, - XED_IFORM_VFMSUBADD132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3247, - XED_IFORM_VFMSUBADD213PD_XMMdq_XMMdq_MEMdq=3248, - XED_IFORM_VFMSUBADD213PD_XMMdq_XMMdq_XMMdq=3249, - XED_IFORM_VFMSUBADD213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3250, - XED_IFORM_VFMSUBADD213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3251, - XED_IFORM_VFMSUBADD213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3252, - XED_IFORM_VFMSUBADD213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3253, - XED_IFORM_VFMSUBADD213PD_YMMqq_YMMqq_MEMqq=3254, - XED_IFORM_VFMSUBADD213PD_YMMqq_YMMqq_YMMqq=3255, - XED_IFORM_VFMSUBADD213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3256, - XED_IFORM_VFMSUBADD213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3257, - XED_IFORM_VFMSUBADD213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3258, - XED_IFORM_VFMSUBADD213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3259, - XED_IFORM_VFMSUBADD213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3260, - XED_IFORM_VFMSUBADD213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3261, - XED_IFORM_VFMSUBADD213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3262, - XED_IFORM_VFMSUBADD213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3263, - XED_IFORM_VFMSUBADD213PS_XMMdq_XMMdq_MEMdq=3264, - XED_IFORM_VFMSUBADD213PS_XMMdq_XMMdq_XMMdq=3265, - XED_IFORM_VFMSUBADD213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3266, - XED_IFORM_VFMSUBADD213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3267, - XED_IFORM_VFMSUBADD213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3268, - XED_IFORM_VFMSUBADD213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3269, - XED_IFORM_VFMSUBADD213PS_YMMqq_YMMqq_MEMqq=3270, - XED_IFORM_VFMSUBADD213PS_YMMqq_YMMqq_YMMqq=3271, - XED_IFORM_VFMSUBADD213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3272, - XED_IFORM_VFMSUBADD213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3273, - XED_IFORM_VFMSUBADD231PD_XMMdq_XMMdq_MEMdq=3274, - XED_IFORM_VFMSUBADD231PD_XMMdq_XMMdq_XMMdq=3275, - XED_IFORM_VFMSUBADD231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3276, - XED_IFORM_VFMSUBADD231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3277, - XED_IFORM_VFMSUBADD231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3278, - XED_IFORM_VFMSUBADD231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3279, - XED_IFORM_VFMSUBADD231PD_YMMqq_YMMqq_MEMqq=3280, - XED_IFORM_VFMSUBADD231PD_YMMqq_YMMqq_YMMqq=3281, - XED_IFORM_VFMSUBADD231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3282, - XED_IFORM_VFMSUBADD231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3283, - XED_IFORM_VFMSUBADD231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3284, - XED_IFORM_VFMSUBADD231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3285, - XED_IFORM_VFMSUBADD231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3286, - XED_IFORM_VFMSUBADD231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3287, - XED_IFORM_VFMSUBADD231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3288, - XED_IFORM_VFMSUBADD231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3289, - XED_IFORM_VFMSUBADD231PS_XMMdq_XMMdq_MEMdq=3290, - XED_IFORM_VFMSUBADD231PS_XMMdq_XMMdq_XMMdq=3291, - XED_IFORM_VFMSUBADD231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3292, - XED_IFORM_VFMSUBADD231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3293, - XED_IFORM_VFMSUBADD231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3294, - XED_IFORM_VFMSUBADD231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3295, - XED_IFORM_VFMSUBADD231PS_YMMqq_YMMqq_MEMqq=3296, - XED_IFORM_VFMSUBADD231PS_YMMqq_YMMqq_YMMqq=3297, - XED_IFORM_VFMSUBADD231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3298, - XED_IFORM_VFMSUBADD231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3299, - XED_IFORM_VFMSUBADDPD_XMMdq_XMMdq_MEMdq_XMMdq=3300, - XED_IFORM_VFMSUBADDPD_XMMdq_XMMdq_XMMdq_MEMdq=3301, - XED_IFORM_VFMSUBADDPD_XMMdq_XMMdq_XMMdq_XMMdq=3302, - XED_IFORM_VFMSUBADDPD_YMMqq_YMMqq_MEMqq_YMMqq=3303, - XED_IFORM_VFMSUBADDPD_YMMqq_YMMqq_YMMqq_MEMqq=3304, - XED_IFORM_VFMSUBADDPD_YMMqq_YMMqq_YMMqq_YMMqq=3305, - XED_IFORM_VFMSUBADDPS_XMMdq_XMMdq_MEMdq_XMMdq=3306, - XED_IFORM_VFMSUBADDPS_XMMdq_XMMdq_XMMdq_MEMdq=3307, - XED_IFORM_VFMSUBADDPS_XMMdq_XMMdq_XMMdq_XMMdq=3308, - XED_IFORM_VFMSUBADDPS_YMMqq_YMMqq_MEMqq_YMMqq=3309, - XED_IFORM_VFMSUBADDPS_YMMqq_YMMqq_YMMqq_MEMqq=3310, - XED_IFORM_VFMSUBADDPS_YMMqq_YMMqq_YMMqq_YMMqq=3311, - XED_IFORM_VFMSUBPD_XMMdq_XMMdq_MEMdq_XMMdq=3312, - XED_IFORM_VFMSUBPD_XMMdq_XMMdq_XMMdq_MEMdq=3313, - XED_IFORM_VFMSUBPD_XMMdq_XMMdq_XMMdq_XMMdq=3314, - XED_IFORM_VFMSUBPD_YMMqq_YMMqq_MEMqq_YMMqq=3315, - XED_IFORM_VFMSUBPD_YMMqq_YMMqq_YMMqq_MEMqq=3316, - XED_IFORM_VFMSUBPD_YMMqq_YMMqq_YMMqq_YMMqq=3317, - XED_IFORM_VFMSUBPS_XMMdq_XMMdq_MEMdq_XMMdq=3318, - XED_IFORM_VFMSUBPS_XMMdq_XMMdq_XMMdq_MEMdq=3319, - XED_IFORM_VFMSUBPS_XMMdq_XMMdq_XMMdq_XMMdq=3320, - XED_IFORM_VFMSUBPS_YMMqq_YMMqq_MEMqq_YMMqq=3321, - XED_IFORM_VFMSUBPS_YMMqq_YMMqq_YMMqq_MEMqq=3322, - XED_IFORM_VFMSUBPS_YMMqq_YMMqq_YMMqq_YMMqq=3323, - XED_IFORM_VFMSUBSD_XMMdq_XMMq_MEMq_XMMq=3324, - XED_IFORM_VFMSUBSD_XMMdq_XMMq_XMMq_MEMq=3325, - XED_IFORM_VFMSUBSD_XMMdq_XMMq_XMMq_XMMq=3326, - XED_IFORM_VFMSUBSS_XMMdq_XMMd_MEMd_XMMd=3327, - XED_IFORM_VFMSUBSS_XMMdq_XMMd_XMMd_MEMd=3328, - XED_IFORM_VFMSUBSS_XMMdq_XMMd_XMMd_XMMd=3329, - XED_IFORM_VFMULCPH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512=3330, - XED_IFORM_VFMULCPH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512=3331, - XED_IFORM_VFMULCPH_YMM2f16_MASKmskw_YMM2f16_MEM2f16_AVX512=3332, - XED_IFORM_VFMULCPH_YMM2f16_MASKmskw_YMM2f16_YMM2f16_AVX512=3333, - XED_IFORM_VFMULCPH_ZMM2f16_MASKmskw_ZMM2f16_MEM2f16_AVX512=3334, - XED_IFORM_VFMULCPH_ZMM2f16_MASKmskw_ZMM2f16_ZMM2f16_AVX512=3335, - XED_IFORM_VFMULCSH_XMM2f16_MASKmskw_XMM2f16_MEM2f16_AVX512=3336, - XED_IFORM_VFMULCSH_XMM2f16_MASKmskw_XMM2f16_XMM2f16_AVX512=3337, - XED_IFORM_VFNMADD132PD_XMMdq_XMMdq_MEMdq=3338, - XED_IFORM_VFNMADD132PD_XMMdq_XMMdq_XMMdq=3339, - XED_IFORM_VFNMADD132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3340, - XED_IFORM_VFNMADD132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3341, - XED_IFORM_VFNMADD132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3342, - XED_IFORM_VFNMADD132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3343, - XED_IFORM_VFNMADD132PD_YMMqq_YMMqq_MEMqq=3344, - XED_IFORM_VFNMADD132PD_YMMqq_YMMqq_YMMqq=3345, - XED_IFORM_VFNMADD132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3346, - XED_IFORM_VFNMADD132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3347, - XED_IFORM_VFNMADD132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3348, - XED_IFORM_VFNMADD132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3349, - XED_IFORM_VFNMADD132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3350, - XED_IFORM_VFNMADD132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3351, - XED_IFORM_VFNMADD132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3352, - XED_IFORM_VFNMADD132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3353, - XED_IFORM_VFNMADD132PS_XMMdq_XMMdq_MEMdq=3354, - XED_IFORM_VFNMADD132PS_XMMdq_XMMdq_XMMdq=3355, - XED_IFORM_VFNMADD132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3356, - XED_IFORM_VFNMADD132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3357, - XED_IFORM_VFNMADD132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3358, - XED_IFORM_VFNMADD132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3359, - XED_IFORM_VFNMADD132PS_YMMqq_YMMqq_MEMqq=3360, - XED_IFORM_VFNMADD132PS_YMMqq_YMMqq_YMMqq=3361, - XED_IFORM_VFNMADD132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3362, - XED_IFORM_VFNMADD132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3363, - XED_IFORM_VFNMADD132SD_XMMdq_XMMq_MEMq=3364, - XED_IFORM_VFNMADD132SD_XMMdq_XMMq_XMMq=3365, - XED_IFORM_VFNMADD132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3366, - XED_IFORM_VFNMADD132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3367, - XED_IFORM_VFNMADD132SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3368, - XED_IFORM_VFNMADD132SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3369, - XED_IFORM_VFNMADD132SS_XMMdq_XMMd_MEMd=3370, - XED_IFORM_VFNMADD132SS_XMMdq_XMMd_XMMd=3371, - XED_IFORM_VFNMADD132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3372, - XED_IFORM_VFNMADD132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3373, - XED_IFORM_VFNMADD213PD_XMMdq_XMMdq_MEMdq=3374, - XED_IFORM_VFNMADD213PD_XMMdq_XMMdq_XMMdq=3375, - XED_IFORM_VFNMADD213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3376, - XED_IFORM_VFNMADD213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3377, - XED_IFORM_VFNMADD213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3378, - XED_IFORM_VFNMADD213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3379, - XED_IFORM_VFNMADD213PD_YMMqq_YMMqq_MEMqq=3380, - XED_IFORM_VFNMADD213PD_YMMqq_YMMqq_YMMqq=3381, - XED_IFORM_VFNMADD213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3382, - XED_IFORM_VFNMADD213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3383, - XED_IFORM_VFNMADD213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3384, - XED_IFORM_VFNMADD213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3385, - XED_IFORM_VFNMADD213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3386, - XED_IFORM_VFNMADD213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3387, - XED_IFORM_VFNMADD213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3388, - XED_IFORM_VFNMADD213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3389, - XED_IFORM_VFNMADD213PS_XMMdq_XMMdq_MEMdq=3390, - XED_IFORM_VFNMADD213PS_XMMdq_XMMdq_XMMdq=3391, - XED_IFORM_VFNMADD213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3392, - XED_IFORM_VFNMADD213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3393, - XED_IFORM_VFNMADD213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3394, - XED_IFORM_VFNMADD213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3395, - XED_IFORM_VFNMADD213PS_YMMqq_YMMqq_MEMqq=3396, - XED_IFORM_VFNMADD213PS_YMMqq_YMMqq_YMMqq=3397, - XED_IFORM_VFNMADD213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3398, - XED_IFORM_VFNMADD213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3399, - XED_IFORM_VFNMADD213SD_XMMdq_XMMq_MEMq=3400, - XED_IFORM_VFNMADD213SD_XMMdq_XMMq_XMMq=3401, - XED_IFORM_VFNMADD213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3402, - XED_IFORM_VFNMADD213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3403, - XED_IFORM_VFNMADD213SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3404, - XED_IFORM_VFNMADD213SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3405, - XED_IFORM_VFNMADD213SS_XMMdq_XMMd_MEMd=3406, - XED_IFORM_VFNMADD213SS_XMMdq_XMMd_XMMd=3407, - XED_IFORM_VFNMADD213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3408, - XED_IFORM_VFNMADD213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3409, - XED_IFORM_VFNMADD231PD_XMMdq_XMMdq_MEMdq=3410, - XED_IFORM_VFNMADD231PD_XMMdq_XMMdq_XMMdq=3411, - XED_IFORM_VFNMADD231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3412, - XED_IFORM_VFNMADD231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3413, - XED_IFORM_VFNMADD231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3414, - XED_IFORM_VFNMADD231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3415, - XED_IFORM_VFNMADD231PD_YMMqq_YMMqq_MEMqq=3416, - XED_IFORM_VFNMADD231PD_YMMqq_YMMqq_YMMqq=3417, - XED_IFORM_VFNMADD231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3418, - XED_IFORM_VFNMADD231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3419, - XED_IFORM_VFNMADD231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3420, - XED_IFORM_VFNMADD231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3421, - XED_IFORM_VFNMADD231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3422, - XED_IFORM_VFNMADD231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3423, - XED_IFORM_VFNMADD231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3424, - XED_IFORM_VFNMADD231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3425, - XED_IFORM_VFNMADD231PS_XMMdq_XMMdq_MEMdq=3426, - XED_IFORM_VFNMADD231PS_XMMdq_XMMdq_XMMdq=3427, - XED_IFORM_VFNMADD231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3428, - XED_IFORM_VFNMADD231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3429, - XED_IFORM_VFNMADD231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3430, - XED_IFORM_VFNMADD231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3431, - XED_IFORM_VFNMADD231PS_YMMqq_YMMqq_MEMqq=3432, - XED_IFORM_VFNMADD231PS_YMMqq_YMMqq_YMMqq=3433, - XED_IFORM_VFNMADD231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3434, - XED_IFORM_VFNMADD231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3435, - XED_IFORM_VFNMADD231SD_XMMdq_XMMq_MEMq=3436, - XED_IFORM_VFNMADD231SD_XMMdq_XMMq_XMMq=3437, - XED_IFORM_VFNMADD231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3438, - XED_IFORM_VFNMADD231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3439, - XED_IFORM_VFNMADD231SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3440, - XED_IFORM_VFNMADD231SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3441, - XED_IFORM_VFNMADD231SS_XMMdq_XMMd_MEMd=3442, - XED_IFORM_VFNMADD231SS_XMMdq_XMMd_XMMd=3443, - XED_IFORM_VFNMADD231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3444, - XED_IFORM_VFNMADD231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3445, - XED_IFORM_VFNMADDPD_XMMdq_XMMdq_MEMdq_XMMdq=3446, - XED_IFORM_VFNMADDPD_XMMdq_XMMdq_XMMdq_MEMdq=3447, - XED_IFORM_VFNMADDPD_XMMdq_XMMdq_XMMdq_XMMdq=3448, - XED_IFORM_VFNMADDPD_YMMqq_YMMqq_MEMqq_YMMqq=3449, - XED_IFORM_VFNMADDPD_YMMqq_YMMqq_YMMqq_MEMqq=3450, - XED_IFORM_VFNMADDPD_YMMqq_YMMqq_YMMqq_YMMqq=3451, - XED_IFORM_VFNMADDPS_XMMdq_XMMdq_MEMdq_XMMdq=3452, - XED_IFORM_VFNMADDPS_XMMdq_XMMdq_XMMdq_MEMdq=3453, - XED_IFORM_VFNMADDPS_XMMdq_XMMdq_XMMdq_XMMdq=3454, - XED_IFORM_VFNMADDPS_YMMqq_YMMqq_MEMqq_YMMqq=3455, - XED_IFORM_VFNMADDPS_YMMqq_YMMqq_YMMqq_MEMqq=3456, - XED_IFORM_VFNMADDPS_YMMqq_YMMqq_YMMqq_YMMqq=3457, - XED_IFORM_VFNMADDSD_XMMdq_XMMq_MEMq_XMMq=3458, - XED_IFORM_VFNMADDSD_XMMdq_XMMq_XMMq_MEMq=3459, - XED_IFORM_VFNMADDSD_XMMdq_XMMq_XMMq_XMMq=3460, - XED_IFORM_VFNMADDSS_XMMdq_XMMd_MEMd_XMMd=3461, - XED_IFORM_VFNMADDSS_XMMdq_XMMd_XMMd_MEMd=3462, - XED_IFORM_VFNMADDSS_XMMdq_XMMd_XMMd_XMMd=3463, - XED_IFORM_VFNMSUB132PD_XMMdq_XMMdq_MEMdq=3464, - XED_IFORM_VFNMSUB132PD_XMMdq_XMMdq_XMMdq=3465, - XED_IFORM_VFNMSUB132PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3466, - XED_IFORM_VFNMSUB132PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3467, - XED_IFORM_VFNMSUB132PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3468, - XED_IFORM_VFNMSUB132PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3469, - XED_IFORM_VFNMSUB132PD_YMMqq_YMMqq_MEMqq=3470, - XED_IFORM_VFNMSUB132PD_YMMqq_YMMqq_YMMqq=3471, - XED_IFORM_VFNMSUB132PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3472, - XED_IFORM_VFNMSUB132PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3473, - XED_IFORM_VFNMSUB132PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3474, - XED_IFORM_VFNMSUB132PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3475, - XED_IFORM_VFNMSUB132PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3476, - XED_IFORM_VFNMSUB132PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3477, - XED_IFORM_VFNMSUB132PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3478, - XED_IFORM_VFNMSUB132PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3479, - XED_IFORM_VFNMSUB132PS_XMMdq_XMMdq_MEMdq=3480, - XED_IFORM_VFNMSUB132PS_XMMdq_XMMdq_XMMdq=3481, - XED_IFORM_VFNMSUB132PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3482, - XED_IFORM_VFNMSUB132PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3483, - XED_IFORM_VFNMSUB132PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3484, - XED_IFORM_VFNMSUB132PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3485, - XED_IFORM_VFNMSUB132PS_YMMqq_YMMqq_MEMqq=3486, - XED_IFORM_VFNMSUB132PS_YMMqq_YMMqq_YMMqq=3487, - XED_IFORM_VFNMSUB132PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3488, - XED_IFORM_VFNMSUB132PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3489, - XED_IFORM_VFNMSUB132SD_XMMdq_XMMq_MEMq=3490, - XED_IFORM_VFNMSUB132SD_XMMdq_XMMq_XMMq=3491, - XED_IFORM_VFNMSUB132SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3492, - XED_IFORM_VFNMSUB132SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3493, - XED_IFORM_VFNMSUB132SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3494, - XED_IFORM_VFNMSUB132SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3495, - XED_IFORM_VFNMSUB132SS_XMMdq_XMMd_MEMd=3496, - XED_IFORM_VFNMSUB132SS_XMMdq_XMMd_XMMd=3497, - XED_IFORM_VFNMSUB132SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3498, - XED_IFORM_VFNMSUB132SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3499, - XED_IFORM_VFNMSUB213PD_XMMdq_XMMdq_MEMdq=3500, - XED_IFORM_VFNMSUB213PD_XMMdq_XMMdq_XMMdq=3501, - XED_IFORM_VFNMSUB213PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3502, - XED_IFORM_VFNMSUB213PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3503, - XED_IFORM_VFNMSUB213PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3504, - XED_IFORM_VFNMSUB213PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3505, - XED_IFORM_VFNMSUB213PD_YMMqq_YMMqq_MEMqq=3506, - XED_IFORM_VFNMSUB213PD_YMMqq_YMMqq_YMMqq=3507, - XED_IFORM_VFNMSUB213PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3508, - XED_IFORM_VFNMSUB213PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3509, - XED_IFORM_VFNMSUB213PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3510, - XED_IFORM_VFNMSUB213PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3511, - XED_IFORM_VFNMSUB213PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3512, - XED_IFORM_VFNMSUB213PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3513, - XED_IFORM_VFNMSUB213PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3514, - XED_IFORM_VFNMSUB213PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3515, - XED_IFORM_VFNMSUB213PS_XMMdq_XMMdq_MEMdq=3516, - XED_IFORM_VFNMSUB213PS_XMMdq_XMMdq_XMMdq=3517, - XED_IFORM_VFNMSUB213PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3518, - XED_IFORM_VFNMSUB213PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3519, - XED_IFORM_VFNMSUB213PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3520, - XED_IFORM_VFNMSUB213PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3521, - XED_IFORM_VFNMSUB213PS_YMMqq_YMMqq_MEMqq=3522, - XED_IFORM_VFNMSUB213PS_YMMqq_YMMqq_YMMqq=3523, - XED_IFORM_VFNMSUB213PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3524, - XED_IFORM_VFNMSUB213PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3525, - XED_IFORM_VFNMSUB213SD_XMMdq_XMMq_MEMq=3526, - XED_IFORM_VFNMSUB213SD_XMMdq_XMMq_XMMq=3527, - XED_IFORM_VFNMSUB213SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3528, - XED_IFORM_VFNMSUB213SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3529, - XED_IFORM_VFNMSUB213SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3530, - XED_IFORM_VFNMSUB213SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3531, - XED_IFORM_VFNMSUB213SS_XMMdq_XMMd_MEMd=3532, - XED_IFORM_VFNMSUB213SS_XMMdq_XMMd_XMMd=3533, - XED_IFORM_VFNMSUB213SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3534, - XED_IFORM_VFNMSUB213SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3535, - XED_IFORM_VFNMSUB231PD_XMMdq_XMMdq_MEMdq=3536, - XED_IFORM_VFNMSUB231PD_XMMdq_XMMdq_XMMdq=3537, - XED_IFORM_VFNMSUB231PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3538, - XED_IFORM_VFNMSUB231PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3539, - XED_IFORM_VFNMSUB231PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3540, - XED_IFORM_VFNMSUB231PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3541, - XED_IFORM_VFNMSUB231PD_YMMqq_YMMqq_MEMqq=3542, - XED_IFORM_VFNMSUB231PD_YMMqq_YMMqq_YMMqq=3543, - XED_IFORM_VFNMSUB231PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3544, - XED_IFORM_VFNMSUB231PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3545, - XED_IFORM_VFNMSUB231PH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3546, - XED_IFORM_VFNMSUB231PH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3547, - XED_IFORM_VFNMSUB231PH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3548, - XED_IFORM_VFNMSUB231PH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3549, - XED_IFORM_VFNMSUB231PH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3550, - XED_IFORM_VFNMSUB231PH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3551, - XED_IFORM_VFNMSUB231PS_XMMdq_XMMdq_MEMdq=3552, - XED_IFORM_VFNMSUB231PS_XMMdq_XMMdq_XMMdq=3553, - XED_IFORM_VFNMSUB231PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3554, - XED_IFORM_VFNMSUB231PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3555, - XED_IFORM_VFNMSUB231PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3556, - XED_IFORM_VFNMSUB231PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3557, - XED_IFORM_VFNMSUB231PS_YMMqq_YMMqq_MEMqq=3558, - XED_IFORM_VFNMSUB231PS_YMMqq_YMMqq_YMMqq=3559, - XED_IFORM_VFNMSUB231PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3560, - XED_IFORM_VFNMSUB231PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3561, - XED_IFORM_VFNMSUB231SD_XMMdq_XMMq_MEMq=3562, - XED_IFORM_VFNMSUB231SD_XMMdq_XMMq_XMMq=3563, - XED_IFORM_VFNMSUB231SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3564, - XED_IFORM_VFNMSUB231SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3565, - XED_IFORM_VFNMSUB231SH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3566, - XED_IFORM_VFNMSUB231SH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3567, - XED_IFORM_VFNMSUB231SS_XMMdq_XMMd_MEMd=3568, - XED_IFORM_VFNMSUB231SS_XMMdq_XMMd_XMMd=3569, - XED_IFORM_VFNMSUB231SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3570, - XED_IFORM_VFNMSUB231SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3571, - XED_IFORM_VFNMSUBPD_XMMdq_XMMdq_MEMdq_XMMdq=3572, - XED_IFORM_VFNMSUBPD_XMMdq_XMMdq_XMMdq_MEMdq=3573, - XED_IFORM_VFNMSUBPD_XMMdq_XMMdq_XMMdq_XMMdq=3574, - XED_IFORM_VFNMSUBPD_YMMqq_YMMqq_MEMqq_YMMqq=3575, - XED_IFORM_VFNMSUBPD_YMMqq_YMMqq_YMMqq_MEMqq=3576, - XED_IFORM_VFNMSUBPD_YMMqq_YMMqq_YMMqq_YMMqq=3577, - XED_IFORM_VFNMSUBPS_XMMdq_XMMdq_MEMdq_XMMdq=3578, - XED_IFORM_VFNMSUBPS_XMMdq_XMMdq_XMMdq_MEMdq=3579, - XED_IFORM_VFNMSUBPS_XMMdq_XMMdq_XMMdq_XMMdq=3580, - XED_IFORM_VFNMSUBPS_YMMqq_YMMqq_MEMqq_YMMqq=3581, - XED_IFORM_VFNMSUBPS_YMMqq_YMMqq_YMMqq_MEMqq=3582, - XED_IFORM_VFNMSUBPS_YMMqq_YMMqq_YMMqq_YMMqq=3583, - XED_IFORM_VFNMSUBSD_XMMdq_XMMq_MEMq_XMMq=3584, - XED_IFORM_VFNMSUBSD_XMMdq_XMMq_XMMq_MEMq=3585, - XED_IFORM_VFNMSUBSD_XMMdq_XMMq_XMMq_XMMq=3586, - XED_IFORM_VFNMSUBSS_XMMdq_XMMd_MEMd_XMMd=3587, - XED_IFORM_VFNMSUBSS_XMMdq_XMMd_XMMd_MEMd=3588, - XED_IFORM_VFNMSUBSS_XMMdq_XMMd_XMMd_XMMd=3589, - XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_MEMf64_IMM8_AVX512_VL128=3590, - XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_MEMf64_IMM8_AVX512_VL256=3591, - XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_MEMf64_IMM8_AVX512_VL512=3592, - XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_XMMf64_IMM8_AVX512=3593, - XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_YMMf64_IMM8_AVX512=3594, - XED_IFORM_VFPCLASSPD_MASKmskw_MASKmskw_ZMMf64_IMM8_AVX512=3595, - XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_MEMf16_IMM8_AVX512_VL128=3596, - XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_MEMf16_IMM8_AVX512_VL256=3597, - XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_MEMf16_IMM8_AVX512_VL512=3598, - XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_XMMf16_IMM8_AVX512=3599, - XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_YMMf16_IMM8_AVX512=3600, - XED_IFORM_VFPCLASSPH_MASKmskw_MASKmskw_ZMMf16_IMM8_AVX512=3601, - XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_MEMf32_IMM8_AVX512_VL128=3602, - XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_MEMf32_IMM8_AVX512_VL256=3603, - XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_MEMf32_IMM8_AVX512_VL512=3604, - XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_XMMf32_IMM8_AVX512=3605, - XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_YMMf32_IMM8_AVX512=3606, - XED_IFORM_VFPCLASSPS_MASKmskw_MASKmskw_ZMMf32_IMM8_AVX512=3607, - XED_IFORM_VFPCLASSSD_MASKmskw_MASKmskw_MEMf64_IMM8_AVX512=3608, - XED_IFORM_VFPCLASSSD_MASKmskw_MASKmskw_XMMf64_IMM8_AVX512=3609, - XED_IFORM_VFPCLASSSH_MASKmskw_MASKmskw_MEMf16_IMM8_AVX512=3610, - XED_IFORM_VFPCLASSSH_MASKmskw_MASKmskw_XMMf16_IMM8_AVX512=3611, - XED_IFORM_VFPCLASSSS_MASKmskw_MASKmskw_MEMf32_IMM8_AVX512=3612, - XED_IFORM_VFPCLASSSS_MASKmskw_MASKmskw_XMMf32_IMM8_AVX512=3613, - XED_IFORM_VFRCZPD_XMMdq_MEMdq=3614, - XED_IFORM_VFRCZPD_XMMdq_XMMdq=3615, - XED_IFORM_VFRCZPD_YMMqq_MEMqq=3616, - XED_IFORM_VFRCZPD_YMMqq_YMMqq=3617, - XED_IFORM_VFRCZPS_XMMdq_MEMdq=3618, - XED_IFORM_VFRCZPS_XMMdq_XMMdq=3619, - XED_IFORM_VFRCZPS_YMMqq_MEMqq=3620, - XED_IFORM_VFRCZPS_YMMqq_YMMqq=3621, - XED_IFORM_VFRCZSD_XMMdq_MEMq=3622, - XED_IFORM_VFRCZSD_XMMdq_XMMq=3623, - XED_IFORM_VFRCZSS_XMMdq_MEMd=3624, - XED_IFORM_VFRCZSS_XMMdq_XMMd=3625, - XED_IFORM_VGATHERDPD_XMMf64_MASKmskw_MEMf64_AVX512_VL128=3626, - XED_IFORM_VGATHERDPD_XMMf64_MEMf64_XMMi64_VL128=3627, - XED_IFORM_VGATHERDPD_YMMf64_MASKmskw_MEMf64_AVX512_VL256=3628, - XED_IFORM_VGATHERDPD_YMMf64_MEMf64_YMMi64_VL256=3629, - XED_IFORM_VGATHERDPD_ZMMf64_MASKmskw_MEMf64_AVX512_VL512=3630, - XED_IFORM_VGATHERDPS_XMMf32_MASKmskw_MEMf32_AVX512_VL128=3631, - XED_IFORM_VGATHERDPS_XMMf32_MEMf32_XMMi32_VL128=3632, - XED_IFORM_VGATHERDPS_YMMf32_MASKmskw_MEMf32_AVX512_VL256=3633, - XED_IFORM_VGATHERDPS_YMMf32_MEMf32_YMMi32_VL256=3634, - XED_IFORM_VGATHERDPS_ZMMf32_MASKmskw_MEMf32_AVX512_VL512=3635, - XED_IFORM_VGATHERPF0DPD_MEMf64_MASKmskw_AVX512PF_VL512=3636, - XED_IFORM_VGATHERPF0DPS_MEMf32_MASKmskw_AVX512PF_VL512=3637, - XED_IFORM_VGATHERPF0QPD_MEMf64_MASKmskw_AVX512PF_VL512=3638, - XED_IFORM_VGATHERPF0QPS_MEMf32_MASKmskw_AVX512PF_VL512=3639, - XED_IFORM_VGATHERPF1DPD_MEMf64_MASKmskw_AVX512PF_VL512=3640, - XED_IFORM_VGATHERPF1DPS_MEMf32_MASKmskw_AVX512PF_VL512=3641, - XED_IFORM_VGATHERPF1QPD_MEMf64_MASKmskw_AVX512PF_VL512=3642, - XED_IFORM_VGATHERPF1QPS_MEMf32_MASKmskw_AVX512PF_VL512=3643, - XED_IFORM_VGATHERQPD_XMMf64_MASKmskw_MEMf64_AVX512_VL128=3644, - XED_IFORM_VGATHERQPD_XMMf64_MEMf64_XMMi64_VL128=3645, - XED_IFORM_VGATHERQPD_YMMf64_MASKmskw_MEMf64_AVX512_VL256=3646, - XED_IFORM_VGATHERQPD_YMMf64_MEMf64_YMMi64_VL256=3647, - XED_IFORM_VGATHERQPD_ZMMf64_MASKmskw_MEMf64_AVX512_VL512=3648, - XED_IFORM_VGATHERQPS_XMMf32_MASKmskw_MEMf32_AVX512_VL128=3649, - XED_IFORM_VGATHERQPS_XMMf32_MASKmskw_MEMf32_AVX512_VL256=3650, - XED_IFORM_VGATHERQPS_XMMf32_MEMf32_XMMi32_VL128=3651, - XED_IFORM_VGATHERQPS_XMMf32_MEMf32_XMMi32_VL256=3652, - XED_IFORM_VGATHERQPS_YMMf32_MASKmskw_MEMf32_AVX512_VL512=3653, - XED_IFORM_VGETEXPPD_XMMf64_MASKmskw_MEMf64_AVX512=3654, - XED_IFORM_VGETEXPPD_XMMf64_MASKmskw_XMMf64_AVX512=3655, - XED_IFORM_VGETEXPPD_YMMf64_MASKmskw_MEMf64_AVX512=3656, - XED_IFORM_VGETEXPPD_YMMf64_MASKmskw_YMMf64_AVX512=3657, - XED_IFORM_VGETEXPPD_ZMMf64_MASKmskw_MEMf64_AVX512=3658, - XED_IFORM_VGETEXPPD_ZMMf64_MASKmskw_ZMMf64_AVX512=3659, - XED_IFORM_VGETEXPPH_XMMf16_MASKmskw_MEMf16_AVX512=3660, - XED_IFORM_VGETEXPPH_XMMf16_MASKmskw_XMMf16_AVX512=3661, - XED_IFORM_VGETEXPPH_YMMf16_MASKmskw_MEMf16_AVX512=3662, - XED_IFORM_VGETEXPPH_YMMf16_MASKmskw_YMMf16_AVX512=3663, - XED_IFORM_VGETEXPPH_ZMMf16_MASKmskw_MEMf16_AVX512=3664, - XED_IFORM_VGETEXPPH_ZMMf16_MASKmskw_ZMMf16_AVX512=3665, - XED_IFORM_VGETEXPPS_XMMf32_MASKmskw_MEMf32_AVX512=3666, - XED_IFORM_VGETEXPPS_XMMf32_MASKmskw_XMMf32_AVX512=3667, - XED_IFORM_VGETEXPPS_YMMf32_MASKmskw_MEMf32_AVX512=3668, - XED_IFORM_VGETEXPPS_YMMf32_MASKmskw_YMMf32_AVX512=3669, - XED_IFORM_VGETEXPPS_ZMMf32_MASKmskw_MEMf32_AVX512=3670, - XED_IFORM_VGETEXPPS_ZMMf32_MASKmskw_ZMMf32_AVX512=3671, - XED_IFORM_VGETEXPSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3672, - XED_IFORM_VGETEXPSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3673, - XED_IFORM_VGETEXPSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3674, - XED_IFORM_VGETEXPSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3675, - XED_IFORM_VGETEXPSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3676, - XED_IFORM_VGETEXPSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3677, - XED_IFORM_VGETMANTPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512=3678, - XED_IFORM_VGETMANTPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512=3679, - XED_IFORM_VGETMANTPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512=3680, - XED_IFORM_VGETMANTPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512=3681, - XED_IFORM_VGETMANTPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512=3682, - XED_IFORM_VGETMANTPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512=3683, - XED_IFORM_VGETMANTPH_XMMf16_MASKmskw_MEMf16_IMM8_AVX512=3684, - XED_IFORM_VGETMANTPH_XMMf16_MASKmskw_XMMf16_IMM8_AVX512=3685, - XED_IFORM_VGETMANTPH_YMMf16_MASKmskw_MEMf16_IMM8_AVX512=3686, - XED_IFORM_VGETMANTPH_YMMf16_MASKmskw_YMMf16_IMM8_AVX512=3687, - XED_IFORM_VGETMANTPH_ZMMf16_MASKmskw_MEMf16_IMM8_AVX512=3688, - XED_IFORM_VGETMANTPH_ZMMf16_MASKmskw_ZMMf16_IMM8_AVX512=3689, - XED_IFORM_VGETMANTPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512=3690, - XED_IFORM_VGETMANTPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512=3691, - XED_IFORM_VGETMANTPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512=3692, - XED_IFORM_VGETMANTPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512=3693, - XED_IFORM_VGETMANTPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512=3694, - XED_IFORM_VGETMANTPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512=3695, - XED_IFORM_VGETMANTSD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=3696, - XED_IFORM_VGETMANTSD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=3697, - XED_IFORM_VGETMANTSH_XMMf16_MASKmskw_XMMf16_MEMf16_IMM8_AVX512=3698, - XED_IFORM_VGETMANTSH_XMMf16_MASKmskw_XMMf16_XMMf16_IMM8_AVX512=3699, - XED_IFORM_VGETMANTSS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=3700, - XED_IFORM_VGETMANTSS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=3701, - XED_IFORM_VGF2P8AFFINEINVQB_XMMu8_MASKmskw_XMMu8_MEMu64_IMM8_AVX512=3702, - XED_IFORM_VGF2P8AFFINEINVQB_XMMu8_MASKmskw_XMMu8_XMMu64_IMM8_AVX512=3703, - XED_IFORM_VGF2P8AFFINEINVQB_XMMu8_XMMu8_MEMu64_IMM8=3704, - XED_IFORM_VGF2P8AFFINEINVQB_XMMu8_XMMu8_XMMu64_IMM8=3705, - XED_IFORM_VGF2P8AFFINEINVQB_YMMu8_MASKmskw_YMMu8_MEMu64_IMM8_AVX512=3706, - XED_IFORM_VGF2P8AFFINEINVQB_YMMu8_MASKmskw_YMMu8_YMMu64_IMM8_AVX512=3707, - XED_IFORM_VGF2P8AFFINEINVQB_YMMu8_YMMu8_MEMu64_IMM8=3708, - XED_IFORM_VGF2P8AFFINEINVQB_YMMu8_YMMu8_YMMu64_IMM8=3709, - XED_IFORM_VGF2P8AFFINEINVQB_ZMMu8_MASKmskw_ZMMu8_MEMu64_IMM8_AVX512=3710, - XED_IFORM_VGF2P8AFFINEINVQB_ZMMu8_MASKmskw_ZMMu8_ZMMu64_IMM8_AVX512=3711, - XED_IFORM_VGF2P8AFFINEQB_XMMu8_MASKmskw_XMMu8_MEMu64_IMM8_AVX512=3712, - XED_IFORM_VGF2P8AFFINEQB_XMMu8_MASKmskw_XMMu8_XMMu64_IMM8_AVX512=3713, - XED_IFORM_VGF2P8AFFINEQB_XMMu8_XMMu8_MEMu64_IMM8=3714, - XED_IFORM_VGF2P8AFFINEQB_XMMu8_XMMu8_XMMu64_IMM8=3715, - XED_IFORM_VGF2P8AFFINEQB_YMMu8_MASKmskw_YMMu8_MEMu64_IMM8_AVX512=3716, - XED_IFORM_VGF2P8AFFINEQB_YMMu8_MASKmskw_YMMu8_YMMu64_IMM8_AVX512=3717, - XED_IFORM_VGF2P8AFFINEQB_YMMu8_YMMu8_MEMu64_IMM8=3718, - XED_IFORM_VGF2P8AFFINEQB_YMMu8_YMMu8_YMMu64_IMM8=3719, - XED_IFORM_VGF2P8AFFINEQB_ZMMu8_MASKmskw_ZMMu8_MEMu64_IMM8_AVX512=3720, - XED_IFORM_VGF2P8AFFINEQB_ZMMu8_MASKmskw_ZMMu8_ZMMu64_IMM8_AVX512=3721, - XED_IFORM_VGF2P8MULB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=3722, - XED_IFORM_VGF2P8MULB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=3723, - XED_IFORM_VGF2P8MULB_XMMu8_XMMu8_MEMu8=3724, - XED_IFORM_VGF2P8MULB_XMMu8_XMMu8_XMMu8=3725, - XED_IFORM_VGF2P8MULB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=3726, - XED_IFORM_VGF2P8MULB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=3727, - XED_IFORM_VGF2P8MULB_YMMu8_YMMu8_MEMu8=3728, - XED_IFORM_VGF2P8MULB_YMMu8_YMMu8_YMMu8=3729, - XED_IFORM_VGF2P8MULB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=3730, - XED_IFORM_VGF2P8MULB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=3731, - XED_IFORM_VHADDPD_XMMdq_XMMdq_MEMdq=3732, - XED_IFORM_VHADDPD_XMMdq_XMMdq_XMMdq=3733, - XED_IFORM_VHADDPD_YMMqq_YMMqq_MEMqq=3734, - XED_IFORM_VHADDPD_YMMqq_YMMqq_YMMqq=3735, - XED_IFORM_VHADDPS_XMMdq_XMMdq_MEMdq=3736, - XED_IFORM_VHADDPS_XMMdq_XMMdq_XMMdq=3737, - XED_IFORM_VHADDPS_YMMqq_YMMqq_MEMqq=3738, - XED_IFORM_VHADDPS_YMMqq_YMMqq_YMMqq=3739, - XED_IFORM_VHSUBPD_XMMdq_XMMdq_MEMdq=3740, - XED_IFORM_VHSUBPD_XMMdq_XMMdq_XMMdq=3741, - XED_IFORM_VHSUBPD_YMMqq_YMMqq_MEMqq=3742, - XED_IFORM_VHSUBPD_YMMqq_YMMqq_YMMqq=3743, - XED_IFORM_VHSUBPS_XMMdq_XMMdq_MEMdq=3744, - XED_IFORM_VHSUBPS_XMMdq_XMMdq_XMMdq=3745, - XED_IFORM_VHSUBPS_YMMqq_YMMqq_MEMqq=3746, - XED_IFORM_VHSUBPS_YMMqq_YMMqq_YMMqq=3747, - XED_IFORM_VINSERTF128_YMMqq_YMMqq_MEMdq_IMMb=3748, - XED_IFORM_VINSERTF128_YMMqq_YMMqq_XMMdq_IMMb=3749, - XED_IFORM_VINSERTF32X4_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=3750, - XED_IFORM_VINSERTF32X4_YMMf32_MASKmskw_YMMf32_XMMf32_IMM8_AVX512=3751, - XED_IFORM_VINSERTF32X4_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=3752, - XED_IFORM_VINSERTF32X4_ZMMf32_MASKmskw_ZMMf32_XMMf32_IMM8_AVX512=3753, - XED_IFORM_VINSERTF32X8_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=3754, - XED_IFORM_VINSERTF32X8_ZMMf32_MASKmskw_ZMMf32_YMMf32_IMM8_AVX512=3755, - XED_IFORM_VINSERTF64X2_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=3756, - XED_IFORM_VINSERTF64X2_YMMf64_MASKmskw_YMMf64_XMMf64_IMM8_AVX512=3757, - XED_IFORM_VINSERTF64X2_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=3758, - XED_IFORM_VINSERTF64X2_ZMMf64_MASKmskw_ZMMf64_XMMf64_IMM8_AVX512=3759, - XED_IFORM_VINSERTF64X4_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=3760, - XED_IFORM_VINSERTF64X4_ZMMf64_MASKmskw_ZMMf64_YMMf64_IMM8_AVX512=3761, - XED_IFORM_VINSERTI128_YMMqq_YMMqq_MEMdq_IMMb=3762, - XED_IFORM_VINSERTI128_YMMqq_YMMqq_XMMdq_IMMb=3763, - XED_IFORM_VINSERTI32X4_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=3764, - XED_IFORM_VINSERTI32X4_YMMu32_MASKmskw_YMMu32_XMMu32_IMM8_AVX512=3765, - XED_IFORM_VINSERTI32X4_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=3766, - XED_IFORM_VINSERTI32X4_ZMMu32_MASKmskw_ZMMu32_XMMu32_IMM8_AVX512=3767, - XED_IFORM_VINSERTI32X8_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=3768, - XED_IFORM_VINSERTI32X8_ZMMu32_MASKmskw_ZMMu32_YMMu32_IMM8_AVX512=3769, - XED_IFORM_VINSERTI64X2_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=3770, - XED_IFORM_VINSERTI64X2_YMMu64_MASKmskw_YMMu64_XMMu64_IMM8_AVX512=3771, - XED_IFORM_VINSERTI64X2_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=3772, - XED_IFORM_VINSERTI64X2_ZMMu64_MASKmskw_ZMMu64_XMMu64_IMM8_AVX512=3773, - XED_IFORM_VINSERTI64X4_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=3774, - XED_IFORM_VINSERTI64X4_ZMMu64_MASKmskw_ZMMu64_YMMu64_IMM8_AVX512=3775, - XED_IFORM_VINSERTPS_XMMdq_XMMdq_MEMd_IMMb=3776, - XED_IFORM_VINSERTPS_XMMdq_XMMdq_XMMdq_IMMb=3777, - XED_IFORM_VINSERTPS_XMMf32_XMMf32_MEMf32_IMM8_AVX512=3778, - XED_IFORM_VINSERTPS_XMMf32_XMMf32_XMMf32_IMM8_AVX512=3779, - XED_IFORM_VLDDQU_XMMdq_MEMdq=3780, - XED_IFORM_VLDDQU_YMMqq_MEMqq=3781, - XED_IFORM_VLDMXCSR_MEMd=3782, - XED_IFORM_VMASKMOVDQU_XMMdq_XMMdq=3783, - XED_IFORM_VMASKMOVPD_MEMdq_XMMdq_XMMdq=3784, - XED_IFORM_VMASKMOVPD_MEMqq_YMMqq_YMMqq=3785, - XED_IFORM_VMASKMOVPD_XMMdq_XMMdq_MEMdq=3786, - XED_IFORM_VMASKMOVPD_YMMqq_YMMqq_MEMqq=3787, - XED_IFORM_VMASKMOVPS_MEMdq_XMMdq_XMMdq=3788, - XED_IFORM_VMASKMOVPS_MEMqq_YMMqq_YMMqq=3789, - XED_IFORM_VMASKMOVPS_XMMdq_XMMdq_MEMdq=3790, - XED_IFORM_VMASKMOVPS_YMMqq_YMMqq_MEMqq=3791, - XED_IFORM_VMAXPD_XMMdq_XMMdq_MEMdq=3792, - XED_IFORM_VMAXPD_XMMdq_XMMdq_XMMdq=3793, - XED_IFORM_VMAXPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3794, - XED_IFORM_VMAXPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3795, - XED_IFORM_VMAXPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3796, - XED_IFORM_VMAXPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3797, - XED_IFORM_VMAXPD_YMMqq_YMMqq_MEMqq=3798, - XED_IFORM_VMAXPD_YMMqq_YMMqq_YMMqq=3799, - XED_IFORM_VMAXPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3800, - XED_IFORM_VMAXPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3801, - XED_IFORM_VMAXPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3802, - XED_IFORM_VMAXPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3803, - XED_IFORM_VMAXPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3804, - XED_IFORM_VMAXPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3805, - XED_IFORM_VMAXPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3806, - XED_IFORM_VMAXPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3807, - XED_IFORM_VMAXPS_XMMdq_XMMdq_MEMdq=3808, - XED_IFORM_VMAXPS_XMMdq_XMMdq_XMMdq=3809, - XED_IFORM_VMAXPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3810, - XED_IFORM_VMAXPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3811, - XED_IFORM_VMAXPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3812, - XED_IFORM_VMAXPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3813, - XED_IFORM_VMAXPS_YMMqq_YMMqq_MEMqq=3814, - XED_IFORM_VMAXPS_YMMqq_YMMqq_YMMqq=3815, - XED_IFORM_VMAXPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3816, - XED_IFORM_VMAXPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3817, - XED_IFORM_VMAXSD_XMMdq_XMMdq_MEMq=3818, - XED_IFORM_VMAXSD_XMMdq_XMMdq_XMMq=3819, - XED_IFORM_VMAXSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3820, - XED_IFORM_VMAXSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3821, - XED_IFORM_VMAXSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3822, - XED_IFORM_VMAXSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3823, - XED_IFORM_VMAXSS_XMMdq_XMMdq_MEMd=3824, - XED_IFORM_VMAXSS_XMMdq_XMMdq_XMMd=3825, - XED_IFORM_VMAXSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3826, - XED_IFORM_VMAXSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3827, - XED_IFORM_VMCALL=3828, - XED_IFORM_VMCLEAR_MEMq=3829, - XED_IFORM_VMFUNC=3830, - XED_IFORM_VMINPD_XMMdq_XMMdq_MEMdq=3831, - XED_IFORM_VMINPD_XMMdq_XMMdq_XMMdq=3832, - XED_IFORM_VMINPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3833, - XED_IFORM_VMINPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3834, - XED_IFORM_VMINPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=3835, - XED_IFORM_VMINPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=3836, - XED_IFORM_VMINPD_YMMqq_YMMqq_MEMqq=3837, - XED_IFORM_VMINPD_YMMqq_YMMqq_YMMqq=3838, - XED_IFORM_VMINPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=3839, - XED_IFORM_VMINPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=3840, - XED_IFORM_VMINPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3841, - XED_IFORM_VMINPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3842, - XED_IFORM_VMINPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=3843, - XED_IFORM_VMINPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=3844, - XED_IFORM_VMINPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=3845, - XED_IFORM_VMINPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=3846, - XED_IFORM_VMINPS_XMMdq_XMMdq_MEMdq=3847, - XED_IFORM_VMINPS_XMMdq_XMMdq_XMMdq=3848, - XED_IFORM_VMINPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3849, - XED_IFORM_VMINPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3850, - XED_IFORM_VMINPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=3851, - XED_IFORM_VMINPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=3852, - XED_IFORM_VMINPS_YMMqq_YMMqq_MEMqq=3853, - XED_IFORM_VMINPS_YMMqq_YMMqq_YMMqq=3854, - XED_IFORM_VMINPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=3855, - XED_IFORM_VMINPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=3856, - XED_IFORM_VMINSD_XMMdq_XMMdq_MEMq=3857, - XED_IFORM_VMINSD_XMMdq_XMMdq_XMMq=3858, - XED_IFORM_VMINSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=3859, - XED_IFORM_VMINSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=3860, - XED_IFORM_VMINSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=3861, - XED_IFORM_VMINSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=3862, - XED_IFORM_VMINSS_XMMdq_XMMdq_MEMd=3863, - XED_IFORM_VMINSS_XMMdq_XMMdq_XMMd=3864, - XED_IFORM_VMINSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=3865, - XED_IFORM_VMINSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=3866, - XED_IFORM_VMLAUNCH=3867, - XED_IFORM_VMLOAD_ArAX=3868, - XED_IFORM_VMMCALL=3869, - XED_IFORM_VMOVAPD_MEMdq_XMMdq=3870, - XED_IFORM_VMOVAPD_MEMf64_MASKmskw_XMMf64_AVX512=3871, - XED_IFORM_VMOVAPD_MEMf64_MASKmskw_YMMf64_AVX512=3872, - XED_IFORM_VMOVAPD_MEMf64_MASKmskw_ZMMf64_AVX512=3873, - XED_IFORM_VMOVAPD_MEMqq_YMMqq=3874, - XED_IFORM_VMOVAPD_XMMdq_MEMdq=3875, - XED_IFORM_VMOVAPD_XMMdq_XMMdq_28=3876, - XED_IFORM_VMOVAPD_XMMdq_XMMdq_29=3877, - XED_IFORM_VMOVAPD_XMMf64_MASKmskw_MEMf64_AVX512=3878, - XED_IFORM_VMOVAPD_XMMf64_MASKmskw_XMMf64_AVX512=3879, - XED_IFORM_VMOVAPD_YMMf64_MASKmskw_MEMf64_AVX512=3880, - XED_IFORM_VMOVAPD_YMMf64_MASKmskw_YMMf64_AVX512=3881, - XED_IFORM_VMOVAPD_YMMqq_MEMqq=3882, - XED_IFORM_VMOVAPD_YMMqq_YMMqq_28=3883, - XED_IFORM_VMOVAPD_YMMqq_YMMqq_29=3884, - XED_IFORM_VMOVAPD_ZMMf64_MASKmskw_MEMf64_AVX512=3885, - XED_IFORM_VMOVAPD_ZMMf64_MASKmskw_ZMMf64_AVX512=3886, - XED_IFORM_VMOVAPS_MEMdq_XMMdq=3887, - XED_IFORM_VMOVAPS_MEMf32_MASKmskw_XMMf32_AVX512=3888, - XED_IFORM_VMOVAPS_MEMf32_MASKmskw_YMMf32_AVX512=3889, - XED_IFORM_VMOVAPS_MEMf32_MASKmskw_ZMMf32_AVX512=3890, - XED_IFORM_VMOVAPS_MEMqq_YMMqq=3891, - XED_IFORM_VMOVAPS_XMMdq_MEMdq=3892, - XED_IFORM_VMOVAPS_XMMdq_XMMdq_28=3893, - XED_IFORM_VMOVAPS_XMMdq_XMMdq_29=3894, - XED_IFORM_VMOVAPS_XMMf32_MASKmskw_MEMf32_AVX512=3895, - XED_IFORM_VMOVAPS_XMMf32_MASKmskw_XMMf32_AVX512=3896, - XED_IFORM_VMOVAPS_YMMf32_MASKmskw_MEMf32_AVX512=3897, - XED_IFORM_VMOVAPS_YMMf32_MASKmskw_YMMf32_AVX512=3898, - XED_IFORM_VMOVAPS_YMMqq_MEMqq=3899, - XED_IFORM_VMOVAPS_YMMqq_YMMqq_28=3900, - XED_IFORM_VMOVAPS_YMMqq_YMMqq_29=3901, - XED_IFORM_VMOVAPS_ZMMf32_MASKmskw_MEMf32_AVX512=3902, - XED_IFORM_VMOVAPS_ZMMf32_MASKmskw_ZMMf32_AVX512=3903, - XED_IFORM_VMOVD_GPR32d_XMMd=3904, - XED_IFORM_VMOVD_GPR32u32_XMMu32_AVX512=3905, - XED_IFORM_VMOVD_MEMd_XMMd=3906, - XED_IFORM_VMOVD_MEMu32_XMMu32_AVX512=3907, - XED_IFORM_VMOVD_XMMdq_GPR32d=3908, - XED_IFORM_VMOVD_XMMdq_MEMd=3909, - XED_IFORM_VMOVD_XMMu32_GPR32u32_AVX512=3910, - XED_IFORM_VMOVD_XMMu32_MEMu32_AVX512=3911, - XED_IFORM_VMOVDDUP_XMMdq_MEMq=3912, - XED_IFORM_VMOVDDUP_XMMdq_XMMq=3913, - XED_IFORM_VMOVDDUP_XMMf64_MASKmskw_MEMf64_AVX512=3914, - XED_IFORM_VMOVDDUP_XMMf64_MASKmskw_XMMf64_AVX512=3915, - XED_IFORM_VMOVDDUP_YMMf64_MASKmskw_MEMf64_AVX512=3916, - XED_IFORM_VMOVDDUP_YMMf64_MASKmskw_YMMf64_AVX512=3917, - XED_IFORM_VMOVDDUP_YMMqq_MEMqq=3918, - XED_IFORM_VMOVDDUP_YMMqq_YMMqq=3919, - XED_IFORM_VMOVDDUP_ZMMf64_MASKmskw_MEMf64_AVX512=3920, - XED_IFORM_VMOVDDUP_ZMMf64_MASKmskw_ZMMf64_AVX512=3921, - XED_IFORM_VMOVDQA_MEMdq_XMMdq=3922, - XED_IFORM_VMOVDQA_MEMqq_YMMqq=3923, - XED_IFORM_VMOVDQA_XMMdq_MEMdq=3924, - XED_IFORM_VMOVDQA_XMMdq_XMMdq_6F=3925, - XED_IFORM_VMOVDQA_XMMdq_XMMdq_7F=3926, - XED_IFORM_VMOVDQA_YMMqq_MEMqq=3927, - XED_IFORM_VMOVDQA_YMMqq_YMMqq_6F=3928, - XED_IFORM_VMOVDQA_YMMqq_YMMqq_7F=3929, - XED_IFORM_VMOVDQA32_MEMu32_MASKmskw_XMMu32_AVX512=3930, - XED_IFORM_VMOVDQA32_MEMu32_MASKmskw_YMMu32_AVX512=3931, - XED_IFORM_VMOVDQA32_MEMu32_MASKmskw_ZMMu32_AVX512=3932, - XED_IFORM_VMOVDQA32_XMMu32_MASKmskw_MEMu32_AVX512=3933, - XED_IFORM_VMOVDQA32_XMMu32_MASKmskw_XMMu32_AVX512=3934, - XED_IFORM_VMOVDQA32_YMMu32_MASKmskw_MEMu32_AVX512=3935, - XED_IFORM_VMOVDQA32_YMMu32_MASKmskw_YMMu32_AVX512=3936, - XED_IFORM_VMOVDQA32_ZMMu32_MASKmskw_MEMu32_AVX512=3937, - XED_IFORM_VMOVDQA32_ZMMu32_MASKmskw_ZMMu32_AVX512=3938, - XED_IFORM_VMOVDQA64_MEMu64_MASKmskw_XMMu64_AVX512=3939, - XED_IFORM_VMOVDQA64_MEMu64_MASKmskw_YMMu64_AVX512=3940, - XED_IFORM_VMOVDQA64_MEMu64_MASKmskw_ZMMu64_AVX512=3941, - XED_IFORM_VMOVDQA64_XMMu64_MASKmskw_MEMu64_AVX512=3942, - XED_IFORM_VMOVDQA64_XMMu64_MASKmskw_XMMu64_AVX512=3943, - XED_IFORM_VMOVDQA64_YMMu64_MASKmskw_MEMu64_AVX512=3944, - XED_IFORM_VMOVDQA64_YMMu64_MASKmskw_YMMu64_AVX512=3945, - XED_IFORM_VMOVDQA64_ZMMu64_MASKmskw_MEMu64_AVX512=3946, - XED_IFORM_VMOVDQA64_ZMMu64_MASKmskw_ZMMu64_AVX512=3947, - XED_IFORM_VMOVDQU_MEMdq_XMMdq=3948, - XED_IFORM_VMOVDQU_MEMqq_YMMqq=3949, - XED_IFORM_VMOVDQU_XMMdq_MEMdq=3950, - XED_IFORM_VMOVDQU_XMMdq_XMMdq_6F=3951, - XED_IFORM_VMOVDQU_XMMdq_XMMdq_7F=3952, - XED_IFORM_VMOVDQU_YMMqq_MEMqq=3953, - XED_IFORM_VMOVDQU_YMMqq_YMMqq_6F=3954, - XED_IFORM_VMOVDQU_YMMqq_YMMqq_7F=3955, - XED_IFORM_VMOVDQU16_MEMu16_MASKmskw_XMMu16_AVX512=3956, - XED_IFORM_VMOVDQU16_MEMu16_MASKmskw_YMMu16_AVX512=3957, - XED_IFORM_VMOVDQU16_MEMu16_MASKmskw_ZMMu16_AVX512=3958, - XED_IFORM_VMOVDQU16_XMMu16_MASKmskw_MEMu16_AVX512=3959, - XED_IFORM_VMOVDQU16_XMMu16_MASKmskw_XMMu16_AVX512=3960, - XED_IFORM_VMOVDQU16_YMMu16_MASKmskw_MEMu16_AVX512=3961, - XED_IFORM_VMOVDQU16_YMMu16_MASKmskw_YMMu16_AVX512=3962, - XED_IFORM_VMOVDQU16_ZMMu16_MASKmskw_MEMu16_AVX512=3963, - XED_IFORM_VMOVDQU16_ZMMu16_MASKmskw_ZMMu16_AVX512=3964, - XED_IFORM_VMOVDQU32_MEMu32_MASKmskw_XMMu32_AVX512=3965, - XED_IFORM_VMOVDQU32_MEMu32_MASKmskw_YMMu32_AVX512=3966, - XED_IFORM_VMOVDQU32_MEMu32_MASKmskw_ZMMu32_AVX512=3967, - XED_IFORM_VMOVDQU32_XMMu32_MASKmskw_MEMu32_AVX512=3968, - XED_IFORM_VMOVDQU32_XMMu32_MASKmskw_XMMu32_AVX512=3969, - XED_IFORM_VMOVDQU32_YMMu32_MASKmskw_MEMu32_AVX512=3970, - XED_IFORM_VMOVDQU32_YMMu32_MASKmskw_YMMu32_AVX512=3971, - XED_IFORM_VMOVDQU32_ZMMu32_MASKmskw_MEMu32_AVX512=3972, - XED_IFORM_VMOVDQU32_ZMMu32_MASKmskw_ZMMu32_AVX512=3973, - XED_IFORM_VMOVDQU64_MEMu64_MASKmskw_XMMu64_AVX512=3974, - XED_IFORM_VMOVDQU64_MEMu64_MASKmskw_YMMu64_AVX512=3975, - XED_IFORM_VMOVDQU64_MEMu64_MASKmskw_ZMMu64_AVX512=3976, - XED_IFORM_VMOVDQU64_XMMu64_MASKmskw_MEMu64_AVX512=3977, - XED_IFORM_VMOVDQU64_XMMu64_MASKmskw_XMMu64_AVX512=3978, - XED_IFORM_VMOVDQU64_YMMu64_MASKmskw_MEMu64_AVX512=3979, - XED_IFORM_VMOVDQU64_YMMu64_MASKmskw_YMMu64_AVX512=3980, - XED_IFORM_VMOVDQU64_ZMMu64_MASKmskw_MEMu64_AVX512=3981, - XED_IFORM_VMOVDQU64_ZMMu64_MASKmskw_ZMMu64_AVX512=3982, - XED_IFORM_VMOVDQU8_MEMu8_MASKmskw_XMMu8_AVX512=3983, - XED_IFORM_VMOVDQU8_MEMu8_MASKmskw_YMMu8_AVX512=3984, - XED_IFORM_VMOVDQU8_MEMu8_MASKmskw_ZMMu8_AVX512=3985, - XED_IFORM_VMOVDQU8_XMMu8_MASKmskw_MEMu8_AVX512=3986, - XED_IFORM_VMOVDQU8_XMMu8_MASKmskw_XMMu8_AVX512=3987, - XED_IFORM_VMOVDQU8_YMMu8_MASKmskw_MEMu8_AVX512=3988, - XED_IFORM_VMOVDQU8_YMMu8_MASKmskw_YMMu8_AVX512=3989, - XED_IFORM_VMOVDQU8_ZMMu8_MASKmskw_MEMu8_AVX512=3990, - XED_IFORM_VMOVDQU8_ZMMu8_MASKmskw_ZMMu8_AVX512=3991, - XED_IFORM_VMOVHLPS_XMMdq_XMMdq_XMMdq=3992, - XED_IFORM_VMOVHLPS_XMMf32_XMMf32_XMMf32_AVX512=3993, - XED_IFORM_VMOVHPD_MEMf64_XMMf64_AVX512=3994, - XED_IFORM_VMOVHPD_MEMq_XMMdq=3995, - XED_IFORM_VMOVHPD_XMMdq_XMMq_MEMq=3996, - XED_IFORM_VMOVHPD_XMMf64_XMMf64_MEMf64_AVX512=3997, - XED_IFORM_VMOVHPS_MEMf32_XMMf32_AVX512=3998, - XED_IFORM_VMOVHPS_MEMq_XMMdq=3999, - XED_IFORM_VMOVHPS_XMMdq_XMMq_MEMq=4000, - XED_IFORM_VMOVHPS_XMMf32_XMMf32_MEMf32_AVX512=4001, - XED_IFORM_VMOVLHPS_XMMdq_XMMq_XMMq=4002, - XED_IFORM_VMOVLHPS_XMMf32_XMMf32_XMMf32_AVX512=4003, - XED_IFORM_VMOVLPD_MEMf64_XMMf64_AVX512=4004, - XED_IFORM_VMOVLPD_MEMq_XMMq=4005, - XED_IFORM_VMOVLPD_XMMdq_XMMdq_MEMq=4006, - XED_IFORM_VMOVLPD_XMMf64_XMMf64_MEMf64_AVX512=4007, - XED_IFORM_VMOVLPS_MEMf32_XMMf32_AVX512=4008, - XED_IFORM_VMOVLPS_MEMq_XMMq=4009, - XED_IFORM_VMOVLPS_XMMdq_XMMdq_MEMq=4010, - XED_IFORM_VMOVLPS_XMMf32_XMMf32_MEMf32_AVX512=4011, - XED_IFORM_VMOVMSKPD_GPR32d_XMMdq=4012, - XED_IFORM_VMOVMSKPD_GPR32d_YMMqq=4013, - XED_IFORM_VMOVMSKPS_GPR32d_XMMdq=4014, - XED_IFORM_VMOVMSKPS_GPR32d_YMMqq=4015, - XED_IFORM_VMOVNTDQ_MEMdq_XMMdq=4016, - XED_IFORM_VMOVNTDQ_MEMqq_YMMqq=4017, - XED_IFORM_VMOVNTDQ_MEMu32_XMMu32_AVX512=4018, - XED_IFORM_VMOVNTDQ_MEMu32_YMMu32_AVX512=4019, - XED_IFORM_VMOVNTDQ_MEMu32_ZMMu32_AVX512=4020, - XED_IFORM_VMOVNTDQA_XMMdq_MEMdq=4021, - XED_IFORM_VMOVNTDQA_XMMu32_MEMu32_AVX512=4022, - XED_IFORM_VMOVNTDQA_YMMqq_MEMqq=4023, - XED_IFORM_VMOVNTDQA_YMMu32_MEMu32_AVX512=4024, - XED_IFORM_VMOVNTDQA_ZMMu32_MEMu32_AVX512=4025, - XED_IFORM_VMOVNTPD_MEMdq_XMMdq=4026, - XED_IFORM_VMOVNTPD_MEMf64_XMMf64_AVX512=4027, - XED_IFORM_VMOVNTPD_MEMf64_YMMf64_AVX512=4028, - XED_IFORM_VMOVNTPD_MEMf64_ZMMf64_AVX512=4029, - XED_IFORM_VMOVNTPD_MEMqq_YMMqq=4030, - XED_IFORM_VMOVNTPS_MEMdq_XMMdq=4031, - XED_IFORM_VMOVNTPS_MEMf32_XMMf32_AVX512=4032, - XED_IFORM_VMOVNTPS_MEMf32_YMMf32_AVX512=4033, - XED_IFORM_VMOVNTPS_MEMf32_ZMMf32_AVX512=4034, - XED_IFORM_VMOVNTPS_MEMqq_YMMqq=4035, - XED_IFORM_VMOVQ_GPR64q_XMMq=4036, - XED_IFORM_VMOVQ_GPR64u64_XMMu64_AVX512=4037, - XED_IFORM_VMOVQ_MEMq_XMMq_7E=4038, - XED_IFORM_VMOVQ_MEMq_XMMq_D6=4039, - XED_IFORM_VMOVQ_MEMu64_XMMu64_AVX512=4040, - XED_IFORM_VMOVQ_XMMdq_GPR64q=4041, - XED_IFORM_VMOVQ_XMMdq_MEMq_6E=4042, - XED_IFORM_VMOVQ_XMMdq_MEMq_7E=4043, - XED_IFORM_VMOVQ_XMMdq_XMMq_7E=4044, - XED_IFORM_VMOVQ_XMMdq_XMMq_D6=4045, - XED_IFORM_VMOVQ_XMMu64_GPR64u64_AVX512=4046, - XED_IFORM_VMOVQ_XMMu64_MEMu64_AVX512=4047, - XED_IFORM_VMOVQ_XMMu64_XMMu64_AVX512=4048, - XED_IFORM_VMOVSD_MEMf64_MASKmskw_XMMf64_AVX512=4049, - XED_IFORM_VMOVSD_MEMq_XMMq=4050, - XED_IFORM_VMOVSD_XMMdq_MEMq=4051, - XED_IFORM_VMOVSD_XMMdq_XMMdq_XMMq_10=4052, - XED_IFORM_VMOVSD_XMMdq_XMMdq_XMMq_11=4053, - XED_IFORM_VMOVSD_XMMf64_MASKmskw_MEMf64_AVX512=4054, - XED_IFORM_VMOVSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=4055, - XED_IFORM_VMOVSH_MEMf16_MASKmskw_XMMf16_AVX512=4056, - XED_IFORM_VMOVSH_XMMf16_MASKmskw_MEMf16_AVX512=4057, - XED_IFORM_VMOVSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=4058, - XED_IFORM_VMOVSHDUP_XMMdq_MEMdq=4059, - XED_IFORM_VMOVSHDUP_XMMdq_XMMdq=4060, - XED_IFORM_VMOVSHDUP_XMMf32_MASKmskw_MEMf32_AVX512=4061, - XED_IFORM_VMOVSHDUP_XMMf32_MASKmskw_XMMf32_AVX512=4062, - XED_IFORM_VMOVSHDUP_YMMf32_MASKmskw_MEMf32_AVX512=4063, - XED_IFORM_VMOVSHDUP_YMMf32_MASKmskw_YMMf32_AVX512=4064, - XED_IFORM_VMOVSHDUP_YMMqq_MEMqq=4065, - XED_IFORM_VMOVSHDUP_YMMqq_YMMqq=4066, - XED_IFORM_VMOVSHDUP_ZMMf32_MASKmskw_MEMf32_AVX512=4067, - XED_IFORM_VMOVSHDUP_ZMMf32_MASKmskw_ZMMf32_AVX512=4068, - XED_IFORM_VMOVSLDUP_XMMdq_MEMdq=4069, - XED_IFORM_VMOVSLDUP_XMMdq_XMMdq=4070, - XED_IFORM_VMOVSLDUP_XMMf32_MASKmskw_MEMf32_AVX512=4071, - XED_IFORM_VMOVSLDUP_XMMf32_MASKmskw_XMMf32_AVX512=4072, - XED_IFORM_VMOVSLDUP_YMMf32_MASKmskw_MEMf32_AVX512=4073, - XED_IFORM_VMOVSLDUP_YMMf32_MASKmskw_YMMf32_AVX512=4074, - XED_IFORM_VMOVSLDUP_YMMqq_MEMqq=4075, - XED_IFORM_VMOVSLDUP_YMMqq_YMMqq=4076, - XED_IFORM_VMOVSLDUP_ZMMf32_MASKmskw_MEMf32_AVX512=4077, - XED_IFORM_VMOVSLDUP_ZMMf32_MASKmskw_ZMMf32_AVX512=4078, - XED_IFORM_VMOVSS_MEMd_XMMd=4079, - XED_IFORM_VMOVSS_MEMf32_MASKmskw_XMMf32_AVX512=4080, - XED_IFORM_VMOVSS_XMMdq_MEMd=4081, - XED_IFORM_VMOVSS_XMMdq_XMMdq_XMMd_10=4082, - XED_IFORM_VMOVSS_XMMdq_XMMdq_XMMd_11=4083, - XED_IFORM_VMOVSS_XMMf32_MASKmskw_MEMf32_AVX512=4084, - XED_IFORM_VMOVSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=4085, - XED_IFORM_VMOVUPD_MEMdq_XMMdq=4086, - XED_IFORM_VMOVUPD_MEMf64_MASKmskw_XMMf64_AVX512=4087, - XED_IFORM_VMOVUPD_MEMf64_MASKmskw_YMMf64_AVX512=4088, - XED_IFORM_VMOVUPD_MEMf64_MASKmskw_ZMMf64_AVX512=4089, - XED_IFORM_VMOVUPD_MEMqq_YMMqq=4090, - XED_IFORM_VMOVUPD_XMMdq_MEMdq=4091, - XED_IFORM_VMOVUPD_XMMdq_XMMdq_10=4092, - XED_IFORM_VMOVUPD_XMMdq_XMMdq_11=4093, - XED_IFORM_VMOVUPD_XMMf64_MASKmskw_MEMf64_AVX512=4094, - XED_IFORM_VMOVUPD_XMMf64_MASKmskw_XMMf64_AVX512=4095, - XED_IFORM_VMOVUPD_YMMf64_MASKmskw_MEMf64_AVX512=4096, - XED_IFORM_VMOVUPD_YMMf64_MASKmskw_YMMf64_AVX512=4097, - XED_IFORM_VMOVUPD_YMMqq_MEMqq=4098, - XED_IFORM_VMOVUPD_YMMqq_YMMqq_10=4099, - XED_IFORM_VMOVUPD_YMMqq_YMMqq_11=4100, - XED_IFORM_VMOVUPD_ZMMf64_MASKmskw_MEMf64_AVX512=4101, - XED_IFORM_VMOVUPD_ZMMf64_MASKmskw_ZMMf64_AVX512=4102, - XED_IFORM_VMOVUPS_MEMdq_XMMdq=4103, - XED_IFORM_VMOVUPS_MEMf32_MASKmskw_XMMf32_AVX512=4104, - XED_IFORM_VMOVUPS_MEMf32_MASKmskw_YMMf32_AVX512=4105, - XED_IFORM_VMOVUPS_MEMf32_MASKmskw_ZMMf32_AVX512=4106, - XED_IFORM_VMOVUPS_MEMqq_YMMqq=4107, - XED_IFORM_VMOVUPS_XMMdq_MEMdq=4108, - XED_IFORM_VMOVUPS_XMMdq_XMMdq_10=4109, - XED_IFORM_VMOVUPS_XMMdq_XMMdq_11=4110, - XED_IFORM_VMOVUPS_XMMf32_MASKmskw_MEMf32_AVX512=4111, - XED_IFORM_VMOVUPS_XMMf32_MASKmskw_XMMf32_AVX512=4112, - XED_IFORM_VMOVUPS_YMMf32_MASKmskw_MEMf32_AVX512=4113, - XED_IFORM_VMOVUPS_YMMf32_MASKmskw_YMMf32_AVX512=4114, - XED_IFORM_VMOVUPS_YMMqq_MEMqq=4115, - XED_IFORM_VMOVUPS_YMMqq_YMMqq_10=4116, - XED_IFORM_VMOVUPS_YMMqq_YMMqq_11=4117, - XED_IFORM_VMOVUPS_ZMMf32_MASKmskw_MEMf32_AVX512=4118, - XED_IFORM_VMOVUPS_ZMMf32_MASKmskw_ZMMf32_AVX512=4119, - XED_IFORM_VMOVW_GPR32f16_XMMf16_AVX512=4120, - XED_IFORM_VMOVW_MEMf16_XMMf16_AVX512=4121, - XED_IFORM_VMOVW_XMMf16_GPR32f16_AVX512=4122, - XED_IFORM_VMOVW_XMMf16_MEMf16_AVX512=4123, - XED_IFORM_VMPSADBW_XMMdq_XMMdq_MEMdq_IMMb=4124, - XED_IFORM_VMPSADBW_XMMdq_XMMdq_XMMdq_IMMb=4125, - XED_IFORM_VMPSADBW_YMMqq_YMMqq_MEMqq_IMMb=4126, - XED_IFORM_VMPSADBW_YMMqq_YMMqq_YMMqq_IMMb=4127, - XED_IFORM_VMPTRLD_MEMq=4128, - XED_IFORM_VMPTRST_MEMq=4129, - XED_IFORM_VMREAD_GPR32_GPR32=4130, - XED_IFORM_VMREAD_GPR64_GPR64=4131, - XED_IFORM_VMREAD_MEMd_GPR32=4132, - XED_IFORM_VMREAD_MEMq_GPR64=4133, - XED_IFORM_VMRESUME=4134, - XED_IFORM_VMRUN_ArAX=4135, - XED_IFORM_VMSAVE=4136, - XED_IFORM_VMULPD_XMMdq_XMMdq_MEMdq=4137, - XED_IFORM_VMULPD_XMMdq_XMMdq_XMMdq=4138, - XED_IFORM_VMULPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=4139, - XED_IFORM_VMULPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=4140, - XED_IFORM_VMULPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=4141, - XED_IFORM_VMULPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=4142, - XED_IFORM_VMULPD_YMMqq_YMMqq_MEMqq=4143, - XED_IFORM_VMULPD_YMMqq_YMMqq_YMMqq=4144, - XED_IFORM_VMULPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=4145, - XED_IFORM_VMULPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=4146, - XED_IFORM_VMULPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=4147, - XED_IFORM_VMULPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=4148, - XED_IFORM_VMULPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=4149, - XED_IFORM_VMULPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=4150, - XED_IFORM_VMULPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=4151, - XED_IFORM_VMULPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=4152, - XED_IFORM_VMULPS_XMMdq_XMMdq_MEMdq=4153, - XED_IFORM_VMULPS_XMMdq_XMMdq_XMMdq=4154, - XED_IFORM_VMULPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=4155, - XED_IFORM_VMULPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=4156, - XED_IFORM_VMULPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=4157, - XED_IFORM_VMULPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=4158, - XED_IFORM_VMULPS_YMMqq_YMMqq_MEMqq=4159, - XED_IFORM_VMULPS_YMMqq_YMMqq_YMMqq=4160, - XED_IFORM_VMULPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=4161, - XED_IFORM_VMULPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=4162, - XED_IFORM_VMULSD_XMMdq_XMMdq_MEMq=4163, - XED_IFORM_VMULSD_XMMdq_XMMdq_XMMq=4164, - XED_IFORM_VMULSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=4165, - XED_IFORM_VMULSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=4166, - XED_IFORM_VMULSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=4167, - XED_IFORM_VMULSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=4168, - XED_IFORM_VMULSS_XMMdq_XMMdq_MEMd=4169, - XED_IFORM_VMULSS_XMMdq_XMMdq_XMMd=4170, - XED_IFORM_VMULSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=4171, - XED_IFORM_VMULSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=4172, - XED_IFORM_VMWRITE_GPR32_GPR32=4173, - XED_IFORM_VMWRITE_GPR32_MEMd=4174, - XED_IFORM_VMWRITE_GPR64_GPR64=4175, - XED_IFORM_VMWRITE_GPR64_MEMq=4176, - XED_IFORM_VMXOFF=4177, - XED_IFORM_VMXON_MEMq=4178, - XED_IFORM_VORPD_XMMdq_XMMdq_MEMdq=4179, - XED_IFORM_VORPD_XMMdq_XMMdq_XMMdq=4180, - XED_IFORM_VORPD_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4181, - XED_IFORM_VORPD_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4182, - XED_IFORM_VORPD_YMMqq_YMMqq_MEMqq=4183, - XED_IFORM_VORPD_YMMqq_YMMqq_YMMqq=4184, - XED_IFORM_VORPD_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4185, - XED_IFORM_VORPD_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4186, - XED_IFORM_VORPD_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4187, - XED_IFORM_VORPD_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4188, - XED_IFORM_VORPS_XMMdq_XMMdq_MEMdq=4189, - XED_IFORM_VORPS_XMMdq_XMMdq_XMMdq=4190, - XED_IFORM_VORPS_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4191, - XED_IFORM_VORPS_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4192, - XED_IFORM_VORPS_YMMqq_YMMqq_MEMqq=4193, - XED_IFORM_VORPS_YMMqq_YMMqq_YMMqq=4194, - XED_IFORM_VORPS_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4195, - XED_IFORM_VORPS_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4196, - XED_IFORM_VORPS_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4197, - XED_IFORM_VORPS_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4198, - XED_IFORM_VP2INTERSECTD_MASKmskw_XMMu32_MEMu32_AVX512=4199, - XED_IFORM_VP2INTERSECTD_MASKmskw_XMMu32_XMMu32_AVX512=4200, - XED_IFORM_VP2INTERSECTD_MASKmskw_YMMu32_MEMu32_AVX512=4201, - XED_IFORM_VP2INTERSECTD_MASKmskw_YMMu32_YMMu32_AVX512=4202, - XED_IFORM_VP2INTERSECTD_MASKmskw_ZMMu32_MEMu32_AVX512=4203, - XED_IFORM_VP2INTERSECTD_MASKmskw_ZMMu32_ZMMu32_AVX512=4204, - XED_IFORM_VP2INTERSECTQ_MASKmskw_XMMu64_MEMu64_AVX512=4205, - XED_IFORM_VP2INTERSECTQ_MASKmskw_XMMu64_XMMu64_AVX512=4206, - XED_IFORM_VP2INTERSECTQ_MASKmskw_YMMu64_MEMu64_AVX512=4207, - XED_IFORM_VP2INTERSECTQ_MASKmskw_YMMu64_YMMu64_AVX512=4208, - XED_IFORM_VP2INTERSECTQ_MASKmskw_ZMMu64_MEMu64_AVX512=4209, - XED_IFORM_VP2INTERSECTQ_MASKmskw_ZMMu64_ZMMu64_AVX512=4210, - XED_IFORM_VP4DPWSSD_ZMMi32_MASKmskw_ZMMi16_MEMu32_AVX512=4211, - XED_IFORM_VP4DPWSSDS_ZMMi32_MASKmskw_ZMMi16_MEMu32_AVX512=4212, - XED_IFORM_VPABSB_XMMdq_MEMdq=4213, - XED_IFORM_VPABSB_XMMdq_XMMdq=4214, - XED_IFORM_VPABSB_XMMi8_MASKmskw_MEMi8_AVX512=4215, - XED_IFORM_VPABSB_XMMi8_MASKmskw_XMMi8_AVX512=4216, - XED_IFORM_VPABSB_YMMi8_MASKmskw_MEMi8_AVX512=4217, - XED_IFORM_VPABSB_YMMi8_MASKmskw_YMMi8_AVX512=4218, - XED_IFORM_VPABSB_YMMqq_MEMqq=4219, - XED_IFORM_VPABSB_YMMqq_YMMqq=4220, - XED_IFORM_VPABSB_ZMMi8_MASKmskw_MEMi8_AVX512=4221, - XED_IFORM_VPABSB_ZMMi8_MASKmskw_ZMMi8_AVX512=4222, - XED_IFORM_VPABSD_XMMdq_MEMdq=4223, - XED_IFORM_VPABSD_XMMdq_XMMdq=4224, - XED_IFORM_VPABSD_XMMi32_MASKmskw_MEMi32_AVX512=4225, - XED_IFORM_VPABSD_XMMi32_MASKmskw_XMMi32_AVX512=4226, - XED_IFORM_VPABSD_YMMi32_MASKmskw_MEMi32_AVX512=4227, - XED_IFORM_VPABSD_YMMi32_MASKmskw_YMMi32_AVX512=4228, - XED_IFORM_VPABSD_YMMqq_MEMqq=4229, - XED_IFORM_VPABSD_YMMqq_YMMqq=4230, - XED_IFORM_VPABSD_ZMMi32_MASKmskw_MEMi32_AVX512=4231, - XED_IFORM_VPABSD_ZMMi32_MASKmskw_ZMMi32_AVX512=4232, - XED_IFORM_VPABSQ_XMMi64_MASKmskw_MEMi64_AVX512=4233, - XED_IFORM_VPABSQ_XMMi64_MASKmskw_XMMi64_AVX512=4234, - XED_IFORM_VPABSQ_YMMi64_MASKmskw_MEMi64_AVX512=4235, - XED_IFORM_VPABSQ_YMMi64_MASKmskw_YMMi64_AVX512=4236, - XED_IFORM_VPABSQ_ZMMi64_MASKmskw_MEMi64_AVX512=4237, - XED_IFORM_VPABSQ_ZMMi64_MASKmskw_ZMMi64_AVX512=4238, - XED_IFORM_VPABSW_XMMdq_MEMdq=4239, - XED_IFORM_VPABSW_XMMdq_XMMdq=4240, - XED_IFORM_VPABSW_XMMi16_MASKmskw_MEMi16_AVX512=4241, - XED_IFORM_VPABSW_XMMi16_MASKmskw_XMMi16_AVX512=4242, - XED_IFORM_VPABSW_YMMi16_MASKmskw_MEMi16_AVX512=4243, - XED_IFORM_VPABSW_YMMi16_MASKmskw_YMMi16_AVX512=4244, - XED_IFORM_VPABSW_YMMqq_MEMqq=4245, - XED_IFORM_VPABSW_YMMqq_YMMqq=4246, - XED_IFORM_VPABSW_ZMMi16_MASKmskw_MEMi16_AVX512=4247, - XED_IFORM_VPABSW_ZMMi16_MASKmskw_ZMMi16_AVX512=4248, - XED_IFORM_VPACKSSDW_XMMdq_XMMdq_MEMdq=4249, - XED_IFORM_VPACKSSDW_XMMdq_XMMdq_XMMdq=4250, - XED_IFORM_VPACKSSDW_XMMi16_MASKmskw_XMMi32_MEMi32_AVX512=4251, - XED_IFORM_VPACKSSDW_XMMi16_MASKmskw_XMMi32_XMMi32_AVX512=4252, - XED_IFORM_VPACKSSDW_YMMi16_MASKmskw_YMMi32_MEMi32_AVX512=4253, - XED_IFORM_VPACKSSDW_YMMi16_MASKmskw_YMMi32_YMMi32_AVX512=4254, - XED_IFORM_VPACKSSDW_YMMqq_YMMqq_MEMqq=4255, - XED_IFORM_VPACKSSDW_YMMqq_YMMqq_YMMqq=4256, - XED_IFORM_VPACKSSDW_ZMMi16_MASKmskw_ZMMi32_MEMi32_AVX512=4257, - XED_IFORM_VPACKSSDW_ZMMi16_MASKmskw_ZMMi32_ZMMi32_AVX512=4258, - XED_IFORM_VPACKSSWB_XMMdq_XMMdq_MEMdq=4259, - XED_IFORM_VPACKSSWB_XMMdq_XMMdq_XMMdq=4260, - XED_IFORM_VPACKSSWB_XMMi8_MASKmskw_XMMi16_MEMi16_AVX512=4261, - XED_IFORM_VPACKSSWB_XMMi8_MASKmskw_XMMi16_XMMi16_AVX512=4262, - XED_IFORM_VPACKSSWB_YMMi8_MASKmskw_YMMi16_MEMi16_AVX512=4263, - XED_IFORM_VPACKSSWB_YMMi8_MASKmskw_YMMi16_YMMi16_AVX512=4264, - XED_IFORM_VPACKSSWB_YMMqq_YMMqq_MEMqq=4265, - XED_IFORM_VPACKSSWB_YMMqq_YMMqq_YMMqq=4266, - XED_IFORM_VPACKSSWB_ZMMi8_MASKmskw_ZMMi16_MEMi16_AVX512=4267, - XED_IFORM_VPACKSSWB_ZMMi8_MASKmskw_ZMMi16_ZMMi16_AVX512=4268, - XED_IFORM_VPACKUSDW_XMMdq_XMMdq_MEMdq=4269, - XED_IFORM_VPACKUSDW_XMMdq_XMMdq_XMMdq=4270, - XED_IFORM_VPACKUSDW_XMMu16_MASKmskw_XMMu32_MEMu32_AVX512=4271, - XED_IFORM_VPACKUSDW_XMMu16_MASKmskw_XMMu32_XMMu32_AVX512=4272, - XED_IFORM_VPACKUSDW_YMMqq_YMMqq_MEMqq=4273, - XED_IFORM_VPACKUSDW_YMMqq_YMMqq_YMMqq=4274, - XED_IFORM_VPACKUSDW_YMMu16_MASKmskw_YMMu32_MEMu32_AVX512=4275, - XED_IFORM_VPACKUSDW_YMMu16_MASKmskw_YMMu32_YMMu32_AVX512=4276, - XED_IFORM_VPACKUSDW_ZMMu16_MASKmskw_ZMMu32_MEMu32_AVX512=4277, - XED_IFORM_VPACKUSDW_ZMMu16_MASKmskw_ZMMu32_ZMMu32_AVX512=4278, - XED_IFORM_VPACKUSWB_XMMdq_XMMdq_MEMdq=4279, - XED_IFORM_VPACKUSWB_XMMdq_XMMdq_XMMdq=4280, - XED_IFORM_VPACKUSWB_XMMu8_MASKmskw_XMMu16_MEMu16_AVX512=4281, - XED_IFORM_VPACKUSWB_XMMu8_MASKmskw_XMMu16_XMMu16_AVX512=4282, - XED_IFORM_VPACKUSWB_YMMqq_YMMqq_MEMqq=4283, - XED_IFORM_VPACKUSWB_YMMqq_YMMqq_YMMqq=4284, - XED_IFORM_VPACKUSWB_YMMu8_MASKmskw_YMMu16_MEMu16_AVX512=4285, - XED_IFORM_VPACKUSWB_YMMu8_MASKmskw_YMMu16_YMMu16_AVX512=4286, - XED_IFORM_VPACKUSWB_ZMMu8_MASKmskw_ZMMu16_MEMu16_AVX512=4287, - XED_IFORM_VPACKUSWB_ZMMu8_MASKmskw_ZMMu16_ZMMu16_AVX512=4288, - XED_IFORM_VPADDB_XMMdq_XMMdq_MEMdq=4289, - XED_IFORM_VPADDB_XMMdq_XMMdq_XMMdq=4290, - XED_IFORM_VPADDB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4291, - XED_IFORM_VPADDB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4292, - XED_IFORM_VPADDB_YMMqq_YMMqq_MEMqq=4293, - XED_IFORM_VPADDB_YMMqq_YMMqq_YMMqq=4294, - XED_IFORM_VPADDB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4295, - XED_IFORM_VPADDB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4296, - XED_IFORM_VPADDB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4297, - XED_IFORM_VPADDB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4298, - XED_IFORM_VPADDD_XMMdq_XMMdq_MEMdq=4299, - XED_IFORM_VPADDD_XMMdq_XMMdq_XMMdq=4300, - XED_IFORM_VPADDD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4301, - XED_IFORM_VPADDD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4302, - XED_IFORM_VPADDD_YMMqq_YMMqq_MEMqq=4303, - XED_IFORM_VPADDD_YMMqq_YMMqq_YMMqq=4304, - XED_IFORM_VPADDD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4305, - XED_IFORM_VPADDD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4306, - XED_IFORM_VPADDD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4307, - XED_IFORM_VPADDD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4308, - XED_IFORM_VPADDQ_XMMdq_XMMdq_MEMdq=4309, - XED_IFORM_VPADDQ_XMMdq_XMMdq_XMMdq=4310, - XED_IFORM_VPADDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4311, - XED_IFORM_VPADDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4312, - XED_IFORM_VPADDQ_YMMqq_YMMqq_MEMqq=4313, - XED_IFORM_VPADDQ_YMMqq_YMMqq_YMMqq=4314, - XED_IFORM_VPADDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4315, - XED_IFORM_VPADDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4316, - XED_IFORM_VPADDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4317, - XED_IFORM_VPADDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4318, - XED_IFORM_VPADDSB_XMMdq_XMMdq_MEMdq=4319, - XED_IFORM_VPADDSB_XMMdq_XMMdq_XMMdq=4320, - XED_IFORM_VPADDSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512=4321, - XED_IFORM_VPADDSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512=4322, - XED_IFORM_VPADDSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512=4323, - XED_IFORM_VPADDSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512=4324, - XED_IFORM_VPADDSB_YMMqq_YMMqq_MEMqq=4325, - XED_IFORM_VPADDSB_YMMqq_YMMqq_YMMqq=4326, - XED_IFORM_VPADDSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512=4327, - XED_IFORM_VPADDSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512=4328, - XED_IFORM_VPADDSW_XMMdq_XMMdq_MEMdq=4329, - XED_IFORM_VPADDSW_XMMdq_XMMdq_XMMdq=4330, - XED_IFORM_VPADDSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=4331, - XED_IFORM_VPADDSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=4332, - XED_IFORM_VPADDSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=4333, - XED_IFORM_VPADDSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=4334, - XED_IFORM_VPADDSW_YMMqq_YMMqq_MEMqq=4335, - XED_IFORM_VPADDSW_YMMqq_YMMqq_YMMqq=4336, - XED_IFORM_VPADDSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=4337, - XED_IFORM_VPADDSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=4338, - XED_IFORM_VPADDUSB_XMMdq_XMMdq_MEMdq=4339, - XED_IFORM_VPADDUSB_XMMdq_XMMdq_XMMdq=4340, - XED_IFORM_VPADDUSB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4341, - XED_IFORM_VPADDUSB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4342, - XED_IFORM_VPADDUSB_YMMqq_YMMqq_MEMqq=4343, - XED_IFORM_VPADDUSB_YMMqq_YMMqq_YMMqq=4344, - XED_IFORM_VPADDUSB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4345, - XED_IFORM_VPADDUSB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4346, - XED_IFORM_VPADDUSB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4347, - XED_IFORM_VPADDUSB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4348, - XED_IFORM_VPADDUSW_XMMdq_XMMdq_MEMdq=4349, - XED_IFORM_VPADDUSW_XMMdq_XMMdq_XMMdq=4350, - XED_IFORM_VPADDUSW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4351, - XED_IFORM_VPADDUSW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4352, - XED_IFORM_VPADDUSW_YMMqq_YMMqq_MEMqq=4353, - XED_IFORM_VPADDUSW_YMMqq_YMMqq_YMMqq=4354, - XED_IFORM_VPADDUSW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4355, - XED_IFORM_VPADDUSW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4356, - XED_IFORM_VPADDUSW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4357, - XED_IFORM_VPADDUSW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4358, - XED_IFORM_VPADDW_XMMdq_XMMdq_MEMdq=4359, - XED_IFORM_VPADDW_XMMdq_XMMdq_XMMdq=4360, - XED_IFORM_VPADDW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4361, - XED_IFORM_VPADDW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4362, - XED_IFORM_VPADDW_YMMqq_YMMqq_MEMqq=4363, - XED_IFORM_VPADDW_YMMqq_YMMqq_YMMqq=4364, - XED_IFORM_VPADDW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4365, - XED_IFORM_VPADDW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4366, - XED_IFORM_VPADDW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4367, - XED_IFORM_VPADDW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4368, - XED_IFORM_VPALIGNR_XMMdq_XMMdq_MEMdq_IMMb=4369, - XED_IFORM_VPALIGNR_XMMdq_XMMdq_XMMdq_IMMb=4370, - XED_IFORM_VPALIGNR_XMMu8_MASKmskw_XMMu8_MEMu8_IMM8_AVX512=4371, - XED_IFORM_VPALIGNR_XMMu8_MASKmskw_XMMu8_XMMu8_IMM8_AVX512=4372, - XED_IFORM_VPALIGNR_YMMqq_YMMqq_MEMqq_IMMb=4373, - XED_IFORM_VPALIGNR_YMMqq_YMMqq_YMMqq_IMMb=4374, - XED_IFORM_VPALIGNR_YMMu8_MASKmskw_YMMu8_MEMu8_IMM8_AVX512=4375, - XED_IFORM_VPALIGNR_YMMu8_MASKmskw_YMMu8_YMMu8_IMM8_AVX512=4376, - XED_IFORM_VPALIGNR_ZMMu8_MASKmskw_ZMMu8_MEMu8_IMM8_AVX512=4377, - XED_IFORM_VPALIGNR_ZMMu8_MASKmskw_ZMMu8_ZMMu8_IMM8_AVX512=4378, - XED_IFORM_VPAND_XMMdq_XMMdq_MEMdq=4379, - XED_IFORM_VPAND_XMMdq_XMMdq_XMMdq=4380, - XED_IFORM_VPAND_YMMqq_YMMqq_MEMqq=4381, - XED_IFORM_VPAND_YMMqq_YMMqq_YMMqq=4382, - XED_IFORM_VPANDD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4383, - XED_IFORM_VPANDD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4384, - XED_IFORM_VPANDD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4385, - XED_IFORM_VPANDD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4386, - XED_IFORM_VPANDD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4387, - XED_IFORM_VPANDD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4388, - XED_IFORM_VPANDN_XMMdq_XMMdq_MEMdq=4389, - XED_IFORM_VPANDN_XMMdq_XMMdq_XMMdq=4390, - XED_IFORM_VPANDN_YMMqq_YMMqq_MEMqq=4391, - XED_IFORM_VPANDN_YMMqq_YMMqq_YMMqq=4392, - XED_IFORM_VPANDND_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4393, - XED_IFORM_VPANDND_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4394, - XED_IFORM_VPANDND_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4395, - XED_IFORM_VPANDND_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4396, - XED_IFORM_VPANDND_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4397, - XED_IFORM_VPANDND_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4398, - XED_IFORM_VPANDNQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4399, - XED_IFORM_VPANDNQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4400, - XED_IFORM_VPANDNQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4401, - XED_IFORM_VPANDNQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4402, - XED_IFORM_VPANDNQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4403, - XED_IFORM_VPANDNQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4404, - XED_IFORM_VPANDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4405, - XED_IFORM_VPANDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4406, - XED_IFORM_VPANDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4407, - XED_IFORM_VPANDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4408, - XED_IFORM_VPANDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4409, - XED_IFORM_VPANDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4410, - XED_IFORM_VPAVGB_XMMdq_XMMdq_MEMdq=4411, - XED_IFORM_VPAVGB_XMMdq_XMMdq_XMMdq=4412, - XED_IFORM_VPAVGB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4413, - XED_IFORM_VPAVGB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4414, - XED_IFORM_VPAVGB_YMMqq_YMMqq_MEMqq=4415, - XED_IFORM_VPAVGB_YMMqq_YMMqq_YMMqq=4416, - XED_IFORM_VPAVGB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4417, - XED_IFORM_VPAVGB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4418, - XED_IFORM_VPAVGB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4419, - XED_IFORM_VPAVGB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4420, - XED_IFORM_VPAVGW_XMMdq_XMMdq_MEMdq=4421, - XED_IFORM_VPAVGW_XMMdq_XMMdq_XMMdq=4422, - XED_IFORM_VPAVGW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4423, - XED_IFORM_VPAVGW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4424, - XED_IFORM_VPAVGW_YMMqq_YMMqq_MEMqq=4425, - XED_IFORM_VPAVGW_YMMqq_YMMqq_YMMqq=4426, - XED_IFORM_VPAVGW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4427, - XED_IFORM_VPAVGW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4428, - XED_IFORM_VPAVGW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4429, - XED_IFORM_VPAVGW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4430, - XED_IFORM_VPBLENDD_XMMdq_XMMdq_MEMdq_IMMb=4431, - XED_IFORM_VPBLENDD_XMMdq_XMMdq_XMMdq_IMMb=4432, - XED_IFORM_VPBLENDD_YMMqq_YMMqq_MEMqq_IMMb=4433, - XED_IFORM_VPBLENDD_YMMqq_YMMqq_YMMqq_IMMb=4434, - XED_IFORM_VPBLENDMB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4435, - XED_IFORM_VPBLENDMB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4436, - XED_IFORM_VPBLENDMB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4437, - XED_IFORM_VPBLENDMB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4438, - XED_IFORM_VPBLENDMB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4439, - XED_IFORM_VPBLENDMB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4440, - XED_IFORM_VPBLENDMD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4441, - XED_IFORM_VPBLENDMD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4442, - XED_IFORM_VPBLENDMD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4443, - XED_IFORM_VPBLENDMD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4444, - XED_IFORM_VPBLENDMD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4445, - XED_IFORM_VPBLENDMD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4446, - XED_IFORM_VPBLENDMQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4447, - XED_IFORM_VPBLENDMQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4448, - XED_IFORM_VPBLENDMQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4449, - XED_IFORM_VPBLENDMQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4450, - XED_IFORM_VPBLENDMQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4451, - XED_IFORM_VPBLENDMQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4452, - XED_IFORM_VPBLENDMW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4453, - XED_IFORM_VPBLENDMW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4454, - XED_IFORM_VPBLENDMW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4455, - XED_IFORM_VPBLENDMW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4456, - XED_IFORM_VPBLENDMW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4457, - XED_IFORM_VPBLENDMW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4458, - XED_IFORM_VPBLENDVB_XMMdq_XMMdq_MEMdq_XMMdq=4459, - XED_IFORM_VPBLENDVB_XMMdq_XMMdq_XMMdq_XMMdq=4460, - XED_IFORM_VPBLENDVB_YMMqq_YMMqq_MEMqq_YMMqq=4461, - XED_IFORM_VPBLENDVB_YMMqq_YMMqq_YMMqq_YMMqq=4462, - XED_IFORM_VPBLENDW_XMMdq_XMMdq_MEMdq_IMMb=4463, - XED_IFORM_VPBLENDW_XMMdq_XMMdq_XMMdq_IMMb=4464, - XED_IFORM_VPBLENDW_YMMqq_YMMqq_MEMqq_IMMb=4465, - XED_IFORM_VPBLENDW_YMMqq_YMMqq_YMMqq_IMMb=4466, - XED_IFORM_VPBROADCASTB_XMMdq_MEMb=4467, - XED_IFORM_VPBROADCASTB_XMMdq_XMMb=4468, - XED_IFORM_VPBROADCASTB_XMMu8_MASKmskw_GPR32u8_AVX512=4469, - XED_IFORM_VPBROADCASTB_XMMu8_MASKmskw_MEMu8_AVX512=4470, - XED_IFORM_VPBROADCASTB_XMMu8_MASKmskw_XMMu8_AVX512=4471, - XED_IFORM_VPBROADCASTB_YMMqq_MEMb=4472, - XED_IFORM_VPBROADCASTB_YMMqq_XMMb=4473, - XED_IFORM_VPBROADCASTB_YMMu8_MASKmskw_GPR32u8_AVX512=4474, - XED_IFORM_VPBROADCASTB_YMMu8_MASKmskw_MEMu8_AVX512=4475, - XED_IFORM_VPBROADCASTB_YMMu8_MASKmskw_XMMu8_AVX512=4476, - XED_IFORM_VPBROADCASTB_ZMMu8_MASKmskw_GPR32u8_AVX512=4477, - XED_IFORM_VPBROADCASTB_ZMMu8_MASKmskw_MEMu8_AVX512=4478, - XED_IFORM_VPBROADCASTB_ZMMu8_MASKmskw_XMMu8_AVX512=4479, - XED_IFORM_VPBROADCASTD_XMMdq_MEMd=4480, - XED_IFORM_VPBROADCASTD_XMMdq_XMMd=4481, - XED_IFORM_VPBROADCASTD_XMMu32_MASKmskw_GPR32u32_AVX512=4482, - XED_IFORM_VPBROADCASTD_XMMu32_MASKmskw_MEMu32_AVX512=4483, - XED_IFORM_VPBROADCASTD_XMMu32_MASKmskw_XMMu32_AVX512=4484, - XED_IFORM_VPBROADCASTD_YMMqq_MEMd=4485, - XED_IFORM_VPBROADCASTD_YMMqq_XMMd=4486, - XED_IFORM_VPBROADCASTD_YMMu32_MASKmskw_GPR32u32_AVX512=4487, - XED_IFORM_VPBROADCASTD_YMMu32_MASKmskw_MEMu32_AVX512=4488, - XED_IFORM_VPBROADCASTD_YMMu32_MASKmskw_XMMu32_AVX512=4489, - XED_IFORM_VPBROADCASTD_ZMMu32_MASKmskw_GPR32u32_AVX512=4490, - XED_IFORM_VPBROADCASTD_ZMMu32_MASKmskw_MEMu32_AVX512=4491, - XED_IFORM_VPBROADCASTD_ZMMu32_MASKmskw_XMMu32_AVX512=4492, - XED_IFORM_VPBROADCASTMB2Q_XMMu64_MASKu64_AVX512=4493, - XED_IFORM_VPBROADCASTMB2Q_YMMu64_MASKu64_AVX512=4494, - XED_IFORM_VPBROADCASTMB2Q_ZMMu64_MASKu64_AVX512CD=4495, - XED_IFORM_VPBROADCASTMW2D_XMMu32_MASKu32_AVX512=4496, - XED_IFORM_VPBROADCASTMW2D_YMMu32_MASKu32_AVX512=4497, - XED_IFORM_VPBROADCASTMW2D_ZMMu32_MASKu32_AVX512CD=4498, - XED_IFORM_VPBROADCASTQ_XMMdq_MEMq=4499, - XED_IFORM_VPBROADCASTQ_XMMdq_XMMq=4500, - XED_IFORM_VPBROADCASTQ_XMMu64_MASKmskw_GPR64u64_AVX512=4501, - XED_IFORM_VPBROADCASTQ_XMMu64_MASKmskw_MEMu64_AVX512=4502, - XED_IFORM_VPBROADCASTQ_XMMu64_MASKmskw_XMMu64_AVX512=4503, - XED_IFORM_VPBROADCASTQ_YMMqq_MEMq=4504, - XED_IFORM_VPBROADCASTQ_YMMqq_XMMq=4505, - XED_IFORM_VPBROADCASTQ_YMMu64_MASKmskw_GPR64u64_AVX512=4506, - XED_IFORM_VPBROADCASTQ_YMMu64_MASKmskw_MEMu64_AVX512=4507, - XED_IFORM_VPBROADCASTQ_YMMu64_MASKmskw_XMMu64_AVX512=4508, - XED_IFORM_VPBROADCASTQ_ZMMu64_MASKmskw_GPR64u64_AVX512=4509, - XED_IFORM_VPBROADCASTQ_ZMMu64_MASKmskw_MEMu64_AVX512=4510, - XED_IFORM_VPBROADCASTQ_ZMMu64_MASKmskw_XMMu64_AVX512=4511, - XED_IFORM_VPBROADCASTW_XMMdq_MEMw=4512, - XED_IFORM_VPBROADCASTW_XMMdq_XMMw=4513, - XED_IFORM_VPBROADCASTW_XMMu16_MASKmskw_GPR32u16_AVX512=4514, - XED_IFORM_VPBROADCASTW_XMMu16_MASKmskw_MEMu16_AVX512=4515, - XED_IFORM_VPBROADCASTW_XMMu16_MASKmskw_XMMu16_AVX512=4516, - XED_IFORM_VPBROADCASTW_YMMqq_MEMw=4517, - XED_IFORM_VPBROADCASTW_YMMqq_XMMw=4518, - XED_IFORM_VPBROADCASTW_YMMu16_MASKmskw_GPR32u16_AVX512=4519, - XED_IFORM_VPBROADCASTW_YMMu16_MASKmskw_MEMu16_AVX512=4520, - XED_IFORM_VPBROADCASTW_YMMu16_MASKmskw_XMMu16_AVX512=4521, - XED_IFORM_VPBROADCASTW_ZMMu16_MASKmskw_GPR32u16_AVX512=4522, - XED_IFORM_VPBROADCASTW_ZMMu16_MASKmskw_MEMu16_AVX512=4523, - XED_IFORM_VPBROADCASTW_ZMMu16_MASKmskw_XMMu16_AVX512=4524, - XED_IFORM_VPCLMULQDQ_XMMdq_XMMdq_MEMdq_IMMb=4525, - XED_IFORM_VPCLMULQDQ_XMMdq_XMMdq_XMMdq_IMMb=4526, - XED_IFORM_VPCLMULQDQ_XMMu128_XMMu64_MEMu64_IMM8_AVX512=4527, - XED_IFORM_VPCLMULQDQ_XMMu128_XMMu64_XMMu64_IMM8_AVX512=4528, - XED_IFORM_VPCLMULQDQ_YMMu128_YMMu64_MEMu64_IMM8=4529, - XED_IFORM_VPCLMULQDQ_YMMu128_YMMu64_MEMu64_IMM8_AVX512=4530, - XED_IFORM_VPCLMULQDQ_YMMu128_YMMu64_YMMu64_IMM8=4531, - XED_IFORM_VPCLMULQDQ_YMMu128_YMMu64_YMMu64_IMM8_AVX512=4532, - XED_IFORM_VPCLMULQDQ_ZMMu128_ZMMu64_MEMu64_IMM8_AVX512=4533, - XED_IFORM_VPCLMULQDQ_ZMMu128_ZMMu64_ZMMu64_IMM8_AVX512=4534, - XED_IFORM_VPCMOV_XMMdq_XMMdq_MEMdq_XMMdq=4535, - XED_IFORM_VPCMOV_XMMdq_XMMdq_XMMdq_MEMdq=4536, - XED_IFORM_VPCMOV_XMMdq_XMMdq_XMMdq_XMMdq=4537, - XED_IFORM_VPCMOV_YMMqq_YMMqq_MEMqq_YMMqq=4538, - XED_IFORM_VPCMOV_YMMqq_YMMqq_YMMqq_MEMqq=4539, - XED_IFORM_VPCMOV_YMMqq_YMMqq_YMMqq_YMMqq=4540, - XED_IFORM_VPCMPB_MASKmskw_MASKmskw_XMMi8_MEMi8_IMM8_AVX512=4541, - XED_IFORM_VPCMPB_MASKmskw_MASKmskw_XMMi8_XMMi8_IMM8_AVX512=4542, - XED_IFORM_VPCMPB_MASKmskw_MASKmskw_YMMi8_MEMi8_IMM8_AVX512=4543, - XED_IFORM_VPCMPB_MASKmskw_MASKmskw_YMMi8_YMMi8_IMM8_AVX512=4544, - XED_IFORM_VPCMPB_MASKmskw_MASKmskw_ZMMi8_MEMi8_IMM8_AVX512=4545, - XED_IFORM_VPCMPB_MASKmskw_MASKmskw_ZMMi8_ZMMi8_IMM8_AVX512=4546, - XED_IFORM_VPCMPD_MASKmskw_MASKmskw_XMMi32_MEMi32_IMM8_AVX512=4547, - XED_IFORM_VPCMPD_MASKmskw_MASKmskw_XMMi32_XMMi32_IMM8_AVX512=4548, - XED_IFORM_VPCMPD_MASKmskw_MASKmskw_YMMi32_MEMi32_IMM8_AVX512=4549, - XED_IFORM_VPCMPD_MASKmskw_MASKmskw_YMMi32_YMMi32_IMM8_AVX512=4550, - XED_IFORM_VPCMPD_MASKmskw_MASKmskw_ZMMi32_MEMi32_IMM8_AVX512=4551, - XED_IFORM_VPCMPD_MASKmskw_MASKmskw_ZMMi32_ZMMi32_IMM8_AVX512=4552, - XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512=4553, - XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512=4554, - XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512=4555, - XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512=4556, - XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512=4557, - XED_IFORM_VPCMPEQB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512=4558, - XED_IFORM_VPCMPEQB_XMMdq_XMMdq_MEMdq=4559, - XED_IFORM_VPCMPEQB_XMMdq_XMMdq_XMMdq=4560, - XED_IFORM_VPCMPEQB_YMMqq_YMMqq_MEMqq=4561, - XED_IFORM_VPCMPEQB_YMMqq_YMMqq_YMMqq=4562, - XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_XMMu32_MEMu32_AVX512=4563, - XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_XMMu32_XMMu32_AVX512=4564, - XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_YMMu32_MEMu32_AVX512=4565, - XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_YMMu32_YMMu32_AVX512=4566, - XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_ZMMu32_MEMu32_AVX512=4567, - XED_IFORM_VPCMPEQD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_AVX512=4568, - XED_IFORM_VPCMPEQD_XMMdq_XMMdq_MEMdq=4569, - XED_IFORM_VPCMPEQD_XMMdq_XMMdq_XMMdq=4570, - XED_IFORM_VPCMPEQD_YMMqq_YMMqq_MEMqq=4571, - XED_IFORM_VPCMPEQD_YMMqq_YMMqq_YMMqq=4572, - XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_XMMu64_MEMu64_AVX512=4573, - XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_XMMu64_XMMu64_AVX512=4574, - XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_YMMu64_MEMu64_AVX512=4575, - XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_YMMu64_YMMu64_AVX512=4576, - XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_AVX512=4577, - XED_IFORM_VPCMPEQQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_AVX512=4578, - XED_IFORM_VPCMPEQQ_XMMdq_XMMdq_MEMdq=4579, - XED_IFORM_VPCMPEQQ_XMMdq_XMMdq_XMMdq=4580, - XED_IFORM_VPCMPEQQ_YMMqq_YMMqq_MEMqq=4581, - XED_IFORM_VPCMPEQQ_YMMqq_YMMqq_YMMqq=4582, - XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512=4583, - XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512=4584, - XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512=4585, - XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512=4586, - XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512=4587, - XED_IFORM_VPCMPEQW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512=4588, - XED_IFORM_VPCMPEQW_XMMdq_XMMdq_MEMdq=4589, - XED_IFORM_VPCMPEQW_XMMdq_XMMdq_XMMdq=4590, - XED_IFORM_VPCMPEQW_YMMqq_YMMqq_MEMqq=4591, - XED_IFORM_VPCMPEQW_YMMqq_YMMqq_YMMqq=4592, - XED_IFORM_VPCMPESTRI_XMMdq_MEMdq_IMMb=4593, - XED_IFORM_VPCMPESTRI_XMMdq_XMMdq_IMMb=4594, - XED_IFORM_VPCMPESTRI64_XMMdq_MEMdq_IMMb=4595, - XED_IFORM_VPCMPESTRI64_XMMdq_XMMdq_IMMb=4596, - XED_IFORM_VPCMPESTRM_XMMdq_MEMdq_IMMb=4597, - XED_IFORM_VPCMPESTRM_XMMdq_XMMdq_IMMb=4598, - XED_IFORM_VPCMPESTRM64_XMMdq_MEMdq_IMMb=4599, - XED_IFORM_VPCMPESTRM64_XMMdq_XMMdq_IMMb=4600, - XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512=4601, - XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512=4602, - XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512=4603, - XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512=4604, - XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512=4605, - XED_IFORM_VPCMPGTB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512=4606, - XED_IFORM_VPCMPGTB_XMMdq_XMMdq_MEMdq=4607, - XED_IFORM_VPCMPGTB_XMMdq_XMMdq_XMMdq=4608, - XED_IFORM_VPCMPGTB_YMMqq_YMMqq_MEMqq=4609, - XED_IFORM_VPCMPGTB_YMMqq_YMMqq_YMMqq=4610, - XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_XMMi32_MEMi32_AVX512=4611, - XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_XMMi32_XMMi32_AVX512=4612, - XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_YMMi32_MEMi32_AVX512=4613, - XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_YMMi32_YMMi32_AVX512=4614, - XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_ZMMi32_MEMi32_AVX512=4615, - XED_IFORM_VPCMPGTD_MASKmskw_MASKmskw_ZMMi32_ZMMi32_AVX512=4616, - XED_IFORM_VPCMPGTD_XMMdq_XMMdq_MEMdq=4617, - XED_IFORM_VPCMPGTD_XMMdq_XMMdq_XMMdq=4618, - XED_IFORM_VPCMPGTD_YMMqq_YMMqq_MEMqq=4619, - XED_IFORM_VPCMPGTD_YMMqq_YMMqq_YMMqq=4620, - XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_XMMi64_MEMi64_AVX512=4621, - XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_XMMi64_XMMi64_AVX512=4622, - XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_YMMi64_MEMi64_AVX512=4623, - XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_YMMi64_YMMi64_AVX512=4624, - XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_ZMMi64_MEMi64_AVX512=4625, - XED_IFORM_VPCMPGTQ_MASKmskw_MASKmskw_ZMMi64_ZMMi64_AVX512=4626, - XED_IFORM_VPCMPGTQ_XMMdq_XMMdq_MEMdq=4627, - XED_IFORM_VPCMPGTQ_XMMdq_XMMdq_XMMdq=4628, - XED_IFORM_VPCMPGTQ_YMMqq_YMMqq_MEMqq=4629, - XED_IFORM_VPCMPGTQ_YMMqq_YMMqq_YMMqq=4630, - XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512=4631, - XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512=4632, - XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512=4633, - XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512=4634, - XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512=4635, - XED_IFORM_VPCMPGTW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512=4636, - XED_IFORM_VPCMPGTW_XMMdq_XMMdq_MEMdq=4637, - XED_IFORM_VPCMPGTW_XMMdq_XMMdq_XMMdq=4638, - XED_IFORM_VPCMPGTW_YMMqq_YMMqq_MEMqq=4639, - XED_IFORM_VPCMPGTW_YMMqq_YMMqq_YMMqq=4640, - XED_IFORM_VPCMPISTRI_XMMdq_MEMdq_IMMb=4641, - XED_IFORM_VPCMPISTRI_XMMdq_XMMdq_IMMb=4642, - XED_IFORM_VPCMPISTRI64_XMMdq_MEMdq_IMMb=4643, - XED_IFORM_VPCMPISTRI64_XMMdq_XMMdq_IMMb=4644, - XED_IFORM_VPCMPISTRM_XMMdq_MEMdq_IMMb=4645, - XED_IFORM_VPCMPISTRM_XMMdq_XMMdq_IMMb=4646, - XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_XMMi64_MEMi64_IMM8_AVX512=4647, - XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_XMMi64_XMMi64_IMM8_AVX512=4648, - XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_YMMi64_MEMi64_IMM8_AVX512=4649, - XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_YMMi64_YMMi64_IMM8_AVX512=4650, - XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_ZMMi64_MEMi64_IMM8_AVX512=4651, - XED_IFORM_VPCMPQ_MASKmskw_MASKmskw_ZMMi64_ZMMi64_IMM8_AVX512=4652, - XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_XMMu8_MEMu8_IMM8_AVX512=4653, - XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_XMMu8_XMMu8_IMM8_AVX512=4654, - XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_YMMu8_MEMu8_IMM8_AVX512=4655, - XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_YMMu8_YMMu8_IMM8_AVX512=4656, - XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_ZMMu8_MEMu8_IMM8_AVX512=4657, - XED_IFORM_VPCMPUB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_IMM8_AVX512=4658, - XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_XMMu32_MEMu32_IMM8_AVX512=4659, - XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_XMMu32_XMMu32_IMM8_AVX512=4660, - XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=4661, - XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_YMMu32_YMMu32_IMM8_AVX512=4662, - XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=4663, - XED_IFORM_VPCMPUD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512=4664, - XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_XMMu64_MEMu64_IMM8_AVX512=4665, - XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_XMMu64_XMMu64_IMM8_AVX512=4666, - XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=4667, - XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_YMMu64_YMMu64_IMM8_AVX512=4668, - XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=4669, - XED_IFORM_VPCMPUQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512=4670, - XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_XMMu16_MEMu16_IMM8_AVX512=4671, - XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_XMMu16_XMMu16_IMM8_AVX512=4672, - XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_YMMu16_MEMu16_IMM8_AVX512=4673, - XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_YMMu16_YMMu16_IMM8_AVX512=4674, - XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_ZMMu16_MEMu16_IMM8_AVX512=4675, - XED_IFORM_VPCMPUW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_IMM8_AVX512=4676, - XED_IFORM_VPCMPW_MASKmskw_MASKmskw_XMMi16_MEMi16_IMM8_AVX512=4677, - XED_IFORM_VPCMPW_MASKmskw_MASKmskw_XMMi16_XMMi16_IMM8_AVX512=4678, - XED_IFORM_VPCMPW_MASKmskw_MASKmskw_YMMi16_MEMi16_IMM8_AVX512=4679, - XED_IFORM_VPCMPW_MASKmskw_MASKmskw_YMMi16_YMMi16_IMM8_AVX512=4680, - XED_IFORM_VPCMPW_MASKmskw_MASKmskw_ZMMi16_MEMi16_IMM8_AVX512=4681, - XED_IFORM_VPCMPW_MASKmskw_MASKmskw_ZMMi16_ZMMi16_IMM8_AVX512=4682, - XED_IFORM_VPCOMB_XMMdq_XMMdq_MEMdq_IMMb=4683, - XED_IFORM_VPCOMB_XMMdq_XMMdq_XMMdq_IMMb=4684, - XED_IFORM_VPCOMD_XMMdq_XMMdq_MEMdq_IMMb=4685, - XED_IFORM_VPCOMD_XMMdq_XMMdq_XMMdq_IMMb=4686, - XED_IFORM_VPCOMPRESSB_MEMu8_MASKmskw_XMMu8_AVX512=4687, - XED_IFORM_VPCOMPRESSB_MEMu8_MASKmskw_YMMu8_AVX512=4688, - XED_IFORM_VPCOMPRESSB_MEMu8_MASKmskw_ZMMu8_AVX512=4689, - XED_IFORM_VPCOMPRESSB_XMMu8_MASKmskw_XMMu8_AVX512=4690, - XED_IFORM_VPCOMPRESSB_YMMu8_MASKmskw_YMMu8_AVX512=4691, - XED_IFORM_VPCOMPRESSB_ZMMu8_MASKmskw_ZMMu8_AVX512=4692, - XED_IFORM_VPCOMPRESSD_MEMu32_MASKmskw_XMMu32_AVX512=4693, - XED_IFORM_VPCOMPRESSD_MEMu32_MASKmskw_YMMu32_AVX512=4694, - XED_IFORM_VPCOMPRESSD_MEMu32_MASKmskw_ZMMu32_AVX512=4695, - XED_IFORM_VPCOMPRESSD_XMMu32_MASKmskw_XMMu32_AVX512=4696, - XED_IFORM_VPCOMPRESSD_YMMu32_MASKmskw_YMMu32_AVX512=4697, - XED_IFORM_VPCOMPRESSD_ZMMu32_MASKmskw_ZMMu32_AVX512=4698, - XED_IFORM_VPCOMPRESSQ_MEMu64_MASKmskw_XMMu64_AVX512=4699, - XED_IFORM_VPCOMPRESSQ_MEMu64_MASKmskw_YMMu64_AVX512=4700, - XED_IFORM_VPCOMPRESSQ_MEMu64_MASKmskw_ZMMu64_AVX512=4701, - XED_IFORM_VPCOMPRESSQ_XMMu64_MASKmskw_XMMu64_AVX512=4702, - XED_IFORM_VPCOMPRESSQ_YMMu64_MASKmskw_YMMu64_AVX512=4703, - XED_IFORM_VPCOMPRESSQ_ZMMu64_MASKmskw_ZMMu64_AVX512=4704, - XED_IFORM_VPCOMPRESSW_MEMu16_MASKmskw_XMMu16_AVX512=4705, - XED_IFORM_VPCOMPRESSW_MEMu16_MASKmskw_YMMu16_AVX512=4706, - XED_IFORM_VPCOMPRESSW_MEMu16_MASKmskw_ZMMu16_AVX512=4707, - XED_IFORM_VPCOMPRESSW_XMMu16_MASKmskw_XMMu16_AVX512=4708, - XED_IFORM_VPCOMPRESSW_YMMu16_MASKmskw_YMMu16_AVX512=4709, - XED_IFORM_VPCOMPRESSW_ZMMu16_MASKmskw_ZMMu16_AVX512=4710, - XED_IFORM_VPCOMQ_XMMdq_XMMdq_MEMdq_IMMb=4711, - XED_IFORM_VPCOMQ_XMMdq_XMMdq_XMMdq_IMMb=4712, - XED_IFORM_VPCOMUB_XMMdq_XMMdq_MEMdq_IMMb=4713, - XED_IFORM_VPCOMUB_XMMdq_XMMdq_XMMdq_IMMb=4714, - XED_IFORM_VPCOMUD_XMMdq_XMMdq_MEMdq_IMMb=4715, - XED_IFORM_VPCOMUD_XMMdq_XMMdq_XMMdq_IMMb=4716, - XED_IFORM_VPCOMUQ_XMMdq_XMMdq_MEMdq_IMMb=4717, - XED_IFORM_VPCOMUQ_XMMdq_XMMdq_XMMdq_IMMb=4718, - XED_IFORM_VPCOMUW_XMMdq_XMMdq_MEMdq_IMMb=4719, - XED_IFORM_VPCOMUW_XMMdq_XMMdq_XMMdq_IMMb=4720, - XED_IFORM_VPCOMW_XMMdq_XMMdq_MEMdq_IMMb=4721, - XED_IFORM_VPCOMW_XMMdq_XMMdq_XMMdq_IMMb=4722, - XED_IFORM_VPCONFLICTD_XMMu32_MASKmskw_MEMu32_AVX512=4723, - XED_IFORM_VPCONFLICTD_XMMu32_MASKmskw_XMMu32_AVX512=4724, - XED_IFORM_VPCONFLICTD_YMMu32_MASKmskw_MEMu32_AVX512=4725, - XED_IFORM_VPCONFLICTD_YMMu32_MASKmskw_YMMu32_AVX512=4726, - XED_IFORM_VPCONFLICTD_ZMMu32_MASKmskw_MEMu32_AVX512CD=4727, - XED_IFORM_VPCONFLICTD_ZMMu32_MASKmskw_ZMMu32_AVX512CD=4728, - XED_IFORM_VPCONFLICTQ_XMMu64_MASKmskw_MEMu64_AVX512=4729, - XED_IFORM_VPCONFLICTQ_XMMu64_MASKmskw_XMMu64_AVX512=4730, - XED_IFORM_VPCONFLICTQ_YMMu64_MASKmskw_MEMu64_AVX512=4731, - XED_IFORM_VPCONFLICTQ_YMMu64_MASKmskw_YMMu64_AVX512=4732, - XED_IFORM_VPCONFLICTQ_ZMMu64_MASKmskw_MEMu64_AVX512CD=4733, - XED_IFORM_VPCONFLICTQ_ZMMu64_MASKmskw_ZMMu64_AVX512CD=4734, - XED_IFORM_VPDPBUSD_XMMi32_MASKmskw_XMMu8_MEMu32_AVX512=4735, - XED_IFORM_VPDPBUSD_XMMi32_MASKmskw_XMMu8_XMMu32_AVX512=4736, - XED_IFORM_VPDPBUSD_XMMi32_XMMu32_MEMu32=4737, - XED_IFORM_VPDPBUSD_XMMi32_XMMu32_XMMu32=4738, - XED_IFORM_VPDPBUSD_YMMi32_MASKmskw_YMMu8_MEMu32_AVX512=4739, - XED_IFORM_VPDPBUSD_YMMi32_MASKmskw_YMMu8_YMMu32_AVX512=4740, - XED_IFORM_VPDPBUSD_YMMi32_YMMu32_MEMu32=4741, - XED_IFORM_VPDPBUSD_YMMi32_YMMu32_YMMu32=4742, - XED_IFORM_VPDPBUSD_ZMMi32_MASKmskw_ZMMu8_MEMu32_AVX512=4743, - XED_IFORM_VPDPBUSD_ZMMi32_MASKmskw_ZMMu8_ZMMu32_AVX512=4744, - XED_IFORM_VPDPBUSDS_XMMi32_MASKmskw_XMMu8_MEMu32_AVX512=4745, - XED_IFORM_VPDPBUSDS_XMMi32_MASKmskw_XMMu8_XMMu32_AVX512=4746, - XED_IFORM_VPDPBUSDS_XMMi32_XMMu32_MEMu32=4747, - XED_IFORM_VPDPBUSDS_XMMi32_XMMu32_XMMu32=4748, - XED_IFORM_VPDPBUSDS_YMMi32_MASKmskw_YMMu8_MEMu32_AVX512=4749, - XED_IFORM_VPDPBUSDS_YMMi32_MASKmskw_YMMu8_YMMu32_AVX512=4750, - XED_IFORM_VPDPBUSDS_YMMi32_YMMu32_MEMu32=4751, - XED_IFORM_VPDPBUSDS_YMMi32_YMMu32_YMMu32=4752, - XED_IFORM_VPDPBUSDS_ZMMi32_MASKmskw_ZMMu8_MEMu32_AVX512=4753, - XED_IFORM_VPDPBUSDS_ZMMi32_MASKmskw_ZMMu8_ZMMu32_AVX512=4754, - XED_IFORM_VPDPWSSD_XMMi32_MASKmskw_XMMi16_MEMu32_AVX512=4755, - XED_IFORM_VPDPWSSD_XMMi32_MASKmskw_XMMi16_XMMu32_AVX512=4756, - XED_IFORM_VPDPWSSD_XMMi32_XMMu32_MEMu32=4757, - XED_IFORM_VPDPWSSD_XMMi32_XMMu32_XMMu32=4758, - XED_IFORM_VPDPWSSD_YMMi32_MASKmskw_YMMi16_MEMu32_AVX512=4759, - XED_IFORM_VPDPWSSD_YMMi32_MASKmskw_YMMi16_YMMu32_AVX512=4760, - XED_IFORM_VPDPWSSD_YMMi32_YMMu32_MEMu32=4761, - XED_IFORM_VPDPWSSD_YMMi32_YMMu32_YMMu32=4762, - XED_IFORM_VPDPWSSD_ZMMi32_MASKmskw_ZMMi16_MEMu32_AVX512=4763, - XED_IFORM_VPDPWSSD_ZMMi32_MASKmskw_ZMMi16_ZMMu32_AVX512=4764, - XED_IFORM_VPDPWSSDS_XMMi32_MASKmskw_XMMi16_MEMu32_AVX512=4765, - XED_IFORM_VPDPWSSDS_XMMi32_MASKmskw_XMMi16_XMMu32_AVX512=4766, - XED_IFORM_VPDPWSSDS_XMMi32_XMMu32_MEMu32=4767, - XED_IFORM_VPDPWSSDS_XMMi32_XMMu32_XMMu32=4768, - XED_IFORM_VPDPWSSDS_YMMi32_MASKmskw_YMMi16_MEMu32_AVX512=4769, - XED_IFORM_VPDPWSSDS_YMMi32_MASKmskw_YMMi16_YMMu32_AVX512=4770, - XED_IFORM_VPDPWSSDS_YMMi32_YMMu32_MEMu32=4771, - XED_IFORM_VPDPWSSDS_YMMi32_YMMu32_YMMu32=4772, - XED_IFORM_VPDPWSSDS_ZMMi32_MASKmskw_ZMMi16_MEMu32_AVX512=4773, - XED_IFORM_VPDPWSSDS_ZMMi32_MASKmskw_ZMMi16_ZMMu32_AVX512=4774, - XED_IFORM_VPERM2F128_YMMqq_YMMqq_MEMqq_IMMb=4775, - XED_IFORM_VPERM2F128_YMMqq_YMMqq_YMMqq_IMMb=4776, - XED_IFORM_VPERM2I128_YMMqq_YMMqq_MEMqq_IMMb=4777, - XED_IFORM_VPERM2I128_YMMqq_YMMqq_YMMqq_IMMb=4778, - XED_IFORM_VPERMB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4779, - XED_IFORM_VPERMB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4780, - XED_IFORM_VPERMB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4781, - XED_IFORM_VPERMB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4782, - XED_IFORM_VPERMB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4783, - XED_IFORM_VPERMB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4784, - XED_IFORM_VPERMD_YMMqq_YMMqq_MEMqq=4785, - XED_IFORM_VPERMD_YMMqq_YMMqq_YMMqq=4786, - XED_IFORM_VPERMD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4787, - XED_IFORM_VPERMD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4788, - XED_IFORM_VPERMD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4789, - XED_IFORM_VPERMD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4790, - XED_IFORM_VPERMI2B_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4791, - XED_IFORM_VPERMI2B_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4792, - XED_IFORM_VPERMI2B_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4793, - XED_IFORM_VPERMI2B_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4794, - XED_IFORM_VPERMI2B_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4795, - XED_IFORM_VPERMI2B_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4796, - XED_IFORM_VPERMI2D_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4797, - XED_IFORM_VPERMI2D_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4798, - XED_IFORM_VPERMI2D_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4799, - XED_IFORM_VPERMI2D_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4800, - XED_IFORM_VPERMI2D_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4801, - XED_IFORM_VPERMI2D_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4802, - XED_IFORM_VPERMI2PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=4803, - XED_IFORM_VPERMI2PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=4804, - XED_IFORM_VPERMI2PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=4805, - XED_IFORM_VPERMI2PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=4806, - XED_IFORM_VPERMI2PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=4807, - XED_IFORM_VPERMI2PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=4808, - XED_IFORM_VPERMI2PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=4809, - XED_IFORM_VPERMI2PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=4810, - XED_IFORM_VPERMI2PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=4811, - XED_IFORM_VPERMI2PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=4812, - XED_IFORM_VPERMI2PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=4813, - XED_IFORM_VPERMI2PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=4814, - XED_IFORM_VPERMI2Q_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4815, - XED_IFORM_VPERMI2Q_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4816, - XED_IFORM_VPERMI2Q_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4817, - XED_IFORM_VPERMI2Q_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4818, - XED_IFORM_VPERMI2Q_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4819, - XED_IFORM_VPERMI2Q_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4820, - XED_IFORM_VPERMI2W_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4821, - XED_IFORM_VPERMI2W_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4822, - XED_IFORM_VPERMI2W_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4823, - XED_IFORM_VPERMI2W_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4824, - XED_IFORM_VPERMI2W_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4825, - XED_IFORM_VPERMI2W_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4826, - XED_IFORM_VPERMIL2PD_XMMdq_XMMdq_MEMdq_XMMdq_IMMb=4827, - XED_IFORM_VPERMIL2PD_XMMdq_XMMdq_XMMdq_MEMdq_IMMb=4828, - XED_IFORM_VPERMIL2PD_XMMdq_XMMdq_XMMdq_XMMdq_IMMb=4829, - XED_IFORM_VPERMIL2PD_YMMqq_YMMqq_MEMqq_YMMqq_IMMb=4830, - XED_IFORM_VPERMIL2PD_YMMqq_YMMqq_YMMqq_MEMqq_IMMb=4831, - XED_IFORM_VPERMIL2PD_YMMqq_YMMqq_YMMqq_YMMqq_IMMb=4832, - XED_IFORM_VPERMIL2PS_XMMdq_XMMdq_MEMdq_XMMdq_IMMb=4833, - XED_IFORM_VPERMIL2PS_XMMdq_XMMdq_XMMdq_MEMdq_IMMb=4834, - XED_IFORM_VPERMIL2PS_XMMdq_XMMdq_XMMdq_XMMdq_IMMb=4835, - XED_IFORM_VPERMIL2PS_YMMqq_YMMqq_MEMqq_YMMqq_IMMb=4836, - XED_IFORM_VPERMIL2PS_YMMqq_YMMqq_YMMqq_MEMqq_IMMb=4837, - XED_IFORM_VPERMIL2PS_YMMqq_YMMqq_YMMqq_YMMqq_IMMb=4838, - XED_IFORM_VPERMILPD_XMMdq_MEMdq_IMMb=4839, - XED_IFORM_VPERMILPD_XMMdq_XMMdq_IMMb=4840, - XED_IFORM_VPERMILPD_XMMdq_XMMdq_MEMdq=4841, - XED_IFORM_VPERMILPD_XMMdq_XMMdq_XMMdq=4842, - XED_IFORM_VPERMILPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512=4843, - XED_IFORM_VPERMILPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512=4844, - XED_IFORM_VPERMILPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=4845, - XED_IFORM_VPERMILPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=4846, - XED_IFORM_VPERMILPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512=4847, - XED_IFORM_VPERMILPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512=4848, - XED_IFORM_VPERMILPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=4849, - XED_IFORM_VPERMILPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=4850, - XED_IFORM_VPERMILPD_YMMqq_MEMqq_IMMb=4851, - XED_IFORM_VPERMILPD_YMMqq_YMMqq_IMMb=4852, - XED_IFORM_VPERMILPD_YMMqq_YMMqq_MEMqq=4853, - XED_IFORM_VPERMILPD_YMMqq_YMMqq_YMMqq=4854, - XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512=4855, - XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512=4856, - XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=4857, - XED_IFORM_VPERMILPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=4858, - XED_IFORM_VPERMILPS_XMMdq_MEMdq_IMMb=4859, - XED_IFORM_VPERMILPS_XMMdq_XMMdq_IMMb=4860, - XED_IFORM_VPERMILPS_XMMdq_XMMdq_MEMdq=4861, - XED_IFORM_VPERMILPS_XMMdq_XMMdq_XMMdq=4862, - XED_IFORM_VPERMILPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512=4863, - XED_IFORM_VPERMILPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512=4864, - XED_IFORM_VPERMILPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=4865, - XED_IFORM_VPERMILPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=4866, - XED_IFORM_VPERMILPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512=4867, - XED_IFORM_VPERMILPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512=4868, - XED_IFORM_VPERMILPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=4869, - XED_IFORM_VPERMILPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=4870, - XED_IFORM_VPERMILPS_YMMqq_MEMqq_IMMb=4871, - XED_IFORM_VPERMILPS_YMMqq_YMMqq_IMMb=4872, - XED_IFORM_VPERMILPS_YMMqq_YMMqq_MEMqq=4873, - XED_IFORM_VPERMILPS_YMMqq_YMMqq_YMMqq=4874, - XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512=4875, - XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512=4876, - XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=4877, - XED_IFORM_VPERMILPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=4878, - XED_IFORM_VPERMPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512=4879, - XED_IFORM_VPERMPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512=4880, - XED_IFORM_VPERMPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=4881, - XED_IFORM_VPERMPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=4882, - XED_IFORM_VPERMPD_YMMqq_MEMqq_IMMb=4883, - XED_IFORM_VPERMPD_YMMqq_YMMqq_IMMb=4884, - XED_IFORM_VPERMPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512=4885, - XED_IFORM_VPERMPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512=4886, - XED_IFORM_VPERMPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=4887, - XED_IFORM_VPERMPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=4888, - XED_IFORM_VPERMPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=4889, - XED_IFORM_VPERMPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=4890, - XED_IFORM_VPERMPS_YMMqq_YMMqq_MEMqq=4891, - XED_IFORM_VPERMPS_YMMqq_YMMqq_YMMqq=4892, - XED_IFORM_VPERMPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=4893, - XED_IFORM_VPERMPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=4894, - XED_IFORM_VPERMQ_YMMqq_MEMqq_IMMb=4895, - XED_IFORM_VPERMQ_YMMqq_YMMqq_IMMb=4896, - XED_IFORM_VPERMQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=4897, - XED_IFORM_VPERMQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=4898, - XED_IFORM_VPERMQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4899, - XED_IFORM_VPERMQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4900, - XED_IFORM_VPERMQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=4901, - XED_IFORM_VPERMQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=4902, - XED_IFORM_VPERMQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4903, - XED_IFORM_VPERMQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4904, - XED_IFORM_VPERMT2B_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=4905, - XED_IFORM_VPERMT2B_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=4906, - XED_IFORM_VPERMT2B_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=4907, - XED_IFORM_VPERMT2B_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=4908, - XED_IFORM_VPERMT2B_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=4909, - XED_IFORM_VPERMT2B_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=4910, - XED_IFORM_VPERMT2D_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=4911, - XED_IFORM_VPERMT2D_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=4912, - XED_IFORM_VPERMT2D_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=4913, - XED_IFORM_VPERMT2D_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=4914, - XED_IFORM_VPERMT2D_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=4915, - XED_IFORM_VPERMT2D_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=4916, - XED_IFORM_VPERMT2PD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=4917, - XED_IFORM_VPERMT2PD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=4918, - XED_IFORM_VPERMT2PD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=4919, - XED_IFORM_VPERMT2PD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=4920, - XED_IFORM_VPERMT2PD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=4921, - XED_IFORM_VPERMT2PD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=4922, - XED_IFORM_VPERMT2PS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=4923, - XED_IFORM_VPERMT2PS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=4924, - XED_IFORM_VPERMT2PS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=4925, - XED_IFORM_VPERMT2PS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=4926, - XED_IFORM_VPERMT2PS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=4927, - XED_IFORM_VPERMT2PS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=4928, - XED_IFORM_VPERMT2Q_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=4929, - XED_IFORM_VPERMT2Q_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=4930, - XED_IFORM_VPERMT2Q_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=4931, - XED_IFORM_VPERMT2Q_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=4932, - XED_IFORM_VPERMT2Q_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=4933, - XED_IFORM_VPERMT2Q_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=4934, - XED_IFORM_VPERMT2W_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4935, - XED_IFORM_VPERMT2W_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4936, - XED_IFORM_VPERMT2W_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4937, - XED_IFORM_VPERMT2W_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4938, - XED_IFORM_VPERMT2W_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4939, - XED_IFORM_VPERMT2W_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4940, - XED_IFORM_VPERMW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=4941, - XED_IFORM_VPERMW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=4942, - XED_IFORM_VPERMW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=4943, - XED_IFORM_VPERMW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=4944, - XED_IFORM_VPERMW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=4945, - XED_IFORM_VPERMW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=4946, - XED_IFORM_VPEXPANDB_XMMu8_MASKmskw_MEMu8_AVX512=4947, - XED_IFORM_VPEXPANDB_XMMu8_MASKmskw_XMMu8_AVX512=4948, - XED_IFORM_VPEXPANDB_YMMu8_MASKmskw_MEMu8_AVX512=4949, - XED_IFORM_VPEXPANDB_YMMu8_MASKmskw_YMMu8_AVX512=4950, - XED_IFORM_VPEXPANDB_ZMMu8_MASKmskw_MEMu8_AVX512=4951, - XED_IFORM_VPEXPANDB_ZMMu8_MASKmskw_ZMMu8_AVX512=4952, - XED_IFORM_VPEXPANDD_XMMu32_MASKmskw_MEMu32_AVX512=4953, - XED_IFORM_VPEXPANDD_XMMu32_MASKmskw_XMMu32_AVX512=4954, - XED_IFORM_VPEXPANDD_YMMu32_MASKmskw_MEMu32_AVX512=4955, - XED_IFORM_VPEXPANDD_YMMu32_MASKmskw_YMMu32_AVX512=4956, - XED_IFORM_VPEXPANDD_ZMMu32_MASKmskw_MEMu32_AVX512=4957, - XED_IFORM_VPEXPANDD_ZMMu32_MASKmskw_ZMMu32_AVX512=4958, - XED_IFORM_VPEXPANDQ_XMMu64_MASKmskw_MEMu64_AVX512=4959, - XED_IFORM_VPEXPANDQ_XMMu64_MASKmskw_XMMu64_AVX512=4960, - XED_IFORM_VPEXPANDQ_YMMu64_MASKmskw_MEMu64_AVX512=4961, - XED_IFORM_VPEXPANDQ_YMMu64_MASKmskw_YMMu64_AVX512=4962, - XED_IFORM_VPEXPANDQ_ZMMu64_MASKmskw_MEMu64_AVX512=4963, - XED_IFORM_VPEXPANDQ_ZMMu64_MASKmskw_ZMMu64_AVX512=4964, - XED_IFORM_VPEXPANDW_XMMu16_MASKmskw_MEMu16_AVX512=4965, - XED_IFORM_VPEXPANDW_XMMu16_MASKmskw_XMMu16_AVX512=4966, - XED_IFORM_VPEXPANDW_YMMu16_MASKmskw_MEMu16_AVX512=4967, - XED_IFORM_VPEXPANDW_YMMu16_MASKmskw_YMMu16_AVX512=4968, - XED_IFORM_VPEXPANDW_ZMMu16_MASKmskw_MEMu16_AVX512=4969, - XED_IFORM_VPEXPANDW_ZMMu16_MASKmskw_ZMMu16_AVX512=4970, - XED_IFORM_VPEXTRB_GPR32d_XMMdq_IMMb=4971, - XED_IFORM_VPEXTRB_GPR32u8_XMMu8_IMM8_AVX512=4972, - XED_IFORM_VPEXTRB_MEMb_XMMdq_IMMb=4973, - XED_IFORM_VPEXTRB_MEMu8_XMMu8_IMM8_AVX512=4974, - XED_IFORM_VPEXTRD_GPR32d_XMMdq_IMMb=4975, - XED_IFORM_VPEXTRD_GPR32u32_XMMu32_IMM8_AVX512=4976, - XED_IFORM_VPEXTRD_MEMd_XMMdq_IMMb=4977, - XED_IFORM_VPEXTRD_MEMu32_XMMu32_IMM8_AVX512=4978, - XED_IFORM_VPEXTRQ_GPR64q_XMMdq_IMMb=4979, - XED_IFORM_VPEXTRQ_GPR64u64_XMMu64_IMM8_AVX512=4980, - XED_IFORM_VPEXTRQ_MEMq_XMMdq_IMMb=4981, - XED_IFORM_VPEXTRQ_MEMu64_XMMu64_IMM8_AVX512=4982, - XED_IFORM_VPEXTRW_GPR32d_XMMdq_IMMb_15=4983, - XED_IFORM_VPEXTRW_GPR32d_XMMdq_IMMb_C5=4984, - XED_IFORM_VPEXTRW_GPR32u16_XMMu16_IMM8_AVX512=4985, - XED_IFORM_VPEXTRW_MEMu16_XMMu16_IMM8_AVX512=4986, - XED_IFORM_VPEXTRW_MEMw_XMMdq_IMMb=4987, - XED_IFORM_VPEXTRW_GPR32u16_XMMu16_IMM8_AVX512_C5=4988, - XED_IFORM_VPGATHERDD_XMMu32_MASKmskw_MEMu32_AVX512_VL128=4989, - XED_IFORM_VPGATHERDD_XMMu32_MEMd_XMMi32_VL128=4990, - XED_IFORM_VPGATHERDD_YMMu32_MASKmskw_MEMu32_AVX512_VL256=4991, - XED_IFORM_VPGATHERDD_YMMu32_MEMd_YMMi32_VL256=4992, - XED_IFORM_VPGATHERDD_ZMMu32_MASKmskw_MEMu32_AVX512_VL512=4993, - XED_IFORM_VPGATHERDQ_XMMu64_MASKmskw_MEMu64_AVX512_VL128=4994, - XED_IFORM_VPGATHERDQ_XMMu64_MEMq_XMMi64_VL128=4995, - XED_IFORM_VPGATHERDQ_YMMu64_MASKmskw_MEMu64_AVX512_VL256=4996, - XED_IFORM_VPGATHERDQ_YMMu64_MEMq_YMMi64_VL256=4997, - XED_IFORM_VPGATHERDQ_ZMMu64_MASKmskw_MEMu64_AVX512_VL512=4998, - XED_IFORM_VPGATHERQD_XMMu32_MASKmskw_MEMu32_AVX512_VL128=4999, - XED_IFORM_VPGATHERQD_XMMu32_MASKmskw_MEMu32_AVX512_VL256=5000, - XED_IFORM_VPGATHERQD_XMMu32_MEMd_XMMi32_VL128=5001, - XED_IFORM_VPGATHERQD_XMMu32_MEMd_XMMi32_VL256=5002, - XED_IFORM_VPGATHERQD_YMMu32_MASKmskw_MEMu32_AVX512_VL512=5003, - XED_IFORM_VPGATHERQQ_XMMu64_MASKmskw_MEMu64_AVX512_VL128=5004, - XED_IFORM_VPGATHERQQ_XMMu64_MEMq_XMMi64_VL128=5005, - XED_IFORM_VPGATHERQQ_YMMu64_MASKmskw_MEMu64_AVX512_VL256=5006, - XED_IFORM_VPGATHERQQ_YMMu64_MEMq_YMMi64_VL256=5007, - XED_IFORM_VPGATHERQQ_ZMMu64_MASKmskw_MEMu64_AVX512_VL512=5008, - XED_IFORM_VPHADDBD_XMMdq_MEMdq=5009, - XED_IFORM_VPHADDBD_XMMdq_XMMdq=5010, - XED_IFORM_VPHADDBQ_XMMdq_MEMdq=5011, - XED_IFORM_VPHADDBQ_XMMdq_XMMdq=5012, - XED_IFORM_VPHADDBW_XMMdq_MEMdq=5013, - XED_IFORM_VPHADDBW_XMMdq_XMMdq=5014, - XED_IFORM_VPHADDD_XMMdq_XMMdq_MEMdq=5015, - XED_IFORM_VPHADDD_XMMdq_XMMdq_XMMdq=5016, - XED_IFORM_VPHADDD_YMMqq_YMMqq_MEMqq=5017, - XED_IFORM_VPHADDD_YMMqq_YMMqq_YMMqq=5018, - XED_IFORM_VPHADDDQ_XMMdq_MEMdq=5019, - XED_IFORM_VPHADDDQ_XMMdq_XMMdq=5020, - XED_IFORM_VPHADDSW_XMMdq_XMMdq_MEMdq=5021, - XED_IFORM_VPHADDSW_XMMdq_XMMdq_XMMdq=5022, - XED_IFORM_VPHADDSW_YMMqq_YMMqq_MEMqq=5023, - XED_IFORM_VPHADDSW_YMMqq_YMMqq_YMMqq=5024, - XED_IFORM_VPHADDUBD_XMMdq_MEMdq=5025, - XED_IFORM_VPHADDUBD_XMMdq_XMMdq=5026, - XED_IFORM_VPHADDUBQ_XMMdq_MEMdq=5027, - XED_IFORM_VPHADDUBQ_XMMdq_XMMdq=5028, - XED_IFORM_VPHADDUBW_XMMdq_MEMdq=5029, - XED_IFORM_VPHADDUBW_XMMdq_XMMdq=5030, - XED_IFORM_VPHADDUDQ_XMMdq_MEMdq=5031, - XED_IFORM_VPHADDUDQ_XMMdq_XMMdq=5032, - XED_IFORM_VPHADDUWD_XMMdq_MEMdq=5033, - XED_IFORM_VPHADDUWD_XMMdq_XMMdq=5034, - XED_IFORM_VPHADDUWQ_XMMdq_MEMdq=5035, - XED_IFORM_VPHADDUWQ_XMMdq_XMMdq=5036, - XED_IFORM_VPHADDW_XMMdq_XMMdq_MEMdq=5037, - XED_IFORM_VPHADDW_XMMdq_XMMdq_XMMdq=5038, - XED_IFORM_VPHADDW_YMMqq_YMMqq_MEMqq=5039, - XED_IFORM_VPHADDW_YMMqq_YMMqq_YMMqq=5040, - XED_IFORM_VPHADDWD_XMMdq_MEMdq=5041, - XED_IFORM_VPHADDWD_XMMdq_XMMdq=5042, - XED_IFORM_VPHADDWQ_XMMdq_MEMdq=5043, - XED_IFORM_VPHADDWQ_XMMdq_XMMdq=5044, - XED_IFORM_VPHMINPOSUW_XMMdq_MEMdq=5045, - XED_IFORM_VPHMINPOSUW_XMMdq_XMMdq=5046, - XED_IFORM_VPHSUBBW_XMMdq_MEMdq=5047, - XED_IFORM_VPHSUBBW_XMMdq_XMMdq=5048, - XED_IFORM_VPHSUBD_XMMdq_XMMdq_MEMdq=5049, - XED_IFORM_VPHSUBD_XMMdq_XMMdq_XMMdq=5050, - XED_IFORM_VPHSUBD_YMMqq_YMMqq_MEMqq=5051, - XED_IFORM_VPHSUBD_YMMqq_YMMqq_YMMqq=5052, - XED_IFORM_VPHSUBDQ_XMMdq_MEMdq=5053, - XED_IFORM_VPHSUBDQ_XMMdq_XMMdq=5054, - XED_IFORM_VPHSUBSW_XMMdq_XMMdq_MEMdq=5055, - XED_IFORM_VPHSUBSW_XMMdq_XMMdq_XMMdq=5056, - XED_IFORM_VPHSUBSW_YMMqq_YMMqq_MEMqq=5057, - XED_IFORM_VPHSUBSW_YMMqq_YMMqq_YMMqq=5058, - XED_IFORM_VPHSUBW_XMMdq_XMMdq_MEMdq=5059, - XED_IFORM_VPHSUBW_XMMdq_XMMdq_XMMdq=5060, - XED_IFORM_VPHSUBW_YMMqq_YMMqq_MEMqq=5061, - XED_IFORM_VPHSUBW_YMMqq_YMMqq_YMMqq=5062, - XED_IFORM_VPHSUBWD_XMMdq_MEMdq=5063, - XED_IFORM_VPHSUBWD_XMMdq_XMMdq=5064, - XED_IFORM_VPINSRB_XMMdq_XMMdq_GPR32d_IMMb=5065, - XED_IFORM_VPINSRB_XMMdq_XMMdq_MEMb_IMMb=5066, - XED_IFORM_VPINSRB_XMMu8_XMMu8_GPR32u8_IMM8_AVX512=5067, - XED_IFORM_VPINSRB_XMMu8_XMMu8_MEMu8_IMM8_AVX512=5068, - XED_IFORM_VPINSRD_XMMdq_XMMdq_GPR32d_IMMb=5069, - XED_IFORM_VPINSRD_XMMdq_XMMdq_MEMd_IMMb=5070, - XED_IFORM_VPINSRD_XMMu32_XMMu32_GPR32u32_IMM8_AVX512=5071, - XED_IFORM_VPINSRD_XMMu32_XMMu32_MEMu32_IMM8_AVX512=5072, - XED_IFORM_VPINSRQ_XMMdq_XMMdq_GPR64q_IMMb=5073, - XED_IFORM_VPINSRQ_XMMdq_XMMdq_MEMq_IMMb=5074, - XED_IFORM_VPINSRQ_XMMu64_XMMu64_GPR64u64_IMM8_AVX512=5075, - XED_IFORM_VPINSRQ_XMMu64_XMMu64_MEMu64_IMM8_AVX512=5076, - XED_IFORM_VPINSRW_XMMdq_XMMdq_GPR32d_IMMb=5077, - XED_IFORM_VPINSRW_XMMdq_XMMdq_MEMw_IMMb=5078, - XED_IFORM_VPINSRW_XMMu16_XMMu16_GPR32u16_IMM8_AVX512=5079, - XED_IFORM_VPINSRW_XMMu16_XMMu16_MEMu16_IMM8_AVX512=5080, - XED_IFORM_VPLZCNTD_XMMu32_MASKmskw_MEMu32_AVX512=5081, - XED_IFORM_VPLZCNTD_XMMu32_MASKmskw_XMMu32_AVX512=5082, - XED_IFORM_VPLZCNTD_YMMu32_MASKmskw_MEMu32_AVX512=5083, - XED_IFORM_VPLZCNTD_YMMu32_MASKmskw_YMMu32_AVX512=5084, - XED_IFORM_VPLZCNTD_ZMMu32_MASKmskw_MEMu32_AVX512CD=5085, - XED_IFORM_VPLZCNTD_ZMMu32_MASKmskw_ZMMu32_AVX512CD=5086, - XED_IFORM_VPLZCNTQ_XMMu64_MASKmskw_MEMu64_AVX512=5087, - XED_IFORM_VPLZCNTQ_XMMu64_MASKmskw_XMMu64_AVX512=5088, - XED_IFORM_VPLZCNTQ_YMMu64_MASKmskw_MEMu64_AVX512=5089, - XED_IFORM_VPLZCNTQ_YMMu64_MASKmskw_YMMu64_AVX512=5090, - XED_IFORM_VPLZCNTQ_ZMMu64_MASKmskw_MEMu64_AVX512CD=5091, - XED_IFORM_VPLZCNTQ_ZMMu64_MASKmskw_ZMMu64_AVX512CD=5092, - XED_IFORM_VPMACSDD_XMMdq_XMMdq_MEMdq_XMMdq=5093, - XED_IFORM_VPMACSDD_XMMdq_XMMdq_XMMdq_XMMdq=5094, - XED_IFORM_VPMACSDQH_XMMdq_XMMdq_MEMdq_XMMdq=5095, - XED_IFORM_VPMACSDQH_XMMdq_XMMdq_XMMdq_XMMdq=5096, - XED_IFORM_VPMACSDQL_XMMdq_XMMdq_MEMdq_XMMdq=5097, - XED_IFORM_VPMACSDQL_XMMdq_XMMdq_XMMdq_XMMdq=5098, - XED_IFORM_VPMACSSDD_XMMdq_XMMdq_MEMdq_XMMdq=5099, - XED_IFORM_VPMACSSDD_XMMdq_XMMdq_XMMdq_XMMdq=5100, - XED_IFORM_VPMACSSDQH_XMMdq_XMMdq_MEMdq_XMMdq=5101, - XED_IFORM_VPMACSSDQH_XMMdq_XMMdq_XMMdq_XMMdq=5102, - XED_IFORM_VPMACSSDQL_XMMdq_XMMdq_MEMdq_XMMdq=5103, - XED_IFORM_VPMACSSDQL_XMMdq_XMMdq_XMMdq_XMMdq=5104, - XED_IFORM_VPMACSSWD_XMMdq_XMMdq_MEMdq_XMMdq=5105, - XED_IFORM_VPMACSSWD_XMMdq_XMMdq_XMMdq_XMMdq=5106, - XED_IFORM_VPMACSSWW_XMMdq_XMMdq_MEMdq_XMMdq=5107, - XED_IFORM_VPMACSSWW_XMMdq_XMMdq_XMMdq_XMMdq=5108, - XED_IFORM_VPMACSWD_XMMdq_XMMdq_MEMdq_XMMdq=5109, - XED_IFORM_VPMACSWD_XMMdq_XMMdq_XMMdq_XMMdq=5110, - XED_IFORM_VPMACSWW_XMMdq_XMMdq_MEMdq_XMMdq=5111, - XED_IFORM_VPMACSWW_XMMdq_XMMdq_XMMdq_XMMdq=5112, - XED_IFORM_VPMADCSSWD_XMMdq_XMMdq_MEMdq_XMMdq=5113, - XED_IFORM_VPMADCSSWD_XMMdq_XMMdq_XMMdq_XMMdq=5114, - XED_IFORM_VPMADCSWD_XMMdq_XMMdq_MEMdq_XMMdq=5115, - XED_IFORM_VPMADCSWD_XMMdq_XMMdq_XMMdq_XMMdq=5116, - XED_IFORM_VPMADD52HUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5117, - XED_IFORM_VPMADD52HUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5118, - XED_IFORM_VPMADD52HUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5119, - XED_IFORM_VPMADD52HUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5120, - XED_IFORM_VPMADD52HUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5121, - XED_IFORM_VPMADD52HUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5122, - XED_IFORM_VPMADD52LUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5123, - XED_IFORM_VPMADD52LUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5124, - XED_IFORM_VPMADD52LUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5125, - XED_IFORM_VPMADD52LUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5126, - XED_IFORM_VPMADD52LUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5127, - XED_IFORM_VPMADD52LUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5128, - XED_IFORM_VPMADDUBSW_XMMdq_XMMdq_MEMdq=5129, - XED_IFORM_VPMADDUBSW_XMMdq_XMMdq_XMMdq=5130, - XED_IFORM_VPMADDUBSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=5131, - XED_IFORM_VPMADDUBSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=5132, - XED_IFORM_VPMADDUBSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=5133, - XED_IFORM_VPMADDUBSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=5134, - XED_IFORM_VPMADDUBSW_YMMqq_YMMqq_MEMqq=5135, - XED_IFORM_VPMADDUBSW_YMMqq_YMMqq_YMMqq=5136, - XED_IFORM_VPMADDUBSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=5137, - XED_IFORM_VPMADDUBSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=5138, - XED_IFORM_VPMADDWD_XMMdq_XMMdq_MEMdq=5139, - XED_IFORM_VPMADDWD_XMMdq_XMMdq_XMMdq=5140, - XED_IFORM_VPMADDWD_XMMi32_MASKmskw_XMMi16_MEMi16_AVX512=5141, - XED_IFORM_VPMADDWD_XMMi32_MASKmskw_XMMi16_XMMi16_AVX512=5142, - XED_IFORM_VPMADDWD_YMMi32_MASKmskw_YMMi16_MEMi16_AVX512=5143, - XED_IFORM_VPMADDWD_YMMi32_MASKmskw_YMMi16_YMMi16_AVX512=5144, - XED_IFORM_VPMADDWD_YMMqq_YMMqq_MEMqq=5145, - XED_IFORM_VPMADDWD_YMMqq_YMMqq_YMMqq=5146, - XED_IFORM_VPMADDWD_ZMMi32_MASKmskw_ZMMi16_MEMi16_AVX512=5147, - XED_IFORM_VPMADDWD_ZMMi32_MASKmskw_ZMMi16_ZMMi16_AVX512=5148, - XED_IFORM_VPMASKMOVD_MEMdq_XMMdq_XMMdq=5149, - XED_IFORM_VPMASKMOVD_MEMqq_YMMqq_YMMqq=5150, - XED_IFORM_VPMASKMOVD_XMMdq_XMMdq_MEMdq=5151, - XED_IFORM_VPMASKMOVD_YMMqq_YMMqq_MEMqq=5152, - XED_IFORM_VPMASKMOVQ_MEMdq_XMMdq_XMMdq=5153, - XED_IFORM_VPMASKMOVQ_MEMqq_YMMqq_YMMqq=5154, - XED_IFORM_VPMASKMOVQ_XMMdq_XMMdq_MEMdq=5155, - XED_IFORM_VPMASKMOVQ_YMMqq_YMMqq_MEMqq=5156, - XED_IFORM_VPMAXSB_XMMdq_XMMdq_MEMdq=5157, - XED_IFORM_VPMAXSB_XMMdq_XMMdq_XMMdq=5158, - XED_IFORM_VPMAXSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512=5159, - XED_IFORM_VPMAXSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512=5160, - XED_IFORM_VPMAXSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512=5161, - XED_IFORM_VPMAXSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512=5162, - XED_IFORM_VPMAXSB_YMMqq_YMMqq_MEMqq=5163, - XED_IFORM_VPMAXSB_YMMqq_YMMqq_YMMqq=5164, - XED_IFORM_VPMAXSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512=5165, - XED_IFORM_VPMAXSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512=5166, - XED_IFORM_VPMAXSD_XMMdq_XMMdq_MEMdq=5167, - XED_IFORM_VPMAXSD_XMMdq_XMMdq_XMMdq=5168, - XED_IFORM_VPMAXSD_XMMi32_MASKmskw_XMMi32_MEMi32_AVX512=5169, - XED_IFORM_VPMAXSD_XMMi32_MASKmskw_XMMi32_XMMi32_AVX512=5170, - XED_IFORM_VPMAXSD_YMMi32_MASKmskw_YMMi32_MEMi32_AVX512=5171, - XED_IFORM_VPMAXSD_YMMi32_MASKmskw_YMMi32_YMMi32_AVX512=5172, - XED_IFORM_VPMAXSD_YMMqq_YMMqq_MEMqq=5173, - XED_IFORM_VPMAXSD_YMMqq_YMMqq_YMMqq=5174, - XED_IFORM_VPMAXSD_ZMMi32_MASKmskw_ZMMi32_MEMi32_AVX512=5175, - XED_IFORM_VPMAXSD_ZMMi32_MASKmskw_ZMMi32_ZMMi32_AVX512=5176, - XED_IFORM_VPMAXSQ_XMMi64_MASKmskw_XMMi64_MEMi64_AVX512=5177, - XED_IFORM_VPMAXSQ_XMMi64_MASKmskw_XMMi64_XMMi64_AVX512=5178, - XED_IFORM_VPMAXSQ_YMMi64_MASKmskw_YMMi64_MEMi64_AVX512=5179, - XED_IFORM_VPMAXSQ_YMMi64_MASKmskw_YMMi64_YMMi64_AVX512=5180, - XED_IFORM_VPMAXSQ_ZMMi64_MASKmskw_ZMMi64_MEMi64_AVX512=5181, - XED_IFORM_VPMAXSQ_ZMMi64_MASKmskw_ZMMi64_ZMMi64_AVX512=5182, - XED_IFORM_VPMAXSW_XMMdq_XMMdq_MEMdq=5183, - XED_IFORM_VPMAXSW_XMMdq_XMMdq_XMMdq=5184, - XED_IFORM_VPMAXSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=5185, - XED_IFORM_VPMAXSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=5186, - XED_IFORM_VPMAXSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=5187, - XED_IFORM_VPMAXSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=5188, - XED_IFORM_VPMAXSW_YMMqq_YMMqq_MEMqq=5189, - XED_IFORM_VPMAXSW_YMMqq_YMMqq_YMMqq=5190, - XED_IFORM_VPMAXSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=5191, - XED_IFORM_VPMAXSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=5192, - XED_IFORM_VPMAXUB_XMMdq_XMMdq_MEMdq=5193, - XED_IFORM_VPMAXUB_XMMdq_XMMdq_XMMdq=5194, - XED_IFORM_VPMAXUB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=5195, - XED_IFORM_VPMAXUB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=5196, - XED_IFORM_VPMAXUB_YMMqq_YMMqq_MEMqq=5197, - XED_IFORM_VPMAXUB_YMMqq_YMMqq_YMMqq=5198, - XED_IFORM_VPMAXUB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=5199, - XED_IFORM_VPMAXUB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=5200, - XED_IFORM_VPMAXUB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=5201, - XED_IFORM_VPMAXUB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=5202, - XED_IFORM_VPMAXUD_XMMdq_XMMdq_MEMdq=5203, - XED_IFORM_VPMAXUD_XMMdq_XMMdq_XMMdq=5204, - XED_IFORM_VPMAXUD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5205, - XED_IFORM_VPMAXUD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5206, - XED_IFORM_VPMAXUD_YMMqq_YMMqq_MEMqq=5207, - XED_IFORM_VPMAXUD_YMMqq_YMMqq_YMMqq=5208, - XED_IFORM_VPMAXUD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5209, - XED_IFORM_VPMAXUD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5210, - XED_IFORM_VPMAXUD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5211, - XED_IFORM_VPMAXUD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5212, - XED_IFORM_VPMAXUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5213, - XED_IFORM_VPMAXUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5214, - XED_IFORM_VPMAXUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5215, - XED_IFORM_VPMAXUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5216, - XED_IFORM_VPMAXUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5217, - XED_IFORM_VPMAXUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5218, - XED_IFORM_VPMAXUW_XMMdq_XMMdq_MEMdq=5219, - XED_IFORM_VPMAXUW_XMMdq_XMMdq_XMMdq=5220, - XED_IFORM_VPMAXUW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5221, - XED_IFORM_VPMAXUW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5222, - XED_IFORM_VPMAXUW_YMMqq_YMMqq_MEMqq=5223, - XED_IFORM_VPMAXUW_YMMqq_YMMqq_YMMqq=5224, - XED_IFORM_VPMAXUW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5225, - XED_IFORM_VPMAXUW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5226, - XED_IFORM_VPMAXUW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5227, - XED_IFORM_VPMAXUW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5228, - XED_IFORM_VPMINSB_XMMdq_XMMdq_MEMdq=5229, - XED_IFORM_VPMINSB_XMMdq_XMMdq_XMMdq=5230, - XED_IFORM_VPMINSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512=5231, - XED_IFORM_VPMINSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512=5232, - XED_IFORM_VPMINSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512=5233, - XED_IFORM_VPMINSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512=5234, - XED_IFORM_VPMINSB_YMMqq_YMMqq_MEMqq=5235, - XED_IFORM_VPMINSB_YMMqq_YMMqq_YMMqq=5236, - XED_IFORM_VPMINSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512=5237, - XED_IFORM_VPMINSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512=5238, - XED_IFORM_VPMINSD_XMMdq_XMMdq_MEMdq=5239, - XED_IFORM_VPMINSD_XMMdq_XMMdq_XMMdq=5240, - XED_IFORM_VPMINSD_XMMi32_MASKmskw_XMMi32_MEMi32_AVX512=5241, - XED_IFORM_VPMINSD_XMMi32_MASKmskw_XMMi32_XMMi32_AVX512=5242, - XED_IFORM_VPMINSD_YMMi32_MASKmskw_YMMi32_MEMi32_AVX512=5243, - XED_IFORM_VPMINSD_YMMi32_MASKmskw_YMMi32_YMMi32_AVX512=5244, - XED_IFORM_VPMINSD_YMMqq_YMMqq_MEMqq=5245, - XED_IFORM_VPMINSD_YMMqq_YMMqq_YMMqq=5246, - XED_IFORM_VPMINSD_ZMMi32_MASKmskw_ZMMi32_MEMi32_AVX512=5247, - XED_IFORM_VPMINSD_ZMMi32_MASKmskw_ZMMi32_ZMMi32_AVX512=5248, - XED_IFORM_VPMINSQ_XMMi64_MASKmskw_XMMi64_MEMi64_AVX512=5249, - XED_IFORM_VPMINSQ_XMMi64_MASKmskw_XMMi64_XMMi64_AVX512=5250, - XED_IFORM_VPMINSQ_YMMi64_MASKmskw_YMMi64_MEMi64_AVX512=5251, - XED_IFORM_VPMINSQ_YMMi64_MASKmskw_YMMi64_YMMi64_AVX512=5252, - XED_IFORM_VPMINSQ_ZMMi64_MASKmskw_ZMMi64_MEMi64_AVX512=5253, - XED_IFORM_VPMINSQ_ZMMi64_MASKmskw_ZMMi64_ZMMi64_AVX512=5254, - XED_IFORM_VPMINSW_XMMdq_XMMdq_MEMdq=5255, - XED_IFORM_VPMINSW_XMMdq_XMMdq_XMMdq=5256, - XED_IFORM_VPMINSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=5257, - XED_IFORM_VPMINSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=5258, - XED_IFORM_VPMINSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=5259, - XED_IFORM_VPMINSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=5260, - XED_IFORM_VPMINSW_YMMqq_YMMqq_MEMqq=5261, - XED_IFORM_VPMINSW_YMMqq_YMMqq_YMMqq=5262, - XED_IFORM_VPMINSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=5263, - XED_IFORM_VPMINSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=5264, - XED_IFORM_VPMINUB_XMMdq_XMMdq_MEMdq=5265, - XED_IFORM_VPMINUB_XMMdq_XMMdq_XMMdq=5266, - XED_IFORM_VPMINUB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=5267, - XED_IFORM_VPMINUB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=5268, - XED_IFORM_VPMINUB_YMMqq_YMMqq_MEMqq=5269, - XED_IFORM_VPMINUB_YMMqq_YMMqq_YMMqq=5270, - XED_IFORM_VPMINUB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=5271, - XED_IFORM_VPMINUB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=5272, - XED_IFORM_VPMINUB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=5273, - XED_IFORM_VPMINUB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=5274, - XED_IFORM_VPMINUD_XMMdq_XMMdq_MEMdq=5275, - XED_IFORM_VPMINUD_XMMdq_XMMdq_XMMdq=5276, - XED_IFORM_VPMINUD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5277, - XED_IFORM_VPMINUD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5278, - XED_IFORM_VPMINUD_YMMqq_YMMqq_MEMqq=5279, - XED_IFORM_VPMINUD_YMMqq_YMMqq_YMMqq=5280, - XED_IFORM_VPMINUD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5281, - XED_IFORM_VPMINUD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5282, - XED_IFORM_VPMINUD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5283, - XED_IFORM_VPMINUD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5284, - XED_IFORM_VPMINUQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5285, - XED_IFORM_VPMINUQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5286, - XED_IFORM_VPMINUQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5287, - XED_IFORM_VPMINUQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5288, - XED_IFORM_VPMINUQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5289, - XED_IFORM_VPMINUQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5290, - XED_IFORM_VPMINUW_XMMdq_XMMdq_MEMdq=5291, - XED_IFORM_VPMINUW_XMMdq_XMMdq_XMMdq=5292, - XED_IFORM_VPMINUW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5293, - XED_IFORM_VPMINUW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5294, - XED_IFORM_VPMINUW_YMMqq_YMMqq_MEMqq=5295, - XED_IFORM_VPMINUW_YMMqq_YMMqq_YMMqq=5296, - XED_IFORM_VPMINUW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5297, - XED_IFORM_VPMINUW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5298, - XED_IFORM_VPMINUW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5299, - XED_IFORM_VPMINUW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5300, - XED_IFORM_VPMOVB2M_MASKmskw_XMMu8_AVX512=5301, - XED_IFORM_VPMOVB2M_MASKmskw_YMMu8_AVX512=5302, - XED_IFORM_VPMOVB2M_MASKmskw_ZMMu8_AVX512=5303, - XED_IFORM_VPMOVD2M_MASKmskw_XMMu32_AVX512=5304, - XED_IFORM_VPMOVD2M_MASKmskw_YMMu32_AVX512=5305, - XED_IFORM_VPMOVD2M_MASKmskw_ZMMu32_AVX512=5306, - XED_IFORM_VPMOVDB_MEMu8_MASKmskw_XMMu32_AVX512=5307, - XED_IFORM_VPMOVDB_MEMu8_MASKmskw_YMMu32_AVX512=5308, - XED_IFORM_VPMOVDB_MEMu8_MASKmskw_ZMMu32_AVX512=5309, - XED_IFORM_VPMOVDB_XMMu8_MASKmskw_XMMu32_AVX512=5310, - XED_IFORM_VPMOVDB_XMMu8_MASKmskw_YMMu32_AVX512=5311, - XED_IFORM_VPMOVDB_XMMu8_MASKmskw_ZMMu32_AVX512=5312, - XED_IFORM_VPMOVDW_MEMu16_MASKmskw_XMMu32_AVX512=5313, - XED_IFORM_VPMOVDW_MEMu16_MASKmskw_YMMu32_AVX512=5314, - XED_IFORM_VPMOVDW_MEMu16_MASKmskw_ZMMu32_AVX512=5315, - XED_IFORM_VPMOVDW_XMMu16_MASKmskw_XMMu32_AVX512=5316, - XED_IFORM_VPMOVDW_XMMu16_MASKmskw_YMMu32_AVX512=5317, - XED_IFORM_VPMOVDW_YMMu16_MASKmskw_ZMMu32_AVX512=5318, - XED_IFORM_VPMOVM2B_XMMu8_MASKmskw_AVX512=5319, - XED_IFORM_VPMOVM2B_YMMu8_MASKmskw_AVX512=5320, - XED_IFORM_VPMOVM2B_ZMMu8_MASKmskw_AVX512=5321, - XED_IFORM_VPMOVM2D_XMMu32_MASKmskw_AVX512=5322, - XED_IFORM_VPMOVM2D_YMMu32_MASKmskw_AVX512=5323, - XED_IFORM_VPMOVM2D_ZMMu32_MASKmskw_AVX512=5324, - XED_IFORM_VPMOVM2Q_XMMu64_MASKmskw_AVX512=5325, - XED_IFORM_VPMOVM2Q_YMMu64_MASKmskw_AVX512=5326, - XED_IFORM_VPMOVM2Q_ZMMu64_MASKmskw_AVX512=5327, - XED_IFORM_VPMOVM2W_XMMu16_MASKmskw_AVX512=5328, - XED_IFORM_VPMOVM2W_YMMu16_MASKmskw_AVX512=5329, - XED_IFORM_VPMOVM2W_ZMMu16_MASKmskw_AVX512=5330, - XED_IFORM_VPMOVMSKB_GPR32d_XMMdq=5331, - XED_IFORM_VPMOVMSKB_GPR32d_YMMqq=5332, - XED_IFORM_VPMOVQ2M_MASKmskw_XMMu64_AVX512=5333, - XED_IFORM_VPMOVQ2M_MASKmskw_YMMu64_AVX512=5334, - XED_IFORM_VPMOVQ2M_MASKmskw_ZMMu64_AVX512=5335, - XED_IFORM_VPMOVQB_MEMu8_MASKmskw_XMMu64_AVX512=5336, - XED_IFORM_VPMOVQB_MEMu8_MASKmskw_YMMu64_AVX512=5337, - XED_IFORM_VPMOVQB_MEMu8_MASKmskw_ZMMu64_AVX512=5338, - XED_IFORM_VPMOVQB_XMMu8_MASKmskw_XMMu64_AVX512=5339, - XED_IFORM_VPMOVQB_XMMu8_MASKmskw_YMMu64_AVX512=5340, - XED_IFORM_VPMOVQB_XMMu8_MASKmskw_ZMMu64_AVX512=5341, - XED_IFORM_VPMOVQD_MEMu32_MASKmskw_XMMu64_AVX512=5342, - XED_IFORM_VPMOVQD_MEMu32_MASKmskw_YMMu64_AVX512=5343, - XED_IFORM_VPMOVQD_MEMu32_MASKmskw_ZMMu64_AVX512=5344, - XED_IFORM_VPMOVQD_XMMu32_MASKmskw_XMMu64_AVX512=5345, - XED_IFORM_VPMOVQD_XMMu32_MASKmskw_YMMu64_AVX512=5346, - XED_IFORM_VPMOVQD_YMMu32_MASKmskw_ZMMu64_AVX512=5347, - XED_IFORM_VPMOVQW_MEMu16_MASKmskw_XMMu64_AVX512=5348, - XED_IFORM_VPMOVQW_MEMu16_MASKmskw_YMMu64_AVX512=5349, - XED_IFORM_VPMOVQW_MEMu16_MASKmskw_ZMMu64_AVX512=5350, - XED_IFORM_VPMOVQW_XMMu16_MASKmskw_XMMu64_AVX512=5351, - XED_IFORM_VPMOVQW_XMMu16_MASKmskw_YMMu64_AVX512=5352, - XED_IFORM_VPMOVQW_XMMu16_MASKmskw_ZMMu64_AVX512=5353, - XED_IFORM_VPMOVSDB_MEMi8_MASKmskw_XMMi32_AVX512=5354, - XED_IFORM_VPMOVSDB_MEMi8_MASKmskw_YMMi32_AVX512=5355, - XED_IFORM_VPMOVSDB_MEMi8_MASKmskw_ZMMi32_AVX512=5356, - XED_IFORM_VPMOVSDB_XMMi8_MASKmskw_XMMi32_AVX512=5357, - XED_IFORM_VPMOVSDB_XMMi8_MASKmskw_YMMi32_AVX512=5358, - XED_IFORM_VPMOVSDB_XMMi8_MASKmskw_ZMMi32_AVX512=5359, - XED_IFORM_VPMOVSDW_MEMi16_MASKmskw_XMMi32_AVX512=5360, - XED_IFORM_VPMOVSDW_MEMi16_MASKmskw_YMMi32_AVX512=5361, - XED_IFORM_VPMOVSDW_MEMi16_MASKmskw_ZMMi32_AVX512=5362, - XED_IFORM_VPMOVSDW_XMMi16_MASKmskw_XMMi32_AVX512=5363, - XED_IFORM_VPMOVSDW_XMMi16_MASKmskw_YMMi32_AVX512=5364, - XED_IFORM_VPMOVSDW_YMMi16_MASKmskw_ZMMi32_AVX512=5365, - XED_IFORM_VPMOVSQB_MEMi8_MASKmskw_XMMi64_AVX512=5366, - XED_IFORM_VPMOVSQB_MEMi8_MASKmskw_YMMi64_AVX512=5367, - XED_IFORM_VPMOVSQB_MEMi8_MASKmskw_ZMMi64_AVX512=5368, - XED_IFORM_VPMOVSQB_XMMi8_MASKmskw_XMMi64_AVX512=5369, - XED_IFORM_VPMOVSQB_XMMi8_MASKmskw_YMMi64_AVX512=5370, - XED_IFORM_VPMOVSQB_XMMi8_MASKmskw_ZMMi64_AVX512=5371, - XED_IFORM_VPMOVSQD_MEMi32_MASKmskw_XMMi64_AVX512=5372, - XED_IFORM_VPMOVSQD_MEMi32_MASKmskw_YMMi64_AVX512=5373, - XED_IFORM_VPMOVSQD_MEMi32_MASKmskw_ZMMi64_AVX512=5374, - XED_IFORM_VPMOVSQD_XMMi32_MASKmskw_XMMi64_AVX512=5375, - XED_IFORM_VPMOVSQD_XMMi32_MASKmskw_YMMi64_AVX512=5376, - XED_IFORM_VPMOVSQD_YMMi32_MASKmskw_ZMMi64_AVX512=5377, - XED_IFORM_VPMOVSQW_MEMi16_MASKmskw_XMMi64_AVX512=5378, - XED_IFORM_VPMOVSQW_MEMi16_MASKmskw_YMMi64_AVX512=5379, - XED_IFORM_VPMOVSQW_MEMi16_MASKmskw_ZMMi64_AVX512=5380, - XED_IFORM_VPMOVSQW_XMMi16_MASKmskw_XMMi64_AVX512=5381, - XED_IFORM_VPMOVSQW_XMMi16_MASKmskw_YMMi64_AVX512=5382, - XED_IFORM_VPMOVSQW_XMMi16_MASKmskw_ZMMi64_AVX512=5383, - XED_IFORM_VPMOVSWB_MEMi8_MASKmskw_XMMi16_AVX512=5384, - XED_IFORM_VPMOVSWB_MEMi8_MASKmskw_YMMi16_AVX512=5385, - XED_IFORM_VPMOVSWB_MEMi8_MASKmskw_ZMMi16_AVX512=5386, - XED_IFORM_VPMOVSWB_XMMi8_MASKmskw_XMMi16_AVX512=5387, - XED_IFORM_VPMOVSWB_XMMi8_MASKmskw_YMMi16_AVX512=5388, - XED_IFORM_VPMOVSWB_YMMi8_MASKmskw_ZMMi16_AVX512=5389, - XED_IFORM_VPMOVSXBD_XMMdq_MEMd=5390, - XED_IFORM_VPMOVSXBD_XMMdq_XMMd=5391, - XED_IFORM_VPMOVSXBD_XMMi32_MASKmskw_MEMi8_AVX512=5392, - XED_IFORM_VPMOVSXBD_XMMi32_MASKmskw_XMMi8_AVX512=5393, - XED_IFORM_VPMOVSXBD_YMMi32_MASKmskw_MEMi8_AVX512=5394, - XED_IFORM_VPMOVSXBD_YMMi32_MASKmskw_XMMi8_AVX512=5395, - XED_IFORM_VPMOVSXBD_YMMqq_MEMq=5396, - XED_IFORM_VPMOVSXBD_YMMqq_XMMq=5397, - XED_IFORM_VPMOVSXBD_ZMMi32_MASKmskw_MEMi8_AVX512=5398, - XED_IFORM_VPMOVSXBD_ZMMi32_MASKmskw_XMMi8_AVX512=5399, - XED_IFORM_VPMOVSXBQ_XMMdq_MEMw=5400, - XED_IFORM_VPMOVSXBQ_XMMdq_XMMw=5401, - XED_IFORM_VPMOVSXBQ_XMMi64_MASKmskw_MEMi8_AVX512=5402, - XED_IFORM_VPMOVSXBQ_XMMi64_MASKmskw_XMMi8_AVX512=5403, - XED_IFORM_VPMOVSXBQ_YMMi64_MASKmskw_MEMi8_AVX512=5404, - XED_IFORM_VPMOVSXBQ_YMMi64_MASKmskw_XMMi8_AVX512=5405, - XED_IFORM_VPMOVSXBQ_YMMqq_MEMd=5406, - XED_IFORM_VPMOVSXBQ_YMMqq_XMMd=5407, - XED_IFORM_VPMOVSXBQ_ZMMi64_MASKmskw_MEMi8_AVX512=5408, - XED_IFORM_VPMOVSXBQ_ZMMi64_MASKmskw_XMMi8_AVX512=5409, - XED_IFORM_VPMOVSXBW_XMMdq_MEMq=5410, - XED_IFORM_VPMOVSXBW_XMMdq_XMMq=5411, - XED_IFORM_VPMOVSXBW_XMMi16_MASKmskw_MEMi8_AVX512=5412, - XED_IFORM_VPMOVSXBW_XMMi16_MASKmskw_XMMi8_AVX512=5413, - XED_IFORM_VPMOVSXBW_YMMi16_MASKmskw_MEMi8_AVX512=5414, - XED_IFORM_VPMOVSXBW_YMMi16_MASKmskw_XMMi8_AVX512=5415, - XED_IFORM_VPMOVSXBW_YMMqq_MEMdq=5416, - XED_IFORM_VPMOVSXBW_YMMqq_XMMdq=5417, - XED_IFORM_VPMOVSXBW_ZMMi16_MASKmskw_MEMi8_AVX512=5418, - XED_IFORM_VPMOVSXBW_ZMMi16_MASKmskw_YMMi8_AVX512=5419, - XED_IFORM_VPMOVSXDQ_XMMdq_MEMq=5420, - XED_IFORM_VPMOVSXDQ_XMMdq_XMMq=5421, - XED_IFORM_VPMOVSXDQ_XMMi64_MASKmskw_MEMi32_AVX512=5422, - XED_IFORM_VPMOVSXDQ_XMMi64_MASKmskw_XMMi32_AVX512=5423, - XED_IFORM_VPMOVSXDQ_YMMi64_MASKmskw_MEMi32_AVX512=5424, - XED_IFORM_VPMOVSXDQ_YMMi64_MASKmskw_XMMi32_AVX512=5425, - XED_IFORM_VPMOVSXDQ_YMMqq_MEMdq=5426, - XED_IFORM_VPMOVSXDQ_YMMqq_XMMdq=5427, - XED_IFORM_VPMOVSXDQ_ZMMi64_MASKmskw_MEMi32_AVX512=5428, - XED_IFORM_VPMOVSXDQ_ZMMi64_MASKmskw_YMMi32_AVX512=5429, - XED_IFORM_VPMOVSXWD_XMMdq_MEMq=5430, - XED_IFORM_VPMOVSXWD_XMMdq_XMMq=5431, - XED_IFORM_VPMOVSXWD_XMMi32_MASKmskw_MEMi16_AVX512=5432, - XED_IFORM_VPMOVSXWD_XMMi32_MASKmskw_XMMi16_AVX512=5433, - XED_IFORM_VPMOVSXWD_YMMi32_MASKmskw_MEMi16_AVX512=5434, - XED_IFORM_VPMOVSXWD_YMMi32_MASKmskw_XMMi16_AVX512=5435, - XED_IFORM_VPMOVSXWD_YMMqq_MEMdq=5436, - XED_IFORM_VPMOVSXWD_YMMqq_XMMdq=5437, - XED_IFORM_VPMOVSXWD_ZMMi32_MASKmskw_MEMi16_AVX512=5438, - XED_IFORM_VPMOVSXWD_ZMMi32_MASKmskw_YMMi16_AVX512=5439, - XED_IFORM_VPMOVSXWQ_XMMdq_MEMd=5440, - XED_IFORM_VPMOVSXWQ_XMMdq_XMMd=5441, - XED_IFORM_VPMOVSXWQ_XMMi64_MASKmskw_MEMi16_AVX512=5442, - XED_IFORM_VPMOVSXWQ_XMMi64_MASKmskw_XMMi16_AVX512=5443, - XED_IFORM_VPMOVSXWQ_YMMi64_MASKmskw_MEMi16_AVX512=5444, - XED_IFORM_VPMOVSXWQ_YMMi64_MASKmskw_XMMi16_AVX512=5445, - XED_IFORM_VPMOVSXWQ_YMMqq_MEMq=5446, - XED_IFORM_VPMOVSXWQ_YMMqq_XMMq=5447, - XED_IFORM_VPMOVSXWQ_ZMMi64_MASKmskw_MEMi16_AVX512=5448, - XED_IFORM_VPMOVSXWQ_ZMMi64_MASKmskw_XMMi16_AVX512=5449, - XED_IFORM_VPMOVUSDB_MEMu8_MASKmskw_XMMu32_AVX512=5450, - XED_IFORM_VPMOVUSDB_MEMu8_MASKmskw_YMMu32_AVX512=5451, - XED_IFORM_VPMOVUSDB_MEMu8_MASKmskw_ZMMu32_AVX512=5452, - XED_IFORM_VPMOVUSDB_XMMu8_MASKmskw_XMMu32_AVX512=5453, - XED_IFORM_VPMOVUSDB_XMMu8_MASKmskw_YMMu32_AVX512=5454, - XED_IFORM_VPMOVUSDB_XMMu8_MASKmskw_ZMMu32_AVX512=5455, - XED_IFORM_VPMOVUSDW_MEMu16_MASKmskw_XMMu32_AVX512=5456, - XED_IFORM_VPMOVUSDW_MEMu16_MASKmskw_YMMu32_AVX512=5457, - XED_IFORM_VPMOVUSDW_MEMu16_MASKmskw_ZMMu32_AVX512=5458, - XED_IFORM_VPMOVUSDW_XMMu16_MASKmskw_XMMu32_AVX512=5459, - XED_IFORM_VPMOVUSDW_XMMu16_MASKmskw_YMMu32_AVX512=5460, - XED_IFORM_VPMOVUSDW_YMMu16_MASKmskw_ZMMu32_AVX512=5461, - XED_IFORM_VPMOVUSQB_MEMu8_MASKmskw_XMMu64_AVX512=5462, - XED_IFORM_VPMOVUSQB_MEMu8_MASKmskw_YMMu64_AVX512=5463, - XED_IFORM_VPMOVUSQB_MEMu8_MASKmskw_ZMMu64_AVX512=5464, - XED_IFORM_VPMOVUSQB_XMMu8_MASKmskw_XMMu64_AVX512=5465, - XED_IFORM_VPMOVUSQB_XMMu8_MASKmskw_YMMu64_AVX512=5466, - XED_IFORM_VPMOVUSQB_XMMu8_MASKmskw_ZMMu64_AVX512=5467, - XED_IFORM_VPMOVUSQD_MEMu32_MASKmskw_XMMu64_AVX512=5468, - XED_IFORM_VPMOVUSQD_MEMu32_MASKmskw_YMMu64_AVX512=5469, - XED_IFORM_VPMOVUSQD_MEMu32_MASKmskw_ZMMu64_AVX512=5470, - XED_IFORM_VPMOVUSQD_XMMu32_MASKmskw_XMMu64_AVX512=5471, - XED_IFORM_VPMOVUSQD_XMMu32_MASKmskw_YMMu64_AVX512=5472, - XED_IFORM_VPMOVUSQD_YMMu32_MASKmskw_ZMMu64_AVX512=5473, - XED_IFORM_VPMOVUSQW_MEMu16_MASKmskw_XMMu64_AVX512=5474, - XED_IFORM_VPMOVUSQW_MEMu16_MASKmskw_YMMu64_AVX512=5475, - XED_IFORM_VPMOVUSQW_MEMu16_MASKmskw_ZMMu64_AVX512=5476, - XED_IFORM_VPMOVUSQW_XMMu16_MASKmskw_XMMu64_AVX512=5477, - XED_IFORM_VPMOVUSQW_XMMu16_MASKmskw_YMMu64_AVX512=5478, - XED_IFORM_VPMOVUSQW_XMMu16_MASKmskw_ZMMu64_AVX512=5479, - XED_IFORM_VPMOVUSWB_MEMu8_MASKmskw_XMMu16_AVX512=5480, - XED_IFORM_VPMOVUSWB_MEMu8_MASKmskw_YMMu16_AVX512=5481, - XED_IFORM_VPMOVUSWB_MEMu8_MASKmskw_ZMMu16_AVX512=5482, - XED_IFORM_VPMOVUSWB_XMMu8_MASKmskw_XMMu16_AVX512=5483, - XED_IFORM_VPMOVUSWB_XMMu8_MASKmskw_YMMu16_AVX512=5484, - XED_IFORM_VPMOVUSWB_YMMu8_MASKmskw_ZMMu16_AVX512=5485, - XED_IFORM_VPMOVW2M_MASKmskw_XMMu16_AVX512=5486, - XED_IFORM_VPMOVW2M_MASKmskw_YMMu16_AVX512=5487, - XED_IFORM_VPMOVW2M_MASKmskw_ZMMu16_AVX512=5488, - XED_IFORM_VPMOVWB_MEMu8_MASKmskw_XMMu16_AVX512=5489, - XED_IFORM_VPMOVWB_MEMu8_MASKmskw_YMMu16_AVX512=5490, - XED_IFORM_VPMOVWB_MEMu8_MASKmskw_ZMMu16_AVX512=5491, - XED_IFORM_VPMOVWB_XMMu8_MASKmskw_XMMu16_AVX512=5492, - XED_IFORM_VPMOVWB_XMMu8_MASKmskw_YMMu16_AVX512=5493, - XED_IFORM_VPMOVWB_YMMu8_MASKmskw_ZMMu16_AVX512=5494, - XED_IFORM_VPMOVZXBD_XMMdq_MEMd=5495, - XED_IFORM_VPMOVZXBD_XMMdq_XMMd=5496, - XED_IFORM_VPMOVZXBD_XMMi32_MASKmskw_MEMi8_AVX512=5497, - XED_IFORM_VPMOVZXBD_XMMi32_MASKmskw_XMMi8_AVX512=5498, - XED_IFORM_VPMOVZXBD_YMMi32_MASKmskw_MEMi8_AVX512=5499, - XED_IFORM_VPMOVZXBD_YMMi32_MASKmskw_XMMi8_AVX512=5500, - XED_IFORM_VPMOVZXBD_YMMqq_MEMq=5501, - XED_IFORM_VPMOVZXBD_YMMqq_XMMq=5502, - XED_IFORM_VPMOVZXBD_ZMMi32_MASKmskw_MEMi8_AVX512=5503, - XED_IFORM_VPMOVZXBD_ZMMi32_MASKmskw_XMMi8_AVX512=5504, - XED_IFORM_VPMOVZXBQ_XMMdq_MEMw=5505, - XED_IFORM_VPMOVZXBQ_XMMdq_XMMw=5506, - XED_IFORM_VPMOVZXBQ_XMMi64_MASKmskw_MEMi8_AVX512=5507, - XED_IFORM_VPMOVZXBQ_XMMi64_MASKmskw_XMMi8_AVX512=5508, - XED_IFORM_VPMOVZXBQ_YMMi64_MASKmskw_MEMi8_AVX512=5509, - XED_IFORM_VPMOVZXBQ_YMMi64_MASKmskw_XMMi8_AVX512=5510, - XED_IFORM_VPMOVZXBQ_YMMqq_MEMd=5511, - XED_IFORM_VPMOVZXBQ_YMMqq_XMMd=5512, - XED_IFORM_VPMOVZXBQ_ZMMi64_MASKmskw_MEMi8_AVX512=5513, - XED_IFORM_VPMOVZXBQ_ZMMi64_MASKmskw_XMMi8_AVX512=5514, - XED_IFORM_VPMOVZXBW_XMMdq_MEMq=5515, - XED_IFORM_VPMOVZXBW_XMMdq_XMMq=5516, - XED_IFORM_VPMOVZXBW_XMMi16_MASKmskw_MEMi8_AVX512=5517, - XED_IFORM_VPMOVZXBW_XMMi16_MASKmskw_XMMi8_AVX512=5518, - XED_IFORM_VPMOVZXBW_YMMi16_MASKmskw_MEMi8_AVX512=5519, - XED_IFORM_VPMOVZXBW_YMMi16_MASKmskw_XMMi8_AVX512=5520, - XED_IFORM_VPMOVZXBW_YMMqq_MEMdq=5521, - XED_IFORM_VPMOVZXBW_YMMqq_XMMdq=5522, - XED_IFORM_VPMOVZXBW_ZMMi16_MASKmskw_MEMi8_AVX512=5523, - XED_IFORM_VPMOVZXBW_ZMMi16_MASKmskw_YMMi8_AVX512=5524, - XED_IFORM_VPMOVZXDQ_XMMdq_MEMq=5525, - XED_IFORM_VPMOVZXDQ_XMMdq_XMMq=5526, - XED_IFORM_VPMOVZXDQ_XMMi64_MASKmskw_MEMi32_AVX512=5527, - XED_IFORM_VPMOVZXDQ_XMMi64_MASKmskw_XMMi32_AVX512=5528, - XED_IFORM_VPMOVZXDQ_YMMi64_MASKmskw_MEMi32_AVX512=5529, - XED_IFORM_VPMOVZXDQ_YMMi64_MASKmskw_XMMi32_AVX512=5530, - XED_IFORM_VPMOVZXDQ_YMMqq_MEMdq=5531, - XED_IFORM_VPMOVZXDQ_YMMqq_XMMdq=5532, - XED_IFORM_VPMOVZXDQ_ZMMi64_MASKmskw_MEMi32_AVX512=5533, - XED_IFORM_VPMOVZXDQ_ZMMi64_MASKmskw_YMMi32_AVX512=5534, - XED_IFORM_VPMOVZXWD_XMMdq_MEMq=5535, - XED_IFORM_VPMOVZXWD_XMMdq_XMMq=5536, - XED_IFORM_VPMOVZXWD_XMMi32_MASKmskw_MEMi16_AVX512=5537, - XED_IFORM_VPMOVZXWD_XMMi32_MASKmskw_XMMi16_AVX512=5538, - XED_IFORM_VPMOVZXWD_YMMi32_MASKmskw_MEMi16_AVX512=5539, - XED_IFORM_VPMOVZXWD_YMMi32_MASKmskw_XMMi16_AVX512=5540, - XED_IFORM_VPMOVZXWD_YMMqq_MEMdq=5541, - XED_IFORM_VPMOVZXWD_YMMqq_XMMdq=5542, - XED_IFORM_VPMOVZXWD_ZMMi32_MASKmskw_MEMi16_AVX512=5543, - XED_IFORM_VPMOVZXWD_ZMMi32_MASKmskw_YMMi16_AVX512=5544, - XED_IFORM_VPMOVZXWQ_XMMdq_MEMd=5545, - XED_IFORM_VPMOVZXWQ_XMMdq_XMMd=5546, - XED_IFORM_VPMOVZXWQ_XMMi64_MASKmskw_MEMi16_AVX512=5547, - XED_IFORM_VPMOVZXWQ_XMMi64_MASKmskw_XMMi16_AVX512=5548, - XED_IFORM_VPMOVZXWQ_YMMi64_MASKmskw_MEMi16_AVX512=5549, - XED_IFORM_VPMOVZXWQ_YMMi64_MASKmskw_XMMi16_AVX512=5550, - XED_IFORM_VPMOVZXWQ_YMMqq_MEMq=5551, - XED_IFORM_VPMOVZXWQ_YMMqq_XMMq=5552, - XED_IFORM_VPMOVZXWQ_ZMMi64_MASKmskw_MEMi16_AVX512=5553, - XED_IFORM_VPMOVZXWQ_ZMMi64_MASKmskw_XMMi16_AVX512=5554, - XED_IFORM_VPMULDQ_XMMdq_XMMdq_MEMdq=5555, - XED_IFORM_VPMULDQ_XMMdq_XMMdq_XMMdq=5556, - XED_IFORM_VPMULDQ_XMMi64_MASKmskw_XMMi32_MEMi32_AVX512=5557, - XED_IFORM_VPMULDQ_XMMi64_MASKmskw_XMMi32_XMMi32_AVX512=5558, - XED_IFORM_VPMULDQ_YMMi64_MASKmskw_YMMi32_MEMi32_AVX512=5559, - XED_IFORM_VPMULDQ_YMMi64_MASKmskw_YMMi32_YMMi32_AVX512=5560, - XED_IFORM_VPMULDQ_YMMqq_YMMqq_MEMqq=5561, - XED_IFORM_VPMULDQ_YMMqq_YMMqq_YMMqq=5562, - XED_IFORM_VPMULDQ_ZMMi64_MASKmskw_ZMMi32_MEMi32_AVX512=5563, - XED_IFORM_VPMULDQ_ZMMi64_MASKmskw_ZMMi32_ZMMi32_AVX512=5564, - XED_IFORM_VPMULHRSW_XMMdq_XMMdq_MEMdq=5565, - XED_IFORM_VPMULHRSW_XMMdq_XMMdq_XMMdq=5566, - XED_IFORM_VPMULHRSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=5567, - XED_IFORM_VPMULHRSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=5568, - XED_IFORM_VPMULHRSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=5569, - XED_IFORM_VPMULHRSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=5570, - XED_IFORM_VPMULHRSW_YMMqq_YMMqq_MEMqq=5571, - XED_IFORM_VPMULHRSW_YMMqq_YMMqq_YMMqq=5572, - XED_IFORM_VPMULHRSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=5573, - XED_IFORM_VPMULHRSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=5574, - XED_IFORM_VPMULHUW_XMMdq_XMMdq_MEMdq=5575, - XED_IFORM_VPMULHUW_XMMdq_XMMdq_XMMdq=5576, - XED_IFORM_VPMULHUW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5577, - XED_IFORM_VPMULHUW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5578, - XED_IFORM_VPMULHUW_YMMqq_YMMqq_MEMqq=5579, - XED_IFORM_VPMULHUW_YMMqq_YMMqq_YMMqq=5580, - XED_IFORM_VPMULHUW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5581, - XED_IFORM_VPMULHUW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5582, - XED_IFORM_VPMULHUW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5583, - XED_IFORM_VPMULHUW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5584, - XED_IFORM_VPMULHW_XMMdq_XMMdq_MEMdq=5585, - XED_IFORM_VPMULHW_XMMdq_XMMdq_XMMdq=5586, - XED_IFORM_VPMULHW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5587, - XED_IFORM_VPMULHW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5588, - XED_IFORM_VPMULHW_YMMqq_YMMqq_MEMqq=5589, - XED_IFORM_VPMULHW_YMMqq_YMMqq_YMMqq=5590, - XED_IFORM_VPMULHW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5591, - XED_IFORM_VPMULHW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5592, - XED_IFORM_VPMULHW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5593, - XED_IFORM_VPMULHW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5594, - XED_IFORM_VPMULLD_XMMdq_XMMdq_MEMdq=5595, - XED_IFORM_VPMULLD_XMMdq_XMMdq_XMMdq=5596, - XED_IFORM_VPMULLD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5597, - XED_IFORM_VPMULLD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5598, - XED_IFORM_VPMULLD_YMMqq_YMMqq_MEMqq=5599, - XED_IFORM_VPMULLD_YMMqq_YMMqq_YMMqq=5600, - XED_IFORM_VPMULLD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5601, - XED_IFORM_VPMULLD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5602, - XED_IFORM_VPMULLD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5603, - XED_IFORM_VPMULLD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5604, - XED_IFORM_VPMULLQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5605, - XED_IFORM_VPMULLQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5606, - XED_IFORM_VPMULLQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5607, - XED_IFORM_VPMULLQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5608, - XED_IFORM_VPMULLQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5609, - XED_IFORM_VPMULLQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5610, - XED_IFORM_VPMULLW_XMMdq_XMMdq_MEMdq=5611, - XED_IFORM_VPMULLW_XMMdq_XMMdq_XMMdq=5612, - XED_IFORM_VPMULLW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5613, - XED_IFORM_VPMULLW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5614, - XED_IFORM_VPMULLW_YMMqq_YMMqq_MEMqq=5615, - XED_IFORM_VPMULLW_YMMqq_YMMqq_YMMqq=5616, - XED_IFORM_VPMULLW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5617, - XED_IFORM_VPMULLW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5618, - XED_IFORM_VPMULLW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5619, - XED_IFORM_VPMULLW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5620, - XED_IFORM_VPMULTISHIFTQB_XMMu8_MASKmskw_XMMu8_MEMu64_AVX512=5621, - XED_IFORM_VPMULTISHIFTQB_XMMu8_MASKmskw_XMMu8_XMMu64_AVX512=5622, - XED_IFORM_VPMULTISHIFTQB_YMMu8_MASKmskw_YMMu8_MEMu64_AVX512=5623, - XED_IFORM_VPMULTISHIFTQB_YMMu8_MASKmskw_YMMu8_YMMu64_AVX512=5624, - XED_IFORM_VPMULTISHIFTQB_ZMMu8_MASKmskw_ZMMu8_MEMu64_AVX512=5625, - XED_IFORM_VPMULTISHIFTQB_ZMMu8_MASKmskw_ZMMu8_ZMMu64_AVX512=5626, - XED_IFORM_VPMULUDQ_XMMdq_XMMdq_MEMdq=5627, - XED_IFORM_VPMULUDQ_XMMdq_XMMdq_XMMdq=5628, - XED_IFORM_VPMULUDQ_XMMu64_MASKmskw_XMMu32_MEMu32_AVX512=5629, - XED_IFORM_VPMULUDQ_XMMu64_MASKmskw_XMMu32_XMMu32_AVX512=5630, - XED_IFORM_VPMULUDQ_YMMqq_YMMqq_MEMqq=5631, - XED_IFORM_VPMULUDQ_YMMqq_YMMqq_YMMqq=5632, - XED_IFORM_VPMULUDQ_YMMu64_MASKmskw_YMMu32_MEMu32_AVX512=5633, - XED_IFORM_VPMULUDQ_YMMu64_MASKmskw_YMMu32_YMMu32_AVX512=5634, - XED_IFORM_VPMULUDQ_ZMMu64_MASKmskw_ZMMu32_MEMu32_AVX512=5635, - XED_IFORM_VPMULUDQ_ZMMu64_MASKmskw_ZMMu32_ZMMu32_AVX512=5636, - XED_IFORM_VPOPCNTB_XMMu8_MASKmskw_MEMu8_AVX512=5637, - XED_IFORM_VPOPCNTB_XMMu8_MASKmskw_XMMu8_AVX512=5638, - XED_IFORM_VPOPCNTB_YMMu8_MASKmskw_MEMu8_AVX512=5639, - XED_IFORM_VPOPCNTB_YMMu8_MASKmskw_YMMu8_AVX512=5640, - XED_IFORM_VPOPCNTB_ZMMu8_MASKmskw_MEMu8_AVX512=5641, - XED_IFORM_VPOPCNTB_ZMMu8_MASKmskw_ZMMu8_AVX512=5642, - XED_IFORM_VPOPCNTD_XMMu32_MASKmskw_MEMu32_AVX512=5643, - XED_IFORM_VPOPCNTD_XMMu32_MASKmskw_XMMu32_AVX512=5644, - XED_IFORM_VPOPCNTD_YMMu32_MASKmskw_MEMu32_AVX512=5645, - XED_IFORM_VPOPCNTD_YMMu32_MASKmskw_YMMu32_AVX512=5646, - XED_IFORM_VPOPCNTD_ZMMu32_MASKmskw_MEMu32_AVX512=5647, - XED_IFORM_VPOPCNTD_ZMMu32_MASKmskw_ZMMu32_AVX512=5648, - XED_IFORM_VPOPCNTQ_XMMu64_MASKmskw_MEMu64_AVX512=5649, - XED_IFORM_VPOPCNTQ_XMMu64_MASKmskw_XMMu64_AVX512=5650, - XED_IFORM_VPOPCNTQ_YMMu64_MASKmskw_MEMu64_AVX512=5651, - XED_IFORM_VPOPCNTQ_YMMu64_MASKmskw_YMMu64_AVX512=5652, - XED_IFORM_VPOPCNTQ_ZMMu64_MASKmskw_MEMu64_AVX512=5653, - XED_IFORM_VPOPCNTQ_ZMMu64_MASKmskw_ZMMu64_AVX512=5654, - XED_IFORM_VPOPCNTW_XMMu16_MASKmskw_MEMu16_AVX512=5655, - XED_IFORM_VPOPCNTW_XMMu16_MASKmskw_XMMu16_AVX512=5656, - XED_IFORM_VPOPCNTW_YMMu16_MASKmskw_MEMu16_AVX512=5657, - XED_IFORM_VPOPCNTW_YMMu16_MASKmskw_YMMu16_AVX512=5658, - XED_IFORM_VPOPCNTW_ZMMu16_MASKmskw_MEMu16_AVX512=5659, - XED_IFORM_VPOPCNTW_ZMMu16_MASKmskw_ZMMu16_AVX512=5660, - XED_IFORM_VPOR_XMMdq_XMMdq_MEMdq=5661, - XED_IFORM_VPOR_XMMdq_XMMdq_XMMdq=5662, - XED_IFORM_VPOR_YMMqq_YMMqq_MEMqq=5663, - XED_IFORM_VPOR_YMMqq_YMMqq_YMMqq=5664, - XED_IFORM_VPORD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5665, - XED_IFORM_VPORD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5666, - XED_IFORM_VPORD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5667, - XED_IFORM_VPORD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5668, - XED_IFORM_VPORD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5669, - XED_IFORM_VPORD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5670, - XED_IFORM_VPORQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5671, - XED_IFORM_VPORQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5672, - XED_IFORM_VPORQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5673, - XED_IFORM_VPORQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5674, - XED_IFORM_VPORQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5675, - XED_IFORM_VPORQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5676, - XED_IFORM_VPPERM_XMMdq_XMMdq_MEMdq_XMMdq=5677, - XED_IFORM_VPPERM_XMMdq_XMMdq_XMMdq_MEMdq=5678, - XED_IFORM_VPPERM_XMMdq_XMMdq_XMMdq_XMMdq=5679, - XED_IFORM_VPROLD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=5680, - XED_IFORM_VPROLD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=5681, - XED_IFORM_VPROLD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=5682, - XED_IFORM_VPROLD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=5683, - XED_IFORM_VPROLD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=5684, - XED_IFORM_VPROLD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=5685, - XED_IFORM_VPROLQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512=5686, - XED_IFORM_VPROLQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512=5687, - XED_IFORM_VPROLQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=5688, - XED_IFORM_VPROLQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=5689, - XED_IFORM_VPROLQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=5690, - XED_IFORM_VPROLQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=5691, - XED_IFORM_VPROLVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5692, - XED_IFORM_VPROLVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5693, - XED_IFORM_VPROLVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5694, - XED_IFORM_VPROLVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5695, - XED_IFORM_VPROLVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5696, - XED_IFORM_VPROLVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5697, - XED_IFORM_VPROLVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5698, - XED_IFORM_VPROLVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5699, - XED_IFORM_VPROLVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5700, - XED_IFORM_VPROLVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5701, - XED_IFORM_VPROLVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5702, - XED_IFORM_VPROLVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5703, - XED_IFORM_VPRORD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=5704, - XED_IFORM_VPRORD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=5705, - XED_IFORM_VPRORD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=5706, - XED_IFORM_VPRORD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=5707, - XED_IFORM_VPRORD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=5708, - XED_IFORM_VPRORD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=5709, - XED_IFORM_VPRORQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512=5710, - XED_IFORM_VPRORQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512=5711, - XED_IFORM_VPRORQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=5712, - XED_IFORM_VPRORQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=5713, - XED_IFORM_VPRORQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=5714, - XED_IFORM_VPRORQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=5715, - XED_IFORM_VPRORVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5716, - XED_IFORM_VPRORVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5717, - XED_IFORM_VPRORVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5718, - XED_IFORM_VPRORVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5719, - XED_IFORM_VPRORVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5720, - XED_IFORM_VPRORVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5721, - XED_IFORM_VPRORVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5722, - XED_IFORM_VPRORVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5723, - XED_IFORM_VPRORVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5724, - XED_IFORM_VPRORVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5725, - XED_IFORM_VPRORVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5726, - XED_IFORM_VPRORVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5727, - XED_IFORM_VPROTB_XMMdq_MEMdq_IMMb=5728, - XED_IFORM_VPROTB_XMMdq_MEMdq_XMMdq=5729, - XED_IFORM_VPROTB_XMMdq_XMMdq_IMMb=5730, - XED_IFORM_VPROTB_XMMdq_XMMdq_MEMdq=5731, - XED_IFORM_VPROTB_XMMdq_XMMdq_XMMdq=5732, - XED_IFORM_VPROTD_XMMdq_MEMdq_IMMb=5733, - XED_IFORM_VPROTD_XMMdq_MEMdq_XMMdq=5734, - XED_IFORM_VPROTD_XMMdq_XMMdq_IMMb=5735, - XED_IFORM_VPROTD_XMMdq_XMMdq_MEMdq=5736, - XED_IFORM_VPROTD_XMMdq_XMMdq_XMMdq=5737, - XED_IFORM_VPROTQ_XMMdq_MEMdq_IMMb=5738, - XED_IFORM_VPROTQ_XMMdq_MEMdq_XMMdq=5739, - XED_IFORM_VPROTQ_XMMdq_XMMdq_IMMb=5740, - XED_IFORM_VPROTQ_XMMdq_XMMdq_MEMdq=5741, - XED_IFORM_VPROTQ_XMMdq_XMMdq_XMMdq=5742, - XED_IFORM_VPROTW_XMMdq_MEMdq_IMMb=5743, - XED_IFORM_VPROTW_XMMdq_MEMdq_XMMdq=5744, - XED_IFORM_VPROTW_XMMdq_XMMdq_IMMb=5745, - XED_IFORM_VPROTW_XMMdq_XMMdq_MEMdq=5746, - XED_IFORM_VPROTW_XMMdq_XMMdq_XMMdq=5747, - XED_IFORM_VPSADBW_XMMdq_XMMdq_MEMdq=5748, - XED_IFORM_VPSADBW_XMMdq_XMMdq_XMMdq=5749, - XED_IFORM_VPSADBW_XMMu16_XMMu8_MEMu8_AVX512=5750, - XED_IFORM_VPSADBW_XMMu16_XMMu8_XMMu8_AVX512=5751, - XED_IFORM_VPSADBW_YMMqq_YMMqq_MEMqq=5752, - XED_IFORM_VPSADBW_YMMqq_YMMqq_YMMqq=5753, - XED_IFORM_VPSADBW_YMMu16_YMMu8_MEMu8_AVX512=5754, - XED_IFORM_VPSADBW_YMMu16_YMMu8_YMMu8_AVX512=5755, - XED_IFORM_VPSADBW_ZMMu16_ZMMu8_MEMu8_AVX512=5756, - XED_IFORM_VPSADBW_ZMMu16_ZMMu8_ZMMu8_AVX512=5757, - XED_IFORM_VPSCATTERDD_MEMu32_MASKmskw_XMMu32_AVX512_VL128=5758, - XED_IFORM_VPSCATTERDD_MEMu32_MASKmskw_YMMu32_AVX512_VL256=5759, - XED_IFORM_VPSCATTERDD_MEMu32_MASKmskw_ZMMu32_AVX512_VL512=5760, - XED_IFORM_VPSCATTERDQ_MEMu64_MASKmskw_XMMu64_AVX512_VL128=5761, - XED_IFORM_VPSCATTERDQ_MEMu64_MASKmskw_YMMu64_AVX512_VL256=5762, - XED_IFORM_VPSCATTERDQ_MEMu64_MASKmskw_ZMMu64_AVX512_VL512=5763, - XED_IFORM_VPSCATTERQD_MEMu32_MASKmskw_XMMu32_AVX512_VL128=5764, - XED_IFORM_VPSCATTERQD_MEMu32_MASKmskw_XMMu32_AVX512_VL256=5765, - XED_IFORM_VPSCATTERQD_MEMu32_MASKmskw_YMMu32_AVX512_VL512=5766, - XED_IFORM_VPSCATTERQQ_MEMu64_MASKmskw_XMMu64_AVX512_VL128=5767, - XED_IFORM_VPSCATTERQQ_MEMu64_MASKmskw_YMMu64_AVX512_VL256=5768, - XED_IFORM_VPSCATTERQQ_MEMu64_MASKmskw_ZMMu64_AVX512_VL512=5769, - XED_IFORM_VPSHAB_XMMdq_MEMdq_XMMdq=5770, - XED_IFORM_VPSHAB_XMMdq_XMMdq_MEMdq=5771, - XED_IFORM_VPSHAB_XMMdq_XMMdq_XMMdq=5772, - XED_IFORM_VPSHAD_XMMdq_MEMdq_XMMdq=5773, - XED_IFORM_VPSHAD_XMMdq_XMMdq_MEMdq=5774, - XED_IFORM_VPSHAD_XMMdq_XMMdq_XMMdq=5775, - XED_IFORM_VPSHAQ_XMMdq_MEMdq_XMMdq=5776, - XED_IFORM_VPSHAQ_XMMdq_XMMdq_MEMdq=5777, - XED_IFORM_VPSHAQ_XMMdq_XMMdq_XMMdq=5778, - XED_IFORM_VPSHAW_XMMdq_MEMdq_XMMdq=5779, - XED_IFORM_VPSHAW_XMMdq_XMMdq_MEMdq=5780, - XED_IFORM_VPSHAW_XMMdq_XMMdq_XMMdq=5781, - XED_IFORM_VPSHLB_XMMdq_MEMdq_XMMdq=5782, - XED_IFORM_VPSHLB_XMMdq_XMMdq_MEMdq=5783, - XED_IFORM_VPSHLB_XMMdq_XMMdq_XMMdq=5784, - XED_IFORM_VPSHLD_XMMdq_MEMdq_XMMdq=5785, - XED_IFORM_VPSHLD_XMMdq_XMMdq_MEMdq=5786, - XED_IFORM_VPSHLD_XMMdq_XMMdq_XMMdq=5787, - XED_IFORM_VPSHLDD_XMMu32_MASKmskw_XMMu32_MEMu32_IMM8_AVX512=5788, - XED_IFORM_VPSHLDD_XMMu32_MASKmskw_XMMu32_XMMu32_IMM8_AVX512=5789, - XED_IFORM_VPSHLDD_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=5790, - XED_IFORM_VPSHLDD_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512=5791, - XED_IFORM_VPSHLDD_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=5792, - XED_IFORM_VPSHLDD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512=5793, - XED_IFORM_VPSHLDQ_XMMu64_MASKmskw_XMMu64_MEMu64_IMM8_AVX512=5794, - XED_IFORM_VPSHLDQ_XMMu64_MASKmskw_XMMu64_XMMu64_IMM8_AVX512=5795, - XED_IFORM_VPSHLDQ_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=5796, - XED_IFORM_VPSHLDQ_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512=5797, - XED_IFORM_VPSHLDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=5798, - XED_IFORM_VPSHLDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512=5799, - XED_IFORM_VPSHLDVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5800, - XED_IFORM_VPSHLDVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5801, - XED_IFORM_VPSHLDVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5802, - XED_IFORM_VPSHLDVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5803, - XED_IFORM_VPSHLDVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5804, - XED_IFORM_VPSHLDVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5805, - XED_IFORM_VPSHLDVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5806, - XED_IFORM_VPSHLDVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5807, - XED_IFORM_VPSHLDVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5808, - XED_IFORM_VPSHLDVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5809, - XED_IFORM_VPSHLDVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5810, - XED_IFORM_VPSHLDVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5811, - XED_IFORM_VPSHLDVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5812, - XED_IFORM_VPSHLDVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5813, - XED_IFORM_VPSHLDVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5814, - XED_IFORM_VPSHLDVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5815, - XED_IFORM_VPSHLDVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5816, - XED_IFORM_VPSHLDVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5817, - XED_IFORM_VPSHLDW_XMMu16_MASKmskw_XMMu16_MEMu16_IMM8_AVX512=5818, - XED_IFORM_VPSHLDW_XMMu16_MASKmskw_XMMu16_XMMu16_IMM8_AVX512=5819, - XED_IFORM_VPSHLDW_YMMu16_MASKmskw_YMMu16_MEMu16_IMM8_AVX512=5820, - XED_IFORM_VPSHLDW_YMMu16_MASKmskw_YMMu16_YMMu16_IMM8_AVX512=5821, - XED_IFORM_VPSHLDW_ZMMu16_MASKmskw_ZMMu16_MEMu16_IMM8_AVX512=5822, - XED_IFORM_VPSHLDW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_IMM8_AVX512=5823, - XED_IFORM_VPSHLQ_XMMdq_MEMdq_XMMdq=5824, - XED_IFORM_VPSHLQ_XMMdq_XMMdq_MEMdq=5825, - XED_IFORM_VPSHLQ_XMMdq_XMMdq_XMMdq=5826, - XED_IFORM_VPSHLW_XMMdq_MEMdq_XMMdq=5827, - XED_IFORM_VPSHLW_XMMdq_XMMdq_MEMdq=5828, - XED_IFORM_VPSHLW_XMMdq_XMMdq_XMMdq=5829, - XED_IFORM_VPSHRDD_XMMu32_MASKmskw_XMMu32_MEMu32_IMM8_AVX512=5830, - XED_IFORM_VPSHRDD_XMMu32_MASKmskw_XMMu32_XMMu32_IMM8_AVX512=5831, - XED_IFORM_VPSHRDD_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=5832, - XED_IFORM_VPSHRDD_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512=5833, - XED_IFORM_VPSHRDD_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=5834, - XED_IFORM_VPSHRDD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512=5835, - XED_IFORM_VPSHRDQ_XMMu64_MASKmskw_XMMu64_MEMu64_IMM8_AVX512=5836, - XED_IFORM_VPSHRDQ_XMMu64_MASKmskw_XMMu64_XMMu64_IMM8_AVX512=5837, - XED_IFORM_VPSHRDQ_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=5838, - XED_IFORM_VPSHRDQ_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512=5839, - XED_IFORM_VPSHRDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=5840, - XED_IFORM_VPSHRDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512=5841, - XED_IFORM_VPSHRDVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5842, - XED_IFORM_VPSHRDVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5843, - XED_IFORM_VPSHRDVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5844, - XED_IFORM_VPSHRDVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5845, - XED_IFORM_VPSHRDVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5846, - XED_IFORM_VPSHRDVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5847, - XED_IFORM_VPSHRDVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5848, - XED_IFORM_VPSHRDVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5849, - XED_IFORM_VPSHRDVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5850, - XED_IFORM_VPSHRDVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5851, - XED_IFORM_VPSHRDVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5852, - XED_IFORM_VPSHRDVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5853, - XED_IFORM_VPSHRDVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5854, - XED_IFORM_VPSHRDVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5855, - XED_IFORM_VPSHRDVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5856, - XED_IFORM_VPSHRDVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5857, - XED_IFORM_VPSHRDVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5858, - XED_IFORM_VPSHRDVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5859, - XED_IFORM_VPSHRDW_XMMu16_MASKmskw_XMMu16_MEMu16_IMM8_AVX512=5860, - XED_IFORM_VPSHRDW_XMMu16_MASKmskw_XMMu16_XMMu16_IMM8_AVX512=5861, - XED_IFORM_VPSHRDW_YMMu16_MASKmskw_YMMu16_MEMu16_IMM8_AVX512=5862, - XED_IFORM_VPSHRDW_YMMu16_MASKmskw_YMMu16_YMMu16_IMM8_AVX512=5863, - XED_IFORM_VPSHRDW_ZMMu16_MASKmskw_ZMMu16_MEMu16_IMM8_AVX512=5864, - XED_IFORM_VPSHRDW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_IMM8_AVX512=5865, - XED_IFORM_VPSHUFB_XMMdq_XMMdq_MEMdq=5866, - XED_IFORM_VPSHUFB_XMMdq_XMMdq_XMMdq=5867, - XED_IFORM_VPSHUFB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=5868, - XED_IFORM_VPSHUFB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=5869, - XED_IFORM_VPSHUFB_YMMqq_YMMqq_MEMqq=5870, - XED_IFORM_VPSHUFB_YMMqq_YMMqq_YMMqq=5871, - XED_IFORM_VPSHUFB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=5872, - XED_IFORM_VPSHUFB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=5873, - XED_IFORM_VPSHUFB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=5874, - XED_IFORM_VPSHUFB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=5875, - XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_XMMu64_MEMu8_AVX512=5876, - XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_XMMu64_XMMu8_AVX512=5877, - XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_YMMu64_MEMu8_AVX512=5878, - XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_YMMu64_YMMu8_AVX512=5879, - XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_ZMMu64_MEMu8_AVX512=5880, - XED_IFORM_VPSHUFBITQMB_MASKmskw_MASKmskw_ZMMu64_ZMMu8_AVX512=5881, - XED_IFORM_VPSHUFD_XMMdq_MEMdq_IMMb=5882, - XED_IFORM_VPSHUFD_XMMdq_XMMdq_IMMb=5883, - XED_IFORM_VPSHUFD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=5884, - XED_IFORM_VPSHUFD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=5885, - XED_IFORM_VPSHUFD_YMMqq_MEMqq_IMMb=5886, - XED_IFORM_VPSHUFD_YMMqq_YMMqq_IMMb=5887, - XED_IFORM_VPSHUFD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=5888, - XED_IFORM_VPSHUFD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=5889, - XED_IFORM_VPSHUFD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=5890, - XED_IFORM_VPSHUFD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=5891, - XED_IFORM_VPSHUFHW_XMMdq_MEMdq_IMMb=5892, - XED_IFORM_VPSHUFHW_XMMdq_XMMdq_IMMb=5893, - XED_IFORM_VPSHUFHW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512=5894, - XED_IFORM_VPSHUFHW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512=5895, - XED_IFORM_VPSHUFHW_YMMqq_MEMqq_IMMb=5896, - XED_IFORM_VPSHUFHW_YMMqq_YMMqq_IMMb=5897, - XED_IFORM_VPSHUFHW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512=5898, - XED_IFORM_VPSHUFHW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512=5899, - XED_IFORM_VPSHUFHW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512=5900, - XED_IFORM_VPSHUFHW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512=5901, - XED_IFORM_VPSHUFLW_XMMdq_MEMdq_IMMb=5902, - XED_IFORM_VPSHUFLW_XMMdq_XMMdq_IMMb=5903, - XED_IFORM_VPSHUFLW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512=5904, - XED_IFORM_VPSHUFLW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512=5905, - XED_IFORM_VPSHUFLW_YMMqq_MEMqq_IMMb=5906, - XED_IFORM_VPSHUFLW_YMMqq_YMMqq_IMMb=5907, - XED_IFORM_VPSHUFLW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512=5908, - XED_IFORM_VPSHUFLW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512=5909, - XED_IFORM_VPSHUFLW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512=5910, - XED_IFORM_VPSHUFLW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512=5911, - XED_IFORM_VPSIGNB_XMMdq_XMMdq_MEMdq=5912, - XED_IFORM_VPSIGNB_XMMdq_XMMdq_XMMdq=5913, - XED_IFORM_VPSIGNB_YMMqq_YMMqq_MEMqq=5914, - XED_IFORM_VPSIGNB_YMMqq_YMMqq_YMMqq=5915, - XED_IFORM_VPSIGND_XMMdq_XMMdq_MEMdq=5916, - XED_IFORM_VPSIGND_XMMdq_XMMdq_XMMdq=5917, - XED_IFORM_VPSIGND_YMMqq_YMMqq_MEMqq=5918, - XED_IFORM_VPSIGND_YMMqq_YMMqq_YMMqq=5919, - XED_IFORM_VPSIGNW_XMMdq_XMMdq_MEMdq=5920, - XED_IFORM_VPSIGNW_XMMdq_XMMdq_XMMdq=5921, - XED_IFORM_VPSIGNW_YMMqq_YMMqq_MEMqq=5922, - XED_IFORM_VPSIGNW_YMMqq_YMMqq_YMMqq=5923, - XED_IFORM_VPSLLD_XMMdq_XMMdq_IMMb=5924, - XED_IFORM_VPSLLD_XMMdq_XMMdq_MEMdq=5925, - XED_IFORM_VPSLLD_XMMdq_XMMdq_XMMdq=5926, - XED_IFORM_VPSLLD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=5927, - XED_IFORM_VPSLLD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=5928, - XED_IFORM_VPSLLD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5929, - XED_IFORM_VPSLLD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5930, - XED_IFORM_VPSLLD_YMMqq_YMMqq_IMMb=5931, - XED_IFORM_VPSLLD_YMMqq_YMMqq_MEMdq=5932, - XED_IFORM_VPSLLD_YMMqq_YMMqq_XMMq=5933, - XED_IFORM_VPSLLD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=5934, - XED_IFORM_VPSLLD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=5935, - XED_IFORM_VPSLLD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5936, - XED_IFORM_VPSLLD_YMMu32_MASKmskw_YMMu32_XMMu32_AVX512=5937, - XED_IFORM_VPSLLD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=5938, - XED_IFORM_VPSLLD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=5939, - XED_IFORM_VPSLLD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5940, - XED_IFORM_VPSLLD_ZMMu32_MASKmskw_ZMMu32_XMMu32_AVX512=5941, - XED_IFORM_VPSLLDQ_XMMdq_XMMdq_IMMb=5942, - XED_IFORM_VPSLLDQ_XMMu8_MEMu8_IMM8_AVX512=5943, - XED_IFORM_VPSLLDQ_XMMu8_XMMu8_IMM8_AVX512=5944, - XED_IFORM_VPSLLDQ_YMMqq_YMMqq_IMMb=5945, - XED_IFORM_VPSLLDQ_YMMu8_MEMu8_IMM8_AVX512=5946, - XED_IFORM_VPSLLDQ_YMMu8_YMMu8_IMM8_AVX512=5947, - XED_IFORM_VPSLLDQ_ZMMu8_MEMu8_IMM8_AVX512=5948, - XED_IFORM_VPSLLDQ_ZMMu8_ZMMu8_IMM8_AVX512=5949, - XED_IFORM_VPSLLQ_XMMdq_XMMdq_IMMb=5950, - XED_IFORM_VPSLLQ_XMMdq_XMMdq_MEMdq=5951, - XED_IFORM_VPSLLQ_XMMdq_XMMdq_XMMdq=5952, - XED_IFORM_VPSLLQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512=5953, - XED_IFORM_VPSLLQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512=5954, - XED_IFORM_VPSLLQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5955, - XED_IFORM_VPSLLQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5956, - XED_IFORM_VPSLLQ_YMMqq_YMMqq_IMMb=5957, - XED_IFORM_VPSLLQ_YMMqq_YMMqq_MEMdq=5958, - XED_IFORM_VPSLLQ_YMMqq_YMMqq_XMMq=5959, - XED_IFORM_VPSLLQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=5960, - XED_IFORM_VPSLLQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=5961, - XED_IFORM_VPSLLQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5962, - XED_IFORM_VPSLLQ_YMMu64_MASKmskw_YMMu64_XMMu64_AVX512=5963, - XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=5964, - XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=5965, - XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5966, - XED_IFORM_VPSLLQ_ZMMu64_MASKmskw_ZMMu64_XMMu64_AVX512=5967, - XED_IFORM_VPSLLVD_XMMdq_XMMdq_MEMdq=5968, - XED_IFORM_VPSLLVD_XMMdq_XMMdq_XMMdq=5969, - XED_IFORM_VPSLLVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=5970, - XED_IFORM_VPSLLVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=5971, - XED_IFORM_VPSLLVD_YMMqq_YMMqq_MEMqq=5972, - XED_IFORM_VPSLLVD_YMMqq_YMMqq_YMMqq=5973, - XED_IFORM_VPSLLVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=5974, - XED_IFORM_VPSLLVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=5975, - XED_IFORM_VPSLLVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=5976, - XED_IFORM_VPSLLVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=5977, - XED_IFORM_VPSLLVQ_XMMdq_XMMdq_MEMdq=5978, - XED_IFORM_VPSLLVQ_XMMdq_XMMdq_XMMdq=5979, - XED_IFORM_VPSLLVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=5980, - XED_IFORM_VPSLLVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=5981, - XED_IFORM_VPSLLVQ_YMMqq_YMMqq_MEMqq=5982, - XED_IFORM_VPSLLVQ_YMMqq_YMMqq_YMMqq=5983, - XED_IFORM_VPSLLVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=5984, - XED_IFORM_VPSLLVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=5985, - XED_IFORM_VPSLLVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=5986, - XED_IFORM_VPSLLVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=5987, - XED_IFORM_VPSLLVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5988, - XED_IFORM_VPSLLVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=5989, - XED_IFORM_VPSLLVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=5990, - XED_IFORM_VPSLLVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=5991, - XED_IFORM_VPSLLVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=5992, - XED_IFORM_VPSLLVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=5993, - XED_IFORM_VPSLLW_XMMdq_XMMdq_IMMb=5994, - XED_IFORM_VPSLLW_XMMdq_XMMdq_MEMdq=5995, - XED_IFORM_VPSLLW_XMMdq_XMMdq_XMMdq=5996, - XED_IFORM_VPSLLW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512=5997, - XED_IFORM_VPSLLW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512=5998, - XED_IFORM_VPSLLW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=5999, - XED_IFORM_VPSLLW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=6000, - XED_IFORM_VPSLLW_YMMqq_YMMqq_IMMb=6001, - XED_IFORM_VPSLLW_YMMqq_YMMqq_MEMdq=6002, - XED_IFORM_VPSLLW_YMMqq_YMMqq_XMMq=6003, - XED_IFORM_VPSLLW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512=6004, - XED_IFORM_VPSLLW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512=6005, - XED_IFORM_VPSLLW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=6006, - XED_IFORM_VPSLLW_YMMu16_MASKmskw_YMMu16_XMMu16_AVX512=6007, - XED_IFORM_VPSLLW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512=6008, - XED_IFORM_VPSLLW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512=6009, - XED_IFORM_VPSLLW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=6010, - XED_IFORM_VPSLLW_ZMMu16_MASKmskw_ZMMu16_XMMu16_AVX512=6011, - XED_IFORM_VPSRAD_XMMdq_XMMdq_IMMb=6012, - XED_IFORM_VPSRAD_XMMdq_XMMdq_MEMdq=6013, - XED_IFORM_VPSRAD_XMMdq_XMMdq_XMMdq=6014, - XED_IFORM_VPSRAD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=6015, - XED_IFORM_VPSRAD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=6016, - XED_IFORM_VPSRAD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=6017, - XED_IFORM_VPSRAD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=6018, - XED_IFORM_VPSRAD_YMMqq_YMMqq_IMMb=6019, - XED_IFORM_VPSRAD_YMMqq_YMMqq_MEMdq=6020, - XED_IFORM_VPSRAD_YMMqq_YMMqq_XMMq=6021, - XED_IFORM_VPSRAD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=6022, - XED_IFORM_VPSRAD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=6023, - XED_IFORM_VPSRAD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=6024, - XED_IFORM_VPSRAD_YMMu32_MASKmskw_YMMu32_XMMu32_AVX512=6025, - XED_IFORM_VPSRAD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=6026, - XED_IFORM_VPSRAD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=6027, - XED_IFORM_VPSRAD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=6028, - XED_IFORM_VPSRAD_ZMMu32_MASKmskw_ZMMu32_XMMu32_AVX512=6029, - XED_IFORM_VPSRAQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512=6030, - XED_IFORM_VPSRAQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512=6031, - XED_IFORM_VPSRAQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=6032, - XED_IFORM_VPSRAQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=6033, - XED_IFORM_VPSRAQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=6034, - XED_IFORM_VPSRAQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=6035, - XED_IFORM_VPSRAQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=6036, - XED_IFORM_VPSRAQ_YMMu64_MASKmskw_YMMu64_XMMu64_AVX512=6037, - XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=6038, - XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=6039, - XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=6040, - XED_IFORM_VPSRAQ_ZMMu64_MASKmskw_ZMMu64_XMMu64_AVX512=6041, - XED_IFORM_VPSRAVD_XMMdq_XMMdq_MEMdq=6042, - XED_IFORM_VPSRAVD_XMMdq_XMMdq_XMMdq=6043, - XED_IFORM_VPSRAVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=6044, - XED_IFORM_VPSRAVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=6045, - XED_IFORM_VPSRAVD_YMMqq_YMMqq_MEMqq=6046, - XED_IFORM_VPSRAVD_YMMqq_YMMqq_YMMqq=6047, - XED_IFORM_VPSRAVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=6048, - XED_IFORM_VPSRAVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=6049, - XED_IFORM_VPSRAVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=6050, - XED_IFORM_VPSRAVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=6051, - XED_IFORM_VPSRAVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=6052, - XED_IFORM_VPSRAVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=6053, - XED_IFORM_VPSRAVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=6054, - XED_IFORM_VPSRAVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=6055, - XED_IFORM_VPSRAVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=6056, - XED_IFORM_VPSRAVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=6057, - XED_IFORM_VPSRAVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=6058, - XED_IFORM_VPSRAVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=6059, - XED_IFORM_VPSRAVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=6060, - XED_IFORM_VPSRAVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=6061, - XED_IFORM_VPSRAVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=6062, - XED_IFORM_VPSRAVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=6063, - XED_IFORM_VPSRAW_XMMdq_XMMdq_IMMb=6064, - XED_IFORM_VPSRAW_XMMdq_XMMdq_MEMdq=6065, - XED_IFORM_VPSRAW_XMMdq_XMMdq_XMMdq=6066, - XED_IFORM_VPSRAW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512=6067, - XED_IFORM_VPSRAW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512=6068, - XED_IFORM_VPSRAW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=6069, - XED_IFORM_VPSRAW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=6070, - XED_IFORM_VPSRAW_YMMqq_YMMqq_IMMb=6071, - XED_IFORM_VPSRAW_YMMqq_YMMqq_MEMdq=6072, - XED_IFORM_VPSRAW_YMMqq_YMMqq_XMMq=6073, - XED_IFORM_VPSRAW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512=6074, - XED_IFORM_VPSRAW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512=6075, - XED_IFORM_VPSRAW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=6076, - XED_IFORM_VPSRAW_YMMu16_MASKmskw_YMMu16_XMMu16_AVX512=6077, - XED_IFORM_VPSRAW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512=6078, - XED_IFORM_VPSRAW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512=6079, - XED_IFORM_VPSRAW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=6080, - XED_IFORM_VPSRAW_ZMMu16_MASKmskw_ZMMu16_XMMu16_AVX512=6081, - XED_IFORM_VPSRLD_XMMdq_XMMdq_IMMb=6082, - XED_IFORM_VPSRLD_XMMdq_XMMdq_MEMdq=6083, - XED_IFORM_VPSRLD_XMMdq_XMMdq_XMMdq=6084, - XED_IFORM_VPSRLD_XMMu32_MASKmskw_MEMu32_IMM8_AVX512=6085, - XED_IFORM_VPSRLD_XMMu32_MASKmskw_XMMu32_IMM8_AVX512=6086, - XED_IFORM_VPSRLD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=6087, - XED_IFORM_VPSRLD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=6088, - XED_IFORM_VPSRLD_YMMqq_YMMqq_IMMb=6089, - XED_IFORM_VPSRLD_YMMqq_YMMqq_MEMdq=6090, - XED_IFORM_VPSRLD_YMMqq_YMMqq_XMMq=6091, - XED_IFORM_VPSRLD_YMMu32_MASKmskw_MEMu32_IMM8_AVX512=6092, - XED_IFORM_VPSRLD_YMMu32_MASKmskw_YMMu32_IMM8_AVX512=6093, - XED_IFORM_VPSRLD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=6094, - XED_IFORM_VPSRLD_YMMu32_MASKmskw_YMMu32_XMMu32_AVX512=6095, - XED_IFORM_VPSRLD_ZMMu32_MASKmskw_MEMu32_IMM8_AVX512=6096, - XED_IFORM_VPSRLD_ZMMu32_MASKmskw_ZMMu32_IMM8_AVX512=6097, - XED_IFORM_VPSRLD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=6098, - XED_IFORM_VPSRLD_ZMMu32_MASKmskw_ZMMu32_XMMu32_AVX512=6099, - XED_IFORM_VPSRLDQ_XMMdq_XMMdq_IMMb=6100, - XED_IFORM_VPSRLDQ_XMMu8_MEMu8_IMM8_AVX512=6101, - XED_IFORM_VPSRLDQ_XMMu8_XMMu8_IMM8_AVX512=6102, - XED_IFORM_VPSRLDQ_YMMqq_YMMqq_IMMb=6103, - XED_IFORM_VPSRLDQ_YMMu8_MEMu8_IMM8_AVX512=6104, - XED_IFORM_VPSRLDQ_YMMu8_YMMu8_IMM8_AVX512=6105, - XED_IFORM_VPSRLDQ_ZMMu8_MEMu8_IMM8_AVX512=6106, - XED_IFORM_VPSRLDQ_ZMMu8_ZMMu8_IMM8_AVX512=6107, - XED_IFORM_VPSRLQ_XMMdq_XMMdq_IMMb=6108, - XED_IFORM_VPSRLQ_XMMdq_XMMdq_MEMdq=6109, - XED_IFORM_VPSRLQ_XMMdq_XMMdq_XMMdq=6110, - XED_IFORM_VPSRLQ_XMMu64_MASKmskw_MEMu64_IMM8_AVX512=6111, - XED_IFORM_VPSRLQ_XMMu64_MASKmskw_XMMu64_IMM8_AVX512=6112, - XED_IFORM_VPSRLQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=6113, - XED_IFORM_VPSRLQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=6114, - XED_IFORM_VPSRLQ_YMMqq_YMMqq_IMMb=6115, - XED_IFORM_VPSRLQ_YMMqq_YMMqq_MEMdq=6116, - XED_IFORM_VPSRLQ_YMMqq_YMMqq_XMMq=6117, - XED_IFORM_VPSRLQ_YMMu64_MASKmskw_MEMu64_IMM8_AVX512=6118, - XED_IFORM_VPSRLQ_YMMu64_MASKmskw_YMMu64_IMM8_AVX512=6119, - XED_IFORM_VPSRLQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=6120, - XED_IFORM_VPSRLQ_YMMu64_MASKmskw_YMMu64_XMMu64_AVX512=6121, - XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_MEMu64_IMM8_AVX512=6122, - XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_ZMMu64_IMM8_AVX512=6123, - XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=6124, - XED_IFORM_VPSRLQ_ZMMu64_MASKmskw_ZMMu64_XMMu64_AVX512=6125, - XED_IFORM_VPSRLVD_XMMdq_XMMdq_MEMdq=6126, - XED_IFORM_VPSRLVD_XMMdq_XMMdq_XMMdq=6127, - XED_IFORM_VPSRLVD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=6128, - XED_IFORM_VPSRLVD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=6129, - XED_IFORM_VPSRLVD_YMMqq_YMMqq_MEMqq=6130, - XED_IFORM_VPSRLVD_YMMqq_YMMqq_YMMqq=6131, - XED_IFORM_VPSRLVD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=6132, - XED_IFORM_VPSRLVD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=6133, - XED_IFORM_VPSRLVD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=6134, - XED_IFORM_VPSRLVD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=6135, - XED_IFORM_VPSRLVQ_XMMdq_XMMdq_MEMdq=6136, - XED_IFORM_VPSRLVQ_XMMdq_XMMdq_XMMdq=6137, - XED_IFORM_VPSRLVQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=6138, - XED_IFORM_VPSRLVQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=6139, - XED_IFORM_VPSRLVQ_YMMqq_YMMqq_MEMqq=6140, - XED_IFORM_VPSRLVQ_YMMqq_YMMqq_YMMqq=6141, - XED_IFORM_VPSRLVQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=6142, - XED_IFORM_VPSRLVQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=6143, - XED_IFORM_VPSRLVQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=6144, - XED_IFORM_VPSRLVQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=6145, - XED_IFORM_VPSRLVW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=6146, - XED_IFORM_VPSRLVW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=6147, - XED_IFORM_VPSRLVW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=6148, - XED_IFORM_VPSRLVW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=6149, - XED_IFORM_VPSRLVW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=6150, - XED_IFORM_VPSRLVW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=6151, - XED_IFORM_VPSRLW_XMMdq_XMMdq_IMMb=6152, - XED_IFORM_VPSRLW_XMMdq_XMMdq_MEMdq=6153, - XED_IFORM_VPSRLW_XMMdq_XMMdq_XMMdq=6154, - XED_IFORM_VPSRLW_XMMu16_MASKmskw_MEMu16_IMM8_AVX512=6155, - XED_IFORM_VPSRLW_XMMu16_MASKmskw_XMMu16_IMM8_AVX512=6156, - XED_IFORM_VPSRLW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=6157, - XED_IFORM_VPSRLW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=6158, - XED_IFORM_VPSRLW_YMMqq_YMMqq_IMMb=6159, - XED_IFORM_VPSRLW_YMMqq_YMMqq_MEMdq=6160, - XED_IFORM_VPSRLW_YMMqq_YMMqq_XMMq=6161, - XED_IFORM_VPSRLW_YMMu16_MASKmskw_MEMu16_IMM8_AVX512=6162, - XED_IFORM_VPSRLW_YMMu16_MASKmskw_YMMu16_IMM8_AVX512=6163, - XED_IFORM_VPSRLW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=6164, - XED_IFORM_VPSRLW_YMMu16_MASKmskw_YMMu16_XMMu16_AVX512=6165, - XED_IFORM_VPSRLW_ZMMu16_MASKmskw_MEMu16_IMM8_AVX512=6166, - XED_IFORM_VPSRLW_ZMMu16_MASKmskw_ZMMu16_IMM8_AVX512=6167, - XED_IFORM_VPSRLW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=6168, - XED_IFORM_VPSRLW_ZMMu16_MASKmskw_ZMMu16_XMMu16_AVX512=6169, - XED_IFORM_VPSUBB_XMMdq_XMMdq_MEMdq=6170, - XED_IFORM_VPSUBB_XMMdq_XMMdq_XMMdq=6171, - XED_IFORM_VPSUBB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=6172, - XED_IFORM_VPSUBB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=6173, - XED_IFORM_VPSUBB_YMMqq_YMMqq_MEMqq=6174, - XED_IFORM_VPSUBB_YMMqq_YMMqq_YMMqq=6175, - XED_IFORM_VPSUBB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=6176, - XED_IFORM_VPSUBB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=6177, - XED_IFORM_VPSUBB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=6178, - XED_IFORM_VPSUBB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=6179, - XED_IFORM_VPSUBD_XMMdq_XMMdq_MEMdq=6180, - XED_IFORM_VPSUBD_XMMdq_XMMdq_XMMdq=6181, - XED_IFORM_VPSUBD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=6182, - XED_IFORM_VPSUBD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=6183, - XED_IFORM_VPSUBD_YMMqq_YMMqq_MEMqq=6184, - XED_IFORM_VPSUBD_YMMqq_YMMqq_YMMqq=6185, - XED_IFORM_VPSUBD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=6186, - XED_IFORM_VPSUBD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=6187, - XED_IFORM_VPSUBD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=6188, - XED_IFORM_VPSUBD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=6189, - XED_IFORM_VPSUBQ_XMMdq_XMMdq_MEMdq=6190, - XED_IFORM_VPSUBQ_XMMdq_XMMdq_XMMdq=6191, - XED_IFORM_VPSUBQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=6192, - XED_IFORM_VPSUBQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=6193, - XED_IFORM_VPSUBQ_YMMqq_YMMqq_MEMqq=6194, - XED_IFORM_VPSUBQ_YMMqq_YMMqq_YMMqq=6195, - XED_IFORM_VPSUBQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=6196, - XED_IFORM_VPSUBQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=6197, - XED_IFORM_VPSUBQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=6198, - XED_IFORM_VPSUBQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=6199, - XED_IFORM_VPSUBSB_XMMdq_XMMdq_MEMdq=6200, - XED_IFORM_VPSUBSB_XMMdq_XMMdq_XMMdq=6201, - XED_IFORM_VPSUBSB_XMMi8_MASKmskw_XMMi8_MEMi8_AVX512=6202, - XED_IFORM_VPSUBSB_XMMi8_MASKmskw_XMMi8_XMMi8_AVX512=6203, - XED_IFORM_VPSUBSB_YMMi8_MASKmskw_YMMi8_MEMi8_AVX512=6204, - XED_IFORM_VPSUBSB_YMMi8_MASKmskw_YMMi8_YMMi8_AVX512=6205, - XED_IFORM_VPSUBSB_YMMqq_YMMqq_MEMqq=6206, - XED_IFORM_VPSUBSB_YMMqq_YMMqq_YMMqq=6207, - XED_IFORM_VPSUBSB_ZMMi8_MASKmskw_ZMMi8_MEMi8_AVX512=6208, - XED_IFORM_VPSUBSB_ZMMi8_MASKmskw_ZMMi8_ZMMi8_AVX512=6209, - XED_IFORM_VPSUBSW_XMMdq_XMMdq_MEMdq=6210, - XED_IFORM_VPSUBSW_XMMdq_XMMdq_XMMdq=6211, - XED_IFORM_VPSUBSW_XMMi16_MASKmskw_XMMi16_MEMi16_AVX512=6212, - XED_IFORM_VPSUBSW_XMMi16_MASKmskw_XMMi16_XMMi16_AVX512=6213, - XED_IFORM_VPSUBSW_YMMi16_MASKmskw_YMMi16_MEMi16_AVX512=6214, - XED_IFORM_VPSUBSW_YMMi16_MASKmskw_YMMi16_YMMi16_AVX512=6215, - XED_IFORM_VPSUBSW_YMMqq_YMMqq_MEMqq=6216, - XED_IFORM_VPSUBSW_YMMqq_YMMqq_YMMqq=6217, - XED_IFORM_VPSUBSW_ZMMi16_MASKmskw_ZMMi16_MEMi16_AVX512=6218, - XED_IFORM_VPSUBSW_ZMMi16_MASKmskw_ZMMi16_ZMMi16_AVX512=6219, - XED_IFORM_VPSUBUSB_XMMdq_XMMdq_MEMdq=6220, - XED_IFORM_VPSUBUSB_XMMdq_XMMdq_XMMdq=6221, - XED_IFORM_VPSUBUSB_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=6222, - XED_IFORM_VPSUBUSB_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=6223, - XED_IFORM_VPSUBUSB_YMMqq_YMMqq_MEMqq=6224, - XED_IFORM_VPSUBUSB_YMMqq_YMMqq_YMMqq=6225, - XED_IFORM_VPSUBUSB_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=6226, - XED_IFORM_VPSUBUSB_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=6227, - XED_IFORM_VPSUBUSB_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=6228, - XED_IFORM_VPSUBUSB_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=6229, - XED_IFORM_VPSUBUSW_XMMdq_XMMdq_MEMdq=6230, - XED_IFORM_VPSUBUSW_XMMdq_XMMdq_XMMdq=6231, - XED_IFORM_VPSUBUSW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=6232, - XED_IFORM_VPSUBUSW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=6233, - XED_IFORM_VPSUBUSW_YMMqq_YMMqq_MEMqq=6234, - XED_IFORM_VPSUBUSW_YMMqq_YMMqq_YMMqq=6235, - XED_IFORM_VPSUBUSW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=6236, - XED_IFORM_VPSUBUSW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=6237, - XED_IFORM_VPSUBUSW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=6238, - XED_IFORM_VPSUBUSW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=6239, - XED_IFORM_VPSUBW_XMMdq_XMMdq_MEMdq=6240, - XED_IFORM_VPSUBW_XMMdq_XMMdq_XMMdq=6241, - XED_IFORM_VPSUBW_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=6242, - XED_IFORM_VPSUBW_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=6243, - XED_IFORM_VPSUBW_YMMqq_YMMqq_MEMqq=6244, - XED_IFORM_VPSUBW_YMMqq_YMMqq_YMMqq=6245, - XED_IFORM_VPSUBW_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=6246, - XED_IFORM_VPSUBW_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=6247, - XED_IFORM_VPSUBW_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=6248, - XED_IFORM_VPSUBW_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=6249, - XED_IFORM_VPTERNLOGD_XMMu32_MASKmskw_XMMu32_MEMu32_IMM8_AVX512=6250, - XED_IFORM_VPTERNLOGD_XMMu32_MASKmskw_XMMu32_XMMu32_IMM8_AVX512=6251, - XED_IFORM_VPTERNLOGD_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=6252, - XED_IFORM_VPTERNLOGD_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512=6253, - XED_IFORM_VPTERNLOGD_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=6254, - XED_IFORM_VPTERNLOGD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512=6255, - XED_IFORM_VPTERNLOGQ_XMMu64_MASKmskw_XMMu64_MEMu64_IMM8_AVX512=6256, - XED_IFORM_VPTERNLOGQ_XMMu64_MASKmskw_XMMu64_XMMu64_IMM8_AVX512=6257, - XED_IFORM_VPTERNLOGQ_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=6258, - XED_IFORM_VPTERNLOGQ_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512=6259, - XED_IFORM_VPTERNLOGQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=6260, - XED_IFORM_VPTERNLOGQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512=6261, - XED_IFORM_VPTEST_XMMdq_MEMdq=6262, - XED_IFORM_VPTEST_XMMdq_XMMdq=6263, - XED_IFORM_VPTEST_YMMqq_MEMqq=6264, - XED_IFORM_VPTEST_YMMqq_YMMqq=6265, - XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512=6266, - XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512=6267, - XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512=6268, - XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512=6269, - XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512=6270, - XED_IFORM_VPTESTMB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512=6271, - XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_XMMu32_MEMu32_AVX512=6272, - XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_XMMu32_XMMu32_AVX512=6273, - XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_YMMu32_MEMu32_AVX512=6274, - XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_YMMu32_YMMu32_AVX512=6275, - XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_ZMMu32_MEMu32_AVX512=6276, - XED_IFORM_VPTESTMD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_AVX512=6277, - XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_XMMu64_MEMu64_AVX512=6278, - XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_XMMu64_XMMu64_AVX512=6279, - XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_YMMu64_MEMu64_AVX512=6280, - XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_YMMu64_YMMu64_AVX512=6281, - XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_AVX512=6282, - XED_IFORM_VPTESTMQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_AVX512=6283, - XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512=6284, - XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512=6285, - XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512=6286, - XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512=6287, - XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512=6288, - XED_IFORM_VPTESTMW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512=6289, - XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_XMMu8_MEMu8_AVX512=6290, - XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_XMMu8_XMMu8_AVX512=6291, - XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_YMMu8_MEMu8_AVX512=6292, - XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_YMMu8_YMMu8_AVX512=6293, - XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_ZMMu8_MEMu8_AVX512=6294, - XED_IFORM_VPTESTNMB_MASKmskw_MASKmskw_ZMMu8_ZMMu8_AVX512=6295, - XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_XMMu32_MEMu32_AVX512=6296, - XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_XMMu32_XMMu32_AVX512=6297, - XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_YMMu32_MEMu32_AVX512=6298, - XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_YMMu32_YMMu32_AVX512=6299, - XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_ZMMu32_MEMu32_AVX512=6300, - XED_IFORM_VPTESTNMD_MASKmskw_MASKmskw_ZMMu32_ZMMu32_AVX512=6301, - XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_XMMu64_MEMu64_AVX512=6302, - XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_XMMu64_XMMu64_AVX512=6303, - XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_YMMu64_MEMu64_AVX512=6304, - XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_YMMu64_YMMu64_AVX512=6305, - XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_ZMMu64_MEMu64_AVX512=6306, - XED_IFORM_VPTESTNMQ_MASKmskw_MASKmskw_ZMMu64_ZMMu64_AVX512=6307, - XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_XMMu16_MEMu16_AVX512=6308, - XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_XMMu16_XMMu16_AVX512=6309, - XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_YMMu16_MEMu16_AVX512=6310, - XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_YMMu16_YMMu16_AVX512=6311, - XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_ZMMu16_MEMu16_AVX512=6312, - XED_IFORM_VPTESTNMW_MASKmskw_MASKmskw_ZMMu16_ZMMu16_AVX512=6313, - XED_IFORM_VPUNPCKHBW_XMMdq_XMMdq_MEMdq=6314, - XED_IFORM_VPUNPCKHBW_XMMdq_XMMdq_XMMdq=6315, - XED_IFORM_VPUNPCKHBW_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=6316, - XED_IFORM_VPUNPCKHBW_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=6317, - XED_IFORM_VPUNPCKHBW_YMMqq_YMMqq_MEMqq=6318, - XED_IFORM_VPUNPCKHBW_YMMqq_YMMqq_YMMqq=6319, - XED_IFORM_VPUNPCKHBW_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=6320, - XED_IFORM_VPUNPCKHBW_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=6321, - XED_IFORM_VPUNPCKHBW_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=6322, - XED_IFORM_VPUNPCKHBW_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=6323, - XED_IFORM_VPUNPCKHDQ_XMMdq_XMMdq_MEMdq=6324, - XED_IFORM_VPUNPCKHDQ_XMMdq_XMMdq_XMMdq=6325, - XED_IFORM_VPUNPCKHDQ_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=6326, - XED_IFORM_VPUNPCKHDQ_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=6327, - XED_IFORM_VPUNPCKHDQ_YMMqq_YMMqq_MEMqq=6328, - XED_IFORM_VPUNPCKHDQ_YMMqq_YMMqq_YMMqq=6329, - XED_IFORM_VPUNPCKHDQ_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=6330, - XED_IFORM_VPUNPCKHDQ_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=6331, - XED_IFORM_VPUNPCKHDQ_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=6332, - XED_IFORM_VPUNPCKHDQ_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=6333, - XED_IFORM_VPUNPCKHQDQ_XMMdq_XMMdq_MEMdq=6334, - XED_IFORM_VPUNPCKHQDQ_XMMdq_XMMdq_XMMdq=6335, - XED_IFORM_VPUNPCKHQDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=6336, - XED_IFORM_VPUNPCKHQDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=6337, - XED_IFORM_VPUNPCKHQDQ_YMMqq_YMMqq_MEMqq=6338, - XED_IFORM_VPUNPCKHQDQ_YMMqq_YMMqq_YMMqq=6339, - XED_IFORM_VPUNPCKHQDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=6340, - XED_IFORM_VPUNPCKHQDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=6341, - XED_IFORM_VPUNPCKHQDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=6342, - XED_IFORM_VPUNPCKHQDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=6343, - XED_IFORM_VPUNPCKHWD_XMMdq_XMMdq_MEMdq=6344, - XED_IFORM_VPUNPCKHWD_XMMdq_XMMdq_XMMdq=6345, - XED_IFORM_VPUNPCKHWD_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=6346, - XED_IFORM_VPUNPCKHWD_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=6347, - XED_IFORM_VPUNPCKHWD_YMMqq_YMMqq_MEMqq=6348, - XED_IFORM_VPUNPCKHWD_YMMqq_YMMqq_YMMqq=6349, - XED_IFORM_VPUNPCKHWD_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=6350, - XED_IFORM_VPUNPCKHWD_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=6351, - XED_IFORM_VPUNPCKHWD_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=6352, - XED_IFORM_VPUNPCKHWD_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=6353, - XED_IFORM_VPUNPCKLBW_XMMdq_XMMdq_MEMdq=6354, - XED_IFORM_VPUNPCKLBW_XMMdq_XMMdq_XMMdq=6355, - XED_IFORM_VPUNPCKLBW_XMMu8_MASKmskw_XMMu8_MEMu8_AVX512=6356, - XED_IFORM_VPUNPCKLBW_XMMu8_MASKmskw_XMMu8_XMMu8_AVX512=6357, - XED_IFORM_VPUNPCKLBW_YMMqq_YMMqq_MEMqq=6358, - XED_IFORM_VPUNPCKLBW_YMMqq_YMMqq_YMMqq=6359, - XED_IFORM_VPUNPCKLBW_YMMu8_MASKmskw_YMMu8_MEMu8_AVX512=6360, - XED_IFORM_VPUNPCKLBW_YMMu8_MASKmskw_YMMu8_YMMu8_AVX512=6361, - XED_IFORM_VPUNPCKLBW_ZMMu8_MASKmskw_ZMMu8_MEMu8_AVX512=6362, - XED_IFORM_VPUNPCKLBW_ZMMu8_MASKmskw_ZMMu8_ZMMu8_AVX512=6363, - XED_IFORM_VPUNPCKLDQ_XMMdq_XMMdq_MEMdq=6364, - XED_IFORM_VPUNPCKLDQ_XMMdq_XMMdq_XMMdq=6365, - XED_IFORM_VPUNPCKLDQ_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=6366, - XED_IFORM_VPUNPCKLDQ_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=6367, - XED_IFORM_VPUNPCKLDQ_YMMqq_YMMqq_MEMqq=6368, - XED_IFORM_VPUNPCKLDQ_YMMqq_YMMqq_YMMqq=6369, - XED_IFORM_VPUNPCKLDQ_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=6370, - XED_IFORM_VPUNPCKLDQ_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=6371, - XED_IFORM_VPUNPCKLDQ_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=6372, - XED_IFORM_VPUNPCKLDQ_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=6373, - XED_IFORM_VPUNPCKLQDQ_XMMdq_XMMdq_MEMdq=6374, - XED_IFORM_VPUNPCKLQDQ_XMMdq_XMMdq_XMMdq=6375, - XED_IFORM_VPUNPCKLQDQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=6376, - XED_IFORM_VPUNPCKLQDQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=6377, - XED_IFORM_VPUNPCKLQDQ_YMMqq_YMMqq_MEMqq=6378, - XED_IFORM_VPUNPCKLQDQ_YMMqq_YMMqq_YMMqq=6379, - XED_IFORM_VPUNPCKLQDQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=6380, - XED_IFORM_VPUNPCKLQDQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=6381, - XED_IFORM_VPUNPCKLQDQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=6382, - XED_IFORM_VPUNPCKLQDQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=6383, - XED_IFORM_VPUNPCKLWD_XMMdq_XMMdq_MEMdq=6384, - XED_IFORM_VPUNPCKLWD_XMMdq_XMMdq_XMMdq=6385, - XED_IFORM_VPUNPCKLWD_XMMu16_MASKmskw_XMMu16_MEMu16_AVX512=6386, - XED_IFORM_VPUNPCKLWD_XMMu16_MASKmskw_XMMu16_XMMu16_AVX512=6387, - XED_IFORM_VPUNPCKLWD_YMMqq_YMMqq_MEMqq=6388, - XED_IFORM_VPUNPCKLWD_YMMqq_YMMqq_YMMqq=6389, - XED_IFORM_VPUNPCKLWD_YMMu16_MASKmskw_YMMu16_MEMu16_AVX512=6390, - XED_IFORM_VPUNPCKLWD_YMMu16_MASKmskw_YMMu16_YMMu16_AVX512=6391, - XED_IFORM_VPUNPCKLWD_ZMMu16_MASKmskw_ZMMu16_MEMu16_AVX512=6392, - XED_IFORM_VPUNPCKLWD_ZMMu16_MASKmskw_ZMMu16_ZMMu16_AVX512=6393, - XED_IFORM_VPXOR_XMMdq_XMMdq_MEMdq=6394, - XED_IFORM_VPXOR_XMMdq_XMMdq_XMMdq=6395, - XED_IFORM_VPXOR_YMMqq_YMMqq_MEMqq=6396, - XED_IFORM_VPXOR_YMMqq_YMMqq_YMMqq=6397, - XED_IFORM_VPXORD_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=6398, - XED_IFORM_VPXORD_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=6399, - XED_IFORM_VPXORD_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=6400, - XED_IFORM_VPXORD_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=6401, - XED_IFORM_VPXORD_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=6402, - XED_IFORM_VPXORD_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=6403, - XED_IFORM_VPXORQ_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=6404, - XED_IFORM_VPXORQ_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=6405, - XED_IFORM_VPXORQ_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=6406, - XED_IFORM_VPXORQ_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=6407, - XED_IFORM_VPXORQ_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=6408, - XED_IFORM_VPXORQ_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=6409, - XED_IFORM_VRANGEPD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=6410, - XED_IFORM_VRANGEPD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=6411, - XED_IFORM_VRANGEPD_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=6412, - XED_IFORM_VRANGEPD_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512=6413, - XED_IFORM_VRANGEPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=6414, - XED_IFORM_VRANGEPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512=6415, - XED_IFORM_VRANGEPS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=6416, - XED_IFORM_VRANGEPS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=6417, - XED_IFORM_VRANGEPS_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=6418, - XED_IFORM_VRANGEPS_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512=6419, - XED_IFORM_VRANGEPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=6420, - XED_IFORM_VRANGEPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512=6421, - XED_IFORM_VRANGESD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=6422, - XED_IFORM_VRANGESD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=6423, - XED_IFORM_VRANGESS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=6424, - XED_IFORM_VRANGESS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=6425, - XED_IFORM_VRCP14PD_XMMf64_MASKmskw_MEMf64_AVX512=6426, - XED_IFORM_VRCP14PD_XMMf64_MASKmskw_XMMf64_AVX512=6427, - XED_IFORM_VRCP14PD_YMMf64_MASKmskw_MEMf64_AVX512=6428, - XED_IFORM_VRCP14PD_YMMf64_MASKmskw_YMMf64_AVX512=6429, - XED_IFORM_VRCP14PD_ZMMf64_MASKmskw_MEMf64_AVX512=6430, - XED_IFORM_VRCP14PD_ZMMf64_MASKmskw_ZMMf64_AVX512=6431, - XED_IFORM_VRCP14PS_XMMf32_MASKmskw_MEMf32_AVX512=6432, - XED_IFORM_VRCP14PS_XMMf32_MASKmskw_XMMf32_AVX512=6433, - XED_IFORM_VRCP14PS_YMMf32_MASKmskw_MEMf32_AVX512=6434, - XED_IFORM_VRCP14PS_YMMf32_MASKmskw_YMMf32_AVX512=6435, - XED_IFORM_VRCP14PS_ZMMf32_MASKmskw_MEMf32_AVX512=6436, - XED_IFORM_VRCP14PS_ZMMf32_MASKmskw_ZMMf32_AVX512=6437, - XED_IFORM_VRCP14SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=6438, - XED_IFORM_VRCP14SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=6439, - XED_IFORM_VRCP14SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=6440, - XED_IFORM_VRCP14SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=6441, - XED_IFORM_VRCP28PD_ZMMf64_MASKmskw_MEMf64_AVX512ER=6442, - XED_IFORM_VRCP28PD_ZMMf64_MASKmskw_ZMMf64_AVX512ER=6443, - XED_IFORM_VRCP28PS_ZMMf32_MASKmskw_MEMf32_AVX512ER=6444, - XED_IFORM_VRCP28PS_ZMMf32_MASKmskw_ZMMf32_AVX512ER=6445, - XED_IFORM_VRCP28SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512ER=6446, - XED_IFORM_VRCP28SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512ER=6447, - XED_IFORM_VRCP28SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512ER=6448, - XED_IFORM_VRCP28SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512ER=6449, - XED_IFORM_VRCPPH_XMMf16_MASKmskw_MEMf16_AVX512=6450, - XED_IFORM_VRCPPH_XMMf16_MASKmskw_XMMf16_AVX512=6451, - XED_IFORM_VRCPPH_YMMf16_MASKmskw_MEMf16_AVX512=6452, - XED_IFORM_VRCPPH_YMMf16_MASKmskw_YMMf16_AVX512=6453, - XED_IFORM_VRCPPH_ZMMf16_MASKmskw_MEMf16_AVX512=6454, - XED_IFORM_VRCPPH_ZMMf16_MASKmskw_ZMMf16_AVX512=6455, - XED_IFORM_VRCPPS_XMMdq_MEMdq=6456, - XED_IFORM_VRCPPS_XMMdq_XMMdq=6457, - XED_IFORM_VRCPPS_YMMqq_MEMqq=6458, - XED_IFORM_VRCPPS_YMMqq_YMMqq=6459, - XED_IFORM_VRCPSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=6460, - XED_IFORM_VRCPSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=6461, - XED_IFORM_VRCPSS_XMMdq_XMMdq_MEMd=6462, - XED_IFORM_VRCPSS_XMMdq_XMMdq_XMMd=6463, - XED_IFORM_VREDUCEPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512=6464, - XED_IFORM_VREDUCEPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512=6465, - XED_IFORM_VREDUCEPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512=6466, - XED_IFORM_VREDUCEPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512=6467, - XED_IFORM_VREDUCEPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512=6468, - XED_IFORM_VREDUCEPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512=6469, - XED_IFORM_VREDUCEPH_XMMf16_MASKmskw_MEMf16_IMM8_AVX512=6470, - XED_IFORM_VREDUCEPH_XMMf16_MASKmskw_XMMf16_IMM8_AVX512=6471, - XED_IFORM_VREDUCEPH_YMMf16_MASKmskw_MEMf16_IMM8_AVX512=6472, - XED_IFORM_VREDUCEPH_YMMf16_MASKmskw_YMMf16_IMM8_AVX512=6473, - XED_IFORM_VREDUCEPH_ZMMf16_MASKmskw_MEMf16_IMM8_AVX512=6474, - XED_IFORM_VREDUCEPH_ZMMf16_MASKmskw_ZMMf16_IMM8_AVX512=6475, - XED_IFORM_VREDUCEPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512=6476, - XED_IFORM_VREDUCEPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512=6477, - XED_IFORM_VREDUCEPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512=6478, - XED_IFORM_VREDUCEPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512=6479, - XED_IFORM_VREDUCEPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512=6480, - XED_IFORM_VREDUCEPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512=6481, - XED_IFORM_VREDUCESD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=6482, - XED_IFORM_VREDUCESD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=6483, - XED_IFORM_VREDUCESH_XMMf16_MASKmskw_XMMf16_MEMf16_IMM8_AVX512=6484, - XED_IFORM_VREDUCESH_XMMf16_MASKmskw_XMMf16_XMMf16_IMM8_AVX512=6485, - XED_IFORM_VREDUCESS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=6486, - XED_IFORM_VREDUCESS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=6487, - XED_IFORM_VRNDSCALEPD_XMMf64_MASKmskw_MEMf64_IMM8_AVX512=6488, - XED_IFORM_VRNDSCALEPD_XMMf64_MASKmskw_XMMf64_IMM8_AVX512=6489, - XED_IFORM_VRNDSCALEPD_YMMf64_MASKmskw_MEMf64_IMM8_AVX512=6490, - XED_IFORM_VRNDSCALEPD_YMMf64_MASKmskw_YMMf64_IMM8_AVX512=6491, - XED_IFORM_VRNDSCALEPD_ZMMf64_MASKmskw_MEMf64_IMM8_AVX512=6492, - XED_IFORM_VRNDSCALEPD_ZMMf64_MASKmskw_ZMMf64_IMM8_AVX512=6493, - XED_IFORM_VRNDSCALEPH_XMMf16_MASKmskw_MEMf16_IMM8_AVX512=6494, - XED_IFORM_VRNDSCALEPH_XMMf16_MASKmskw_XMMf16_IMM8_AVX512=6495, - XED_IFORM_VRNDSCALEPH_YMMf16_MASKmskw_MEMf16_IMM8_AVX512=6496, - XED_IFORM_VRNDSCALEPH_YMMf16_MASKmskw_YMMf16_IMM8_AVX512=6497, - XED_IFORM_VRNDSCALEPH_ZMMf16_MASKmskw_MEMf16_IMM8_AVX512=6498, - XED_IFORM_VRNDSCALEPH_ZMMf16_MASKmskw_ZMMf16_IMM8_AVX512=6499, - XED_IFORM_VRNDSCALEPS_XMMf32_MASKmskw_MEMf32_IMM8_AVX512=6500, - XED_IFORM_VRNDSCALEPS_XMMf32_MASKmskw_XMMf32_IMM8_AVX512=6501, - XED_IFORM_VRNDSCALEPS_YMMf32_MASKmskw_MEMf32_IMM8_AVX512=6502, - XED_IFORM_VRNDSCALEPS_YMMf32_MASKmskw_YMMf32_IMM8_AVX512=6503, - XED_IFORM_VRNDSCALEPS_ZMMf32_MASKmskw_MEMf32_IMM8_AVX512=6504, - XED_IFORM_VRNDSCALEPS_ZMMf32_MASKmskw_ZMMf32_IMM8_AVX512=6505, - XED_IFORM_VRNDSCALESD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=6506, - XED_IFORM_VRNDSCALESD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=6507, - XED_IFORM_VRNDSCALESH_XMMf16_MASKmskw_XMMf16_MEMf16_IMM8_AVX512=6508, - XED_IFORM_VRNDSCALESH_XMMf16_MASKmskw_XMMf16_XMMf16_IMM8_AVX512=6509, - XED_IFORM_VRNDSCALESS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=6510, - XED_IFORM_VRNDSCALESS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=6511, - XED_IFORM_VROUNDPD_XMMdq_MEMdq_IMMb=6512, - XED_IFORM_VROUNDPD_XMMdq_XMMdq_IMMb=6513, - XED_IFORM_VROUNDPD_YMMqq_MEMqq_IMMb=6514, - XED_IFORM_VROUNDPD_YMMqq_YMMqq_IMMb=6515, - XED_IFORM_VROUNDPS_XMMdq_MEMdq_IMMb=6516, - XED_IFORM_VROUNDPS_XMMdq_XMMdq_IMMb=6517, - XED_IFORM_VROUNDPS_YMMqq_MEMqq_IMMb=6518, - XED_IFORM_VROUNDPS_YMMqq_YMMqq_IMMb=6519, - XED_IFORM_VROUNDSD_XMMdq_XMMdq_MEMq_IMMb=6520, - XED_IFORM_VROUNDSD_XMMdq_XMMdq_XMMq_IMMb=6521, - XED_IFORM_VROUNDSS_XMMdq_XMMdq_MEMd_IMMb=6522, - XED_IFORM_VROUNDSS_XMMdq_XMMdq_XMMd_IMMb=6523, - XED_IFORM_VRSQRT14PD_XMMf64_MASKmskw_MEMf64_AVX512=6524, - XED_IFORM_VRSQRT14PD_XMMf64_MASKmskw_XMMf64_AVX512=6525, - XED_IFORM_VRSQRT14PD_YMMf64_MASKmskw_MEMf64_AVX512=6526, - XED_IFORM_VRSQRT14PD_YMMf64_MASKmskw_YMMf64_AVX512=6527, - XED_IFORM_VRSQRT14PD_ZMMf64_MASKmskw_MEMf64_AVX512=6528, - XED_IFORM_VRSQRT14PD_ZMMf64_MASKmskw_ZMMf64_AVX512=6529, - XED_IFORM_VRSQRT14PS_XMMf32_MASKmskw_MEMf32_AVX512=6530, - XED_IFORM_VRSQRT14PS_XMMf32_MASKmskw_XMMf32_AVX512=6531, - XED_IFORM_VRSQRT14PS_YMMf32_MASKmskw_MEMf32_AVX512=6532, - XED_IFORM_VRSQRT14PS_YMMf32_MASKmskw_YMMf32_AVX512=6533, - XED_IFORM_VRSQRT14PS_ZMMf32_MASKmskw_MEMf32_AVX512=6534, - XED_IFORM_VRSQRT14PS_ZMMf32_MASKmskw_ZMMf32_AVX512=6535, - XED_IFORM_VRSQRT14SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=6536, - XED_IFORM_VRSQRT14SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=6537, - XED_IFORM_VRSQRT14SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=6538, - XED_IFORM_VRSQRT14SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=6539, - XED_IFORM_VRSQRT28PD_ZMMf64_MASKmskw_MEMf64_AVX512ER=6540, - XED_IFORM_VRSQRT28PD_ZMMf64_MASKmskw_ZMMf64_AVX512ER=6541, - XED_IFORM_VRSQRT28PS_ZMMf32_MASKmskw_MEMf32_AVX512ER=6542, - XED_IFORM_VRSQRT28PS_ZMMf32_MASKmskw_ZMMf32_AVX512ER=6543, - XED_IFORM_VRSQRT28SD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512ER=6544, - XED_IFORM_VRSQRT28SD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512ER=6545, - XED_IFORM_VRSQRT28SS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512ER=6546, - XED_IFORM_VRSQRT28SS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512ER=6547, - XED_IFORM_VRSQRTPH_XMMf16_MASKmskw_MEMf16_AVX512=6548, - XED_IFORM_VRSQRTPH_XMMf16_MASKmskw_XMMf16_AVX512=6549, - XED_IFORM_VRSQRTPH_YMMf16_MASKmskw_MEMf16_AVX512=6550, - XED_IFORM_VRSQRTPH_YMMf16_MASKmskw_YMMf16_AVX512=6551, - XED_IFORM_VRSQRTPH_ZMMf16_MASKmskw_MEMf16_AVX512=6552, - XED_IFORM_VRSQRTPH_ZMMf16_MASKmskw_ZMMf16_AVX512=6553, - XED_IFORM_VRSQRTPS_XMMdq_MEMdq=6554, - XED_IFORM_VRSQRTPS_XMMdq_XMMdq=6555, - XED_IFORM_VRSQRTPS_YMMqq_MEMqq=6556, - XED_IFORM_VRSQRTPS_YMMqq_YMMqq=6557, - XED_IFORM_VRSQRTSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=6558, - XED_IFORM_VRSQRTSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=6559, - XED_IFORM_VRSQRTSS_XMMdq_XMMdq_MEMd=6560, - XED_IFORM_VRSQRTSS_XMMdq_XMMdq_XMMd=6561, - XED_IFORM_VSCALEFPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=6562, - XED_IFORM_VSCALEFPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=6563, - XED_IFORM_VSCALEFPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=6564, - XED_IFORM_VSCALEFPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=6565, - XED_IFORM_VSCALEFPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=6566, - XED_IFORM_VSCALEFPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=6567, - XED_IFORM_VSCALEFPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=6568, - XED_IFORM_VSCALEFPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=6569, - XED_IFORM_VSCALEFPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=6570, - XED_IFORM_VSCALEFPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=6571, - XED_IFORM_VSCALEFPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=6572, - XED_IFORM_VSCALEFPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=6573, - XED_IFORM_VSCALEFPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=6574, - XED_IFORM_VSCALEFPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=6575, - XED_IFORM_VSCALEFPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=6576, - XED_IFORM_VSCALEFPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=6577, - XED_IFORM_VSCALEFPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=6578, - XED_IFORM_VSCALEFPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=6579, - XED_IFORM_VSCALEFSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=6580, - XED_IFORM_VSCALEFSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=6581, - XED_IFORM_VSCALEFSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=6582, - XED_IFORM_VSCALEFSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=6583, - XED_IFORM_VSCALEFSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=6584, - XED_IFORM_VSCALEFSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=6585, - XED_IFORM_VSCATTERDPD_MEMf64_MASKmskw_XMMf64_AVX512_VL128=6586, - XED_IFORM_VSCATTERDPD_MEMf64_MASKmskw_YMMf64_AVX512_VL256=6587, - XED_IFORM_VSCATTERDPD_MEMf64_MASKmskw_ZMMf64_AVX512_VL512=6588, - XED_IFORM_VSCATTERDPS_MEMf32_MASKmskw_XMMf32_AVX512_VL128=6589, - XED_IFORM_VSCATTERDPS_MEMf32_MASKmskw_YMMf32_AVX512_VL256=6590, - XED_IFORM_VSCATTERDPS_MEMf32_MASKmskw_ZMMf32_AVX512_VL512=6591, - XED_IFORM_VSCATTERPF0DPD_MEMf64_MASKmskw_AVX512PF_VL512=6592, - XED_IFORM_VSCATTERPF0DPS_MEMf32_MASKmskw_AVX512PF_VL512=6593, - XED_IFORM_VSCATTERPF0QPD_MEMf64_MASKmskw_AVX512PF_VL512=6594, - XED_IFORM_VSCATTERPF0QPS_MEMf32_MASKmskw_AVX512PF_VL512=6595, - XED_IFORM_VSCATTERPF1DPD_MEMf64_MASKmskw_AVX512PF_VL512=6596, - XED_IFORM_VSCATTERPF1DPS_MEMf32_MASKmskw_AVX512PF_VL512=6597, - XED_IFORM_VSCATTERPF1QPD_MEMf64_MASKmskw_AVX512PF_VL512=6598, - XED_IFORM_VSCATTERPF1QPS_MEMf32_MASKmskw_AVX512PF_VL512=6599, - XED_IFORM_VSCATTERQPD_MEMf64_MASKmskw_XMMf64_AVX512_VL128=6600, - XED_IFORM_VSCATTERQPD_MEMf64_MASKmskw_YMMf64_AVX512_VL256=6601, - XED_IFORM_VSCATTERQPD_MEMf64_MASKmskw_ZMMf64_AVX512_VL512=6602, - XED_IFORM_VSCATTERQPS_MEMf32_MASKmskw_XMMf32_AVX512_VL128=6603, - XED_IFORM_VSCATTERQPS_MEMf32_MASKmskw_XMMf32_AVX512_VL256=6604, - XED_IFORM_VSCATTERQPS_MEMf32_MASKmskw_YMMf32_AVX512_VL512=6605, - XED_IFORM_VSHUFF32X4_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=6606, - XED_IFORM_VSHUFF32X4_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512=6607, - XED_IFORM_VSHUFF32X4_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=6608, - XED_IFORM_VSHUFF32X4_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512=6609, - XED_IFORM_VSHUFF64X2_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=6610, - XED_IFORM_VSHUFF64X2_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512=6611, - XED_IFORM_VSHUFF64X2_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=6612, - XED_IFORM_VSHUFF64X2_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512=6613, - XED_IFORM_VSHUFI32X4_YMMu32_MASKmskw_YMMu32_MEMu32_IMM8_AVX512=6614, - XED_IFORM_VSHUFI32X4_YMMu32_MASKmskw_YMMu32_YMMu32_IMM8_AVX512=6615, - XED_IFORM_VSHUFI32X4_ZMMu32_MASKmskw_ZMMu32_MEMu32_IMM8_AVX512=6616, - XED_IFORM_VSHUFI32X4_ZMMu32_MASKmskw_ZMMu32_ZMMu32_IMM8_AVX512=6617, - XED_IFORM_VSHUFI64X2_YMMu64_MASKmskw_YMMu64_MEMu64_IMM8_AVX512=6618, - XED_IFORM_VSHUFI64X2_YMMu64_MASKmskw_YMMu64_YMMu64_IMM8_AVX512=6619, - XED_IFORM_VSHUFI64X2_ZMMu64_MASKmskw_ZMMu64_MEMu64_IMM8_AVX512=6620, - XED_IFORM_VSHUFI64X2_ZMMu64_MASKmskw_ZMMu64_ZMMu64_IMM8_AVX512=6621, - XED_IFORM_VSHUFPD_XMMdq_XMMdq_MEMdq_IMMb=6622, - XED_IFORM_VSHUFPD_XMMdq_XMMdq_XMMdq_IMMb=6623, - XED_IFORM_VSHUFPD_XMMf64_MASKmskw_XMMf64_MEMf64_IMM8_AVX512=6624, - XED_IFORM_VSHUFPD_XMMf64_MASKmskw_XMMf64_XMMf64_IMM8_AVX512=6625, - XED_IFORM_VSHUFPD_YMMf64_MASKmskw_YMMf64_MEMf64_IMM8_AVX512=6626, - XED_IFORM_VSHUFPD_YMMf64_MASKmskw_YMMf64_YMMf64_IMM8_AVX512=6627, - XED_IFORM_VSHUFPD_YMMqq_YMMqq_MEMqq_IMMb=6628, - XED_IFORM_VSHUFPD_YMMqq_YMMqq_YMMqq_IMMb=6629, - XED_IFORM_VSHUFPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_IMM8_AVX512=6630, - XED_IFORM_VSHUFPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_IMM8_AVX512=6631, - XED_IFORM_VSHUFPS_XMMdq_XMMdq_MEMdq_IMMb=6632, - XED_IFORM_VSHUFPS_XMMdq_XMMdq_XMMdq_IMMb=6633, - XED_IFORM_VSHUFPS_XMMf32_MASKmskw_XMMf32_MEMf32_IMM8_AVX512=6634, - XED_IFORM_VSHUFPS_XMMf32_MASKmskw_XMMf32_XMMf32_IMM8_AVX512=6635, - XED_IFORM_VSHUFPS_YMMf32_MASKmskw_YMMf32_MEMf32_IMM8_AVX512=6636, - XED_IFORM_VSHUFPS_YMMf32_MASKmskw_YMMf32_YMMf32_IMM8_AVX512=6637, - XED_IFORM_VSHUFPS_YMMqq_YMMqq_MEMqq_IMMb=6638, - XED_IFORM_VSHUFPS_YMMqq_YMMqq_YMMqq_IMMb=6639, - XED_IFORM_VSHUFPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512=6640, - XED_IFORM_VSHUFPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512=6641, - XED_IFORM_VSQRTPD_XMMdq_MEMdq=6642, - XED_IFORM_VSQRTPD_XMMdq_XMMdq=6643, - XED_IFORM_VSQRTPD_XMMf64_MASKmskw_MEMf64_AVX512=6644, - XED_IFORM_VSQRTPD_XMMf64_MASKmskw_XMMf64_AVX512=6645, - XED_IFORM_VSQRTPD_YMMf64_MASKmskw_MEMf64_AVX512=6646, - XED_IFORM_VSQRTPD_YMMf64_MASKmskw_YMMf64_AVX512=6647, - XED_IFORM_VSQRTPD_YMMqq_MEMqq=6648, - XED_IFORM_VSQRTPD_YMMqq_YMMqq=6649, - XED_IFORM_VSQRTPD_ZMMf64_MASKmskw_MEMf64_AVX512=6650, - XED_IFORM_VSQRTPD_ZMMf64_MASKmskw_ZMMf64_AVX512=6651, - XED_IFORM_VSQRTPH_XMMf16_MASKmskw_MEMf16_AVX512=6652, - XED_IFORM_VSQRTPH_XMMf16_MASKmskw_XMMf16_AVX512=6653, - XED_IFORM_VSQRTPH_YMMf16_MASKmskw_MEMf16_AVX512=6654, - XED_IFORM_VSQRTPH_YMMf16_MASKmskw_YMMf16_AVX512=6655, - XED_IFORM_VSQRTPH_ZMMf16_MASKmskw_MEMf16_AVX512=6656, - XED_IFORM_VSQRTPH_ZMMf16_MASKmskw_ZMMf16_AVX512=6657, - XED_IFORM_VSQRTPS_XMMdq_MEMdq=6658, - XED_IFORM_VSQRTPS_XMMdq_XMMdq=6659, - XED_IFORM_VSQRTPS_XMMf32_MASKmskw_MEMf32_AVX512=6660, - XED_IFORM_VSQRTPS_XMMf32_MASKmskw_XMMf32_AVX512=6661, - XED_IFORM_VSQRTPS_YMMf32_MASKmskw_MEMf32_AVX512=6662, - XED_IFORM_VSQRTPS_YMMf32_MASKmskw_YMMf32_AVX512=6663, - XED_IFORM_VSQRTPS_YMMqq_MEMqq=6664, - XED_IFORM_VSQRTPS_YMMqq_YMMqq=6665, - XED_IFORM_VSQRTPS_ZMMf32_MASKmskw_MEMf32_AVX512=6666, - XED_IFORM_VSQRTPS_ZMMf32_MASKmskw_ZMMf32_AVX512=6667, - XED_IFORM_VSQRTSD_XMMdq_XMMdq_MEMq=6668, - XED_IFORM_VSQRTSD_XMMdq_XMMdq_XMMq=6669, - XED_IFORM_VSQRTSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=6670, - XED_IFORM_VSQRTSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=6671, - XED_IFORM_VSQRTSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=6672, - XED_IFORM_VSQRTSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=6673, - XED_IFORM_VSQRTSS_XMMdq_XMMdq_MEMd=6674, - XED_IFORM_VSQRTSS_XMMdq_XMMdq_XMMd=6675, - XED_IFORM_VSQRTSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=6676, - XED_IFORM_VSQRTSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=6677, - XED_IFORM_VSTMXCSR_MEMd=6678, - XED_IFORM_VSUBPD_XMMdq_XMMdq_MEMdq=6679, - XED_IFORM_VSUBPD_XMMdq_XMMdq_XMMdq=6680, - XED_IFORM_VSUBPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=6681, - XED_IFORM_VSUBPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=6682, - XED_IFORM_VSUBPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=6683, - XED_IFORM_VSUBPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=6684, - XED_IFORM_VSUBPD_YMMqq_YMMqq_MEMqq=6685, - XED_IFORM_VSUBPD_YMMqq_YMMqq_YMMqq=6686, - XED_IFORM_VSUBPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=6687, - XED_IFORM_VSUBPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=6688, - XED_IFORM_VSUBPH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=6689, - XED_IFORM_VSUBPH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=6690, - XED_IFORM_VSUBPH_YMMf16_MASKmskw_YMMf16_MEMf16_AVX512=6691, - XED_IFORM_VSUBPH_YMMf16_MASKmskw_YMMf16_YMMf16_AVX512=6692, - XED_IFORM_VSUBPH_ZMMf16_MASKmskw_ZMMf16_MEMf16_AVX512=6693, - XED_IFORM_VSUBPH_ZMMf16_MASKmskw_ZMMf16_ZMMf16_AVX512=6694, - XED_IFORM_VSUBPS_XMMdq_XMMdq_MEMdq=6695, - XED_IFORM_VSUBPS_XMMdq_XMMdq_XMMdq=6696, - XED_IFORM_VSUBPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=6697, - XED_IFORM_VSUBPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=6698, - XED_IFORM_VSUBPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=6699, - XED_IFORM_VSUBPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=6700, - XED_IFORM_VSUBPS_YMMqq_YMMqq_MEMqq=6701, - XED_IFORM_VSUBPS_YMMqq_YMMqq_YMMqq=6702, - XED_IFORM_VSUBPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=6703, - XED_IFORM_VSUBPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=6704, - XED_IFORM_VSUBSD_XMMdq_XMMdq_MEMq=6705, - XED_IFORM_VSUBSD_XMMdq_XMMdq_XMMq=6706, - XED_IFORM_VSUBSD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=6707, - XED_IFORM_VSUBSD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=6708, - XED_IFORM_VSUBSH_XMMf16_MASKmskw_XMMf16_MEMf16_AVX512=6709, - XED_IFORM_VSUBSH_XMMf16_MASKmskw_XMMf16_XMMf16_AVX512=6710, - XED_IFORM_VSUBSS_XMMdq_XMMdq_MEMd=6711, - XED_IFORM_VSUBSS_XMMdq_XMMdq_XMMd=6712, - XED_IFORM_VSUBSS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=6713, - XED_IFORM_VSUBSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=6714, - XED_IFORM_VTESTPD_XMMdq_MEMdq=6715, - XED_IFORM_VTESTPD_XMMdq_XMMdq=6716, - XED_IFORM_VTESTPD_YMMqq_MEMqq=6717, - XED_IFORM_VTESTPD_YMMqq_YMMqq=6718, - XED_IFORM_VTESTPS_XMMdq_MEMdq=6719, - XED_IFORM_VTESTPS_XMMdq_XMMdq=6720, - XED_IFORM_VTESTPS_YMMqq_MEMqq=6721, - XED_IFORM_VTESTPS_YMMqq_YMMqq=6722, - XED_IFORM_VUCOMISD_XMMdq_MEMq=6723, - XED_IFORM_VUCOMISD_XMMdq_XMMq=6724, - XED_IFORM_VUCOMISD_XMMf64_MEMf64_AVX512=6725, - XED_IFORM_VUCOMISD_XMMf64_XMMf64_AVX512=6726, - XED_IFORM_VUCOMISH_XMMf16_MEMf16_AVX512=6727, - XED_IFORM_VUCOMISH_XMMf16_XMMf16_AVX512=6728, - XED_IFORM_VUCOMISS_XMMdq_MEMd=6729, - XED_IFORM_VUCOMISS_XMMdq_XMMd=6730, - XED_IFORM_VUCOMISS_XMMf32_MEMf32_AVX512=6731, - XED_IFORM_VUCOMISS_XMMf32_XMMf32_AVX512=6732, - XED_IFORM_VUNPCKHPD_XMMdq_XMMdq_MEMdq=6733, - XED_IFORM_VUNPCKHPD_XMMdq_XMMdq_XMMdq=6734, - XED_IFORM_VUNPCKHPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=6735, - XED_IFORM_VUNPCKHPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=6736, - XED_IFORM_VUNPCKHPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=6737, - XED_IFORM_VUNPCKHPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=6738, - XED_IFORM_VUNPCKHPD_YMMqq_YMMqq_MEMqq=6739, - XED_IFORM_VUNPCKHPD_YMMqq_YMMqq_YMMqq=6740, - XED_IFORM_VUNPCKHPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=6741, - XED_IFORM_VUNPCKHPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=6742, - XED_IFORM_VUNPCKHPS_XMMdq_XMMdq_MEMdq=6743, - XED_IFORM_VUNPCKHPS_XMMdq_XMMdq_XMMdq=6744, - XED_IFORM_VUNPCKHPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=6745, - XED_IFORM_VUNPCKHPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=6746, - XED_IFORM_VUNPCKHPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=6747, - XED_IFORM_VUNPCKHPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=6748, - XED_IFORM_VUNPCKHPS_YMMqq_YMMqq_MEMqq=6749, - XED_IFORM_VUNPCKHPS_YMMqq_YMMqq_YMMqq=6750, - XED_IFORM_VUNPCKHPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=6751, - XED_IFORM_VUNPCKHPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=6752, - XED_IFORM_VUNPCKLPD_XMMdq_XMMdq_MEMdq=6753, - XED_IFORM_VUNPCKLPD_XMMdq_XMMdq_XMMdq=6754, - XED_IFORM_VUNPCKLPD_XMMf64_MASKmskw_XMMf64_MEMf64_AVX512=6755, - XED_IFORM_VUNPCKLPD_XMMf64_MASKmskw_XMMf64_XMMf64_AVX512=6756, - XED_IFORM_VUNPCKLPD_YMMf64_MASKmskw_YMMf64_MEMf64_AVX512=6757, - XED_IFORM_VUNPCKLPD_YMMf64_MASKmskw_YMMf64_YMMf64_AVX512=6758, - XED_IFORM_VUNPCKLPD_YMMqq_YMMqq_MEMqq=6759, - XED_IFORM_VUNPCKLPD_YMMqq_YMMqq_YMMqq=6760, - XED_IFORM_VUNPCKLPD_ZMMf64_MASKmskw_ZMMf64_MEMf64_AVX512=6761, - XED_IFORM_VUNPCKLPD_ZMMf64_MASKmskw_ZMMf64_ZMMf64_AVX512=6762, - XED_IFORM_VUNPCKLPS_XMMdq_XMMdq_MEMdq=6763, - XED_IFORM_VUNPCKLPS_XMMdq_XMMdq_XMMdq=6764, - XED_IFORM_VUNPCKLPS_XMMf32_MASKmskw_XMMf32_MEMf32_AVX512=6765, - XED_IFORM_VUNPCKLPS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512=6766, - XED_IFORM_VUNPCKLPS_YMMf32_MASKmskw_YMMf32_MEMf32_AVX512=6767, - XED_IFORM_VUNPCKLPS_YMMf32_MASKmskw_YMMf32_YMMf32_AVX512=6768, - XED_IFORM_VUNPCKLPS_YMMqq_YMMqq_MEMqq=6769, - XED_IFORM_VUNPCKLPS_YMMqq_YMMqq_YMMqq=6770, - XED_IFORM_VUNPCKLPS_ZMMf32_MASKmskw_ZMMf32_MEMf32_AVX512=6771, - XED_IFORM_VUNPCKLPS_ZMMf32_MASKmskw_ZMMf32_ZMMf32_AVX512=6772, - XED_IFORM_VXORPD_XMMdq_XMMdq_MEMdq=6773, - XED_IFORM_VXORPD_XMMdq_XMMdq_XMMdq=6774, - XED_IFORM_VXORPD_XMMu64_MASKmskw_XMMu64_MEMu64_AVX512=6775, - XED_IFORM_VXORPD_XMMu64_MASKmskw_XMMu64_XMMu64_AVX512=6776, - XED_IFORM_VXORPD_YMMqq_YMMqq_MEMqq=6777, - XED_IFORM_VXORPD_YMMqq_YMMqq_YMMqq=6778, - XED_IFORM_VXORPD_YMMu64_MASKmskw_YMMu64_MEMu64_AVX512=6779, - XED_IFORM_VXORPD_YMMu64_MASKmskw_YMMu64_YMMu64_AVX512=6780, - XED_IFORM_VXORPD_ZMMu64_MASKmskw_ZMMu64_MEMu64_AVX512=6781, - XED_IFORM_VXORPD_ZMMu64_MASKmskw_ZMMu64_ZMMu64_AVX512=6782, - XED_IFORM_VXORPS_XMMdq_XMMdq_MEMdq=6783, - XED_IFORM_VXORPS_XMMdq_XMMdq_XMMdq=6784, - XED_IFORM_VXORPS_XMMu32_MASKmskw_XMMu32_MEMu32_AVX512=6785, - XED_IFORM_VXORPS_XMMu32_MASKmskw_XMMu32_XMMu32_AVX512=6786, - XED_IFORM_VXORPS_YMMqq_YMMqq_MEMqq=6787, - XED_IFORM_VXORPS_YMMqq_YMMqq_YMMqq=6788, - XED_IFORM_VXORPS_YMMu32_MASKmskw_YMMu32_MEMu32_AVX512=6789, - XED_IFORM_VXORPS_YMMu32_MASKmskw_YMMu32_YMMu32_AVX512=6790, - XED_IFORM_VXORPS_ZMMu32_MASKmskw_ZMMu32_MEMu32_AVX512=6791, - XED_IFORM_VXORPS_ZMMu32_MASKmskw_ZMMu32_ZMMu32_AVX512=6792, - XED_IFORM_VZEROALL=6793, - XED_IFORM_VZEROUPPER=6794, - XED_IFORM_WBINVD=6795, - XED_IFORM_WBNOINVD=6796, - XED_IFORM_WRFSBASE_GPRy=6797, - XED_IFORM_WRGSBASE_GPRy=6798, - XED_IFORM_WRMSR=6799, - XED_IFORM_WRPKRU=6800, - XED_IFORM_WRSSD_MEMu32_GPR32u32=6801, - XED_IFORM_WRSSQ_MEMu64_GPR64u64=6802, - XED_IFORM_WRUSSD_MEMu32_GPR32u32=6803, - XED_IFORM_WRUSSQ_MEMu64_GPR64u64=6804, - XED_IFORM_XABORT_IMMb=6805, - XED_IFORM_XADD_GPR8_GPR8=6806, - XED_IFORM_XADD_GPRv_GPRv=6807, - XED_IFORM_XADD_MEMb_GPR8=6808, - XED_IFORM_XADD_MEMv_GPRv=6809, - XED_IFORM_XADD_LOCK_MEMb_GPR8=6810, - XED_IFORM_XADD_LOCK_MEMv_GPRv=6811, - XED_IFORM_XBEGIN_RELBRz=6812, - XED_IFORM_XCHG_GPR8_GPR8=6813, - XED_IFORM_XCHG_GPRv_GPRv=6814, - XED_IFORM_XCHG_GPRv_OrAX=6815, - XED_IFORM_XCHG_MEMb_GPR8=6816, - XED_IFORM_XCHG_MEMv_GPRv=6817, - XED_IFORM_XEND=6818, - XED_IFORM_XGETBV=6819, - XED_IFORM_XLAT=6820, - XED_IFORM_XOR_AL_IMMb=6821, - XED_IFORM_XOR_GPR8_GPR8_30=6822, - XED_IFORM_XOR_GPR8_GPR8_32=6823, - XED_IFORM_XOR_GPR8_IMMb_80r6=6824, - XED_IFORM_XOR_GPR8_IMMb_82r6=6825, - XED_IFORM_XOR_GPR8_MEMb=6826, - XED_IFORM_XOR_GPRv_GPRv_31=6827, - XED_IFORM_XOR_GPRv_GPRv_33=6828, - XED_IFORM_XOR_GPRv_IMMb=6829, - XED_IFORM_XOR_GPRv_IMMz=6830, - XED_IFORM_XOR_GPRv_MEMv=6831, - XED_IFORM_XOR_MEMb_GPR8=6832, - XED_IFORM_XOR_MEMb_IMMb_80r6=6833, - XED_IFORM_XOR_MEMb_IMMb_82r6=6834, - XED_IFORM_XOR_MEMv_GPRv=6835, - XED_IFORM_XOR_MEMv_IMMb=6836, - XED_IFORM_XOR_MEMv_IMMz=6837, - XED_IFORM_XOR_OrAX_IMMz=6838, - XED_IFORM_XORPD_XMMxuq_MEMxuq=6839, - XED_IFORM_XORPD_XMMxuq_XMMxuq=6840, - XED_IFORM_XORPS_XMMxud_MEMxud=6841, - XED_IFORM_XORPS_XMMxud_XMMxud=6842, - XED_IFORM_XOR_LOCK_MEMb_GPR8=6843, - XED_IFORM_XOR_LOCK_MEMb_IMMb_80r6=6844, - XED_IFORM_XOR_LOCK_MEMb_IMMb_82r6=6845, - XED_IFORM_XOR_LOCK_MEMv_GPRv=6846, - XED_IFORM_XOR_LOCK_MEMv_IMMb=6847, - XED_IFORM_XOR_LOCK_MEMv_IMMz=6848, - XED_IFORM_XRESLDTRK=6849, - XED_IFORM_XRSTOR_MEMmxsave=6850, - XED_IFORM_XRSTOR64_MEMmxsave=6851, - XED_IFORM_XRSTORS_MEMmxsave=6852, - XED_IFORM_XRSTORS64_MEMmxsave=6853, - XED_IFORM_XSAVE_MEMmxsave=6854, - XED_IFORM_XSAVE64_MEMmxsave=6855, - XED_IFORM_XSAVEC_MEMmxsave=6856, - XED_IFORM_XSAVEC64_MEMmxsave=6857, - XED_IFORM_XSAVEOPT_MEMmxsave=6858, - XED_IFORM_XSAVEOPT64_MEMmxsave=6859, - XED_IFORM_XSAVES_MEMmxsave=6860, - XED_IFORM_XSAVES64_MEMmxsave=6861, - XED_IFORM_XSETBV=6862, - XED_IFORM_XSTORE=6863, - XED_IFORM_XSUSLDTRK=6864, - XED_IFORM_XTEST=6865, - XED_IFORM_LAST -} xed_iform_enum_t; - -/// This converts strings to #xed_iform_enum_t types. -/// @param s A C-string. -/// @return #xed_iform_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_iform_enum_t str2xed_iform_enum_t(const char* s); -/// This converts strings to #xed_iform_enum_t types. -/// @param p An enumeration element of type xed_iform_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_iform_enum_t2str(const xed_iform_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_iform_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_iform_enum_t xed_iform_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-iform-map.h b/target/i386/latx/include/xed/xed-iform-map.h deleted file mode 100644 index 406730ef4d7..00000000000 --- a/target/i386/latx/include/xed/xed-iform-map.h +++ /dev/null @@ -1,117 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-iform-map.h -/// - -#if !defined(XED_IFORM_MAP_H) -# define XED_IFORM_MAP_H - -#include "xed-common-hdrs.h" -#include "xed-types.h" -#include "xed-iform-enum.h" /* generated */ -#include "xed-iclass-enum.h" /* generated */ -#include "xed-category-enum.h" /* generated */ -#include "xed-extension-enum.h" /* generated */ -#include "xed-isa-set-enum.h" /* generated */ - -/// @ingroup IFORM -/// Statically available information about iforms. -/// Values are returned by #xed_iform_map(). -typedef struct xed_iform_info_s { - xed_uint32_t iclass :16; // xed_iclass_enum_t - xed_uint32_t category :8; //xed_category_enum_t - xed_uint32_t extension :8; //xed_extension_enum_t - - xed_uint32_t isa_set :16; //xed_isa_set_enum_t - /* if nonzero, index in to the disassembly string table */ - xed_uint32_t string_table_idx:16; -} xed_iform_info_t; - - -/// @ingroup IFORM -/// Map the #xed_iform_enum_t to a pointer to a #xed_iform_info_t which -/// indicates the #xed_iclass_enum_t, the #xed_category_enum_t and the -/// #xed_extension_enum_t for the iform. Returns 0 if the iform is not a -/// valid iform. -XED_DLL_EXPORT -const xed_iform_info_t* xed_iform_map(xed_iform_enum_t iform); - -/// @ingroup IFORM -/// Return the maximum number of iforms for a particular iclass. This -/// function returns valid data as soon as global data is -/// initialized. (This function does not require a decoded instruction as -/// input). -XED_DLL_EXPORT -xed_uint32_t xed_iform_max_per_iclass(xed_iclass_enum_t iclass); - -/// @ingroup IFORM -/// Return the first of the iforms for a particular iclass. This function -/// returns valid data as soon as global data is initialized. (This -/// function does not require a decoded instruction as input). -XED_DLL_EXPORT -xed_uint32_t xed_iform_first_per_iclass(xed_iclass_enum_t iclass); - -/// @ingroup IFORM -/// Return the iclass for a given iform. This -/// function returns valid data as soon as global data is initialized. (This -/// function does not require a decoded instruction as input). -static -XED_INLINE xed_iclass_enum_t xed_iform_to_iclass(xed_iform_enum_t iform) { - const xed_iform_info_t* ii = xed_iform_map(iform); - if (ii) - return (xed_iclass_enum_t) ii->iclass; - return XED_ICLASS_INVALID; -} - -/// @ingroup IFORM -/// Return the category for a given iform. This -/// function returns valid data as soon as global data is initialized. (This -/// function does not require a decoded instruction as input). -XED_DLL_EXPORT -xed_category_enum_t xed_iform_to_category(xed_iform_enum_t iform); - -/// @ingroup IFORM -/// Return the extension for a given iform. This function returns valid -/// data as soon as global data is initialized. (This function does not -/// require a decoded instruction as input). -XED_DLL_EXPORT -xed_extension_enum_t xed_iform_to_extension(xed_iform_enum_t iform); - -/// @ingroup IFORM -/// Return the isa_set for a given iform. This function returns valid data -/// as soon as global data is initialized. (This function does not require -/// a decoded instruction as input). -XED_DLL_EXPORT -xed_isa_set_enum_t xed_iform_to_isa_set(xed_iform_enum_t iform); - -/// @ingroup IFORM -/// Return a pointer to a character string of the iclass. This -/// translates the internal disambiguated names to the more ambiguous -/// names that people like to see. This returns the ATT SYSV-syntax name. -XED_DLL_EXPORT -char const* xed_iform_to_iclass_string_att(xed_iform_enum_t iform); - - -/// @ingroup IFORM -/// Return a pointer to a character string of the iclass. This -/// translates the internal disambiguated names to the more ambiguous -/// names that people like to see. This returns the Intel-syntax name. -XED_DLL_EXPORT -char const* xed_iform_to_iclass_string_intel(xed_iform_enum_t iform); - -#endif diff --git a/target/i386/latx/include/xed/xed-iformfl-enum.h b/target/i386/latx/include/xed/xed-iformfl-enum.h deleted file mode 100644 index 0eb49921055..00000000000 --- a/target/i386/latx/include/xed/xed-iformfl-enum.h +++ /dev/null @@ -1,6976 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-iformfl-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_IFORMFL_ENUM_H) -# define XED_IFORMFL_ENUM_H -#include "xed-common-hdrs.h" -#include "xed-iclass-enum.h" -#define XED_IFORMFL_AAA_FIRST_DEFINED 1 -#define XED_IFORMFL_AAA_LAST_DEFINED 1 -#define XED_IFORMFL_AAD_FIRST_DEFINED 1 -#define XED_IFORMFL_AAD_LAST_DEFINED 1 -#define XED_IFORMFL_AAM_FIRST_DEFINED 1 -#define XED_IFORMFL_AAM_LAST_DEFINED 1 -#define XED_IFORMFL_AAS_FIRST_DEFINED 1 -#define XED_IFORMFL_AAS_LAST_DEFINED 1 -#define XED_IFORMFL_ADC_FIRST_DEFINED 1 -#define XED_IFORMFL_ADC_LAST_DEFINED 1 -#define XED_IFORMFL_ADCX_FIRST_DEFINED 1 -#define XED_IFORMFL_ADCX_LAST_DEFINED 1 -#define XED_IFORMFL_ADC_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_ADC_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_ADD_FIRST_DEFINED 1 -#define XED_IFORMFL_ADD_LAST_DEFINED 1 -#define XED_IFORMFL_ADDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_ADDPD_LAST_DEFINED 1 -#define XED_IFORMFL_ADDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_ADDPS_LAST_DEFINED 1 -#define XED_IFORMFL_ADDSD_FIRST_DEFINED 1 -#define XED_IFORMFL_ADDSD_LAST_DEFINED 1 -#define XED_IFORMFL_ADDSS_FIRST_DEFINED 1 -#define XED_IFORMFL_ADDSS_LAST_DEFINED 1 -#define XED_IFORMFL_ADDSUBPD_FIRST_DEFINED 1 -#define XED_IFORMFL_ADDSUBPD_LAST_DEFINED 1 -#define XED_IFORMFL_ADDSUBPS_FIRST_DEFINED 1 -#define XED_IFORMFL_ADDSUBPS_LAST_DEFINED 1 -#define XED_IFORMFL_ADD_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_ADD_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_ADOX_FIRST_DEFINED 1 -#define XED_IFORMFL_ADOX_LAST_DEFINED 1 -#define XED_IFORMFL_AESDEC_FIRST_DEFINED 1 -#define XED_IFORMFL_AESDEC_LAST_DEFINED 1 -#define XED_IFORMFL_AESDEC128KL_FIRST_DEFINED 1 -#define XED_IFORMFL_AESDEC128KL_LAST_DEFINED 1 -#define XED_IFORMFL_AESDEC256KL_FIRST_DEFINED 1 -#define XED_IFORMFL_AESDEC256KL_LAST_DEFINED 1 -#define XED_IFORMFL_AESDECLAST_FIRST_DEFINED 1 -#define XED_IFORMFL_AESDECLAST_LAST_DEFINED 1 -#define XED_IFORMFL_AESDECWIDE128KL_FIRST_DEFINED 1 -#define XED_IFORMFL_AESDECWIDE128KL_LAST_DEFINED 1 -#define XED_IFORMFL_AESDECWIDE256KL_FIRST_DEFINED 1 -#define XED_IFORMFL_AESDECWIDE256KL_LAST_DEFINED 1 -#define XED_IFORMFL_AESENC_FIRST_DEFINED 1 -#define XED_IFORMFL_AESENC_LAST_DEFINED 1 -#define XED_IFORMFL_AESENC128KL_FIRST_DEFINED 1 -#define XED_IFORMFL_AESENC128KL_LAST_DEFINED 1 -#define XED_IFORMFL_AESENC256KL_FIRST_DEFINED 1 -#define XED_IFORMFL_AESENC256KL_LAST_DEFINED 1 -#define XED_IFORMFL_AESENCLAST_FIRST_DEFINED 1 -#define XED_IFORMFL_AESENCLAST_LAST_DEFINED 1 -#define XED_IFORMFL_AESENCWIDE128KL_FIRST_DEFINED 1 -#define XED_IFORMFL_AESENCWIDE128KL_LAST_DEFINED 1 -#define XED_IFORMFL_AESENCWIDE256KL_FIRST_DEFINED 1 -#define XED_IFORMFL_AESENCWIDE256KL_LAST_DEFINED 1 -#define XED_IFORMFL_AESIMC_FIRST_DEFINED 1 -#define XED_IFORMFL_AESIMC_LAST_DEFINED 1 -#define XED_IFORMFL_AESKEYGENASSIST_FIRST_DEFINED 1 -#define XED_IFORMFL_AESKEYGENASSIST_LAST_DEFINED 1 -#define XED_IFORMFL_AND_FIRST_DEFINED 1 -#define XED_IFORMFL_AND_LAST_DEFINED 1 -#define XED_IFORMFL_ANDN_FIRST_DEFINED 1 -#define XED_IFORMFL_ANDN_LAST_DEFINED 1 -#define XED_IFORMFL_ANDNPD_FIRST_DEFINED 1 -#define XED_IFORMFL_ANDNPD_LAST_DEFINED 1 -#define XED_IFORMFL_ANDNPS_FIRST_DEFINED 1 -#define XED_IFORMFL_ANDNPS_LAST_DEFINED 1 -#define XED_IFORMFL_ANDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_ANDPD_LAST_DEFINED 1 -#define XED_IFORMFL_ANDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_ANDPS_LAST_DEFINED 1 -#define XED_IFORMFL_AND_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_AND_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_ARPL_FIRST_DEFINED 1 -#define XED_IFORMFL_ARPL_LAST_DEFINED 1 -#define XED_IFORMFL_BEXTR_FIRST_DEFINED 1 -#define XED_IFORMFL_BEXTR_LAST_DEFINED 1 -#define XED_IFORMFL_BEXTR_XOP_FIRST_DEFINED 1 -#define XED_IFORMFL_BEXTR_XOP_LAST_DEFINED 1 -#define XED_IFORMFL_BLCFILL_FIRST_DEFINED 1 -#define XED_IFORMFL_BLCFILL_LAST_DEFINED 1 -#define XED_IFORMFL_BLCI_FIRST_DEFINED 1 -#define XED_IFORMFL_BLCI_LAST_DEFINED 1 -#define XED_IFORMFL_BLCIC_FIRST_DEFINED 1 -#define XED_IFORMFL_BLCIC_LAST_DEFINED 1 -#define XED_IFORMFL_BLCMSK_FIRST_DEFINED 1 -#define XED_IFORMFL_BLCMSK_LAST_DEFINED 1 -#define XED_IFORMFL_BLCS_FIRST_DEFINED 1 -#define XED_IFORMFL_BLCS_LAST_DEFINED 1 -#define XED_IFORMFL_BLENDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_BLENDPD_LAST_DEFINED 1 -#define XED_IFORMFL_BLENDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_BLENDPS_LAST_DEFINED 1 -#define XED_IFORMFL_BLENDVPD_FIRST_DEFINED 1 -#define XED_IFORMFL_BLENDVPD_LAST_DEFINED 1 -#define XED_IFORMFL_BLENDVPS_FIRST_DEFINED 1 -#define XED_IFORMFL_BLENDVPS_LAST_DEFINED 1 -#define XED_IFORMFL_BLSFILL_FIRST_DEFINED 1 -#define XED_IFORMFL_BLSFILL_LAST_DEFINED 1 -#define XED_IFORMFL_BLSI_FIRST_DEFINED 1 -#define XED_IFORMFL_BLSI_LAST_DEFINED 1 -#define XED_IFORMFL_BLSIC_FIRST_DEFINED 1 -#define XED_IFORMFL_BLSIC_LAST_DEFINED 1 -#define XED_IFORMFL_BLSMSK_FIRST_DEFINED 1 -#define XED_IFORMFL_BLSMSK_LAST_DEFINED 1 -#define XED_IFORMFL_BLSR_FIRST_DEFINED 1 -#define XED_IFORMFL_BLSR_LAST_DEFINED 1 -#define XED_IFORMFL_BNDCL_FIRST_DEFINED 1 -#define XED_IFORMFL_BNDCL_LAST_DEFINED 1 -#define XED_IFORMFL_BNDCN_FIRST_DEFINED 1 -#define XED_IFORMFL_BNDCN_LAST_DEFINED 1 -#define XED_IFORMFL_BNDCU_FIRST_DEFINED 1 -#define XED_IFORMFL_BNDCU_LAST_DEFINED 1 -#define XED_IFORMFL_BNDLDX_FIRST_DEFINED 1 -#define XED_IFORMFL_BNDLDX_LAST_DEFINED 1 -#define XED_IFORMFL_BNDMK_FIRST_DEFINED 1 -#define XED_IFORMFL_BNDMK_LAST_DEFINED 1 -#define XED_IFORMFL_BNDMOV_FIRST_DEFINED 1 -#define XED_IFORMFL_BNDMOV_LAST_DEFINED 1 -#define XED_IFORMFL_BNDSTX_FIRST_DEFINED 1 -#define XED_IFORMFL_BNDSTX_LAST_DEFINED 1 -#define XED_IFORMFL_BOUND_FIRST_DEFINED 1 -#define XED_IFORMFL_BOUND_LAST_DEFINED 1 -#define XED_IFORMFL_BSF_FIRST_DEFINED 1 -#define XED_IFORMFL_BSF_LAST_DEFINED 1 -#define XED_IFORMFL_BSR_FIRST_DEFINED 1 -#define XED_IFORMFL_BSR_LAST_DEFINED 1 -#define XED_IFORMFL_BSWAP_FIRST_DEFINED 1 -#define XED_IFORMFL_BSWAP_LAST_DEFINED 1 -#define XED_IFORMFL_BT_FIRST_DEFINED 1 -#define XED_IFORMFL_BT_LAST_DEFINED 1 -#define XED_IFORMFL_BTC_FIRST_DEFINED 1 -#define XED_IFORMFL_BTC_LAST_DEFINED 1 -#define XED_IFORMFL_BTC_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_BTC_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_BTR_FIRST_DEFINED 1 -#define XED_IFORMFL_BTR_LAST_DEFINED 1 -#define XED_IFORMFL_BTR_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_BTR_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_BTS_FIRST_DEFINED 1 -#define XED_IFORMFL_BTS_LAST_DEFINED 1 -#define XED_IFORMFL_BTS_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_BTS_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_BZHI_FIRST_DEFINED 1 -#define XED_IFORMFL_BZHI_LAST_DEFINED 1 -#define XED_IFORMFL_CALL_FAR_FIRST_DEFINED 1 -#define XED_IFORMFL_CALL_FAR_LAST_DEFINED 1 -#define XED_IFORMFL_CALL_NEAR_FIRST_DEFINED 1 -#define XED_IFORMFL_CALL_NEAR_LAST_DEFINED 1 -#define XED_IFORMFL_CBW_FIRST_DEFINED 1 -#define XED_IFORMFL_CBW_LAST_DEFINED 1 -#define XED_IFORMFL_CDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_CDQ_LAST_DEFINED 1 -#define XED_IFORMFL_CDQE_FIRST_DEFINED 1 -#define XED_IFORMFL_CDQE_LAST_DEFINED 1 -#define XED_IFORMFL_CLAC_FIRST_DEFINED 1 -#define XED_IFORMFL_CLAC_LAST_DEFINED 1 -#define XED_IFORMFL_CLC_FIRST_DEFINED 1 -#define XED_IFORMFL_CLC_LAST_DEFINED 1 -#define XED_IFORMFL_CLD_FIRST_DEFINED 1 -#define XED_IFORMFL_CLD_LAST_DEFINED 1 -#define XED_IFORMFL_CLDEMOTE_FIRST_DEFINED 1 -#define XED_IFORMFL_CLDEMOTE_LAST_DEFINED 1 -#define XED_IFORMFL_CLFLUSH_FIRST_DEFINED 1 -#define XED_IFORMFL_CLFLUSH_LAST_DEFINED 1 -#define XED_IFORMFL_CLFLUSHOPT_FIRST_DEFINED 1 -#define XED_IFORMFL_CLFLUSHOPT_LAST_DEFINED 1 -#define XED_IFORMFL_CLGI_FIRST_DEFINED 1 -#define XED_IFORMFL_CLGI_LAST_DEFINED 1 -#define XED_IFORMFL_CLI_FIRST_DEFINED 1 -#define XED_IFORMFL_CLI_LAST_DEFINED 1 -#define XED_IFORMFL_CLRSSBSY_FIRST_DEFINED 1 -#define XED_IFORMFL_CLRSSBSY_LAST_DEFINED 1 -#define XED_IFORMFL_CLTS_FIRST_DEFINED 1 -#define XED_IFORMFL_CLTS_LAST_DEFINED 1 -#define XED_IFORMFL_CLUI_FIRST_DEFINED 1 -#define XED_IFORMFL_CLUI_LAST_DEFINED 1 -#define XED_IFORMFL_CLWB_FIRST_DEFINED 1 -#define XED_IFORMFL_CLWB_LAST_DEFINED 1 -#define XED_IFORMFL_CLZERO_FIRST_DEFINED 1 -#define XED_IFORMFL_CLZERO_LAST_DEFINED 1 -#define XED_IFORMFL_CMC_FIRST_DEFINED 1 -#define XED_IFORMFL_CMC_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVB_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVB_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVBE_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVBE_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVL_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVL_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVLE_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVLE_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVNB_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVNB_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVNBE_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVNBE_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVNL_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVNL_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVNLE_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVNLE_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVNO_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVNO_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVNP_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVNP_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVNS_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVNS_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVNZ_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVNZ_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVO_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVO_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVP_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVP_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVS_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVS_LAST_DEFINED 1 -#define XED_IFORMFL_CMOVZ_FIRST_DEFINED 1 -#define XED_IFORMFL_CMOVZ_LAST_DEFINED 1 -#define XED_IFORMFL_CMP_FIRST_DEFINED 1 -#define XED_IFORMFL_CMP_LAST_DEFINED 1 -#define XED_IFORMFL_CMPPD_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPPD_LAST_DEFINED 1 -#define XED_IFORMFL_CMPPS_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPPS_LAST_DEFINED 1 -#define XED_IFORMFL_CMPSB_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPSB_LAST_DEFINED 1 -#define XED_IFORMFL_CMPSD_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPSD_LAST_DEFINED 1 -#define XED_IFORMFL_CMPSD_XMM_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPSD_XMM_LAST_DEFINED 1 -#define XED_IFORMFL_CMPSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPSQ_LAST_DEFINED 1 -#define XED_IFORMFL_CMPSS_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPSS_LAST_DEFINED 1 -#define XED_IFORMFL_CMPSW_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPSW_LAST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG_LAST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG16B_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG16B_LAST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG16B_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG16B_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG8B_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG8B_LAST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG8B_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG8B_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_CMPXCHG_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_COMISD_FIRST_DEFINED 1 -#define XED_IFORMFL_COMISD_LAST_DEFINED 1 -#define XED_IFORMFL_COMISS_FIRST_DEFINED 1 -#define XED_IFORMFL_COMISS_LAST_DEFINED 1 -#define XED_IFORMFL_CPUID_FIRST_DEFINED 1 -#define XED_IFORMFL_CPUID_LAST_DEFINED 1 -#define XED_IFORMFL_CQO_FIRST_DEFINED 1 -#define XED_IFORMFL_CQO_LAST_DEFINED 1 -#define XED_IFORMFL_CRC32_FIRST_DEFINED 1 -#define XED_IFORMFL_CRC32_LAST_DEFINED 1 -#define XED_IFORMFL_CVTDQ2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTDQ2PD_LAST_DEFINED 1 -#define XED_IFORMFL_CVTDQ2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTDQ2PS_LAST_DEFINED 1 -#define XED_IFORMFL_CVTPD2DQ_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTPD2DQ_LAST_DEFINED 1 -#define XED_IFORMFL_CVTPD2PI_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTPD2PI_LAST_DEFINED 1 -#define XED_IFORMFL_CVTPD2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTPD2PS_LAST_DEFINED 1 -#define XED_IFORMFL_CVTPI2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTPI2PD_LAST_DEFINED 1 -#define XED_IFORMFL_CVTPI2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTPI2PS_LAST_DEFINED 1 -#define XED_IFORMFL_CVTPS2DQ_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTPS2DQ_LAST_DEFINED 1 -#define XED_IFORMFL_CVTPS2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTPS2PD_LAST_DEFINED 1 -#define XED_IFORMFL_CVTPS2PI_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTPS2PI_LAST_DEFINED 1 -#define XED_IFORMFL_CVTSD2SI_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTSD2SI_LAST_DEFINED 1 -#define XED_IFORMFL_CVTSD2SS_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTSD2SS_LAST_DEFINED 1 -#define XED_IFORMFL_CVTSI2SD_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTSI2SD_LAST_DEFINED 1 -#define XED_IFORMFL_CVTSI2SS_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTSI2SS_LAST_DEFINED 1 -#define XED_IFORMFL_CVTSS2SD_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTSS2SD_LAST_DEFINED 1 -#define XED_IFORMFL_CVTSS2SI_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTSS2SI_LAST_DEFINED 1 -#define XED_IFORMFL_CVTTPD2DQ_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTTPD2DQ_LAST_DEFINED 1 -#define XED_IFORMFL_CVTTPD2PI_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTTPD2PI_LAST_DEFINED 1 -#define XED_IFORMFL_CVTTPS2DQ_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTTPS2DQ_LAST_DEFINED 1 -#define XED_IFORMFL_CVTTPS2PI_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTTPS2PI_LAST_DEFINED 1 -#define XED_IFORMFL_CVTTSD2SI_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTTSD2SI_LAST_DEFINED 1 -#define XED_IFORMFL_CVTTSS2SI_FIRST_DEFINED 1 -#define XED_IFORMFL_CVTTSS2SI_LAST_DEFINED 1 -#define XED_IFORMFL_CWD_FIRST_DEFINED 1 -#define XED_IFORMFL_CWD_LAST_DEFINED 1 -#define XED_IFORMFL_CWDE_FIRST_DEFINED 1 -#define XED_IFORMFL_CWDE_LAST_DEFINED 1 -#define XED_IFORMFL_DAA_FIRST_DEFINED 1 -#define XED_IFORMFL_DAA_LAST_DEFINED 1 -#define XED_IFORMFL_DAS_FIRST_DEFINED 1 -#define XED_IFORMFL_DAS_LAST_DEFINED 1 -#define XED_IFORMFL_DEC_FIRST_DEFINED 1 -#define XED_IFORMFL_DEC_LAST_DEFINED 1 -#define XED_IFORMFL_DEC_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_DEC_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_DIV_FIRST_DEFINED 1 -#define XED_IFORMFL_DIV_LAST_DEFINED 1 -#define XED_IFORMFL_DIVPD_FIRST_DEFINED 1 -#define XED_IFORMFL_DIVPD_LAST_DEFINED 1 -#define XED_IFORMFL_DIVPS_FIRST_DEFINED 1 -#define XED_IFORMFL_DIVPS_LAST_DEFINED 1 -#define XED_IFORMFL_DIVSD_FIRST_DEFINED 1 -#define XED_IFORMFL_DIVSD_LAST_DEFINED 1 -#define XED_IFORMFL_DIVSS_FIRST_DEFINED 1 -#define XED_IFORMFL_DIVSS_LAST_DEFINED 1 -#define XED_IFORMFL_DPPD_FIRST_DEFINED 1 -#define XED_IFORMFL_DPPD_LAST_DEFINED 1 -#define XED_IFORMFL_DPPS_FIRST_DEFINED 1 -#define XED_IFORMFL_DPPS_LAST_DEFINED 1 -#define XED_IFORMFL_EMMS_FIRST_DEFINED 1 -#define XED_IFORMFL_EMMS_LAST_DEFINED 1 -#define XED_IFORMFL_ENCLS_FIRST_DEFINED 1 -#define XED_IFORMFL_ENCLS_LAST_DEFINED 1 -#define XED_IFORMFL_ENCLU_FIRST_DEFINED 1 -#define XED_IFORMFL_ENCLU_LAST_DEFINED 1 -#define XED_IFORMFL_ENCLV_FIRST_DEFINED 1 -#define XED_IFORMFL_ENCLV_LAST_DEFINED 1 -#define XED_IFORMFL_ENCODEKEY128_FIRST_DEFINED 1 -#define XED_IFORMFL_ENCODEKEY128_LAST_DEFINED 1 -#define XED_IFORMFL_ENCODEKEY256_FIRST_DEFINED 1 -#define XED_IFORMFL_ENCODEKEY256_LAST_DEFINED 1 -#define XED_IFORMFL_ENDBR32_FIRST_DEFINED 1 -#define XED_IFORMFL_ENDBR32_LAST_DEFINED 1 -#define XED_IFORMFL_ENDBR64_FIRST_DEFINED 1 -#define XED_IFORMFL_ENDBR64_LAST_DEFINED 1 -#define XED_IFORMFL_ENQCMD_FIRST_DEFINED 1 -#define XED_IFORMFL_ENQCMD_LAST_DEFINED 1 -#define XED_IFORMFL_ENQCMDS_FIRST_DEFINED 1 -#define XED_IFORMFL_ENQCMDS_LAST_DEFINED 1 -#define XED_IFORMFL_ENTER_FIRST_DEFINED 1 -#define XED_IFORMFL_ENTER_LAST_DEFINED 1 -#define XED_IFORMFL_EXTRACTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_EXTRACTPS_LAST_DEFINED 1 -#define XED_IFORMFL_EXTRQ_FIRST_DEFINED 1 -#define XED_IFORMFL_EXTRQ_LAST_DEFINED 1 -#define XED_IFORMFL_F2XM1_FIRST_DEFINED 1 -#define XED_IFORMFL_F2XM1_LAST_DEFINED 1 -#define XED_IFORMFL_FABS_FIRST_DEFINED 1 -#define XED_IFORMFL_FABS_LAST_DEFINED 1 -#define XED_IFORMFL_FADD_FIRST_DEFINED 1 -#define XED_IFORMFL_FADD_LAST_DEFINED 1 -#define XED_IFORMFL_FADDP_FIRST_DEFINED 1 -#define XED_IFORMFL_FADDP_LAST_DEFINED 1 -#define XED_IFORMFL_FBLD_FIRST_DEFINED 1 -#define XED_IFORMFL_FBLD_LAST_DEFINED 1 -#define XED_IFORMFL_FBSTP_FIRST_DEFINED 1 -#define XED_IFORMFL_FBSTP_LAST_DEFINED 1 -#define XED_IFORMFL_FCHS_FIRST_DEFINED 1 -#define XED_IFORMFL_FCHS_LAST_DEFINED 1 -#define XED_IFORMFL_FCMOVB_FIRST_DEFINED 1 -#define XED_IFORMFL_FCMOVB_LAST_DEFINED 1 -#define XED_IFORMFL_FCMOVBE_FIRST_DEFINED 1 -#define XED_IFORMFL_FCMOVBE_LAST_DEFINED 1 -#define XED_IFORMFL_FCMOVE_FIRST_DEFINED 1 -#define XED_IFORMFL_FCMOVE_LAST_DEFINED 1 -#define XED_IFORMFL_FCMOVNB_FIRST_DEFINED 1 -#define XED_IFORMFL_FCMOVNB_LAST_DEFINED 1 -#define XED_IFORMFL_FCMOVNBE_FIRST_DEFINED 1 -#define XED_IFORMFL_FCMOVNBE_LAST_DEFINED 1 -#define XED_IFORMFL_FCMOVNE_FIRST_DEFINED 1 -#define XED_IFORMFL_FCMOVNE_LAST_DEFINED 1 -#define XED_IFORMFL_FCMOVNU_FIRST_DEFINED 1 -#define XED_IFORMFL_FCMOVNU_LAST_DEFINED 1 -#define XED_IFORMFL_FCMOVU_FIRST_DEFINED 1 -#define XED_IFORMFL_FCMOVU_LAST_DEFINED 1 -#define XED_IFORMFL_FCOM_FIRST_DEFINED 1 -#define XED_IFORMFL_FCOM_LAST_DEFINED 1 -#define XED_IFORMFL_FCOMI_FIRST_DEFINED 1 -#define XED_IFORMFL_FCOMI_LAST_DEFINED 1 -#define XED_IFORMFL_FCOMIP_FIRST_DEFINED 1 -#define XED_IFORMFL_FCOMIP_LAST_DEFINED 1 -#define XED_IFORMFL_FCOMP_FIRST_DEFINED 1 -#define XED_IFORMFL_FCOMP_LAST_DEFINED 1 -#define XED_IFORMFL_FCOMPP_FIRST_DEFINED 1 -#define XED_IFORMFL_FCOMPP_LAST_DEFINED 1 -#define XED_IFORMFL_FCOS_FIRST_DEFINED 1 -#define XED_IFORMFL_FCOS_LAST_DEFINED 1 -#define XED_IFORMFL_FDECSTP_FIRST_DEFINED 1 -#define XED_IFORMFL_FDECSTP_LAST_DEFINED 1 -#define XED_IFORMFL_FDISI8087_NOP_FIRST_DEFINED 1 -#define XED_IFORMFL_FDISI8087_NOP_LAST_DEFINED 1 -#define XED_IFORMFL_FDIV_FIRST_DEFINED 1 -#define XED_IFORMFL_FDIV_LAST_DEFINED 1 -#define XED_IFORMFL_FDIVP_FIRST_DEFINED 1 -#define XED_IFORMFL_FDIVP_LAST_DEFINED 1 -#define XED_IFORMFL_FDIVR_FIRST_DEFINED 1 -#define XED_IFORMFL_FDIVR_LAST_DEFINED 1 -#define XED_IFORMFL_FDIVRP_FIRST_DEFINED 1 -#define XED_IFORMFL_FDIVRP_LAST_DEFINED 1 -#define XED_IFORMFL_FEMMS_FIRST_DEFINED 1 -#define XED_IFORMFL_FEMMS_LAST_DEFINED 1 -#define XED_IFORMFL_FENI8087_NOP_FIRST_DEFINED 1 -#define XED_IFORMFL_FENI8087_NOP_LAST_DEFINED 1 -#define XED_IFORMFL_FFREE_FIRST_DEFINED 1 -#define XED_IFORMFL_FFREE_LAST_DEFINED 1 -#define XED_IFORMFL_FFREEP_FIRST_DEFINED 1 -#define XED_IFORMFL_FFREEP_LAST_DEFINED 1 -#define XED_IFORMFL_FIADD_FIRST_DEFINED 1 -#define XED_IFORMFL_FIADD_LAST_DEFINED 1 -#define XED_IFORMFL_FICOM_FIRST_DEFINED 1 -#define XED_IFORMFL_FICOM_LAST_DEFINED 1 -#define XED_IFORMFL_FICOMP_FIRST_DEFINED 1 -#define XED_IFORMFL_FICOMP_LAST_DEFINED 1 -#define XED_IFORMFL_FIDIV_FIRST_DEFINED 1 -#define XED_IFORMFL_FIDIV_LAST_DEFINED 1 -#define XED_IFORMFL_FIDIVR_FIRST_DEFINED 1 -#define XED_IFORMFL_FIDIVR_LAST_DEFINED 1 -#define XED_IFORMFL_FILD_FIRST_DEFINED 1 -#define XED_IFORMFL_FILD_LAST_DEFINED 1 -#define XED_IFORMFL_FIMUL_FIRST_DEFINED 1 -#define XED_IFORMFL_FIMUL_LAST_DEFINED 1 -#define XED_IFORMFL_FINCSTP_FIRST_DEFINED 1 -#define XED_IFORMFL_FINCSTP_LAST_DEFINED 1 -#define XED_IFORMFL_FIST_FIRST_DEFINED 1 -#define XED_IFORMFL_FIST_LAST_DEFINED 1 -#define XED_IFORMFL_FISTP_FIRST_DEFINED 1 -#define XED_IFORMFL_FISTP_LAST_DEFINED 1 -#define XED_IFORMFL_FISTTP_FIRST_DEFINED 1 -#define XED_IFORMFL_FISTTP_LAST_DEFINED 1 -#define XED_IFORMFL_FISUB_FIRST_DEFINED 1 -#define XED_IFORMFL_FISUB_LAST_DEFINED 1 -#define XED_IFORMFL_FISUBR_FIRST_DEFINED 1 -#define XED_IFORMFL_FISUBR_LAST_DEFINED 1 -#define XED_IFORMFL_FLD_FIRST_DEFINED 1 -#define XED_IFORMFL_FLD_LAST_DEFINED 1 -#define XED_IFORMFL_FLD1_FIRST_DEFINED 1 -#define XED_IFORMFL_FLD1_LAST_DEFINED 1 -#define XED_IFORMFL_FLDCW_FIRST_DEFINED 1 -#define XED_IFORMFL_FLDCW_LAST_DEFINED 1 -#define XED_IFORMFL_FLDENV_FIRST_DEFINED 1 -#define XED_IFORMFL_FLDENV_LAST_DEFINED 1 -#define XED_IFORMFL_FLDL2E_FIRST_DEFINED 1 -#define XED_IFORMFL_FLDL2E_LAST_DEFINED 1 -#define XED_IFORMFL_FLDL2T_FIRST_DEFINED 1 -#define XED_IFORMFL_FLDL2T_LAST_DEFINED 1 -#define XED_IFORMFL_FLDLG2_FIRST_DEFINED 1 -#define XED_IFORMFL_FLDLG2_LAST_DEFINED 1 -#define XED_IFORMFL_FLDLN2_FIRST_DEFINED 1 -#define XED_IFORMFL_FLDLN2_LAST_DEFINED 1 -#define XED_IFORMFL_FLDPI_FIRST_DEFINED 1 -#define XED_IFORMFL_FLDPI_LAST_DEFINED 1 -#define XED_IFORMFL_FLDZ_FIRST_DEFINED 1 -#define XED_IFORMFL_FLDZ_LAST_DEFINED 1 -#define XED_IFORMFL_FMUL_FIRST_DEFINED 1 -#define XED_IFORMFL_FMUL_LAST_DEFINED 1 -#define XED_IFORMFL_FMULP_FIRST_DEFINED 1 -#define XED_IFORMFL_FMULP_LAST_DEFINED 1 -#define XED_IFORMFL_FNCLEX_FIRST_DEFINED 1 -#define XED_IFORMFL_FNCLEX_LAST_DEFINED 1 -#define XED_IFORMFL_FNINIT_FIRST_DEFINED 1 -#define XED_IFORMFL_FNINIT_LAST_DEFINED 1 -#define XED_IFORMFL_FNOP_FIRST_DEFINED 1 -#define XED_IFORMFL_FNOP_LAST_DEFINED 1 -#define XED_IFORMFL_FNSAVE_FIRST_DEFINED 1 -#define XED_IFORMFL_FNSAVE_LAST_DEFINED 1 -#define XED_IFORMFL_FNSTCW_FIRST_DEFINED 1 -#define XED_IFORMFL_FNSTCW_LAST_DEFINED 1 -#define XED_IFORMFL_FNSTENV_FIRST_DEFINED 1 -#define XED_IFORMFL_FNSTENV_LAST_DEFINED 1 -#define XED_IFORMFL_FNSTSW_FIRST_DEFINED 1 -#define XED_IFORMFL_FNSTSW_LAST_DEFINED 1 -#define XED_IFORMFL_FPATAN_FIRST_DEFINED 1 -#define XED_IFORMFL_FPATAN_LAST_DEFINED 1 -#define XED_IFORMFL_FPREM_FIRST_DEFINED 1 -#define XED_IFORMFL_FPREM_LAST_DEFINED 1 -#define XED_IFORMFL_FPREM1_FIRST_DEFINED 1 -#define XED_IFORMFL_FPREM1_LAST_DEFINED 1 -#define XED_IFORMFL_FPTAN_FIRST_DEFINED 1 -#define XED_IFORMFL_FPTAN_LAST_DEFINED 1 -#define XED_IFORMFL_FRNDINT_FIRST_DEFINED 1 -#define XED_IFORMFL_FRNDINT_LAST_DEFINED 1 -#define XED_IFORMFL_FRSTOR_FIRST_DEFINED 1 -#define XED_IFORMFL_FRSTOR_LAST_DEFINED 1 -#define XED_IFORMFL_FSCALE_FIRST_DEFINED 1 -#define XED_IFORMFL_FSCALE_LAST_DEFINED 1 -#define XED_IFORMFL_FSETPM287_NOP_FIRST_DEFINED 1 -#define XED_IFORMFL_FSETPM287_NOP_LAST_DEFINED 1 -#define XED_IFORMFL_FSIN_FIRST_DEFINED 1 -#define XED_IFORMFL_FSIN_LAST_DEFINED 1 -#define XED_IFORMFL_FSINCOS_FIRST_DEFINED 1 -#define XED_IFORMFL_FSINCOS_LAST_DEFINED 1 -#define XED_IFORMFL_FSQRT_FIRST_DEFINED 1 -#define XED_IFORMFL_FSQRT_LAST_DEFINED 1 -#define XED_IFORMFL_FST_FIRST_DEFINED 1 -#define XED_IFORMFL_FST_LAST_DEFINED 1 -#define XED_IFORMFL_FSTP_FIRST_DEFINED 1 -#define XED_IFORMFL_FSTP_LAST_DEFINED 1 -#define XED_IFORMFL_FSTPNCE_FIRST_DEFINED 1 -#define XED_IFORMFL_FSTPNCE_LAST_DEFINED 1 -#define XED_IFORMFL_FSUB_FIRST_DEFINED 1 -#define XED_IFORMFL_FSUB_LAST_DEFINED 1 -#define XED_IFORMFL_FSUBP_FIRST_DEFINED 1 -#define XED_IFORMFL_FSUBP_LAST_DEFINED 1 -#define XED_IFORMFL_FSUBR_FIRST_DEFINED 1 -#define XED_IFORMFL_FSUBR_LAST_DEFINED 1 -#define XED_IFORMFL_FSUBRP_FIRST_DEFINED 1 -#define XED_IFORMFL_FSUBRP_LAST_DEFINED 1 -#define XED_IFORMFL_FTST_FIRST_DEFINED 1 -#define XED_IFORMFL_FTST_LAST_DEFINED 1 -#define XED_IFORMFL_FUCOM_FIRST_DEFINED 1 -#define XED_IFORMFL_FUCOM_LAST_DEFINED 1 -#define XED_IFORMFL_FUCOMI_FIRST_DEFINED 1 -#define XED_IFORMFL_FUCOMI_LAST_DEFINED 1 -#define XED_IFORMFL_FUCOMIP_FIRST_DEFINED 1 -#define XED_IFORMFL_FUCOMIP_LAST_DEFINED 1 -#define XED_IFORMFL_FUCOMP_FIRST_DEFINED 1 -#define XED_IFORMFL_FUCOMP_LAST_DEFINED 1 -#define XED_IFORMFL_FUCOMPP_FIRST_DEFINED 1 -#define XED_IFORMFL_FUCOMPP_LAST_DEFINED 1 -#define XED_IFORMFL_FWAIT_FIRST_DEFINED 1 -#define XED_IFORMFL_FWAIT_LAST_DEFINED 1 -#define XED_IFORMFL_FXAM_FIRST_DEFINED 1 -#define XED_IFORMFL_FXAM_LAST_DEFINED 1 -#define XED_IFORMFL_FXCH_FIRST_DEFINED 1 -#define XED_IFORMFL_FXCH_LAST_DEFINED 1 -#define XED_IFORMFL_FXRSTOR_FIRST_DEFINED 1 -#define XED_IFORMFL_FXRSTOR_LAST_DEFINED 1 -#define XED_IFORMFL_FXRSTOR64_FIRST_DEFINED 1 -#define XED_IFORMFL_FXRSTOR64_LAST_DEFINED 1 -#define XED_IFORMFL_FXSAVE_FIRST_DEFINED 1 -#define XED_IFORMFL_FXSAVE_LAST_DEFINED 1 -#define XED_IFORMFL_FXSAVE64_FIRST_DEFINED 1 -#define XED_IFORMFL_FXSAVE64_LAST_DEFINED 1 -#define XED_IFORMFL_FXTRACT_FIRST_DEFINED 1 -#define XED_IFORMFL_FXTRACT_LAST_DEFINED 1 -#define XED_IFORMFL_FYL2X_FIRST_DEFINED 1 -#define XED_IFORMFL_FYL2X_LAST_DEFINED 1 -#define XED_IFORMFL_FYL2XP1_FIRST_DEFINED 1 -#define XED_IFORMFL_FYL2XP1_LAST_DEFINED 1 -#define XED_IFORMFL_GETSEC_FIRST_DEFINED 1 -#define XED_IFORMFL_GETSEC_LAST_DEFINED 1 -#define XED_IFORMFL_GF2P8AFFINEINVQB_FIRST_DEFINED 1 -#define XED_IFORMFL_GF2P8AFFINEINVQB_LAST_DEFINED 1 -#define XED_IFORMFL_GF2P8AFFINEQB_FIRST_DEFINED 1 -#define XED_IFORMFL_GF2P8AFFINEQB_LAST_DEFINED 1 -#define XED_IFORMFL_GF2P8MULB_FIRST_DEFINED 1 -#define XED_IFORMFL_GF2P8MULB_LAST_DEFINED 1 -#define XED_IFORMFL_HADDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_HADDPD_LAST_DEFINED 1 -#define XED_IFORMFL_HADDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_HADDPS_LAST_DEFINED 1 -#define XED_IFORMFL_HLT_FIRST_DEFINED 1 -#define XED_IFORMFL_HLT_LAST_DEFINED 1 -#define XED_IFORMFL_HRESET_FIRST_DEFINED 1 -#define XED_IFORMFL_HRESET_LAST_DEFINED 1 -#define XED_IFORMFL_HSUBPD_FIRST_DEFINED 1 -#define XED_IFORMFL_HSUBPD_LAST_DEFINED 1 -#define XED_IFORMFL_HSUBPS_FIRST_DEFINED 1 -#define XED_IFORMFL_HSUBPS_LAST_DEFINED 1 -#define XED_IFORMFL_IDIV_FIRST_DEFINED 1 -#define XED_IFORMFL_IDIV_LAST_DEFINED 1 -#define XED_IFORMFL_IMUL_FIRST_DEFINED 1 -#define XED_IFORMFL_IMUL_LAST_DEFINED 1 -#define XED_IFORMFL_IN_FIRST_DEFINED 1 -#define XED_IFORMFL_IN_LAST_DEFINED 1 -#define XED_IFORMFL_INC_FIRST_DEFINED 1 -#define XED_IFORMFL_INC_LAST_DEFINED 1 -#define XED_IFORMFL_INCSSPD_FIRST_DEFINED 1 -#define XED_IFORMFL_INCSSPD_LAST_DEFINED 1 -#define XED_IFORMFL_INCSSPQ_FIRST_DEFINED 1 -#define XED_IFORMFL_INCSSPQ_LAST_DEFINED 1 -#define XED_IFORMFL_INC_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_INC_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_INSB_FIRST_DEFINED 1 -#define XED_IFORMFL_INSB_LAST_DEFINED 1 -#define XED_IFORMFL_INSD_FIRST_DEFINED 1 -#define XED_IFORMFL_INSD_LAST_DEFINED 1 -#define XED_IFORMFL_INSERTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_INSERTPS_LAST_DEFINED 1 -#define XED_IFORMFL_INSERTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_INSERTQ_LAST_DEFINED 1 -#define XED_IFORMFL_INSW_FIRST_DEFINED 1 -#define XED_IFORMFL_INSW_LAST_DEFINED 1 -#define XED_IFORMFL_INT_FIRST_DEFINED 1 -#define XED_IFORMFL_INT_LAST_DEFINED 1 -#define XED_IFORMFL_INT1_FIRST_DEFINED 1 -#define XED_IFORMFL_INT1_LAST_DEFINED 1 -#define XED_IFORMFL_INT3_FIRST_DEFINED 1 -#define XED_IFORMFL_INT3_LAST_DEFINED 1 -#define XED_IFORMFL_INTO_FIRST_DEFINED 1 -#define XED_IFORMFL_INTO_LAST_DEFINED 1 -#define XED_IFORMFL_INVD_FIRST_DEFINED 1 -#define XED_IFORMFL_INVD_LAST_DEFINED 1 -#define XED_IFORMFL_INVEPT_FIRST_DEFINED 1 -#define XED_IFORMFL_INVEPT_LAST_DEFINED 1 -#define XED_IFORMFL_INVLPG_FIRST_DEFINED 1 -#define XED_IFORMFL_INVLPG_LAST_DEFINED 1 -#define XED_IFORMFL_INVLPGA_FIRST_DEFINED 1 -#define XED_IFORMFL_INVLPGA_LAST_DEFINED 1 -#define XED_IFORMFL_INVLPGB_FIRST_DEFINED 1 -#define XED_IFORMFL_INVLPGB_LAST_DEFINED 1 -#define XED_IFORMFL_INVPCID_FIRST_DEFINED 1 -#define XED_IFORMFL_INVPCID_LAST_DEFINED 1 -#define XED_IFORMFL_INVVPID_FIRST_DEFINED 1 -#define XED_IFORMFL_INVVPID_LAST_DEFINED 1 -#define XED_IFORMFL_IRET_FIRST_DEFINED 1 -#define XED_IFORMFL_IRET_LAST_DEFINED 1 -#define XED_IFORMFL_IRETD_FIRST_DEFINED 1 -#define XED_IFORMFL_IRETD_LAST_DEFINED 1 -#define XED_IFORMFL_IRETQ_FIRST_DEFINED 1 -#define XED_IFORMFL_IRETQ_LAST_DEFINED 1 -#define XED_IFORMFL_JB_FIRST_DEFINED 1 -#define XED_IFORMFL_JB_LAST_DEFINED 1 -#define XED_IFORMFL_JBE_FIRST_DEFINED 1 -#define XED_IFORMFL_JBE_LAST_DEFINED 1 -#define XED_IFORMFL_JCXZ_FIRST_DEFINED 1 -#define XED_IFORMFL_JCXZ_LAST_DEFINED 1 -#define XED_IFORMFL_JECXZ_FIRST_DEFINED 1 -#define XED_IFORMFL_JECXZ_LAST_DEFINED 1 -#define XED_IFORMFL_JL_FIRST_DEFINED 1 -#define XED_IFORMFL_JL_LAST_DEFINED 1 -#define XED_IFORMFL_JLE_FIRST_DEFINED 1 -#define XED_IFORMFL_JLE_LAST_DEFINED 1 -#define XED_IFORMFL_JMP_FIRST_DEFINED 1 -#define XED_IFORMFL_JMP_LAST_DEFINED 1 -#define XED_IFORMFL_JMP_FAR_FIRST_DEFINED 1 -#define XED_IFORMFL_JMP_FAR_LAST_DEFINED 1 -#define XED_IFORMFL_JNB_FIRST_DEFINED 1 -#define XED_IFORMFL_JNB_LAST_DEFINED 1 -#define XED_IFORMFL_JNBE_FIRST_DEFINED 1 -#define XED_IFORMFL_JNBE_LAST_DEFINED 1 -#define XED_IFORMFL_JNL_FIRST_DEFINED 1 -#define XED_IFORMFL_JNL_LAST_DEFINED 1 -#define XED_IFORMFL_JNLE_FIRST_DEFINED 1 -#define XED_IFORMFL_JNLE_LAST_DEFINED 1 -#define XED_IFORMFL_JNO_FIRST_DEFINED 1 -#define XED_IFORMFL_JNO_LAST_DEFINED 1 -#define XED_IFORMFL_JNP_FIRST_DEFINED 1 -#define XED_IFORMFL_JNP_LAST_DEFINED 1 -#define XED_IFORMFL_JNS_FIRST_DEFINED 1 -#define XED_IFORMFL_JNS_LAST_DEFINED 1 -#define XED_IFORMFL_JNZ_FIRST_DEFINED 1 -#define XED_IFORMFL_JNZ_LAST_DEFINED 1 -#define XED_IFORMFL_JO_FIRST_DEFINED 1 -#define XED_IFORMFL_JO_LAST_DEFINED 1 -#define XED_IFORMFL_JP_FIRST_DEFINED 1 -#define XED_IFORMFL_JP_LAST_DEFINED 1 -#define XED_IFORMFL_JRCXZ_FIRST_DEFINED 1 -#define XED_IFORMFL_JRCXZ_LAST_DEFINED 1 -#define XED_IFORMFL_JS_FIRST_DEFINED 1 -#define XED_IFORMFL_JS_LAST_DEFINED 1 -#define XED_IFORMFL_JZ_FIRST_DEFINED 1 -#define XED_IFORMFL_JZ_LAST_DEFINED 1 -#define XED_IFORMFL_KADDB_FIRST_DEFINED 1 -#define XED_IFORMFL_KADDB_LAST_DEFINED 1 -#define XED_IFORMFL_KADDD_FIRST_DEFINED 1 -#define XED_IFORMFL_KADDD_LAST_DEFINED 1 -#define XED_IFORMFL_KADDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KADDQ_LAST_DEFINED 1 -#define XED_IFORMFL_KADDW_FIRST_DEFINED 1 -#define XED_IFORMFL_KADDW_LAST_DEFINED 1 -#define XED_IFORMFL_KANDB_FIRST_DEFINED 1 -#define XED_IFORMFL_KANDB_LAST_DEFINED 1 -#define XED_IFORMFL_KANDD_FIRST_DEFINED 1 -#define XED_IFORMFL_KANDD_LAST_DEFINED 1 -#define XED_IFORMFL_KANDNB_FIRST_DEFINED 1 -#define XED_IFORMFL_KANDNB_LAST_DEFINED 1 -#define XED_IFORMFL_KANDND_FIRST_DEFINED 1 -#define XED_IFORMFL_KANDND_LAST_DEFINED 1 -#define XED_IFORMFL_KANDNQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KANDNQ_LAST_DEFINED 1 -#define XED_IFORMFL_KANDNW_FIRST_DEFINED 1 -#define XED_IFORMFL_KANDNW_LAST_DEFINED 1 -#define XED_IFORMFL_KANDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KANDQ_LAST_DEFINED 1 -#define XED_IFORMFL_KANDW_FIRST_DEFINED 1 -#define XED_IFORMFL_KANDW_LAST_DEFINED 1 -#define XED_IFORMFL_KMOVB_FIRST_DEFINED 1 -#define XED_IFORMFL_KMOVB_LAST_DEFINED 1 -#define XED_IFORMFL_KMOVD_FIRST_DEFINED 1 -#define XED_IFORMFL_KMOVD_LAST_DEFINED 1 -#define XED_IFORMFL_KMOVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KMOVQ_LAST_DEFINED 1 -#define XED_IFORMFL_KMOVW_FIRST_DEFINED 1 -#define XED_IFORMFL_KMOVW_LAST_DEFINED 1 -#define XED_IFORMFL_KNOTB_FIRST_DEFINED 1 -#define XED_IFORMFL_KNOTB_LAST_DEFINED 1 -#define XED_IFORMFL_KNOTD_FIRST_DEFINED 1 -#define XED_IFORMFL_KNOTD_LAST_DEFINED 1 -#define XED_IFORMFL_KNOTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KNOTQ_LAST_DEFINED 1 -#define XED_IFORMFL_KNOTW_FIRST_DEFINED 1 -#define XED_IFORMFL_KNOTW_LAST_DEFINED 1 -#define XED_IFORMFL_KORB_FIRST_DEFINED 1 -#define XED_IFORMFL_KORB_LAST_DEFINED 1 -#define XED_IFORMFL_KORD_FIRST_DEFINED 1 -#define XED_IFORMFL_KORD_LAST_DEFINED 1 -#define XED_IFORMFL_KORQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KORQ_LAST_DEFINED 1 -#define XED_IFORMFL_KORTESTB_FIRST_DEFINED 1 -#define XED_IFORMFL_KORTESTB_LAST_DEFINED 1 -#define XED_IFORMFL_KORTESTD_FIRST_DEFINED 1 -#define XED_IFORMFL_KORTESTD_LAST_DEFINED 1 -#define XED_IFORMFL_KORTESTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KORTESTQ_LAST_DEFINED 1 -#define XED_IFORMFL_KORTESTW_FIRST_DEFINED 1 -#define XED_IFORMFL_KORTESTW_LAST_DEFINED 1 -#define XED_IFORMFL_KORW_FIRST_DEFINED 1 -#define XED_IFORMFL_KORW_LAST_DEFINED 1 -#define XED_IFORMFL_KSHIFTLB_FIRST_DEFINED 1 -#define XED_IFORMFL_KSHIFTLB_LAST_DEFINED 1 -#define XED_IFORMFL_KSHIFTLD_FIRST_DEFINED 1 -#define XED_IFORMFL_KSHIFTLD_LAST_DEFINED 1 -#define XED_IFORMFL_KSHIFTLQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KSHIFTLQ_LAST_DEFINED 1 -#define XED_IFORMFL_KSHIFTLW_FIRST_DEFINED 1 -#define XED_IFORMFL_KSHIFTLW_LAST_DEFINED 1 -#define XED_IFORMFL_KSHIFTRB_FIRST_DEFINED 1 -#define XED_IFORMFL_KSHIFTRB_LAST_DEFINED 1 -#define XED_IFORMFL_KSHIFTRD_FIRST_DEFINED 1 -#define XED_IFORMFL_KSHIFTRD_LAST_DEFINED 1 -#define XED_IFORMFL_KSHIFTRQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KSHIFTRQ_LAST_DEFINED 1 -#define XED_IFORMFL_KSHIFTRW_FIRST_DEFINED 1 -#define XED_IFORMFL_KSHIFTRW_LAST_DEFINED 1 -#define XED_IFORMFL_KTESTB_FIRST_DEFINED 1 -#define XED_IFORMFL_KTESTB_LAST_DEFINED 1 -#define XED_IFORMFL_KTESTD_FIRST_DEFINED 1 -#define XED_IFORMFL_KTESTD_LAST_DEFINED 1 -#define XED_IFORMFL_KTESTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KTESTQ_LAST_DEFINED 1 -#define XED_IFORMFL_KTESTW_FIRST_DEFINED 1 -#define XED_IFORMFL_KTESTW_LAST_DEFINED 1 -#define XED_IFORMFL_KUNPCKBW_FIRST_DEFINED 1 -#define XED_IFORMFL_KUNPCKBW_LAST_DEFINED 1 -#define XED_IFORMFL_KUNPCKDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KUNPCKDQ_LAST_DEFINED 1 -#define XED_IFORMFL_KUNPCKWD_FIRST_DEFINED 1 -#define XED_IFORMFL_KUNPCKWD_LAST_DEFINED 1 -#define XED_IFORMFL_KXNORB_FIRST_DEFINED 1 -#define XED_IFORMFL_KXNORB_LAST_DEFINED 1 -#define XED_IFORMFL_KXNORD_FIRST_DEFINED 1 -#define XED_IFORMFL_KXNORD_LAST_DEFINED 1 -#define XED_IFORMFL_KXNORQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KXNORQ_LAST_DEFINED 1 -#define XED_IFORMFL_KXNORW_FIRST_DEFINED 1 -#define XED_IFORMFL_KXNORW_LAST_DEFINED 1 -#define XED_IFORMFL_KXORB_FIRST_DEFINED 1 -#define XED_IFORMFL_KXORB_LAST_DEFINED 1 -#define XED_IFORMFL_KXORD_FIRST_DEFINED 1 -#define XED_IFORMFL_KXORD_LAST_DEFINED 1 -#define XED_IFORMFL_KXORQ_FIRST_DEFINED 1 -#define XED_IFORMFL_KXORQ_LAST_DEFINED 1 -#define XED_IFORMFL_KXORW_FIRST_DEFINED 1 -#define XED_IFORMFL_KXORW_LAST_DEFINED 1 -#define XED_IFORMFL_LAHF_FIRST_DEFINED 1 -#define XED_IFORMFL_LAHF_LAST_DEFINED 1 -#define XED_IFORMFL_LAR_FIRST_DEFINED 1 -#define XED_IFORMFL_LAR_LAST_DEFINED 1 -#define XED_IFORMFL_LDDQU_FIRST_DEFINED 1 -#define XED_IFORMFL_LDDQU_LAST_DEFINED 1 -#define XED_IFORMFL_LDMXCSR_FIRST_DEFINED 1 -#define XED_IFORMFL_LDMXCSR_LAST_DEFINED 1 -#define XED_IFORMFL_LDS_FIRST_DEFINED 1 -#define XED_IFORMFL_LDS_LAST_DEFINED 1 -#define XED_IFORMFL_LDTILECFG_FIRST_DEFINED 1 -#define XED_IFORMFL_LDTILECFG_LAST_DEFINED 1 -#define XED_IFORMFL_LEA_FIRST_DEFINED 1 -#define XED_IFORMFL_LEA_LAST_DEFINED 1 -#define XED_IFORMFL_LEAVE_FIRST_DEFINED 1 -#define XED_IFORMFL_LEAVE_LAST_DEFINED 1 -#define XED_IFORMFL_LES_FIRST_DEFINED 1 -#define XED_IFORMFL_LES_LAST_DEFINED 1 -#define XED_IFORMFL_LFENCE_FIRST_DEFINED 1 -#define XED_IFORMFL_LFENCE_LAST_DEFINED 1 -#define XED_IFORMFL_LFS_FIRST_DEFINED 1 -#define XED_IFORMFL_LFS_LAST_DEFINED 1 -#define XED_IFORMFL_LGDT_FIRST_DEFINED 1 -#define XED_IFORMFL_LGDT_LAST_DEFINED 1 -#define XED_IFORMFL_LGS_FIRST_DEFINED 1 -#define XED_IFORMFL_LGS_LAST_DEFINED 1 -#define XED_IFORMFL_LIDT_FIRST_DEFINED 1 -#define XED_IFORMFL_LIDT_LAST_DEFINED 1 -#define XED_IFORMFL_LLDT_FIRST_DEFINED 1 -#define XED_IFORMFL_LLDT_LAST_DEFINED 1 -#define XED_IFORMFL_LLWPCB_FIRST_DEFINED 1 -#define XED_IFORMFL_LLWPCB_LAST_DEFINED 1 -#define XED_IFORMFL_LMSW_FIRST_DEFINED 1 -#define XED_IFORMFL_LMSW_LAST_DEFINED 1 -#define XED_IFORMFL_LOADIWKEY_FIRST_DEFINED 1 -#define XED_IFORMFL_LOADIWKEY_LAST_DEFINED 1 -#define XED_IFORMFL_LODSB_FIRST_DEFINED 1 -#define XED_IFORMFL_LODSB_LAST_DEFINED 1 -#define XED_IFORMFL_LODSD_FIRST_DEFINED 1 -#define XED_IFORMFL_LODSD_LAST_DEFINED 1 -#define XED_IFORMFL_LODSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_LODSQ_LAST_DEFINED 1 -#define XED_IFORMFL_LODSW_FIRST_DEFINED 1 -#define XED_IFORMFL_LODSW_LAST_DEFINED 1 -#define XED_IFORMFL_LOOP_FIRST_DEFINED 1 -#define XED_IFORMFL_LOOP_LAST_DEFINED 1 -#define XED_IFORMFL_LOOPE_FIRST_DEFINED 1 -#define XED_IFORMFL_LOOPE_LAST_DEFINED 1 -#define XED_IFORMFL_LOOPNE_FIRST_DEFINED 1 -#define XED_IFORMFL_LOOPNE_LAST_DEFINED 1 -#define XED_IFORMFL_LSL_FIRST_DEFINED 1 -#define XED_IFORMFL_LSL_LAST_DEFINED 1 -#define XED_IFORMFL_LSS_FIRST_DEFINED 1 -#define XED_IFORMFL_LSS_LAST_DEFINED 1 -#define XED_IFORMFL_LTR_FIRST_DEFINED 1 -#define XED_IFORMFL_LTR_LAST_DEFINED 1 -#define XED_IFORMFL_LWPINS_FIRST_DEFINED 1 -#define XED_IFORMFL_LWPINS_LAST_DEFINED 1 -#define XED_IFORMFL_LWPVAL_FIRST_DEFINED 1 -#define XED_IFORMFL_LWPVAL_LAST_DEFINED 1 -#define XED_IFORMFL_LZCNT_FIRST_DEFINED 1 -#define XED_IFORMFL_LZCNT_LAST_DEFINED 1 -#define XED_IFORMFL_MASKMOVDQU_FIRST_DEFINED 1 -#define XED_IFORMFL_MASKMOVDQU_LAST_DEFINED 1 -#define XED_IFORMFL_MASKMOVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_MASKMOVQ_LAST_DEFINED 1 -#define XED_IFORMFL_MAXPD_FIRST_DEFINED 1 -#define XED_IFORMFL_MAXPD_LAST_DEFINED 1 -#define XED_IFORMFL_MAXPS_FIRST_DEFINED 1 -#define XED_IFORMFL_MAXPS_LAST_DEFINED 1 -#define XED_IFORMFL_MAXSD_FIRST_DEFINED 1 -#define XED_IFORMFL_MAXSD_LAST_DEFINED 1 -#define XED_IFORMFL_MAXSS_FIRST_DEFINED 1 -#define XED_IFORMFL_MAXSS_LAST_DEFINED 1 -#define XED_IFORMFL_MCOMMIT_FIRST_DEFINED 1 -#define XED_IFORMFL_MCOMMIT_LAST_DEFINED 1 -#define XED_IFORMFL_MFENCE_FIRST_DEFINED 1 -#define XED_IFORMFL_MFENCE_LAST_DEFINED 1 -#define XED_IFORMFL_MINPD_FIRST_DEFINED 1 -#define XED_IFORMFL_MINPD_LAST_DEFINED 1 -#define XED_IFORMFL_MINPS_FIRST_DEFINED 1 -#define XED_IFORMFL_MINPS_LAST_DEFINED 1 -#define XED_IFORMFL_MINSD_FIRST_DEFINED 1 -#define XED_IFORMFL_MINSD_LAST_DEFINED 1 -#define XED_IFORMFL_MINSS_FIRST_DEFINED 1 -#define XED_IFORMFL_MINSS_LAST_DEFINED 1 -#define XED_IFORMFL_MONITOR_FIRST_DEFINED 1 -#define XED_IFORMFL_MONITOR_LAST_DEFINED 1 -#define XED_IFORMFL_MONITORX_FIRST_DEFINED 1 -#define XED_IFORMFL_MONITORX_LAST_DEFINED 1 -#define XED_IFORMFL_MOV_FIRST_DEFINED 1 -#define XED_IFORMFL_MOV_LAST_DEFINED 1 -#define XED_IFORMFL_MOVAPD_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVAPD_LAST_DEFINED 1 -#define XED_IFORMFL_MOVAPS_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVAPS_LAST_DEFINED 1 -#define XED_IFORMFL_MOVBE_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVBE_LAST_DEFINED 1 -#define XED_IFORMFL_MOVD_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVD_LAST_DEFINED 1 -#define XED_IFORMFL_MOVDDUP_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVDDUP_LAST_DEFINED 1 -#define XED_IFORMFL_MOVDIR64B_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVDIR64B_LAST_DEFINED 1 -#define XED_IFORMFL_MOVDIRI_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVDIRI_LAST_DEFINED 1 -#define XED_IFORMFL_MOVDQ2Q_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVDQ2Q_LAST_DEFINED 1 -#define XED_IFORMFL_MOVDQA_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVDQA_LAST_DEFINED 1 -#define XED_IFORMFL_MOVDQU_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVDQU_LAST_DEFINED 1 -#define XED_IFORMFL_MOVHLPS_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVHLPS_LAST_DEFINED 1 -#define XED_IFORMFL_MOVHPD_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVHPD_LAST_DEFINED 1 -#define XED_IFORMFL_MOVHPS_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVHPS_LAST_DEFINED 1 -#define XED_IFORMFL_MOVLHPS_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVLHPS_LAST_DEFINED 1 -#define XED_IFORMFL_MOVLPD_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVLPD_LAST_DEFINED 1 -#define XED_IFORMFL_MOVLPS_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVLPS_LAST_DEFINED 1 -#define XED_IFORMFL_MOVMSKPD_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVMSKPD_LAST_DEFINED 1 -#define XED_IFORMFL_MOVMSKPS_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVMSKPS_LAST_DEFINED 1 -#define XED_IFORMFL_MOVNTDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVNTDQ_LAST_DEFINED 1 -#define XED_IFORMFL_MOVNTDQA_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVNTDQA_LAST_DEFINED 1 -#define XED_IFORMFL_MOVNTI_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVNTI_LAST_DEFINED 1 -#define XED_IFORMFL_MOVNTPD_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVNTPD_LAST_DEFINED 1 -#define XED_IFORMFL_MOVNTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVNTPS_LAST_DEFINED 1 -#define XED_IFORMFL_MOVNTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVNTQ_LAST_DEFINED 1 -#define XED_IFORMFL_MOVNTSD_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVNTSD_LAST_DEFINED 1 -#define XED_IFORMFL_MOVNTSS_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVNTSS_LAST_DEFINED 1 -#define XED_IFORMFL_MOVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVQ_LAST_DEFINED 1 -#define XED_IFORMFL_MOVQ2DQ_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVQ2DQ_LAST_DEFINED 1 -#define XED_IFORMFL_MOVSB_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVSB_LAST_DEFINED 1 -#define XED_IFORMFL_MOVSD_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVSD_LAST_DEFINED 1 -#define XED_IFORMFL_MOVSD_XMM_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVSD_XMM_LAST_DEFINED 1 -#define XED_IFORMFL_MOVSHDUP_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVSHDUP_LAST_DEFINED 1 -#define XED_IFORMFL_MOVSLDUP_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVSLDUP_LAST_DEFINED 1 -#define XED_IFORMFL_MOVSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVSQ_LAST_DEFINED 1 -#define XED_IFORMFL_MOVSS_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVSS_LAST_DEFINED 1 -#define XED_IFORMFL_MOVSW_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVSW_LAST_DEFINED 1 -#define XED_IFORMFL_MOVSX_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVSX_LAST_DEFINED 1 -#define XED_IFORMFL_MOVSXD_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVSXD_LAST_DEFINED 1 -#define XED_IFORMFL_MOVUPD_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVUPD_LAST_DEFINED 1 -#define XED_IFORMFL_MOVUPS_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVUPS_LAST_DEFINED 1 -#define XED_IFORMFL_MOVZX_FIRST_DEFINED 1 -#define XED_IFORMFL_MOVZX_LAST_DEFINED 1 -#define XED_IFORMFL_MOV_CR_FIRST_DEFINED 1 -#define XED_IFORMFL_MOV_CR_LAST_DEFINED 1 -#define XED_IFORMFL_MOV_DR_FIRST_DEFINED 1 -#define XED_IFORMFL_MOV_DR_LAST_DEFINED 1 -#define XED_IFORMFL_MPSADBW_FIRST_DEFINED 1 -#define XED_IFORMFL_MPSADBW_LAST_DEFINED 1 -#define XED_IFORMFL_MUL_FIRST_DEFINED 1 -#define XED_IFORMFL_MUL_LAST_DEFINED 1 -#define XED_IFORMFL_MULPD_FIRST_DEFINED 1 -#define XED_IFORMFL_MULPD_LAST_DEFINED 1 -#define XED_IFORMFL_MULPS_FIRST_DEFINED 1 -#define XED_IFORMFL_MULPS_LAST_DEFINED 1 -#define XED_IFORMFL_MULSD_FIRST_DEFINED 1 -#define XED_IFORMFL_MULSD_LAST_DEFINED 1 -#define XED_IFORMFL_MULSS_FIRST_DEFINED 1 -#define XED_IFORMFL_MULSS_LAST_DEFINED 1 -#define XED_IFORMFL_MULX_FIRST_DEFINED 1 -#define XED_IFORMFL_MULX_LAST_DEFINED 1 -#define XED_IFORMFL_MWAIT_FIRST_DEFINED 1 -#define XED_IFORMFL_MWAIT_LAST_DEFINED 1 -#define XED_IFORMFL_MWAITX_FIRST_DEFINED 1 -#define XED_IFORMFL_MWAITX_LAST_DEFINED 1 -#define XED_IFORMFL_NEG_FIRST_DEFINED 1 -#define XED_IFORMFL_NEG_LAST_DEFINED 1 -#define XED_IFORMFL_NEG_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_NEG_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_NOP_FIRST_DEFINED 1 -#define XED_IFORMFL_NOP_LAST_DEFINED 1 -#define XED_IFORMFL_NOT_FIRST_DEFINED 1 -#define XED_IFORMFL_NOT_LAST_DEFINED 1 -#define XED_IFORMFL_NOT_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_NOT_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_OR_FIRST_DEFINED 1 -#define XED_IFORMFL_OR_LAST_DEFINED 1 -#define XED_IFORMFL_ORPD_FIRST_DEFINED 1 -#define XED_IFORMFL_ORPD_LAST_DEFINED 1 -#define XED_IFORMFL_ORPS_FIRST_DEFINED 1 -#define XED_IFORMFL_ORPS_LAST_DEFINED 1 -#define XED_IFORMFL_OR_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_OR_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_OUT_FIRST_DEFINED 1 -#define XED_IFORMFL_OUT_LAST_DEFINED 1 -#define XED_IFORMFL_OUTSB_FIRST_DEFINED 1 -#define XED_IFORMFL_OUTSB_LAST_DEFINED 1 -#define XED_IFORMFL_OUTSD_FIRST_DEFINED 1 -#define XED_IFORMFL_OUTSD_LAST_DEFINED 1 -#define XED_IFORMFL_OUTSW_FIRST_DEFINED 1 -#define XED_IFORMFL_OUTSW_LAST_DEFINED 1 -#define XED_IFORMFL_PABSB_FIRST_DEFINED 1 -#define XED_IFORMFL_PABSB_LAST_DEFINED 1 -#define XED_IFORMFL_PABSD_FIRST_DEFINED 1 -#define XED_IFORMFL_PABSD_LAST_DEFINED 1 -#define XED_IFORMFL_PABSW_FIRST_DEFINED 1 -#define XED_IFORMFL_PABSW_LAST_DEFINED 1 -#define XED_IFORMFL_PACKSSDW_FIRST_DEFINED 1 -#define XED_IFORMFL_PACKSSDW_LAST_DEFINED 1 -#define XED_IFORMFL_PACKSSWB_FIRST_DEFINED 1 -#define XED_IFORMFL_PACKSSWB_LAST_DEFINED 1 -#define XED_IFORMFL_PACKUSDW_FIRST_DEFINED 1 -#define XED_IFORMFL_PACKUSDW_LAST_DEFINED 1 -#define XED_IFORMFL_PACKUSWB_FIRST_DEFINED 1 -#define XED_IFORMFL_PACKUSWB_LAST_DEFINED 1 -#define XED_IFORMFL_PADDB_FIRST_DEFINED 1 -#define XED_IFORMFL_PADDB_LAST_DEFINED 1 -#define XED_IFORMFL_PADDD_FIRST_DEFINED 1 -#define XED_IFORMFL_PADDD_LAST_DEFINED 1 -#define XED_IFORMFL_PADDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PADDQ_LAST_DEFINED 1 -#define XED_IFORMFL_PADDSB_FIRST_DEFINED 1 -#define XED_IFORMFL_PADDSB_LAST_DEFINED 1 -#define XED_IFORMFL_PADDSW_FIRST_DEFINED 1 -#define XED_IFORMFL_PADDSW_LAST_DEFINED 1 -#define XED_IFORMFL_PADDUSB_FIRST_DEFINED 1 -#define XED_IFORMFL_PADDUSB_LAST_DEFINED 1 -#define XED_IFORMFL_PADDUSW_FIRST_DEFINED 1 -#define XED_IFORMFL_PADDUSW_LAST_DEFINED 1 -#define XED_IFORMFL_PADDW_FIRST_DEFINED 1 -#define XED_IFORMFL_PADDW_LAST_DEFINED 1 -#define XED_IFORMFL_PALIGNR_FIRST_DEFINED 1 -#define XED_IFORMFL_PALIGNR_LAST_DEFINED 1 -#define XED_IFORMFL_PAND_FIRST_DEFINED 1 -#define XED_IFORMFL_PAND_LAST_DEFINED 1 -#define XED_IFORMFL_PANDN_FIRST_DEFINED 1 -#define XED_IFORMFL_PANDN_LAST_DEFINED 1 -#define XED_IFORMFL_PAUSE_FIRST_DEFINED 1 -#define XED_IFORMFL_PAUSE_LAST_DEFINED 1 -#define XED_IFORMFL_PAVGB_FIRST_DEFINED 1 -#define XED_IFORMFL_PAVGB_LAST_DEFINED 1 -#define XED_IFORMFL_PAVGUSB_FIRST_DEFINED 1 -#define XED_IFORMFL_PAVGUSB_LAST_DEFINED 1 -#define XED_IFORMFL_PAVGW_FIRST_DEFINED 1 -#define XED_IFORMFL_PAVGW_LAST_DEFINED 1 -#define XED_IFORMFL_PBLENDVB_FIRST_DEFINED 1 -#define XED_IFORMFL_PBLENDVB_LAST_DEFINED 1 -#define XED_IFORMFL_PBLENDW_FIRST_DEFINED 1 -#define XED_IFORMFL_PBLENDW_LAST_DEFINED 1 -#define XED_IFORMFL_PCLMULQDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PCLMULQDQ_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPEQB_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPEQB_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPEQD_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPEQD_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPEQQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPEQQ_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPEQW_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPEQW_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPESTRI_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPESTRI_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPESTRI64_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPESTRI64_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPESTRM_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPESTRM_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPESTRM64_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPESTRM64_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPGTB_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPGTB_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPGTD_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPGTD_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPGTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPGTQ_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPGTW_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPGTW_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPISTRI_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPISTRI_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPISTRI64_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPISTRI64_LAST_DEFINED 1 -#define XED_IFORMFL_PCMPISTRM_FIRST_DEFINED 1 -#define XED_IFORMFL_PCMPISTRM_LAST_DEFINED 1 -#define XED_IFORMFL_PCONFIG_FIRST_DEFINED 1 -#define XED_IFORMFL_PCONFIG_LAST_DEFINED 1 -#define XED_IFORMFL_PDEP_FIRST_DEFINED 1 -#define XED_IFORMFL_PDEP_LAST_DEFINED 1 -#define XED_IFORMFL_PEXT_FIRST_DEFINED 1 -#define XED_IFORMFL_PEXT_LAST_DEFINED 1 -#define XED_IFORMFL_PEXTRB_FIRST_DEFINED 1 -#define XED_IFORMFL_PEXTRB_LAST_DEFINED 1 -#define XED_IFORMFL_PEXTRD_FIRST_DEFINED 1 -#define XED_IFORMFL_PEXTRD_LAST_DEFINED 1 -#define XED_IFORMFL_PEXTRQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PEXTRQ_LAST_DEFINED 1 -#define XED_IFORMFL_PEXTRW_FIRST_DEFINED 1 -#define XED_IFORMFL_PEXTRW_LAST_DEFINED 1 -#define XED_IFORMFL_PEXTRW_SSE4_FIRST_DEFINED 1 -#define XED_IFORMFL_PEXTRW_SSE4_LAST_DEFINED 1 -#define XED_IFORMFL_PF2ID_FIRST_DEFINED 1 -#define XED_IFORMFL_PF2ID_LAST_DEFINED 1 -#define XED_IFORMFL_PF2IW_FIRST_DEFINED 1 -#define XED_IFORMFL_PF2IW_LAST_DEFINED 1 -#define XED_IFORMFL_PFACC_FIRST_DEFINED 1 -#define XED_IFORMFL_PFACC_LAST_DEFINED 1 -#define XED_IFORMFL_PFADD_FIRST_DEFINED 1 -#define XED_IFORMFL_PFADD_LAST_DEFINED 1 -#define XED_IFORMFL_PFCMPEQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PFCMPEQ_LAST_DEFINED 1 -#define XED_IFORMFL_PFCMPGE_FIRST_DEFINED 1 -#define XED_IFORMFL_PFCMPGE_LAST_DEFINED 1 -#define XED_IFORMFL_PFCMPGT_FIRST_DEFINED 1 -#define XED_IFORMFL_PFCMPGT_LAST_DEFINED 1 -#define XED_IFORMFL_PFMAX_FIRST_DEFINED 1 -#define XED_IFORMFL_PFMAX_LAST_DEFINED 1 -#define XED_IFORMFL_PFMIN_FIRST_DEFINED 1 -#define XED_IFORMFL_PFMIN_LAST_DEFINED 1 -#define XED_IFORMFL_PFMUL_FIRST_DEFINED 1 -#define XED_IFORMFL_PFMUL_LAST_DEFINED 1 -#define XED_IFORMFL_PFNACC_FIRST_DEFINED 1 -#define XED_IFORMFL_PFNACC_LAST_DEFINED 1 -#define XED_IFORMFL_PFPNACC_FIRST_DEFINED 1 -#define XED_IFORMFL_PFPNACC_LAST_DEFINED 1 -#define XED_IFORMFL_PFRCP_FIRST_DEFINED 1 -#define XED_IFORMFL_PFRCP_LAST_DEFINED 1 -#define XED_IFORMFL_PFRCPIT1_FIRST_DEFINED 1 -#define XED_IFORMFL_PFRCPIT1_LAST_DEFINED 1 -#define XED_IFORMFL_PFRCPIT2_FIRST_DEFINED 1 -#define XED_IFORMFL_PFRCPIT2_LAST_DEFINED 1 -#define XED_IFORMFL_PFRSQIT1_FIRST_DEFINED 1 -#define XED_IFORMFL_PFRSQIT1_LAST_DEFINED 1 -#define XED_IFORMFL_PFRSQRT_FIRST_DEFINED 1 -#define XED_IFORMFL_PFRSQRT_LAST_DEFINED 1 -#define XED_IFORMFL_PFSUB_FIRST_DEFINED 1 -#define XED_IFORMFL_PFSUB_LAST_DEFINED 1 -#define XED_IFORMFL_PFSUBR_FIRST_DEFINED 1 -#define XED_IFORMFL_PFSUBR_LAST_DEFINED 1 -#define XED_IFORMFL_PHADDD_FIRST_DEFINED 1 -#define XED_IFORMFL_PHADDD_LAST_DEFINED 1 -#define XED_IFORMFL_PHADDSW_FIRST_DEFINED 1 -#define XED_IFORMFL_PHADDSW_LAST_DEFINED 1 -#define XED_IFORMFL_PHADDW_FIRST_DEFINED 1 -#define XED_IFORMFL_PHADDW_LAST_DEFINED 1 -#define XED_IFORMFL_PHMINPOSUW_FIRST_DEFINED 1 -#define XED_IFORMFL_PHMINPOSUW_LAST_DEFINED 1 -#define XED_IFORMFL_PHSUBD_FIRST_DEFINED 1 -#define XED_IFORMFL_PHSUBD_LAST_DEFINED 1 -#define XED_IFORMFL_PHSUBSW_FIRST_DEFINED 1 -#define XED_IFORMFL_PHSUBSW_LAST_DEFINED 1 -#define XED_IFORMFL_PHSUBW_FIRST_DEFINED 1 -#define XED_IFORMFL_PHSUBW_LAST_DEFINED 1 -#define XED_IFORMFL_PI2FD_FIRST_DEFINED 1 -#define XED_IFORMFL_PI2FD_LAST_DEFINED 1 -#define XED_IFORMFL_PI2FW_FIRST_DEFINED 1 -#define XED_IFORMFL_PI2FW_LAST_DEFINED 1 -#define XED_IFORMFL_PINSRB_FIRST_DEFINED 1 -#define XED_IFORMFL_PINSRB_LAST_DEFINED 1 -#define XED_IFORMFL_PINSRD_FIRST_DEFINED 1 -#define XED_IFORMFL_PINSRD_LAST_DEFINED 1 -#define XED_IFORMFL_PINSRQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PINSRQ_LAST_DEFINED 1 -#define XED_IFORMFL_PINSRW_FIRST_DEFINED 1 -#define XED_IFORMFL_PINSRW_LAST_DEFINED 1 -#define XED_IFORMFL_PMADDUBSW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMADDUBSW_LAST_DEFINED 1 -#define XED_IFORMFL_PMADDWD_FIRST_DEFINED 1 -#define XED_IFORMFL_PMADDWD_LAST_DEFINED 1 -#define XED_IFORMFL_PMAXSB_FIRST_DEFINED 1 -#define XED_IFORMFL_PMAXSB_LAST_DEFINED 1 -#define XED_IFORMFL_PMAXSD_FIRST_DEFINED 1 -#define XED_IFORMFL_PMAXSD_LAST_DEFINED 1 -#define XED_IFORMFL_PMAXSW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMAXSW_LAST_DEFINED 1 -#define XED_IFORMFL_PMAXUB_FIRST_DEFINED 1 -#define XED_IFORMFL_PMAXUB_LAST_DEFINED 1 -#define XED_IFORMFL_PMAXUD_FIRST_DEFINED 1 -#define XED_IFORMFL_PMAXUD_LAST_DEFINED 1 -#define XED_IFORMFL_PMAXUW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMAXUW_LAST_DEFINED 1 -#define XED_IFORMFL_PMINSB_FIRST_DEFINED 1 -#define XED_IFORMFL_PMINSB_LAST_DEFINED 1 -#define XED_IFORMFL_PMINSD_FIRST_DEFINED 1 -#define XED_IFORMFL_PMINSD_LAST_DEFINED 1 -#define XED_IFORMFL_PMINSW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMINSW_LAST_DEFINED 1 -#define XED_IFORMFL_PMINUB_FIRST_DEFINED 1 -#define XED_IFORMFL_PMINUB_LAST_DEFINED 1 -#define XED_IFORMFL_PMINUD_FIRST_DEFINED 1 -#define XED_IFORMFL_PMINUD_LAST_DEFINED 1 -#define XED_IFORMFL_PMINUW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMINUW_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVMSKB_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVMSKB_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVSXBD_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVSXBD_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVSXBQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVSXBQ_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVSXBW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVSXBW_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVSXDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVSXDQ_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVSXWD_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVSXWD_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVSXWQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVSXWQ_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVZXBD_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVZXBD_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVZXBQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVZXBQ_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVZXBW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVZXBW_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVZXDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVZXDQ_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVZXWD_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVZXWD_LAST_DEFINED 1 -#define XED_IFORMFL_PMOVZXWQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PMOVZXWQ_LAST_DEFINED 1 -#define XED_IFORMFL_PMULDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PMULDQ_LAST_DEFINED 1 -#define XED_IFORMFL_PMULHRSW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMULHRSW_LAST_DEFINED 1 -#define XED_IFORMFL_PMULHRW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMULHRW_LAST_DEFINED 1 -#define XED_IFORMFL_PMULHUW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMULHUW_LAST_DEFINED 1 -#define XED_IFORMFL_PMULHW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMULHW_LAST_DEFINED 1 -#define XED_IFORMFL_PMULLD_FIRST_DEFINED 1 -#define XED_IFORMFL_PMULLD_LAST_DEFINED 1 -#define XED_IFORMFL_PMULLW_FIRST_DEFINED 1 -#define XED_IFORMFL_PMULLW_LAST_DEFINED 1 -#define XED_IFORMFL_PMULUDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PMULUDQ_LAST_DEFINED 1 -#define XED_IFORMFL_POP_FIRST_DEFINED 1 -#define XED_IFORMFL_POP_LAST_DEFINED 1 -#define XED_IFORMFL_POPA_FIRST_DEFINED 1 -#define XED_IFORMFL_POPA_LAST_DEFINED 1 -#define XED_IFORMFL_POPAD_FIRST_DEFINED 1 -#define XED_IFORMFL_POPAD_LAST_DEFINED 1 -#define XED_IFORMFL_POPCNT_FIRST_DEFINED 1 -#define XED_IFORMFL_POPCNT_LAST_DEFINED 1 -#define XED_IFORMFL_POPF_FIRST_DEFINED 1 -#define XED_IFORMFL_POPF_LAST_DEFINED 1 -#define XED_IFORMFL_POPFD_FIRST_DEFINED 1 -#define XED_IFORMFL_POPFD_LAST_DEFINED 1 -#define XED_IFORMFL_POPFQ_FIRST_DEFINED 1 -#define XED_IFORMFL_POPFQ_LAST_DEFINED 1 -#define XED_IFORMFL_POR_FIRST_DEFINED 1 -#define XED_IFORMFL_POR_LAST_DEFINED 1 -#define XED_IFORMFL_PREFETCHNTA_FIRST_DEFINED 1 -#define XED_IFORMFL_PREFETCHNTA_LAST_DEFINED 1 -#define XED_IFORMFL_PREFETCHT0_FIRST_DEFINED 1 -#define XED_IFORMFL_PREFETCHT0_LAST_DEFINED 1 -#define XED_IFORMFL_PREFETCHT1_FIRST_DEFINED 1 -#define XED_IFORMFL_PREFETCHT1_LAST_DEFINED 1 -#define XED_IFORMFL_PREFETCHT2_FIRST_DEFINED 1 -#define XED_IFORMFL_PREFETCHT2_LAST_DEFINED 1 -#define XED_IFORMFL_PREFETCHW_FIRST_DEFINED 1 -#define XED_IFORMFL_PREFETCHW_LAST_DEFINED 1 -#define XED_IFORMFL_PREFETCHWT1_FIRST_DEFINED 1 -#define XED_IFORMFL_PREFETCHWT1_LAST_DEFINED 1 -#define XED_IFORMFL_PREFETCH_EXCLUSIVE_FIRST_DEFINED 1 -#define XED_IFORMFL_PREFETCH_EXCLUSIVE_LAST_DEFINED 1 -#define XED_IFORMFL_PREFETCH_RESERVED_FIRST_DEFINED 1 -#define XED_IFORMFL_PREFETCH_RESERVED_LAST_DEFINED 1 -#define XED_IFORMFL_PSADBW_FIRST_DEFINED 1 -#define XED_IFORMFL_PSADBW_LAST_DEFINED 1 -#define XED_IFORMFL_PSHUFB_FIRST_DEFINED 1 -#define XED_IFORMFL_PSHUFB_LAST_DEFINED 1 -#define XED_IFORMFL_PSHUFD_FIRST_DEFINED 1 -#define XED_IFORMFL_PSHUFD_LAST_DEFINED 1 -#define XED_IFORMFL_PSHUFHW_FIRST_DEFINED 1 -#define XED_IFORMFL_PSHUFHW_LAST_DEFINED 1 -#define XED_IFORMFL_PSHUFLW_FIRST_DEFINED 1 -#define XED_IFORMFL_PSHUFLW_LAST_DEFINED 1 -#define XED_IFORMFL_PSHUFW_FIRST_DEFINED 1 -#define XED_IFORMFL_PSHUFW_LAST_DEFINED 1 -#define XED_IFORMFL_PSIGNB_FIRST_DEFINED 1 -#define XED_IFORMFL_PSIGNB_LAST_DEFINED 1 -#define XED_IFORMFL_PSIGND_FIRST_DEFINED 1 -#define XED_IFORMFL_PSIGND_LAST_DEFINED 1 -#define XED_IFORMFL_PSIGNW_FIRST_DEFINED 1 -#define XED_IFORMFL_PSIGNW_LAST_DEFINED 1 -#define XED_IFORMFL_PSLLD_FIRST_DEFINED 1 -#define XED_IFORMFL_PSLLD_LAST_DEFINED 1 -#define XED_IFORMFL_PSLLDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PSLLDQ_LAST_DEFINED 1 -#define XED_IFORMFL_PSLLQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PSLLQ_LAST_DEFINED 1 -#define XED_IFORMFL_PSLLW_FIRST_DEFINED 1 -#define XED_IFORMFL_PSLLW_LAST_DEFINED 1 -#define XED_IFORMFL_PSMASH_FIRST_DEFINED 1 -#define XED_IFORMFL_PSMASH_LAST_DEFINED 1 -#define XED_IFORMFL_PSRAD_FIRST_DEFINED 1 -#define XED_IFORMFL_PSRAD_LAST_DEFINED 1 -#define XED_IFORMFL_PSRAW_FIRST_DEFINED 1 -#define XED_IFORMFL_PSRAW_LAST_DEFINED 1 -#define XED_IFORMFL_PSRLD_FIRST_DEFINED 1 -#define XED_IFORMFL_PSRLD_LAST_DEFINED 1 -#define XED_IFORMFL_PSRLDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PSRLDQ_LAST_DEFINED 1 -#define XED_IFORMFL_PSRLQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PSRLQ_LAST_DEFINED 1 -#define XED_IFORMFL_PSRLW_FIRST_DEFINED 1 -#define XED_IFORMFL_PSRLW_LAST_DEFINED 1 -#define XED_IFORMFL_PSUBB_FIRST_DEFINED 1 -#define XED_IFORMFL_PSUBB_LAST_DEFINED 1 -#define XED_IFORMFL_PSUBD_FIRST_DEFINED 1 -#define XED_IFORMFL_PSUBD_LAST_DEFINED 1 -#define XED_IFORMFL_PSUBQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PSUBQ_LAST_DEFINED 1 -#define XED_IFORMFL_PSUBSB_FIRST_DEFINED 1 -#define XED_IFORMFL_PSUBSB_LAST_DEFINED 1 -#define XED_IFORMFL_PSUBSW_FIRST_DEFINED 1 -#define XED_IFORMFL_PSUBSW_LAST_DEFINED 1 -#define XED_IFORMFL_PSUBUSB_FIRST_DEFINED 1 -#define XED_IFORMFL_PSUBUSB_LAST_DEFINED 1 -#define XED_IFORMFL_PSUBUSW_FIRST_DEFINED 1 -#define XED_IFORMFL_PSUBUSW_LAST_DEFINED 1 -#define XED_IFORMFL_PSUBW_FIRST_DEFINED 1 -#define XED_IFORMFL_PSUBW_LAST_DEFINED 1 -#define XED_IFORMFL_PSWAPD_FIRST_DEFINED 1 -#define XED_IFORMFL_PSWAPD_LAST_DEFINED 1 -#define XED_IFORMFL_PTEST_FIRST_DEFINED 1 -#define XED_IFORMFL_PTEST_LAST_DEFINED 1 -#define XED_IFORMFL_PTWRITE_FIRST_DEFINED 1 -#define XED_IFORMFL_PTWRITE_LAST_DEFINED 1 -#define XED_IFORMFL_PUNPCKHBW_FIRST_DEFINED 1 -#define XED_IFORMFL_PUNPCKHBW_LAST_DEFINED 1 -#define XED_IFORMFL_PUNPCKHDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PUNPCKHDQ_LAST_DEFINED 1 -#define XED_IFORMFL_PUNPCKHQDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PUNPCKHQDQ_LAST_DEFINED 1 -#define XED_IFORMFL_PUNPCKHWD_FIRST_DEFINED 1 -#define XED_IFORMFL_PUNPCKHWD_LAST_DEFINED 1 -#define XED_IFORMFL_PUNPCKLBW_FIRST_DEFINED 1 -#define XED_IFORMFL_PUNPCKLBW_LAST_DEFINED 1 -#define XED_IFORMFL_PUNPCKLDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PUNPCKLDQ_LAST_DEFINED 1 -#define XED_IFORMFL_PUNPCKLQDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PUNPCKLQDQ_LAST_DEFINED 1 -#define XED_IFORMFL_PUNPCKLWD_FIRST_DEFINED 1 -#define XED_IFORMFL_PUNPCKLWD_LAST_DEFINED 1 -#define XED_IFORMFL_PUSH_FIRST_DEFINED 1 -#define XED_IFORMFL_PUSH_LAST_DEFINED 1 -#define XED_IFORMFL_PUSHA_FIRST_DEFINED 1 -#define XED_IFORMFL_PUSHA_LAST_DEFINED 1 -#define XED_IFORMFL_PUSHAD_FIRST_DEFINED 1 -#define XED_IFORMFL_PUSHAD_LAST_DEFINED 1 -#define XED_IFORMFL_PUSHF_FIRST_DEFINED 1 -#define XED_IFORMFL_PUSHF_LAST_DEFINED 1 -#define XED_IFORMFL_PUSHFD_FIRST_DEFINED 1 -#define XED_IFORMFL_PUSHFD_LAST_DEFINED 1 -#define XED_IFORMFL_PUSHFQ_FIRST_DEFINED 1 -#define XED_IFORMFL_PUSHFQ_LAST_DEFINED 1 -#define XED_IFORMFL_PVALIDATE_FIRST_DEFINED 1 -#define XED_IFORMFL_PVALIDATE_LAST_DEFINED 1 -#define XED_IFORMFL_PXOR_FIRST_DEFINED 1 -#define XED_IFORMFL_PXOR_LAST_DEFINED 1 -#define XED_IFORMFL_RCL_FIRST_DEFINED 1 -#define XED_IFORMFL_RCL_LAST_DEFINED 1 -#define XED_IFORMFL_RCPPS_FIRST_DEFINED 1 -#define XED_IFORMFL_RCPPS_LAST_DEFINED 1 -#define XED_IFORMFL_RCPSS_FIRST_DEFINED 1 -#define XED_IFORMFL_RCPSS_LAST_DEFINED 1 -#define XED_IFORMFL_RCR_FIRST_DEFINED 1 -#define XED_IFORMFL_RCR_LAST_DEFINED 1 -#define XED_IFORMFL_RDFSBASE_FIRST_DEFINED 1 -#define XED_IFORMFL_RDFSBASE_LAST_DEFINED 1 -#define XED_IFORMFL_RDGSBASE_FIRST_DEFINED 1 -#define XED_IFORMFL_RDGSBASE_LAST_DEFINED 1 -#define XED_IFORMFL_RDMSR_FIRST_DEFINED 1 -#define XED_IFORMFL_RDMSR_LAST_DEFINED 1 -#define XED_IFORMFL_RDPID_FIRST_DEFINED 1 -#define XED_IFORMFL_RDPID_LAST_DEFINED 1 -#define XED_IFORMFL_RDPKRU_FIRST_DEFINED 1 -#define XED_IFORMFL_RDPKRU_LAST_DEFINED 1 -#define XED_IFORMFL_RDPMC_FIRST_DEFINED 1 -#define XED_IFORMFL_RDPMC_LAST_DEFINED 1 -#define XED_IFORMFL_RDPRU_FIRST_DEFINED 1 -#define XED_IFORMFL_RDPRU_LAST_DEFINED 1 -#define XED_IFORMFL_RDRAND_FIRST_DEFINED 1 -#define XED_IFORMFL_RDRAND_LAST_DEFINED 1 -#define XED_IFORMFL_RDSEED_FIRST_DEFINED 1 -#define XED_IFORMFL_RDSEED_LAST_DEFINED 1 -#define XED_IFORMFL_RDSSPD_FIRST_DEFINED 1 -#define XED_IFORMFL_RDSSPD_LAST_DEFINED 1 -#define XED_IFORMFL_RDSSPQ_FIRST_DEFINED 1 -#define XED_IFORMFL_RDSSPQ_LAST_DEFINED 1 -#define XED_IFORMFL_RDTSC_FIRST_DEFINED 1 -#define XED_IFORMFL_RDTSC_LAST_DEFINED 1 -#define XED_IFORMFL_RDTSCP_FIRST_DEFINED 1 -#define XED_IFORMFL_RDTSCP_LAST_DEFINED 1 -#define XED_IFORMFL_REPE_CMPSB_FIRST_DEFINED 1 -#define XED_IFORMFL_REPE_CMPSB_LAST_DEFINED 1 -#define XED_IFORMFL_REPE_CMPSD_FIRST_DEFINED 1 -#define XED_IFORMFL_REPE_CMPSD_LAST_DEFINED 1 -#define XED_IFORMFL_REPE_CMPSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_REPE_CMPSQ_LAST_DEFINED 1 -#define XED_IFORMFL_REPE_CMPSW_FIRST_DEFINED 1 -#define XED_IFORMFL_REPE_CMPSW_LAST_DEFINED 1 -#define XED_IFORMFL_REPE_SCASB_FIRST_DEFINED 1 -#define XED_IFORMFL_REPE_SCASB_LAST_DEFINED 1 -#define XED_IFORMFL_REPE_SCASD_FIRST_DEFINED 1 -#define XED_IFORMFL_REPE_SCASD_LAST_DEFINED 1 -#define XED_IFORMFL_REPE_SCASQ_FIRST_DEFINED 1 -#define XED_IFORMFL_REPE_SCASQ_LAST_DEFINED 1 -#define XED_IFORMFL_REPE_SCASW_FIRST_DEFINED 1 -#define XED_IFORMFL_REPE_SCASW_LAST_DEFINED 1 -#define XED_IFORMFL_REPNE_CMPSB_FIRST_DEFINED 1 -#define XED_IFORMFL_REPNE_CMPSB_LAST_DEFINED 1 -#define XED_IFORMFL_REPNE_CMPSD_FIRST_DEFINED 1 -#define XED_IFORMFL_REPNE_CMPSD_LAST_DEFINED 1 -#define XED_IFORMFL_REPNE_CMPSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_REPNE_CMPSQ_LAST_DEFINED 1 -#define XED_IFORMFL_REPNE_CMPSW_FIRST_DEFINED 1 -#define XED_IFORMFL_REPNE_CMPSW_LAST_DEFINED 1 -#define XED_IFORMFL_REPNE_SCASB_FIRST_DEFINED 1 -#define XED_IFORMFL_REPNE_SCASB_LAST_DEFINED 1 -#define XED_IFORMFL_REPNE_SCASD_FIRST_DEFINED 1 -#define XED_IFORMFL_REPNE_SCASD_LAST_DEFINED 1 -#define XED_IFORMFL_REPNE_SCASQ_FIRST_DEFINED 1 -#define XED_IFORMFL_REPNE_SCASQ_LAST_DEFINED 1 -#define XED_IFORMFL_REPNE_SCASW_FIRST_DEFINED 1 -#define XED_IFORMFL_REPNE_SCASW_LAST_DEFINED 1 -#define XED_IFORMFL_REP_INSB_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_INSB_LAST_DEFINED 1 -#define XED_IFORMFL_REP_INSD_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_INSD_LAST_DEFINED 1 -#define XED_IFORMFL_REP_INSW_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_INSW_LAST_DEFINED 1 -#define XED_IFORMFL_REP_LODSB_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_LODSB_LAST_DEFINED 1 -#define XED_IFORMFL_REP_LODSD_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_LODSD_LAST_DEFINED 1 -#define XED_IFORMFL_REP_LODSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_LODSQ_LAST_DEFINED 1 -#define XED_IFORMFL_REP_LODSW_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_LODSW_LAST_DEFINED 1 -#define XED_IFORMFL_REP_MONTMUL_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_MONTMUL_LAST_DEFINED 1 -#define XED_IFORMFL_REP_MOVSB_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_MOVSB_LAST_DEFINED 1 -#define XED_IFORMFL_REP_MOVSD_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_MOVSD_LAST_DEFINED 1 -#define XED_IFORMFL_REP_MOVSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_MOVSQ_LAST_DEFINED 1 -#define XED_IFORMFL_REP_MOVSW_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_MOVSW_LAST_DEFINED 1 -#define XED_IFORMFL_REP_OUTSB_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_OUTSB_LAST_DEFINED 1 -#define XED_IFORMFL_REP_OUTSD_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_OUTSD_LAST_DEFINED 1 -#define XED_IFORMFL_REP_OUTSW_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_OUTSW_LAST_DEFINED 1 -#define XED_IFORMFL_REP_STOSB_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_STOSB_LAST_DEFINED 1 -#define XED_IFORMFL_REP_STOSD_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_STOSD_LAST_DEFINED 1 -#define XED_IFORMFL_REP_STOSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_STOSQ_LAST_DEFINED 1 -#define XED_IFORMFL_REP_STOSW_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_STOSW_LAST_DEFINED 1 -#define XED_IFORMFL_REP_XCRYPTCBC_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_XCRYPTCBC_LAST_DEFINED 1 -#define XED_IFORMFL_REP_XCRYPTCFB_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_XCRYPTCFB_LAST_DEFINED 1 -#define XED_IFORMFL_REP_XCRYPTCTR_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_XCRYPTCTR_LAST_DEFINED 1 -#define XED_IFORMFL_REP_XCRYPTECB_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_XCRYPTECB_LAST_DEFINED 1 -#define XED_IFORMFL_REP_XCRYPTOFB_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_XCRYPTOFB_LAST_DEFINED 1 -#define XED_IFORMFL_REP_XSHA1_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_XSHA1_LAST_DEFINED 1 -#define XED_IFORMFL_REP_XSHA256_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_XSHA256_LAST_DEFINED 1 -#define XED_IFORMFL_REP_XSTORE_FIRST_DEFINED 1 -#define XED_IFORMFL_REP_XSTORE_LAST_DEFINED 1 -#define XED_IFORMFL_RET_FAR_FIRST_DEFINED 1 -#define XED_IFORMFL_RET_FAR_LAST_DEFINED 1 -#define XED_IFORMFL_RET_NEAR_FIRST_DEFINED 1 -#define XED_IFORMFL_RET_NEAR_LAST_DEFINED 1 -#define XED_IFORMFL_RMPADJUST_FIRST_DEFINED 1 -#define XED_IFORMFL_RMPADJUST_LAST_DEFINED 1 -#define XED_IFORMFL_RMPUPDATE_FIRST_DEFINED 1 -#define XED_IFORMFL_RMPUPDATE_LAST_DEFINED 1 -#define XED_IFORMFL_ROL_FIRST_DEFINED 1 -#define XED_IFORMFL_ROL_LAST_DEFINED 1 -#define XED_IFORMFL_ROR_FIRST_DEFINED 1 -#define XED_IFORMFL_ROR_LAST_DEFINED 1 -#define XED_IFORMFL_RORX_FIRST_DEFINED 1 -#define XED_IFORMFL_RORX_LAST_DEFINED 1 -#define XED_IFORMFL_ROUNDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_ROUNDPD_LAST_DEFINED 1 -#define XED_IFORMFL_ROUNDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_ROUNDPS_LAST_DEFINED 1 -#define XED_IFORMFL_ROUNDSD_FIRST_DEFINED 1 -#define XED_IFORMFL_ROUNDSD_LAST_DEFINED 1 -#define XED_IFORMFL_ROUNDSS_FIRST_DEFINED 1 -#define XED_IFORMFL_ROUNDSS_LAST_DEFINED 1 -#define XED_IFORMFL_RSM_FIRST_DEFINED 1 -#define XED_IFORMFL_RSM_LAST_DEFINED 1 -#define XED_IFORMFL_RSQRTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_RSQRTPS_LAST_DEFINED 1 -#define XED_IFORMFL_RSQRTSS_FIRST_DEFINED 1 -#define XED_IFORMFL_RSQRTSS_LAST_DEFINED 1 -#define XED_IFORMFL_RSTORSSP_FIRST_DEFINED 1 -#define XED_IFORMFL_RSTORSSP_LAST_DEFINED 1 -#define XED_IFORMFL_SAHF_FIRST_DEFINED 1 -#define XED_IFORMFL_SAHF_LAST_DEFINED 1 -#define XED_IFORMFL_SALC_FIRST_DEFINED 1 -#define XED_IFORMFL_SALC_LAST_DEFINED 1 -#define XED_IFORMFL_SAR_FIRST_DEFINED 1 -#define XED_IFORMFL_SAR_LAST_DEFINED 1 -#define XED_IFORMFL_SARX_FIRST_DEFINED 1 -#define XED_IFORMFL_SARX_LAST_DEFINED 1 -#define XED_IFORMFL_SAVEPREVSSP_FIRST_DEFINED 1 -#define XED_IFORMFL_SAVEPREVSSP_LAST_DEFINED 1 -#define XED_IFORMFL_SBB_FIRST_DEFINED 1 -#define XED_IFORMFL_SBB_LAST_DEFINED 1 -#define XED_IFORMFL_SBB_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_SBB_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_SCASB_FIRST_DEFINED 1 -#define XED_IFORMFL_SCASB_LAST_DEFINED 1 -#define XED_IFORMFL_SCASD_FIRST_DEFINED 1 -#define XED_IFORMFL_SCASD_LAST_DEFINED 1 -#define XED_IFORMFL_SCASQ_FIRST_DEFINED 1 -#define XED_IFORMFL_SCASQ_LAST_DEFINED 1 -#define XED_IFORMFL_SCASW_FIRST_DEFINED 1 -#define XED_IFORMFL_SCASW_LAST_DEFINED 1 -#define XED_IFORMFL_SEAMCALL_FIRST_DEFINED 1 -#define XED_IFORMFL_SEAMCALL_LAST_DEFINED 1 -#define XED_IFORMFL_SEAMOPS_FIRST_DEFINED 1 -#define XED_IFORMFL_SEAMOPS_LAST_DEFINED 1 -#define XED_IFORMFL_SEAMRET_FIRST_DEFINED 1 -#define XED_IFORMFL_SEAMRET_LAST_DEFINED 1 -#define XED_IFORMFL_SENDUIPI_FIRST_DEFINED 1 -#define XED_IFORMFL_SENDUIPI_LAST_DEFINED 1 -#define XED_IFORMFL_SERIALIZE_FIRST_DEFINED 1 -#define XED_IFORMFL_SERIALIZE_LAST_DEFINED 1 -#define XED_IFORMFL_SETB_FIRST_DEFINED 1 -#define XED_IFORMFL_SETB_LAST_DEFINED 1 -#define XED_IFORMFL_SETBE_FIRST_DEFINED 1 -#define XED_IFORMFL_SETBE_LAST_DEFINED 1 -#define XED_IFORMFL_SETL_FIRST_DEFINED 1 -#define XED_IFORMFL_SETL_LAST_DEFINED 1 -#define XED_IFORMFL_SETLE_FIRST_DEFINED 1 -#define XED_IFORMFL_SETLE_LAST_DEFINED 1 -#define XED_IFORMFL_SETNB_FIRST_DEFINED 1 -#define XED_IFORMFL_SETNB_LAST_DEFINED 1 -#define XED_IFORMFL_SETNBE_FIRST_DEFINED 1 -#define XED_IFORMFL_SETNBE_LAST_DEFINED 1 -#define XED_IFORMFL_SETNL_FIRST_DEFINED 1 -#define XED_IFORMFL_SETNL_LAST_DEFINED 1 -#define XED_IFORMFL_SETNLE_FIRST_DEFINED 1 -#define XED_IFORMFL_SETNLE_LAST_DEFINED 1 -#define XED_IFORMFL_SETNO_FIRST_DEFINED 1 -#define XED_IFORMFL_SETNO_LAST_DEFINED 1 -#define XED_IFORMFL_SETNP_FIRST_DEFINED 1 -#define XED_IFORMFL_SETNP_LAST_DEFINED 1 -#define XED_IFORMFL_SETNS_FIRST_DEFINED 1 -#define XED_IFORMFL_SETNS_LAST_DEFINED 1 -#define XED_IFORMFL_SETNZ_FIRST_DEFINED 1 -#define XED_IFORMFL_SETNZ_LAST_DEFINED 1 -#define XED_IFORMFL_SETO_FIRST_DEFINED 1 -#define XED_IFORMFL_SETO_LAST_DEFINED 1 -#define XED_IFORMFL_SETP_FIRST_DEFINED 1 -#define XED_IFORMFL_SETP_LAST_DEFINED 1 -#define XED_IFORMFL_SETS_FIRST_DEFINED 1 -#define XED_IFORMFL_SETS_LAST_DEFINED 1 -#define XED_IFORMFL_SETSSBSY_FIRST_DEFINED 1 -#define XED_IFORMFL_SETSSBSY_LAST_DEFINED 1 -#define XED_IFORMFL_SETZ_FIRST_DEFINED 1 -#define XED_IFORMFL_SETZ_LAST_DEFINED 1 -#define XED_IFORMFL_SFENCE_FIRST_DEFINED 1 -#define XED_IFORMFL_SFENCE_LAST_DEFINED 1 -#define XED_IFORMFL_SGDT_FIRST_DEFINED 1 -#define XED_IFORMFL_SGDT_LAST_DEFINED 1 -#define XED_IFORMFL_SHA1MSG1_FIRST_DEFINED 1 -#define XED_IFORMFL_SHA1MSG1_LAST_DEFINED 1 -#define XED_IFORMFL_SHA1MSG2_FIRST_DEFINED 1 -#define XED_IFORMFL_SHA1MSG2_LAST_DEFINED 1 -#define XED_IFORMFL_SHA1NEXTE_FIRST_DEFINED 1 -#define XED_IFORMFL_SHA1NEXTE_LAST_DEFINED 1 -#define XED_IFORMFL_SHA1RNDS4_FIRST_DEFINED 1 -#define XED_IFORMFL_SHA1RNDS4_LAST_DEFINED 1 -#define XED_IFORMFL_SHA256MSG1_FIRST_DEFINED 1 -#define XED_IFORMFL_SHA256MSG1_LAST_DEFINED 1 -#define XED_IFORMFL_SHA256MSG2_FIRST_DEFINED 1 -#define XED_IFORMFL_SHA256MSG2_LAST_DEFINED 1 -#define XED_IFORMFL_SHA256RNDS2_FIRST_DEFINED 1 -#define XED_IFORMFL_SHA256RNDS2_LAST_DEFINED 1 -#define XED_IFORMFL_SHL_FIRST_DEFINED 1 -#define XED_IFORMFL_SHL_LAST_DEFINED 1 -#define XED_IFORMFL_SHLD_FIRST_DEFINED 1 -#define XED_IFORMFL_SHLD_LAST_DEFINED 1 -#define XED_IFORMFL_SHLX_FIRST_DEFINED 1 -#define XED_IFORMFL_SHLX_LAST_DEFINED 1 -#define XED_IFORMFL_SHR_FIRST_DEFINED 1 -#define XED_IFORMFL_SHR_LAST_DEFINED 1 -#define XED_IFORMFL_SHRD_FIRST_DEFINED 1 -#define XED_IFORMFL_SHRD_LAST_DEFINED 1 -#define XED_IFORMFL_SHRX_FIRST_DEFINED 1 -#define XED_IFORMFL_SHRX_LAST_DEFINED 1 -#define XED_IFORMFL_SHUFPD_FIRST_DEFINED 1 -#define XED_IFORMFL_SHUFPD_LAST_DEFINED 1 -#define XED_IFORMFL_SHUFPS_FIRST_DEFINED 1 -#define XED_IFORMFL_SHUFPS_LAST_DEFINED 1 -#define XED_IFORMFL_SIDT_FIRST_DEFINED 1 -#define XED_IFORMFL_SIDT_LAST_DEFINED 1 -#define XED_IFORMFL_SKINIT_FIRST_DEFINED 1 -#define XED_IFORMFL_SKINIT_LAST_DEFINED 1 -#define XED_IFORMFL_SLDT_FIRST_DEFINED 1 -#define XED_IFORMFL_SLDT_LAST_DEFINED 1 -#define XED_IFORMFL_SLWPCB_FIRST_DEFINED 1 -#define XED_IFORMFL_SLWPCB_LAST_DEFINED 1 -#define XED_IFORMFL_SMSW_FIRST_DEFINED 1 -#define XED_IFORMFL_SMSW_LAST_DEFINED 1 -#define XED_IFORMFL_SQRTPD_FIRST_DEFINED 1 -#define XED_IFORMFL_SQRTPD_LAST_DEFINED 1 -#define XED_IFORMFL_SQRTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_SQRTPS_LAST_DEFINED 1 -#define XED_IFORMFL_SQRTSD_FIRST_DEFINED 1 -#define XED_IFORMFL_SQRTSD_LAST_DEFINED 1 -#define XED_IFORMFL_SQRTSS_FIRST_DEFINED 1 -#define XED_IFORMFL_SQRTSS_LAST_DEFINED 1 -#define XED_IFORMFL_STAC_FIRST_DEFINED 1 -#define XED_IFORMFL_STAC_LAST_DEFINED 1 -#define XED_IFORMFL_STC_FIRST_DEFINED 1 -#define XED_IFORMFL_STC_LAST_DEFINED 1 -#define XED_IFORMFL_STD_FIRST_DEFINED 1 -#define XED_IFORMFL_STD_LAST_DEFINED 1 -#define XED_IFORMFL_STGI_FIRST_DEFINED 1 -#define XED_IFORMFL_STGI_LAST_DEFINED 1 -#define XED_IFORMFL_STI_FIRST_DEFINED 1 -#define XED_IFORMFL_STI_LAST_DEFINED 1 -#define XED_IFORMFL_STMXCSR_FIRST_DEFINED 1 -#define XED_IFORMFL_STMXCSR_LAST_DEFINED 1 -#define XED_IFORMFL_STOSB_FIRST_DEFINED 1 -#define XED_IFORMFL_STOSB_LAST_DEFINED 1 -#define XED_IFORMFL_STOSD_FIRST_DEFINED 1 -#define XED_IFORMFL_STOSD_LAST_DEFINED 1 -#define XED_IFORMFL_STOSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_STOSQ_LAST_DEFINED 1 -#define XED_IFORMFL_STOSW_FIRST_DEFINED 1 -#define XED_IFORMFL_STOSW_LAST_DEFINED 1 -#define XED_IFORMFL_STR_FIRST_DEFINED 1 -#define XED_IFORMFL_STR_LAST_DEFINED 1 -#define XED_IFORMFL_STTILECFG_FIRST_DEFINED 1 -#define XED_IFORMFL_STTILECFG_LAST_DEFINED 1 -#define XED_IFORMFL_STUI_FIRST_DEFINED 1 -#define XED_IFORMFL_STUI_LAST_DEFINED 1 -#define XED_IFORMFL_SUB_FIRST_DEFINED 1 -#define XED_IFORMFL_SUB_LAST_DEFINED 1 -#define XED_IFORMFL_SUBPD_FIRST_DEFINED 1 -#define XED_IFORMFL_SUBPD_LAST_DEFINED 1 -#define XED_IFORMFL_SUBPS_FIRST_DEFINED 1 -#define XED_IFORMFL_SUBPS_LAST_DEFINED 1 -#define XED_IFORMFL_SUBSD_FIRST_DEFINED 1 -#define XED_IFORMFL_SUBSD_LAST_DEFINED 1 -#define XED_IFORMFL_SUBSS_FIRST_DEFINED 1 -#define XED_IFORMFL_SUBSS_LAST_DEFINED 1 -#define XED_IFORMFL_SUB_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_SUB_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_SWAPGS_FIRST_DEFINED 1 -#define XED_IFORMFL_SWAPGS_LAST_DEFINED 1 -#define XED_IFORMFL_SYSCALL_FIRST_DEFINED 1 -#define XED_IFORMFL_SYSCALL_LAST_DEFINED 1 -#define XED_IFORMFL_SYSCALL_AMD_FIRST_DEFINED 1 -#define XED_IFORMFL_SYSCALL_AMD_LAST_DEFINED 1 -#define XED_IFORMFL_SYSENTER_FIRST_DEFINED 1 -#define XED_IFORMFL_SYSENTER_LAST_DEFINED 1 -#define XED_IFORMFL_SYSEXIT_FIRST_DEFINED 1 -#define XED_IFORMFL_SYSEXIT_LAST_DEFINED 1 -#define XED_IFORMFL_SYSRET_FIRST_DEFINED 1 -#define XED_IFORMFL_SYSRET_LAST_DEFINED 1 -#define XED_IFORMFL_SYSRET64_FIRST_DEFINED 1 -#define XED_IFORMFL_SYSRET64_LAST_DEFINED 1 -#define XED_IFORMFL_SYSRET_AMD_FIRST_DEFINED 1 -#define XED_IFORMFL_SYSRET_AMD_LAST_DEFINED 1 -#define XED_IFORMFL_T1MSKC_FIRST_DEFINED 1 -#define XED_IFORMFL_T1MSKC_LAST_DEFINED 1 -#define XED_IFORMFL_TDCALL_FIRST_DEFINED 1 -#define XED_IFORMFL_TDCALL_LAST_DEFINED 1 -#define XED_IFORMFL_TDPBF16PS_FIRST_DEFINED 1 -#define XED_IFORMFL_TDPBF16PS_LAST_DEFINED 1 -#define XED_IFORMFL_TDPBSSD_FIRST_DEFINED 1 -#define XED_IFORMFL_TDPBSSD_LAST_DEFINED 1 -#define XED_IFORMFL_TDPBSUD_FIRST_DEFINED 1 -#define XED_IFORMFL_TDPBSUD_LAST_DEFINED 1 -#define XED_IFORMFL_TDPBUSD_FIRST_DEFINED 1 -#define XED_IFORMFL_TDPBUSD_LAST_DEFINED 1 -#define XED_IFORMFL_TDPBUUD_FIRST_DEFINED 1 -#define XED_IFORMFL_TDPBUUD_LAST_DEFINED 1 -#define XED_IFORMFL_TEST_FIRST_DEFINED 1 -#define XED_IFORMFL_TEST_LAST_DEFINED 1 -#define XED_IFORMFL_TESTUI_FIRST_DEFINED 1 -#define XED_IFORMFL_TESTUI_LAST_DEFINED 1 -#define XED_IFORMFL_TILELOADD_FIRST_DEFINED 1 -#define XED_IFORMFL_TILELOADD_LAST_DEFINED 1 -#define XED_IFORMFL_TILELOADDT1_FIRST_DEFINED 1 -#define XED_IFORMFL_TILELOADDT1_LAST_DEFINED 1 -#define XED_IFORMFL_TILERELEASE_FIRST_DEFINED 1 -#define XED_IFORMFL_TILERELEASE_LAST_DEFINED 1 -#define XED_IFORMFL_TILESTORED_FIRST_DEFINED 1 -#define XED_IFORMFL_TILESTORED_LAST_DEFINED 1 -#define XED_IFORMFL_TILEZERO_FIRST_DEFINED 1 -#define XED_IFORMFL_TILEZERO_LAST_DEFINED 1 -#define XED_IFORMFL_TLBSYNC_FIRST_DEFINED 1 -#define XED_IFORMFL_TLBSYNC_LAST_DEFINED 1 -#define XED_IFORMFL_TPAUSE_FIRST_DEFINED 1 -#define XED_IFORMFL_TPAUSE_LAST_DEFINED 1 -#define XED_IFORMFL_TZCNT_FIRST_DEFINED 1 -#define XED_IFORMFL_TZCNT_LAST_DEFINED 1 -#define XED_IFORMFL_TZMSK_FIRST_DEFINED 1 -#define XED_IFORMFL_TZMSK_LAST_DEFINED 1 -#define XED_IFORMFL_UCOMISD_FIRST_DEFINED 1 -#define XED_IFORMFL_UCOMISD_LAST_DEFINED 1 -#define XED_IFORMFL_UCOMISS_FIRST_DEFINED 1 -#define XED_IFORMFL_UCOMISS_LAST_DEFINED 1 -#define XED_IFORMFL_UD0_FIRST_DEFINED 1 -#define XED_IFORMFL_UD0_LAST_DEFINED 1 -#define XED_IFORMFL_UD1_FIRST_DEFINED 1 -#define XED_IFORMFL_UD1_LAST_DEFINED 1 -#define XED_IFORMFL_UD2_FIRST_DEFINED 1 -#define XED_IFORMFL_UD2_LAST_DEFINED 1 -#define XED_IFORMFL_UIRET_FIRST_DEFINED 1 -#define XED_IFORMFL_UIRET_LAST_DEFINED 1 -#define XED_IFORMFL_UMONITOR_FIRST_DEFINED 1 -#define XED_IFORMFL_UMONITOR_LAST_DEFINED 1 -#define XED_IFORMFL_UMWAIT_FIRST_DEFINED 1 -#define XED_IFORMFL_UMWAIT_LAST_DEFINED 1 -#define XED_IFORMFL_UNPCKHPD_FIRST_DEFINED 1 -#define XED_IFORMFL_UNPCKHPD_LAST_DEFINED 1 -#define XED_IFORMFL_UNPCKHPS_FIRST_DEFINED 1 -#define XED_IFORMFL_UNPCKHPS_LAST_DEFINED 1 -#define XED_IFORMFL_UNPCKLPD_FIRST_DEFINED 1 -#define XED_IFORMFL_UNPCKLPD_LAST_DEFINED 1 -#define XED_IFORMFL_UNPCKLPS_FIRST_DEFINED 1 -#define XED_IFORMFL_UNPCKLPS_LAST_DEFINED 1 -#define XED_IFORMFL_V4FMADDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_V4FMADDPS_LAST_DEFINED 1 -#define XED_IFORMFL_V4FMADDSS_FIRST_DEFINED 1 -#define XED_IFORMFL_V4FMADDSS_LAST_DEFINED 1 -#define XED_IFORMFL_V4FNMADDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_V4FNMADDPS_LAST_DEFINED 1 -#define XED_IFORMFL_V4FNMADDSS_FIRST_DEFINED 1 -#define XED_IFORMFL_V4FNMADDSS_LAST_DEFINED 1 -#define XED_IFORMFL_VADDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VADDPD_LAST_DEFINED 1 -#define XED_IFORMFL_VADDPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VADDPH_LAST_DEFINED 1 -#define XED_IFORMFL_VADDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VADDPS_LAST_DEFINED 1 -#define XED_IFORMFL_VADDSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VADDSD_LAST_DEFINED 1 -#define XED_IFORMFL_VADDSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VADDSH_LAST_DEFINED 1 -#define XED_IFORMFL_VADDSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VADDSS_LAST_DEFINED 1 -#define XED_IFORMFL_VADDSUBPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VADDSUBPD_LAST_DEFINED 1 -#define XED_IFORMFL_VADDSUBPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VADDSUBPS_LAST_DEFINED 1 -#define XED_IFORMFL_VAESDEC_FIRST_DEFINED 1 -#define XED_IFORMFL_VAESDEC_LAST_DEFINED 1 -#define XED_IFORMFL_VAESDECLAST_FIRST_DEFINED 1 -#define XED_IFORMFL_VAESDECLAST_LAST_DEFINED 1 -#define XED_IFORMFL_VAESENC_FIRST_DEFINED 1 -#define XED_IFORMFL_VAESENC_LAST_DEFINED 1 -#define XED_IFORMFL_VAESENCLAST_FIRST_DEFINED 1 -#define XED_IFORMFL_VAESENCLAST_LAST_DEFINED 1 -#define XED_IFORMFL_VAESIMC_FIRST_DEFINED 1 -#define XED_IFORMFL_VAESIMC_LAST_DEFINED 1 -#define XED_IFORMFL_VAESKEYGENASSIST_FIRST_DEFINED 1 -#define XED_IFORMFL_VAESKEYGENASSIST_LAST_DEFINED 1 -#define XED_IFORMFL_VALIGND_FIRST_DEFINED 1 -#define XED_IFORMFL_VALIGND_LAST_DEFINED 1 -#define XED_IFORMFL_VALIGNQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VALIGNQ_LAST_DEFINED 1 -#define XED_IFORMFL_VANDNPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VANDNPD_LAST_DEFINED 1 -#define XED_IFORMFL_VANDNPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VANDNPS_LAST_DEFINED 1 -#define XED_IFORMFL_VANDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VANDPD_LAST_DEFINED 1 -#define XED_IFORMFL_VANDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VANDPS_LAST_DEFINED 1 -#define XED_IFORMFL_VBLENDMPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VBLENDMPD_LAST_DEFINED 1 -#define XED_IFORMFL_VBLENDMPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VBLENDMPS_LAST_DEFINED 1 -#define XED_IFORMFL_VBLENDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VBLENDPD_LAST_DEFINED 1 -#define XED_IFORMFL_VBLENDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VBLENDPS_LAST_DEFINED 1 -#define XED_IFORMFL_VBLENDVPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VBLENDVPD_LAST_DEFINED 1 -#define XED_IFORMFL_VBLENDVPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VBLENDVPS_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF128_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF128_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF32X2_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF32X2_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF32X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF32X4_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF32X8_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF32X8_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF64X2_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF64X2_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF64X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTF64X4_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI128_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI128_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI32X2_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI32X2_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI32X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI32X4_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI32X8_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI32X8_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI64X2_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI64X2_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI64X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTI64X4_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTSD_LAST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VBROADCASTSS_LAST_DEFINED 1 -#define XED_IFORMFL_VCMPPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCMPPD_LAST_DEFINED 1 -#define XED_IFORMFL_VCMPPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCMPPH_LAST_DEFINED 1 -#define XED_IFORMFL_VCMPPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCMPPS_LAST_DEFINED 1 -#define XED_IFORMFL_VCMPSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCMPSD_LAST_DEFINED 1 -#define XED_IFORMFL_VCMPSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCMPSH_LAST_DEFINED 1 -#define XED_IFORMFL_VCMPSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCMPSS_LAST_DEFINED 1 -#define XED_IFORMFL_VCOMISD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCOMISD_LAST_DEFINED 1 -#define XED_IFORMFL_VCOMISH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCOMISH_LAST_DEFINED 1 -#define XED_IFORMFL_VCOMISS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCOMISS_LAST_DEFINED 1 -#define XED_IFORMFL_VCOMPRESSPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCOMPRESSPD_LAST_DEFINED 1 -#define XED_IFORMFL_VCOMPRESSPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCOMPRESSPS_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTDQ2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTDQ2PD_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTDQ2PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTDQ2PH_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTDQ2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTDQ2PS_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTNE2PS2BF16_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTNE2PS2BF16_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTNEPS2BF16_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTNEPS2BF16_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2DQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2DQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2PH_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2PS_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2QQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2QQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2UDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2UDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2UQQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPD2UQQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2DQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2DQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2PD_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2PS_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2PSX_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2PSX_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2QQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2QQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2UDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2UDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2UQQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2UQQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2UW_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2UW_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2W_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPH2W_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2DQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2DQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2PD_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2PH_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2PHX_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2PHX_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2QQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2QQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2UDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2UDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2UQQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTPS2UQQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTQQ2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTQQ2PD_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTQQ2PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTQQ2PH_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTQQ2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTQQ2PS_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSD2SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSD2SH_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSD2SI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSD2SI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSD2SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSD2SS_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSD2USI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSD2USI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSH2SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSH2SD_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSH2SI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSH2SI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSH2SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSH2SS_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSH2USI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSH2USI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSI2SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSI2SD_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSI2SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSI2SH_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSI2SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSI2SS_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSS2SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSS2SD_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSS2SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSS2SH_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSS2SI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSS2SI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTSS2USI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTSS2USI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPD2DQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPD2DQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPD2QQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPD2QQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPD2UDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPD2UDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPD2UQQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPD2UQQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2DQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2DQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2QQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2QQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2UDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2UDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2UQQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2UQQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2UW_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2UW_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2W_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPH2W_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPS2DQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPS2DQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPS2QQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPS2QQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPS2UDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPS2UDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTPS2UQQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTPS2UQQ_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTSD2SI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTSD2SI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTSD2USI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTSD2USI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTSH2SI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTSH2SI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTSH2USI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTSH2USI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTSS2SI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTSS2SI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTTSS2USI_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTTSS2USI_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTUDQ2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTUDQ2PD_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTUDQ2PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTUDQ2PH_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTUDQ2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTUDQ2PS_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTUQQ2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTUQQ2PD_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTUQQ2PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTUQQ2PH_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTUQQ2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTUQQ2PS_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTUSI2SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTUSI2SD_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTUSI2SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTUSI2SH_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTUSI2SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTUSI2SS_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTUW2PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTUW2PH_LAST_DEFINED 1 -#define XED_IFORMFL_VCVTW2PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VCVTW2PH_LAST_DEFINED 1 -#define XED_IFORMFL_VDBPSADBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VDBPSADBW_LAST_DEFINED 1 -#define XED_IFORMFL_VDIVPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VDIVPD_LAST_DEFINED 1 -#define XED_IFORMFL_VDIVPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VDIVPH_LAST_DEFINED 1 -#define XED_IFORMFL_VDIVPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VDIVPS_LAST_DEFINED 1 -#define XED_IFORMFL_VDIVSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VDIVSD_LAST_DEFINED 1 -#define XED_IFORMFL_VDIVSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VDIVSH_LAST_DEFINED 1 -#define XED_IFORMFL_VDIVSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VDIVSS_LAST_DEFINED 1 -#define XED_IFORMFL_VDPBF16PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VDPBF16PS_LAST_DEFINED 1 -#define XED_IFORMFL_VDPPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VDPPD_LAST_DEFINED 1 -#define XED_IFORMFL_VDPPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VDPPS_LAST_DEFINED 1 -#define XED_IFORMFL_VERR_FIRST_DEFINED 1 -#define XED_IFORMFL_VERR_LAST_DEFINED 1 -#define XED_IFORMFL_VERW_FIRST_DEFINED 1 -#define XED_IFORMFL_VERW_LAST_DEFINED 1 -#define XED_IFORMFL_VEXP2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXP2PD_LAST_DEFINED 1 -#define XED_IFORMFL_VEXP2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXP2PS_LAST_DEFINED 1 -#define XED_IFORMFL_VEXPANDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXPANDPD_LAST_DEFINED 1 -#define XED_IFORMFL_VEXPANDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXPANDPS_LAST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTF128_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTF128_LAST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTF32X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTF32X4_LAST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTF32X8_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTF32X8_LAST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTF64X2_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTF64X2_LAST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTF64X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTF64X4_LAST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTI128_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTI128_LAST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTI32X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTI32X4_LAST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTI32X8_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTI32X8_LAST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTI64X2_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTI64X2_LAST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTI64X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTI64X4_LAST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VEXTRACTPS_LAST_DEFINED 1 -#define XED_IFORMFL_VFCMADDCPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFCMADDCPH_LAST_DEFINED 1 -#define XED_IFORMFL_VFCMADDCSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFCMADDCSH_LAST_DEFINED 1 -#define XED_IFORMFL_VFCMULCPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFCMULCPH_LAST_DEFINED 1 -#define XED_IFORMFL_VFCMULCSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFCMULCSH_LAST_DEFINED 1 -#define XED_IFORMFL_VFIXUPIMMPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFIXUPIMMPD_LAST_DEFINED 1 -#define XED_IFORMFL_VFIXUPIMMPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFIXUPIMMPS_LAST_DEFINED 1 -#define XED_IFORMFL_VFIXUPIMMSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFIXUPIMMSD_LAST_DEFINED 1 -#define XED_IFORMFL_VFIXUPIMMSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFIXUPIMMSS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD132PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD132PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD132PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD132PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD132PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD132PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD132SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD132SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD132SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD132SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD132SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD132SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD213PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD213PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD213PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD213PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD213PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD213PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD213SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD213SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD213SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD213SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD213SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD213SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD231PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD231PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD231PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD231PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD231PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD231PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD231SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD231SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD231SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD231SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADD231SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADD231SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDCPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDCPH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDCSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDCSH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDPD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDPS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB132PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB132PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB132PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB132PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB132PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB132PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB213PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB213PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB213PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB213PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB213PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB213PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB231PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB231PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB231PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB231PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB231PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUB231PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUBPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUBPD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUBPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMADDSUBPS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB132SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB213SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUB231SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD132PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD132PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD132PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD132PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD132PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD132PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD213PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD213PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD213PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD213PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD213PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD213PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD231PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD231PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD231PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD231PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD231PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADD231PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADDPD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBADDPS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBPD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBPS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBSD_LAST_DEFINED 1 -#define XED_IFORMFL_VFMSUBSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMSUBSS_LAST_DEFINED 1 -#define XED_IFORMFL_VFMULCPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMULCPH_LAST_DEFINED 1 -#define XED_IFORMFL_VFMULCSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFMULCSH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD132SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD213SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADD231SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADDPD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADDPS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADDSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADDSD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMADDSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMADDSS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB132SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB213SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231PD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231PH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231PH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231PS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231SD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231SH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231SH_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUB231SS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUBPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUBPD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUBPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUBPS_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUBSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUBSD_LAST_DEFINED 1 -#define XED_IFORMFL_VFNMSUBSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFNMSUBSS_LAST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSPD_LAST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSPH_LAST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSPS_LAST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSSD_LAST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSSH_LAST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFPCLASSSS_LAST_DEFINED 1 -#define XED_IFORMFL_VFRCZPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFRCZPD_LAST_DEFINED 1 -#define XED_IFORMFL_VFRCZPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFRCZPS_LAST_DEFINED 1 -#define XED_IFORMFL_VFRCZSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VFRCZSD_LAST_DEFINED 1 -#define XED_IFORMFL_VFRCZSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VFRCZSS_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERDPD_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERDPS_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF0DPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF0DPD_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF0DPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF0DPS_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF0QPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF0QPD_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF0QPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF0QPS_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF1DPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF1DPD_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF1DPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF1DPS_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF1QPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF1QPD_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF1QPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERPF1QPS_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERQPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERQPD_LAST_DEFINED 1 -#define XED_IFORMFL_VGATHERQPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VGATHERQPS_LAST_DEFINED 1 -#define XED_IFORMFL_VGETEXPPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETEXPPD_LAST_DEFINED 1 -#define XED_IFORMFL_VGETEXPPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETEXPPH_LAST_DEFINED 1 -#define XED_IFORMFL_VGETEXPPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETEXPPS_LAST_DEFINED 1 -#define XED_IFORMFL_VGETEXPSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETEXPSD_LAST_DEFINED 1 -#define XED_IFORMFL_VGETEXPSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETEXPSH_LAST_DEFINED 1 -#define XED_IFORMFL_VGETEXPSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETEXPSS_LAST_DEFINED 1 -#define XED_IFORMFL_VGETMANTPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETMANTPD_LAST_DEFINED 1 -#define XED_IFORMFL_VGETMANTPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETMANTPH_LAST_DEFINED 1 -#define XED_IFORMFL_VGETMANTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETMANTPS_LAST_DEFINED 1 -#define XED_IFORMFL_VGETMANTSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETMANTSD_LAST_DEFINED 1 -#define XED_IFORMFL_VGETMANTSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETMANTSH_LAST_DEFINED 1 -#define XED_IFORMFL_VGETMANTSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VGETMANTSS_LAST_DEFINED 1 -#define XED_IFORMFL_VGF2P8AFFINEINVQB_FIRST_DEFINED 1 -#define XED_IFORMFL_VGF2P8AFFINEINVQB_LAST_DEFINED 1 -#define XED_IFORMFL_VGF2P8AFFINEQB_FIRST_DEFINED 1 -#define XED_IFORMFL_VGF2P8AFFINEQB_LAST_DEFINED 1 -#define XED_IFORMFL_VGF2P8MULB_FIRST_DEFINED 1 -#define XED_IFORMFL_VGF2P8MULB_LAST_DEFINED 1 -#define XED_IFORMFL_VHADDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VHADDPD_LAST_DEFINED 1 -#define XED_IFORMFL_VHADDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VHADDPS_LAST_DEFINED 1 -#define XED_IFORMFL_VHSUBPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VHSUBPD_LAST_DEFINED 1 -#define XED_IFORMFL_VHSUBPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VHSUBPS_LAST_DEFINED 1 -#define XED_IFORMFL_VINSERTF128_FIRST_DEFINED 1 -#define XED_IFORMFL_VINSERTF128_LAST_DEFINED 1 -#define XED_IFORMFL_VINSERTF32X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VINSERTF32X4_LAST_DEFINED 1 -#define XED_IFORMFL_VINSERTF32X8_FIRST_DEFINED 1 -#define XED_IFORMFL_VINSERTF32X8_LAST_DEFINED 1 -#define XED_IFORMFL_VINSERTF64X2_FIRST_DEFINED 1 -#define XED_IFORMFL_VINSERTF64X2_LAST_DEFINED 1 -#define XED_IFORMFL_VINSERTF64X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VINSERTF64X4_LAST_DEFINED 1 -#define XED_IFORMFL_VINSERTI128_FIRST_DEFINED 1 -#define XED_IFORMFL_VINSERTI128_LAST_DEFINED 1 -#define XED_IFORMFL_VINSERTI32X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VINSERTI32X4_LAST_DEFINED 1 -#define XED_IFORMFL_VINSERTI32X8_FIRST_DEFINED 1 -#define XED_IFORMFL_VINSERTI32X8_LAST_DEFINED 1 -#define XED_IFORMFL_VINSERTI64X2_FIRST_DEFINED 1 -#define XED_IFORMFL_VINSERTI64X2_LAST_DEFINED 1 -#define XED_IFORMFL_VINSERTI64X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VINSERTI64X4_LAST_DEFINED 1 -#define XED_IFORMFL_VINSERTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VINSERTPS_LAST_DEFINED 1 -#define XED_IFORMFL_VLDDQU_FIRST_DEFINED 1 -#define XED_IFORMFL_VLDDQU_LAST_DEFINED 1 -#define XED_IFORMFL_VLDMXCSR_FIRST_DEFINED 1 -#define XED_IFORMFL_VLDMXCSR_LAST_DEFINED 1 -#define XED_IFORMFL_VMASKMOVDQU_FIRST_DEFINED 1 -#define XED_IFORMFL_VMASKMOVDQU_LAST_DEFINED 1 -#define XED_IFORMFL_VMASKMOVPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMASKMOVPD_LAST_DEFINED 1 -#define XED_IFORMFL_VMASKMOVPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMASKMOVPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMAXPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMAXPD_LAST_DEFINED 1 -#define XED_IFORMFL_VMAXPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VMAXPH_LAST_DEFINED 1 -#define XED_IFORMFL_VMAXPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMAXPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMAXSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMAXSD_LAST_DEFINED 1 -#define XED_IFORMFL_VMAXSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VMAXSH_LAST_DEFINED 1 -#define XED_IFORMFL_VMAXSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMAXSS_LAST_DEFINED 1 -#define XED_IFORMFL_VMCALL_FIRST_DEFINED 1 -#define XED_IFORMFL_VMCALL_LAST_DEFINED 1 -#define XED_IFORMFL_VMCLEAR_FIRST_DEFINED 1 -#define XED_IFORMFL_VMCLEAR_LAST_DEFINED 1 -#define XED_IFORMFL_VMFUNC_FIRST_DEFINED 1 -#define XED_IFORMFL_VMFUNC_LAST_DEFINED 1 -#define XED_IFORMFL_VMINPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMINPD_LAST_DEFINED 1 -#define XED_IFORMFL_VMINPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VMINPH_LAST_DEFINED 1 -#define XED_IFORMFL_VMINPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMINPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMINSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMINSD_LAST_DEFINED 1 -#define XED_IFORMFL_VMINSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VMINSH_LAST_DEFINED 1 -#define XED_IFORMFL_VMINSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMINSS_LAST_DEFINED 1 -#define XED_IFORMFL_VMLAUNCH_FIRST_DEFINED 1 -#define XED_IFORMFL_VMLAUNCH_LAST_DEFINED 1 -#define XED_IFORMFL_VMLOAD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMLOAD_LAST_DEFINED 1 -#define XED_IFORMFL_VMMCALL_FIRST_DEFINED 1 -#define XED_IFORMFL_VMMCALL_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVAPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVAPD_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVAPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVAPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVD_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVDDUP_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVDDUP_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVDQA_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVDQA_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVDQA32_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVDQA32_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVDQA64_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVDQA64_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVDQU_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVDQU_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVDQU16_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVDQU16_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVDQU32_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVDQU32_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVDQU64_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVDQU64_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVDQU8_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVDQU8_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVHLPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVHLPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVHPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVHPD_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVHPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVHPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVLHPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVLHPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVLPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVLPD_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVLPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVLPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVMSKPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVMSKPD_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVMSKPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVMSKPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVNTDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVNTDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVNTDQA_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVNTDQA_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVNTPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVNTPD_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVNTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVNTPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVQ_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVSD_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVSH_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVSHDUP_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVSHDUP_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVSLDUP_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVSLDUP_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVSS_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVUPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVUPD_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVUPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVUPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMOVW_FIRST_DEFINED 1 -#define XED_IFORMFL_VMOVW_LAST_DEFINED 1 -#define XED_IFORMFL_VMPSADBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VMPSADBW_LAST_DEFINED 1 -#define XED_IFORMFL_VMPTRLD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMPTRLD_LAST_DEFINED 1 -#define XED_IFORMFL_VMPTRST_FIRST_DEFINED 1 -#define XED_IFORMFL_VMPTRST_LAST_DEFINED 1 -#define XED_IFORMFL_VMREAD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMREAD_LAST_DEFINED 1 -#define XED_IFORMFL_VMRESUME_FIRST_DEFINED 1 -#define XED_IFORMFL_VMRESUME_LAST_DEFINED 1 -#define XED_IFORMFL_VMRUN_FIRST_DEFINED 1 -#define XED_IFORMFL_VMRUN_LAST_DEFINED 1 -#define XED_IFORMFL_VMSAVE_FIRST_DEFINED 1 -#define XED_IFORMFL_VMSAVE_LAST_DEFINED 1 -#define XED_IFORMFL_VMULPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMULPD_LAST_DEFINED 1 -#define XED_IFORMFL_VMULPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VMULPH_LAST_DEFINED 1 -#define XED_IFORMFL_VMULPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMULPS_LAST_DEFINED 1 -#define XED_IFORMFL_VMULSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VMULSD_LAST_DEFINED 1 -#define XED_IFORMFL_VMULSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VMULSH_LAST_DEFINED 1 -#define XED_IFORMFL_VMULSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VMULSS_LAST_DEFINED 1 -#define XED_IFORMFL_VMWRITE_FIRST_DEFINED 1 -#define XED_IFORMFL_VMWRITE_LAST_DEFINED 1 -#define XED_IFORMFL_VMXOFF_FIRST_DEFINED 1 -#define XED_IFORMFL_VMXOFF_LAST_DEFINED 1 -#define XED_IFORMFL_VMXON_FIRST_DEFINED 1 -#define XED_IFORMFL_VMXON_LAST_DEFINED 1 -#define XED_IFORMFL_VORPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VORPD_LAST_DEFINED 1 -#define XED_IFORMFL_VORPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VORPS_LAST_DEFINED 1 -#define XED_IFORMFL_VP2INTERSECTD_FIRST_DEFINED 1 -#define XED_IFORMFL_VP2INTERSECTD_LAST_DEFINED 1 -#define XED_IFORMFL_VP2INTERSECTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VP2INTERSECTQ_LAST_DEFINED 1 -#define XED_IFORMFL_VP4DPWSSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VP4DPWSSD_LAST_DEFINED 1 -#define XED_IFORMFL_VP4DPWSSDS_FIRST_DEFINED 1 -#define XED_IFORMFL_VP4DPWSSDS_LAST_DEFINED 1 -#define XED_IFORMFL_VPABSB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPABSB_LAST_DEFINED 1 -#define XED_IFORMFL_VPABSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPABSD_LAST_DEFINED 1 -#define XED_IFORMFL_VPABSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPABSQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPABSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPABSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPACKSSDW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPACKSSDW_LAST_DEFINED 1 -#define XED_IFORMFL_VPACKSSWB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPACKSSWB_LAST_DEFINED 1 -#define XED_IFORMFL_VPACKUSDW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPACKUSDW_LAST_DEFINED 1 -#define XED_IFORMFL_VPACKUSWB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPACKUSWB_LAST_DEFINED 1 -#define XED_IFORMFL_VPADDB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPADDB_LAST_DEFINED 1 -#define XED_IFORMFL_VPADDD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPADDD_LAST_DEFINED 1 -#define XED_IFORMFL_VPADDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPADDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPADDSB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPADDSB_LAST_DEFINED 1 -#define XED_IFORMFL_VPADDSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPADDSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPADDUSB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPADDUSB_LAST_DEFINED 1 -#define XED_IFORMFL_VPADDUSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPADDUSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPADDW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPADDW_LAST_DEFINED 1 -#define XED_IFORMFL_VPALIGNR_FIRST_DEFINED 1 -#define XED_IFORMFL_VPALIGNR_LAST_DEFINED 1 -#define XED_IFORMFL_VPAND_FIRST_DEFINED 1 -#define XED_IFORMFL_VPAND_LAST_DEFINED 1 -#define XED_IFORMFL_VPANDD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPANDD_LAST_DEFINED 1 -#define XED_IFORMFL_VPANDN_FIRST_DEFINED 1 -#define XED_IFORMFL_VPANDN_LAST_DEFINED 1 -#define XED_IFORMFL_VPANDND_FIRST_DEFINED 1 -#define XED_IFORMFL_VPANDND_LAST_DEFINED 1 -#define XED_IFORMFL_VPANDNQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPANDNQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPANDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPANDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPAVGB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPAVGB_LAST_DEFINED 1 -#define XED_IFORMFL_VPAVGW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPAVGW_LAST_DEFINED 1 -#define XED_IFORMFL_VPBLENDD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBLENDD_LAST_DEFINED 1 -#define XED_IFORMFL_VPBLENDMB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBLENDMB_LAST_DEFINED 1 -#define XED_IFORMFL_VPBLENDMD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBLENDMD_LAST_DEFINED 1 -#define XED_IFORMFL_VPBLENDMQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBLENDMQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPBLENDMW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBLENDMW_LAST_DEFINED 1 -#define XED_IFORMFL_VPBLENDVB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBLENDVB_LAST_DEFINED 1 -#define XED_IFORMFL_VPBLENDW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBLENDW_LAST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTB_LAST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTD_LAST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTMB2Q_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTMB2Q_LAST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTMW2D_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTMW2D_LAST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPBROADCASTW_LAST_DEFINED 1 -#define XED_IFORMFL_VPCLMULQDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCLMULQDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMOV_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMOV_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPB_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPD_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPEQB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPEQB_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPEQD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPEQD_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPEQQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPEQQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPEQW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPEQW_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPESTRI_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPESTRI_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPESTRI64_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPESTRI64_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPESTRM_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPESTRM_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPESTRM64_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPESTRM64_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPGTB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPGTB_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPGTD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPGTD_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPGTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPGTQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPGTW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPGTW_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPISTRI_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPISTRI_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPISTRI64_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPISTRI64_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPISTRM_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPISTRM_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPUB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPUB_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPUD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPUD_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPUQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPUQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPUW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPUW_LAST_DEFINED 1 -#define XED_IFORMFL_VPCMPW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCMPW_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMB_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMD_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMPRESSB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMPRESSB_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMPRESSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMPRESSD_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMPRESSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMPRESSQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMPRESSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMPRESSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMUB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMUB_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMUD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMUD_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMUQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMUQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMUW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMUW_LAST_DEFINED 1 -#define XED_IFORMFL_VPCOMW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCOMW_LAST_DEFINED 1 -#define XED_IFORMFL_VPCONFLICTD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCONFLICTD_LAST_DEFINED 1 -#define XED_IFORMFL_VPCONFLICTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPCONFLICTQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPDPBUSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPDPBUSD_LAST_DEFINED 1 -#define XED_IFORMFL_VPDPBUSDS_FIRST_DEFINED 1 -#define XED_IFORMFL_VPDPBUSDS_LAST_DEFINED 1 -#define XED_IFORMFL_VPDPWSSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPDPWSSD_LAST_DEFINED 1 -#define XED_IFORMFL_VPDPWSSDS_FIRST_DEFINED 1 -#define XED_IFORMFL_VPDPWSSDS_LAST_DEFINED 1 -#define XED_IFORMFL_VPERM2F128_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERM2F128_LAST_DEFINED 1 -#define XED_IFORMFL_VPERM2I128_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERM2I128_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMB_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMD_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMI2B_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMI2B_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMI2D_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMI2D_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMI2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMI2PD_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMI2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMI2PS_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMI2Q_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMI2Q_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMI2W_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMI2W_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMIL2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMIL2PD_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMIL2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMIL2PS_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMILPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMILPD_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMILPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMILPS_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMPD_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMPS_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMT2B_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMT2B_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMT2D_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMT2D_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMT2PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMT2PD_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMT2PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMT2PS_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMT2Q_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMT2Q_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMT2W_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMT2W_LAST_DEFINED 1 -#define XED_IFORMFL_VPERMW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPERMW_LAST_DEFINED 1 -#define XED_IFORMFL_VPEXPANDB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPEXPANDB_LAST_DEFINED 1 -#define XED_IFORMFL_VPEXPANDD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPEXPANDD_LAST_DEFINED 1 -#define XED_IFORMFL_VPEXPANDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPEXPANDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPEXPANDW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPEXPANDW_LAST_DEFINED 1 -#define XED_IFORMFL_VPEXTRB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPEXTRB_LAST_DEFINED 1 -#define XED_IFORMFL_VPEXTRD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPEXTRD_LAST_DEFINED 1 -#define XED_IFORMFL_VPEXTRQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPEXTRQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPEXTRW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPEXTRW_LAST_DEFINED 1 -#define XED_IFORMFL_VPEXTRW_C5_FIRST_DEFINED 1 -#define XED_IFORMFL_VPEXTRW_C5_LAST_DEFINED 1 -#define XED_IFORMFL_VPGATHERDD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPGATHERDD_LAST_DEFINED 1 -#define XED_IFORMFL_VPGATHERDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPGATHERDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPGATHERQD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPGATHERQD_LAST_DEFINED 1 -#define XED_IFORMFL_VPGATHERQQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPGATHERQQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDBD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDBD_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDBQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDBQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDBW_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDD_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDUBD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDUBD_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDUBQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDUBQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDUBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDUBW_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDUDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDUDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDUWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDUWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDUWQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDUWQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDW_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPHADDWQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHADDWQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPHMINPOSUW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHMINPOSUW_LAST_DEFINED 1 -#define XED_IFORMFL_VPHSUBBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHSUBBW_LAST_DEFINED 1 -#define XED_IFORMFL_VPHSUBD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHSUBD_LAST_DEFINED 1 -#define XED_IFORMFL_VPHSUBDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHSUBDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPHSUBSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHSUBSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPHSUBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHSUBW_LAST_DEFINED 1 -#define XED_IFORMFL_VPHSUBWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPHSUBWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPINSRB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPINSRB_LAST_DEFINED 1 -#define XED_IFORMFL_VPINSRD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPINSRD_LAST_DEFINED 1 -#define XED_IFORMFL_VPINSRQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPINSRQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPINSRW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPINSRW_LAST_DEFINED 1 -#define XED_IFORMFL_VPLZCNTD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPLZCNTD_LAST_DEFINED 1 -#define XED_IFORMFL_VPLZCNTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPLZCNTQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMACSDD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMACSDD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMACSDQH_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMACSDQH_LAST_DEFINED 1 -#define XED_IFORMFL_VPMACSDQL_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMACSDQL_LAST_DEFINED 1 -#define XED_IFORMFL_VPMACSSDD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMACSSDD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMACSSDQH_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMACSSDQH_LAST_DEFINED 1 -#define XED_IFORMFL_VPMACSSDQL_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMACSSDQL_LAST_DEFINED 1 -#define XED_IFORMFL_VPMACSSWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMACSSWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMACSSWW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMACSSWW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMACSWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMACSWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMACSWW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMACSWW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMADCSSWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMADCSSWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMADCSWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMADCSWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMADD52HUQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMADD52HUQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMADD52LUQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMADD52LUQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMADDUBSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMADDUBSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMADDWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMADDWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMASKMOVD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMASKMOVD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMASKMOVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMASKMOVQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMAXSB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMAXSB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMAXSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMAXSD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMAXSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMAXSQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMAXSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMAXSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMAXUB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMAXUB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMAXUD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMAXUD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMAXUQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMAXUQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMAXUW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMAXUW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMINSB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMINSB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMINSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMINSD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMINSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMINSQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMINSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMINSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMINUB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMINUB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMINUD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMINUD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMINUQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMINUQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMINUW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMINUW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVB2M_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVB2M_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVD2M_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVD2M_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVDB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVDB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVDW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVDW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVM2B_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVM2B_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVM2D_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVM2D_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVM2Q_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVM2Q_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVM2W_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVM2W_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVMSKB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVMSKB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVQ2M_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVQ2M_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVQB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVQB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVQD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVQD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVQW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVQW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSDB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSDB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSDW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSDW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSQB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSQB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSQD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSQD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSQW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSQW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSWB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSWB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXBD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXBD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXBQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXBQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXBW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXWQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVSXWQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSDB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSDB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSDW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSDW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSQB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSQB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSQD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSQD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSQW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSQW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSWB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVUSWB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVW2M_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVW2M_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVWB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVWB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXBD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXBD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXBQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXBQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXBW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXWQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMOVZXWQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMULDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMULDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMULHRSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMULHRSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMULHUW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMULHUW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMULHW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMULHW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMULLD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMULLD_LAST_DEFINED 1 -#define XED_IFORMFL_VPMULLQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMULLQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPMULLW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMULLW_LAST_DEFINED 1 -#define XED_IFORMFL_VPMULTISHIFTQB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMULTISHIFTQB_LAST_DEFINED 1 -#define XED_IFORMFL_VPMULUDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPMULUDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPOPCNTB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPOPCNTB_LAST_DEFINED 1 -#define XED_IFORMFL_VPOPCNTD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPOPCNTD_LAST_DEFINED 1 -#define XED_IFORMFL_VPOPCNTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPOPCNTQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPOPCNTW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPOPCNTW_LAST_DEFINED 1 -#define XED_IFORMFL_VPOR_FIRST_DEFINED 1 -#define XED_IFORMFL_VPOR_LAST_DEFINED 1 -#define XED_IFORMFL_VPORD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPORD_LAST_DEFINED 1 -#define XED_IFORMFL_VPORQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPORQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPPERM_FIRST_DEFINED 1 -#define XED_IFORMFL_VPPERM_LAST_DEFINED 1 -#define XED_IFORMFL_VPROLD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPROLD_LAST_DEFINED 1 -#define XED_IFORMFL_VPROLQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPROLQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPROLVD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPROLVD_LAST_DEFINED 1 -#define XED_IFORMFL_VPROLVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPROLVQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPRORD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPRORD_LAST_DEFINED 1 -#define XED_IFORMFL_VPRORQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPRORQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPRORVD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPRORVD_LAST_DEFINED 1 -#define XED_IFORMFL_VPRORVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPRORVQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPROTB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPROTB_LAST_DEFINED 1 -#define XED_IFORMFL_VPROTD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPROTD_LAST_DEFINED 1 -#define XED_IFORMFL_VPROTQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPROTQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPROTW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPROTW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSADBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSADBW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSCATTERDD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSCATTERDD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSCATTERDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSCATTERDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSCATTERQD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSCATTERQD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSCATTERQQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSCATTERQQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHAB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHAB_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHAD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHAD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHAQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHAQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHAW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHAW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHLB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHLB_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHLD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHLD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHLDD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHLDD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHLDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHLDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHLDVD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHLDVD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHLDVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHLDVQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHLDVW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHLDVW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHLDW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHLDW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHLQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHLQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHLW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHLW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHRDD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHRDD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHRDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHRDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHRDVD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHRDVD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHRDVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHRDVQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHRDVW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHRDVW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHRDW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHRDW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHUFB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHUFB_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHUFBITQMB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHUFBITQMB_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHUFD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHUFD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHUFHW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHUFHW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSHUFLW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSHUFLW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSIGNB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSIGNB_LAST_DEFINED 1 -#define XED_IFORMFL_VPSIGND_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSIGND_LAST_DEFINED 1 -#define XED_IFORMFL_VPSIGNW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSIGNW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSLLD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSLLD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSLLDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSLLDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSLLQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSLLQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSLLVD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSLLVD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSLLVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSLLVQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSLLVW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSLLVW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSLLW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSLLW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRAD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRAD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRAQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRAQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRAVD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRAVD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRAVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRAVQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRAVW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRAVW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRAW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRAW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRLD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRLD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRLDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRLDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRLQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRLQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRLVD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRLVD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRLVQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRLVQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRLVW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRLVW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSRLW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSRLW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSUBB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSUBB_LAST_DEFINED 1 -#define XED_IFORMFL_VPSUBD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSUBD_LAST_DEFINED 1 -#define XED_IFORMFL_VPSUBQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSUBQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPSUBSB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSUBSB_LAST_DEFINED 1 -#define XED_IFORMFL_VPSUBSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSUBSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSUBUSB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSUBUSB_LAST_DEFINED 1 -#define XED_IFORMFL_VPSUBUSW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSUBUSW_LAST_DEFINED 1 -#define XED_IFORMFL_VPSUBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPSUBW_LAST_DEFINED 1 -#define XED_IFORMFL_VPTERNLOGD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPTERNLOGD_LAST_DEFINED 1 -#define XED_IFORMFL_VPTERNLOGQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPTERNLOGQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPTEST_FIRST_DEFINED 1 -#define XED_IFORMFL_VPTEST_LAST_DEFINED 1 -#define XED_IFORMFL_VPTESTMB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPTESTMB_LAST_DEFINED 1 -#define XED_IFORMFL_VPTESTMD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPTESTMD_LAST_DEFINED 1 -#define XED_IFORMFL_VPTESTMQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPTESTMQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPTESTMW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPTESTMW_LAST_DEFINED 1 -#define XED_IFORMFL_VPTESTNMB_FIRST_DEFINED 1 -#define XED_IFORMFL_VPTESTNMB_LAST_DEFINED 1 -#define XED_IFORMFL_VPTESTNMD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPTESTNMD_LAST_DEFINED 1 -#define XED_IFORMFL_VPTESTNMQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPTESTNMQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPTESTNMW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPTESTNMW_LAST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKHBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKHBW_LAST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKHDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKHDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKHQDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKHQDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKHWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKHWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKLBW_FIRST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKLBW_LAST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKLDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKLDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKLQDQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKLQDQ_LAST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKLWD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPUNPCKLWD_LAST_DEFINED 1 -#define XED_IFORMFL_VPXOR_FIRST_DEFINED 1 -#define XED_IFORMFL_VPXOR_LAST_DEFINED 1 -#define XED_IFORMFL_VPXORD_FIRST_DEFINED 1 -#define XED_IFORMFL_VPXORD_LAST_DEFINED 1 -#define XED_IFORMFL_VPXORQ_FIRST_DEFINED 1 -#define XED_IFORMFL_VPXORQ_LAST_DEFINED 1 -#define XED_IFORMFL_VRANGEPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRANGEPD_LAST_DEFINED 1 -#define XED_IFORMFL_VRANGEPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRANGEPS_LAST_DEFINED 1 -#define XED_IFORMFL_VRANGESD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRANGESD_LAST_DEFINED 1 -#define XED_IFORMFL_VRANGESS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRANGESS_LAST_DEFINED 1 -#define XED_IFORMFL_VRCP14PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCP14PD_LAST_DEFINED 1 -#define XED_IFORMFL_VRCP14PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCP14PS_LAST_DEFINED 1 -#define XED_IFORMFL_VRCP14SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCP14SD_LAST_DEFINED 1 -#define XED_IFORMFL_VRCP14SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCP14SS_LAST_DEFINED 1 -#define XED_IFORMFL_VRCP28PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCP28PD_LAST_DEFINED 1 -#define XED_IFORMFL_VRCP28PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCP28PS_LAST_DEFINED 1 -#define XED_IFORMFL_VRCP28SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCP28SD_LAST_DEFINED 1 -#define XED_IFORMFL_VRCP28SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCP28SS_LAST_DEFINED 1 -#define XED_IFORMFL_VRCPPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCPPH_LAST_DEFINED 1 -#define XED_IFORMFL_VRCPPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCPPS_LAST_DEFINED 1 -#define XED_IFORMFL_VRCPSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCPSH_LAST_DEFINED 1 -#define XED_IFORMFL_VRCPSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRCPSS_LAST_DEFINED 1 -#define XED_IFORMFL_VREDUCEPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VREDUCEPD_LAST_DEFINED 1 -#define XED_IFORMFL_VREDUCEPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VREDUCEPH_LAST_DEFINED 1 -#define XED_IFORMFL_VREDUCEPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VREDUCEPS_LAST_DEFINED 1 -#define XED_IFORMFL_VREDUCESD_FIRST_DEFINED 1 -#define XED_IFORMFL_VREDUCESD_LAST_DEFINED 1 -#define XED_IFORMFL_VREDUCESH_FIRST_DEFINED 1 -#define XED_IFORMFL_VREDUCESH_LAST_DEFINED 1 -#define XED_IFORMFL_VREDUCESS_FIRST_DEFINED 1 -#define XED_IFORMFL_VREDUCESS_LAST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALEPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALEPD_LAST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALEPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALEPH_LAST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALEPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALEPS_LAST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALESD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALESD_LAST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALESH_FIRST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALESH_LAST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALESS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRNDSCALESS_LAST_DEFINED 1 -#define XED_IFORMFL_VROUNDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VROUNDPD_LAST_DEFINED 1 -#define XED_IFORMFL_VROUNDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VROUNDPS_LAST_DEFINED 1 -#define XED_IFORMFL_VROUNDSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VROUNDSD_LAST_DEFINED 1 -#define XED_IFORMFL_VROUNDSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VROUNDSS_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRT14PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRT14PD_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRT14PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRT14PS_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRT14SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRT14SD_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRT14SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRT14SS_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRT28PD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRT28PD_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRT28PS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRT28PS_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRT28SD_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRT28SD_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRT28SS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRT28SS_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRTPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRTPH_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRTPS_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRTSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRTSH_LAST_DEFINED 1 -#define XED_IFORMFL_VRSQRTSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VRSQRTSS_LAST_DEFINED 1 -#define XED_IFORMFL_VSCALEFPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCALEFPD_LAST_DEFINED 1 -#define XED_IFORMFL_VSCALEFPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCALEFPH_LAST_DEFINED 1 -#define XED_IFORMFL_VSCALEFPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCALEFPS_LAST_DEFINED 1 -#define XED_IFORMFL_VSCALEFSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCALEFSD_LAST_DEFINED 1 -#define XED_IFORMFL_VSCALEFSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCALEFSH_LAST_DEFINED 1 -#define XED_IFORMFL_VSCALEFSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCALEFSS_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERDPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERDPD_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERDPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERDPS_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF0DPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF0DPD_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF0DPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF0DPS_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF0QPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF0QPD_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF0QPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF0QPS_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF1DPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF1DPD_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF1DPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF1DPS_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF1QPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF1QPD_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF1QPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERPF1QPS_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERQPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERQPD_LAST_DEFINED 1 -#define XED_IFORMFL_VSCATTERQPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSCATTERQPS_LAST_DEFINED 1 -#define XED_IFORMFL_VSHUFF32X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VSHUFF32X4_LAST_DEFINED 1 -#define XED_IFORMFL_VSHUFF64X2_FIRST_DEFINED 1 -#define XED_IFORMFL_VSHUFF64X2_LAST_DEFINED 1 -#define XED_IFORMFL_VSHUFI32X4_FIRST_DEFINED 1 -#define XED_IFORMFL_VSHUFI32X4_LAST_DEFINED 1 -#define XED_IFORMFL_VSHUFI64X2_FIRST_DEFINED 1 -#define XED_IFORMFL_VSHUFI64X2_LAST_DEFINED 1 -#define XED_IFORMFL_VSHUFPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSHUFPD_LAST_DEFINED 1 -#define XED_IFORMFL_VSHUFPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSHUFPS_LAST_DEFINED 1 -#define XED_IFORMFL_VSQRTPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSQRTPD_LAST_DEFINED 1 -#define XED_IFORMFL_VSQRTPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VSQRTPH_LAST_DEFINED 1 -#define XED_IFORMFL_VSQRTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSQRTPS_LAST_DEFINED 1 -#define XED_IFORMFL_VSQRTSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSQRTSD_LAST_DEFINED 1 -#define XED_IFORMFL_VSQRTSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VSQRTSH_LAST_DEFINED 1 -#define XED_IFORMFL_VSQRTSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSQRTSS_LAST_DEFINED 1 -#define XED_IFORMFL_VSTMXCSR_FIRST_DEFINED 1 -#define XED_IFORMFL_VSTMXCSR_LAST_DEFINED 1 -#define XED_IFORMFL_VSUBPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSUBPD_LAST_DEFINED 1 -#define XED_IFORMFL_VSUBPH_FIRST_DEFINED 1 -#define XED_IFORMFL_VSUBPH_LAST_DEFINED 1 -#define XED_IFORMFL_VSUBPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSUBPS_LAST_DEFINED 1 -#define XED_IFORMFL_VSUBSD_FIRST_DEFINED 1 -#define XED_IFORMFL_VSUBSD_LAST_DEFINED 1 -#define XED_IFORMFL_VSUBSH_FIRST_DEFINED 1 -#define XED_IFORMFL_VSUBSH_LAST_DEFINED 1 -#define XED_IFORMFL_VSUBSS_FIRST_DEFINED 1 -#define XED_IFORMFL_VSUBSS_LAST_DEFINED 1 -#define XED_IFORMFL_VTESTPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VTESTPD_LAST_DEFINED 1 -#define XED_IFORMFL_VTESTPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VTESTPS_LAST_DEFINED 1 -#define XED_IFORMFL_VUCOMISD_FIRST_DEFINED 1 -#define XED_IFORMFL_VUCOMISD_LAST_DEFINED 1 -#define XED_IFORMFL_VUCOMISH_FIRST_DEFINED 1 -#define XED_IFORMFL_VUCOMISH_LAST_DEFINED 1 -#define XED_IFORMFL_VUCOMISS_FIRST_DEFINED 1 -#define XED_IFORMFL_VUCOMISS_LAST_DEFINED 1 -#define XED_IFORMFL_VUNPCKHPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VUNPCKHPD_LAST_DEFINED 1 -#define XED_IFORMFL_VUNPCKHPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VUNPCKHPS_LAST_DEFINED 1 -#define XED_IFORMFL_VUNPCKLPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VUNPCKLPD_LAST_DEFINED 1 -#define XED_IFORMFL_VUNPCKLPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VUNPCKLPS_LAST_DEFINED 1 -#define XED_IFORMFL_VXORPD_FIRST_DEFINED 1 -#define XED_IFORMFL_VXORPD_LAST_DEFINED 1 -#define XED_IFORMFL_VXORPS_FIRST_DEFINED 1 -#define XED_IFORMFL_VXORPS_LAST_DEFINED 1 -#define XED_IFORMFL_VZEROALL_FIRST_DEFINED 1 -#define XED_IFORMFL_VZEROALL_LAST_DEFINED 1 -#define XED_IFORMFL_VZEROUPPER_FIRST_DEFINED 1 -#define XED_IFORMFL_VZEROUPPER_LAST_DEFINED 1 -#define XED_IFORMFL_WBINVD_FIRST_DEFINED 1 -#define XED_IFORMFL_WBINVD_LAST_DEFINED 1 -#define XED_IFORMFL_WBNOINVD_FIRST_DEFINED 1 -#define XED_IFORMFL_WBNOINVD_LAST_DEFINED 1 -#define XED_IFORMFL_WRFSBASE_FIRST_DEFINED 1 -#define XED_IFORMFL_WRFSBASE_LAST_DEFINED 1 -#define XED_IFORMFL_WRGSBASE_FIRST_DEFINED 1 -#define XED_IFORMFL_WRGSBASE_LAST_DEFINED 1 -#define XED_IFORMFL_WRMSR_FIRST_DEFINED 1 -#define XED_IFORMFL_WRMSR_LAST_DEFINED 1 -#define XED_IFORMFL_WRPKRU_FIRST_DEFINED 1 -#define XED_IFORMFL_WRPKRU_LAST_DEFINED 1 -#define XED_IFORMFL_WRSSD_FIRST_DEFINED 1 -#define XED_IFORMFL_WRSSD_LAST_DEFINED 1 -#define XED_IFORMFL_WRSSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_WRSSQ_LAST_DEFINED 1 -#define XED_IFORMFL_WRUSSD_FIRST_DEFINED 1 -#define XED_IFORMFL_WRUSSD_LAST_DEFINED 1 -#define XED_IFORMFL_WRUSSQ_FIRST_DEFINED 1 -#define XED_IFORMFL_WRUSSQ_LAST_DEFINED 1 -#define XED_IFORMFL_XABORT_FIRST_DEFINED 1 -#define XED_IFORMFL_XABORT_LAST_DEFINED 1 -#define XED_IFORMFL_XADD_FIRST_DEFINED 1 -#define XED_IFORMFL_XADD_LAST_DEFINED 1 -#define XED_IFORMFL_XADD_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_XADD_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_XBEGIN_FIRST_DEFINED 1 -#define XED_IFORMFL_XBEGIN_LAST_DEFINED 1 -#define XED_IFORMFL_XCHG_FIRST_DEFINED 1 -#define XED_IFORMFL_XCHG_LAST_DEFINED 1 -#define XED_IFORMFL_XEND_FIRST_DEFINED 1 -#define XED_IFORMFL_XEND_LAST_DEFINED 1 -#define XED_IFORMFL_XGETBV_FIRST_DEFINED 1 -#define XED_IFORMFL_XGETBV_LAST_DEFINED 1 -#define XED_IFORMFL_XLAT_FIRST_DEFINED 1 -#define XED_IFORMFL_XLAT_LAST_DEFINED 1 -#define XED_IFORMFL_XOR_FIRST_DEFINED 1 -#define XED_IFORMFL_XOR_LAST_DEFINED 1 -#define XED_IFORMFL_XORPD_FIRST_DEFINED 1 -#define XED_IFORMFL_XORPD_LAST_DEFINED 1 -#define XED_IFORMFL_XORPS_FIRST_DEFINED 1 -#define XED_IFORMFL_XORPS_LAST_DEFINED 1 -#define XED_IFORMFL_XOR_LOCK_FIRST_DEFINED 1 -#define XED_IFORMFL_XOR_LOCK_LAST_DEFINED 1 -#define XED_IFORMFL_XRESLDTRK_FIRST_DEFINED 1 -#define XED_IFORMFL_XRESLDTRK_LAST_DEFINED 1 -#define XED_IFORMFL_XRSTOR_FIRST_DEFINED 1 -#define XED_IFORMFL_XRSTOR_LAST_DEFINED 1 -#define XED_IFORMFL_XRSTOR64_FIRST_DEFINED 1 -#define XED_IFORMFL_XRSTOR64_LAST_DEFINED 1 -#define XED_IFORMFL_XRSTORS_FIRST_DEFINED 1 -#define XED_IFORMFL_XRSTORS_LAST_DEFINED 1 -#define XED_IFORMFL_XRSTORS64_FIRST_DEFINED 1 -#define XED_IFORMFL_XRSTORS64_LAST_DEFINED 1 -#define XED_IFORMFL_XSAVE_FIRST_DEFINED 1 -#define XED_IFORMFL_XSAVE_LAST_DEFINED 1 -#define XED_IFORMFL_XSAVE64_FIRST_DEFINED 1 -#define XED_IFORMFL_XSAVE64_LAST_DEFINED 1 -#define XED_IFORMFL_XSAVEC_FIRST_DEFINED 1 -#define XED_IFORMFL_XSAVEC_LAST_DEFINED 1 -#define XED_IFORMFL_XSAVEC64_FIRST_DEFINED 1 -#define XED_IFORMFL_XSAVEC64_LAST_DEFINED 1 -#define XED_IFORMFL_XSAVEOPT_FIRST_DEFINED 1 -#define XED_IFORMFL_XSAVEOPT_LAST_DEFINED 1 -#define XED_IFORMFL_XSAVEOPT64_FIRST_DEFINED 1 -#define XED_IFORMFL_XSAVEOPT64_LAST_DEFINED 1 -#define XED_IFORMFL_XSAVES_FIRST_DEFINED 1 -#define XED_IFORMFL_XSAVES_LAST_DEFINED 1 -#define XED_IFORMFL_XSAVES64_FIRST_DEFINED 1 -#define XED_IFORMFL_XSAVES64_LAST_DEFINED 1 -#define XED_IFORMFL_XSETBV_FIRST_DEFINED 1 -#define XED_IFORMFL_XSETBV_LAST_DEFINED 1 -#define XED_IFORMFL_XSTORE_FIRST_DEFINED 1 -#define XED_IFORMFL_XSTORE_LAST_DEFINED 1 -#define XED_IFORMFL_XSUSLDTRK_FIRST_DEFINED 1 -#define XED_IFORMFL_XSUSLDTRK_LAST_DEFINED 1 -#define XED_IFORMFL_XTEST_FIRST_DEFINED 1 -#define XED_IFORMFL_XTEST_LAST_DEFINED 1 -#define XED_IFORMFL_LAST_DEFINED 1 -typedef enum { - XED_IFORMFL_AAA_FIRST=1, - XED_IFORMFL_AAA_LAST=1, - XED_IFORMFL_AAD_FIRST=2, - XED_IFORMFL_AAD_LAST=2, - XED_IFORMFL_AAM_FIRST=3, - XED_IFORMFL_AAM_LAST=3, - XED_IFORMFL_AAS_FIRST=4, - XED_IFORMFL_AAS_LAST=4, - XED_IFORMFL_ADC_FIRST=5, - XED_IFORMFL_ADC_LAST=22, - XED_IFORMFL_ADCX_FIRST=23, - XED_IFORMFL_ADCX_LAST=26, - XED_IFORMFL_ADC_LOCK_FIRST=27, - XED_IFORMFL_ADC_LOCK_LAST=32, - XED_IFORMFL_ADD_FIRST=33, - XED_IFORMFL_ADD_LAST=50, - XED_IFORMFL_ADDPD_FIRST=51, - XED_IFORMFL_ADDPD_LAST=52, - XED_IFORMFL_ADDPS_FIRST=53, - XED_IFORMFL_ADDPS_LAST=54, - XED_IFORMFL_ADDSD_FIRST=55, - XED_IFORMFL_ADDSD_LAST=56, - XED_IFORMFL_ADDSS_FIRST=57, - XED_IFORMFL_ADDSS_LAST=58, - XED_IFORMFL_ADDSUBPD_FIRST=59, - XED_IFORMFL_ADDSUBPD_LAST=60, - XED_IFORMFL_ADDSUBPS_FIRST=61, - XED_IFORMFL_ADDSUBPS_LAST=62, - XED_IFORMFL_ADD_LOCK_FIRST=63, - XED_IFORMFL_ADD_LOCK_LAST=68, - XED_IFORMFL_ADOX_FIRST=69, - XED_IFORMFL_ADOX_LAST=72, - XED_IFORMFL_AESDEC_FIRST=73, - XED_IFORMFL_AESDEC_LAST=74, - XED_IFORMFL_AESDEC128KL_FIRST=75, - XED_IFORMFL_AESDEC128KL_LAST=75, - XED_IFORMFL_AESDEC256KL_FIRST=76, - XED_IFORMFL_AESDEC256KL_LAST=76, - XED_IFORMFL_AESDECLAST_FIRST=77, - XED_IFORMFL_AESDECLAST_LAST=78, - XED_IFORMFL_AESDECWIDE128KL_FIRST=79, - XED_IFORMFL_AESDECWIDE128KL_LAST=79, - XED_IFORMFL_AESDECWIDE256KL_FIRST=80, - XED_IFORMFL_AESDECWIDE256KL_LAST=80, - XED_IFORMFL_AESENC_FIRST=81, - XED_IFORMFL_AESENC_LAST=82, - XED_IFORMFL_AESENC128KL_FIRST=83, - XED_IFORMFL_AESENC128KL_LAST=83, - XED_IFORMFL_AESENC256KL_FIRST=84, - XED_IFORMFL_AESENC256KL_LAST=84, - XED_IFORMFL_AESENCLAST_FIRST=85, - XED_IFORMFL_AESENCLAST_LAST=86, - XED_IFORMFL_AESENCWIDE128KL_FIRST=87, - XED_IFORMFL_AESENCWIDE128KL_LAST=87, - XED_IFORMFL_AESENCWIDE256KL_FIRST=88, - XED_IFORMFL_AESENCWIDE256KL_LAST=88, - XED_IFORMFL_AESIMC_FIRST=89, - XED_IFORMFL_AESIMC_LAST=90, - XED_IFORMFL_AESKEYGENASSIST_FIRST=91, - XED_IFORMFL_AESKEYGENASSIST_LAST=92, - XED_IFORMFL_AND_FIRST=93, - XED_IFORMFL_AND_LAST=110, - XED_IFORMFL_ANDN_FIRST=111, - XED_IFORMFL_ANDN_LAST=114, - XED_IFORMFL_ANDNPD_FIRST=115, - XED_IFORMFL_ANDNPD_LAST=116, - XED_IFORMFL_ANDNPS_FIRST=117, - XED_IFORMFL_ANDNPS_LAST=118, - XED_IFORMFL_ANDPD_FIRST=119, - XED_IFORMFL_ANDPD_LAST=120, - XED_IFORMFL_ANDPS_FIRST=121, - XED_IFORMFL_ANDPS_LAST=122, - XED_IFORMFL_AND_LOCK_FIRST=123, - XED_IFORMFL_AND_LOCK_LAST=128, - XED_IFORMFL_ARPL_FIRST=129, - XED_IFORMFL_ARPL_LAST=130, - XED_IFORMFL_BEXTR_FIRST=131, - XED_IFORMFL_BEXTR_LAST=134, - XED_IFORMFL_BEXTR_XOP_FIRST=135, - XED_IFORMFL_BEXTR_XOP_LAST=138, - XED_IFORMFL_BLCFILL_FIRST=139, - XED_IFORMFL_BLCFILL_LAST=142, - XED_IFORMFL_BLCI_FIRST=143, - XED_IFORMFL_BLCI_LAST=146, - XED_IFORMFL_BLCIC_FIRST=147, - XED_IFORMFL_BLCIC_LAST=150, - XED_IFORMFL_BLCMSK_FIRST=151, - XED_IFORMFL_BLCMSK_LAST=154, - XED_IFORMFL_BLCS_FIRST=155, - XED_IFORMFL_BLCS_LAST=158, - XED_IFORMFL_BLENDPD_FIRST=159, - XED_IFORMFL_BLENDPD_LAST=160, - XED_IFORMFL_BLENDPS_FIRST=161, - XED_IFORMFL_BLENDPS_LAST=162, - XED_IFORMFL_BLENDVPD_FIRST=163, - XED_IFORMFL_BLENDVPD_LAST=164, - XED_IFORMFL_BLENDVPS_FIRST=165, - XED_IFORMFL_BLENDVPS_LAST=166, - XED_IFORMFL_BLSFILL_FIRST=167, - XED_IFORMFL_BLSFILL_LAST=170, - XED_IFORMFL_BLSI_FIRST=171, - XED_IFORMFL_BLSI_LAST=174, - XED_IFORMFL_BLSIC_FIRST=175, - XED_IFORMFL_BLSIC_LAST=178, - XED_IFORMFL_BLSMSK_FIRST=179, - XED_IFORMFL_BLSMSK_LAST=182, - XED_IFORMFL_BLSR_FIRST=183, - XED_IFORMFL_BLSR_LAST=186, - XED_IFORMFL_BNDCL_FIRST=187, - XED_IFORMFL_BNDCL_LAST=189, - XED_IFORMFL_BNDCN_FIRST=190, - XED_IFORMFL_BNDCN_LAST=192, - XED_IFORMFL_BNDCU_FIRST=193, - XED_IFORMFL_BNDCU_LAST=195, - XED_IFORMFL_BNDLDX_FIRST=196, - XED_IFORMFL_BNDLDX_LAST=197, - XED_IFORMFL_BNDMK_FIRST=198, - XED_IFORMFL_BNDMK_LAST=198, - XED_IFORMFL_BNDMOV_FIRST=199, - XED_IFORMFL_BNDMOV_LAST=203, - XED_IFORMFL_BNDSTX_FIRST=204, - XED_IFORMFL_BNDSTX_LAST=205, - XED_IFORMFL_BOUND_FIRST=206, - XED_IFORMFL_BOUND_LAST=207, - XED_IFORMFL_BSF_FIRST=208, - XED_IFORMFL_BSF_LAST=209, - XED_IFORMFL_BSR_FIRST=210, - XED_IFORMFL_BSR_LAST=211, - XED_IFORMFL_BSWAP_FIRST=212, - XED_IFORMFL_BSWAP_LAST=212, - XED_IFORMFL_BT_FIRST=213, - XED_IFORMFL_BT_LAST=216, - XED_IFORMFL_BTC_FIRST=217, - XED_IFORMFL_BTC_LAST=220, - XED_IFORMFL_BTC_LOCK_FIRST=221, - XED_IFORMFL_BTC_LOCK_LAST=222, - XED_IFORMFL_BTR_FIRST=223, - XED_IFORMFL_BTR_LAST=226, - XED_IFORMFL_BTR_LOCK_FIRST=227, - XED_IFORMFL_BTR_LOCK_LAST=228, - XED_IFORMFL_BTS_FIRST=229, - XED_IFORMFL_BTS_LAST=232, - XED_IFORMFL_BTS_LOCK_FIRST=233, - XED_IFORMFL_BTS_LOCK_LAST=234, - XED_IFORMFL_BZHI_FIRST=235, - XED_IFORMFL_BZHI_LAST=238, - XED_IFORMFL_CALL_FAR_FIRST=239, - XED_IFORMFL_CALL_FAR_LAST=240, - XED_IFORMFL_CALL_NEAR_FIRST=241, - XED_IFORMFL_CALL_NEAR_LAST=244, - XED_IFORMFL_CBW_FIRST=245, - XED_IFORMFL_CBW_LAST=245, - XED_IFORMFL_CDQ_FIRST=246, - XED_IFORMFL_CDQ_LAST=246, - XED_IFORMFL_CDQE_FIRST=247, - XED_IFORMFL_CDQE_LAST=247, - XED_IFORMFL_CLAC_FIRST=248, - XED_IFORMFL_CLAC_LAST=248, - XED_IFORMFL_CLC_FIRST=249, - XED_IFORMFL_CLC_LAST=249, - XED_IFORMFL_CLD_FIRST=250, - XED_IFORMFL_CLD_LAST=250, - XED_IFORMFL_CLDEMOTE_FIRST=251, - XED_IFORMFL_CLDEMOTE_LAST=251, - XED_IFORMFL_CLFLUSH_FIRST=252, - XED_IFORMFL_CLFLUSH_LAST=252, - XED_IFORMFL_CLFLUSHOPT_FIRST=253, - XED_IFORMFL_CLFLUSHOPT_LAST=253, - XED_IFORMFL_CLGI_FIRST=254, - XED_IFORMFL_CLGI_LAST=254, - XED_IFORMFL_CLI_FIRST=255, - XED_IFORMFL_CLI_LAST=255, - XED_IFORMFL_CLRSSBSY_FIRST=256, - XED_IFORMFL_CLRSSBSY_LAST=256, - XED_IFORMFL_CLTS_FIRST=257, - XED_IFORMFL_CLTS_LAST=257, - XED_IFORMFL_CLUI_FIRST=258, - XED_IFORMFL_CLUI_LAST=258, - XED_IFORMFL_CLWB_FIRST=259, - XED_IFORMFL_CLWB_LAST=259, - XED_IFORMFL_CLZERO_FIRST=260, - XED_IFORMFL_CLZERO_LAST=260, - XED_IFORMFL_CMC_FIRST=261, - XED_IFORMFL_CMC_LAST=261, - XED_IFORMFL_CMOVB_FIRST=262, - XED_IFORMFL_CMOVB_LAST=263, - XED_IFORMFL_CMOVBE_FIRST=264, - XED_IFORMFL_CMOVBE_LAST=265, - XED_IFORMFL_CMOVL_FIRST=266, - XED_IFORMFL_CMOVL_LAST=267, - XED_IFORMFL_CMOVLE_FIRST=268, - XED_IFORMFL_CMOVLE_LAST=269, - XED_IFORMFL_CMOVNB_FIRST=270, - XED_IFORMFL_CMOVNB_LAST=271, - XED_IFORMFL_CMOVNBE_FIRST=272, - XED_IFORMFL_CMOVNBE_LAST=273, - XED_IFORMFL_CMOVNL_FIRST=274, - XED_IFORMFL_CMOVNL_LAST=275, - XED_IFORMFL_CMOVNLE_FIRST=276, - XED_IFORMFL_CMOVNLE_LAST=277, - XED_IFORMFL_CMOVNO_FIRST=278, - XED_IFORMFL_CMOVNO_LAST=279, - XED_IFORMFL_CMOVNP_FIRST=280, - XED_IFORMFL_CMOVNP_LAST=281, - XED_IFORMFL_CMOVNS_FIRST=282, - XED_IFORMFL_CMOVNS_LAST=283, - XED_IFORMFL_CMOVNZ_FIRST=284, - XED_IFORMFL_CMOVNZ_LAST=285, - XED_IFORMFL_CMOVO_FIRST=286, - XED_IFORMFL_CMOVO_LAST=287, - XED_IFORMFL_CMOVP_FIRST=288, - XED_IFORMFL_CMOVP_LAST=289, - XED_IFORMFL_CMOVS_FIRST=290, - XED_IFORMFL_CMOVS_LAST=291, - XED_IFORMFL_CMOVZ_FIRST=292, - XED_IFORMFL_CMOVZ_LAST=293, - XED_IFORMFL_CMP_FIRST=294, - XED_IFORMFL_CMP_LAST=311, - XED_IFORMFL_CMPPD_FIRST=312, - XED_IFORMFL_CMPPD_LAST=313, - XED_IFORMFL_CMPPS_FIRST=314, - XED_IFORMFL_CMPPS_LAST=315, - XED_IFORMFL_CMPSB_FIRST=316, - XED_IFORMFL_CMPSB_LAST=316, - XED_IFORMFL_CMPSD_FIRST=317, - XED_IFORMFL_CMPSD_LAST=317, - XED_IFORMFL_CMPSD_XMM_FIRST=318, - XED_IFORMFL_CMPSD_XMM_LAST=319, - XED_IFORMFL_CMPSQ_FIRST=320, - XED_IFORMFL_CMPSQ_LAST=320, - XED_IFORMFL_CMPSS_FIRST=321, - XED_IFORMFL_CMPSS_LAST=322, - XED_IFORMFL_CMPSW_FIRST=323, - XED_IFORMFL_CMPSW_LAST=323, - XED_IFORMFL_CMPXCHG_FIRST=324, - XED_IFORMFL_CMPXCHG_LAST=327, - XED_IFORMFL_CMPXCHG16B_FIRST=328, - XED_IFORMFL_CMPXCHG16B_LAST=328, - XED_IFORMFL_CMPXCHG16B_LOCK_FIRST=329, - XED_IFORMFL_CMPXCHG16B_LOCK_LAST=329, - XED_IFORMFL_CMPXCHG8B_FIRST=330, - XED_IFORMFL_CMPXCHG8B_LAST=330, - XED_IFORMFL_CMPXCHG8B_LOCK_FIRST=331, - XED_IFORMFL_CMPXCHG8B_LOCK_LAST=331, - XED_IFORMFL_CMPXCHG_LOCK_FIRST=332, - XED_IFORMFL_CMPXCHG_LOCK_LAST=333, - XED_IFORMFL_COMISD_FIRST=334, - XED_IFORMFL_COMISD_LAST=335, - XED_IFORMFL_COMISS_FIRST=336, - XED_IFORMFL_COMISS_LAST=337, - XED_IFORMFL_CPUID_FIRST=338, - XED_IFORMFL_CPUID_LAST=338, - XED_IFORMFL_CQO_FIRST=339, - XED_IFORMFL_CQO_LAST=339, - XED_IFORMFL_CRC32_FIRST=340, - XED_IFORMFL_CRC32_LAST=343, - XED_IFORMFL_CVTDQ2PD_FIRST=344, - XED_IFORMFL_CVTDQ2PD_LAST=345, - XED_IFORMFL_CVTDQ2PS_FIRST=346, - XED_IFORMFL_CVTDQ2PS_LAST=347, - XED_IFORMFL_CVTPD2DQ_FIRST=348, - XED_IFORMFL_CVTPD2DQ_LAST=349, - XED_IFORMFL_CVTPD2PI_FIRST=350, - XED_IFORMFL_CVTPD2PI_LAST=351, - XED_IFORMFL_CVTPD2PS_FIRST=352, - XED_IFORMFL_CVTPD2PS_LAST=353, - XED_IFORMFL_CVTPI2PD_FIRST=354, - XED_IFORMFL_CVTPI2PD_LAST=355, - XED_IFORMFL_CVTPI2PS_FIRST=356, - XED_IFORMFL_CVTPI2PS_LAST=357, - XED_IFORMFL_CVTPS2DQ_FIRST=358, - XED_IFORMFL_CVTPS2DQ_LAST=359, - XED_IFORMFL_CVTPS2PD_FIRST=360, - XED_IFORMFL_CVTPS2PD_LAST=361, - XED_IFORMFL_CVTPS2PI_FIRST=362, - XED_IFORMFL_CVTPS2PI_LAST=363, - XED_IFORMFL_CVTSD2SI_FIRST=364, - XED_IFORMFL_CVTSD2SI_LAST=367, - XED_IFORMFL_CVTSD2SS_FIRST=368, - XED_IFORMFL_CVTSD2SS_LAST=369, - XED_IFORMFL_CVTSI2SD_FIRST=370, - XED_IFORMFL_CVTSI2SD_LAST=373, - XED_IFORMFL_CVTSI2SS_FIRST=374, - XED_IFORMFL_CVTSI2SS_LAST=377, - XED_IFORMFL_CVTSS2SD_FIRST=378, - XED_IFORMFL_CVTSS2SD_LAST=379, - XED_IFORMFL_CVTSS2SI_FIRST=380, - XED_IFORMFL_CVTSS2SI_LAST=383, - XED_IFORMFL_CVTTPD2DQ_FIRST=384, - XED_IFORMFL_CVTTPD2DQ_LAST=385, - XED_IFORMFL_CVTTPD2PI_FIRST=386, - XED_IFORMFL_CVTTPD2PI_LAST=387, - XED_IFORMFL_CVTTPS2DQ_FIRST=388, - XED_IFORMFL_CVTTPS2DQ_LAST=389, - XED_IFORMFL_CVTTPS2PI_FIRST=390, - XED_IFORMFL_CVTTPS2PI_LAST=391, - XED_IFORMFL_CVTTSD2SI_FIRST=392, - XED_IFORMFL_CVTTSD2SI_LAST=395, - XED_IFORMFL_CVTTSS2SI_FIRST=396, - XED_IFORMFL_CVTTSS2SI_LAST=399, - XED_IFORMFL_CWD_FIRST=400, - XED_IFORMFL_CWD_LAST=400, - XED_IFORMFL_CWDE_FIRST=401, - XED_IFORMFL_CWDE_LAST=401, - XED_IFORMFL_DAA_FIRST=402, - XED_IFORMFL_DAA_LAST=402, - XED_IFORMFL_DAS_FIRST=403, - XED_IFORMFL_DAS_LAST=403, - XED_IFORMFL_DEC_FIRST=404, - XED_IFORMFL_DEC_LAST=408, - XED_IFORMFL_DEC_LOCK_FIRST=409, - XED_IFORMFL_DEC_LOCK_LAST=410, - XED_IFORMFL_DIV_FIRST=411, - XED_IFORMFL_DIV_LAST=414, - XED_IFORMFL_DIVPD_FIRST=415, - XED_IFORMFL_DIVPD_LAST=416, - XED_IFORMFL_DIVPS_FIRST=417, - XED_IFORMFL_DIVPS_LAST=418, - XED_IFORMFL_DIVSD_FIRST=419, - XED_IFORMFL_DIVSD_LAST=420, - XED_IFORMFL_DIVSS_FIRST=421, - XED_IFORMFL_DIVSS_LAST=422, - XED_IFORMFL_DPPD_FIRST=423, - XED_IFORMFL_DPPD_LAST=424, - XED_IFORMFL_DPPS_FIRST=425, - XED_IFORMFL_DPPS_LAST=426, - XED_IFORMFL_EMMS_FIRST=427, - XED_IFORMFL_EMMS_LAST=427, - XED_IFORMFL_ENCLS_FIRST=428, - XED_IFORMFL_ENCLS_LAST=428, - XED_IFORMFL_ENCLU_FIRST=429, - XED_IFORMFL_ENCLU_LAST=429, - XED_IFORMFL_ENCLV_FIRST=430, - XED_IFORMFL_ENCLV_LAST=430, - XED_IFORMFL_ENCODEKEY128_FIRST=431, - XED_IFORMFL_ENCODEKEY128_LAST=431, - XED_IFORMFL_ENCODEKEY256_FIRST=432, - XED_IFORMFL_ENCODEKEY256_LAST=432, - XED_IFORMFL_ENDBR32_FIRST=433, - XED_IFORMFL_ENDBR32_LAST=433, - XED_IFORMFL_ENDBR64_FIRST=434, - XED_IFORMFL_ENDBR64_LAST=434, - XED_IFORMFL_ENQCMD_FIRST=435, - XED_IFORMFL_ENQCMD_LAST=435, - XED_IFORMFL_ENQCMDS_FIRST=436, - XED_IFORMFL_ENQCMDS_LAST=436, - XED_IFORMFL_ENTER_FIRST=437, - XED_IFORMFL_ENTER_LAST=437, - XED_IFORMFL_EXTRACTPS_FIRST=438, - XED_IFORMFL_EXTRACTPS_LAST=439, - XED_IFORMFL_EXTRQ_FIRST=440, - XED_IFORMFL_EXTRQ_LAST=441, - XED_IFORMFL_F2XM1_FIRST=442, - XED_IFORMFL_F2XM1_LAST=442, - XED_IFORMFL_FABS_FIRST=443, - XED_IFORMFL_FABS_LAST=443, - XED_IFORMFL_FADD_FIRST=444, - XED_IFORMFL_FADD_LAST=447, - XED_IFORMFL_FADDP_FIRST=448, - XED_IFORMFL_FADDP_LAST=448, - XED_IFORMFL_FBLD_FIRST=449, - XED_IFORMFL_FBLD_LAST=449, - XED_IFORMFL_FBSTP_FIRST=450, - XED_IFORMFL_FBSTP_LAST=450, - XED_IFORMFL_FCHS_FIRST=451, - XED_IFORMFL_FCHS_LAST=451, - XED_IFORMFL_FCMOVB_FIRST=452, - XED_IFORMFL_FCMOVB_LAST=452, - XED_IFORMFL_FCMOVBE_FIRST=453, - XED_IFORMFL_FCMOVBE_LAST=453, - XED_IFORMFL_FCMOVE_FIRST=454, - XED_IFORMFL_FCMOVE_LAST=454, - XED_IFORMFL_FCMOVNB_FIRST=455, - XED_IFORMFL_FCMOVNB_LAST=455, - XED_IFORMFL_FCMOVNBE_FIRST=456, - XED_IFORMFL_FCMOVNBE_LAST=456, - XED_IFORMFL_FCMOVNE_FIRST=457, - XED_IFORMFL_FCMOVNE_LAST=457, - XED_IFORMFL_FCMOVNU_FIRST=458, - XED_IFORMFL_FCMOVNU_LAST=458, - XED_IFORMFL_FCMOVU_FIRST=459, - XED_IFORMFL_FCMOVU_LAST=459, - XED_IFORMFL_FCOM_FIRST=460, - XED_IFORMFL_FCOM_LAST=463, - XED_IFORMFL_FCOMI_FIRST=464, - XED_IFORMFL_FCOMI_LAST=464, - XED_IFORMFL_FCOMIP_FIRST=465, - XED_IFORMFL_FCOMIP_LAST=465, - XED_IFORMFL_FCOMP_FIRST=466, - XED_IFORMFL_FCOMP_LAST=470, - XED_IFORMFL_FCOMPP_FIRST=471, - XED_IFORMFL_FCOMPP_LAST=471, - XED_IFORMFL_FCOS_FIRST=472, - XED_IFORMFL_FCOS_LAST=472, - XED_IFORMFL_FDECSTP_FIRST=473, - XED_IFORMFL_FDECSTP_LAST=473, - XED_IFORMFL_FDISI8087_NOP_FIRST=474, - XED_IFORMFL_FDISI8087_NOP_LAST=474, - XED_IFORMFL_FDIV_FIRST=475, - XED_IFORMFL_FDIV_LAST=478, - XED_IFORMFL_FDIVP_FIRST=479, - XED_IFORMFL_FDIVP_LAST=479, - XED_IFORMFL_FDIVR_FIRST=480, - XED_IFORMFL_FDIVR_LAST=483, - XED_IFORMFL_FDIVRP_FIRST=484, - XED_IFORMFL_FDIVRP_LAST=484, - XED_IFORMFL_FEMMS_FIRST=485, - XED_IFORMFL_FEMMS_LAST=485, - XED_IFORMFL_FENI8087_NOP_FIRST=486, - XED_IFORMFL_FENI8087_NOP_LAST=486, - XED_IFORMFL_FFREE_FIRST=487, - XED_IFORMFL_FFREE_LAST=487, - XED_IFORMFL_FFREEP_FIRST=488, - XED_IFORMFL_FFREEP_LAST=488, - XED_IFORMFL_FIADD_FIRST=489, - XED_IFORMFL_FIADD_LAST=490, - XED_IFORMFL_FICOM_FIRST=491, - XED_IFORMFL_FICOM_LAST=492, - XED_IFORMFL_FICOMP_FIRST=493, - XED_IFORMFL_FICOMP_LAST=494, - XED_IFORMFL_FIDIV_FIRST=495, - XED_IFORMFL_FIDIV_LAST=496, - XED_IFORMFL_FIDIVR_FIRST=497, - XED_IFORMFL_FIDIVR_LAST=498, - XED_IFORMFL_FILD_FIRST=499, - XED_IFORMFL_FILD_LAST=501, - XED_IFORMFL_FIMUL_FIRST=502, - XED_IFORMFL_FIMUL_LAST=503, - XED_IFORMFL_FINCSTP_FIRST=504, - XED_IFORMFL_FINCSTP_LAST=504, - XED_IFORMFL_FIST_FIRST=505, - XED_IFORMFL_FIST_LAST=506, - XED_IFORMFL_FISTP_FIRST=507, - XED_IFORMFL_FISTP_LAST=509, - XED_IFORMFL_FISTTP_FIRST=510, - XED_IFORMFL_FISTTP_LAST=512, - XED_IFORMFL_FISUB_FIRST=513, - XED_IFORMFL_FISUB_LAST=514, - XED_IFORMFL_FISUBR_FIRST=515, - XED_IFORMFL_FISUBR_LAST=516, - XED_IFORMFL_FLD_FIRST=517, - XED_IFORMFL_FLD_LAST=520, - XED_IFORMFL_FLD1_FIRST=521, - XED_IFORMFL_FLD1_LAST=521, - XED_IFORMFL_FLDCW_FIRST=522, - XED_IFORMFL_FLDCW_LAST=522, - XED_IFORMFL_FLDENV_FIRST=523, - XED_IFORMFL_FLDENV_LAST=524, - XED_IFORMFL_FLDL2E_FIRST=525, - XED_IFORMFL_FLDL2E_LAST=525, - XED_IFORMFL_FLDL2T_FIRST=526, - XED_IFORMFL_FLDL2T_LAST=526, - XED_IFORMFL_FLDLG2_FIRST=527, - XED_IFORMFL_FLDLG2_LAST=527, - XED_IFORMFL_FLDLN2_FIRST=528, - XED_IFORMFL_FLDLN2_LAST=528, - XED_IFORMFL_FLDPI_FIRST=529, - XED_IFORMFL_FLDPI_LAST=529, - XED_IFORMFL_FLDZ_FIRST=530, - XED_IFORMFL_FLDZ_LAST=530, - XED_IFORMFL_FMUL_FIRST=531, - XED_IFORMFL_FMUL_LAST=534, - XED_IFORMFL_FMULP_FIRST=535, - XED_IFORMFL_FMULP_LAST=535, - XED_IFORMFL_FNCLEX_FIRST=536, - XED_IFORMFL_FNCLEX_LAST=536, - XED_IFORMFL_FNINIT_FIRST=537, - XED_IFORMFL_FNINIT_LAST=537, - XED_IFORMFL_FNOP_FIRST=538, - XED_IFORMFL_FNOP_LAST=538, - XED_IFORMFL_FNSAVE_FIRST=539, - XED_IFORMFL_FNSAVE_LAST=540, - XED_IFORMFL_FNSTCW_FIRST=541, - XED_IFORMFL_FNSTCW_LAST=541, - XED_IFORMFL_FNSTENV_FIRST=542, - XED_IFORMFL_FNSTENV_LAST=543, - XED_IFORMFL_FNSTSW_FIRST=544, - XED_IFORMFL_FNSTSW_LAST=545, - XED_IFORMFL_FPATAN_FIRST=546, - XED_IFORMFL_FPATAN_LAST=546, - XED_IFORMFL_FPREM_FIRST=547, - XED_IFORMFL_FPREM_LAST=547, - XED_IFORMFL_FPREM1_FIRST=548, - XED_IFORMFL_FPREM1_LAST=548, - XED_IFORMFL_FPTAN_FIRST=549, - XED_IFORMFL_FPTAN_LAST=549, - XED_IFORMFL_FRNDINT_FIRST=550, - XED_IFORMFL_FRNDINT_LAST=550, - XED_IFORMFL_FRSTOR_FIRST=551, - XED_IFORMFL_FRSTOR_LAST=552, - XED_IFORMFL_FSCALE_FIRST=553, - XED_IFORMFL_FSCALE_LAST=553, - XED_IFORMFL_FSETPM287_NOP_FIRST=554, - XED_IFORMFL_FSETPM287_NOP_LAST=554, - XED_IFORMFL_FSIN_FIRST=555, - XED_IFORMFL_FSIN_LAST=555, - XED_IFORMFL_FSINCOS_FIRST=556, - XED_IFORMFL_FSINCOS_LAST=556, - XED_IFORMFL_FSQRT_FIRST=557, - XED_IFORMFL_FSQRT_LAST=557, - XED_IFORMFL_FST_FIRST=558, - XED_IFORMFL_FST_LAST=560, - XED_IFORMFL_FSTP_FIRST=561, - XED_IFORMFL_FSTP_LAST=566, - XED_IFORMFL_FSTPNCE_FIRST=567, - XED_IFORMFL_FSTPNCE_LAST=567, - XED_IFORMFL_FSUB_FIRST=568, - XED_IFORMFL_FSUB_LAST=571, - XED_IFORMFL_FSUBP_FIRST=572, - XED_IFORMFL_FSUBP_LAST=572, - XED_IFORMFL_FSUBR_FIRST=573, - XED_IFORMFL_FSUBR_LAST=576, - XED_IFORMFL_FSUBRP_FIRST=577, - XED_IFORMFL_FSUBRP_LAST=577, - XED_IFORMFL_FTST_FIRST=578, - XED_IFORMFL_FTST_LAST=578, - XED_IFORMFL_FUCOM_FIRST=579, - XED_IFORMFL_FUCOM_LAST=579, - XED_IFORMFL_FUCOMI_FIRST=580, - XED_IFORMFL_FUCOMI_LAST=580, - XED_IFORMFL_FUCOMIP_FIRST=581, - XED_IFORMFL_FUCOMIP_LAST=581, - XED_IFORMFL_FUCOMP_FIRST=582, - XED_IFORMFL_FUCOMP_LAST=582, - XED_IFORMFL_FUCOMPP_FIRST=583, - XED_IFORMFL_FUCOMPP_LAST=583, - XED_IFORMFL_FWAIT_FIRST=584, - XED_IFORMFL_FWAIT_LAST=584, - XED_IFORMFL_FXAM_FIRST=585, - XED_IFORMFL_FXAM_LAST=585, - XED_IFORMFL_FXCH_FIRST=586, - XED_IFORMFL_FXCH_LAST=588, - XED_IFORMFL_FXRSTOR_FIRST=589, - XED_IFORMFL_FXRSTOR_LAST=589, - XED_IFORMFL_FXRSTOR64_FIRST=590, - XED_IFORMFL_FXRSTOR64_LAST=590, - XED_IFORMFL_FXSAVE_FIRST=591, - XED_IFORMFL_FXSAVE_LAST=591, - XED_IFORMFL_FXSAVE64_FIRST=592, - XED_IFORMFL_FXSAVE64_LAST=592, - XED_IFORMFL_FXTRACT_FIRST=593, - XED_IFORMFL_FXTRACT_LAST=593, - XED_IFORMFL_FYL2X_FIRST=594, - XED_IFORMFL_FYL2X_LAST=594, - XED_IFORMFL_FYL2XP1_FIRST=595, - XED_IFORMFL_FYL2XP1_LAST=595, - XED_IFORMFL_GETSEC_FIRST=596, - XED_IFORMFL_GETSEC_LAST=596, - XED_IFORMFL_GF2P8AFFINEINVQB_FIRST=597, - XED_IFORMFL_GF2P8AFFINEINVQB_LAST=598, - XED_IFORMFL_GF2P8AFFINEQB_FIRST=599, - XED_IFORMFL_GF2P8AFFINEQB_LAST=600, - XED_IFORMFL_GF2P8MULB_FIRST=601, - XED_IFORMFL_GF2P8MULB_LAST=602, - XED_IFORMFL_HADDPD_FIRST=603, - XED_IFORMFL_HADDPD_LAST=604, - XED_IFORMFL_HADDPS_FIRST=605, - XED_IFORMFL_HADDPS_LAST=606, - XED_IFORMFL_HLT_FIRST=607, - XED_IFORMFL_HLT_LAST=607, - XED_IFORMFL_HRESET_FIRST=608, - XED_IFORMFL_HRESET_LAST=608, - XED_IFORMFL_HSUBPD_FIRST=609, - XED_IFORMFL_HSUBPD_LAST=610, - XED_IFORMFL_HSUBPS_FIRST=611, - XED_IFORMFL_HSUBPS_LAST=612, - XED_IFORMFL_IDIV_FIRST=613, - XED_IFORMFL_IDIV_LAST=616, - XED_IFORMFL_IMUL_FIRST=617, - XED_IFORMFL_IMUL_LAST=626, - XED_IFORMFL_IN_FIRST=627, - XED_IFORMFL_IN_LAST=630, - XED_IFORMFL_INC_FIRST=631, - XED_IFORMFL_INC_LAST=635, - XED_IFORMFL_INCSSPD_FIRST=636, - XED_IFORMFL_INCSSPD_LAST=636, - XED_IFORMFL_INCSSPQ_FIRST=637, - XED_IFORMFL_INCSSPQ_LAST=637, - XED_IFORMFL_INC_LOCK_FIRST=638, - XED_IFORMFL_INC_LOCK_LAST=639, - XED_IFORMFL_INSB_FIRST=640, - XED_IFORMFL_INSB_LAST=640, - XED_IFORMFL_INSD_FIRST=641, - XED_IFORMFL_INSD_LAST=641, - XED_IFORMFL_INSERTPS_FIRST=642, - XED_IFORMFL_INSERTPS_LAST=643, - XED_IFORMFL_INSERTQ_FIRST=644, - XED_IFORMFL_INSERTQ_LAST=645, - XED_IFORMFL_INSW_FIRST=646, - XED_IFORMFL_INSW_LAST=646, - XED_IFORMFL_INT_FIRST=647, - XED_IFORMFL_INT_LAST=647, - XED_IFORMFL_INT1_FIRST=648, - XED_IFORMFL_INT1_LAST=648, - XED_IFORMFL_INT3_FIRST=649, - XED_IFORMFL_INT3_LAST=649, - XED_IFORMFL_INTO_FIRST=650, - XED_IFORMFL_INTO_LAST=650, - XED_IFORMFL_INVD_FIRST=651, - XED_IFORMFL_INVD_LAST=651, - XED_IFORMFL_INVEPT_FIRST=652, - XED_IFORMFL_INVEPT_LAST=653, - XED_IFORMFL_INVLPG_FIRST=654, - XED_IFORMFL_INVLPG_LAST=654, - XED_IFORMFL_INVLPGA_FIRST=655, - XED_IFORMFL_INVLPGA_LAST=655, - XED_IFORMFL_INVLPGB_FIRST=656, - XED_IFORMFL_INVLPGB_LAST=657, - XED_IFORMFL_INVPCID_FIRST=658, - XED_IFORMFL_INVPCID_LAST=659, - XED_IFORMFL_INVVPID_FIRST=660, - XED_IFORMFL_INVVPID_LAST=661, - XED_IFORMFL_IRET_FIRST=662, - XED_IFORMFL_IRET_LAST=662, - XED_IFORMFL_IRETD_FIRST=663, - XED_IFORMFL_IRETD_LAST=663, - XED_IFORMFL_IRETQ_FIRST=664, - XED_IFORMFL_IRETQ_LAST=664, - XED_IFORMFL_JB_FIRST=665, - XED_IFORMFL_JB_LAST=667, - XED_IFORMFL_JBE_FIRST=668, - XED_IFORMFL_JBE_LAST=670, - XED_IFORMFL_JCXZ_FIRST=671, - XED_IFORMFL_JCXZ_LAST=671, - XED_IFORMFL_JECXZ_FIRST=672, - XED_IFORMFL_JECXZ_LAST=672, - XED_IFORMFL_JL_FIRST=673, - XED_IFORMFL_JL_LAST=675, - XED_IFORMFL_JLE_FIRST=676, - XED_IFORMFL_JLE_LAST=678, - XED_IFORMFL_JMP_FIRST=679, - XED_IFORMFL_JMP_LAST=683, - XED_IFORMFL_JMP_FAR_FIRST=684, - XED_IFORMFL_JMP_FAR_LAST=685, - XED_IFORMFL_JNB_FIRST=686, - XED_IFORMFL_JNB_LAST=688, - XED_IFORMFL_JNBE_FIRST=689, - XED_IFORMFL_JNBE_LAST=691, - XED_IFORMFL_JNL_FIRST=692, - XED_IFORMFL_JNL_LAST=694, - XED_IFORMFL_JNLE_FIRST=695, - XED_IFORMFL_JNLE_LAST=697, - XED_IFORMFL_JNO_FIRST=698, - XED_IFORMFL_JNO_LAST=700, - XED_IFORMFL_JNP_FIRST=701, - XED_IFORMFL_JNP_LAST=703, - XED_IFORMFL_JNS_FIRST=704, - XED_IFORMFL_JNS_LAST=706, - XED_IFORMFL_JNZ_FIRST=707, - XED_IFORMFL_JNZ_LAST=709, - XED_IFORMFL_JO_FIRST=710, - XED_IFORMFL_JO_LAST=712, - XED_IFORMFL_JP_FIRST=713, - XED_IFORMFL_JP_LAST=715, - XED_IFORMFL_JRCXZ_FIRST=716, - XED_IFORMFL_JRCXZ_LAST=716, - XED_IFORMFL_JS_FIRST=717, - XED_IFORMFL_JS_LAST=719, - XED_IFORMFL_JZ_FIRST=720, - XED_IFORMFL_JZ_LAST=722, - XED_IFORMFL_KADDB_FIRST=723, - XED_IFORMFL_KADDB_LAST=723, - XED_IFORMFL_KADDD_FIRST=724, - XED_IFORMFL_KADDD_LAST=724, - XED_IFORMFL_KADDQ_FIRST=725, - XED_IFORMFL_KADDQ_LAST=725, - XED_IFORMFL_KADDW_FIRST=726, - XED_IFORMFL_KADDW_LAST=726, - XED_IFORMFL_KANDB_FIRST=727, - XED_IFORMFL_KANDB_LAST=727, - XED_IFORMFL_KANDD_FIRST=728, - XED_IFORMFL_KANDD_LAST=728, - XED_IFORMFL_KANDNB_FIRST=729, - XED_IFORMFL_KANDNB_LAST=729, - XED_IFORMFL_KANDND_FIRST=730, - XED_IFORMFL_KANDND_LAST=730, - XED_IFORMFL_KANDNQ_FIRST=731, - XED_IFORMFL_KANDNQ_LAST=731, - XED_IFORMFL_KANDNW_FIRST=732, - XED_IFORMFL_KANDNW_LAST=732, - XED_IFORMFL_KANDQ_FIRST=733, - XED_IFORMFL_KANDQ_LAST=733, - XED_IFORMFL_KANDW_FIRST=734, - XED_IFORMFL_KANDW_LAST=734, - XED_IFORMFL_KMOVB_FIRST=735, - XED_IFORMFL_KMOVB_LAST=739, - XED_IFORMFL_KMOVD_FIRST=740, - XED_IFORMFL_KMOVD_LAST=744, - XED_IFORMFL_KMOVQ_FIRST=745, - XED_IFORMFL_KMOVQ_LAST=749, - XED_IFORMFL_KMOVW_FIRST=750, - XED_IFORMFL_KMOVW_LAST=754, - XED_IFORMFL_KNOTB_FIRST=755, - XED_IFORMFL_KNOTB_LAST=755, - XED_IFORMFL_KNOTD_FIRST=756, - XED_IFORMFL_KNOTD_LAST=756, - XED_IFORMFL_KNOTQ_FIRST=757, - XED_IFORMFL_KNOTQ_LAST=757, - XED_IFORMFL_KNOTW_FIRST=758, - XED_IFORMFL_KNOTW_LAST=758, - XED_IFORMFL_KORB_FIRST=759, - XED_IFORMFL_KORB_LAST=759, - XED_IFORMFL_KORD_FIRST=760, - XED_IFORMFL_KORD_LAST=760, - XED_IFORMFL_KORQ_FIRST=761, - XED_IFORMFL_KORQ_LAST=761, - XED_IFORMFL_KORTESTB_FIRST=762, - XED_IFORMFL_KORTESTB_LAST=762, - XED_IFORMFL_KORTESTD_FIRST=763, - XED_IFORMFL_KORTESTD_LAST=763, - XED_IFORMFL_KORTESTQ_FIRST=764, - XED_IFORMFL_KORTESTQ_LAST=764, - XED_IFORMFL_KORTESTW_FIRST=765, - XED_IFORMFL_KORTESTW_LAST=765, - XED_IFORMFL_KORW_FIRST=766, - XED_IFORMFL_KORW_LAST=766, - XED_IFORMFL_KSHIFTLB_FIRST=767, - XED_IFORMFL_KSHIFTLB_LAST=767, - XED_IFORMFL_KSHIFTLD_FIRST=768, - XED_IFORMFL_KSHIFTLD_LAST=768, - XED_IFORMFL_KSHIFTLQ_FIRST=769, - XED_IFORMFL_KSHIFTLQ_LAST=769, - XED_IFORMFL_KSHIFTLW_FIRST=770, - XED_IFORMFL_KSHIFTLW_LAST=770, - XED_IFORMFL_KSHIFTRB_FIRST=771, - XED_IFORMFL_KSHIFTRB_LAST=771, - XED_IFORMFL_KSHIFTRD_FIRST=772, - XED_IFORMFL_KSHIFTRD_LAST=772, - XED_IFORMFL_KSHIFTRQ_FIRST=773, - XED_IFORMFL_KSHIFTRQ_LAST=773, - XED_IFORMFL_KSHIFTRW_FIRST=774, - XED_IFORMFL_KSHIFTRW_LAST=774, - XED_IFORMFL_KTESTB_FIRST=775, - XED_IFORMFL_KTESTB_LAST=775, - XED_IFORMFL_KTESTD_FIRST=776, - XED_IFORMFL_KTESTD_LAST=776, - XED_IFORMFL_KTESTQ_FIRST=777, - XED_IFORMFL_KTESTQ_LAST=777, - XED_IFORMFL_KTESTW_FIRST=778, - XED_IFORMFL_KTESTW_LAST=778, - XED_IFORMFL_KUNPCKBW_FIRST=779, - XED_IFORMFL_KUNPCKBW_LAST=779, - XED_IFORMFL_KUNPCKDQ_FIRST=780, - XED_IFORMFL_KUNPCKDQ_LAST=780, - XED_IFORMFL_KUNPCKWD_FIRST=781, - XED_IFORMFL_KUNPCKWD_LAST=781, - XED_IFORMFL_KXNORB_FIRST=782, - XED_IFORMFL_KXNORB_LAST=782, - XED_IFORMFL_KXNORD_FIRST=783, - XED_IFORMFL_KXNORD_LAST=783, - XED_IFORMFL_KXNORQ_FIRST=784, - XED_IFORMFL_KXNORQ_LAST=784, - XED_IFORMFL_KXNORW_FIRST=785, - XED_IFORMFL_KXNORW_LAST=785, - XED_IFORMFL_KXORB_FIRST=786, - XED_IFORMFL_KXORB_LAST=786, - XED_IFORMFL_KXORD_FIRST=787, - XED_IFORMFL_KXORD_LAST=787, - XED_IFORMFL_KXORQ_FIRST=788, - XED_IFORMFL_KXORQ_LAST=788, - XED_IFORMFL_KXORW_FIRST=789, - XED_IFORMFL_KXORW_LAST=789, - XED_IFORMFL_LAHF_FIRST=790, - XED_IFORMFL_LAHF_LAST=790, - XED_IFORMFL_LAR_FIRST=791, - XED_IFORMFL_LAR_LAST=792, - XED_IFORMFL_LDDQU_FIRST=793, - XED_IFORMFL_LDDQU_LAST=793, - XED_IFORMFL_LDMXCSR_FIRST=794, - XED_IFORMFL_LDMXCSR_LAST=794, - XED_IFORMFL_LDS_FIRST=795, - XED_IFORMFL_LDS_LAST=795, - XED_IFORMFL_LDTILECFG_FIRST=796, - XED_IFORMFL_LDTILECFG_LAST=796, - XED_IFORMFL_LEA_FIRST=797, - XED_IFORMFL_LEA_LAST=797, - XED_IFORMFL_LEAVE_FIRST=798, - XED_IFORMFL_LEAVE_LAST=798, - XED_IFORMFL_LES_FIRST=799, - XED_IFORMFL_LES_LAST=799, - XED_IFORMFL_LFENCE_FIRST=800, - XED_IFORMFL_LFENCE_LAST=800, - XED_IFORMFL_LFS_FIRST=801, - XED_IFORMFL_LFS_LAST=801, - XED_IFORMFL_LGDT_FIRST=802, - XED_IFORMFL_LGDT_LAST=803, - XED_IFORMFL_LGS_FIRST=804, - XED_IFORMFL_LGS_LAST=804, - XED_IFORMFL_LIDT_FIRST=805, - XED_IFORMFL_LIDT_LAST=806, - XED_IFORMFL_LLDT_FIRST=807, - XED_IFORMFL_LLDT_LAST=808, - XED_IFORMFL_LLWPCB_FIRST=809, - XED_IFORMFL_LLWPCB_LAST=809, - XED_IFORMFL_LMSW_FIRST=810, - XED_IFORMFL_LMSW_LAST=811, - XED_IFORMFL_LOADIWKEY_FIRST=812, - XED_IFORMFL_LOADIWKEY_LAST=812, - XED_IFORMFL_LODSB_FIRST=813, - XED_IFORMFL_LODSB_LAST=813, - XED_IFORMFL_LODSD_FIRST=814, - XED_IFORMFL_LODSD_LAST=814, - XED_IFORMFL_LODSQ_FIRST=815, - XED_IFORMFL_LODSQ_LAST=815, - XED_IFORMFL_LODSW_FIRST=816, - XED_IFORMFL_LODSW_LAST=816, - XED_IFORMFL_LOOP_FIRST=817, - XED_IFORMFL_LOOP_LAST=817, - XED_IFORMFL_LOOPE_FIRST=818, - XED_IFORMFL_LOOPE_LAST=818, - XED_IFORMFL_LOOPNE_FIRST=819, - XED_IFORMFL_LOOPNE_LAST=819, - XED_IFORMFL_LSL_FIRST=820, - XED_IFORMFL_LSL_LAST=821, - XED_IFORMFL_LSS_FIRST=822, - XED_IFORMFL_LSS_LAST=822, - XED_IFORMFL_LTR_FIRST=823, - XED_IFORMFL_LTR_LAST=824, - XED_IFORMFL_LWPINS_FIRST=825, - XED_IFORMFL_LWPINS_LAST=826, - XED_IFORMFL_LWPVAL_FIRST=827, - XED_IFORMFL_LWPVAL_LAST=828, - XED_IFORMFL_LZCNT_FIRST=829, - XED_IFORMFL_LZCNT_LAST=830, - XED_IFORMFL_MASKMOVDQU_FIRST=831, - XED_IFORMFL_MASKMOVDQU_LAST=831, - XED_IFORMFL_MASKMOVQ_FIRST=832, - XED_IFORMFL_MASKMOVQ_LAST=832, - XED_IFORMFL_MAXPD_FIRST=833, - XED_IFORMFL_MAXPD_LAST=834, - XED_IFORMFL_MAXPS_FIRST=835, - XED_IFORMFL_MAXPS_LAST=836, - XED_IFORMFL_MAXSD_FIRST=837, - XED_IFORMFL_MAXSD_LAST=838, - XED_IFORMFL_MAXSS_FIRST=839, - XED_IFORMFL_MAXSS_LAST=840, - XED_IFORMFL_MCOMMIT_FIRST=841, - XED_IFORMFL_MCOMMIT_LAST=841, - XED_IFORMFL_MFENCE_FIRST=842, - XED_IFORMFL_MFENCE_LAST=842, - XED_IFORMFL_MINPD_FIRST=843, - XED_IFORMFL_MINPD_LAST=844, - XED_IFORMFL_MINPS_FIRST=845, - XED_IFORMFL_MINPS_LAST=846, - XED_IFORMFL_MINSD_FIRST=847, - XED_IFORMFL_MINSD_LAST=848, - XED_IFORMFL_MINSS_FIRST=849, - XED_IFORMFL_MINSS_LAST=850, - XED_IFORMFL_MONITOR_FIRST=851, - XED_IFORMFL_MONITOR_LAST=851, - XED_IFORMFL_MONITORX_FIRST=852, - XED_IFORMFL_MONITORX_LAST=852, - XED_IFORMFL_MOV_FIRST=853, - XED_IFORMFL_MOV_LAST=874, - XED_IFORMFL_MOVAPD_FIRST=875, - XED_IFORMFL_MOVAPD_LAST=878, - XED_IFORMFL_MOVAPS_FIRST=879, - XED_IFORMFL_MOVAPS_LAST=882, - XED_IFORMFL_MOVBE_FIRST=883, - XED_IFORMFL_MOVBE_LAST=884, - XED_IFORMFL_MOVD_FIRST=885, - XED_IFORMFL_MOVD_LAST=892, - XED_IFORMFL_MOVDDUP_FIRST=893, - XED_IFORMFL_MOVDDUP_LAST=894, - XED_IFORMFL_MOVDIR64B_FIRST=895, - XED_IFORMFL_MOVDIR64B_LAST=895, - XED_IFORMFL_MOVDIRI_FIRST=896, - XED_IFORMFL_MOVDIRI_LAST=897, - XED_IFORMFL_MOVDQ2Q_FIRST=898, - XED_IFORMFL_MOVDQ2Q_LAST=898, - XED_IFORMFL_MOVDQA_FIRST=899, - XED_IFORMFL_MOVDQA_LAST=902, - XED_IFORMFL_MOVDQU_FIRST=903, - XED_IFORMFL_MOVDQU_LAST=906, - XED_IFORMFL_MOVHLPS_FIRST=907, - XED_IFORMFL_MOVHLPS_LAST=907, - XED_IFORMFL_MOVHPD_FIRST=908, - XED_IFORMFL_MOVHPD_LAST=909, - XED_IFORMFL_MOVHPS_FIRST=910, - XED_IFORMFL_MOVHPS_LAST=911, - XED_IFORMFL_MOVLHPS_FIRST=912, - XED_IFORMFL_MOVLHPS_LAST=912, - XED_IFORMFL_MOVLPD_FIRST=913, - XED_IFORMFL_MOVLPD_LAST=914, - XED_IFORMFL_MOVLPS_FIRST=915, - XED_IFORMFL_MOVLPS_LAST=916, - XED_IFORMFL_MOVMSKPD_FIRST=917, - XED_IFORMFL_MOVMSKPD_LAST=917, - XED_IFORMFL_MOVMSKPS_FIRST=918, - XED_IFORMFL_MOVMSKPS_LAST=918, - XED_IFORMFL_MOVNTDQ_FIRST=919, - XED_IFORMFL_MOVNTDQ_LAST=919, - XED_IFORMFL_MOVNTDQA_FIRST=920, - XED_IFORMFL_MOVNTDQA_LAST=920, - XED_IFORMFL_MOVNTI_FIRST=921, - XED_IFORMFL_MOVNTI_LAST=922, - XED_IFORMFL_MOVNTPD_FIRST=923, - XED_IFORMFL_MOVNTPD_LAST=923, - XED_IFORMFL_MOVNTPS_FIRST=924, - XED_IFORMFL_MOVNTPS_LAST=924, - XED_IFORMFL_MOVNTQ_FIRST=925, - XED_IFORMFL_MOVNTQ_LAST=925, - XED_IFORMFL_MOVNTSD_FIRST=926, - XED_IFORMFL_MOVNTSD_LAST=926, - XED_IFORMFL_MOVNTSS_FIRST=927, - XED_IFORMFL_MOVNTSS_LAST=927, - XED_IFORMFL_MOVQ_FIRST=928, - XED_IFORMFL_MOVQ_LAST=943, - XED_IFORMFL_MOVQ2DQ_FIRST=944, - XED_IFORMFL_MOVQ2DQ_LAST=944, - XED_IFORMFL_MOVSB_FIRST=945, - XED_IFORMFL_MOVSB_LAST=945, - XED_IFORMFL_MOVSD_FIRST=946, - XED_IFORMFL_MOVSD_LAST=946, - XED_IFORMFL_MOVSD_XMM_FIRST=947, - XED_IFORMFL_MOVSD_XMM_LAST=950, - XED_IFORMFL_MOVSHDUP_FIRST=951, - XED_IFORMFL_MOVSHDUP_LAST=952, - XED_IFORMFL_MOVSLDUP_FIRST=953, - XED_IFORMFL_MOVSLDUP_LAST=954, - XED_IFORMFL_MOVSQ_FIRST=955, - XED_IFORMFL_MOVSQ_LAST=955, - XED_IFORMFL_MOVSS_FIRST=956, - XED_IFORMFL_MOVSS_LAST=959, - XED_IFORMFL_MOVSW_FIRST=960, - XED_IFORMFL_MOVSW_LAST=960, - XED_IFORMFL_MOVSX_FIRST=961, - XED_IFORMFL_MOVSX_LAST=964, - XED_IFORMFL_MOVSXD_FIRST=965, - XED_IFORMFL_MOVSXD_LAST=966, - XED_IFORMFL_MOVUPD_FIRST=967, - XED_IFORMFL_MOVUPD_LAST=970, - XED_IFORMFL_MOVUPS_FIRST=971, - XED_IFORMFL_MOVUPS_LAST=974, - XED_IFORMFL_MOVZX_FIRST=975, - XED_IFORMFL_MOVZX_LAST=978, - XED_IFORMFL_MOV_CR_FIRST=979, - XED_IFORMFL_MOV_CR_LAST=982, - XED_IFORMFL_MOV_DR_FIRST=983, - XED_IFORMFL_MOV_DR_LAST=986, - XED_IFORMFL_MPSADBW_FIRST=987, - XED_IFORMFL_MPSADBW_LAST=988, - XED_IFORMFL_MUL_FIRST=989, - XED_IFORMFL_MUL_LAST=992, - XED_IFORMFL_MULPD_FIRST=993, - XED_IFORMFL_MULPD_LAST=994, - XED_IFORMFL_MULPS_FIRST=995, - XED_IFORMFL_MULPS_LAST=996, - XED_IFORMFL_MULSD_FIRST=997, - XED_IFORMFL_MULSD_LAST=998, - XED_IFORMFL_MULSS_FIRST=999, - XED_IFORMFL_MULSS_LAST=1000, - XED_IFORMFL_MULX_FIRST=1001, - XED_IFORMFL_MULX_LAST=1004, - XED_IFORMFL_MWAIT_FIRST=1005, - XED_IFORMFL_MWAIT_LAST=1005, - XED_IFORMFL_MWAITX_FIRST=1006, - XED_IFORMFL_MWAITX_LAST=1006, - XED_IFORMFL_NEG_FIRST=1007, - XED_IFORMFL_NEG_LAST=1010, - XED_IFORMFL_NEG_LOCK_FIRST=1011, - XED_IFORMFL_NEG_LOCK_LAST=1012, - XED_IFORMFL_NOP_FIRST=1013, - XED_IFORMFL_NOP_LAST=1040, - XED_IFORMFL_NOT_FIRST=1041, - XED_IFORMFL_NOT_LAST=1044, - XED_IFORMFL_NOT_LOCK_FIRST=1045, - XED_IFORMFL_NOT_LOCK_LAST=1046, - XED_IFORMFL_OR_FIRST=1047, - XED_IFORMFL_OR_LAST=1064, - XED_IFORMFL_ORPD_FIRST=1065, - XED_IFORMFL_ORPD_LAST=1066, - XED_IFORMFL_ORPS_FIRST=1067, - XED_IFORMFL_ORPS_LAST=1068, - XED_IFORMFL_OR_LOCK_FIRST=1069, - XED_IFORMFL_OR_LOCK_LAST=1074, - XED_IFORMFL_OUT_FIRST=1075, - XED_IFORMFL_OUT_LAST=1078, - XED_IFORMFL_OUTSB_FIRST=1079, - XED_IFORMFL_OUTSB_LAST=1079, - XED_IFORMFL_OUTSD_FIRST=1080, - XED_IFORMFL_OUTSD_LAST=1080, - XED_IFORMFL_OUTSW_FIRST=1081, - XED_IFORMFL_OUTSW_LAST=1081, - XED_IFORMFL_PABSB_FIRST=1082, - XED_IFORMFL_PABSB_LAST=1085, - XED_IFORMFL_PABSD_FIRST=1086, - XED_IFORMFL_PABSD_LAST=1089, - XED_IFORMFL_PABSW_FIRST=1090, - XED_IFORMFL_PABSW_LAST=1093, - XED_IFORMFL_PACKSSDW_FIRST=1094, - XED_IFORMFL_PACKSSDW_LAST=1097, - XED_IFORMFL_PACKSSWB_FIRST=1098, - XED_IFORMFL_PACKSSWB_LAST=1101, - XED_IFORMFL_PACKUSDW_FIRST=1102, - XED_IFORMFL_PACKUSDW_LAST=1103, - XED_IFORMFL_PACKUSWB_FIRST=1104, - XED_IFORMFL_PACKUSWB_LAST=1107, - XED_IFORMFL_PADDB_FIRST=1108, - XED_IFORMFL_PADDB_LAST=1111, - XED_IFORMFL_PADDD_FIRST=1112, - XED_IFORMFL_PADDD_LAST=1115, - XED_IFORMFL_PADDQ_FIRST=1116, - XED_IFORMFL_PADDQ_LAST=1119, - XED_IFORMFL_PADDSB_FIRST=1120, - XED_IFORMFL_PADDSB_LAST=1123, - XED_IFORMFL_PADDSW_FIRST=1124, - XED_IFORMFL_PADDSW_LAST=1127, - XED_IFORMFL_PADDUSB_FIRST=1128, - XED_IFORMFL_PADDUSB_LAST=1131, - XED_IFORMFL_PADDUSW_FIRST=1132, - XED_IFORMFL_PADDUSW_LAST=1135, - XED_IFORMFL_PADDW_FIRST=1136, - XED_IFORMFL_PADDW_LAST=1139, - XED_IFORMFL_PALIGNR_FIRST=1140, - XED_IFORMFL_PALIGNR_LAST=1143, - XED_IFORMFL_PAND_FIRST=1144, - XED_IFORMFL_PAND_LAST=1147, - XED_IFORMFL_PANDN_FIRST=1148, - XED_IFORMFL_PANDN_LAST=1151, - XED_IFORMFL_PAUSE_FIRST=1152, - XED_IFORMFL_PAUSE_LAST=1152, - XED_IFORMFL_PAVGB_FIRST=1153, - XED_IFORMFL_PAVGB_LAST=1156, - XED_IFORMFL_PAVGUSB_FIRST=1157, - XED_IFORMFL_PAVGUSB_LAST=1158, - XED_IFORMFL_PAVGW_FIRST=1159, - XED_IFORMFL_PAVGW_LAST=1162, - XED_IFORMFL_PBLENDVB_FIRST=1163, - XED_IFORMFL_PBLENDVB_LAST=1164, - XED_IFORMFL_PBLENDW_FIRST=1165, - XED_IFORMFL_PBLENDW_LAST=1166, - XED_IFORMFL_PCLMULQDQ_FIRST=1167, - XED_IFORMFL_PCLMULQDQ_LAST=1168, - XED_IFORMFL_PCMPEQB_FIRST=1169, - XED_IFORMFL_PCMPEQB_LAST=1172, - XED_IFORMFL_PCMPEQD_FIRST=1173, - XED_IFORMFL_PCMPEQD_LAST=1176, - XED_IFORMFL_PCMPEQQ_FIRST=1177, - XED_IFORMFL_PCMPEQQ_LAST=1178, - XED_IFORMFL_PCMPEQW_FIRST=1179, - XED_IFORMFL_PCMPEQW_LAST=1182, - XED_IFORMFL_PCMPESTRI_FIRST=1183, - XED_IFORMFL_PCMPESTRI_LAST=1184, - XED_IFORMFL_PCMPESTRI64_FIRST=1185, - XED_IFORMFL_PCMPESTRI64_LAST=1186, - XED_IFORMFL_PCMPESTRM_FIRST=1187, - XED_IFORMFL_PCMPESTRM_LAST=1188, - XED_IFORMFL_PCMPESTRM64_FIRST=1189, - XED_IFORMFL_PCMPESTRM64_LAST=1190, - XED_IFORMFL_PCMPGTB_FIRST=1191, - XED_IFORMFL_PCMPGTB_LAST=1194, - XED_IFORMFL_PCMPGTD_FIRST=1195, - XED_IFORMFL_PCMPGTD_LAST=1198, - XED_IFORMFL_PCMPGTQ_FIRST=1199, - XED_IFORMFL_PCMPGTQ_LAST=1200, - XED_IFORMFL_PCMPGTW_FIRST=1201, - XED_IFORMFL_PCMPGTW_LAST=1204, - XED_IFORMFL_PCMPISTRI_FIRST=1205, - XED_IFORMFL_PCMPISTRI_LAST=1206, - XED_IFORMFL_PCMPISTRI64_FIRST=1207, - XED_IFORMFL_PCMPISTRI64_LAST=1208, - XED_IFORMFL_PCMPISTRM_FIRST=1209, - XED_IFORMFL_PCMPISTRM_LAST=1210, - XED_IFORMFL_PCONFIG_FIRST=1211, - XED_IFORMFL_PCONFIG_LAST=1212, - XED_IFORMFL_PDEP_FIRST=1213, - XED_IFORMFL_PDEP_LAST=1216, - XED_IFORMFL_PEXT_FIRST=1217, - XED_IFORMFL_PEXT_LAST=1220, - XED_IFORMFL_PEXTRB_FIRST=1221, - XED_IFORMFL_PEXTRB_LAST=1222, - XED_IFORMFL_PEXTRD_FIRST=1223, - XED_IFORMFL_PEXTRD_LAST=1224, - XED_IFORMFL_PEXTRQ_FIRST=1225, - XED_IFORMFL_PEXTRQ_LAST=1226, - XED_IFORMFL_PEXTRW_FIRST=1227, - XED_IFORMFL_PEXTRW_LAST=1228, - XED_IFORMFL_PEXTRW_SSE4_FIRST=1229, - XED_IFORMFL_PEXTRW_SSE4_LAST=1230, - XED_IFORMFL_PF2ID_FIRST=1231, - XED_IFORMFL_PF2ID_LAST=1232, - XED_IFORMFL_PF2IW_FIRST=1233, - XED_IFORMFL_PF2IW_LAST=1234, - XED_IFORMFL_PFACC_FIRST=1235, - XED_IFORMFL_PFACC_LAST=1236, - XED_IFORMFL_PFADD_FIRST=1237, - XED_IFORMFL_PFADD_LAST=1238, - XED_IFORMFL_PFCMPEQ_FIRST=1239, - XED_IFORMFL_PFCMPEQ_LAST=1240, - XED_IFORMFL_PFCMPGE_FIRST=1241, - XED_IFORMFL_PFCMPGE_LAST=1242, - XED_IFORMFL_PFCMPGT_FIRST=1243, - XED_IFORMFL_PFCMPGT_LAST=1244, - XED_IFORMFL_PFMAX_FIRST=1245, - XED_IFORMFL_PFMAX_LAST=1246, - XED_IFORMFL_PFMIN_FIRST=1247, - XED_IFORMFL_PFMIN_LAST=1248, - XED_IFORMFL_PFMUL_FIRST=1249, - XED_IFORMFL_PFMUL_LAST=1250, - XED_IFORMFL_PFNACC_FIRST=1251, - XED_IFORMFL_PFNACC_LAST=1252, - XED_IFORMFL_PFPNACC_FIRST=1253, - XED_IFORMFL_PFPNACC_LAST=1254, - XED_IFORMFL_PFRCP_FIRST=1255, - XED_IFORMFL_PFRCP_LAST=1256, - XED_IFORMFL_PFRCPIT1_FIRST=1257, - XED_IFORMFL_PFRCPIT1_LAST=1258, - XED_IFORMFL_PFRCPIT2_FIRST=1259, - XED_IFORMFL_PFRCPIT2_LAST=1260, - XED_IFORMFL_PFRSQIT1_FIRST=1261, - XED_IFORMFL_PFRSQIT1_LAST=1262, - XED_IFORMFL_PFRSQRT_FIRST=1263, - XED_IFORMFL_PFRSQRT_LAST=1264, - XED_IFORMFL_PFSUB_FIRST=1265, - XED_IFORMFL_PFSUB_LAST=1266, - XED_IFORMFL_PFSUBR_FIRST=1267, - XED_IFORMFL_PFSUBR_LAST=1268, - XED_IFORMFL_PHADDD_FIRST=1269, - XED_IFORMFL_PHADDD_LAST=1272, - XED_IFORMFL_PHADDSW_FIRST=1273, - XED_IFORMFL_PHADDSW_LAST=1276, - XED_IFORMFL_PHADDW_FIRST=1277, - XED_IFORMFL_PHADDW_LAST=1280, - XED_IFORMFL_PHMINPOSUW_FIRST=1281, - XED_IFORMFL_PHMINPOSUW_LAST=1282, - XED_IFORMFL_PHSUBD_FIRST=1283, - XED_IFORMFL_PHSUBD_LAST=1286, - XED_IFORMFL_PHSUBSW_FIRST=1287, - XED_IFORMFL_PHSUBSW_LAST=1290, - XED_IFORMFL_PHSUBW_FIRST=1291, - XED_IFORMFL_PHSUBW_LAST=1294, - XED_IFORMFL_PI2FD_FIRST=1295, - XED_IFORMFL_PI2FD_LAST=1296, - XED_IFORMFL_PI2FW_FIRST=1297, - XED_IFORMFL_PI2FW_LAST=1298, - XED_IFORMFL_PINSRB_FIRST=1299, - XED_IFORMFL_PINSRB_LAST=1300, - XED_IFORMFL_PINSRD_FIRST=1301, - XED_IFORMFL_PINSRD_LAST=1302, - XED_IFORMFL_PINSRQ_FIRST=1303, - XED_IFORMFL_PINSRQ_LAST=1304, - XED_IFORMFL_PINSRW_FIRST=1305, - XED_IFORMFL_PINSRW_LAST=1308, - XED_IFORMFL_PMADDUBSW_FIRST=1309, - XED_IFORMFL_PMADDUBSW_LAST=1312, - XED_IFORMFL_PMADDWD_FIRST=1313, - XED_IFORMFL_PMADDWD_LAST=1316, - XED_IFORMFL_PMAXSB_FIRST=1317, - XED_IFORMFL_PMAXSB_LAST=1318, - XED_IFORMFL_PMAXSD_FIRST=1319, - XED_IFORMFL_PMAXSD_LAST=1320, - XED_IFORMFL_PMAXSW_FIRST=1321, - XED_IFORMFL_PMAXSW_LAST=1324, - XED_IFORMFL_PMAXUB_FIRST=1325, - XED_IFORMFL_PMAXUB_LAST=1328, - XED_IFORMFL_PMAXUD_FIRST=1329, - XED_IFORMFL_PMAXUD_LAST=1330, - XED_IFORMFL_PMAXUW_FIRST=1331, - XED_IFORMFL_PMAXUW_LAST=1332, - XED_IFORMFL_PMINSB_FIRST=1333, - XED_IFORMFL_PMINSB_LAST=1334, - XED_IFORMFL_PMINSD_FIRST=1335, - XED_IFORMFL_PMINSD_LAST=1336, - XED_IFORMFL_PMINSW_FIRST=1337, - XED_IFORMFL_PMINSW_LAST=1340, - XED_IFORMFL_PMINUB_FIRST=1341, - XED_IFORMFL_PMINUB_LAST=1344, - XED_IFORMFL_PMINUD_FIRST=1345, - XED_IFORMFL_PMINUD_LAST=1346, - XED_IFORMFL_PMINUW_FIRST=1347, - XED_IFORMFL_PMINUW_LAST=1348, - XED_IFORMFL_PMOVMSKB_FIRST=1349, - XED_IFORMFL_PMOVMSKB_LAST=1350, - XED_IFORMFL_PMOVSXBD_FIRST=1351, - XED_IFORMFL_PMOVSXBD_LAST=1352, - XED_IFORMFL_PMOVSXBQ_FIRST=1353, - XED_IFORMFL_PMOVSXBQ_LAST=1354, - XED_IFORMFL_PMOVSXBW_FIRST=1355, - XED_IFORMFL_PMOVSXBW_LAST=1356, - XED_IFORMFL_PMOVSXDQ_FIRST=1357, - XED_IFORMFL_PMOVSXDQ_LAST=1358, - XED_IFORMFL_PMOVSXWD_FIRST=1359, - XED_IFORMFL_PMOVSXWD_LAST=1360, - XED_IFORMFL_PMOVSXWQ_FIRST=1361, - XED_IFORMFL_PMOVSXWQ_LAST=1362, - XED_IFORMFL_PMOVZXBD_FIRST=1363, - XED_IFORMFL_PMOVZXBD_LAST=1364, - XED_IFORMFL_PMOVZXBQ_FIRST=1365, - XED_IFORMFL_PMOVZXBQ_LAST=1366, - XED_IFORMFL_PMOVZXBW_FIRST=1367, - XED_IFORMFL_PMOVZXBW_LAST=1368, - XED_IFORMFL_PMOVZXDQ_FIRST=1369, - XED_IFORMFL_PMOVZXDQ_LAST=1370, - XED_IFORMFL_PMOVZXWD_FIRST=1371, - XED_IFORMFL_PMOVZXWD_LAST=1372, - XED_IFORMFL_PMOVZXWQ_FIRST=1373, - XED_IFORMFL_PMOVZXWQ_LAST=1374, - XED_IFORMFL_PMULDQ_FIRST=1375, - XED_IFORMFL_PMULDQ_LAST=1376, - XED_IFORMFL_PMULHRSW_FIRST=1377, - XED_IFORMFL_PMULHRSW_LAST=1380, - XED_IFORMFL_PMULHRW_FIRST=1381, - XED_IFORMFL_PMULHRW_LAST=1382, - XED_IFORMFL_PMULHUW_FIRST=1383, - XED_IFORMFL_PMULHUW_LAST=1386, - XED_IFORMFL_PMULHW_FIRST=1387, - XED_IFORMFL_PMULHW_LAST=1390, - XED_IFORMFL_PMULLD_FIRST=1391, - XED_IFORMFL_PMULLD_LAST=1392, - XED_IFORMFL_PMULLW_FIRST=1393, - XED_IFORMFL_PMULLW_LAST=1396, - XED_IFORMFL_PMULUDQ_FIRST=1397, - XED_IFORMFL_PMULUDQ_LAST=1400, - XED_IFORMFL_POP_FIRST=1401, - XED_IFORMFL_POP_LAST=1408, - XED_IFORMFL_POPA_FIRST=1409, - XED_IFORMFL_POPA_LAST=1409, - XED_IFORMFL_POPAD_FIRST=1410, - XED_IFORMFL_POPAD_LAST=1410, - XED_IFORMFL_POPCNT_FIRST=1411, - XED_IFORMFL_POPCNT_LAST=1412, - XED_IFORMFL_POPF_FIRST=1413, - XED_IFORMFL_POPF_LAST=1413, - XED_IFORMFL_POPFD_FIRST=1414, - XED_IFORMFL_POPFD_LAST=1414, - XED_IFORMFL_POPFQ_FIRST=1415, - XED_IFORMFL_POPFQ_LAST=1415, - XED_IFORMFL_POR_FIRST=1416, - XED_IFORMFL_POR_LAST=1419, - XED_IFORMFL_PREFETCHNTA_FIRST=1420, - XED_IFORMFL_PREFETCHNTA_LAST=1420, - XED_IFORMFL_PREFETCHT0_FIRST=1421, - XED_IFORMFL_PREFETCHT0_LAST=1421, - XED_IFORMFL_PREFETCHT1_FIRST=1422, - XED_IFORMFL_PREFETCHT1_LAST=1422, - XED_IFORMFL_PREFETCHT2_FIRST=1423, - XED_IFORMFL_PREFETCHT2_LAST=1423, - XED_IFORMFL_PREFETCHW_FIRST=1424, - XED_IFORMFL_PREFETCHW_LAST=1425, - XED_IFORMFL_PREFETCHWT1_FIRST=1426, - XED_IFORMFL_PREFETCHWT1_LAST=1426, - XED_IFORMFL_PREFETCH_EXCLUSIVE_FIRST=1427, - XED_IFORMFL_PREFETCH_EXCLUSIVE_LAST=1427, - XED_IFORMFL_PREFETCH_RESERVED_FIRST=1428, - XED_IFORMFL_PREFETCH_RESERVED_LAST=1431, - XED_IFORMFL_PSADBW_FIRST=1432, - XED_IFORMFL_PSADBW_LAST=1435, - XED_IFORMFL_PSHUFB_FIRST=1436, - XED_IFORMFL_PSHUFB_LAST=1439, - XED_IFORMFL_PSHUFD_FIRST=1440, - XED_IFORMFL_PSHUFD_LAST=1441, - XED_IFORMFL_PSHUFHW_FIRST=1442, - XED_IFORMFL_PSHUFHW_LAST=1443, - XED_IFORMFL_PSHUFLW_FIRST=1444, - XED_IFORMFL_PSHUFLW_LAST=1445, - XED_IFORMFL_PSHUFW_FIRST=1446, - XED_IFORMFL_PSHUFW_LAST=1447, - XED_IFORMFL_PSIGNB_FIRST=1448, - XED_IFORMFL_PSIGNB_LAST=1451, - XED_IFORMFL_PSIGND_FIRST=1452, - XED_IFORMFL_PSIGND_LAST=1455, - XED_IFORMFL_PSIGNW_FIRST=1456, - XED_IFORMFL_PSIGNW_LAST=1459, - XED_IFORMFL_PSLLD_FIRST=1460, - XED_IFORMFL_PSLLD_LAST=1465, - XED_IFORMFL_PSLLDQ_FIRST=1466, - XED_IFORMFL_PSLLDQ_LAST=1466, - XED_IFORMFL_PSLLQ_FIRST=1467, - XED_IFORMFL_PSLLQ_LAST=1472, - XED_IFORMFL_PSLLW_FIRST=1473, - XED_IFORMFL_PSLLW_LAST=1478, - XED_IFORMFL_PSMASH_FIRST=1479, - XED_IFORMFL_PSMASH_LAST=1479, - XED_IFORMFL_PSRAD_FIRST=1480, - XED_IFORMFL_PSRAD_LAST=1485, - XED_IFORMFL_PSRAW_FIRST=1486, - XED_IFORMFL_PSRAW_LAST=1491, - XED_IFORMFL_PSRLD_FIRST=1492, - XED_IFORMFL_PSRLD_LAST=1497, - XED_IFORMFL_PSRLDQ_FIRST=1498, - XED_IFORMFL_PSRLDQ_LAST=1498, - XED_IFORMFL_PSRLQ_FIRST=1499, - XED_IFORMFL_PSRLQ_LAST=1504, - XED_IFORMFL_PSRLW_FIRST=1505, - XED_IFORMFL_PSRLW_LAST=1510, - XED_IFORMFL_PSUBB_FIRST=1511, - XED_IFORMFL_PSUBB_LAST=1514, - XED_IFORMFL_PSUBD_FIRST=1515, - XED_IFORMFL_PSUBD_LAST=1518, - XED_IFORMFL_PSUBQ_FIRST=1519, - XED_IFORMFL_PSUBQ_LAST=1522, - XED_IFORMFL_PSUBSB_FIRST=1523, - XED_IFORMFL_PSUBSB_LAST=1526, - XED_IFORMFL_PSUBSW_FIRST=1527, - XED_IFORMFL_PSUBSW_LAST=1530, - XED_IFORMFL_PSUBUSB_FIRST=1531, - XED_IFORMFL_PSUBUSB_LAST=1534, - XED_IFORMFL_PSUBUSW_FIRST=1535, - XED_IFORMFL_PSUBUSW_LAST=1538, - XED_IFORMFL_PSUBW_FIRST=1539, - XED_IFORMFL_PSUBW_LAST=1542, - XED_IFORMFL_PSWAPD_FIRST=1543, - XED_IFORMFL_PSWAPD_LAST=1544, - XED_IFORMFL_PTEST_FIRST=1545, - XED_IFORMFL_PTEST_LAST=1546, - XED_IFORMFL_PTWRITE_FIRST=1547, - XED_IFORMFL_PTWRITE_LAST=1548, - XED_IFORMFL_PUNPCKHBW_FIRST=1549, - XED_IFORMFL_PUNPCKHBW_LAST=1552, - XED_IFORMFL_PUNPCKHDQ_FIRST=1553, - XED_IFORMFL_PUNPCKHDQ_LAST=1556, - XED_IFORMFL_PUNPCKHQDQ_FIRST=1557, - XED_IFORMFL_PUNPCKHQDQ_LAST=1558, - XED_IFORMFL_PUNPCKHWD_FIRST=1559, - XED_IFORMFL_PUNPCKHWD_LAST=1562, - XED_IFORMFL_PUNPCKLBW_FIRST=1563, - XED_IFORMFL_PUNPCKLBW_LAST=1566, - XED_IFORMFL_PUNPCKLDQ_FIRST=1567, - XED_IFORMFL_PUNPCKLDQ_LAST=1570, - XED_IFORMFL_PUNPCKLQDQ_FIRST=1571, - XED_IFORMFL_PUNPCKLQDQ_LAST=1572, - XED_IFORMFL_PUNPCKLWD_FIRST=1573, - XED_IFORMFL_PUNPCKLWD_LAST=1576, - XED_IFORMFL_PUSH_FIRST=1577, - XED_IFORMFL_PUSH_LAST=1587, - XED_IFORMFL_PUSHA_FIRST=1588, - XED_IFORMFL_PUSHA_LAST=1588, - XED_IFORMFL_PUSHAD_FIRST=1589, - XED_IFORMFL_PUSHAD_LAST=1589, - XED_IFORMFL_PUSHF_FIRST=1590, - XED_IFORMFL_PUSHF_LAST=1590, - XED_IFORMFL_PUSHFD_FIRST=1591, - XED_IFORMFL_PUSHFD_LAST=1591, - XED_IFORMFL_PUSHFQ_FIRST=1592, - XED_IFORMFL_PUSHFQ_LAST=1592, - XED_IFORMFL_PVALIDATE_FIRST=1593, - XED_IFORMFL_PVALIDATE_LAST=1593, - XED_IFORMFL_PXOR_FIRST=1594, - XED_IFORMFL_PXOR_LAST=1597, - XED_IFORMFL_RCL_FIRST=1598, - XED_IFORMFL_RCL_LAST=1609, - XED_IFORMFL_RCPPS_FIRST=1610, - XED_IFORMFL_RCPPS_LAST=1611, - XED_IFORMFL_RCPSS_FIRST=1612, - XED_IFORMFL_RCPSS_LAST=1613, - XED_IFORMFL_RCR_FIRST=1614, - XED_IFORMFL_RCR_LAST=1625, - XED_IFORMFL_RDFSBASE_FIRST=1626, - XED_IFORMFL_RDFSBASE_LAST=1626, - XED_IFORMFL_RDGSBASE_FIRST=1627, - XED_IFORMFL_RDGSBASE_LAST=1627, - XED_IFORMFL_RDMSR_FIRST=1628, - XED_IFORMFL_RDMSR_LAST=1628, - XED_IFORMFL_RDPID_FIRST=1629, - XED_IFORMFL_RDPID_LAST=1630, - XED_IFORMFL_RDPKRU_FIRST=1631, - XED_IFORMFL_RDPKRU_LAST=1631, - XED_IFORMFL_RDPMC_FIRST=1632, - XED_IFORMFL_RDPMC_LAST=1632, - XED_IFORMFL_RDPRU_FIRST=1633, - XED_IFORMFL_RDPRU_LAST=1633, - XED_IFORMFL_RDRAND_FIRST=1634, - XED_IFORMFL_RDRAND_LAST=1634, - XED_IFORMFL_RDSEED_FIRST=1635, - XED_IFORMFL_RDSEED_LAST=1635, - XED_IFORMFL_RDSSPD_FIRST=1636, - XED_IFORMFL_RDSSPD_LAST=1636, - XED_IFORMFL_RDSSPQ_FIRST=1637, - XED_IFORMFL_RDSSPQ_LAST=1637, - XED_IFORMFL_RDTSC_FIRST=1638, - XED_IFORMFL_RDTSC_LAST=1638, - XED_IFORMFL_RDTSCP_FIRST=1639, - XED_IFORMFL_RDTSCP_LAST=1639, - XED_IFORMFL_REPE_CMPSB_FIRST=1640, - XED_IFORMFL_REPE_CMPSB_LAST=1640, - XED_IFORMFL_REPE_CMPSD_FIRST=1641, - XED_IFORMFL_REPE_CMPSD_LAST=1641, - XED_IFORMFL_REPE_CMPSQ_FIRST=1642, - XED_IFORMFL_REPE_CMPSQ_LAST=1642, - XED_IFORMFL_REPE_CMPSW_FIRST=1643, - XED_IFORMFL_REPE_CMPSW_LAST=1643, - XED_IFORMFL_REPE_SCASB_FIRST=1644, - XED_IFORMFL_REPE_SCASB_LAST=1644, - XED_IFORMFL_REPE_SCASD_FIRST=1645, - XED_IFORMFL_REPE_SCASD_LAST=1645, - XED_IFORMFL_REPE_SCASQ_FIRST=1646, - XED_IFORMFL_REPE_SCASQ_LAST=1646, - XED_IFORMFL_REPE_SCASW_FIRST=1647, - XED_IFORMFL_REPE_SCASW_LAST=1647, - XED_IFORMFL_REPNE_CMPSB_FIRST=1648, - XED_IFORMFL_REPNE_CMPSB_LAST=1648, - XED_IFORMFL_REPNE_CMPSD_FIRST=1649, - XED_IFORMFL_REPNE_CMPSD_LAST=1649, - XED_IFORMFL_REPNE_CMPSQ_FIRST=1650, - XED_IFORMFL_REPNE_CMPSQ_LAST=1650, - XED_IFORMFL_REPNE_CMPSW_FIRST=1651, - XED_IFORMFL_REPNE_CMPSW_LAST=1651, - XED_IFORMFL_REPNE_SCASB_FIRST=1652, - XED_IFORMFL_REPNE_SCASB_LAST=1652, - XED_IFORMFL_REPNE_SCASD_FIRST=1653, - XED_IFORMFL_REPNE_SCASD_LAST=1653, - XED_IFORMFL_REPNE_SCASQ_FIRST=1654, - XED_IFORMFL_REPNE_SCASQ_LAST=1654, - XED_IFORMFL_REPNE_SCASW_FIRST=1655, - XED_IFORMFL_REPNE_SCASW_LAST=1655, - XED_IFORMFL_REP_INSB_FIRST=1656, - XED_IFORMFL_REP_INSB_LAST=1656, - XED_IFORMFL_REP_INSD_FIRST=1657, - XED_IFORMFL_REP_INSD_LAST=1657, - XED_IFORMFL_REP_INSW_FIRST=1658, - XED_IFORMFL_REP_INSW_LAST=1658, - XED_IFORMFL_REP_LODSB_FIRST=1659, - XED_IFORMFL_REP_LODSB_LAST=1659, - XED_IFORMFL_REP_LODSD_FIRST=1660, - XED_IFORMFL_REP_LODSD_LAST=1660, - XED_IFORMFL_REP_LODSQ_FIRST=1661, - XED_IFORMFL_REP_LODSQ_LAST=1661, - XED_IFORMFL_REP_LODSW_FIRST=1662, - XED_IFORMFL_REP_LODSW_LAST=1662, - XED_IFORMFL_REP_MONTMUL_FIRST=1663, - XED_IFORMFL_REP_MONTMUL_LAST=1663, - XED_IFORMFL_REP_MOVSB_FIRST=1664, - XED_IFORMFL_REP_MOVSB_LAST=1664, - XED_IFORMFL_REP_MOVSD_FIRST=1665, - XED_IFORMFL_REP_MOVSD_LAST=1665, - XED_IFORMFL_REP_MOVSQ_FIRST=1666, - XED_IFORMFL_REP_MOVSQ_LAST=1666, - XED_IFORMFL_REP_MOVSW_FIRST=1667, - XED_IFORMFL_REP_MOVSW_LAST=1667, - XED_IFORMFL_REP_OUTSB_FIRST=1668, - XED_IFORMFL_REP_OUTSB_LAST=1668, - XED_IFORMFL_REP_OUTSD_FIRST=1669, - XED_IFORMFL_REP_OUTSD_LAST=1669, - XED_IFORMFL_REP_OUTSW_FIRST=1670, - XED_IFORMFL_REP_OUTSW_LAST=1670, - XED_IFORMFL_REP_STOSB_FIRST=1671, - XED_IFORMFL_REP_STOSB_LAST=1671, - XED_IFORMFL_REP_STOSD_FIRST=1672, - XED_IFORMFL_REP_STOSD_LAST=1672, - XED_IFORMFL_REP_STOSQ_FIRST=1673, - XED_IFORMFL_REP_STOSQ_LAST=1673, - XED_IFORMFL_REP_STOSW_FIRST=1674, - XED_IFORMFL_REP_STOSW_LAST=1674, - XED_IFORMFL_REP_XCRYPTCBC_FIRST=1675, - XED_IFORMFL_REP_XCRYPTCBC_LAST=1675, - XED_IFORMFL_REP_XCRYPTCFB_FIRST=1676, - XED_IFORMFL_REP_XCRYPTCFB_LAST=1676, - XED_IFORMFL_REP_XCRYPTCTR_FIRST=1677, - XED_IFORMFL_REP_XCRYPTCTR_LAST=1677, - XED_IFORMFL_REP_XCRYPTECB_FIRST=1678, - XED_IFORMFL_REP_XCRYPTECB_LAST=1678, - XED_IFORMFL_REP_XCRYPTOFB_FIRST=1679, - XED_IFORMFL_REP_XCRYPTOFB_LAST=1679, - XED_IFORMFL_REP_XSHA1_FIRST=1680, - XED_IFORMFL_REP_XSHA1_LAST=1680, - XED_IFORMFL_REP_XSHA256_FIRST=1681, - XED_IFORMFL_REP_XSHA256_LAST=1681, - XED_IFORMFL_REP_XSTORE_FIRST=1682, - XED_IFORMFL_REP_XSTORE_LAST=1682, - XED_IFORMFL_RET_FAR_FIRST=1683, - XED_IFORMFL_RET_FAR_LAST=1684, - XED_IFORMFL_RET_NEAR_FIRST=1685, - XED_IFORMFL_RET_NEAR_LAST=1686, - XED_IFORMFL_RMPADJUST_FIRST=1687, - XED_IFORMFL_RMPADJUST_LAST=1687, - XED_IFORMFL_RMPUPDATE_FIRST=1688, - XED_IFORMFL_RMPUPDATE_LAST=1688, - XED_IFORMFL_ROL_FIRST=1689, - XED_IFORMFL_ROL_LAST=1700, - XED_IFORMFL_ROR_FIRST=1701, - XED_IFORMFL_ROR_LAST=1712, - XED_IFORMFL_RORX_FIRST=1713, - XED_IFORMFL_RORX_LAST=1716, - XED_IFORMFL_ROUNDPD_FIRST=1717, - XED_IFORMFL_ROUNDPD_LAST=1718, - XED_IFORMFL_ROUNDPS_FIRST=1719, - XED_IFORMFL_ROUNDPS_LAST=1720, - XED_IFORMFL_ROUNDSD_FIRST=1721, - XED_IFORMFL_ROUNDSD_LAST=1722, - XED_IFORMFL_ROUNDSS_FIRST=1723, - XED_IFORMFL_ROUNDSS_LAST=1724, - XED_IFORMFL_RSM_FIRST=1725, - XED_IFORMFL_RSM_LAST=1725, - XED_IFORMFL_RSQRTPS_FIRST=1726, - XED_IFORMFL_RSQRTPS_LAST=1727, - XED_IFORMFL_RSQRTSS_FIRST=1728, - XED_IFORMFL_RSQRTSS_LAST=1729, - XED_IFORMFL_RSTORSSP_FIRST=1730, - XED_IFORMFL_RSTORSSP_LAST=1730, - XED_IFORMFL_SAHF_FIRST=1731, - XED_IFORMFL_SAHF_LAST=1731, - XED_IFORMFL_SALC_FIRST=1732, - XED_IFORMFL_SALC_LAST=1732, - XED_IFORMFL_SAR_FIRST=1733, - XED_IFORMFL_SAR_LAST=1744, - XED_IFORMFL_SARX_FIRST=1745, - XED_IFORMFL_SARX_LAST=1748, - XED_IFORMFL_SAVEPREVSSP_FIRST=1749, - XED_IFORMFL_SAVEPREVSSP_LAST=1749, - XED_IFORMFL_SBB_FIRST=1750, - XED_IFORMFL_SBB_LAST=1767, - XED_IFORMFL_SBB_LOCK_FIRST=1768, - XED_IFORMFL_SBB_LOCK_LAST=1773, - XED_IFORMFL_SCASB_FIRST=1774, - XED_IFORMFL_SCASB_LAST=1774, - XED_IFORMFL_SCASD_FIRST=1775, - XED_IFORMFL_SCASD_LAST=1775, - XED_IFORMFL_SCASQ_FIRST=1776, - XED_IFORMFL_SCASQ_LAST=1776, - XED_IFORMFL_SCASW_FIRST=1777, - XED_IFORMFL_SCASW_LAST=1777, - XED_IFORMFL_SEAMCALL_FIRST=1778, - XED_IFORMFL_SEAMCALL_LAST=1778, - XED_IFORMFL_SEAMOPS_FIRST=1779, - XED_IFORMFL_SEAMOPS_LAST=1779, - XED_IFORMFL_SEAMRET_FIRST=1780, - XED_IFORMFL_SEAMRET_LAST=1780, - XED_IFORMFL_SENDUIPI_FIRST=1781, - XED_IFORMFL_SENDUIPI_LAST=1781, - XED_IFORMFL_SERIALIZE_FIRST=1782, - XED_IFORMFL_SERIALIZE_LAST=1782, - XED_IFORMFL_SETB_FIRST=1783, - XED_IFORMFL_SETB_LAST=1784, - XED_IFORMFL_SETBE_FIRST=1785, - XED_IFORMFL_SETBE_LAST=1786, - XED_IFORMFL_SETL_FIRST=1787, - XED_IFORMFL_SETL_LAST=1788, - XED_IFORMFL_SETLE_FIRST=1789, - XED_IFORMFL_SETLE_LAST=1790, - XED_IFORMFL_SETNB_FIRST=1791, - XED_IFORMFL_SETNB_LAST=1792, - XED_IFORMFL_SETNBE_FIRST=1793, - XED_IFORMFL_SETNBE_LAST=1794, - XED_IFORMFL_SETNL_FIRST=1795, - XED_IFORMFL_SETNL_LAST=1796, - XED_IFORMFL_SETNLE_FIRST=1797, - XED_IFORMFL_SETNLE_LAST=1798, - XED_IFORMFL_SETNO_FIRST=1799, - XED_IFORMFL_SETNO_LAST=1800, - XED_IFORMFL_SETNP_FIRST=1801, - XED_IFORMFL_SETNP_LAST=1802, - XED_IFORMFL_SETNS_FIRST=1803, - XED_IFORMFL_SETNS_LAST=1804, - XED_IFORMFL_SETNZ_FIRST=1805, - XED_IFORMFL_SETNZ_LAST=1806, - XED_IFORMFL_SETO_FIRST=1807, - XED_IFORMFL_SETO_LAST=1808, - XED_IFORMFL_SETP_FIRST=1809, - XED_IFORMFL_SETP_LAST=1810, - XED_IFORMFL_SETS_FIRST=1811, - XED_IFORMFL_SETS_LAST=1812, - XED_IFORMFL_SETSSBSY_FIRST=1813, - XED_IFORMFL_SETSSBSY_LAST=1813, - XED_IFORMFL_SETZ_FIRST=1814, - XED_IFORMFL_SETZ_LAST=1815, - XED_IFORMFL_SFENCE_FIRST=1816, - XED_IFORMFL_SFENCE_LAST=1816, - XED_IFORMFL_SGDT_FIRST=1817, - XED_IFORMFL_SGDT_LAST=1818, - XED_IFORMFL_SHA1MSG1_FIRST=1819, - XED_IFORMFL_SHA1MSG1_LAST=1820, - XED_IFORMFL_SHA1MSG2_FIRST=1821, - XED_IFORMFL_SHA1MSG2_LAST=1822, - XED_IFORMFL_SHA1NEXTE_FIRST=1823, - XED_IFORMFL_SHA1NEXTE_LAST=1824, - XED_IFORMFL_SHA1RNDS4_FIRST=1825, - XED_IFORMFL_SHA1RNDS4_LAST=1826, - XED_IFORMFL_SHA256MSG1_FIRST=1827, - XED_IFORMFL_SHA256MSG1_LAST=1828, - XED_IFORMFL_SHA256MSG2_FIRST=1829, - XED_IFORMFL_SHA256MSG2_LAST=1830, - XED_IFORMFL_SHA256RNDS2_FIRST=1831, - XED_IFORMFL_SHA256RNDS2_LAST=1832, - XED_IFORMFL_SHL_FIRST=1833, - XED_IFORMFL_SHL_LAST=1856, - XED_IFORMFL_SHLD_FIRST=1857, - XED_IFORMFL_SHLD_LAST=1860, - XED_IFORMFL_SHLX_FIRST=1861, - XED_IFORMFL_SHLX_LAST=1864, - XED_IFORMFL_SHR_FIRST=1865, - XED_IFORMFL_SHR_LAST=1876, - XED_IFORMFL_SHRD_FIRST=1877, - XED_IFORMFL_SHRD_LAST=1880, - XED_IFORMFL_SHRX_FIRST=1881, - XED_IFORMFL_SHRX_LAST=1884, - XED_IFORMFL_SHUFPD_FIRST=1885, - XED_IFORMFL_SHUFPD_LAST=1886, - XED_IFORMFL_SHUFPS_FIRST=1887, - XED_IFORMFL_SHUFPS_LAST=1888, - XED_IFORMFL_SIDT_FIRST=1889, - XED_IFORMFL_SIDT_LAST=1890, - XED_IFORMFL_SKINIT_FIRST=1891, - XED_IFORMFL_SKINIT_LAST=1891, - XED_IFORMFL_SLDT_FIRST=1892, - XED_IFORMFL_SLDT_LAST=1893, - XED_IFORMFL_SLWPCB_FIRST=1894, - XED_IFORMFL_SLWPCB_LAST=1894, - XED_IFORMFL_SMSW_FIRST=1895, - XED_IFORMFL_SMSW_LAST=1896, - XED_IFORMFL_SQRTPD_FIRST=1897, - XED_IFORMFL_SQRTPD_LAST=1898, - XED_IFORMFL_SQRTPS_FIRST=1899, - XED_IFORMFL_SQRTPS_LAST=1900, - XED_IFORMFL_SQRTSD_FIRST=1901, - XED_IFORMFL_SQRTSD_LAST=1902, - XED_IFORMFL_SQRTSS_FIRST=1903, - XED_IFORMFL_SQRTSS_LAST=1904, - XED_IFORMFL_STAC_FIRST=1905, - XED_IFORMFL_STAC_LAST=1905, - XED_IFORMFL_STC_FIRST=1906, - XED_IFORMFL_STC_LAST=1906, - XED_IFORMFL_STD_FIRST=1907, - XED_IFORMFL_STD_LAST=1907, - XED_IFORMFL_STGI_FIRST=1908, - XED_IFORMFL_STGI_LAST=1908, - XED_IFORMFL_STI_FIRST=1909, - XED_IFORMFL_STI_LAST=1909, - XED_IFORMFL_STMXCSR_FIRST=1910, - XED_IFORMFL_STMXCSR_LAST=1910, - XED_IFORMFL_STOSB_FIRST=1911, - XED_IFORMFL_STOSB_LAST=1911, - XED_IFORMFL_STOSD_FIRST=1912, - XED_IFORMFL_STOSD_LAST=1912, - XED_IFORMFL_STOSQ_FIRST=1913, - XED_IFORMFL_STOSQ_LAST=1913, - XED_IFORMFL_STOSW_FIRST=1914, - XED_IFORMFL_STOSW_LAST=1914, - XED_IFORMFL_STR_FIRST=1915, - XED_IFORMFL_STR_LAST=1916, - XED_IFORMFL_STTILECFG_FIRST=1917, - XED_IFORMFL_STTILECFG_LAST=1917, - XED_IFORMFL_STUI_FIRST=1918, - XED_IFORMFL_STUI_LAST=1918, - XED_IFORMFL_SUB_FIRST=1919, - XED_IFORMFL_SUB_LAST=1936, - XED_IFORMFL_SUBPD_FIRST=1937, - XED_IFORMFL_SUBPD_LAST=1938, - XED_IFORMFL_SUBPS_FIRST=1939, - XED_IFORMFL_SUBPS_LAST=1940, - XED_IFORMFL_SUBSD_FIRST=1941, - XED_IFORMFL_SUBSD_LAST=1942, - XED_IFORMFL_SUBSS_FIRST=1943, - XED_IFORMFL_SUBSS_LAST=1944, - XED_IFORMFL_SUB_LOCK_FIRST=1945, - XED_IFORMFL_SUB_LOCK_LAST=1950, - XED_IFORMFL_SWAPGS_FIRST=1951, - XED_IFORMFL_SWAPGS_LAST=1951, - XED_IFORMFL_SYSCALL_FIRST=1952, - XED_IFORMFL_SYSCALL_LAST=1952, - XED_IFORMFL_SYSCALL_AMD_FIRST=1953, - XED_IFORMFL_SYSCALL_AMD_LAST=1953, - XED_IFORMFL_SYSENTER_FIRST=1954, - XED_IFORMFL_SYSENTER_LAST=1954, - XED_IFORMFL_SYSEXIT_FIRST=1955, - XED_IFORMFL_SYSEXIT_LAST=1955, - XED_IFORMFL_SYSRET_FIRST=1956, - XED_IFORMFL_SYSRET_LAST=1956, - XED_IFORMFL_SYSRET64_FIRST=1957, - XED_IFORMFL_SYSRET64_LAST=1957, - XED_IFORMFL_SYSRET_AMD_FIRST=1958, - XED_IFORMFL_SYSRET_AMD_LAST=1958, - XED_IFORMFL_T1MSKC_FIRST=1959, - XED_IFORMFL_T1MSKC_LAST=1962, - XED_IFORMFL_TDCALL_FIRST=1963, - XED_IFORMFL_TDCALL_LAST=1963, - XED_IFORMFL_TDPBF16PS_FIRST=1964, - XED_IFORMFL_TDPBF16PS_LAST=1964, - XED_IFORMFL_TDPBSSD_FIRST=1965, - XED_IFORMFL_TDPBSSD_LAST=1965, - XED_IFORMFL_TDPBSUD_FIRST=1966, - XED_IFORMFL_TDPBSUD_LAST=1966, - XED_IFORMFL_TDPBUSD_FIRST=1967, - XED_IFORMFL_TDPBUSD_LAST=1967, - XED_IFORMFL_TDPBUUD_FIRST=1968, - XED_IFORMFL_TDPBUUD_LAST=1968, - XED_IFORMFL_TEST_FIRST=1969, - XED_IFORMFL_TEST_LAST=1982, - XED_IFORMFL_TESTUI_FIRST=1983, - XED_IFORMFL_TESTUI_LAST=1983, - XED_IFORMFL_TILELOADD_FIRST=1984, - XED_IFORMFL_TILELOADD_LAST=1984, - XED_IFORMFL_TILELOADDT1_FIRST=1985, - XED_IFORMFL_TILELOADDT1_LAST=1985, - XED_IFORMFL_TILERELEASE_FIRST=1986, - XED_IFORMFL_TILERELEASE_LAST=1986, - XED_IFORMFL_TILESTORED_FIRST=1987, - XED_IFORMFL_TILESTORED_LAST=1987, - XED_IFORMFL_TILEZERO_FIRST=1988, - XED_IFORMFL_TILEZERO_LAST=1988, - XED_IFORMFL_TLBSYNC_FIRST=1989, - XED_IFORMFL_TLBSYNC_LAST=1989, - XED_IFORMFL_TPAUSE_FIRST=1990, - XED_IFORMFL_TPAUSE_LAST=1990, - XED_IFORMFL_TZCNT_FIRST=1991, - XED_IFORMFL_TZCNT_LAST=1992, - XED_IFORMFL_TZMSK_FIRST=1993, - XED_IFORMFL_TZMSK_LAST=1996, - XED_IFORMFL_UCOMISD_FIRST=1997, - XED_IFORMFL_UCOMISD_LAST=1998, - XED_IFORMFL_UCOMISS_FIRST=1999, - XED_IFORMFL_UCOMISS_LAST=2000, - XED_IFORMFL_UD0_FIRST=2001, - XED_IFORMFL_UD0_LAST=2003, - XED_IFORMFL_UD1_FIRST=2004, - XED_IFORMFL_UD1_LAST=2005, - XED_IFORMFL_UD2_FIRST=2006, - XED_IFORMFL_UD2_LAST=2006, - XED_IFORMFL_UIRET_FIRST=2007, - XED_IFORMFL_UIRET_LAST=2007, - XED_IFORMFL_UMONITOR_FIRST=2008, - XED_IFORMFL_UMONITOR_LAST=2008, - XED_IFORMFL_UMWAIT_FIRST=2009, - XED_IFORMFL_UMWAIT_LAST=2009, - XED_IFORMFL_UNPCKHPD_FIRST=2010, - XED_IFORMFL_UNPCKHPD_LAST=2011, - XED_IFORMFL_UNPCKHPS_FIRST=2012, - XED_IFORMFL_UNPCKHPS_LAST=2013, - XED_IFORMFL_UNPCKLPD_FIRST=2014, - XED_IFORMFL_UNPCKLPD_LAST=2015, - XED_IFORMFL_UNPCKLPS_FIRST=2016, - XED_IFORMFL_UNPCKLPS_LAST=2017, - XED_IFORMFL_V4FMADDPS_FIRST=2018, - XED_IFORMFL_V4FMADDPS_LAST=2018, - XED_IFORMFL_V4FMADDSS_FIRST=2019, - XED_IFORMFL_V4FMADDSS_LAST=2019, - XED_IFORMFL_V4FNMADDPS_FIRST=2020, - XED_IFORMFL_V4FNMADDPS_LAST=2020, - XED_IFORMFL_V4FNMADDSS_FIRST=2021, - XED_IFORMFL_V4FNMADDSS_LAST=2021, - XED_IFORMFL_VADDPD_FIRST=2022, - XED_IFORMFL_VADDPD_LAST=2031, - XED_IFORMFL_VADDPH_FIRST=2032, - XED_IFORMFL_VADDPH_LAST=2037, - XED_IFORMFL_VADDPS_FIRST=2038, - XED_IFORMFL_VADDPS_LAST=2047, - XED_IFORMFL_VADDSD_FIRST=2048, - XED_IFORMFL_VADDSD_LAST=2051, - XED_IFORMFL_VADDSH_FIRST=2052, - XED_IFORMFL_VADDSH_LAST=2053, - XED_IFORMFL_VADDSS_FIRST=2054, - XED_IFORMFL_VADDSS_LAST=2057, - XED_IFORMFL_VADDSUBPD_FIRST=2058, - XED_IFORMFL_VADDSUBPD_LAST=2061, - XED_IFORMFL_VADDSUBPS_FIRST=2062, - XED_IFORMFL_VADDSUBPS_LAST=2065, - XED_IFORMFL_VAESDEC_FIRST=2066, - XED_IFORMFL_VAESDEC_LAST=2075, - XED_IFORMFL_VAESDECLAST_FIRST=2076, - XED_IFORMFL_VAESDECLAST_LAST=2085, - XED_IFORMFL_VAESENC_FIRST=2086, - XED_IFORMFL_VAESENC_LAST=2095, - XED_IFORMFL_VAESENCLAST_FIRST=2096, - XED_IFORMFL_VAESENCLAST_LAST=2105, - XED_IFORMFL_VAESIMC_FIRST=2106, - XED_IFORMFL_VAESIMC_LAST=2107, - XED_IFORMFL_VAESKEYGENASSIST_FIRST=2108, - XED_IFORMFL_VAESKEYGENASSIST_LAST=2109, - XED_IFORMFL_VALIGND_FIRST=2110, - XED_IFORMFL_VALIGND_LAST=2115, - XED_IFORMFL_VALIGNQ_FIRST=2116, - XED_IFORMFL_VALIGNQ_LAST=2121, - XED_IFORMFL_VANDNPD_FIRST=2122, - XED_IFORMFL_VANDNPD_LAST=2131, - XED_IFORMFL_VANDNPS_FIRST=2132, - XED_IFORMFL_VANDNPS_LAST=2141, - XED_IFORMFL_VANDPD_FIRST=2142, - XED_IFORMFL_VANDPD_LAST=2151, - XED_IFORMFL_VANDPS_FIRST=2152, - XED_IFORMFL_VANDPS_LAST=2161, - XED_IFORMFL_VBLENDMPD_FIRST=2162, - XED_IFORMFL_VBLENDMPD_LAST=2167, - XED_IFORMFL_VBLENDMPS_FIRST=2168, - XED_IFORMFL_VBLENDMPS_LAST=2173, - XED_IFORMFL_VBLENDPD_FIRST=2174, - XED_IFORMFL_VBLENDPD_LAST=2177, - XED_IFORMFL_VBLENDPS_FIRST=2178, - XED_IFORMFL_VBLENDPS_LAST=2181, - XED_IFORMFL_VBLENDVPD_FIRST=2182, - XED_IFORMFL_VBLENDVPD_LAST=2185, - XED_IFORMFL_VBLENDVPS_FIRST=2186, - XED_IFORMFL_VBLENDVPS_LAST=2189, - XED_IFORMFL_VBROADCASTF128_FIRST=2190, - XED_IFORMFL_VBROADCASTF128_LAST=2190, - XED_IFORMFL_VBROADCASTF32X2_FIRST=2191, - XED_IFORMFL_VBROADCASTF32X2_LAST=2194, - XED_IFORMFL_VBROADCASTF32X4_FIRST=2195, - XED_IFORMFL_VBROADCASTF32X4_LAST=2196, - XED_IFORMFL_VBROADCASTF32X8_FIRST=2197, - XED_IFORMFL_VBROADCASTF32X8_LAST=2197, - XED_IFORMFL_VBROADCASTF64X2_FIRST=2198, - XED_IFORMFL_VBROADCASTF64X2_LAST=2199, - XED_IFORMFL_VBROADCASTF64X4_FIRST=2200, - XED_IFORMFL_VBROADCASTF64X4_LAST=2200, - XED_IFORMFL_VBROADCASTI128_FIRST=2201, - XED_IFORMFL_VBROADCASTI128_LAST=2201, - XED_IFORMFL_VBROADCASTI32X2_FIRST=2202, - XED_IFORMFL_VBROADCASTI32X2_LAST=2207, - XED_IFORMFL_VBROADCASTI32X4_FIRST=2208, - XED_IFORMFL_VBROADCASTI32X4_LAST=2209, - XED_IFORMFL_VBROADCASTI32X8_FIRST=2210, - XED_IFORMFL_VBROADCASTI32X8_LAST=2210, - XED_IFORMFL_VBROADCASTI64X2_FIRST=2211, - XED_IFORMFL_VBROADCASTI64X2_LAST=2212, - XED_IFORMFL_VBROADCASTI64X4_FIRST=2213, - XED_IFORMFL_VBROADCASTI64X4_LAST=2213, - XED_IFORMFL_VBROADCASTSD_FIRST=2214, - XED_IFORMFL_VBROADCASTSD_LAST=2219, - XED_IFORMFL_VBROADCASTSS_FIRST=2220, - XED_IFORMFL_VBROADCASTSS_LAST=2229, - XED_IFORMFL_VCMPPD_FIRST=2230, - XED_IFORMFL_VCMPPD_LAST=2239, - XED_IFORMFL_VCMPPH_FIRST=2240, - XED_IFORMFL_VCMPPH_LAST=2245, - XED_IFORMFL_VCMPPS_FIRST=2246, - XED_IFORMFL_VCMPPS_LAST=2255, - XED_IFORMFL_VCMPSD_FIRST=2256, - XED_IFORMFL_VCMPSD_LAST=2259, - XED_IFORMFL_VCMPSH_FIRST=2260, - XED_IFORMFL_VCMPSH_LAST=2261, - XED_IFORMFL_VCMPSS_FIRST=2262, - XED_IFORMFL_VCMPSS_LAST=2265, - XED_IFORMFL_VCOMISD_FIRST=2266, - XED_IFORMFL_VCOMISD_LAST=2269, - XED_IFORMFL_VCOMISH_FIRST=2270, - XED_IFORMFL_VCOMISH_LAST=2271, - XED_IFORMFL_VCOMISS_FIRST=2272, - XED_IFORMFL_VCOMISS_LAST=2275, - XED_IFORMFL_VCOMPRESSPD_FIRST=2276, - XED_IFORMFL_VCOMPRESSPD_LAST=2281, - XED_IFORMFL_VCOMPRESSPS_FIRST=2282, - XED_IFORMFL_VCOMPRESSPS_LAST=2287, - XED_IFORMFL_VCVTDQ2PD_FIRST=2288, - XED_IFORMFL_VCVTDQ2PD_LAST=2297, - XED_IFORMFL_VCVTDQ2PH_FIRST=2298, - XED_IFORMFL_VCVTDQ2PH_LAST=2303, - XED_IFORMFL_VCVTDQ2PS_FIRST=2304, - XED_IFORMFL_VCVTDQ2PS_LAST=2313, - XED_IFORMFL_VCVTNE2PS2BF16_FIRST=2314, - XED_IFORMFL_VCVTNE2PS2BF16_LAST=2319, - XED_IFORMFL_VCVTNEPS2BF16_FIRST=2320, - XED_IFORMFL_VCVTNEPS2BF16_LAST=2325, - XED_IFORMFL_VCVTPD2DQ_FIRST=2326, - XED_IFORMFL_VCVTPD2DQ_LAST=2335, - XED_IFORMFL_VCVTPD2PH_FIRST=2336, - XED_IFORMFL_VCVTPD2PH_LAST=2341, - XED_IFORMFL_VCVTPD2PS_FIRST=2342, - XED_IFORMFL_VCVTPD2PS_LAST=2351, - XED_IFORMFL_VCVTPD2QQ_FIRST=2352, - XED_IFORMFL_VCVTPD2QQ_LAST=2357, - XED_IFORMFL_VCVTPD2UDQ_FIRST=2358, - XED_IFORMFL_VCVTPD2UDQ_LAST=2363, - XED_IFORMFL_VCVTPD2UQQ_FIRST=2364, - XED_IFORMFL_VCVTPD2UQQ_LAST=2369, - XED_IFORMFL_VCVTPH2DQ_FIRST=2370, - XED_IFORMFL_VCVTPH2DQ_LAST=2375, - XED_IFORMFL_VCVTPH2PD_FIRST=2376, - XED_IFORMFL_VCVTPH2PD_LAST=2381, - XED_IFORMFL_VCVTPH2PS_FIRST=2382, - XED_IFORMFL_VCVTPH2PS_LAST=2391, - XED_IFORMFL_VCVTPH2PSX_FIRST=2392, - XED_IFORMFL_VCVTPH2PSX_LAST=2397, - XED_IFORMFL_VCVTPH2QQ_FIRST=2398, - XED_IFORMFL_VCVTPH2QQ_LAST=2403, - XED_IFORMFL_VCVTPH2UDQ_FIRST=2404, - XED_IFORMFL_VCVTPH2UDQ_LAST=2409, - XED_IFORMFL_VCVTPH2UQQ_FIRST=2410, - XED_IFORMFL_VCVTPH2UQQ_LAST=2415, - XED_IFORMFL_VCVTPH2UW_FIRST=2416, - XED_IFORMFL_VCVTPH2UW_LAST=2421, - XED_IFORMFL_VCVTPH2W_FIRST=2422, - XED_IFORMFL_VCVTPH2W_LAST=2427, - XED_IFORMFL_VCVTPS2DQ_FIRST=2428, - XED_IFORMFL_VCVTPS2DQ_LAST=2437, - XED_IFORMFL_VCVTPS2PD_FIRST=2438, - XED_IFORMFL_VCVTPS2PD_LAST=2447, - XED_IFORMFL_VCVTPS2PH_FIRST=2448, - XED_IFORMFL_VCVTPS2PH_LAST=2457, - XED_IFORMFL_VCVTPS2PHX_FIRST=2458, - XED_IFORMFL_VCVTPS2PHX_LAST=2463, - XED_IFORMFL_VCVTPS2QQ_FIRST=2464, - XED_IFORMFL_VCVTPS2QQ_LAST=2469, - XED_IFORMFL_VCVTPS2UDQ_FIRST=2470, - XED_IFORMFL_VCVTPS2UDQ_LAST=2475, - XED_IFORMFL_VCVTPS2UQQ_FIRST=2476, - XED_IFORMFL_VCVTPS2UQQ_LAST=2481, - XED_IFORMFL_VCVTQQ2PD_FIRST=2482, - XED_IFORMFL_VCVTQQ2PD_LAST=2487, - XED_IFORMFL_VCVTQQ2PH_FIRST=2488, - XED_IFORMFL_VCVTQQ2PH_LAST=2493, - XED_IFORMFL_VCVTQQ2PS_FIRST=2494, - XED_IFORMFL_VCVTQQ2PS_LAST=2499, - XED_IFORMFL_VCVTSD2SH_FIRST=2500, - XED_IFORMFL_VCVTSD2SH_LAST=2501, - XED_IFORMFL_VCVTSD2SI_FIRST=2502, - XED_IFORMFL_VCVTSD2SI_LAST=2509, - XED_IFORMFL_VCVTSD2SS_FIRST=2510, - XED_IFORMFL_VCVTSD2SS_LAST=2513, - XED_IFORMFL_VCVTSD2USI_FIRST=2514, - XED_IFORMFL_VCVTSD2USI_LAST=2517, - XED_IFORMFL_VCVTSH2SD_FIRST=2518, - XED_IFORMFL_VCVTSH2SD_LAST=2519, - XED_IFORMFL_VCVTSH2SI_FIRST=2520, - XED_IFORMFL_VCVTSH2SI_LAST=2523, - XED_IFORMFL_VCVTSH2SS_FIRST=2524, - XED_IFORMFL_VCVTSH2SS_LAST=2525, - XED_IFORMFL_VCVTSH2USI_FIRST=2526, - XED_IFORMFL_VCVTSH2USI_LAST=2529, - XED_IFORMFL_VCVTSI2SD_FIRST=2530, - XED_IFORMFL_VCVTSI2SD_LAST=2537, - XED_IFORMFL_VCVTSI2SH_FIRST=2538, - XED_IFORMFL_VCVTSI2SH_LAST=2541, - XED_IFORMFL_VCVTSI2SS_FIRST=2542, - XED_IFORMFL_VCVTSI2SS_LAST=2549, - XED_IFORMFL_VCVTSS2SD_FIRST=2550, - XED_IFORMFL_VCVTSS2SD_LAST=2553, - XED_IFORMFL_VCVTSS2SH_FIRST=2554, - XED_IFORMFL_VCVTSS2SH_LAST=2555, - XED_IFORMFL_VCVTSS2SI_FIRST=2556, - XED_IFORMFL_VCVTSS2SI_LAST=2563, - XED_IFORMFL_VCVTSS2USI_FIRST=2564, - XED_IFORMFL_VCVTSS2USI_LAST=2567, - XED_IFORMFL_VCVTTPD2DQ_FIRST=2568, - XED_IFORMFL_VCVTTPD2DQ_LAST=2577, - XED_IFORMFL_VCVTTPD2QQ_FIRST=2578, - XED_IFORMFL_VCVTTPD2QQ_LAST=2583, - XED_IFORMFL_VCVTTPD2UDQ_FIRST=2584, - XED_IFORMFL_VCVTTPD2UDQ_LAST=2589, - XED_IFORMFL_VCVTTPD2UQQ_FIRST=2590, - XED_IFORMFL_VCVTTPD2UQQ_LAST=2595, - XED_IFORMFL_VCVTTPH2DQ_FIRST=2596, - XED_IFORMFL_VCVTTPH2DQ_LAST=2601, - XED_IFORMFL_VCVTTPH2QQ_FIRST=2602, - XED_IFORMFL_VCVTTPH2QQ_LAST=2607, - XED_IFORMFL_VCVTTPH2UDQ_FIRST=2608, - XED_IFORMFL_VCVTTPH2UDQ_LAST=2613, - XED_IFORMFL_VCVTTPH2UQQ_FIRST=2614, - XED_IFORMFL_VCVTTPH2UQQ_LAST=2619, - XED_IFORMFL_VCVTTPH2UW_FIRST=2620, - XED_IFORMFL_VCVTTPH2UW_LAST=2625, - XED_IFORMFL_VCVTTPH2W_FIRST=2626, - XED_IFORMFL_VCVTTPH2W_LAST=2631, - XED_IFORMFL_VCVTTPS2DQ_FIRST=2632, - XED_IFORMFL_VCVTTPS2DQ_LAST=2641, - XED_IFORMFL_VCVTTPS2QQ_FIRST=2642, - XED_IFORMFL_VCVTTPS2QQ_LAST=2647, - XED_IFORMFL_VCVTTPS2UDQ_FIRST=2648, - XED_IFORMFL_VCVTTPS2UDQ_LAST=2653, - XED_IFORMFL_VCVTTPS2UQQ_FIRST=2654, - XED_IFORMFL_VCVTTPS2UQQ_LAST=2659, - XED_IFORMFL_VCVTTSD2SI_FIRST=2660, - XED_IFORMFL_VCVTTSD2SI_LAST=2667, - XED_IFORMFL_VCVTTSD2USI_FIRST=2668, - XED_IFORMFL_VCVTTSD2USI_LAST=2671, - XED_IFORMFL_VCVTTSH2SI_FIRST=2672, - XED_IFORMFL_VCVTTSH2SI_LAST=2675, - XED_IFORMFL_VCVTTSH2USI_FIRST=2676, - XED_IFORMFL_VCVTTSH2USI_LAST=2679, - XED_IFORMFL_VCVTTSS2SI_FIRST=2680, - XED_IFORMFL_VCVTTSS2SI_LAST=2687, - XED_IFORMFL_VCVTTSS2USI_FIRST=2688, - XED_IFORMFL_VCVTTSS2USI_LAST=2691, - XED_IFORMFL_VCVTUDQ2PD_FIRST=2692, - XED_IFORMFL_VCVTUDQ2PD_LAST=2697, - XED_IFORMFL_VCVTUDQ2PH_FIRST=2698, - XED_IFORMFL_VCVTUDQ2PH_LAST=2703, - XED_IFORMFL_VCVTUDQ2PS_FIRST=2704, - XED_IFORMFL_VCVTUDQ2PS_LAST=2709, - XED_IFORMFL_VCVTUQQ2PD_FIRST=2710, - XED_IFORMFL_VCVTUQQ2PD_LAST=2715, - XED_IFORMFL_VCVTUQQ2PH_FIRST=2716, - XED_IFORMFL_VCVTUQQ2PH_LAST=2721, - XED_IFORMFL_VCVTUQQ2PS_FIRST=2722, - XED_IFORMFL_VCVTUQQ2PS_LAST=2727, - XED_IFORMFL_VCVTUSI2SD_FIRST=2728, - XED_IFORMFL_VCVTUSI2SD_LAST=2731, - XED_IFORMFL_VCVTUSI2SH_FIRST=2732, - XED_IFORMFL_VCVTUSI2SH_LAST=2735, - XED_IFORMFL_VCVTUSI2SS_FIRST=2736, - XED_IFORMFL_VCVTUSI2SS_LAST=2739, - XED_IFORMFL_VCVTUW2PH_FIRST=2740, - XED_IFORMFL_VCVTUW2PH_LAST=2745, - XED_IFORMFL_VCVTW2PH_FIRST=2746, - XED_IFORMFL_VCVTW2PH_LAST=2751, - XED_IFORMFL_VDBPSADBW_FIRST=2752, - XED_IFORMFL_VDBPSADBW_LAST=2757, - XED_IFORMFL_VDIVPD_FIRST=2758, - XED_IFORMFL_VDIVPD_LAST=2767, - XED_IFORMFL_VDIVPH_FIRST=2768, - XED_IFORMFL_VDIVPH_LAST=2773, - XED_IFORMFL_VDIVPS_FIRST=2774, - XED_IFORMFL_VDIVPS_LAST=2783, - XED_IFORMFL_VDIVSD_FIRST=2784, - XED_IFORMFL_VDIVSD_LAST=2787, - XED_IFORMFL_VDIVSH_FIRST=2788, - XED_IFORMFL_VDIVSH_LAST=2789, - XED_IFORMFL_VDIVSS_FIRST=2790, - XED_IFORMFL_VDIVSS_LAST=2793, - XED_IFORMFL_VDPBF16PS_FIRST=2794, - XED_IFORMFL_VDPBF16PS_LAST=2799, - XED_IFORMFL_VDPPD_FIRST=2800, - XED_IFORMFL_VDPPD_LAST=2801, - XED_IFORMFL_VDPPS_FIRST=2802, - XED_IFORMFL_VDPPS_LAST=2805, - XED_IFORMFL_VERR_FIRST=2806, - XED_IFORMFL_VERR_LAST=2807, - XED_IFORMFL_VERW_FIRST=2808, - XED_IFORMFL_VERW_LAST=2809, - XED_IFORMFL_VEXP2PD_FIRST=2810, - XED_IFORMFL_VEXP2PD_LAST=2811, - XED_IFORMFL_VEXP2PS_FIRST=2812, - XED_IFORMFL_VEXP2PS_LAST=2813, - XED_IFORMFL_VEXPANDPD_FIRST=2814, - XED_IFORMFL_VEXPANDPD_LAST=2819, - XED_IFORMFL_VEXPANDPS_FIRST=2820, - XED_IFORMFL_VEXPANDPS_LAST=2825, - XED_IFORMFL_VEXTRACTF128_FIRST=2826, - XED_IFORMFL_VEXTRACTF128_LAST=2827, - XED_IFORMFL_VEXTRACTF32X4_FIRST=2828, - XED_IFORMFL_VEXTRACTF32X4_LAST=2831, - XED_IFORMFL_VEXTRACTF32X8_FIRST=2832, - XED_IFORMFL_VEXTRACTF32X8_LAST=2833, - XED_IFORMFL_VEXTRACTF64X2_FIRST=2834, - XED_IFORMFL_VEXTRACTF64X2_LAST=2837, - XED_IFORMFL_VEXTRACTF64X4_FIRST=2838, - XED_IFORMFL_VEXTRACTF64X4_LAST=2839, - XED_IFORMFL_VEXTRACTI128_FIRST=2840, - XED_IFORMFL_VEXTRACTI128_LAST=2841, - XED_IFORMFL_VEXTRACTI32X4_FIRST=2842, - XED_IFORMFL_VEXTRACTI32X4_LAST=2845, - XED_IFORMFL_VEXTRACTI32X8_FIRST=2846, - XED_IFORMFL_VEXTRACTI32X8_LAST=2847, - XED_IFORMFL_VEXTRACTI64X2_FIRST=2848, - XED_IFORMFL_VEXTRACTI64X2_LAST=2851, - XED_IFORMFL_VEXTRACTI64X4_FIRST=2852, - XED_IFORMFL_VEXTRACTI64X4_LAST=2853, - XED_IFORMFL_VEXTRACTPS_FIRST=2854, - XED_IFORMFL_VEXTRACTPS_LAST=2857, - XED_IFORMFL_VFCMADDCPH_FIRST=2858, - XED_IFORMFL_VFCMADDCPH_LAST=2863, - XED_IFORMFL_VFCMADDCSH_FIRST=2864, - XED_IFORMFL_VFCMADDCSH_LAST=2865, - XED_IFORMFL_VFCMULCPH_FIRST=2866, - XED_IFORMFL_VFCMULCPH_LAST=2871, - XED_IFORMFL_VFCMULCSH_FIRST=2872, - XED_IFORMFL_VFCMULCSH_LAST=2873, - XED_IFORMFL_VFIXUPIMMPD_FIRST=2874, - XED_IFORMFL_VFIXUPIMMPD_LAST=2879, - XED_IFORMFL_VFIXUPIMMPS_FIRST=2880, - XED_IFORMFL_VFIXUPIMMPS_LAST=2885, - XED_IFORMFL_VFIXUPIMMSD_FIRST=2886, - XED_IFORMFL_VFIXUPIMMSD_LAST=2887, - XED_IFORMFL_VFIXUPIMMSS_FIRST=2888, - XED_IFORMFL_VFIXUPIMMSS_LAST=2889, - XED_IFORMFL_VFMADD132PD_FIRST=2890, - XED_IFORMFL_VFMADD132PD_LAST=2899, - XED_IFORMFL_VFMADD132PH_FIRST=2900, - XED_IFORMFL_VFMADD132PH_LAST=2905, - XED_IFORMFL_VFMADD132PS_FIRST=2906, - XED_IFORMFL_VFMADD132PS_LAST=2915, - XED_IFORMFL_VFMADD132SD_FIRST=2916, - XED_IFORMFL_VFMADD132SD_LAST=2919, - XED_IFORMFL_VFMADD132SH_FIRST=2920, - XED_IFORMFL_VFMADD132SH_LAST=2921, - XED_IFORMFL_VFMADD132SS_FIRST=2922, - XED_IFORMFL_VFMADD132SS_LAST=2925, - XED_IFORMFL_VFMADD213PD_FIRST=2926, - XED_IFORMFL_VFMADD213PD_LAST=2935, - XED_IFORMFL_VFMADD213PH_FIRST=2936, - XED_IFORMFL_VFMADD213PH_LAST=2941, - XED_IFORMFL_VFMADD213PS_FIRST=2942, - XED_IFORMFL_VFMADD213PS_LAST=2951, - XED_IFORMFL_VFMADD213SD_FIRST=2952, - XED_IFORMFL_VFMADD213SD_LAST=2955, - XED_IFORMFL_VFMADD213SH_FIRST=2956, - XED_IFORMFL_VFMADD213SH_LAST=2957, - XED_IFORMFL_VFMADD213SS_FIRST=2958, - XED_IFORMFL_VFMADD213SS_LAST=2961, - XED_IFORMFL_VFMADD231PD_FIRST=2962, - XED_IFORMFL_VFMADD231PD_LAST=2971, - XED_IFORMFL_VFMADD231PH_FIRST=2972, - XED_IFORMFL_VFMADD231PH_LAST=2977, - XED_IFORMFL_VFMADD231PS_FIRST=2978, - XED_IFORMFL_VFMADD231PS_LAST=2987, - XED_IFORMFL_VFMADD231SD_FIRST=2988, - XED_IFORMFL_VFMADD231SD_LAST=2991, - XED_IFORMFL_VFMADD231SH_FIRST=2992, - XED_IFORMFL_VFMADD231SH_LAST=2993, - XED_IFORMFL_VFMADD231SS_FIRST=2994, - XED_IFORMFL_VFMADD231SS_LAST=2997, - XED_IFORMFL_VFMADDCPH_FIRST=2998, - XED_IFORMFL_VFMADDCPH_LAST=3003, - XED_IFORMFL_VFMADDCSH_FIRST=3004, - XED_IFORMFL_VFMADDCSH_LAST=3005, - XED_IFORMFL_VFMADDPD_FIRST=3006, - XED_IFORMFL_VFMADDPD_LAST=3011, - XED_IFORMFL_VFMADDPS_FIRST=3012, - XED_IFORMFL_VFMADDPS_LAST=3017, - XED_IFORMFL_VFMADDSD_FIRST=3018, - XED_IFORMFL_VFMADDSD_LAST=3020, - XED_IFORMFL_VFMADDSS_FIRST=3021, - XED_IFORMFL_VFMADDSS_LAST=3023, - XED_IFORMFL_VFMADDSUB132PD_FIRST=3024, - XED_IFORMFL_VFMADDSUB132PD_LAST=3033, - XED_IFORMFL_VFMADDSUB132PH_FIRST=3034, - XED_IFORMFL_VFMADDSUB132PH_LAST=3039, - XED_IFORMFL_VFMADDSUB132PS_FIRST=3040, - XED_IFORMFL_VFMADDSUB132PS_LAST=3049, - XED_IFORMFL_VFMADDSUB213PD_FIRST=3050, - XED_IFORMFL_VFMADDSUB213PD_LAST=3059, - XED_IFORMFL_VFMADDSUB213PH_FIRST=3060, - XED_IFORMFL_VFMADDSUB213PH_LAST=3065, - XED_IFORMFL_VFMADDSUB213PS_FIRST=3066, - XED_IFORMFL_VFMADDSUB213PS_LAST=3075, - XED_IFORMFL_VFMADDSUB231PD_FIRST=3076, - XED_IFORMFL_VFMADDSUB231PD_LAST=3085, - XED_IFORMFL_VFMADDSUB231PH_FIRST=3086, - XED_IFORMFL_VFMADDSUB231PH_LAST=3091, - XED_IFORMFL_VFMADDSUB231PS_FIRST=3092, - XED_IFORMFL_VFMADDSUB231PS_LAST=3101, - XED_IFORMFL_VFMADDSUBPD_FIRST=3102, - XED_IFORMFL_VFMADDSUBPD_LAST=3107, - XED_IFORMFL_VFMADDSUBPS_FIRST=3108, - XED_IFORMFL_VFMADDSUBPS_LAST=3113, - XED_IFORMFL_VFMSUB132PD_FIRST=3114, - XED_IFORMFL_VFMSUB132PD_LAST=3123, - XED_IFORMFL_VFMSUB132PH_FIRST=3124, - XED_IFORMFL_VFMSUB132PH_LAST=3129, - XED_IFORMFL_VFMSUB132PS_FIRST=3130, - XED_IFORMFL_VFMSUB132PS_LAST=3139, - XED_IFORMFL_VFMSUB132SD_FIRST=3140, - XED_IFORMFL_VFMSUB132SD_LAST=3143, - XED_IFORMFL_VFMSUB132SH_FIRST=3144, - XED_IFORMFL_VFMSUB132SH_LAST=3145, - XED_IFORMFL_VFMSUB132SS_FIRST=3146, - XED_IFORMFL_VFMSUB132SS_LAST=3149, - XED_IFORMFL_VFMSUB213PD_FIRST=3150, - XED_IFORMFL_VFMSUB213PD_LAST=3159, - XED_IFORMFL_VFMSUB213PH_FIRST=3160, - XED_IFORMFL_VFMSUB213PH_LAST=3165, - XED_IFORMFL_VFMSUB213PS_FIRST=3166, - XED_IFORMFL_VFMSUB213PS_LAST=3175, - XED_IFORMFL_VFMSUB213SD_FIRST=3176, - XED_IFORMFL_VFMSUB213SD_LAST=3179, - XED_IFORMFL_VFMSUB213SH_FIRST=3180, - XED_IFORMFL_VFMSUB213SH_LAST=3181, - XED_IFORMFL_VFMSUB213SS_FIRST=3182, - XED_IFORMFL_VFMSUB213SS_LAST=3185, - XED_IFORMFL_VFMSUB231PD_FIRST=3186, - XED_IFORMFL_VFMSUB231PD_LAST=3195, - XED_IFORMFL_VFMSUB231PH_FIRST=3196, - XED_IFORMFL_VFMSUB231PH_LAST=3201, - XED_IFORMFL_VFMSUB231PS_FIRST=3202, - XED_IFORMFL_VFMSUB231PS_LAST=3211, - XED_IFORMFL_VFMSUB231SD_FIRST=3212, - XED_IFORMFL_VFMSUB231SD_LAST=3215, - XED_IFORMFL_VFMSUB231SH_FIRST=3216, - XED_IFORMFL_VFMSUB231SH_LAST=3217, - XED_IFORMFL_VFMSUB231SS_FIRST=3218, - XED_IFORMFL_VFMSUB231SS_LAST=3221, - XED_IFORMFL_VFMSUBADD132PD_FIRST=3222, - XED_IFORMFL_VFMSUBADD132PD_LAST=3231, - XED_IFORMFL_VFMSUBADD132PH_FIRST=3232, - XED_IFORMFL_VFMSUBADD132PH_LAST=3237, - XED_IFORMFL_VFMSUBADD132PS_FIRST=3238, - XED_IFORMFL_VFMSUBADD132PS_LAST=3247, - XED_IFORMFL_VFMSUBADD213PD_FIRST=3248, - XED_IFORMFL_VFMSUBADD213PD_LAST=3257, - XED_IFORMFL_VFMSUBADD213PH_FIRST=3258, - XED_IFORMFL_VFMSUBADD213PH_LAST=3263, - XED_IFORMFL_VFMSUBADD213PS_FIRST=3264, - XED_IFORMFL_VFMSUBADD213PS_LAST=3273, - XED_IFORMFL_VFMSUBADD231PD_FIRST=3274, - XED_IFORMFL_VFMSUBADD231PD_LAST=3283, - XED_IFORMFL_VFMSUBADD231PH_FIRST=3284, - XED_IFORMFL_VFMSUBADD231PH_LAST=3289, - XED_IFORMFL_VFMSUBADD231PS_FIRST=3290, - XED_IFORMFL_VFMSUBADD231PS_LAST=3299, - XED_IFORMFL_VFMSUBADDPD_FIRST=3300, - XED_IFORMFL_VFMSUBADDPD_LAST=3305, - XED_IFORMFL_VFMSUBADDPS_FIRST=3306, - XED_IFORMFL_VFMSUBADDPS_LAST=3311, - XED_IFORMFL_VFMSUBPD_FIRST=3312, - XED_IFORMFL_VFMSUBPD_LAST=3317, - XED_IFORMFL_VFMSUBPS_FIRST=3318, - XED_IFORMFL_VFMSUBPS_LAST=3323, - XED_IFORMFL_VFMSUBSD_FIRST=3324, - XED_IFORMFL_VFMSUBSD_LAST=3326, - XED_IFORMFL_VFMSUBSS_FIRST=3327, - XED_IFORMFL_VFMSUBSS_LAST=3329, - XED_IFORMFL_VFMULCPH_FIRST=3330, - XED_IFORMFL_VFMULCPH_LAST=3335, - XED_IFORMFL_VFMULCSH_FIRST=3336, - XED_IFORMFL_VFMULCSH_LAST=3337, - XED_IFORMFL_VFNMADD132PD_FIRST=3338, - XED_IFORMFL_VFNMADD132PD_LAST=3347, - XED_IFORMFL_VFNMADD132PH_FIRST=3348, - XED_IFORMFL_VFNMADD132PH_LAST=3353, - XED_IFORMFL_VFNMADD132PS_FIRST=3354, - XED_IFORMFL_VFNMADD132PS_LAST=3363, - XED_IFORMFL_VFNMADD132SD_FIRST=3364, - XED_IFORMFL_VFNMADD132SD_LAST=3367, - XED_IFORMFL_VFNMADD132SH_FIRST=3368, - XED_IFORMFL_VFNMADD132SH_LAST=3369, - XED_IFORMFL_VFNMADD132SS_FIRST=3370, - XED_IFORMFL_VFNMADD132SS_LAST=3373, - XED_IFORMFL_VFNMADD213PD_FIRST=3374, - XED_IFORMFL_VFNMADD213PD_LAST=3383, - XED_IFORMFL_VFNMADD213PH_FIRST=3384, - XED_IFORMFL_VFNMADD213PH_LAST=3389, - XED_IFORMFL_VFNMADD213PS_FIRST=3390, - XED_IFORMFL_VFNMADD213PS_LAST=3399, - XED_IFORMFL_VFNMADD213SD_FIRST=3400, - XED_IFORMFL_VFNMADD213SD_LAST=3403, - XED_IFORMFL_VFNMADD213SH_FIRST=3404, - XED_IFORMFL_VFNMADD213SH_LAST=3405, - XED_IFORMFL_VFNMADD213SS_FIRST=3406, - XED_IFORMFL_VFNMADD213SS_LAST=3409, - XED_IFORMFL_VFNMADD231PD_FIRST=3410, - XED_IFORMFL_VFNMADD231PD_LAST=3419, - XED_IFORMFL_VFNMADD231PH_FIRST=3420, - XED_IFORMFL_VFNMADD231PH_LAST=3425, - XED_IFORMFL_VFNMADD231PS_FIRST=3426, - XED_IFORMFL_VFNMADD231PS_LAST=3435, - XED_IFORMFL_VFNMADD231SD_FIRST=3436, - XED_IFORMFL_VFNMADD231SD_LAST=3439, - XED_IFORMFL_VFNMADD231SH_FIRST=3440, - XED_IFORMFL_VFNMADD231SH_LAST=3441, - XED_IFORMFL_VFNMADD231SS_FIRST=3442, - XED_IFORMFL_VFNMADD231SS_LAST=3445, - XED_IFORMFL_VFNMADDPD_FIRST=3446, - XED_IFORMFL_VFNMADDPD_LAST=3451, - XED_IFORMFL_VFNMADDPS_FIRST=3452, - XED_IFORMFL_VFNMADDPS_LAST=3457, - XED_IFORMFL_VFNMADDSD_FIRST=3458, - XED_IFORMFL_VFNMADDSD_LAST=3460, - XED_IFORMFL_VFNMADDSS_FIRST=3461, - XED_IFORMFL_VFNMADDSS_LAST=3463, - XED_IFORMFL_VFNMSUB132PD_FIRST=3464, - XED_IFORMFL_VFNMSUB132PD_LAST=3473, - XED_IFORMFL_VFNMSUB132PH_FIRST=3474, - XED_IFORMFL_VFNMSUB132PH_LAST=3479, - XED_IFORMFL_VFNMSUB132PS_FIRST=3480, - XED_IFORMFL_VFNMSUB132PS_LAST=3489, - XED_IFORMFL_VFNMSUB132SD_FIRST=3490, - XED_IFORMFL_VFNMSUB132SD_LAST=3493, - XED_IFORMFL_VFNMSUB132SH_FIRST=3494, - XED_IFORMFL_VFNMSUB132SH_LAST=3495, - XED_IFORMFL_VFNMSUB132SS_FIRST=3496, - XED_IFORMFL_VFNMSUB132SS_LAST=3499, - XED_IFORMFL_VFNMSUB213PD_FIRST=3500, - XED_IFORMFL_VFNMSUB213PD_LAST=3509, - XED_IFORMFL_VFNMSUB213PH_FIRST=3510, - XED_IFORMFL_VFNMSUB213PH_LAST=3515, - XED_IFORMFL_VFNMSUB213PS_FIRST=3516, - XED_IFORMFL_VFNMSUB213PS_LAST=3525, - XED_IFORMFL_VFNMSUB213SD_FIRST=3526, - XED_IFORMFL_VFNMSUB213SD_LAST=3529, - XED_IFORMFL_VFNMSUB213SH_FIRST=3530, - XED_IFORMFL_VFNMSUB213SH_LAST=3531, - XED_IFORMFL_VFNMSUB213SS_FIRST=3532, - XED_IFORMFL_VFNMSUB213SS_LAST=3535, - XED_IFORMFL_VFNMSUB231PD_FIRST=3536, - XED_IFORMFL_VFNMSUB231PD_LAST=3545, - XED_IFORMFL_VFNMSUB231PH_FIRST=3546, - XED_IFORMFL_VFNMSUB231PH_LAST=3551, - XED_IFORMFL_VFNMSUB231PS_FIRST=3552, - XED_IFORMFL_VFNMSUB231PS_LAST=3561, - XED_IFORMFL_VFNMSUB231SD_FIRST=3562, - XED_IFORMFL_VFNMSUB231SD_LAST=3565, - XED_IFORMFL_VFNMSUB231SH_FIRST=3566, - XED_IFORMFL_VFNMSUB231SH_LAST=3567, - XED_IFORMFL_VFNMSUB231SS_FIRST=3568, - XED_IFORMFL_VFNMSUB231SS_LAST=3571, - XED_IFORMFL_VFNMSUBPD_FIRST=3572, - XED_IFORMFL_VFNMSUBPD_LAST=3577, - XED_IFORMFL_VFNMSUBPS_FIRST=3578, - XED_IFORMFL_VFNMSUBPS_LAST=3583, - XED_IFORMFL_VFNMSUBSD_FIRST=3584, - XED_IFORMFL_VFNMSUBSD_LAST=3586, - XED_IFORMFL_VFNMSUBSS_FIRST=3587, - XED_IFORMFL_VFNMSUBSS_LAST=3589, - XED_IFORMFL_VFPCLASSPD_FIRST=3590, - XED_IFORMFL_VFPCLASSPD_LAST=3595, - XED_IFORMFL_VFPCLASSPH_FIRST=3596, - XED_IFORMFL_VFPCLASSPH_LAST=3601, - XED_IFORMFL_VFPCLASSPS_FIRST=3602, - XED_IFORMFL_VFPCLASSPS_LAST=3607, - XED_IFORMFL_VFPCLASSSD_FIRST=3608, - XED_IFORMFL_VFPCLASSSD_LAST=3609, - XED_IFORMFL_VFPCLASSSH_FIRST=3610, - XED_IFORMFL_VFPCLASSSH_LAST=3611, - XED_IFORMFL_VFPCLASSSS_FIRST=3612, - XED_IFORMFL_VFPCLASSSS_LAST=3613, - XED_IFORMFL_VFRCZPD_FIRST=3614, - XED_IFORMFL_VFRCZPD_LAST=3617, - XED_IFORMFL_VFRCZPS_FIRST=3618, - XED_IFORMFL_VFRCZPS_LAST=3621, - XED_IFORMFL_VFRCZSD_FIRST=3622, - XED_IFORMFL_VFRCZSD_LAST=3623, - XED_IFORMFL_VFRCZSS_FIRST=3624, - XED_IFORMFL_VFRCZSS_LAST=3625, - XED_IFORMFL_VGATHERDPD_FIRST=3626, - XED_IFORMFL_VGATHERDPD_LAST=3630, - XED_IFORMFL_VGATHERDPS_FIRST=3631, - XED_IFORMFL_VGATHERDPS_LAST=3635, - XED_IFORMFL_VGATHERPF0DPD_FIRST=3636, - XED_IFORMFL_VGATHERPF0DPD_LAST=3636, - XED_IFORMFL_VGATHERPF0DPS_FIRST=3637, - XED_IFORMFL_VGATHERPF0DPS_LAST=3637, - XED_IFORMFL_VGATHERPF0QPD_FIRST=3638, - XED_IFORMFL_VGATHERPF0QPD_LAST=3638, - XED_IFORMFL_VGATHERPF0QPS_FIRST=3639, - XED_IFORMFL_VGATHERPF0QPS_LAST=3639, - XED_IFORMFL_VGATHERPF1DPD_FIRST=3640, - XED_IFORMFL_VGATHERPF1DPD_LAST=3640, - XED_IFORMFL_VGATHERPF1DPS_FIRST=3641, - XED_IFORMFL_VGATHERPF1DPS_LAST=3641, - XED_IFORMFL_VGATHERPF1QPD_FIRST=3642, - XED_IFORMFL_VGATHERPF1QPD_LAST=3642, - XED_IFORMFL_VGATHERPF1QPS_FIRST=3643, - XED_IFORMFL_VGATHERPF1QPS_LAST=3643, - XED_IFORMFL_VGATHERQPD_FIRST=3644, - XED_IFORMFL_VGATHERQPD_LAST=3648, - XED_IFORMFL_VGATHERQPS_FIRST=3649, - XED_IFORMFL_VGATHERQPS_LAST=3653, - XED_IFORMFL_VGETEXPPD_FIRST=3654, - XED_IFORMFL_VGETEXPPD_LAST=3659, - XED_IFORMFL_VGETEXPPH_FIRST=3660, - XED_IFORMFL_VGETEXPPH_LAST=3665, - XED_IFORMFL_VGETEXPPS_FIRST=3666, - XED_IFORMFL_VGETEXPPS_LAST=3671, - XED_IFORMFL_VGETEXPSD_FIRST=3672, - XED_IFORMFL_VGETEXPSD_LAST=3673, - XED_IFORMFL_VGETEXPSH_FIRST=3674, - XED_IFORMFL_VGETEXPSH_LAST=3675, - XED_IFORMFL_VGETEXPSS_FIRST=3676, - XED_IFORMFL_VGETEXPSS_LAST=3677, - XED_IFORMFL_VGETMANTPD_FIRST=3678, - XED_IFORMFL_VGETMANTPD_LAST=3683, - XED_IFORMFL_VGETMANTPH_FIRST=3684, - XED_IFORMFL_VGETMANTPH_LAST=3689, - XED_IFORMFL_VGETMANTPS_FIRST=3690, - XED_IFORMFL_VGETMANTPS_LAST=3695, - XED_IFORMFL_VGETMANTSD_FIRST=3696, - XED_IFORMFL_VGETMANTSD_LAST=3697, - XED_IFORMFL_VGETMANTSH_FIRST=3698, - XED_IFORMFL_VGETMANTSH_LAST=3699, - XED_IFORMFL_VGETMANTSS_FIRST=3700, - XED_IFORMFL_VGETMANTSS_LAST=3701, - XED_IFORMFL_VGF2P8AFFINEINVQB_FIRST=3702, - XED_IFORMFL_VGF2P8AFFINEINVQB_LAST=3711, - XED_IFORMFL_VGF2P8AFFINEQB_FIRST=3712, - XED_IFORMFL_VGF2P8AFFINEQB_LAST=3721, - XED_IFORMFL_VGF2P8MULB_FIRST=3722, - XED_IFORMFL_VGF2P8MULB_LAST=3731, - XED_IFORMFL_VHADDPD_FIRST=3732, - XED_IFORMFL_VHADDPD_LAST=3735, - XED_IFORMFL_VHADDPS_FIRST=3736, - XED_IFORMFL_VHADDPS_LAST=3739, - XED_IFORMFL_VHSUBPD_FIRST=3740, - XED_IFORMFL_VHSUBPD_LAST=3743, - XED_IFORMFL_VHSUBPS_FIRST=3744, - XED_IFORMFL_VHSUBPS_LAST=3747, - XED_IFORMFL_VINSERTF128_FIRST=3748, - XED_IFORMFL_VINSERTF128_LAST=3749, - XED_IFORMFL_VINSERTF32X4_FIRST=3750, - XED_IFORMFL_VINSERTF32X4_LAST=3753, - XED_IFORMFL_VINSERTF32X8_FIRST=3754, - XED_IFORMFL_VINSERTF32X8_LAST=3755, - XED_IFORMFL_VINSERTF64X2_FIRST=3756, - XED_IFORMFL_VINSERTF64X2_LAST=3759, - XED_IFORMFL_VINSERTF64X4_FIRST=3760, - XED_IFORMFL_VINSERTF64X4_LAST=3761, - XED_IFORMFL_VINSERTI128_FIRST=3762, - XED_IFORMFL_VINSERTI128_LAST=3763, - XED_IFORMFL_VINSERTI32X4_FIRST=3764, - XED_IFORMFL_VINSERTI32X4_LAST=3767, - XED_IFORMFL_VINSERTI32X8_FIRST=3768, - XED_IFORMFL_VINSERTI32X8_LAST=3769, - XED_IFORMFL_VINSERTI64X2_FIRST=3770, - XED_IFORMFL_VINSERTI64X2_LAST=3773, - XED_IFORMFL_VINSERTI64X4_FIRST=3774, - XED_IFORMFL_VINSERTI64X4_LAST=3775, - XED_IFORMFL_VINSERTPS_FIRST=3776, - XED_IFORMFL_VINSERTPS_LAST=3779, - XED_IFORMFL_VLDDQU_FIRST=3780, - XED_IFORMFL_VLDDQU_LAST=3781, - XED_IFORMFL_VLDMXCSR_FIRST=3782, - XED_IFORMFL_VLDMXCSR_LAST=3782, - XED_IFORMFL_VMASKMOVDQU_FIRST=3783, - XED_IFORMFL_VMASKMOVDQU_LAST=3783, - XED_IFORMFL_VMASKMOVPD_FIRST=3784, - XED_IFORMFL_VMASKMOVPD_LAST=3787, - XED_IFORMFL_VMASKMOVPS_FIRST=3788, - XED_IFORMFL_VMASKMOVPS_LAST=3791, - XED_IFORMFL_VMAXPD_FIRST=3792, - XED_IFORMFL_VMAXPD_LAST=3801, - XED_IFORMFL_VMAXPH_FIRST=3802, - XED_IFORMFL_VMAXPH_LAST=3807, - XED_IFORMFL_VMAXPS_FIRST=3808, - XED_IFORMFL_VMAXPS_LAST=3817, - XED_IFORMFL_VMAXSD_FIRST=3818, - XED_IFORMFL_VMAXSD_LAST=3821, - XED_IFORMFL_VMAXSH_FIRST=3822, - XED_IFORMFL_VMAXSH_LAST=3823, - XED_IFORMFL_VMAXSS_FIRST=3824, - XED_IFORMFL_VMAXSS_LAST=3827, - XED_IFORMFL_VMCALL_FIRST=3828, - XED_IFORMFL_VMCALL_LAST=3828, - XED_IFORMFL_VMCLEAR_FIRST=3829, - XED_IFORMFL_VMCLEAR_LAST=3829, - XED_IFORMFL_VMFUNC_FIRST=3830, - XED_IFORMFL_VMFUNC_LAST=3830, - XED_IFORMFL_VMINPD_FIRST=3831, - XED_IFORMFL_VMINPD_LAST=3840, - XED_IFORMFL_VMINPH_FIRST=3841, - XED_IFORMFL_VMINPH_LAST=3846, - XED_IFORMFL_VMINPS_FIRST=3847, - XED_IFORMFL_VMINPS_LAST=3856, - XED_IFORMFL_VMINSD_FIRST=3857, - XED_IFORMFL_VMINSD_LAST=3860, - XED_IFORMFL_VMINSH_FIRST=3861, - XED_IFORMFL_VMINSH_LAST=3862, - XED_IFORMFL_VMINSS_FIRST=3863, - XED_IFORMFL_VMINSS_LAST=3866, - XED_IFORMFL_VMLAUNCH_FIRST=3867, - XED_IFORMFL_VMLAUNCH_LAST=3867, - XED_IFORMFL_VMLOAD_FIRST=3868, - XED_IFORMFL_VMLOAD_LAST=3868, - XED_IFORMFL_VMMCALL_FIRST=3869, - XED_IFORMFL_VMMCALL_LAST=3869, - XED_IFORMFL_VMOVAPD_FIRST=3870, - XED_IFORMFL_VMOVAPD_LAST=3886, - XED_IFORMFL_VMOVAPS_FIRST=3887, - XED_IFORMFL_VMOVAPS_LAST=3903, - XED_IFORMFL_VMOVD_FIRST=3904, - XED_IFORMFL_VMOVD_LAST=3911, - XED_IFORMFL_VMOVDDUP_FIRST=3912, - XED_IFORMFL_VMOVDDUP_LAST=3921, - XED_IFORMFL_VMOVDQA_FIRST=3922, - XED_IFORMFL_VMOVDQA_LAST=3929, - XED_IFORMFL_VMOVDQA32_FIRST=3930, - XED_IFORMFL_VMOVDQA32_LAST=3938, - XED_IFORMFL_VMOVDQA64_FIRST=3939, - XED_IFORMFL_VMOVDQA64_LAST=3947, - XED_IFORMFL_VMOVDQU_FIRST=3948, - XED_IFORMFL_VMOVDQU_LAST=3955, - XED_IFORMFL_VMOVDQU16_FIRST=3956, - XED_IFORMFL_VMOVDQU16_LAST=3964, - XED_IFORMFL_VMOVDQU32_FIRST=3965, - XED_IFORMFL_VMOVDQU32_LAST=3973, - XED_IFORMFL_VMOVDQU64_FIRST=3974, - XED_IFORMFL_VMOVDQU64_LAST=3982, - XED_IFORMFL_VMOVDQU8_FIRST=3983, - XED_IFORMFL_VMOVDQU8_LAST=3991, - XED_IFORMFL_VMOVHLPS_FIRST=3992, - XED_IFORMFL_VMOVHLPS_LAST=3993, - XED_IFORMFL_VMOVHPD_FIRST=3994, - XED_IFORMFL_VMOVHPD_LAST=3997, - XED_IFORMFL_VMOVHPS_FIRST=3998, - XED_IFORMFL_VMOVHPS_LAST=4001, - XED_IFORMFL_VMOVLHPS_FIRST=4002, - XED_IFORMFL_VMOVLHPS_LAST=4003, - XED_IFORMFL_VMOVLPD_FIRST=4004, - XED_IFORMFL_VMOVLPD_LAST=4007, - XED_IFORMFL_VMOVLPS_FIRST=4008, - XED_IFORMFL_VMOVLPS_LAST=4011, - XED_IFORMFL_VMOVMSKPD_FIRST=4012, - XED_IFORMFL_VMOVMSKPD_LAST=4013, - XED_IFORMFL_VMOVMSKPS_FIRST=4014, - XED_IFORMFL_VMOVMSKPS_LAST=4015, - XED_IFORMFL_VMOVNTDQ_FIRST=4016, - XED_IFORMFL_VMOVNTDQ_LAST=4020, - XED_IFORMFL_VMOVNTDQA_FIRST=4021, - XED_IFORMFL_VMOVNTDQA_LAST=4025, - XED_IFORMFL_VMOVNTPD_FIRST=4026, - XED_IFORMFL_VMOVNTPD_LAST=4030, - XED_IFORMFL_VMOVNTPS_FIRST=4031, - XED_IFORMFL_VMOVNTPS_LAST=4035, - XED_IFORMFL_VMOVQ_FIRST=4036, - XED_IFORMFL_VMOVQ_LAST=4048, - XED_IFORMFL_VMOVSD_FIRST=4049, - XED_IFORMFL_VMOVSD_LAST=4055, - XED_IFORMFL_VMOVSH_FIRST=4056, - XED_IFORMFL_VMOVSH_LAST=4058, - XED_IFORMFL_VMOVSHDUP_FIRST=4059, - XED_IFORMFL_VMOVSHDUP_LAST=4068, - XED_IFORMFL_VMOVSLDUP_FIRST=4069, - XED_IFORMFL_VMOVSLDUP_LAST=4078, - XED_IFORMFL_VMOVSS_FIRST=4079, - XED_IFORMFL_VMOVSS_LAST=4085, - XED_IFORMFL_VMOVUPD_FIRST=4086, - XED_IFORMFL_VMOVUPD_LAST=4102, - XED_IFORMFL_VMOVUPS_FIRST=4103, - XED_IFORMFL_VMOVUPS_LAST=4119, - XED_IFORMFL_VMOVW_FIRST=4120, - XED_IFORMFL_VMOVW_LAST=4123, - XED_IFORMFL_VMPSADBW_FIRST=4124, - XED_IFORMFL_VMPSADBW_LAST=4127, - XED_IFORMFL_VMPTRLD_FIRST=4128, - XED_IFORMFL_VMPTRLD_LAST=4128, - XED_IFORMFL_VMPTRST_FIRST=4129, - XED_IFORMFL_VMPTRST_LAST=4129, - XED_IFORMFL_VMREAD_FIRST=4130, - XED_IFORMFL_VMREAD_LAST=4133, - XED_IFORMFL_VMRESUME_FIRST=4134, - XED_IFORMFL_VMRESUME_LAST=4134, - XED_IFORMFL_VMRUN_FIRST=4135, - XED_IFORMFL_VMRUN_LAST=4135, - XED_IFORMFL_VMSAVE_FIRST=4136, - XED_IFORMFL_VMSAVE_LAST=4136, - XED_IFORMFL_VMULPD_FIRST=4137, - XED_IFORMFL_VMULPD_LAST=4146, - XED_IFORMFL_VMULPH_FIRST=4147, - XED_IFORMFL_VMULPH_LAST=4152, - XED_IFORMFL_VMULPS_FIRST=4153, - XED_IFORMFL_VMULPS_LAST=4162, - XED_IFORMFL_VMULSD_FIRST=4163, - XED_IFORMFL_VMULSD_LAST=4166, - XED_IFORMFL_VMULSH_FIRST=4167, - XED_IFORMFL_VMULSH_LAST=4168, - XED_IFORMFL_VMULSS_FIRST=4169, - XED_IFORMFL_VMULSS_LAST=4172, - XED_IFORMFL_VMWRITE_FIRST=4173, - XED_IFORMFL_VMWRITE_LAST=4176, - XED_IFORMFL_VMXOFF_FIRST=4177, - XED_IFORMFL_VMXOFF_LAST=4177, - XED_IFORMFL_VMXON_FIRST=4178, - XED_IFORMFL_VMXON_LAST=4178, - XED_IFORMFL_VORPD_FIRST=4179, - XED_IFORMFL_VORPD_LAST=4188, - XED_IFORMFL_VORPS_FIRST=4189, - XED_IFORMFL_VORPS_LAST=4198, - XED_IFORMFL_VP2INTERSECTD_FIRST=4199, - XED_IFORMFL_VP2INTERSECTD_LAST=4204, - XED_IFORMFL_VP2INTERSECTQ_FIRST=4205, - XED_IFORMFL_VP2INTERSECTQ_LAST=4210, - XED_IFORMFL_VP4DPWSSD_FIRST=4211, - XED_IFORMFL_VP4DPWSSD_LAST=4211, - XED_IFORMFL_VP4DPWSSDS_FIRST=4212, - XED_IFORMFL_VP4DPWSSDS_LAST=4212, - XED_IFORMFL_VPABSB_FIRST=4213, - XED_IFORMFL_VPABSB_LAST=4222, - XED_IFORMFL_VPABSD_FIRST=4223, - XED_IFORMFL_VPABSD_LAST=4232, - XED_IFORMFL_VPABSQ_FIRST=4233, - XED_IFORMFL_VPABSQ_LAST=4238, - XED_IFORMFL_VPABSW_FIRST=4239, - XED_IFORMFL_VPABSW_LAST=4248, - XED_IFORMFL_VPACKSSDW_FIRST=4249, - XED_IFORMFL_VPACKSSDW_LAST=4258, - XED_IFORMFL_VPACKSSWB_FIRST=4259, - XED_IFORMFL_VPACKSSWB_LAST=4268, - XED_IFORMFL_VPACKUSDW_FIRST=4269, - XED_IFORMFL_VPACKUSDW_LAST=4278, - XED_IFORMFL_VPACKUSWB_FIRST=4279, - XED_IFORMFL_VPACKUSWB_LAST=4288, - XED_IFORMFL_VPADDB_FIRST=4289, - XED_IFORMFL_VPADDB_LAST=4298, - XED_IFORMFL_VPADDD_FIRST=4299, - XED_IFORMFL_VPADDD_LAST=4308, - XED_IFORMFL_VPADDQ_FIRST=4309, - XED_IFORMFL_VPADDQ_LAST=4318, - XED_IFORMFL_VPADDSB_FIRST=4319, - XED_IFORMFL_VPADDSB_LAST=4328, - XED_IFORMFL_VPADDSW_FIRST=4329, - XED_IFORMFL_VPADDSW_LAST=4338, - XED_IFORMFL_VPADDUSB_FIRST=4339, - XED_IFORMFL_VPADDUSB_LAST=4348, - XED_IFORMFL_VPADDUSW_FIRST=4349, - XED_IFORMFL_VPADDUSW_LAST=4358, - XED_IFORMFL_VPADDW_FIRST=4359, - XED_IFORMFL_VPADDW_LAST=4368, - XED_IFORMFL_VPALIGNR_FIRST=4369, - XED_IFORMFL_VPALIGNR_LAST=4378, - XED_IFORMFL_VPAND_FIRST=4379, - XED_IFORMFL_VPAND_LAST=4382, - XED_IFORMFL_VPANDD_FIRST=4383, - XED_IFORMFL_VPANDD_LAST=4388, - XED_IFORMFL_VPANDN_FIRST=4389, - XED_IFORMFL_VPANDN_LAST=4392, - XED_IFORMFL_VPANDND_FIRST=4393, - XED_IFORMFL_VPANDND_LAST=4398, - XED_IFORMFL_VPANDNQ_FIRST=4399, - XED_IFORMFL_VPANDNQ_LAST=4404, - XED_IFORMFL_VPANDQ_FIRST=4405, - XED_IFORMFL_VPANDQ_LAST=4410, - XED_IFORMFL_VPAVGB_FIRST=4411, - XED_IFORMFL_VPAVGB_LAST=4420, - XED_IFORMFL_VPAVGW_FIRST=4421, - XED_IFORMFL_VPAVGW_LAST=4430, - XED_IFORMFL_VPBLENDD_FIRST=4431, - XED_IFORMFL_VPBLENDD_LAST=4434, - XED_IFORMFL_VPBLENDMB_FIRST=4435, - XED_IFORMFL_VPBLENDMB_LAST=4440, - XED_IFORMFL_VPBLENDMD_FIRST=4441, - XED_IFORMFL_VPBLENDMD_LAST=4446, - XED_IFORMFL_VPBLENDMQ_FIRST=4447, - XED_IFORMFL_VPBLENDMQ_LAST=4452, - XED_IFORMFL_VPBLENDMW_FIRST=4453, - XED_IFORMFL_VPBLENDMW_LAST=4458, - XED_IFORMFL_VPBLENDVB_FIRST=4459, - XED_IFORMFL_VPBLENDVB_LAST=4462, - XED_IFORMFL_VPBLENDW_FIRST=4463, - XED_IFORMFL_VPBLENDW_LAST=4466, - XED_IFORMFL_VPBROADCASTB_FIRST=4467, - XED_IFORMFL_VPBROADCASTB_LAST=4479, - XED_IFORMFL_VPBROADCASTD_FIRST=4480, - XED_IFORMFL_VPBROADCASTD_LAST=4492, - XED_IFORMFL_VPBROADCASTMB2Q_FIRST=4493, - XED_IFORMFL_VPBROADCASTMB2Q_LAST=4495, - XED_IFORMFL_VPBROADCASTMW2D_FIRST=4496, - XED_IFORMFL_VPBROADCASTMW2D_LAST=4498, - XED_IFORMFL_VPBROADCASTQ_FIRST=4499, - XED_IFORMFL_VPBROADCASTQ_LAST=4511, - XED_IFORMFL_VPBROADCASTW_FIRST=4512, - XED_IFORMFL_VPBROADCASTW_LAST=4524, - XED_IFORMFL_VPCLMULQDQ_FIRST=4525, - XED_IFORMFL_VPCLMULQDQ_LAST=4534, - XED_IFORMFL_VPCMOV_FIRST=4535, - XED_IFORMFL_VPCMOV_LAST=4540, - XED_IFORMFL_VPCMPB_FIRST=4541, - XED_IFORMFL_VPCMPB_LAST=4546, - XED_IFORMFL_VPCMPD_FIRST=4547, - XED_IFORMFL_VPCMPD_LAST=4552, - XED_IFORMFL_VPCMPEQB_FIRST=4553, - XED_IFORMFL_VPCMPEQB_LAST=4562, - XED_IFORMFL_VPCMPEQD_FIRST=4563, - XED_IFORMFL_VPCMPEQD_LAST=4572, - XED_IFORMFL_VPCMPEQQ_FIRST=4573, - XED_IFORMFL_VPCMPEQQ_LAST=4582, - XED_IFORMFL_VPCMPEQW_FIRST=4583, - XED_IFORMFL_VPCMPEQW_LAST=4592, - XED_IFORMFL_VPCMPESTRI_FIRST=4593, - XED_IFORMFL_VPCMPESTRI_LAST=4594, - XED_IFORMFL_VPCMPESTRI64_FIRST=4595, - XED_IFORMFL_VPCMPESTRI64_LAST=4596, - XED_IFORMFL_VPCMPESTRM_FIRST=4597, - XED_IFORMFL_VPCMPESTRM_LAST=4598, - XED_IFORMFL_VPCMPESTRM64_FIRST=4599, - XED_IFORMFL_VPCMPESTRM64_LAST=4600, - XED_IFORMFL_VPCMPGTB_FIRST=4601, - XED_IFORMFL_VPCMPGTB_LAST=4610, - XED_IFORMFL_VPCMPGTD_FIRST=4611, - XED_IFORMFL_VPCMPGTD_LAST=4620, - XED_IFORMFL_VPCMPGTQ_FIRST=4621, - XED_IFORMFL_VPCMPGTQ_LAST=4630, - XED_IFORMFL_VPCMPGTW_FIRST=4631, - XED_IFORMFL_VPCMPGTW_LAST=4640, - XED_IFORMFL_VPCMPISTRI_FIRST=4641, - XED_IFORMFL_VPCMPISTRI_LAST=4642, - XED_IFORMFL_VPCMPISTRI64_FIRST=4643, - XED_IFORMFL_VPCMPISTRI64_LAST=4644, - XED_IFORMFL_VPCMPISTRM_FIRST=4645, - XED_IFORMFL_VPCMPISTRM_LAST=4646, - XED_IFORMFL_VPCMPQ_FIRST=4647, - XED_IFORMFL_VPCMPQ_LAST=4652, - XED_IFORMFL_VPCMPUB_FIRST=4653, - XED_IFORMFL_VPCMPUB_LAST=4658, - XED_IFORMFL_VPCMPUD_FIRST=4659, - XED_IFORMFL_VPCMPUD_LAST=4664, - XED_IFORMFL_VPCMPUQ_FIRST=4665, - XED_IFORMFL_VPCMPUQ_LAST=4670, - XED_IFORMFL_VPCMPUW_FIRST=4671, - XED_IFORMFL_VPCMPUW_LAST=4676, - XED_IFORMFL_VPCMPW_FIRST=4677, - XED_IFORMFL_VPCMPW_LAST=4682, - XED_IFORMFL_VPCOMB_FIRST=4683, - XED_IFORMFL_VPCOMB_LAST=4684, - XED_IFORMFL_VPCOMD_FIRST=4685, - XED_IFORMFL_VPCOMD_LAST=4686, - XED_IFORMFL_VPCOMPRESSB_FIRST=4687, - XED_IFORMFL_VPCOMPRESSB_LAST=4692, - XED_IFORMFL_VPCOMPRESSD_FIRST=4693, - XED_IFORMFL_VPCOMPRESSD_LAST=4698, - XED_IFORMFL_VPCOMPRESSQ_FIRST=4699, - XED_IFORMFL_VPCOMPRESSQ_LAST=4704, - XED_IFORMFL_VPCOMPRESSW_FIRST=4705, - XED_IFORMFL_VPCOMPRESSW_LAST=4710, - XED_IFORMFL_VPCOMQ_FIRST=4711, - XED_IFORMFL_VPCOMQ_LAST=4712, - XED_IFORMFL_VPCOMUB_FIRST=4713, - XED_IFORMFL_VPCOMUB_LAST=4714, - XED_IFORMFL_VPCOMUD_FIRST=4715, - XED_IFORMFL_VPCOMUD_LAST=4716, - XED_IFORMFL_VPCOMUQ_FIRST=4717, - XED_IFORMFL_VPCOMUQ_LAST=4718, - XED_IFORMFL_VPCOMUW_FIRST=4719, - XED_IFORMFL_VPCOMUW_LAST=4720, - XED_IFORMFL_VPCOMW_FIRST=4721, - XED_IFORMFL_VPCOMW_LAST=4722, - XED_IFORMFL_VPCONFLICTD_FIRST=4723, - XED_IFORMFL_VPCONFLICTD_LAST=4728, - XED_IFORMFL_VPCONFLICTQ_FIRST=4729, - XED_IFORMFL_VPCONFLICTQ_LAST=4734, - XED_IFORMFL_VPDPBUSD_FIRST=4735, - XED_IFORMFL_VPDPBUSD_LAST=4744, - XED_IFORMFL_VPDPBUSDS_FIRST=4745, - XED_IFORMFL_VPDPBUSDS_LAST=4754, - XED_IFORMFL_VPDPWSSD_FIRST=4755, - XED_IFORMFL_VPDPWSSD_LAST=4764, - XED_IFORMFL_VPDPWSSDS_FIRST=4765, - XED_IFORMFL_VPDPWSSDS_LAST=4774, - XED_IFORMFL_VPERM2F128_FIRST=4775, - XED_IFORMFL_VPERM2F128_LAST=4776, - XED_IFORMFL_VPERM2I128_FIRST=4777, - XED_IFORMFL_VPERM2I128_LAST=4778, - XED_IFORMFL_VPERMB_FIRST=4779, - XED_IFORMFL_VPERMB_LAST=4784, - XED_IFORMFL_VPERMD_FIRST=4785, - XED_IFORMFL_VPERMD_LAST=4790, - XED_IFORMFL_VPERMI2B_FIRST=4791, - XED_IFORMFL_VPERMI2B_LAST=4796, - XED_IFORMFL_VPERMI2D_FIRST=4797, - XED_IFORMFL_VPERMI2D_LAST=4802, - XED_IFORMFL_VPERMI2PD_FIRST=4803, - XED_IFORMFL_VPERMI2PD_LAST=4808, - XED_IFORMFL_VPERMI2PS_FIRST=4809, - XED_IFORMFL_VPERMI2PS_LAST=4814, - XED_IFORMFL_VPERMI2Q_FIRST=4815, - XED_IFORMFL_VPERMI2Q_LAST=4820, - XED_IFORMFL_VPERMI2W_FIRST=4821, - XED_IFORMFL_VPERMI2W_LAST=4826, - XED_IFORMFL_VPERMIL2PD_FIRST=4827, - XED_IFORMFL_VPERMIL2PD_LAST=4832, - XED_IFORMFL_VPERMIL2PS_FIRST=4833, - XED_IFORMFL_VPERMIL2PS_LAST=4838, - XED_IFORMFL_VPERMILPD_FIRST=4839, - XED_IFORMFL_VPERMILPD_LAST=4858, - XED_IFORMFL_VPERMILPS_FIRST=4859, - XED_IFORMFL_VPERMILPS_LAST=4878, - XED_IFORMFL_VPERMPD_FIRST=4879, - XED_IFORMFL_VPERMPD_LAST=4888, - XED_IFORMFL_VPERMPS_FIRST=4889, - XED_IFORMFL_VPERMPS_LAST=4894, - XED_IFORMFL_VPERMQ_FIRST=4895, - XED_IFORMFL_VPERMQ_LAST=4904, - XED_IFORMFL_VPERMT2B_FIRST=4905, - XED_IFORMFL_VPERMT2B_LAST=4910, - XED_IFORMFL_VPERMT2D_FIRST=4911, - XED_IFORMFL_VPERMT2D_LAST=4916, - XED_IFORMFL_VPERMT2PD_FIRST=4917, - XED_IFORMFL_VPERMT2PD_LAST=4922, - XED_IFORMFL_VPERMT2PS_FIRST=4923, - XED_IFORMFL_VPERMT2PS_LAST=4928, - XED_IFORMFL_VPERMT2Q_FIRST=4929, - XED_IFORMFL_VPERMT2Q_LAST=4934, - XED_IFORMFL_VPERMT2W_FIRST=4935, - XED_IFORMFL_VPERMT2W_LAST=4940, - XED_IFORMFL_VPERMW_FIRST=4941, - XED_IFORMFL_VPERMW_LAST=4946, - XED_IFORMFL_VPEXPANDB_FIRST=4947, - XED_IFORMFL_VPEXPANDB_LAST=4952, - XED_IFORMFL_VPEXPANDD_FIRST=4953, - XED_IFORMFL_VPEXPANDD_LAST=4958, - XED_IFORMFL_VPEXPANDQ_FIRST=4959, - XED_IFORMFL_VPEXPANDQ_LAST=4964, - XED_IFORMFL_VPEXPANDW_FIRST=4965, - XED_IFORMFL_VPEXPANDW_LAST=4970, - XED_IFORMFL_VPEXTRB_FIRST=4971, - XED_IFORMFL_VPEXTRB_LAST=4974, - XED_IFORMFL_VPEXTRD_FIRST=4975, - XED_IFORMFL_VPEXTRD_LAST=4978, - XED_IFORMFL_VPEXTRQ_FIRST=4979, - XED_IFORMFL_VPEXTRQ_LAST=4982, - XED_IFORMFL_VPEXTRW_FIRST=4983, - XED_IFORMFL_VPEXTRW_LAST=4987, - XED_IFORMFL_VPEXTRW_C5_FIRST=4988, - XED_IFORMFL_VPEXTRW_C5_LAST=4988, - XED_IFORMFL_VPGATHERDD_FIRST=4989, - XED_IFORMFL_VPGATHERDD_LAST=4993, - XED_IFORMFL_VPGATHERDQ_FIRST=4994, - XED_IFORMFL_VPGATHERDQ_LAST=4998, - XED_IFORMFL_VPGATHERQD_FIRST=4999, - XED_IFORMFL_VPGATHERQD_LAST=5003, - XED_IFORMFL_VPGATHERQQ_FIRST=5004, - XED_IFORMFL_VPGATHERQQ_LAST=5008, - XED_IFORMFL_VPHADDBD_FIRST=5009, - XED_IFORMFL_VPHADDBD_LAST=5010, - XED_IFORMFL_VPHADDBQ_FIRST=5011, - XED_IFORMFL_VPHADDBQ_LAST=5012, - XED_IFORMFL_VPHADDBW_FIRST=5013, - XED_IFORMFL_VPHADDBW_LAST=5014, - XED_IFORMFL_VPHADDD_FIRST=5015, - XED_IFORMFL_VPHADDD_LAST=5018, - XED_IFORMFL_VPHADDDQ_FIRST=5019, - XED_IFORMFL_VPHADDDQ_LAST=5020, - XED_IFORMFL_VPHADDSW_FIRST=5021, - XED_IFORMFL_VPHADDSW_LAST=5024, - XED_IFORMFL_VPHADDUBD_FIRST=5025, - XED_IFORMFL_VPHADDUBD_LAST=5026, - XED_IFORMFL_VPHADDUBQ_FIRST=5027, - XED_IFORMFL_VPHADDUBQ_LAST=5028, - XED_IFORMFL_VPHADDUBW_FIRST=5029, - XED_IFORMFL_VPHADDUBW_LAST=5030, - XED_IFORMFL_VPHADDUDQ_FIRST=5031, - XED_IFORMFL_VPHADDUDQ_LAST=5032, - XED_IFORMFL_VPHADDUWD_FIRST=5033, - XED_IFORMFL_VPHADDUWD_LAST=5034, - XED_IFORMFL_VPHADDUWQ_FIRST=5035, - XED_IFORMFL_VPHADDUWQ_LAST=5036, - XED_IFORMFL_VPHADDW_FIRST=5037, - XED_IFORMFL_VPHADDW_LAST=5040, - XED_IFORMFL_VPHADDWD_FIRST=5041, - XED_IFORMFL_VPHADDWD_LAST=5042, - XED_IFORMFL_VPHADDWQ_FIRST=5043, - XED_IFORMFL_VPHADDWQ_LAST=5044, - XED_IFORMFL_VPHMINPOSUW_FIRST=5045, - XED_IFORMFL_VPHMINPOSUW_LAST=5046, - XED_IFORMFL_VPHSUBBW_FIRST=5047, - XED_IFORMFL_VPHSUBBW_LAST=5048, - XED_IFORMFL_VPHSUBD_FIRST=5049, - XED_IFORMFL_VPHSUBD_LAST=5052, - XED_IFORMFL_VPHSUBDQ_FIRST=5053, - XED_IFORMFL_VPHSUBDQ_LAST=5054, - XED_IFORMFL_VPHSUBSW_FIRST=5055, - XED_IFORMFL_VPHSUBSW_LAST=5058, - XED_IFORMFL_VPHSUBW_FIRST=5059, - XED_IFORMFL_VPHSUBW_LAST=5062, - XED_IFORMFL_VPHSUBWD_FIRST=5063, - XED_IFORMFL_VPHSUBWD_LAST=5064, - XED_IFORMFL_VPINSRB_FIRST=5065, - XED_IFORMFL_VPINSRB_LAST=5068, - XED_IFORMFL_VPINSRD_FIRST=5069, - XED_IFORMFL_VPINSRD_LAST=5072, - XED_IFORMFL_VPINSRQ_FIRST=5073, - XED_IFORMFL_VPINSRQ_LAST=5076, - XED_IFORMFL_VPINSRW_FIRST=5077, - XED_IFORMFL_VPINSRW_LAST=5080, - XED_IFORMFL_VPLZCNTD_FIRST=5081, - XED_IFORMFL_VPLZCNTD_LAST=5086, - XED_IFORMFL_VPLZCNTQ_FIRST=5087, - XED_IFORMFL_VPLZCNTQ_LAST=5092, - XED_IFORMFL_VPMACSDD_FIRST=5093, - XED_IFORMFL_VPMACSDD_LAST=5094, - XED_IFORMFL_VPMACSDQH_FIRST=5095, - XED_IFORMFL_VPMACSDQH_LAST=5096, - XED_IFORMFL_VPMACSDQL_FIRST=5097, - XED_IFORMFL_VPMACSDQL_LAST=5098, - XED_IFORMFL_VPMACSSDD_FIRST=5099, - XED_IFORMFL_VPMACSSDD_LAST=5100, - XED_IFORMFL_VPMACSSDQH_FIRST=5101, - XED_IFORMFL_VPMACSSDQH_LAST=5102, - XED_IFORMFL_VPMACSSDQL_FIRST=5103, - XED_IFORMFL_VPMACSSDQL_LAST=5104, - XED_IFORMFL_VPMACSSWD_FIRST=5105, - XED_IFORMFL_VPMACSSWD_LAST=5106, - XED_IFORMFL_VPMACSSWW_FIRST=5107, - XED_IFORMFL_VPMACSSWW_LAST=5108, - XED_IFORMFL_VPMACSWD_FIRST=5109, - XED_IFORMFL_VPMACSWD_LAST=5110, - XED_IFORMFL_VPMACSWW_FIRST=5111, - XED_IFORMFL_VPMACSWW_LAST=5112, - XED_IFORMFL_VPMADCSSWD_FIRST=5113, - XED_IFORMFL_VPMADCSSWD_LAST=5114, - XED_IFORMFL_VPMADCSWD_FIRST=5115, - XED_IFORMFL_VPMADCSWD_LAST=5116, - XED_IFORMFL_VPMADD52HUQ_FIRST=5117, - XED_IFORMFL_VPMADD52HUQ_LAST=5122, - XED_IFORMFL_VPMADD52LUQ_FIRST=5123, - XED_IFORMFL_VPMADD52LUQ_LAST=5128, - XED_IFORMFL_VPMADDUBSW_FIRST=5129, - XED_IFORMFL_VPMADDUBSW_LAST=5138, - XED_IFORMFL_VPMADDWD_FIRST=5139, - XED_IFORMFL_VPMADDWD_LAST=5148, - XED_IFORMFL_VPMASKMOVD_FIRST=5149, - XED_IFORMFL_VPMASKMOVD_LAST=5152, - XED_IFORMFL_VPMASKMOVQ_FIRST=5153, - XED_IFORMFL_VPMASKMOVQ_LAST=5156, - XED_IFORMFL_VPMAXSB_FIRST=5157, - XED_IFORMFL_VPMAXSB_LAST=5166, - XED_IFORMFL_VPMAXSD_FIRST=5167, - XED_IFORMFL_VPMAXSD_LAST=5176, - XED_IFORMFL_VPMAXSQ_FIRST=5177, - XED_IFORMFL_VPMAXSQ_LAST=5182, - XED_IFORMFL_VPMAXSW_FIRST=5183, - XED_IFORMFL_VPMAXSW_LAST=5192, - XED_IFORMFL_VPMAXUB_FIRST=5193, - XED_IFORMFL_VPMAXUB_LAST=5202, - XED_IFORMFL_VPMAXUD_FIRST=5203, - XED_IFORMFL_VPMAXUD_LAST=5212, - XED_IFORMFL_VPMAXUQ_FIRST=5213, - XED_IFORMFL_VPMAXUQ_LAST=5218, - XED_IFORMFL_VPMAXUW_FIRST=5219, - XED_IFORMFL_VPMAXUW_LAST=5228, - XED_IFORMFL_VPMINSB_FIRST=5229, - XED_IFORMFL_VPMINSB_LAST=5238, - XED_IFORMFL_VPMINSD_FIRST=5239, - XED_IFORMFL_VPMINSD_LAST=5248, - XED_IFORMFL_VPMINSQ_FIRST=5249, - XED_IFORMFL_VPMINSQ_LAST=5254, - XED_IFORMFL_VPMINSW_FIRST=5255, - XED_IFORMFL_VPMINSW_LAST=5264, - XED_IFORMFL_VPMINUB_FIRST=5265, - XED_IFORMFL_VPMINUB_LAST=5274, - XED_IFORMFL_VPMINUD_FIRST=5275, - XED_IFORMFL_VPMINUD_LAST=5284, - XED_IFORMFL_VPMINUQ_FIRST=5285, - XED_IFORMFL_VPMINUQ_LAST=5290, - XED_IFORMFL_VPMINUW_FIRST=5291, - XED_IFORMFL_VPMINUW_LAST=5300, - XED_IFORMFL_VPMOVB2M_FIRST=5301, - XED_IFORMFL_VPMOVB2M_LAST=5303, - XED_IFORMFL_VPMOVD2M_FIRST=5304, - XED_IFORMFL_VPMOVD2M_LAST=5306, - XED_IFORMFL_VPMOVDB_FIRST=5307, - XED_IFORMFL_VPMOVDB_LAST=5312, - XED_IFORMFL_VPMOVDW_FIRST=5313, - XED_IFORMFL_VPMOVDW_LAST=5318, - XED_IFORMFL_VPMOVM2B_FIRST=5319, - XED_IFORMFL_VPMOVM2B_LAST=5321, - XED_IFORMFL_VPMOVM2D_FIRST=5322, - XED_IFORMFL_VPMOVM2D_LAST=5324, - XED_IFORMFL_VPMOVM2Q_FIRST=5325, - XED_IFORMFL_VPMOVM2Q_LAST=5327, - XED_IFORMFL_VPMOVM2W_FIRST=5328, - XED_IFORMFL_VPMOVM2W_LAST=5330, - XED_IFORMFL_VPMOVMSKB_FIRST=5331, - XED_IFORMFL_VPMOVMSKB_LAST=5332, - XED_IFORMFL_VPMOVQ2M_FIRST=5333, - XED_IFORMFL_VPMOVQ2M_LAST=5335, - XED_IFORMFL_VPMOVQB_FIRST=5336, - XED_IFORMFL_VPMOVQB_LAST=5341, - XED_IFORMFL_VPMOVQD_FIRST=5342, - XED_IFORMFL_VPMOVQD_LAST=5347, - XED_IFORMFL_VPMOVQW_FIRST=5348, - XED_IFORMFL_VPMOVQW_LAST=5353, - XED_IFORMFL_VPMOVSDB_FIRST=5354, - XED_IFORMFL_VPMOVSDB_LAST=5359, - XED_IFORMFL_VPMOVSDW_FIRST=5360, - XED_IFORMFL_VPMOVSDW_LAST=5365, - XED_IFORMFL_VPMOVSQB_FIRST=5366, - XED_IFORMFL_VPMOVSQB_LAST=5371, - XED_IFORMFL_VPMOVSQD_FIRST=5372, - XED_IFORMFL_VPMOVSQD_LAST=5377, - XED_IFORMFL_VPMOVSQW_FIRST=5378, - XED_IFORMFL_VPMOVSQW_LAST=5383, - XED_IFORMFL_VPMOVSWB_FIRST=5384, - XED_IFORMFL_VPMOVSWB_LAST=5389, - XED_IFORMFL_VPMOVSXBD_FIRST=5390, - XED_IFORMFL_VPMOVSXBD_LAST=5399, - XED_IFORMFL_VPMOVSXBQ_FIRST=5400, - XED_IFORMFL_VPMOVSXBQ_LAST=5409, - XED_IFORMFL_VPMOVSXBW_FIRST=5410, - XED_IFORMFL_VPMOVSXBW_LAST=5419, - XED_IFORMFL_VPMOVSXDQ_FIRST=5420, - XED_IFORMFL_VPMOVSXDQ_LAST=5429, - XED_IFORMFL_VPMOVSXWD_FIRST=5430, - XED_IFORMFL_VPMOVSXWD_LAST=5439, - XED_IFORMFL_VPMOVSXWQ_FIRST=5440, - XED_IFORMFL_VPMOVSXWQ_LAST=5449, - XED_IFORMFL_VPMOVUSDB_FIRST=5450, - XED_IFORMFL_VPMOVUSDB_LAST=5455, - XED_IFORMFL_VPMOVUSDW_FIRST=5456, - XED_IFORMFL_VPMOVUSDW_LAST=5461, - XED_IFORMFL_VPMOVUSQB_FIRST=5462, - XED_IFORMFL_VPMOVUSQB_LAST=5467, - XED_IFORMFL_VPMOVUSQD_FIRST=5468, - XED_IFORMFL_VPMOVUSQD_LAST=5473, - XED_IFORMFL_VPMOVUSQW_FIRST=5474, - XED_IFORMFL_VPMOVUSQW_LAST=5479, - XED_IFORMFL_VPMOVUSWB_FIRST=5480, - XED_IFORMFL_VPMOVUSWB_LAST=5485, - XED_IFORMFL_VPMOVW2M_FIRST=5486, - XED_IFORMFL_VPMOVW2M_LAST=5488, - XED_IFORMFL_VPMOVWB_FIRST=5489, - XED_IFORMFL_VPMOVWB_LAST=5494, - XED_IFORMFL_VPMOVZXBD_FIRST=5495, - XED_IFORMFL_VPMOVZXBD_LAST=5504, - XED_IFORMFL_VPMOVZXBQ_FIRST=5505, - XED_IFORMFL_VPMOVZXBQ_LAST=5514, - XED_IFORMFL_VPMOVZXBW_FIRST=5515, - XED_IFORMFL_VPMOVZXBW_LAST=5524, - XED_IFORMFL_VPMOVZXDQ_FIRST=5525, - XED_IFORMFL_VPMOVZXDQ_LAST=5534, - XED_IFORMFL_VPMOVZXWD_FIRST=5535, - XED_IFORMFL_VPMOVZXWD_LAST=5544, - XED_IFORMFL_VPMOVZXWQ_FIRST=5545, - XED_IFORMFL_VPMOVZXWQ_LAST=5554, - XED_IFORMFL_VPMULDQ_FIRST=5555, - XED_IFORMFL_VPMULDQ_LAST=5564, - XED_IFORMFL_VPMULHRSW_FIRST=5565, - XED_IFORMFL_VPMULHRSW_LAST=5574, - XED_IFORMFL_VPMULHUW_FIRST=5575, - XED_IFORMFL_VPMULHUW_LAST=5584, - XED_IFORMFL_VPMULHW_FIRST=5585, - XED_IFORMFL_VPMULHW_LAST=5594, - XED_IFORMFL_VPMULLD_FIRST=5595, - XED_IFORMFL_VPMULLD_LAST=5604, - XED_IFORMFL_VPMULLQ_FIRST=5605, - XED_IFORMFL_VPMULLQ_LAST=5610, - XED_IFORMFL_VPMULLW_FIRST=5611, - XED_IFORMFL_VPMULLW_LAST=5620, - XED_IFORMFL_VPMULTISHIFTQB_FIRST=5621, - XED_IFORMFL_VPMULTISHIFTQB_LAST=5626, - XED_IFORMFL_VPMULUDQ_FIRST=5627, - XED_IFORMFL_VPMULUDQ_LAST=5636, - XED_IFORMFL_VPOPCNTB_FIRST=5637, - XED_IFORMFL_VPOPCNTB_LAST=5642, - XED_IFORMFL_VPOPCNTD_FIRST=5643, - XED_IFORMFL_VPOPCNTD_LAST=5648, - XED_IFORMFL_VPOPCNTQ_FIRST=5649, - XED_IFORMFL_VPOPCNTQ_LAST=5654, - XED_IFORMFL_VPOPCNTW_FIRST=5655, - XED_IFORMFL_VPOPCNTW_LAST=5660, - XED_IFORMFL_VPOR_FIRST=5661, - XED_IFORMFL_VPOR_LAST=5664, - XED_IFORMFL_VPORD_FIRST=5665, - XED_IFORMFL_VPORD_LAST=5670, - XED_IFORMFL_VPORQ_FIRST=5671, - XED_IFORMFL_VPORQ_LAST=5676, - XED_IFORMFL_VPPERM_FIRST=5677, - XED_IFORMFL_VPPERM_LAST=5679, - XED_IFORMFL_VPROLD_FIRST=5680, - XED_IFORMFL_VPROLD_LAST=5685, - XED_IFORMFL_VPROLQ_FIRST=5686, - XED_IFORMFL_VPROLQ_LAST=5691, - XED_IFORMFL_VPROLVD_FIRST=5692, - XED_IFORMFL_VPROLVD_LAST=5697, - XED_IFORMFL_VPROLVQ_FIRST=5698, - XED_IFORMFL_VPROLVQ_LAST=5703, - XED_IFORMFL_VPRORD_FIRST=5704, - XED_IFORMFL_VPRORD_LAST=5709, - XED_IFORMFL_VPRORQ_FIRST=5710, - XED_IFORMFL_VPRORQ_LAST=5715, - XED_IFORMFL_VPRORVD_FIRST=5716, - XED_IFORMFL_VPRORVD_LAST=5721, - XED_IFORMFL_VPRORVQ_FIRST=5722, - XED_IFORMFL_VPRORVQ_LAST=5727, - XED_IFORMFL_VPROTB_FIRST=5728, - XED_IFORMFL_VPROTB_LAST=5732, - XED_IFORMFL_VPROTD_FIRST=5733, - XED_IFORMFL_VPROTD_LAST=5737, - XED_IFORMFL_VPROTQ_FIRST=5738, - XED_IFORMFL_VPROTQ_LAST=5742, - XED_IFORMFL_VPROTW_FIRST=5743, - XED_IFORMFL_VPROTW_LAST=5747, - XED_IFORMFL_VPSADBW_FIRST=5748, - XED_IFORMFL_VPSADBW_LAST=5757, - XED_IFORMFL_VPSCATTERDD_FIRST=5758, - XED_IFORMFL_VPSCATTERDD_LAST=5760, - XED_IFORMFL_VPSCATTERDQ_FIRST=5761, - XED_IFORMFL_VPSCATTERDQ_LAST=5763, - XED_IFORMFL_VPSCATTERQD_FIRST=5764, - XED_IFORMFL_VPSCATTERQD_LAST=5766, - XED_IFORMFL_VPSCATTERQQ_FIRST=5767, - XED_IFORMFL_VPSCATTERQQ_LAST=5769, - XED_IFORMFL_VPSHAB_FIRST=5770, - XED_IFORMFL_VPSHAB_LAST=5772, - XED_IFORMFL_VPSHAD_FIRST=5773, - XED_IFORMFL_VPSHAD_LAST=5775, - XED_IFORMFL_VPSHAQ_FIRST=5776, - XED_IFORMFL_VPSHAQ_LAST=5778, - XED_IFORMFL_VPSHAW_FIRST=5779, - XED_IFORMFL_VPSHAW_LAST=5781, - XED_IFORMFL_VPSHLB_FIRST=5782, - XED_IFORMFL_VPSHLB_LAST=5784, - XED_IFORMFL_VPSHLD_FIRST=5785, - XED_IFORMFL_VPSHLD_LAST=5787, - XED_IFORMFL_VPSHLDD_FIRST=5788, - XED_IFORMFL_VPSHLDD_LAST=5793, - XED_IFORMFL_VPSHLDQ_FIRST=5794, - XED_IFORMFL_VPSHLDQ_LAST=5799, - XED_IFORMFL_VPSHLDVD_FIRST=5800, - XED_IFORMFL_VPSHLDVD_LAST=5805, - XED_IFORMFL_VPSHLDVQ_FIRST=5806, - XED_IFORMFL_VPSHLDVQ_LAST=5811, - XED_IFORMFL_VPSHLDVW_FIRST=5812, - XED_IFORMFL_VPSHLDVW_LAST=5817, - XED_IFORMFL_VPSHLDW_FIRST=5818, - XED_IFORMFL_VPSHLDW_LAST=5823, - XED_IFORMFL_VPSHLQ_FIRST=5824, - XED_IFORMFL_VPSHLQ_LAST=5826, - XED_IFORMFL_VPSHLW_FIRST=5827, - XED_IFORMFL_VPSHLW_LAST=5829, - XED_IFORMFL_VPSHRDD_FIRST=5830, - XED_IFORMFL_VPSHRDD_LAST=5835, - XED_IFORMFL_VPSHRDQ_FIRST=5836, - XED_IFORMFL_VPSHRDQ_LAST=5841, - XED_IFORMFL_VPSHRDVD_FIRST=5842, - XED_IFORMFL_VPSHRDVD_LAST=5847, - XED_IFORMFL_VPSHRDVQ_FIRST=5848, - XED_IFORMFL_VPSHRDVQ_LAST=5853, - XED_IFORMFL_VPSHRDVW_FIRST=5854, - XED_IFORMFL_VPSHRDVW_LAST=5859, - XED_IFORMFL_VPSHRDW_FIRST=5860, - XED_IFORMFL_VPSHRDW_LAST=5865, - XED_IFORMFL_VPSHUFB_FIRST=5866, - XED_IFORMFL_VPSHUFB_LAST=5875, - XED_IFORMFL_VPSHUFBITQMB_FIRST=5876, - XED_IFORMFL_VPSHUFBITQMB_LAST=5881, - XED_IFORMFL_VPSHUFD_FIRST=5882, - XED_IFORMFL_VPSHUFD_LAST=5891, - XED_IFORMFL_VPSHUFHW_FIRST=5892, - XED_IFORMFL_VPSHUFHW_LAST=5901, - XED_IFORMFL_VPSHUFLW_FIRST=5902, - XED_IFORMFL_VPSHUFLW_LAST=5911, - XED_IFORMFL_VPSIGNB_FIRST=5912, - XED_IFORMFL_VPSIGNB_LAST=5915, - XED_IFORMFL_VPSIGND_FIRST=5916, - XED_IFORMFL_VPSIGND_LAST=5919, - XED_IFORMFL_VPSIGNW_FIRST=5920, - XED_IFORMFL_VPSIGNW_LAST=5923, - XED_IFORMFL_VPSLLD_FIRST=5924, - XED_IFORMFL_VPSLLD_LAST=5941, - XED_IFORMFL_VPSLLDQ_FIRST=5942, - XED_IFORMFL_VPSLLDQ_LAST=5949, - XED_IFORMFL_VPSLLQ_FIRST=5950, - XED_IFORMFL_VPSLLQ_LAST=5967, - XED_IFORMFL_VPSLLVD_FIRST=5968, - XED_IFORMFL_VPSLLVD_LAST=5977, - XED_IFORMFL_VPSLLVQ_FIRST=5978, - XED_IFORMFL_VPSLLVQ_LAST=5987, - XED_IFORMFL_VPSLLVW_FIRST=5988, - XED_IFORMFL_VPSLLVW_LAST=5993, - XED_IFORMFL_VPSLLW_FIRST=5994, - XED_IFORMFL_VPSLLW_LAST=6011, - XED_IFORMFL_VPSRAD_FIRST=6012, - XED_IFORMFL_VPSRAD_LAST=6029, - XED_IFORMFL_VPSRAQ_FIRST=6030, - XED_IFORMFL_VPSRAQ_LAST=6041, - XED_IFORMFL_VPSRAVD_FIRST=6042, - XED_IFORMFL_VPSRAVD_LAST=6051, - XED_IFORMFL_VPSRAVQ_FIRST=6052, - XED_IFORMFL_VPSRAVQ_LAST=6057, - XED_IFORMFL_VPSRAVW_FIRST=6058, - XED_IFORMFL_VPSRAVW_LAST=6063, - XED_IFORMFL_VPSRAW_FIRST=6064, - XED_IFORMFL_VPSRAW_LAST=6081, - XED_IFORMFL_VPSRLD_FIRST=6082, - XED_IFORMFL_VPSRLD_LAST=6099, - XED_IFORMFL_VPSRLDQ_FIRST=6100, - XED_IFORMFL_VPSRLDQ_LAST=6107, - XED_IFORMFL_VPSRLQ_FIRST=6108, - XED_IFORMFL_VPSRLQ_LAST=6125, - XED_IFORMFL_VPSRLVD_FIRST=6126, - XED_IFORMFL_VPSRLVD_LAST=6135, - XED_IFORMFL_VPSRLVQ_FIRST=6136, - XED_IFORMFL_VPSRLVQ_LAST=6145, - XED_IFORMFL_VPSRLVW_FIRST=6146, - XED_IFORMFL_VPSRLVW_LAST=6151, - XED_IFORMFL_VPSRLW_FIRST=6152, - XED_IFORMFL_VPSRLW_LAST=6169, - XED_IFORMFL_VPSUBB_FIRST=6170, - XED_IFORMFL_VPSUBB_LAST=6179, - XED_IFORMFL_VPSUBD_FIRST=6180, - XED_IFORMFL_VPSUBD_LAST=6189, - XED_IFORMFL_VPSUBQ_FIRST=6190, - XED_IFORMFL_VPSUBQ_LAST=6199, - XED_IFORMFL_VPSUBSB_FIRST=6200, - XED_IFORMFL_VPSUBSB_LAST=6209, - XED_IFORMFL_VPSUBSW_FIRST=6210, - XED_IFORMFL_VPSUBSW_LAST=6219, - XED_IFORMFL_VPSUBUSB_FIRST=6220, - XED_IFORMFL_VPSUBUSB_LAST=6229, - XED_IFORMFL_VPSUBUSW_FIRST=6230, - XED_IFORMFL_VPSUBUSW_LAST=6239, - XED_IFORMFL_VPSUBW_FIRST=6240, - XED_IFORMFL_VPSUBW_LAST=6249, - XED_IFORMFL_VPTERNLOGD_FIRST=6250, - XED_IFORMFL_VPTERNLOGD_LAST=6255, - XED_IFORMFL_VPTERNLOGQ_FIRST=6256, - XED_IFORMFL_VPTERNLOGQ_LAST=6261, - XED_IFORMFL_VPTEST_FIRST=6262, - XED_IFORMFL_VPTEST_LAST=6265, - XED_IFORMFL_VPTESTMB_FIRST=6266, - XED_IFORMFL_VPTESTMB_LAST=6271, - XED_IFORMFL_VPTESTMD_FIRST=6272, - XED_IFORMFL_VPTESTMD_LAST=6277, - XED_IFORMFL_VPTESTMQ_FIRST=6278, - XED_IFORMFL_VPTESTMQ_LAST=6283, - XED_IFORMFL_VPTESTMW_FIRST=6284, - XED_IFORMFL_VPTESTMW_LAST=6289, - XED_IFORMFL_VPTESTNMB_FIRST=6290, - XED_IFORMFL_VPTESTNMB_LAST=6295, - XED_IFORMFL_VPTESTNMD_FIRST=6296, - XED_IFORMFL_VPTESTNMD_LAST=6301, - XED_IFORMFL_VPTESTNMQ_FIRST=6302, - XED_IFORMFL_VPTESTNMQ_LAST=6307, - XED_IFORMFL_VPTESTNMW_FIRST=6308, - XED_IFORMFL_VPTESTNMW_LAST=6313, - XED_IFORMFL_VPUNPCKHBW_FIRST=6314, - XED_IFORMFL_VPUNPCKHBW_LAST=6323, - XED_IFORMFL_VPUNPCKHDQ_FIRST=6324, - XED_IFORMFL_VPUNPCKHDQ_LAST=6333, - XED_IFORMFL_VPUNPCKHQDQ_FIRST=6334, - XED_IFORMFL_VPUNPCKHQDQ_LAST=6343, - XED_IFORMFL_VPUNPCKHWD_FIRST=6344, - XED_IFORMFL_VPUNPCKHWD_LAST=6353, - XED_IFORMFL_VPUNPCKLBW_FIRST=6354, - XED_IFORMFL_VPUNPCKLBW_LAST=6363, - XED_IFORMFL_VPUNPCKLDQ_FIRST=6364, - XED_IFORMFL_VPUNPCKLDQ_LAST=6373, - XED_IFORMFL_VPUNPCKLQDQ_FIRST=6374, - XED_IFORMFL_VPUNPCKLQDQ_LAST=6383, - XED_IFORMFL_VPUNPCKLWD_FIRST=6384, - XED_IFORMFL_VPUNPCKLWD_LAST=6393, - XED_IFORMFL_VPXOR_FIRST=6394, - XED_IFORMFL_VPXOR_LAST=6397, - XED_IFORMFL_VPXORD_FIRST=6398, - XED_IFORMFL_VPXORD_LAST=6403, - XED_IFORMFL_VPXORQ_FIRST=6404, - XED_IFORMFL_VPXORQ_LAST=6409, - XED_IFORMFL_VRANGEPD_FIRST=6410, - XED_IFORMFL_VRANGEPD_LAST=6415, - XED_IFORMFL_VRANGEPS_FIRST=6416, - XED_IFORMFL_VRANGEPS_LAST=6421, - XED_IFORMFL_VRANGESD_FIRST=6422, - XED_IFORMFL_VRANGESD_LAST=6423, - XED_IFORMFL_VRANGESS_FIRST=6424, - XED_IFORMFL_VRANGESS_LAST=6425, - XED_IFORMFL_VRCP14PD_FIRST=6426, - XED_IFORMFL_VRCP14PD_LAST=6431, - XED_IFORMFL_VRCP14PS_FIRST=6432, - XED_IFORMFL_VRCP14PS_LAST=6437, - XED_IFORMFL_VRCP14SD_FIRST=6438, - XED_IFORMFL_VRCP14SD_LAST=6439, - XED_IFORMFL_VRCP14SS_FIRST=6440, - XED_IFORMFL_VRCP14SS_LAST=6441, - XED_IFORMFL_VRCP28PD_FIRST=6442, - XED_IFORMFL_VRCP28PD_LAST=6443, - XED_IFORMFL_VRCP28PS_FIRST=6444, - XED_IFORMFL_VRCP28PS_LAST=6445, - XED_IFORMFL_VRCP28SD_FIRST=6446, - XED_IFORMFL_VRCP28SD_LAST=6447, - XED_IFORMFL_VRCP28SS_FIRST=6448, - XED_IFORMFL_VRCP28SS_LAST=6449, - XED_IFORMFL_VRCPPH_FIRST=6450, - XED_IFORMFL_VRCPPH_LAST=6455, - XED_IFORMFL_VRCPPS_FIRST=6456, - XED_IFORMFL_VRCPPS_LAST=6459, - XED_IFORMFL_VRCPSH_FIRST=6460, - XED_IFORMFL_VRCPSH_LAST=6461, - XED_IFORMFL_VRCPSS_FIRST=6462, - XED_IFORMFL_VRCPSS_LAST=6463, - XED_IFORMFL_VREDUCEPD_FIRST=6464, - XED_IFORMFL_VREDUCEPD_LAST=6469, - XED_IFORMFL_VREDUCEPH_FIRST=6470, - XED_IFORMFL_VREDUCEPH_LAST=6475, - XED_IFORMFL_VREDUCEPS_FIRST=6476, - XED_IFORMFL_VREDUCEPS_LAST=6481, - XED_IFORMFL_VREDUCESD_FIRST=6482, - XED_IFORMFL_VREDUCESD_LAST=6483, - XED_IFORMFL_VREDUCESH_FIRST=6484, - XED_IFORMFL_VREDUCESH_LAST=6485, - XED_IFORMFL_VREDUCESS_FIRST=6486, - XED_IFORMFL_VREDUCESS_LAST=6487, - XED_IFORMFL_VRNDSCALEPD_FIRST=6488, - XED_IFORMFL_VRNDSCALEPD_LAST=6493, - XED_IFORMFL_VRNDSCALEPH_FIRST=6494, - XED_IFORMFL_VRNDSCALEPH_LAST=6499, - XED_IFORMFL_VRNDSCALEPS_FIRST=6500, - XED_IFORMFL_VRNDSCALEPS_LAST=6505, - XED_IFORMFL_VRNDSCALESD_FIRST=6506, - XED_IFORMFL_VRNDSCALESD_LAST=6507, - XED_IFORMFL_VRNDSCALESH_FIRST=6508, - XED_IFORMFL_VRNDSCALESH_LAST=6509, - XED_IFORMFL_VRNDSCALESS_FIRST=6510, - XED_IFORMFL_VRNDSCALESS_LAST=6511, - XED_IFORMFL_VROUNDPD_FIRST=6512, - XED_IFORMFL_VROUNDPD_LAST=6515, - XED_IFORMFL_VROUNDPS_FIRST=6516, - XED_IFORMFL_VROUNDPS_LAST=6519, - XED_IFORMFL_VROUNDSD_FIRST=6520, - XED_IFORMFL_VROUNDSD_LAST=6521, - XED_IFORMFL_VROUNDSS_FIRST=6522, - XED_IFORMFL_VROUNDSS_LAST=6523, - XED_IFORMFL_VRSQRT14PD_FIRST=6524, - XED_IFORMFL_VRSQRT14PD_LAST=6529, - XED_IFORMFL_VRSQRT14PS_FIRST=6530, - XED_IFORMFL_VRSQRT14PS_LAST=6535, - XED_IFORMFL_VRSQRT14SD_FIRST=6536, - XED_IFORMFL_VRSQRT14SD_LAST=6537, - XED_IFORMFL_VRSQRT14SS_FIRST=6538, - XED_IFORMFL_VRSQRT14SS_LAST=6539, - XED_IFORMFL_VRSQRT28PD_FIRST=6540, - XED_IFORMFL_VRSQRT28PD_LAST=6541, - XED_IFORMFL_VRSQRT28PS_FIRST=6542, - XED_IFORMFL_VRSQRT28PS_LAST=6543, - XED_IFORMFL_VRSQRT28SD_FIRST=6544, - XED_IFORMFL_VRSQRT28SD_LAST=6545, - XED_IFORMFL_VRSQRT28SS_FIRST=6546, - XED_IFORMFL_VRSQRT28SS_LAST=6547, - XED_IFORMFL_VRSQRTPH_FIRST=6548, - XED_IFORMFL_VRSQRTPH_LAST=6553, - XED_IFORMFL_VRSQRTPS_FIRST=6554, - XED_IFORMFL_VRSQRTPS_LAST=6557, - XED_IFORMFL_VRSQRTSH_FIRST=6558, - XED_IFORMFL_VRSQRTSH_LAST=6559, - XED_IFORMFL_VRSQRTSS_FIRST=6560, - XED_IFORMFL_VRSQRTSS_LAST=6561, - XED_IFORMFL_VSCALEFPD_FIRST=6562, - XED_IFORMFL_VSCALEFPD_LAST=6567, - XED_IFORMFL_VSCALEFPH_FIRST=6568, - XED_IFORMFL_VSCALEFPH_LAST=6573, - XED_IFORMFL_VSCALEFPS_FIRST=6574, - XED_IFORMFL_VSCALEFPS_LAST=6579, - XED_IFORMFL_VSCALEFSD_FIRST=6580, - XED_IFORMFL_VSCALEFSD_LAST=6581, - XED_IFORMFL_VSCALEFSH_FIRST=6582, - XED_IFORMFL_VSCALEFSH_LAST=6583, - XED_IFORMFL_VSCALEFSS_FIRST=6584, - XED_IFORMFL_VSCALEFSS_LAST=6585, - XED_IFORMFL_VSCATTERDPD_FIRST=6586, - XED_IFORMFL_VSCATTERDPD_LAST=6588, - XED_IFORMFL_VSCATTERDPS_FIRST=6589, - XED_IFORMFL_VSCATTERDPS_LAST=6591, - XED_IFORMFL_VSCATTERPF0DPD_FIRST=6592, - XED_IFORMFL_VSCATTERPF0DPD_LAST=6592, - XED_IFORMFL_VSCATTERPF0DPS_FIRST=6593, - XED_IFORMFL_VSCATTERPF0DPS_LAST=6593, - XED_IFORMFL_VSCATTERPF0QPD_FIRST=6594, - XED_IFORMFL_VSCATTERPF0QPD_LAST=6594, - XED_IFORMFL_VSCATTERPF0QPS_FIRST=6595, - XED_IFORMFL_VSCATTERPF0QPS_LAST=6595, - XED_IFORMFL_VSCATTERPF1DPD_FIRST=6596, - XED_IFORMFL_VSCATTERPF1DPD_LAST=6596, - XED_IFORMFL_VSCATTERPF1DPS_FIRST=6597, - XED_IFORMFL_VSCATTERPF1DPS_LAST=6597, - XED_IFORMFL_VSCATTERPF1QPD_FIRST=6598, - XED_IFORMFL_VSCATTERPF1QPD_LAST=6598, - XED_IFORMFL_VSCATTERPF1QPS_FIRST=6599, - XED_IFORMFL_VSCATTERPF1QPS_LAST=6599, - XED_IFORMFL_VSCATTERQPD_FIRST=6600, - XED_IFORMFL_VSCATTERQPD_LAST=6602, - XED_IFORMFL_VSCATTERQPS_FIRST=6603, - XED_IFORMFL_VSCATTERQPS_LAST=6605, - XED_IFORMFL_VSHUFF32X4_FIRST=6606, - XED_IFORMFL_VSHUFF32X4_LAST=6609, - XED_IFORMFL_VSHUFF64X2_FIRST=6610, - XED_IFORMFL_VSHUFF64X2_LAST=6613, - XED_IFORMFL_VSHUFI32X4_FIRST=6614, - XED_IFORMFL_VSHUFI32X4_LAST=6617, - XED_IFORMFL_VSHUFI64X2_FIRST=6618, - XED_IFORMFL_VSHUFI64X2_LAST=6621, - XED_IFORMFL_VSHUFPD_FIRST=6622, - XED_IFORMFL_VSHUFPD_LAST=6631, - XED_IFORMFL_VSHUFPS_FIRST=6632, - XED_IFORMFL_VSHUFPS_LAST=6641, - XED_IFORMFL_VSQRTPD_FIRST=6642, - XED_IFORMFL_VSQRTPD_LAST=6651, - XED_IFORMFL_VSQRTPH_FIRST=6652, - XED_IFORMFL_VSQRTPH_LAST=6657, - XED_IFORMFL_VSQRTPS_FIRST=6658, - XED_IFORMFL_VSQRTPS_LAST=6667, - XED_IFORMFL_VSQRTSD_FIRST=6668, - XED_IFORMFL_VSQRTSD_LAST=6671, - XED_IFORMFL_VSQRTSH_FIRST=6672, - XED_IFORMFL_VSQRTSH_LAST=6673, - XED_IFORMFL_VSQRTSS_FIRST=6674, - XED_IFORMFL_VSQRTSS_LAST=6677, - XED_IFORMFL_VSTMXCSR_FIRST=6678, - XED_IFORMFL_VSTMXCSR_LAST=6678, - XED_IFORMFL_VSUBPD_FIRST=6679, - XED_IFORMFL_VSUBPD_LAST=6688, - XED_IFORMFL_VSUBPH_FIRST=6689, - XED_IFORMFL_VSUBPH_LAST=6694, - XED_IFORMFL_VSUBPS_FIRST=6695, - XED_IFORMFL_VSUBPS_LAST=6704, - XED_IFORMFL_VSUBSD_FIRST=6705, - XED_IFORMFL_VSUBSD_LAST=6708, - XED_IFORMFL_VSUBSH_FIRST=6709, - XED_IFORMFL_VSUBSH_LAST=6710, - XED_IFORMFL_VSUBSS_FIRST=6711, - XED_IFORMFL_VSUBSS_LAST=6714, - XED_IFORMFL_VTESTPD_FIRST=6715, - XED_IFORMFL_VTESTPD_LAST=6718, - XED_IFORMFL_VTESTPS_FIRST=6719, - XED_IFORMFL_VTESTPS_LAST=6722, - XED_IFORMFL_VUCOMISD_FIRST=6723, - XED_IFORMFL_VUCOMISD_LAST=6726, - XED_IFORMFL_VUCOMISH_FIRST=6727, - XED_IFORMFL_VUCOMISH_LAST=6728, - XED_IFORMFL_VUCOMISS_FIRST=6729, - XED_IFORMFL_VUCOMISS_LAST=6732, - XED_IFORMFL_VUNPCKHPD_FIRST=6733, - XED_IFORMFL_VUNPCKHPD_LAST=6742, - XED_IFORMFL_VUNPCKHPS_FIRST=6743, - XED_IFORMFL_VUNPCKHPS_LAST=6752, - XED_IFORMFL_VUNPCKLPD_FIRST=6753, - XED_IFORMFL_VUNPCKLPD_LAST=6762, - XED_IFORMFL_VUNPCKLPS_FIRST=6763, - XED_IFORMFL_VUNPCKLPS_LAST=6772, - XED_IFORMFL_VXORPD_FIRST=6773, - XED_IFORMFL_VXORPD_LAST=6782, - XED_IFORMFL_VXORPS_FIRST=6783, - XED_IFORMFL_VXORPS_LAST=6792, - XED_IFORMFL_VZEROALL_FIRST=6793, - XED_IFORMFL_VZEROALL_LAST=6793, - XED_IFORMFL_VZEROUPPER_FIRST=6794, - XED_IFORMFL_VZEROUPPER_LAST=6794, - XED_IFORMFL_WBINVD_FIRST=6795, - XED_IFORMFL_WBINVD_LAST=6795, - XED_IFORMFL_WBNOINVD_FIRST=6796, - XED_IFORMFL_WBNOINVD_LAST=6796, - XED_IFORMFL_WRFSBASE_FIRST=6797, - XED_IFORMFL_WRFSBASE_LAST=6797, - XED_IFORMFL_WRGSBASE_FIRST=6798, - XED_IFORMFL_WRGSBASE_LAST=6798, - XED_IFORMFL_WRMSR_FIRST=6799, - XED_IFORMFL_WRMSR_LAST=6799, - XED_IFORMFL_WRPKRU_FIRST=6800, - XED_IFORMFL_WRPKRU_LAST=6800, - XED_IFORMFL_WRSSD_FIRST=6801, - XED_IFORMFL_WRSSD_LAST=6801, - XED_IFORMFL_WRSSQ_FIRST=6802, - XED_IFORMFL_WRSSQ_LAST=6802, - XED_IFORMFL_WRUSSD_FIRST=6803, - XED_IFORMFL_WRUSSD_LAST=6803, - XED_IFORMFL_WRUSSQ_FIRST=6804, - XED_IFORMFL_WRUSSQ_LAST=6804, - XED_IFORMFL_XABORT_FIRST=6805, - XED_IFORMFL_XABORT_LAST=6805, - XED_IFORMFL_XADD_FIRST=6806, - XED_IFORMFL_XADD_LAST=6809, - XED_IFORMFL_XADD_LOCK_FIRST=6810, - XED_IFORMFL_XADD_LOCK_LAST=6811, - XED_IFORMFL_XBEGIN_FIRST=6812, - XED_IFORMFL_XBEGIN_LAST=6812, - XED_IFORMFL_XCHG_FIRST=6813, - XED_IFORMFL_XCHG_LAST=6817, - XED_IFORMFL_XEND_FIRST=6818, - XED_IFORMFL_XEND_LAST=6818, - XED_IFORMFL_XGETBV_FIRST=6819, - XED_IFORMFL_XGETBV_LAST=6819, - XED_IFORMFL_XLAT_FIRST=6820, - XED_IFORMFL_XLAT_LAST=6820, - XED_IFORMFL_XOR_FIRST=6821, - XED_IFORMFL_XOR_LAST=6838, - XED_IFORMFL_XORPD_FIRST=6839, - XED_IFORMFL_XORPD_LAST=6840, - XED_IFORMFL_XORPS_FIRST=6841, - XED_IFORMFL_XORPS_LAST=6842, - XED_IFORMFL_XOR_LOCK_FIRST=6843, - XED_IFORMFL_XOR_LOCK_LAST=6848, - XED_IFORMFL_XRESLDTRK_FIRST=6849, - XED_IFORMFL_XRESLDTRK_LAST=6849, - XED_IFORMFL_XRSTOR_FIRST=6850, - XED_IFORMFL_XRSTOR_LAST=6850, - XED_IFORMFL_XRSTOR64_FIRST=6851, - XED_IFORMFL_XRSTOR64_LAST=6851, - XED_IFORMFL_XRSTORS_FIRST=6852, - XED_IFORMFL_XRSTORS_LAST=6852, - XED_IFORMFL_XRSTORS64_FIRST=6853, - XED_IFORMFL_XRSTORS64_LAST=6853, - XED_IFORMFL_XSAVE_FIRST=6854, - XED_IFORMFL_XSAVE_LAST=6854, - XED_IFORMFL_XSAVE64_FIRST=6855, - XED_IFORMFL_XSAVE64_LAST=6855, - XED_IFORMFL_XSAVEC_FIRST=6856, - XED_IFORMFL_XSAVEC_LAST=6856, - XED_IFORMFL_XSAVEC64_FIRST=6857, - XED_IFORMFL_XSAVEC64_LAST=6857, - XED_IFORMFL_XSAVEOPT_FIRST=6858, - XED_IFORMFL_XSAVEOPT_LAST=6858, - XED_IFORMFL_XSAVEOPT64_FIRST=6859, - XED_IFORMFL_XSAVEOPT64_LAST=6859, - XED_IFORMFL_XSAVES_FIRST=6860, - XED_IFORMFL_XSAVES_LAST=6860, - XED_IFORMFL_XSAVES64_FIRST=6861, - XED_IFORMFL_XSAVES64_LAST=6861, - XED_IFORMFL_XSETBV_FIRST=6862, - XED_IFORMFL_XSETBV_LAST=6862, - XED_IFORMFL_XSTORE_FIRST=6863, - XED_IFORMFL_XSTORE_LAST=6863, - XED_IFORMFL_XSUSLDTRK_FIRST=6864, - XED_IFORMFL_XSUSLDTRK_LAST=6864, - XED_IFORMFL_XTEST_FIRST=6865, - XED_IFORMFL_XTEST_LAST=6865, - XED_IFORMFL_LAST -} xed_iformfl_enum_t; - -/// Returns the last element of the enumeration -/// @return xed_iformfl_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_iformfl_enum_t xed_iformfl_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-ild-enum.h b/target/i386/latx/include/xed/xed-ild-enum.h deleted file mode 100644 index 334f408893e..00000000000 --- a/target/i386/latx/include/xed/xed-ild-enum.h +++ /dev/null @@ -1,80 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-ild-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_ILD_ENUM_H) -# define XED_ILD_ENUM_H -#include "xed-common-hdrs.h" -#define XED_ILD_AMD_3DNOW_DEFINED 1 -#define XED_ILD_AMD_XOP8_DEFINED 1 -#define XED_ILD_AMD_XOP9_DEFINED 1 -#define XED_ILD_AMD_XOPA_DEFINED 1 -#define XED_ILD_EVEX_MAP1_DEFINED 1 -#define XED_ILD_EVEX_MAP2_DEFINED 1 -#define XED_ILD_EVEX_MAP3_DEFINED 1 -#define XED_ILD_EVEX_MAP5_DEFINED 1 -#define XED_ILD_EVEX_MAP6_DEFINED 1 -#define XED_ILD_LEGACY_MAP0_DEFINED 1 -#define XED_ILD_LEGACY_MAP1_DEFINED 1 -#define XED_ILD_LEGACY_MAP2_DEFINED 1 -#define XED_ILD_LEGACY_MAP3_DEFINED 1 -#define XED_ILD_VEX_MAP1_DEFINED 1 -#define XED_ILD_VEX_MAP2_DEFINED 1 -#define XED_ILD_VEX_MAP3_DEFINED 1 -#define XED_ILD_MAP_INVALID_DEFINED 1 -#define XED_ILD_LAST_DEFINED 1 -typedef enum { - XED_ILD_AMD_3DNOW=4, - XED_ILD_AMD_XOP8=8, - XED_ILD_AMD_XOP9=9, - XED_ILD_AMD_XOPA=10, - XED_ILD_EVEX_MAP1=1, - XED_ILD_EVEX_MAP2=2, - XED_ILD_EVEX_MAP3=3, - XED_ILD_EVEX_MAP5=5, - XED_ILD_EVEX_MAP6=6, - XED_ILD_LEGACY_MAP0=0, - XED_ILD_LEGACY_MAP1=1, - XED_ILD_LEGACY_MAP2=2, - XED_ILD_LEGACY_MAP3=3, - XED_ILD_VEX_MAP1=1, - XED_ILD_VEX_MAP2=2, - XED_ILD_VEX_MAP3=3, - XED_ILD_MAP_INVALID, - XED_ILD_LAST -} xed_ild_map_enum_t; - -/// This converts strings to #xed_ild_map_enum_t types. -/// @param s A C-string. -/// @return #xed_ild_map_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_ild_map_enum_t str2xed_ild_map_enum_t(const char* s); -/// This converts strings to #xed_ild_map_enum_t types. -/// @param p An enumeration element of type xed_ild_map_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_ild_map_enum_t2str(const xed_ild_map_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_ild_map_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_ild_map_enum_t xed_ild_map_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-ild.h b/target/i386/latx/include/xed/xed-ild.h deleted file mode 100644 index 800c2853ca4..00000000000 --- a/target/i386/latx/include/xed/xed-ild.h +++ /dev/null @@ -1,61 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ - -/// @file xed-ild.h -/// instruction length decoder - -#if !defined(XED_ILD_H) -# define XED_ILD_H -#include "xed-common-hdrs.h" -#include "xed-common-defs.h" -#include "xed-portability.h" -#include "xed-types.h" -#include "xed-decoded-inst.h" - -#include "xed-operand-accessors.h" - - -/// This function just does instruction length decoding. -/// It does not return a fully decoded instruction. -/// @param xedd the decoded instruction of type #xed_decoded_inst_t . -/// Mode/state sent in via xedd; See the #xed_state_t . -/// @param itext the pointer to the array of instruction text bytes -/// @param bytes the length of the itext input array. -/// 1 to 15 bytes, anything more is ignored. -/// @return #xed_error_enum_t indicating success (#XED_ERROR_NONE) or -/// failure. -/// Only two failure codes are valid for this function: -/// #XED_ERROR_BUFFER_TOO_SHORT and #XED_ERROR_GENERAL_ERROR. -/// In general this function cannot tell if the instruction is valid or -/// not. For valid instructions, XED can figure out if enough bytes were -/// provided to decode the instruction. If not enough were provided, -/// XED returns #XED_ERROR_BUFFER_TOO_SHORT. -/// From this function, the #XED_ERROR_GENERAL_ERROR is an indication -/// that XED could not decode the instruction's length because the -/// instruction was so invalid that even its length -/// may across implmentations. -/// -/// @ingroup DEC -XED_DLL_EXPORT xed_error_enum_t -xed_ild_decode(xed_decoded_inst_t* xedd, - const xed_uint8_t* itext, - const unsigned int bytes); - - -#endif - diff --git a/target/i386/latx/include/xed/xed-immdis.h b/target/i386/latx/include/xed/xed-immdis.h deleted file mode 100644 index 32a2f48e4b4..00000000000 --- a/target/i386/latx/include/xed/xed-immdis.h +++ /dev/null @@ -1,199 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-immdis.h -/// - - - -#ifndef XED_IMMDIS_H -# define XED_IMMDIS_H - -#include "xed-types.h" -#include "xed-common-defs.h" -#include "xed-util.h" - - -//////////////////////////////////////////////////////////////////////////// -// DEFINES -//////////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////////// -// TYPES -//////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////// -// PROTOTYPES -//////////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////////// -// GLOBALS -//////////////////////////////////////////////////////////////////////////// - -#define XED_MAX_IMMDIS_BYTES 8 - -// A union for speed of zeroing -union xed_immdis_values_t -{ - xed_uint8_t x[XED_MAX_IMMDIS_BYTES];// STORED LITTLE ENDIAN. BYTE 0 is LSB - xed_uint64_t q; -}; - -/// Stores immediates and displacements for the encoder & decoder. -typedef struct xed_immdis_s { - union xed_immdis_values_t value; - unsigned int currently_used_space :4; // current number of assigned bytes - unsigned int max_allocated_space :4; // max allocation, 4 or 8 - xed_bool_t present : 1; - xed_bool_t immediate_is_unsigned : 1; -} xed_immdis_t; - - - - -XED_DLL_EXPORT void xed_immdis_init(xed_immdis_t* p, xed_uint_t max_bytes); - -/// @name Sizes and lengths -//@{ -/// return the number of bytes added -XED_DLL_EXPORT unsigned int xed_immdis_get_bytes(const xed_immdis_t* p) ; - -//@} - -/// @name Accessors for the value of the immediate or displacement -//@{ -XED_DLL_EXPORT xed_int64_t -xed_immdis_get_signed64(const xed_immdis_t* p); - -XED_DLL_EXPORT xed_uint64_t -xed_immdis_get_unsigned64(const xed_immdis_t* p); - -XED_DLL_EXPORT xed_bool_t -xed_immdis_is_zero(const xed_immdis_t* p) ; - -XED_DLL_EXPORT xed_bool_t -xed_immdis_is_one(const xed_immdis_t* p) ; - -/// Access the i'th byte of the immediate -XED_DLL_EXPORT xed_uint8_t xed_immdis_get_byte(const xed_immdis_t* p, unsigned int i) ; -//@} - -/// @name Presence / absence of an immediate or displacement -//@{ -XED_DLL_EXPORT void xed_immdis_set_present(xed_immdis_t* p) ; - -/// True if the object has had a value or individual bytes added to it. -XED_DLL_EXPORT xed_bool_t xed_immdis_is_present(const xed_immdis_t* p) ; -//@} - - -/// @name Initialization and setup -//@{ -XED_DLL_EXPORT void xed_immdis_set_max_len(xed_immdis_t* p, unsigned int mx) ; -XED_DLL_EXPORT void -xed_immdis_zero(xed_immdis_t* p); - -XED_DLL_EXPORT unsigned int xed_immdis_get_max_length(const xed_immdis_t* p) ; - -//@} - -/// @name Signed vs Unsigned -//@{ -/// Return true if signed. -XED_DLL_EXPORT xed_bool_t -xed_immdis_is_unsigned(const xed_immdis_t* p) ; -/// Return true if signed. -XED_DLL_EXPORT xed_bool_t -xed_immdis_is_signed(const xed_immdis_t* p) ; - -/// Set the immediate to be signed; For decoder use only. -XED_DLL_EXPORT void -xed_immdis_set_signed(xed_immdis_t* p) ; -/// Set the immediate to be unsigned; For decoder use only. -XED_DLL_EXPORT void -xed_immdis_set_unsigned( xed_immdis_t* p) ; -//@} - - -/// @name Adding / setting values -//@{ -XED_DLL_EXPORT void -xed_immdis_add_byte(xed_immdis_t* p, xed_uint8_t b); - - -XED_DLL_EXPORT void -xed_immdis_add_byte_array(xed_immdis_t* p, int nb, xed_uint8_t* ba); - -/// Add 1, 2, 4 or 8 bytes depending on the value x and the mask of -/// legal_widths. The default value of legal_widths = 0x5 only stops -/// adding bytes only on 1 or 4 byte quantities - depending on which -/// bytes of x are zero -- as is used for most memory addressing. You -/// can set legal_widths to 0x7 for branches (1, 2 or 4 byte branch -/// displacements). Or if you have an 8B displacement, you can set -/// legal_widths to 0x8. NOTE: add_shortest_width will add up to -/// XED_MAX_IMMDIS_BYTES if the x value requires it. NOTE: 16b memory -/// addressing can have 16b immediates. -XED_DLL_EXPORT void -xed_immdis_add_shortest_width_signed(xed_immdis_t* p, xed_int64_t x, xed_uint8_t legal_widths); - -/// See add_shortest_width_signed() -XED_DLL_EXPORT void -xed_immdis_add_shortest_width_unsigned(xed_immdis_t* p, xed_uint64_t x, xed_uint8_t legal_widths ); - - -/// add an 8 bit value to the byte array -XED_DLL_EXPORT void -xed_immdis_add8(xed_immdis_t* p, xed_int8_t d); - -/// add a 16 bit value to the byte array -XED_DLL_EXPORT void -xed_immdis_add16(xed_immdis_t* p, xed_int16_t d); - -/// add a 32 bit value to the byte array -XED_DLL_EXPORT void -xed_immdis_add32(xed_immdis_t* p, xed_int32_t d); - -/// add a 64 bit value to the byte array. -XED_DLL_EXPORT void -xed_immdis_add64(xed_immdis_t* p, xed_int64_t d); - -//@} - - -/// @name printing / debugging -//@{ - -/// just print the raw bytes in hex with a leading 0x -XED_DLL_EXPORT int xed_immdis_print(const xed_immdis_t* p, char* buf, int buflen); - -/// Print the value as a signed or unsigned number depending on the -/// value of the immediate_is_unsigned variable. -XED_DLL_EXPORT int -xed_immdis_print_signed_or_unsigned(const xed_immdis_t* p, char* buf, int buflen); - -/// print the signed value, appropriate width, with a leading 0x -XED_DLL_EXPORT int -xed_immdis_print_value_signed(const xed_immdis_t* p, char* buf, int buflen); - -/// print the unsigned value, appropriate width, with a leading 0x -XED_DLL_EXPORT int -xed_immdis_print_value_unsigned(const xed_immdis_t* p, char* buf, int buflen); - -#endif - -//@} - - diff --git a/target/i386/latx/include/xed/xed-immed.h b/target/i386/latx/include/xed/xed-immed.h deleted file mode 100644 index 22e6c65b9e6..00000000000 --- a/target/i386/latx/include/xed/xed-immed.h +++ /dev/null @@ -1,48 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-immed.h -/// - -#ifndef XED_IMMED_H -# define XED_IMMED_H - -#include "xed-types.h" -#include "xed-common-defs.h" -#include "xed-util.h" - -XED_DLL_EXPORT xed_int64_t xed_immed_from_bytes(xed_int8_t* bytes, xed_uint_t n); - /* - Convert an array of bytes representing a Little Endian byte ordering - of a number (11 22 33 44 55.. 88), in to a a 64b SIGNED number. That gets - stored in memory in little endian format of course. - - Input 11 22 33 44 55 66 77 88, 8 - Output 0x8877665544332211 (stored in memory as (lsb) 11 22 33 44 55 66 77 88 (msb)) - - Input f0, 1 - Output 0xffff_ffff_ffff_fff0 (stored in memory as f0 ff ff ff ff ff ff ff) - - Input f0 00, 2 - Output 0x0000_0000_0000_00F0 (stored in memory a f0 00 00 00 00 00 00 00) - - Input 03, 1 - Output 0x0000_0000_0000_0030 (stored in memory a 30 00 00 00 00 00 00 00) - */ - - -#endif diff --git a/target/i386/latx/include/xed/xed-init-pointer-names.h b/target/i386/latx/include/xed/xed-init-pointer-names.h deleted file mode 100644 index ceb07f70870..00000000000 --- a/target/i386/latx/include/xed/xed-init-pointer-names.h +++ /dev/null @@ -1,27 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-init-pointer-names.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_INIT_POINTER_NAMES_H) -# define XED_INIT_POINTER_NAMES_H -#include "xed-internal-header.h" -#define XED_MAX_POINTER_NAMES 65 -#endif diff --git a/target/i386/latx/include/xed/xed-init.h b/target/i386/latx/include/xed/xed-init.h deleted file mode 100644 index 9f5249d9069..00000000000 --- a/target/i386/latx/include/xed/xed-init.h +++ /dev/null @@ -1,35 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-init.h -/// - - - - -#if !defined(XED_INIT_H) -# define XED_INIT_H - - -/// @ingroup INIT -/// This is the call to initialize the XED encode and decode tables. It -/// must be called once before using XED. -void XED_DLL_EXPORT xed_tables_init(void); - -//////////////////////////////////////////////////////////////////////////// - -#endif diff --git a/target/i386/latx/include/xed/xed-inst.h b/target/i386/latx/include/xed/xed-inst.h deleted file mode 100644 index fea79db689a..00000000000 --- a/target/i386/latx/include/xed/xed-inst.h +++ /dev/null @@ -1,368 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-inst.h - - -#if !defined(XED_INST_H) -# define XED_INST_H - -#include "xed-util.h" -#include "xed-portability.h" -#include "xed-category-enum.h" // generated -#include "xed-extension-enum.h" //generated -#include "xed-iclass-enum.h" //generated -#include "xed-operand-enum.h" // generated -#include "xed-operand-visibility-enum.h" //generated -#include "xed-operand-action-enum.h" // generated -#include "xed-operand-convert-enum.h" // generated -#include "xed-operand-type-enum.h" // generated -#include "xed-nonterminal-enum.h" // a generated file -#include "xed-operand-width-enum.h" // a generated file -#include "xed-operand-element-xtype-enum.h" // a generated file -#include "xed-reg-enum.h" // a generated file -#include "xed-attribute-enum.h" // a generated file -#include "xed-exception-enum.h" // a generated file -#include "xed-iform-enum.h" // a generated file -#include "xed-iform-map.h" -#include "xed-attributes.h" - -struct xed_decoded_inst_s; //fwd-decl - -typedef void (*xed_operand_extractor_fn_t)(struct xed_decoded_inst_s* xds); - - -/// @ingroup DEC -/// Constant information about an individual generic operand, like an -///operand template, describing the operand properties. See @ref DEC for -///API information. -typedef struct xed_operand_s -{ - xed_uint8_t _name; // xed_operand_enum_t - - // implicit, explicit, suppressed - xed_uint8_t _operand_visibility; // xed_operand_visibility_enum_t - xed_uint8_t _rw; // read or written // xed_operand_action_enum_t - - // width code, could be invalid (then use register name) - xed_uint8_t _oc2; // xed_operand_width_enum_t - - // IMM, IMM_CONST, NT_LOOKUP_FN, REG, ERROR - xed_uint8_t _type; //xed_operand_type_enum_t - xed_uint8_t _xtype; // xed data type: u32, f32, etc. //xed_operand_element_xtype_enum_t - xed_uint8_t _cvt_idx; // decoration index - xed_uint8_t _nt; - union { - xed_uint32_t _imm; // value for some constant immmed - xed_nonterminal_enum_t _nt; // for nt_lookup_fn's - xed_reg_enum_t _reg; // register name - } _u; -} xed_operand_t; - -/// @name xed_inst_t Template Operands Access -//@{ -/// @ingroup DEC -static XED_INLINE xed_operand_enum_t -xed_operand_name(const xed_operand_t* p) { - return (xed_operand_enum_t)p->_name; -} - - -/// @ingroup DEC -static XED_INLINE xed_operand_visibility_enum_t -xed_operand_operand_visibility( const xed_operand_t* p) { - return (xed_operand_visibility_enum_t)(p->_operand_visibility); -} - - -/// @ingroup DEC -/// @return The #xed_operand_type_enum_t of the operand template. -/// This is probably not what you want. -static XED_INLINE xed_operand_type_enum_t -xed_operand_type(const xed_operand_t* p) { - return (xed_operand_type_enum_t)p->_type; -} - -/// @ingroup DEC -/// @return The #xed_operand_element_xtype_enum_t of the operand template. -/// This is probably not what you want. -static XED_INLINE xed_operand_element_xtype_enum_t -xed_operand_xtype(const xed_operand_t* p) { - return (xed_operand_element_xtype_enum_t)p->_xtype; -} - - -/// @ingroup DEC -static XED_INLINE xed_operand_width_enum_t -xed_operand_width(const xed_operand_t* p) { - return (xed_operand_width_enum_t)p->_oc2; -} - -/// @ingroup DEC -/// @param p an operand template, #xed_operand_t. -/// @param eosz effective operand size of the instruction, 1 | 2 | 3 for -/// 16 | 32 | 64 bits respectively. 0 is invalid. -/// @return the actual width of operand in bits. -/// See xed_decoded_inst_operand_length_bits() for a more general solution. -XED_DLL_EXPORT xed_uint32_t -xed_operand_width_bits(const xed_operand_t* p, - const xed_uint32_t eosz); - -/// @ingroup DEC -static XED_INLINE xed_nonterminal_enum_t -xed_operand_nonterminal_name(const xed_operand_t* p) { - if (p->_nt) - return p->_u._nt; - return XED_NONTERMINAL_INVALID; -} - -/// @ingroup DEC -/// Careful with this one -- use #xed_decoded_inst_get_reg()! This one is -/// probably not what you think it is. It is only used for hard-coded -/// registers implicit in the instruction encoding. Most likely you want to -/// get the #xed_operand_enum_t and then look up the instruction using -/// #xed_decoded_inst_get_reg(). The hard-coded registers are also available -/// that way. -/// @param p an operand template, #xed_operand_t. -/// @return the implicit or suppressed registers, type #xed_reg_enum_t -static XED_INLINE xed_reg_enum_t xed_operand_reg(const xed_operand_t* p) { - if (xed_operand_type(p) == XED_OPERAND_TYPE_REG) - return p->_u._reg; - return XED_REG_INVALID; -} - - - -/// @ingroup DEC -/// Careful with this one; See #xed_operand_is_register(). -/// @param p an operand template, #xed_operand_t. -/// @return 1 if the operand template represents are register-type -/// operand. -/// -/// Related functions: -/// Use #xed_decoded_inst_get_reg() to get the decoded name of /// the -/// register, #xed_reg_enum_t. Use #xed_operand_is_register() to test -/// #xed_operand_enum_t names. -static XED_INLINE xed_uint_t -xed_operand_template_is_register(const xed_operand_t* p) { - return p->_nt || p->_type == XED_OPERAND_TYPE_REG; -} - -/// @ingroup DEC -/// @param p an operand template, #xed_operand_t. -/// These operands represent branch displacements, memory displacements and -/// various immediates -static XED_INLINE xed_uint32_t xed_operand_imm(const xed_operand_t* p) { - if (xed_operand_type(p) == XED_OPERAND_TYPE_IMM_CONST) - return p->_u._imm; - return 0; -} - -/// @ingroup DEC -/// Print the operand p into the buffer buf, of length buflen. -/// @param p an operand template, #xed_operand_t. -/// @param buf buffer that gets filled in -/// @param buflen maximum buffer length -XED_DLL_EXPORT void -xed_operand_print(const xed_operand_t* p, char* buf, int buflen); -//@} - -/// @name xed_inst_t Template Operand Enum Name Classification -//@{ -/// @ingroup DEC -/// Tests the enum for inclusion in XED_OPERAND_REG0 through XED_OPERAND_REG9. -/// @param name the operand name, type #xed_operand_enum_t -/// @return 1 if the operand name is REG0...REG9, 0 otherwise. -/// -///Note there are other registers for memory addressing; See -/// #xed_operand_is_memory_addressing_register . -static XED_INLINE xed_uint_t xed_operand_is_register(xed_operand_enum_t name) { - return name >= XED_OPERAND_REG0 && name <= XED_OPERAND_REG9; -} -/// @ingroup DEC -/// Tests the enum for inclusion in XED_OPERAND_{BASE0,BASE1,INDEX,SEG0,SEG1} -/// @param name the operand name, type #xed_operand_enum_t -/// @return 1 if the operand name is for a memory addressing register operand, 0 -/// otherwise. See also #xed_operand_is_register . -static XED_INLINE xed_uint_t -xed_operand_is_memory_addressing_register(xed_operand_enum_t name) { - return ( name == XED_OPERAND_BASE0 || - name == XED_OPERAND_INDEX || - name == XED_OPERAND_SEG0 || - name == XED_OPERAND_BASE1 || - name == XED_OPERAND_SEG1 ); -} - -//@} - -/// @name xed_inst_t Template Operand Read/Written -//@{ -/// @ingroup DEC -/// DEPRECATED: Returns the raw R/W action. There are many cases for conditional reads -/// and writes. See #xed_decoded_inst_operand_action(). -static XED_INLINE xed_operand_action_enum_t -xed_operand_rw(const xed_operand_t* p) { - return (xed_operand_action_enum_t)p->_rw; -} - -/// @ingroup DEC -/// If the operand is read, including conditional reads -XED_DLL_EXPORT xed_uint_t xed_operand_read(const xed_operand_t* p); -/// @ingroup DEC -/// If the operand is read-only, including conditional reads -XED_DLL_EXPORT xed_uint_t xed_operand_read_only(const xed_operand_t* p); -/// @ingroup DEC -/// If the operand is written, including conditional writes -XED_DLL_EXPORT xed_uint_t xed_operand_written(const xed_operand_t* p); -/// @ingroup DEC -/// If the operand is written-only, including conditional writes -XED_DLL_EXPORT xed_uint_t xed_operand_written_only(const xed_operand_t* p); -/// @ingroup DEC -/// If the operand is read-and-written, conditional reads and conditional writes -XED_DLL_EXPORT xed_uint_t xed_operand_read_and_written(const xed_operand_t* p); -/// @ingroup DEC -/// If the operand has a conditional read (may also write) -XED_DLL_EXPORT xed_uint_t xed_operand_conditional_read(const xed_operand_t* p); -/// @ingroup DEC -/// If the operand has a conditional write (may also read) -XED_DLL_EXPORT xed_uint_t xed_operand_conditional_write(const xed_operand_t* p); -//@} - - -/// @ingroup DEC -/// constant information about a decoded instruction form, including -/// the pointer to the constant operand properties #xed_operand_t for this -/// instruction form. -typedef struct xed_inst_s { - - - // rflags info -- index in to the 2 tables of flags information. - // If _flag_complex is true, then the data are in the - // xed_flags_complex_table[]. Otherwise, the data are in the - // xed_flags_simple_table[]. - - //xed_instruction_fixed_bit_confirmer_fn_t _confirmer; - - // number of operands in the operands array - xed_uint8_t _noperands; - xed_uint8_t _cpl; // the nominal CPL for the instruction. - xed_uint8_t _flag_complex; /* 1/0 valued, bool type */ - xed_uint8_t _exceptions; //xed_exception_enum_t - - xed_uint16_t _flag_info_index; - - xed_uint16_t _iform_enum; //xed_iform_enum_t - // index into the xed_operand[] array of xed_operand_t structures - xed_uint16_t _operand_base; - // index to table of xed_attributes_t structures - xed_uint16_t _attributes; - -} xed_inst_t; - -/// @name xed_inst_t Template Instruction Information -//@{ -/// @ingroup DEC -/// xed_inst_cpl() is DEPRECATED. Please use -/// "xed_decoded_inst_get_attribute(xedd, XED_ATTRIBUTE_RING0)" -/// instead. -///Return the current privilege level (CPL) required for execution, 0 or -///3. If the value is zero, then the instruction can only execute in ring 0. -XED_DLL_EXPORT unsigned int xed_inst_cpl(const xed_inst_t* p) ; - - -//These next few are not doxygen commented because I want people to use the -//higher level interface in xed-decoded-inst.h. -static XED_INLINE xed_iform_enum_t xed_inst_iform_enum(const xed_inst_t* p) { - return (xed_iform_enum_t)p->_iform_enum; -} - -static XED_INLINE xed_iclass_enum_t xed_inst_iclass(const xed_inst_t* p) { - return xed_iform_to_iclass(xed_inst_iform_enum(p)); -} - -static XED_INLINE xed_category_enum_t xed_inst_category(const xed_inst_t* p) { - return xed_iform_to_category(xed_inst_iform_enum(p)); -} - -static XED_INLINE xed_extension_enum_t xed_inst_extension(const xed_inst_t* p) { - return xed_iform_to_extension(xed_inst_iform_enum(p)); -} -static XED_INLINE xed_isa_set_enum_t xed_inst_isa_set(const xed_inst_t* p) { - return xed_iform_to_isa_set(xed_inst_iform_enum(p)); -} - - - -///@ingroup DEC -/// Number of instruction operands -static XED_INLINE unsigned int xed_inst_noperands(const xed_inst_t* p) { - return p->_noperands; -} - -///@ingroup DEC -/// Obtain a pointer to an individual operand -XED_DLL_EXPORT const xed_operand_t* -xed_inst_operand(const xed_inst_t* p, unsigned int i); - - - -XED_DLL_EXPORT xed_uint32_t xed_inst_flag_info_index(const xed_inst_t* p); - -//@} - -/// @name xed_inst_t Attribute access -//@{ -/// @ingroup DEC -/// Scan for the attribute attr and return 1 if it is found, 0 otherwise. -XED_DLL_EXPORT xed_uint32_t -xed_inst_get_attribute(const xed_inst_t* p, - xed_attribute_enum_t attr); - -/// @ingroup DEC -/// Return the attributes bit vector -XED_DLL_EXPORT xed_attributes_t -xed_inst_get_attributes(const xed_inst_t* p); - - -/// @ingroup DEC -/// Return the maximum number of defined attributes, independent of any -/// instruction. -XED_DLL_EXPORT unsigned int xed_attribute_max(void); - -/// @ingroup DEC -/// Return the i'th global attribute in a linear sequence, independent of -/// any instruction. This is used for scanning and printing all attributes. -XED_DLL_EXPORT xed_attribute_enum_t xed_attribute(unsigned int i); - -//@} - -/// @name Exceptions -//@{ -/// @ingroup DEC -/// Return #xed_exception_enum_t if present for the specified instruction. -/// This is currently only used for SSE and AVX instructions. -static XED_INLINE -xed_exception_enum_t xed_inst_exception(const xed_inst_t* p) { - return (xed_exception_enum_t)p->_exceptions; -} - -//@} -/// @ingroup DEC -/// Return the base of instruction table. -XED_DLL_EXPORT const xed_inst_t* xed_inst_table_base(void); - -#endif diff --git a/target/i386/latx/include/xed/xed-interface.h b/target/i386/latx/include/xed/xed-interface.h deleted file mode 100644 index eb8c6210762..00000000000 --- a/target/i386/latx/include/xed/xed-interface.h +++ /dev/null @@ -1,89 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/* -/// @file xed-interface.h -/// -*/ - - - -#if !defined(XED_INTERFACE_H) -# define XED_INTERFACE_H - -#if defined(_WIN32) && defined(_MANAGED) -#pragma unmanaged -#endif - -#include "xed-build-defines.h" /* generated */ -#include "xed-portability.h" - -#include "xed-common-hdrs.h" -#include "xed-types.h" -#include "xed-operand-enum.h" - -#include "xed-init.h" -#include "xed-decode.h" -#include "xed-ild.h" - -#include "xed-state.h" /* dstate, legacy */ -#include "xed-syntax-enum.h" -#include "xed-reg-class-enum.h" /* generated */ -#include "xed-reg-class.h" - -#if defined(XED_ENCODER) -# include "xed-encode.h" -# include "xed-encoder-hl.h" -# include "xed-patch.h" -#endif -#if defined(XED_ENC2_ENCODER) -# include "xed-encode-direct.h" -# include "xed-encode-check.h" -#endif - -#include "xed-util.h" -#include "xed-operand-action.h" - -#include "xed-version.h" -#include "xed-decoded-inst.h" -#include "xed-decoded-inst-api.h" -#include "xed-inst.h" -#include "xed-iclass-enum.h" /* generated */ -#include "xed-category-enum.h" /* generated */ -#include "xed-extension-enum.h" /* generated */ -#include "xed-attribute-enum.h" /* generated */ -#include "xed-exception-enum.h" /* generated */ -#include "xed-operand-element-type-enum.h" /* generated */ -#include "xed-operand-element-xtype-enum.h" /* generated */ - -#include "xed-disas.h" // callbacks for disassembly -#include "xed-format-options.h" /* options for disassembly */ - -#include "xed-iform-enum.h" /* generated */ -/* indicates the first and last index of each iform, for building tables */ -#include "xed-iformfl-enum.h" /* generated */ -/* mapping iforms to iclass/category/extension */ -#include "xed-iform-map.h" -#include "xed-rep-prefix.h" - - -#include "xed-agen.h" -#include "xed-cpuid-rec.h" -#include "xed-isa-set.h" - - -#endif diff --git a/target/i386/latx/include/xed/xed-isa-set-enum.h b/target/i386/latx/include/xed/xed-isa-set-enum.h deleted file mode 100644 index 6f98a760871..00000000000 --- a/target/i386/latx/include/xed/xed-isa-set-enum.h +++ /dev/null @@ -1,410 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-isa-set-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_ISA_SET_ENUM_H) -# define XED_ISA_SET_ENUM_H -#include "xed-common-hdrs.h" -#define XED_ISA_SET_INVALID_DEFINED 1 -#define XED_ISA_SET_3DNOW_DEFINED 1 -#define XED_ISA_SET_3DNOW_PREFETCH_DEFINED 1 -#define XED_ISA_SET_ADOX_ADCX_DEFINED 1 -#define XED_ISA_SET_AES_DEFINED 1 -#define XED_ISA_SET_AMD_DEFINED 1 -#define XED_ISA_SET_AMD_INVLPGB_DEFINED 1 -#define XED_ISA_SET_AMX_BF16_DEFINED 1 -#define XED_ISA_SET_AMX_INT8_DEFINED 1 -#define XED_ISA_SET_AMX_TILE_DEFINED 1 -#define XED_ISA_SET_AVX_DEFINED 1 -#define XED_ISA_SET_AVX2_DEFINED 1 -#define XED_ISA_SET_AVX2GATHER_DEFINED 1 -#define XED_ISA_SET_AVX512BW_128_DEFINED 1 -#define XED_ISA_SET_AVX512BW_128N_DEFINED 1 -#define XED_ISA_SET_AVX512BW_256_DEFINED 1 -#define XED_ISA_SET_AVX512BW_512_DEFINED 1 -#define XED_ISA_SET_AVX512BW_KOP_DEFINED 1 -#define XED_ISA_SET_AVX512CD_128_DEFINED 1 -#define XED_ISA_SET_AVX512CD_256_DEFINED 1 -#define XED_ISA_SET_AVX512CD_512_DEFINED 1 -#define XED_ISA_SET_AVX512DQ_128_DEFINED 1 -#define XED_ISA_SET_AVX512DQ_128N_DEFINED 1 -#define XED_ISA_SET_AVX512DQ_256_DEFINED 1 -#define XED_ISA_SET_AVX512DQ_512_DEFINED 1 -#define XED_ISA_SET_AVX512DQ_KOP_DEFINED 1 -#define XED_ISA_SET_AVX512DQ_SCALAR_DEFINED 1 -#define XED_ISA_SET_AVX512ER_512_DEFINED 1 -#define XED_ISA_SET_AVX512ER_SCALAR_DEFINED 1 -#define XED_ISA_SET_AVX512F_128_DEFINED 1 -#define XED_ISA_SET_AVX512F_128N_DEFINED 1 -#define XED_ISA_SET_AVX512F_256_DEFINED 1 -#define XED_ISA_SET_AVX512F_512_DEFINED 1 -#define XED_ISA_SET_AVX512F_KOP_DEFINED 1 -#define XED_ISA_SET_AVX512F_SCALAR_DEFINED 1 -#define XED_ISA_SET_AVX512PF_512_DEFINED 1 -#define XED_ISA_SET_AVX512_4FMAPS_512_DEFINED 1 -#define XED_ISA_SET_AVX512_4FMAPS_SCALAR_DEFINED 1 -#define XED_ISA_SET_AVX512_4VNNIW_512_DEFINED 1 -#define XED_ISA_SET_AVX512_BF16_128_DEFINED 1 -#define XED_ISA_SET_AVX512_BF16_256_DEFINED 1 -#define XED_ISA_SET_AVX512_BF16_512_DEFINED 1 -#define XED_ISA_SET_AVX512_BITALG_128_DEFINED 1 -#define XED_ISA_SET_AVX512_BITALG_256_DEFINED 1 -#define XED_ISA_SET_AVX512_BITALG_512_DEFINED 1 -#define XED_ISA_SET_AVX512_FP16_128_DEFINED 1 -#define XED_ISA_SET_AVX512_FP16_128N_DEFINED 1 -#define XED_ISA_SET_AVX512_FP16_256_DEFINED 1 -#define XED_ISA_SET_AVX512_FP16_512_DEFINED 1 -#define XED_ISA_SET_AVX512_FP16_SCALAR_DEFINED 1 -#define XED_ISA_SET_AVX512_GFNI_128_DEFINED 1 -#define XED_ISA_SET_AVX512_GFNI_256_DEFINED 1 -#define XED_ISA_SET_AVX512_GFNI_512_DEFINED 1 -#define XED_ISA_SET_AVX512_IFMA_128_DEFINED 1 -#define XED_ISA_SET_AVX512_IFMA_256_DEFINED 1 -#define XED_ISA_SET_AVX512_IFMA_512_DEFINED 1 -#define XED_ISA_SET_AVX512_VAES_128_DEFINED 1 -#define XED_ISA_SET_AVX512_VAES_256_DEFINED 1 -#define XED_ISA_SET_AVX512_VAES_512_DEFINED 1 -#define XED_ISA_SET_AVX512_VBMI2_128_DEFINED 1 -#define XED_ISA_SET_AVX512_VBMI2_256_DEFINED 1 -#define XED_ISA_SET_AVX512_VBMI2_512_DEFINED 1 -#define XED_ISA_SET_AVX512_VBMI_128_DEFINED 1 -#define XED_ISA_SET_AVX512_VBMI_256_DEFINED 1 -#define XED_ISA_SET_AVX512_VBMI_512_DEFINED 1 -#define XED_ISA_SET_AVX512_VNNI_128_DEFINED 1 -#define XED_ISA_SET_AVX512_VNNI_256_DEFINED 1 -#define XED_ISA_SET_AVX512_VNNI_512_DEFINED 1 -#define XED_ISA_SET_AVX512_VP2INTERSECT_128_DEFINED 1 -#define XED_ISA_SET_AVX512_VP2INTERSECT_256_DEFINED 1 -#define XED_ISA_SET_AVX512_VP2INTERSECT_512_DEFINED 1 -#define XED_ISA_SET_AVX512_VPCLMULQDQ_128_DEFINED 1 -#define XED_ISA_SET_AVX512_VPCLMULQDQ_256_DEFINED 1 -#define XED_ISA_SET_AVX512_VPCLMULQDQ_512_DEFINED 1 -#define XED_ISA_SET_AVX512_VPOPCNTDQ_128_DEFINED 1 -#define XED_ISA_SET_AVX512_VPOPCNTDQ_256_DEFINED 1 -#define XED_ISA_SET_AVX512_VPOPCNTDQ_512_DEFINED 1 -#define XED_ISA_SET_AVXAES_DEFINED 1 -#define XED_ISA_SET_AVX_GFNI_DEFINED 1 -#define XED_ISA_SET_AVX_VNNI_DEFINED 1 -#define XED_ISA_SET_BMI1_DEFINED 1 -#define XED_ISA_SET_BMI2_DEFINED 1 -#define XED_ISA_SET_CET_DEFINED 1 -#define XED_ISA_SET_CLDEMOTE_DEFINED 1 -#define XED_ISA_SET_CLFLUSHOPT_DEFINED 1 -#define XED_ISA_SET_CLFSH_DEFINED 1 -#define XED_ISA_SET_CLWB_DEFINED 1 -#define XED_ISA_SET_CLZERO_DEFINED 1 -#define XED_ISA_SET_CMOV_DEFINED 1 -#define XED_ISA_SET_CMPXCHG16B_DEFINED 1 -#define XED_ISA_SET_ENQCMD_DEFINED 1 -#define XED_ISA_SET_F16C_DEFINED 1 -#define XED_ISA_SET_FAT_NOP_DEFINED 1 -#define XED_ISA_SET_FCMOV_DEFINED 1 -#define XED_ISA_SET_FMA_DEFINED 1 -#define XED_ISA_SET_FMA4_DEFINED 1 -#define XED_ISA_SET_FXSAVE_DEFINED 1 -#define XED_ISA_SET_FXSAVE64_DEFINED 1 -#define XED_ISA_SET_GFNI_DEFINED 1 -#define XED_ISA_SET_HRESET_DEFINED 1 -#define XED_ISA_SET_I186_DEFINED 1 -#define XED_ISA_SET_I286PROTECTED_DEFINED 1 -#define XED_ISA_SET_I286REAL_DEFINED 1 -#define XED_ISA_SET_I386_DEFINED 1 -#define XED_ISA_SET_I486_DEFINED 1 -#define XED_ISA_SET_I486REAL_DEFINED 1 -#define XED_ISA_SET_I86_DEFINED 1 -#define XED_ISA_SET_INVPCID_DEFINED 1 -#define XED_ISA_SET_KEYLOCKER_DEFINED 1 -#define XED_ISA_SET_KEYLOCKER_WIDE_DEFINED 1 -#define XED_ISA_SET_LAHF_DEFINED 1 -#define XED_ISA_SET_LONGMODE_DEFINED 1 -#define XED_ISA_SET_LWP_DEFINED 1 -#define XED_ISA_SET_LZCNT_DEFINED 1 -#define XED_ISA_SET_MCOMMIT_DEFINED 1 -#define XED_ISA_SET_MONITOR_DEFINED 1 -#define XED_ISA_SET_MONITORX_DEFINED 1 -#define XED_ISA_SET_MOVBE_DEFINED 1 -#define XED_ISA_SET_MOVDIR_DEFINED 1 -#define XED_ISA_SET_MPX_DEFINED 1 -#define XED_ISA_SET_PAUSE_DEFINED 1 -#define XED_ISA_SET_PCLMULQDQ_DEFINED 1 -#define XED_ISA_SET_PCONFIG_DEFINED 1 -#define XED_ISA_SET_PENTIUMMMX_DEFINED 1 -#define XED_ISA_SET_PENTIUMREAL_DEFINED 1 -#define XED_ISA_SET_PKU_DEFINED 1 -#define XED_ISA_SET_POPCNT_DEFINED 1 -#define XED_ISA_SET_PPRO_DEFINED 1 -#define XED_ISA_SET_PPRO_UD0_LONG_DEFINED 1 -#define XED_ISA_SET_PPRO_UD0_SHORT_DEFINED 1 -#define XED_ISA_SET_PREFETCHW_DEFINED 1 -#define XED_ISA_SET_PREFETCHWT1_DEFINED 1 -#define XED_ISA_SET_PREFETCH_NOP_DEFINED 1 -#define XED_ISA_SET_PTWRITE_DEFINED 1 -#define XED_ISA_SET_RDPID_DEFINED 1 -#define XED_ISA_SET_RDPMC_DEFINED 1 -#define XED_ISA_SET_RDPRU_DEFINED 1 -#define XED_ISA_SET_RDRAND_DEFINED 1 -#define XED_ISA_SET_RDSEED_DEFINED 1 -#define XED_ISA_SET_RDTSCP_DEFINED 1 -#define XED_ISA_SET_RDWRFSGS_DEFINED 1 -#define XED_ISA_SET_RTM_DEFINED 1 -#define XED_ISA_SET_SERIALIZE_DEFINED 1 -#define XED_ISA_SET_SGX_DEFINED 1 -#define XED_ISA_SET_SGX_ENCLV_DEFINED 1 -#define XED_ISA_SET_SHA_DEFINED 1 -#define XED_ISA_SET_SMAP_DEFINED 1 -#define XED_ISA_SET_SMX_DEFINED 1 -#define XED_ISA_SET_SNP_DEFINED 1 -#define XED_ISA_SET_SSE_DEFINED 1 -#define XED_ISA_SET_SSE2_DEFINED 1 -#define XED_ISA_SET_SSE2MMX_DEFINED 1 -#define XED_ISA_SET_SSE3_DEFINED 1 -#define XED_ISA_SET_SSE3X87_DEFINED 1 -#define XED_ISA_SET_SSE4_DEFINED 1 -#define XED_ISA_SET_SSE42_DEFINED 1 -#define XED_ISA_SET_SSE4A_DEFINED 1 -#define XED_ISA_SET_SSEMXCSR_DEFINED 1 -#define XED_ISA_SET_SSE_PREFETCH_DEFINED 1 -#define XED_ISA_SET_SSSE3_DEFINED 1 -#define XED_ISA_SET_SSSE3MMX_DEFINED 1 -#define XED_ISA_SET_SVM_DEFINED 1 -#define XED_ISA_SET_TBM_DEFINED 1 -#define XED_ISA_SET_TDX_DEFINED 1 -#define XED_ISA_SET_TSX_LDTRK_DEFINED 1 -#define XED_ISA_SET_UINTR_DEFINED 1 -#define XED_ISA_SET_VAES_DEFINED 1 -#define XED_ISA_SET_VIA_PADLOCK_AES_DEFINED 1 -#define XED_ISA_SET_VIA_PADLOCK_MONTMUL_DEFINED 1 -#define XED_ISA_SET_VIA_PADLOCK_RNG_DEFINED 1 -#define XED_ISA_SET_VIA_PADLOCK_SHA_DEFINED 1 -#define XED_ISA_SET_VMFUNC_DEFINED 1 -#define XED_ISA_SET_VPCLMULQDQ_DEFINED 1 -#define XED_ISA_SET_VTX_DEFINED 1 -#define XED_ISA_SET_WAITPKG_DEFINED 1 -#define XED_ISA_SET_WBNOINVD_DEFINED 1 -#define XED_ISA_SET_X87_DEFINED 1 -#define XED_ISA_SET_XOP_DEFINED 1 -#define XED_ISA_SET_XSAVE_DEFINED 1 -#define XED_ISA_SET_XSAVEC_DEFINED 1 -#define XED_ISA_SET_XSAVEOPT_DEFINED 1 -#define XED_ISA_SET_XSAVES_DEFINED 1 -#define XED_ISA_SET_LAST_DEFINED 1 -typedef enum { - XED_ISA_SET_INVALID, - XED_ISA_SET_3DNOW, - XED_ISA_SET_3DNOW_PREFETCH, - XED_ISA_SET_ADOX_ADCX, - XED_ISA_SET_AES, - XED_ISA_SET_AMD, - XED_ISA_SET_AMD_INVLPGB, - XED_ISA_SET_AMX_BF16, - XED_ISA_SET_AMX_INT8, - XED_ISA_SET_AMX_TILE, - XED_ISA_SET_AVX, - XED_ISA_SET_AVX2, - XED_ISA_SET_AVX2GATHER, - XED_ISA_SET_AVX512BW_128, - XED_ISA_SET_AVX512BW_128N, - XED_ISA_SET_AVX512BW_256, - XED_ISA_SET_AVX512BW_512, - XED_ISA_SET_AVX512BW_KOP, - XED_ISA_SET_AVX512CD_128, - XED_ISA_SET_AVX512CD_256, - XED_ISA_SET_AVX512CD_512, - XED_ISA_SET_AVX512DQ_128, - XED_ISA_SET_AVX512DQ_128N, - XED_ISA_SET_AVX512DQ_256, - XED_ISA_SET_AVX512DQ_512, - XED_ISA_SET_AVX512DQ_KOP, - XED_ISA_SET_AVX512DQ_SCALAR, - XED_ISA_SET_AVX512ER_512, - XED_ISA_SET_AVX512ER_SCALAR, - XED_ISA_SET_AVX512F_128, - XED_ISA_SET_AVX512F_128N, - XED_ISA_SET_AVX512F_256, - XED_ISA_SET_AVX512F_512, - XED_ISA_SET_AVX512F_KOP, - XED_ISA_SET_AVX512F_SCALAR, - XED_ISA_SET_AVX512PF_512, - XED_ISA_SET_AVX512_4FMAPS_512, - XED_ISA_SET_AVX512_4FMAPS_SCALAR, - XED_ISA_SET_AVX512_4VNNIW_512, - XED_ISA_SET_AVX512_BF16_128, - XED_ISA_SET_AVX512_BF16_256, - XED_ISA_SET_AVX512_BF16_512, - XED_ISA_SET_AVX512_BITALG_128, - XED_ISA_SET_AVX512_BITALG_256, - XED_ISA_SET_AVX512_BITALG_512, - XED_ISA_SET_AVX512_FP16_128, - XED_ISA_SET_AVX512_FP16_128N, - XED_ISA_SET_AVX512_FP16_256, - XED_ISA_SET_AVX512_FP16_512, - XED_ISA_SET_AVX512_FP16_SCALAR, - XED_ISA_SET_AVX512_GFNI_128, - XED_ISA_SET_AVX512_GFNI_256, - XED_ISA_SET_AVX512_GFNI_512, - XED_ISA_SET_AVX512_IFMA_128, - XED_ISA_SET_AVX512_IFMA_256, - XED_ISA_SET_AVX512_IFMA_512, - XED_ISA_SET_AVX512_VAES_128, - XED_ISA_SET_AVX512_VAES_256, - XED_ISA_SET_AVX512_VAES_512, - XED_ISA_SET_AVX512_VBMI2_128, - XED_ISA_SET_AVX512_VBMI2_256, - XED_ISA_SET_AVX512_VBMI2_512, - XED_ISA_SET_AVX512_VBMI_128, - XED_ISA_SET_AVX512_VBMI_256, - XED_ISA_SET_AVX512_VBMI_512, - XED_ISA_SET_AVX512_VNNI_128, - XED_ISA_SET_AVX512_VNNI_256, - XED_ISA_SET_AVX512_VNNI_512, - XED_ISA_SET_AVX512_VP2INTERSECT_128, - XED_ISA_SET_AVX512_VP2INTERSECT_256, - XED_ISA_SET_AVX512_VP2INTERSECT_512, - XED_ISA_SET_AVX512_VPCLMULQDQ_128, - XED_ISA_SET_AVX512_VPCLMULQDQ_256, - XED_ISA_SET_AVX512_VPCLMULQDQ_512, - XED_ISA_SET_AVX512_VPOPCNTDQ_128, - XED_ISA_SET_AVX512_VPOPCNTDQ_256, - XED_ISA_SET_AVX512_VPOPCNTDQ_512, - XED_ISA_SET_AVXAES, - XED_ISA_SET_AVX_GFNI, - XED_ISA_SET_AVX_VNNI, - XED_ISA_SET_BMI1, - XED_ISA_SET_BMI2, - XED_ISA_SET_CET, - XED_ISA_SET_CLDEMOTE, - XED_ISA_SET_CLFLUSHOPT, - XED_ISA_SET_CLFSH, - XED_ISA_SET_CLWB, - XED_ISA_SET_CLZERO, - XED_ISA_SET_CMOV, - XED_ISA_SET_CMPXCHG16B, - XED_ISA_SET_ENQCMD, - XED_ISA_SET_F16C, - XED_ISA_SET_FAT_NOP, - XED_ISA_SET_FCMOV, - XED_ISA_SET_FMA, - XED_ISA_SET_FMA4, - XED_ISA_SET_FXSAVE, - XED_ISA_SET_FXSAVE64, - XED_ISA_SET_GFNI, - XED_ISA_SET_HRESET, - XED_ISA_SET_I186, - XED_ISA_SET_I286PROTECTED, - XED_ISA_SET_I286REAL, - XED_ISA_SET_I386, - XED_ISA_SET_I486, - XED_ISA_SET_I486REAL, - XED_ISA_SET_I86, - XED_ISA_SET_INVPCID, - XED_ISA_SET_KEYLOCKER, - XED_ISA_SET_KEYLOCKER_WIDE, - XED_ISA_SET_LAHF, - XED_ISA_SET_LONGMODE, - XED_ISA_SET_LWP, - XED_ISA_SET_LZCNT, - XED_ISA_SET_MCOMMIT, - XED_ISA_SET_MONITOR, - XED_ISA_SET_MONITORX, - XED_ISA_SET_MOVBE, - XED_ISA_SET_MOVDIR, - XED_ISA_SET_MPX, - XED_ISA_SET_PAUSE, - XED_ISA_SET_PCLMULQDQ, - XED_ISA_SET_PCONFIG, - XED_ISA_SET_PENTIUMMMX, - XED_ISA_SET_PENTIUMREAL, - XED_ISA_SET_PKU, - XED_ISA_SET_POPCNT, - XED_ISA_SET_PPRO, - XED_ISA_SET_PPRO_UD0_LONG, - XED_ISA_SET_PPRO_UD0_SHORT, - XED_ISA_SET_PREFETCHW, - XED_ISA_SET_PREFETCHWT1, - XED_ISA_SET_PREFETCH_NOP, - XED_ISA_SET_PTWRITE, - XED_ISA_SET_RDPID, - XED_ISA_SET_RDPMC, - XED_ISA_SET_RDPRU, - XED_ISA_SET_RDRAND, - XED_ISA_SET_RDSEED, - XED_ISA_SET_RDTSCP, - XED_ISA_SET_RDWRFSGS, - XED_ISA_SET_RTM, - XED_ISA_SET_SERIALIZE, - XED_ISA_SET_SGX, - XED_ISA_SET_SGX_ENCLV, - XED_ISA_SET_SHA, - XED_ISA_SET_SMAP, - XED_ISA_SET_SMX, - XED_ISA_SET_SNP, - XED_ISA_SET_SSE, - XED_ISA_SET_SSE2, - XED_ISA_SET_SSE2MMX, - XED_ISA_SET_SSE3, - XED_ISA_SET_SSE3X87, - XED_ISA_SET_SSE4, - XED_ISA_SET_SSE42, - XED_ISA_SET_SSE4A, - XED_ISA_SET_SSEMXCSR, - XED_ISA_SET_SSE_PREFETCH, - XED_ISA_SET_SSSE3, - XED_ISA_SET_SSSE3MMX, - XED_ISA_SET_SVM, - XED_ISA_SET_TBM, - XED_ISA_SET_TDX, - XED_ISA_SET_TSX_LDTRK, - XED_ISA_SET_UINTR, - XED_ISA_SET_VAES, - XED_ISA_SET_VIA_PADLOCK_AES, - XED_ISA_SET_VIA_PADLOCK_MONTMUL, - XED_ISA_SET_VIA_PADLOCK_RNG, - XED_ISA_SET_VIA_PADLOCK_SHA, - XED_ISA_SET_VMFUNC, - XED_ISA_SET_VPCLMULQDQ, - XED_ISA_SET_VTX, - XED_ISA_SET_WAITPKG, - XED_ISA_SET_WBNOINVD, - XED_ISA_SET_X87, - XED_ISA_SET_XOP, - XED_ISA_SET_XSAVE, - XED_ISA_SET_XSAVEC, - XED_ISA_SET_XSAVEOPT, - XED_ISA_SET_XSAVES, - XED_ISA_SET_LAST -} xed_isa_set_enum_t; - -/// This converts strings to #xed_isa_set_enum_t types. -/// @param s A C-string. -/// @return #xed_isa_set_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_isa_set_enum_t str2xed_isa_set_enum_t(const char* s); -/// This converts strings to #xed_isa_set_enum_t types. -/// @param p An enumeration element of type xed_isa_set_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_isa_set_enum_t2str(const xed_isa_set_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_isa_set_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_isa_set_enum_t xed_isa_set_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-isa-set.h b/target/i386/latx/include/xed/xed-isa-set.h deleted file mode 100644 index 6952f5a64ce..00000000000 --- a/target/i386/latx/include/xed/xed-isa-set.h +++ /dev/null @@ -1,37 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-isa-set.h - - -#if !defined(XED_ISA_SET_H) -# define XED_ISA_SET_H - -#include "xed-common-hdrs.h" -#include "xed-types.h" -#include "xed-isa-set-enum.h" /* generated */ -#include "xed-chip-enum.h" /* generated */ - -/// @ingroup ISASET -/// return 1 if the isa_set is part included in the specified chip, 0 -/// otherwise. -XED_DLL_EXPORT xed_bool_t -xed_isa_set_is_valid_for_chip(xed_isa_set_enum_t isa_set, - xed_chip_enum_t chip); - - -#endif diff --git a/target/i386/latx/include/xed/xed-machine-mode-enum.h b/target/i386/latx/include/xed/xed-machine-mode-enum.h deleted file mode 100644 index b6a65814650..00000000000 --- a/target/i386/latx/include/xed/xed-machine-mode-enum.h +++ /dev/null @@ -1,62 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-machine-mode-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_MACHINE_MODE_ENUM_H) -# define XED_MACHINE_MODE_ENUM_H -#include "xed-common-hdrs.h" -#define XED_MACHINE_MODE_INVALID_DEFINED 1 -#define XED_MACHINE_MODE_LONG_64_DEFINED 1 -#define XED_MACHINE_MODE_LONG_COMPAT_32_DEFINED 1 -#define XED_MACHINE_MODE_LONG_COMPAT_16_DEFINED 1 -#define XED_MACHINE_MODE_LEGACY_32_DEFINED 1 -#define XED_MACHINE_MODE_LEGACY_16_DEFINED 1 -#define XED_MACHINE_MODE_REAL_16_DEFINED 1 -#define XED_MACHINE_MODE_REAL_32_DEFINED 1 -#define XED_MACHINE_MODE_LAST_DEFINED 1 -typedef enum { - XED_MACHINE_MODE_INVALID, - XED_MACHINE_MODE_LONG_64, ///< 64b operating mode - XED_MACHINE_MODE_LONG_COMPAT_32, ///< 32b protected mode - XED_MACHINE_MODE_LONG_COMPAT_16, ///< 16b protected mode - XED_MACHINE_MODE_LEGACY_32, ///< 32b protected mode - XED_MACHINE_MODE_LEGACY_16, ///< 16b protected mode - XED_MACHINE_MODE_REAL_16, ///< 16b real mode - XED_MACHINE_MODE_REAL_32, ///< 32b real mode (CS.D bit = 1) - XED_MACHINE_MODE_LAST -} xed_machine_mode_enum_t; - -/// This converts strings to #xed_machine_mode_enum_t types. -/// @param s A C-string. -/// @return #xed_machine_mode_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_machine_mode_enum_t str2xed_machine_mode_enum_t(const char* s); -/// This converts strings to #xed_machine_mode_enum_t types. -/// @param p An enumeration element of type xed_machine_mode_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_machine_mode_enum_t2str(const xed_machine_mode_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_machine_mode_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_machine_mode_enum_t xed_machine_mode_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-mapu-enum.h b/target/i386/latx/include/xed/xed-mapu-enum.h deleted file mode 100644 index 63c70ce77c3..00000000000 --- a/target/i386/latx/include/xed/xed-mapu-enum.h +++ /dev/null @@ -1,80 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-mapu-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_MAPU_ENUM_H) -# define XED_MAPU_ENUM_H -#include "xed-common-hdrs.h" -#define XED_MAPU_INVALID_DEFINED 1 -#define XED_MAPU_AMD_3DNOW_DEFINED 1 -#define XED_MAPU_AMD_XOP8_DEFINED 1 -#define XED_MAPU_AMD_XOP9_DEFINED 1 -#define XED_MAPU_AMD_XOPA_DEFINED 1 -#define XED_MAPU_EVEX_MAP1_DEFINED 1 -#define XED_MAPU_EVEX_MAP2_DEFINED 1 -#define XED_MAPU_EVEX_MAP3_DEFINED 1 -#define XED_MAPU_EVEX_MAP5_DEFINED 1 -#define XED_MAPU_EVEX_MAP6_DEFINED 1 -#define XED_MAPU_LEGACY_MAP0_DEFINED 1 -#define XED_MAPU_LEGACY_MAP1_DEFINED 1 -#define XED_MAPU_LEGACY_MAP2_DEFINED 1 -#define XED_MAPU_LEGACY_MAP3_DEFINED 1 -#define XED_MAPU_VEX_MAP1_DEFINED 1 -#define XED_MAPU_VEX_MAP2_DEFINED 1 -#define XED_MAPU_VEX_MAP3_DEFINED 1 -#define XED_MAPU_LAST_DEFINED 1 -typedef enum { - XED_MAPU_INVALID, - XED_MAPU_AMD_3DNOW, - XED_MAPU_AMD_XOP8, - XED_MAPU_AMD_XOP9, - XED_MAPU_AMD_XOPA, - XED_MAPU_EVEX_MAP1, - XED_MAPU_EVEX_MAP2, - XED_MAPU_EVEX_MAP3, - XED_MAPU_EVEX_MAP5, - XED_MAPU_EVEX_MAP6, - XED_MAPU_LEGACY_MAP0, - XED_MAPU_LEGACY_MAP1, - XED_MAPU_LEGACY_MAP2, - XED_MAPU_LEGACY_MAP3, - XED_MAPU_VEX_MAP1, - XED_MAPU_VEX_MAP2, - XED_MAPU_VEX_MAP3, - XED_MAPU_LAST -} xed_mapu_enum_t; - -/// This converts strings to #xed_mapu_enum_t types. -/// @param s A C-string. -/// @return #xed_mapu_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_mapu_enum_t str2xed_mapu_enum_t(const char* s); -/// This converts strings to #xed_mapu_enum_t types. -/// @param p An enumeration element of type xed_mapu_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_mapu_enum_t2str(const xed_mapu_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_mapu_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_mapu_enum_t xed_mapu_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-nonterminal-enum.h b/target/i386/latx/include/xed/xed-nonterminal-enum.h deleted file mode 100644 index 59b42ae34a3..00000000000 --- a/target/i386/latx/include/xed/xed-nonterminal-enum.h +++ /dev/null @@ -1,562 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-nonterminal-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_NONTERMINAL_ENUM_H) -# define XED_NONTERMINAL_ENUM_H -#include "xed-common-hdrs.h" -#define XED_NONTERMINAL_INVALID_DEFINED 1 -#define XED_NONTERMINAL_AR10_DEFINED 1 -#define XED_NONTERMINAL_AR11_DEFINED 1 -#define XED_NONTERMINAL_AR12_DEFINED 1 -#define XED_NONTERMINAL_AR13_DEFINED 1 -#define XED_NONTERMINAL_AR14_DEFINED 1 -#define XED_NONTERMINAL_AR15_DEFINED 1 -#define XED_NONTERMINAL_AR8_DEFINED 1 -#define XED_NONTERMINAL_AR9_DEFINED 1 -#define XED_NONTERMINAL_ARAX_DEFINED 1 -#define XED_NONTERMINAL_ARBP_DEFINED 1 -#define XED_NONTERMINAL_ARBX_DEFINED 1 -#define XED_NONTERMINAL_ARCX_DEFINED 1 -#define XED_NONTERMINAL_ARDI_DEFINED 1 -#define XED_NONTERMINAL_ARDX_DEFINED 1 -#define XED_NONTERMINAL_ARSI_DEFINED 1 -#define XED_NONTERMINAL_ARSP_DEFINED 1 -#define XED_NONTERMINAL_ASZ_NONTERM_DEFINED 1 -#define XED_NONTERMINAL_AVX512_ROUND_DEFINED 1 -#define XED_NONTERMINAL_AVX_INSTRUCTIONS_DEFINED 1 -#define XED_NONTERMINAL_AVX_SPLITTER_DEFINED 1 -#define XED_NONTERMINAL_A_GPR_B_DEFINED 1 -#define XED_NONTERMINAL_A_GPR_R_DEFINED 1 -#define XED_NONTERMINAL_BND_B_DEFINED 1 -#define XED_NONTERMINAL_BND_B_CHECK_DEFINED 1 -#define XED_NONTERMINAL_BND_R_DEFINED 1 -#define XED_NONTERMINAL_BND_R_CHECK_DEFINED 1 -#define XED_NONTERMINAL_BRANCH_HINT_DEFINED 1 -#define XED_NONTERMINAL_BRDISP32_DEFINED 1 -#define XED_NONTERMINAL_BRDISP8_DEFINED 1 -#define XED_NONTERMINAL_BRDISPZ_DEFINED 1 -#define XED_NONTERMINAL_CET_NO_TRACK_DEFINED 1 -#define XED_NONTERMINAL_CR_B_DEFINED 1 -#define XED_NONTERMINAL_CR_R_DEFINED 1 -#define XED_NONTERMINAL_CR_WIDTH_DEFINED 1 -#define XED_NONTERMINAL_DF64_DEFINED 1 -#define XED_NONTERMINAL_DR_R_DEFINED 1 -#define XED_NONTERMINAL_ESIZE_128_BITS_DEFINED 1 -#define XED_NONTERMINAL_ESIZE_16_BITS_DEFINED 1 -#define XED_NONTERMINAL_ESIZE_1_BITS_DEFINED 1 -#define XED_NONTERMINAL_ESIZE_2_BITS_DEFINED 1 -#define XED_NONTERMINAL_ESIZE_32_BITS_DEFINED 1 -#define XED_NONTERMINAL_ESIZE_4_BITS_DEFINED 1 -#define XED_NONTERMINAL_ESIZE_64_BITS_DEFINED 1 -#define XED_NONTERMINAL_ESIZE_8_BITS_DEFINED 1 -#define XED_NONTERMINAL_EVEX_INSTRUCTIONS_DEFINED 1 -#define XED_NONTERMINAL_EVEX_SPLITTER_DEFINED 1 -#define XED_NONTERMINAL_FINAL_DSEG_DEFINED 1 -#define XED_NONTERMINAL_FINAL_DSEG1_DEFINED 1 -#define XED_NONTERMINAL_FINAL_DSEG1_MODE64_DEFINED 1 -#define XED_NONTERMINAL_FINAL_DSEG1_NOT64_DEFINED 1 -#define XED_NONTERMINAL_FINAL_DSEG_MODE64_DEFINED 1 -#define XED_NONTERMINAL_FINAL_DSEG_NOT64_DEFINED 1 -#define XED_NONTERMINAL_FINAL_ESEG_DEFINED 1 -#define XED_NONTERMINAL_FINAL_ESEG1_DEFINED 1 -#define XED_NONTERMINAL_FINAL_SSEG_DEFINED 1 -#define XED_NONTERMINAL_FINAL_SSEG0_DEFINED 1 -#define XED_NONTERMINAL_FINAL_SSEG1_DEFINED 1 -#define XED_NONTERMINAL_FINAL_SSEG_MODE64_DEFINED 1 -#define XED_NONTERMINAL_FINAL_SSEG_NOT64_DEFINED 1 -#define XED_NONTERMINAL_FIX_ROUND_LEN128_DEFINED 1 -#define XED_NONTERMINAL_FIX_ROUND_LEN512_DEFINED 1 -#define XED_NONTERMINAL_FORCE64_DEFINED 1 -#define XED_NONTERMINAL_GPR16_B_DEFINED 1 -#define XED_NONTERMINAL_GPR16_R_DEFINED 1 -#define XED_NONTERMINAL_GPR16_SB_DEFINED 1 -#define XED_NONTERMINAL_GPR32_B_DEFINED 1 -#define XED_NONTERMINAL_GPR32_R_DEFINED 1 -#define XED_NONTERMINAL_GPR32_SB_DEFINED 1 -#define XED_NONTERMINAL_GPR32_X_DEFINED 1 -#define XED_NONTERMINAL_GPR64_B_DEFINED 1 -#define XED_NONTERMINAL_GPR64_R_DEFINED 1 -#define XED_NONTERMINAL_GPR64_SB_DEFINED 1 -#define XED_NONTERMINAL_GPR64_X_DEFINED 1 -#define XED_NONTERMINAL_GPR8_B_DEFINED 1 -#define XED_NONTERMINAL_GPR8_R_DEFINED 1 -#define XED_NONTERMINAL_GPR8_SB_DEFINED 1 -#define XED_NONTERMINAL_GPRV_B_DEFINED 1 -#define XED_NONTERMINAL_GPRV_R_DEFINED 1 -#define XED_NONTERMINAL_GPRV_SB_DEFINED 1 -#define XED_NONTERMINAL_GPRY_B_DEFINED 1 -#define XED_NONTERMINAL_GPRY_R_DEFINED 1 -#define XED_NONTERMINAL_GPRZ_B_DEFINED 1 -#define XED_NONTERMINAL_GPRZ_R_DEFINED 1 -#define XED_NONTERMINAL_IGNORE66_DEFINED 1 -#define XED_NONTERMINAL_IMMUNE66_DEFINED 1 -#define XED_NONTERMINAL_IMMUNE66_LOOP64_DEFINED 1 -#define XED_NONTERMINAL_IMMUNE_REXW_DEFINED 1 -#define XED_NONTERMINAL_INSTRUCTIONS_DEFINED 1 -#define XED_NONTERMINAL_ISA_DEFINED 1 -#define XED_NONTERMINAL_MASK1_DEFINED 1 -#define XED_NONTERMINAL_MASKNOT0_DEFINED 1 -#define XED_NONTERMINAL_MASK_B_DEFINED 1 -#define XED_NONTERMINAL_MASK_N_DEFINED 1 -#define XED_NONTERMINAL_MASK_N32_DEFINED 1 -#define XED_NONTERMINAL_MASK_N64_DEFINED 1 -#define XED_NONTERMINAL_MASK_R_DEFINED 1 -#define XED_NONTERMINAL_MEMDISP_DEFINED 1 -#define XED_NONTERMINAL_MEMDISP16_DEFINED 1 -#define XED_NONTERMINAL_MEMDISP32_DEFINED 1 -#define XED_NONTERMINAL_MEMDISP8_DEFINED 1 -#define XED_NONTERMINAL_MEMDISPV_DEFINED 1 -#define XED_NONTERMINAL_MMX_B_DEFINED 1 -#define XED_NONTERMINAL_MMX_R_DEFINED 1 -#define XED_NONTERMINAL_MODRM_DEFINED 1 -#define XED_NONTERMINAL_MODRM16_DEFINED 1 -#define XED_NONTERMINAL_MODRM32_DEFINED 1 -#define XED_NONTERMINAL_MODRM64ALT32_DEFINED 1 -#define XED_NONTERMINAL_NELEM_EIGHTHMEM_DEFINED 1 -#define XED_NONTERMINAL_NELEM_FULL_DEFINED 1 -#define XED_NONTERMINAL_NELEM_FULLMEM_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GPR_READER_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GPR_READER_BYTE_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GPR_READER_SUBDWORD_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GPR_READER_WORD_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GPR_WRITER_LDOP_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GPR_WRITER_LDOP_D_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GPR_WRITER_LDOP_Q_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GPR_WRITER_STORE_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GPR_WRITER_STORE_BYTE_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GPR_WRITER_STORE_SUBDWORD_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GPR_WRITER_STORE_WORD_DEFINED 1 -#define XED_NONTERMINAL_NELEM_GSCAT_DEFINED 1 -#define XED_NONTERMINAL_NELEM_HALF_DEFINED 1 -#define XED_NONTERMINAL_NELEM_HALFMEM_DEFINED 1 -#define XED_NONTERMINAL_NELEM_MEM128_DEFINED 1 -#define XED_NONTERMINAL_NELEM_MOVDDUP_DEFINED 1 -#define XED_NONTERMINAL_NELEM_QUARTER_DEFINED 1 -#define XED_NONTERMINAL_NELEM_QUARTERMEM_DEFINED 1 -#define XED_NONTERMINAL_NELEM_SCALAR_DEFINED 1 -#define XED_NONTERMINAL_NELEM_TUPLE1_DEFINED 1 -#define XED_NONTERMINAL_NELEM_TUPLE1_4X_DEFINED 1 -#define XED_NONTERMINAL_NELEM_TUPLE1_BYTE_DEFINED 1 -#define XED_NONTERMINAL_NELEM_TUPLE1_SUBDWORD_DEFINED 1 -#define XED_NONTERMINAL_NELEM_TUPLE1_WORD_DEFINED 1 -#define XED_NONTERMINAL_NELEM_TUPLE2_DEFINED 1 -#define XED_NONTERMINAL_NELEM_TUPLE4_DEFINED 1 -#define XED_NONTERMINAL_NELEM_TUPLE8_DEFINED 1 -#define XED_NONTERMINAL_OEAX_DEFINED 1 -#define XED_NONTERMINAL_ONE_DEFINED 1 -#define XED_NONTERMINAL_ORAX_DEFINED 1 -#define XED_NONTERMINAL_ORBP_DEFINED 1 -#define XED_NONTERMINAL_ORBX_DEFINED 1 -#define XED_NONTERMINAL_ORCX_DEFINED 1 -#define XED_NONTERMINAL_ORDX_DEFINED 1 -#define XED_NONTERMINAL_ORSP_DEFINED 1 -#define XED_NONTERMINAL_OSZ_NONTERM_DEFINED 1 -#define XED_NONTERMINAL_OVERRIDE_SEG0_DEFINED 1 -#define XED_NONTERMINAL_OVERRIDE_SEG1_DEFINED 1 -#define XED_NONTERMINAL_PREFIXES_DEFINED 1 -#define XED_NONTERMINAL_REFINING66_DEFINED 1 -#define XED_NONTERMINAL_REMOVE_SEGMENT_DEFINED 1 -#define XED_NONTERMINAL_RFLAGS_DEFINED 1 -#define XED_NONTERMINAL_RIP_DEFINED 1 -#define XED_NONTERMINAL_RIPA_DEFINED 1 -#define XED_NONTERMINAL_SAE_DEFINED 1 -#define XED_NONTERMINAL_SEG_DEFINED 1 -#define XED_NONTERMINAL_SEG_MOV_DEFINED 1 -#define XED_NONTERMINAL_SE_IMM8_DEFINED 1 -#define XED_NONTERMINAL_SIB_DEFINED 1 -#define XED_NONTERMINAL_SIB_BASE0_DEFINED 1 -#define XED_NONTERMINAL_SIMM8_DEFINED 1 -#define XED_NONTERMINAL_SIMMZ_DEFINED 1 -#define XED_NONTERMINAL_SRBP_DEFINED 1 -#define XED_NONTERMINAL_SRSP_DEFINED 1 -#define XED_NONTERMINAL_TMM_B_DEFINED 1 -#define XED_NONTERMINAL_TMM_N_DEFINED 1 -#define XED_NONTERMINAL_TMM_R_DEFINED 1 -#define XED_NONTERMINAL_UIMM16_DEFINED 1 -#define XED_NONTERMINAL_UIMM32_DEFINED 1 -#define XED_NONTERMINAL_UIMM8_DEFINED 1 -#define XED_NONTERMINAL_UIMM8_1_DEFINED 1 -#define XED_NONTERMINAL_UIMMV_DEFINED 1 -#define XED_NONTERMINAL_UISA_VMODRM_XMM_DEFINED 1 -#define XED_NONTERMINAL_UISA_VMODRM_YMM_DEFINED 1 -#define XED_NONTERMINAL_UISA_VMODRM_ZMM_DEFINED 1 -#define XED_NONTERMINAL_UISA_VSIB_BASE_DEFINED 1 -#define XED_NONTERMINAL_UISA_VSIB_INDEX_XMM_DEFINED 1 -#define XED_NONTERMINAL_UISA_VSIB_INDEX_YMM_DEFINED 1 -#define XED_NONTERMINAL_UISA_VSIB_INDEX_ZMM_DEFINED 1 -#define XED_NONTERMINAL_UISA_VSIB_XMM_DEFINED 1 -#define XED_NONTERMINAL_UISA_VSIB_YMM_DEFINED 1 -#define XED_NONTERMINAL_UISA_VSIB_ZMM_DEFINED 1 -#define XED_NONTERMINAL_VGPR32_B_DEFINED 1 -#define XED_NONTERMINAL_VGPR32_B_32_DEFINED 1 -#define XED_NONTERMINAL_VGPR32_B_64_DEFINED 1 -#define XED_NONTERMINAL_VGPR32_N_DEFINED 1 -#define XED_NONTERMINAL_VGPR32_N_32_DEFINED 1 -#define XED_NONTERMINAL_VGPR32_N_64_DEFINED 1 -#define XED_NONTERMINAL_VGPR32_R_DEFINED 1 -#define XED_NONTERMINAL_VGPR32_R_32_DEFINED 1 -#define XED_NONTERMINAL_VGPR32_R_64_DEFINED 1 -#define XED_NONTERMINAL_VGPR64_B_DEFINED 1 -#define XED_NONTERMINAL_VGPR64_N_DEFINED 1 -#define XED_NONTERMINAL_VGPR64_R_DEFINED 1 -#define XED_NONTERMINAL_VGPRY_B_DEFINED 1 -#define XED_NONTERMINAL_VGPRY_N_DEFINED 1 -#define XED_NONTERMINAL_VGPRY_R_DEFINED 1 -#define XED_NONTERMINAL_VMODRM_XMM_DEFINED 1 -#define XED_NONTERMINAL_VMODRM_YMM_DEFINED 1 -#define XED_NONTERMINAL_VSIB_BASE_DEFINED 1 -#define XED_NONTERMINAL_VSIB_INDEX_XMM_DEFINED 1 -#define XED_NONTERMINAL_VSIB_INDEX_YMM_DEFINED 1 -#define XED_NONTERMINAL_VSIB_XMM_DEFINED 1 -#define XED_NONTERMINAL_VSIB_YMM_DEFINED 1 -#define XED_NONTERMINAL_X87_DEFINED 1 -#define XED_NONTERMINAL_XMM_B_DEFINED 1 -#define XED_NONTERMINAL_XMM_B3_DEFINED 1 -#define XED_NONTERMINAL_XMM_B3_32_DEFINED 1 -#define XED_NONTERMINAL_XMM_B3_64_DEFINED 1 -#define XED_NONTERMINAL_XMM_B_32_DEFINED 1 -#define XED_NONTERMINAL_XMM_B_64_DEFINED 1 -#define XED_NONTERMINAL_XMM_N_DEFINED 1 -#define XED_NONTERMINAL_XMM_N3_DEFINED 1 -#define XED_NONTERMINAL_XMM_N3_32_DEFINED 1 -#define XED_NONTERMINAL_XMM_N3_64_DEFINED 1 -#define XED_NONTERMINAL_XMM_N_32_DEFINED 1 -#define XED_NONTERMINAL_XMM_N_64_DEFINED 1 -#define XED_NONTERMINAL_XMM_R_DEFINED 1 -#define XED_NONTERMINAL_XMM_R3_DEFINED 1 -#define XED_NONTERMINAL_XMM_R3_32_DEFINED 1 -#define XED_NONTERMINAL_XMM_R3_64_DEFINED 1 -#define XED_NONTERMINAL_XMM_R_32_DEFINED 1 -#define XED_NONTERMINAL_XMM_R_64_DEFINED 1 -#define XED_NONTERMINAL_XMM_SE_DEFINED 1 -#define XED_NONTERMINAL_XMM_SE32_DEFINED 1 -#define XED_NONTERMINAL_XMM_SE64_DEFINED 1 -#define XED_NONTERMINAL_XOP_INSTRUCTIONS_DEFINED 1 -#define XED_NONTERMINAL_YMM_B_DEFINED 1 -#define XED_NONTERMINAL_YMM_B3_DEFINED 1 -#define XED_NONTERMINAL_YMM_B3_32_DEFINED 1 -#define XED_NONTERMINAL_YMM_B3_64_DEFINED 1 -#define XED_NONTERMINAL_YMM_B_32_DEFINED 1 -#define XED_NONTERMINAL_YMM_B_64_DEFINED 1 -#define XED_NONTERMINAL_YMM_N_DEFINED 1 -#define XED_NONTERMINAL_YMM_N3_DEFINED 1 -#define XED_NONTERMINAL_YMM_N3_32_DEFINED 1 -#define XED_NONTERMINAL_YMM_N3_64_DEFINED 1 -#define XED_NONTERMINAL_YMM_N_32_DEFINED 1 -#define XED_NONTERMINAL_YMM_N_64_DEFINED 1 -#define XED_NONTERMINAL_YMM_R_DEFINED 1 -#define XED_NONTERMINAL_YMM_R3_DEFINED 1 -#define XED_NONTERMINAL_YMM_R3_32_DEFINED 1 -#define XED_NONTERMINAL_YMM_R3_64_DEFINED 1 -#define XED_NONTERMINAL_YMM_R_32_DEFINED 1 -#define XED_NONTERMINAL_YMM_R_64_DEFINED 1 -#define XED_NONTERMINAL_YMM_SE_DEFINED 1 -#define XED_NONTERMINAL_YMM_SE32_DEFINED 1 -#define XED_NONTERMINAL_YMM_SE64_DEFINED 1 -#define XED_NONTERMINAL_ZMM_B3_DEFINED 1 -#define XED_NONTERMINAL_ZMM_B3_32_DEFINED 1 -#define XED_NONTERMINAL_ZMM_B3_64_DEFINED 1 -#define XED_NONTERMINAL_ZMM_N3_DEFINED 1 -#define XED_NONTERMINAL_ZMM_N3_32_DEFINED 1 -#define XED_NONTERMINAL_ZMM_N3_64_DEFINED 1 -#define XED_NONTERMINAL_ZMM_R3_DEFINED 1 -#define XED_NONTERMINAL_ZMM_R3_32_DEFINED 1 -#define XED_NONTERMINAL_ZMM_R3_64_DEFINED 1 -#define XED_NONTERMINAL_LAST_DEFINED 1 -typedef enum { - XED_NONTERMINAL_INVALID, - XED_NONTERMINAL_AR10, - XED_NONTERMINAL_AR11, - XED_NONTERMINAL_AR12, - XED_NONTERMINAL_AR13, - XED_NONTERMINAL_AR14, - XED_NONTERMINAL_AR15, - XED_NONTERMINAL_AR8, - XED_NONTERMINAL_AR9, - XED_NONTERMINAL_ARAX, - XED_NONTERMINAL_ARBP, - XED_NONTERMINAL_ARBX, - XED_NONTERMINAL_ARCX, - XED_NONTERMINAL_ARDI, - XED_NONTERMINAL_ARDX, - XED_NONTERMINAL_ARSI, - XED_NONTERMINAL_ARSP, - XED_NONTERMINAL_ASZ_NONTERM, - XED_NONTERMINAL_AVX512_ROUND, - XED_NONTERMINAL_AVX_INSTRUCTIONS, - XED_NONTERMINAL_AVX_SPLITTER, - XED_NONTERMINAL_A_GPR_B, - XED_NONTERMINAL_A_GPR_R, - XED_NONTERMINAL_BND_B, - XED_NONTERMINAL_BND_B_CHECK, - XED_NONTERMINAL_BND_R, - XED_NONTERMINAL_BND_R_CHECK, - XED_NONTERMINAL_BRANCH_HINT, - XED_NONTERMINAL_BRDISP32, - XED_NONTERMINAL_BRDISP8, - XED_NONTERMINAL_BRDISPZ, - XED_NONTERMINAL_CET_NO_TRACK, - XED_NONTERMINAL_CR_B, - XED_NONTERMINAL_CR_R, - XED_NONTERMINAL_CR_WIDTH, - XED_NONTERMINAL_DF64, - XED_NONTERMINAL_DR_R, - XED_NONTERMINAL_ESIZE_128_BITS, - XED_NONTERMINAL_ESIZE_16_BITS, - XED_NONTERMINAL_ESIZE_1_BITS, - XED_NONTERMINAL_ESIZE_2_BITS, - XED_NONTERMINAL_ESIZE_32_BITS, - XED_NONTERMINAL_ESIZE_4_BITS, - XED_NONTERMINAL_ESIZE_64_BITS, - XED_NONTERMINAL_ESIZE_8_BITS, - XED_NONTERMINAL_EVEX_INSTRUCTIONS, - XED_NONTERMINAL_EVEX_SPLITTER, - XED_NONTERMINAL_FINAL_DSEG, - XED_NONTERMINAL_FINAL_DSEG1, - XED_NONTERMINAL_FINAL_DSEG1_MODE64, - XED_NONTERMINAL_FINAL_DSEG1_NOT64, - XED_NONTERMINAL_FINAL_DSEG_MODE64, - XED_NONTERMINAL_FINAL_DSEG_NOT64, - XED_NONTERMINAL_FINAL_ESEG, - XED_NONTERMINAL_FINAL_ESEG1, - XED_NONTERMINAL_FINAL_SSEG, - XED_NONTERMINAL_FINAL_SSEG0, - XED_NONTERMINAL_FINAL_SSEG1, - XED_NONTERMINAL_FINAL_SSEG_MODE64, - XED_NONTERMINAL_FINAL_SSEG_NOT64, - XED_NONTERMINAL_FIX_ROUND_LEN128, - XED_NONTERMINAL_FIX_ROUND_LEN512, - XED_NONTERMINAL_FORCE64, - XED_NONTERMINAL_GPR16_B, - XED_NONTERMINAL_GPR16_R, - XED_NONTERMINAL_GPR16_SB, - XED_NONTERMINAL_GPR32_B, - XED_NONTERMINAL_GPR32_R, - XED_NONTERMINAL_GPR32_SB, - XED_NONTERMINAL_GPR32_X, - XED_NONTERMINAL_GPR64_B, - XED_NONTERMINAL_GPR64_R, - XED_NONTERMINAL_GPR64_SB, - XED_NONTERMINAL_GPR64_X, - XED_NONTERMINAL_GPR8_B, - XED_NONTERMINAL_GPR8_R, - XED_NONTERMINAL_GPR8_SB, - XED_NONTERMINAL_GPRV_B, - XED_NONTERMINAL_GPRV_R, - XED_NONTERMINAL_GPRV_SB, - XED_NONTERMINAL_GPRY_B, - XED_NONTERMINAL_GPRY_R, - XED_NONTERMINAL_GPRZ_B, - XED_NONTERMINAL_GPRZ_R, - XED_NONTERMINAL_IGNORE66, - XED_NONTERMINAL_IMMUNE66, - XED_NONTERMINAL_IMMUNE66_LOOP64, - XED_NONTERMINAL_IMMUNE_REXW, - XED_NONTERMINAL_INSTRUCTIONS, - XED_NONTERMINAL_ISA, - XED_NONTERMINAL_MASK1, - XED_NONTERMINAL_MASKNOT0, - XED_NONTERMINAL_MASK_B, - XED_NONTERMINAL_MASK_N, - XED_NONTERMINAL_MASK_N32, - XED_NONTERMINAL_MASK_N64, - XED_NONTERMINAL_MASK_R, - XED_NONTERMINAL_MEMDISP, - XED_NONTERMINAL_MEMDISP16, - XED_NONTERMINAL_MEMDISP32, - XED_NONTERMINAL_MEMDISP8, - XED_NONTERMINAL_MEMDISPV, - XED_NONTERMINAL_MMX_B, - XED_NONTERMINAL_MMX_R, - XED_NONTERMINAL_MODRM, - XED_NONTERMINAL_MODRM16, - XED_NONTERMINAL_MODRM32, - XED_NONTERMINAL_MODRM64ALT32, - XED_NONTERMINAL_NELEM_EIGHTHMEM, - XED_NONTERMINAL_NELEM_FULL, - XED_NONTERMINAL_NELEM_FULLMEM, - XED_NONTERMINAL_NELEM_GPR_READER, - XED_NONTERMINAL_NELEM_GPR_READER_BYTE, - XED_NONTERMINAL_NELEM_GPR_READER_SUBDWORD, - XED_NONTERMINAL_NELEM_GPR_READER_WORD, - XED_NONTERMINAL_NELEM_GPR_WRITER_LDOP, - XED_NONTERMINAL_NELEM_GPR_WRITER_LDOP_D, - XED_NONTERMINAL_NELEM_GPR_WRITER_LDOP_Q, - XED_NONTERMINAL_NELEM_GPR_WRITER_STORE, - XED_NONTERMINAL_NELEM_GPR_WRITER_STORE_BYTE, - XED_NONTERMINAL_NELEM_GPR_WRITER_STORE_SUBDWORD, - XED_NONTERMINAL_NELEM_GPR_WRITER_STORE_WORD, - XED_NONTERMINAL_NELEM_GSCAT, - XED_NONTERMINAL_NELEM_HALF, - XED_NONTERMINAL_NELEM_HALFMEM, - XED_NONTERMINAL_NELEM_MEM128, - XED_NONTERMINAL_NELEM_MOVDDUP, - XED_NONTERMINAL_NELEM_QUARTER, - XED_NONTERMINAL_NELEM_QUARTERMEM, - XED_NONTERMINAL_NELEM_SCALAR, - XED_NONTERMINAL_NELEM_TUPLE1, - XED_NONTERMINAL_NELEM_TUPLE1_4X, - XED_NONTERMINAL_NELEM_TUPLE1_BYTE, - XED_NONTERMINAL_NELEM_TUPLE1_SUBDWORD, - XED_NONTERMINAL_NELEM_TUPLE1_WORD, - XED_NONTERMINAL_NELEM_TUPLE2, - XED_NONTERMINAL_NELEM_TUPLE4, - XED_NONTERMINAL_NELEM_TUPLE8, - XED_NONTERMINAL_OEAX, - XED_NONTERMINAL_ONE, - XED_NONTERMINAL_ORAX, - XED_NONTERMINAL_ORBP, - XED_NONTERMINAL_ORBX, - XED_NONTERMINAL_ORCX, - XED_NONTERMINAL_ORDX, - XED_NONTERMINAL_ORSP, - XED_NONTERMINAL_OSZ_NONTERM, - XED_NONTERMINAL_OVERRIDE_SEG0, - XED_NONTERMINAL_OVERRIDE_SEG1, - XED_NONTERMINAL_PREFIXES, - XED_NONTERMINAL_REFINING66, - XED_NONTERMINAL_REMOVE_SEGMENT, - XED_NONTERMINAL_RFLAGS, - XED_NONTERMINAL_RIP, - XED_NONTERMINAL_RIPA, - XED_NONTERMINAL_SAE, - XED_NONTERMINAL_SEG, - XED_NONTERMINAL_SEG_MOV, - XED_NONTERMINAL_SE_IMM8, - XED_NONTERMINAL_SIB, - XED_NONTERMINAL_SIB_BASE0, - XED_NONTERMINAL_SIMM8, - XED_NONTERMINAL_SIMMZ, - XED_NONTERMINAL_SRBP, - XED_NONTERMINAL_SRSP, - XED_NONTERMINAL_TMM_B, - XED_NONTERMINAL_TMM_N, - XED_NONTERMINAL_TMM_R, - XED_NONTERMINAL_UIMM16, - XED_NONTERMINAL_UIMM32, - XED_NONTERMINAL_UIMM8, - XED_NONTERMINAL_UIMM8_1, - XED_NONTERMINAL_UIMMV, - XED_NONTERMINAL_UISA_VMODRM_XMM, - XED_NONTERMINAL_UISA_VMODRM_YMM, - XED_NONTERMINAL_UISA_VMODRM_ZMM, - XED_NONTERMINAL_UISA_VSIB_BASE, - XED_NONTERMINAL_UISA_VSIB_INDEX_XMM, - XED_NONTERMINAL_UISA_VSIB_INDEX_YMM, - XED_NONTERMINAL_UISA_VSIB_INDEX_ZMM, - XED_NONTERMINAL_UISA_VSIB_XMM, - XED_NONTERMINAL_UISA_VSIB_YMM, - XED_NONTERMINAL_UISA_VSIB_ZMM, - XED_NONTERMINAL_VGPR32_B, - XED_NONTERMINAL_VGPR32_B_32, - XED_NONTERMINAL_VGPR32_B_64, - XED_NONTERMINAL_VGPR32_N, - XED_NONTERMINAL_VGPR32_N_32, - XED_NONTERMINAL_VGPR32_N_64, - XED_NONTERMINAL_VGPR32_R, - XED_NONTERMINAL_VGPR32_R_32, - XED_NONTERMINAL_VGPR32_R_64, - XED_NONTERMINAL_VGPR64_B, - XED_NONTERMINAL_VGPR64_N, - XED_NONTERMINAL_VGPR64_R, - XED_NONTERMINAL_VGPRY_B, - XED_NONTERMINAL_VGPRY_N, - XED_NONTERMINAL_VGPRY_R, - XED_NONTERMINAL_VMODRM_XMM, - XED_NONTERMINAL_VMODRM_YMM, - XED_NONTERMINAL_VSIB_BASE, - XED_NONTERMINAL_VSIB_INDEX_XMM, - XED_NONTERMINAL_VSIB_INDEX_YMM, - XED_NONTERMINAL_VSIB_XMM, - XED_NONTERMINAL_VSIB_YMM, - XED_NONTERMINAL_X87, - XED_NONTERMINAL_XMM_B, - XED_NONTERMINAL_XMM_B3, - XED_NONTERMINAL_XMM_B3_32, - XED_NONTERMINAL_XMM_B3_64, - XED_NONTERMINAL_XMM_B_32, - XED_NONTERMINAL_XMM_B_64, - XED_NONTERMINAL_XMM_N, - XED_NONTERMINAL_XMM_N3, - XED_NONTERMINAL_XMM_N3_32, - XED_NONTERMINAL_XMM_N3_64, - XED_NONTERMINAL_XMM_N_32, - XED_NONTERMINAL_XMM_N_64, - XED_NONTERMINAL_XMM_R, - XED_NONTERMINAL_XMM_R3, - XED_NONTERMINAL_XMM_R3_32, - XED_NONTERMINAL_XMM_R3_64, - XED_NONTERMINAL_XMM_R_32, - XED_NONTERMINAL_XMM_R_64, - XED_NONTERMINAL_XMM_SE, - XED_NONTERMINAL_XMM_SE32, - XED_NONTERMINAL_XMM_SE64, - XED_NONTERMINAL_XOP_INSTRUCTIONS, - XED_NONTERMINAL_YMM_B, - XED_NONTERMINAL_YMM_B3, - XED_NONTERMINAL_YMM_B3_32, - XED_NONTERMINAL_YMM_B3_64, - XED_NONTERMINAL_YMM_B_32, - XED_NONTERMINAL_YMM_B_64, - XED_NONTERMINAL_YMM_N, - XED_NONTERMINAL_YMM_N3, - XED_NONTERMINAL_YMM_N3_32, - XED_NONTERMINAL_YMM_N3_64, - XED_NONTERMINAL_YMM_N_32, - XED_NONTERMINAL_YMM_N_64, - XED_NONTERMINAL_YMM_R, - XED_NONTERMINAL_YMM_R3, - XED_NONTERMINAL_YMM_R3_32, - XED_NONTERMINAL_YMM_R3_64, - XED_NONTERMINAL_YMM_R_32, - XED_NONTERMINAL_YMM_R_64, - XED_NONTERMINAL_YMM_SE, - XED_NONTERMINAL_YMM_SE32, - XED_NONTERMINAL_YMM_SE64, - XED_NONTERMINAL_ZMM_B3, - XED_NONTERMINAL_ZMM_B3_32, - XED_NONTERMINAL_ZMM_B3_64, - XED_NONTERMINAL_ZMM_N3, - XED_NONTERMINAL_ZMM_N3_32, - XED_NONTERMINAL_ZMM_N3_64, - XED_NONTERMINAL_ZMM_R3, - XED_NONTERMINAL_ZMM_R3_32, - XED_NONTERMINAL_ZMM_R3_64, - XED_NONTERMINAL_LAST -} xed_nonterminal_enum_t; - -/// This converts strings to #xed_nonterminal_enum_t types. -/// @param s A C-string. -/// @return #xed_nonterminal_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_nonterminal_enum_t str2xed_nonterminal_enum_t(const char* s); -/// This converts strings to #xed_nonterminal_enum_t types. -/// @param p An enumeration element of type xed_nonterminal_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_nonterminal_enum_t2str(const xed_nonterminal_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_nonterminal_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_nonterminal_enum_t xed_nonterminal_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-operand-accessors.h b/target/i386/latx/include/xed/xed-operand-accessors.h deleted file mode 100644 index 06eab3756e6..00000000000 --- a/target/i386/latx/include/xed/xed-operand-accessors.h +++ /dev/null @@ -1,1543 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-accessors.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_ACCESSORS_H) -# define XED_OPERAND_ACCESSORS_H -#include "xed-decoded-inst.h" -#include "xed-operand-storage.h" -static XED_INLINE xed_bits_t xed3_operand_get_seg_ovd(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_seg_ovd(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_hint(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_hint(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_encode_force(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_encode_force(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_lock(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_lock(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_need_memdisp(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_need_memdisp(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_int64_t xed3_operand_get_disp(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_disp(xed_decoded_inst_t* d, xed_int64_t opval); - -static XED_INLINE xed_uint8_t xed3_operand_get_disp_width(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_disp_width(xed_decoded_inst_t* d, xed_uint8_t opval); - -static XED_INLINE xed_uint8_t xed3_operand_get_brdisp_width(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_brdisp_width(xed_decoded_inst_t* d, xed_uint8_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_df32(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_df32(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_df64(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_df64(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_norex(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_norex(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_needrex(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_needrex(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_rex(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_rex(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_rexw(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_rexw(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_rexr(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_rexr(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_rexx(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_rexx(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_rexb(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_rexb(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_rep(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_rep(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_osz(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_osz(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_prefix66(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_prefix66(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_asz(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_asz(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_eosz(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_eosz(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_easz(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_easz(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_mod(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_mod(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_reg(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_reg(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_srm(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_srm(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_rm(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_rm(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_realmode(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_realmode(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_chip_enum_t xed3_operand_get_chip(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_chip(xed_decoded_inst_t* d, xed_chip_enum_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_mode(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_mode(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_smode(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_smode(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_modep5(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_modep5(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_modep55c(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_modep55c(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_p4(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_p4(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_lzcnt(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_lzcnt(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_tzcnt(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_tzcnt(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_mode_first_prefix(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_mode_first_prefix(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_mode_short_ud0(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_mode_short_ud0(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_imm0(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_imm0(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_imm1(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_imm1(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_imm0signed(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_imm0signed(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_uint64_t xed3_operand_get_uimm0(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_uimm0(xed_decoded_inst_t* d, xed_uint64_t opval); - -static XED_INLINE xed_uint8_t xed3_operand_get_uimm1(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_uimm1(xed_decoded_inst_t* d, xed_uint8_t opval); - -static XED_INLINE xed_uint8_t xed3_operand_get_imm_width(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_imm_width(xed_decoded_inst_t* d, xed_uint8_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_using_default_segment0(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_using_default_segment0(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_using_default_segment1(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_using_default_segment1(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_default_seg(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_default_seg(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_seg0(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_seg0(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_base0(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_base0(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_index(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_index(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_scale(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_scale(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_need_sib(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_need_sib(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_sibscale(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_sibscale(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_sibbase(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_sibbase(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_sibindex(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_sibindex(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_seg1(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_seg1(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_base1(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_base1(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_mem0(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_mem0(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_mem1(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_mem1(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_uint16_t xed3_operand_get_mem_width(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_mem_width(xed_decoded_inst_t* d, xed_uint16_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_agen(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_agen(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_relbr(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_relbr(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_ptr(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_ptr(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg0(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_reg0(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg1(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_reg1(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg2(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_reg2(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg3(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_reg3(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg4(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_reg4(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg5(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_reg5(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg6(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_reg6(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg7(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_reg7(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg8(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_reg8(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg9(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_reg9(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_reg_enum_t xed3_operand_get_outreg(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_outreg(xed_decoded_inst_t* d, xed_reg_enum_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_encoder_preferred(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_encoder_preferred(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_error_enum_t xed3_operand_get_error(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_error(xed_decoded_inst_t* d, xed_error_enum_t opval); - -static XED_INLINE xed_iclass_enum_t xed3_operand_get_iclass(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_iclass(xed_decoded_inst_t* d, xed_iclass_enum_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_nelem(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_nelem(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_element_size(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_element_size(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_map(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_map(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_out_of_bytes(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_out_of_bytes(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_first_f2f3(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_first_f2f3(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_last_f2f3(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_last_f2f3(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_ild_f2(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_ild_f2(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_ild_f3(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_ild_f3(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_max_bytes(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_max_bytes(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_ild_seg(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_ild_seg(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_nseg_prefixes(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_nseg_prefixes(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_nrexes(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_nrexes(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_nprefixes(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_nprefixes(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_nominal_opcode(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_nominal_opcode(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_pos_nominal_opcode(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_pos_nominal_opcode(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_has_modrm(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_has_modrm(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_has_sib(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_has_sib(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_pos_modrm(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_pos_modrm(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_pos_sib(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_pos_sib(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_pos_disp(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_pos_disp(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_pos_imm(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_pos_imm(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_pos_imm1(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_pos_imm1(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_imm1_bytes(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_imm1_bytes(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_modrm_byte(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_modrm_byte(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_esrc(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_esrc(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_vexvalid(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_vexvalid(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_dummy(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_dummy(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_amd3dnow(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_amd3dnow(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_mpxmode(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_mpxmode(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_cet(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_cet(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_cldemote(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_cldemote(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_vexdest3(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_vexdest3(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_vexdest210(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_vexdest210(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_vl(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_vl(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_vex_prefix(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_vex_prefix(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_vex_c4(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_vex_c4(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_bcast(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_bcast(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_must_use_evex(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_must_use_evex(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_zeroing(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_zeroing(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_llrc(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_llrc(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_bcrc(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_bcrc(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_rexrr(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_rexrr(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_vexdest4(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_vexdest4(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_mask(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_mask(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_roundc(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_roundc(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_sae(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_sae(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_no_scale_disp8(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_no_scale_disp8(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_ubit(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_ubit(xed_decoded_inst_t* d, xed_bits_t opval); - -static XED_INLINE xed_bits_t xed3_operand_get_wbnoinvd(const xed_decoded_inst_t* d); - -static XED_INLINE void xed3_operand_set_wbnoinvd(xed_decoded_inst_t* d, xed_bits_t opval); - -XED_DLL_EXPORT void xed3_get_generic_operand(const xed_decoded_inst_t* d, xed_operand_enum_t operand, void* ret_arg); - -XED_DLL_EXPORT void xed3_set_generic_operand(xed_decoded_inst_t* d, xed_operand_enum_t operand, xed_uint32_t val); - -static XED_INLINE xed_bits_t xed3_operand_get_seg_ovd(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.seg_ovd; -} -static XED_INLINE void xed3_operand_set_seg_ovd(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.seg_ovd = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_hint(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.hint; -} -static XED_INLINE void xed3_operand_set_hint(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.hint = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_encode_force(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.encode_force; -} -static XED_INLINE void xed3_operand_set_encode_force(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.encode_force = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_lock(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.lock; -} -static XED_INLINE void xed3_operand_set_lock(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.lock = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_need_memdisp(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.need_memdisp; -} -static XED_INLINE void xed3_operand_set_need_memdisp(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.need_memdisp = (xed_uint8_t)opval; -} -static XED_INLINE xed_int64_t xed3_operand_get_disp(const xed_decoded_inst_t* d) -{ -return (xed_int64_t)d->_operands.disp; -} -static XED_INLINE void xed3_operand_set_disp(xed_decoded_inst_t* d, xed_int64_t opval) -{ -d->_operands.disp = (xed_uint64_t)opval; -} -static XED_INLINE xed_uint8_t xed3_operand_get_disp_width(const xed_decoded_inst_t* d) -{ -return (xed_uint8_t)d->_operands.disp_width; -} -static XED_INLINE void xed3_operand_set_disp_width(xed_decoded_inst_t* d, xed_uint8_t opval) -{ -d->_operands.disp_width = (xed_uint8_t)opval; -} -static XED_INLINE xed_uint8_t xed3_operand_get_brdisp_width(const xed_decoded_inst_t* d) -{ -return (xed_uint8_t)d->_operands.brdisp_width; -} -static XED_INLINE void xed3_operand_set_brdisp_width(xed_decoded_inst_t* d, xed_uint8_t opval) -{ -d->_operands.brdisp_width = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_df32(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.df32; -} -static XED_INLINE void xed3_operand_set_df32(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.df32 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_df64(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.df64; -} -static XED_INLINE void xed3_operand_set_df64(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.df64 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_norex(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.norex; -} -static XED_INLINE void xed3_operand_set_norex(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.norex = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_needrex(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.needrex; -} -static XED_INLINE void xed3_operand_set_needrex(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.needrex = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_rex(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.rex; -} -static XED_INLINE void xed3_operand_set_rex(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.rex = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_rexw(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.rexw; -} -static XED_INLINE void xed3_operand_set_rexw(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.rexw = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_rexr(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.rexr; -} -static XED_INLINE void xed3_operand_set_rexr(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.rexr = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_rexx(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.rexx; -} -static XED_INLINE void xed3_operand_set_rexx(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.rexx = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_rexb(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.rexb; -} -static XED_INLINE void xed3_operand_set_rexb(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.rexb = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_rep(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.rep; -} -static XED_INLINE void xed3_operand_set_rep(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.rep = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_osz(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.osz; -} -static XED_INLINE void xed3_operand_set_osz(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.osz = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_prefix66(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.prefix66; -} -static XED_INLINE void xed3_operand_set_prefix66(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.prefix66 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_asz(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.asz; -} -static XED_INLINE void xed3_operand_set_asz(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.asz = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_eosz(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.eosz; -} -static XED_INLINE void xed3_operand_set_eosz(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.eosz = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_easz(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.easz; -} -static XED_INLINE void xed3_operand_set_easz(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.easz = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_mod(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.mod; -} -static XED_INLINE void xed3_operand_set_mod(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.mod = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_reg(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.reg; -} -static XED_INLINE void xed3_operand_set_reg(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.reg = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_srm(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.srm; -} -static XED_INLINE void xed3_operand_set_srm(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.srm = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_rm(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.rm; -} -static XED_INLINE void xed3_operand_set_rm(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.rm = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_realmode(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.realmode; -} -static XED_INLINE void xed3_operand_set_realmode(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.realmode = (xed_uint8_t)opval; -} -static XED_INLINE xed_chip_enum_t xed3_operand_get_chip(const xed_decoded_inst_t* d) -{ -return (xed_chip_enum_t)d->_operands.chip; -} -static XED_INLINE void xed3_operand_set_chip(xed_decoded_inst_t* d, xed_chip_enum_t opval) -{ -d->_operands.chip = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_mode(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.mode; -} -static XED_INLINE void xed3_operand_set_mode(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.mode = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_smode(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.smode; -} -static XED_INLINE void xed3_operand_set_smode(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.smode = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_modep5(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.modep5; -} -static XED_INLINE void xed3_operand_set_modep5(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.modep5 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_modep55c(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.modep55c; -} -static XED_INLINE void xed3_operand_set_modep55c(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.modep55c = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_p4(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.p4; -} -static XED_INLINE void xed3_operand_set_p4(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.p4 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_lzcnt(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.lzcnt; -} -static XED_INLINE void xed3_operand_set_lzcnt(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.lzcnt = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_tzcnt(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.tzcnt; -} -static XED_INLINE void xed3_operand_set_tzcnt(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.tzcnt = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_mode_first_prefix(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.mode_first_prefix; -} -static XED_INLINE void xed3_operand_set_mode_first_prefix(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.mode_first_prefix = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_mode_short_ud0(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.mode_short_ud0; -} -static XED_INLINE void xed3_operand_set_mode_short_ud0(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.mode_short_ud0 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_imm0(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.imm0; -} -static XED_INLINE void xed3_operand_set_imm0(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.imm0 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_imm1(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.imm1; -} -static XED_INLINE void xed3_operand_set_imm1(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.imm1 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_imm0signed(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.imm0signed; -} -static XED_INLINE void xed3_operand_set_imm0signed(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.imm0signed = (xed_uint8_t)opval; -} -static XED_INLINE xed_uint64_t xed3_operand_get_uimm0(const xed_decoded_inst_t* d) -{ -return (xed_uint64_t)d->_operands.uimm0; -} -static XED_INLINE void xed3_operand_set_uimm0(xed_decoded_inst_t* d, xed_uint64_t opval) -{ -d->_operands.uimm0 = (xed_uint64_t)opval; -} -static XED_INLINE xed_uint8_t xed3_operand_get_uimm1(const xed_decoded_inst_t* d) -{ -return (xed_uint8_t)d->_operands.uimm1; -} -static XED_INLINE void xed3_operand_set_uimm1(xed_decoded_inst_t* d, xed_uint8_t opval) -{ -d->_operands.uimm1 = (xed_uint8_t)opval; -} -static XED_INLINE xed_uint8_t xed3_operand_get_imm_width(const xed_decoded_inst_t* d) -{ -return (xed_uint8_t)d->_operands.imm_width; -} -static XED_INLINE void xed3_operand_set_imm_width(xed_decoded_inst_t* d, xed_uint8_t opval) -{ -d->_operands.imm_width = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_using_default_segment0(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.using_default_segment0; -} -static XED_INLINE void xed3_operand_set_using_default_segment0(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.using_default_segment0 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_using_default_segment1(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.using_default_segment1; -} -static XED_INLINE void xed3_operand_set_using_default_segment1(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.using_default_segment1 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_default_seg(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.default_seg; -} -static XED_INLINE void xed3_operand_set_default_seg(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.default_seg = (xed_uint8_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_seg0(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.seg0; -} -static XED_INLINE void xed3_operand_set_seg0(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.seg0 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_base0(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.base0; -} -static XED_INLINE void xed3_operand_set_base0(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.base0 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_index(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.index; -} -static XED_INLINE void xed3_operand_set_index(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.index = (xed_uint16_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_scale(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.scale; -} -static XED_INLINE void xed3_operand_set_scale(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.scale = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_need_sib(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.need_sib; -} -static XED_INLINE void xed3_operand_set_need_sib(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.need_sib = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_sibscale(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.sibscale; -} -static XED_INLINE void xed3_operand_set_sibscale(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.sibscale = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_sibbase(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.sibbase; -} -static XED_INLINE void xed3_operand_set_sibbase(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.sibbase = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_sibindex(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.sibindex; -} -static XED_INLINE void xed3_operand_set_sibindex(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.sibindex = (xed_uint8_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_seg1(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.seg1; -} -static XED_INLINE void xed3_operand_set_seg1(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.seg1 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_base1(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.base1; -} -static XED_INLINE void xed3_operand_set_base1(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.base1 = (xed_uint16_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_mem0(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.mem0; -} -static XED_INLINE void xed3_operand_set_mem0(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.mem0 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_mem1(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.mem1; -} -static XED_INLINE void xed3_operand_set_mem1(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.mem1 = (xed_uint8_t)opval; -} -static XED_INLINE xed_uint16_t xed3_operand_get_mem_width(const xed_decoded_inst_t* d) -{ -return (xed_uint16_t)d->_operands.mem_width; -} -static XED_INLINE void xed3_operand_set_mem_width(xed_decoded_inst_t* d, xed_uint16_t opval) -{ -d->_operands.mem_width = (xed_uint16_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_agen(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.agen; -} -static XED_INLINE void xed3_operand_set_agen(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.agen = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_relbr(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.relbr; -} -static XED_INLINE void xed3_operand_set_relbr(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.relbr = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_ptr(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.ptr; -} -static XED_INLINE void xed3_operand_set_ptr(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.ptr = (xed_uint8_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg0(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.reg0; -} -static XED_INLINE void xed3_operand_set_reg0(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.reg0 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg1(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.reg1; -} -static XED_INLINE void xed3_operand_set_reg1(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.reg1 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg2(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.reg2; -} -static XED_INLINE void xed3_operand_set_reg2(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.reg2 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg3(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.reg3; -} -static XED_INLINE void xed3_operand_set_reg3(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.reg3 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg4(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.reg4; -} -static XED_INLINE void xed3_operand_set_reg4(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.reg4 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg5(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.reg5; -} -static XED_INLINE void xed3_operand_set_reg5(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.reg5 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg6(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.reg6; -} -static XED_INLINE void xed3_operand_set_reg6(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.reg6 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg7(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.reg7; -} -static XED_INLINE void xed3_operand_set_reg7(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.reg7 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg8(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.reg8; -} -static XED_INLINE void xed3_operand_set_reg8(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.reg8 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_reg9(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.reg9; -} -static XED_INLINE void xed3_operand_set_reg9(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.reg9 = (xed_uint16_t)opval; -} -static XED_INLINE xed_reg_enum_t xed3_operand_get_outreg(const xed_decoded_inst_t* d) -{ -return (xed_reg_enum_t)d->_operands.outreg; -} -static XED_INLINE void xed3_operand_set_outreg(xed_decoded_inst_t* d, xed_reg_enum_t opval) -{ -d->_operands.outreg = (xed_uint16_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_encoder_preferred(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.encoder_preferred; -} -static XED_INLINE void xed3_operand_set_encoder_preferred(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.encoder_preferred = (xed_uint8_t)opval; -} -static XED_INLINE xed_error_enum_t xed3_operand_get_error(const xed_decoded_inst_t* d) -{ -return (xed_error_enum_t)d->_operands.error; -} -static XED_INLINE void xed3_operand_set_error(xed_decoded_inst_t* d, xed_error_enum_t opval) -{ -d->_operands.error = (xed_uint8_t)opval; -} -static XED_INLINE xed_iclass_enum_t xed3_operand_get_iclass(const xed_decoded_inst_t* d) -{ -return (xed_iclass_enum_t)d->_operands.iclass; -} -static XED_INLINE void xed3_operand_set_iclass(xed_decoded_inst_t* d, xed_iclass_enum_t opval) -{ -d->_operands.iclass = (xed_uint16_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_nelem(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.nelem; -} -static XED_INLINE void xed3_operand_set_nelem(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.nelem = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_element_size(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.element_size; -} -static XED_INLINE void xed3_operand_set_element_size(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.element_size = (xed_uint16_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_map(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.map; -} -static XED_INLINE void xed3_operand_set_map(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.map = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_out_of_bytes(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.out_of_bytes; -} -static XED_INLINE void xed3_operand_set_out_of_bytes(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.out_of_bytes = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_first_f2f3(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.first_f2f3; -} -static XED_INLINE void xed3_operand_set_first_f2f3(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.first_f2f3 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_last_f2f3(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.last_f2f3; -} -static XED_INLINE void xed3_operand_set_last_f2f3(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.last_f2f3 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_ild_f2(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.ild_f2; -} -static XED_INLINE void xed3_operand_set_ild_f2(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.ild_f2 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_ild_f3(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.ild_f3; -} -static XED_INLINE void xed3_operand_set_ild_f3(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.ild_f3 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_max_bytes(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.max_bytes; -} -static XED_INLINE void xed3_operand_set_max_bytes(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.max_bytes = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_ild_seg(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.ild_seg; -} -static XED_INLINE void xed3_operand_set_ild_seg(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.ild_seg = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_nseg_prefixes(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.nseg_prefixes; -} -static XED_INLINE void xed3_operand_set_nseg_prefixes(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.nseg_prefixes = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_nrexes(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.nrexes; -} -static XED_INLINE void xed3_operand_set_nrexes(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.nrexes = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_nprefixes(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.nprefixes; -} -static XED_INLINE void xed3_operand_set_nprefixes(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.nprefixes = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_nominal_opcode(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.nominal_opcode; -} -static XED_INLINE void xed3_operand_set_nominal_opcode(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.nominal_opcode = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_pos_nominal_opcode(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.pos_nominal_opcode; -} -static XED_INLINE void xed3_operand_set_pos_nominal_opcode(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.pos_nominal_opcode = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_has_modrm(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.has_modrm; -} -static XED_INLINE void xed3_operand_set_has_modrm(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.has_modrm = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_has_sib(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.has_sib; -} -static XED_INLINE void xed3_operand_set_has_sib(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.has_sib = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_pos_modrm(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.pos_modrm; -} -static XED_INLINE void xed3_operand_set_pos_modrm(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.pos_modrm = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_pos_sib(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.pos_sib; -} -static XED_INLINE void xed3_operand_set_pos_sib(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.pos_sib = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_pos_disp(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.pos_disp; -} -static XED_INLINE void xed3_operand_set_pos_disp(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.pos_disp = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_pos_imm(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.pos_imm; -} -static XED_INLINE void xed3_operand_set_pos_imm(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.pos_imm = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_pos_imm1(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.pos_imm1; -} -static XED_INLINE void xed3_operand_set_pos_imm1(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.pos_imm1 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_imm1_bytes(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.imm1_bytes; -} -static XED_INLINE void xed3_operand_set_imm1_bytes(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.imm1_bytes = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_modrm_byte(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.modrm_byte; -} -static XED_INLINE void xed3_operand_set_modrm_byte(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.modrm_byte = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_esrc(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.esrc; -} -static XED_INLINE void xed3_operand_set_esrc(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.esrc = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_vexvalid(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.vexvalid; -} -static XED_INLINE void xed3_operand_set_vexvalid(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.vexvalid = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_dummy(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.dummy; -} -static XED_INLINE void xed3_operand_set_dummy(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.dummy = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_amd3dnow(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.amd3dnow; -} -static XED_INLINE void xed3_operand_set_amd3dnow(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.amd3dnow = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_mpxmode(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.mpxmode; -} -static XED_INLINE void xed3_operand_set_mpxmode(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.mpxmode = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_cet(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.cet; -} -static XED_INLINE void xed3_operand_set_cet(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.cet = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_cldemote(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.cldemote; -} -static XED_INLINE void xed3_operand_set_cldemote(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.cldemote = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_vexdest3(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.vexdest3; -} -static XED_INLINE void xed3_operand_set_vexdest3(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.vexdest3 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_vexdest210(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.vexdest210; -} -static XED_INLINE void xed3_operand_set_vexdest210(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.vexdest210 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_vl(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.vl; -} -static XED_INLINE void xed3_operand_set_vl(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.vl = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_vex_prefix(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.vex_prefix; -} -static XED_INLINE void xed3_operand_set_vex_prefix(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.vex_prefix = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_vex_c4(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.vex_c4; -} -static XED_INLINE void xed3_operand_set_vex_c4(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.vex_c4 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_bcast(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.bcast; -} -static XED_INLINE void xed3_operand_set_bcast(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.bcast = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_must_use_evex(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.must_use_evex; -} -static XED_INLINE void xed3_operand_set_must_use_evex(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.must_use_evex = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_zeroing(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.zeroing; -} -static XED_INLINE void xed3_operand_set_zeroing(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.zeroing = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_llrc(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.llrc; -} -static XED_INLINE void xed3_operand_set_llrc(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.llrc = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_bcrc(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.bcrc; -} -static XED_INLINE void xed3_operand_set_bcrc(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.bcrc = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_rexrr(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.rexrr; -} -static XED_INLINE void xed3_operand_set_rexrr(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.rexrr = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_vexdest4(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.vexdest4; -} -static XED_INLINE void xed3_operand_set_vexdest4(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.vexdest4 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_mask(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.mask; -} -static XED_INLINE void xed3_operand_set_mask(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.mask = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_roundc(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.roundc; -} -static XED_INLINE void xed3_operand_set_roundc(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.roundc = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_sae(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.sae; -} -static XED_INLINE void xed3_operand_set_sae(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.sae = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_no_scale_disp8(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.no_scale_disp8; -} -static XED_INLINE void xed3_operand_set_no_scale_disp8(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.no_scale_disp8 = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_ubit(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.ubit; -} -static XED_INLINE void xed3_operand_set_ubit(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.ubit = (xed_uint8_t)opval; -} -static XED_INLINE xed_bits_t xed3_operand_get_wbnoinvd(const xed_decoded_inst_t* d) -{ -return (xed_bits_t)d->_operands.wbnoinvd; -} -static XED_INLINE void xed3_operand_set_wbnoinvd(xed_decoded_inst_t* d, xed_bits_t opval) -{ -d->_operands.wbnoinvd = (xed_uint8_t)opval; -} -#endif diff --git a/target/i386/latx/include/xed/xed-operand-action-enum.h b/target/i386/latx/include/xed/xed-operand-action-enum.h deleted file mode 100644 index 9013ae8988d..00000000000 --- a/target/i386/latx/include/xed/xed-operand-action-enum.h +++ /dev/null @@ -1,62 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-action-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_ACTION_ENUM_H) -# define XED_OPERAND_ACTION_ENUM_H -#include "xed-common-hdrs.h" -#define XED_OPERAND_ACTION_INVALID_DEFINED 1 -#define XED_OPERAND_ACTION_RW_DEFINED 1 -#define XED_OPERAND_ACTION_R_DEFINED 1 -#define XED_OPERAND_ACTION_W_DEFINED 1 -#define XED_OPERAND_ACTION_RCW_DEFINED 1 -#define XED_OPERAND_ACTION_CW_DEFINED 1 -#define XED_OPERAND_ACTION_CRW_DEFINED 1 -#define XED_OPERAND_ACTION_CR_DEFINED 1 -#define XED_OPERAND_ACTION_LAST_DEFINED 1 -typedef enum { - XED_OPERAND_ACTION_INVALID, - XED_OPERAND_ACTION_RW, ///< Read and written (must write) - XED_OPERAND_ACTION_R, ///< Read-only - XED_OPERAND_ACTION_W, ///< Write-only (must write) - XED_OPERAND_ACTION_RCW, ///< Read and conditionlly written (may write) - XED_OPERAND_ACTION_CW, ///< Conditionlly written (may write) - XED_OPERAND_ACTION_CRW, ///< Conditionlly read, always written (must write) - XED_OPERAND_ACTION_CR, ///< Conditional read - XED_OPERAND_ACTION_LAST -} xed_operand_action_enum_t; - -/// This converts strings to #xed_operand_action_enum_t types. -/// @param s A C-string. -/// @return #xed_operand_action_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_action_enum_t str2xed_operand_action_enum_t(const char* s); -/// This converts strings to #xed_operand_action_enum_t types. -/// @param p An enumeration element of type xed_operand_action_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_operand_action_enum_t2str(const xed_operand_action_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_operand_action_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_action_enum_t xed_operand_action_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-operand-action.h b/target/i386/latx/include/xed/xed-operand-action.h deleted file mode 100644 index 4c90be8b8dc..00000000000 --- a/target/i386/latx/include/xed/xed-operand-action.h +++ /dev/null @@ -1,36 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-action.h -/// - -#if !defined(XED_OPERAND_ACTION_H) -# define XED_OPERAND_ACTION_H - -#include "xed-types.h" -#include "xed-operand-action-enum.h" - -XED_DLL_EXPORT xed_uint_t xed_operand_action_read(const xed_operand_action_enum_t rw); -XED_DLL_EXPORT xed_uint_t xed_operand_action_read_only(const xed_operand_action_enum_t rw); -XED_DLL_EXPORT xed_uint_t xed_operand_action_written(const xed_operand_action_enum_t rw); -XED_DLL_EXPORT xed_uint_t xed_operand_action_written_only(const xed_operand_action_enum_t rw); -XED_DLL_EXPORT xed_uint_t xed_operand_action_read_and_written(const xed_operand_action_enum_t rw); -XED_DLL_EXPORT xed_uint_t xed_operand_action_conditional_read(const xed_operand_action_enum_t rw); -XED_DLL_EXPORT xed_uint_t xed_operand_action_conditional_write(const xed_operand_action_enum_t rw); - -#endif - diff --git a/target/i386/latx/include/xed/xed-operand-convert-enum.h b/target/i386/latx/include/xed/xed-operand-convert-enum.h deleted file mode 100644 index 4426a216b45..00000000000 --- a/target/i386/latx/include/xed/xed-operand-convert-enum.h +++ /dev/null @@ -1,56 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-convert-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_CONVERT_ENUM_H) -# define XED_OPERAND_CONVERT_ENUM_H -#include "xed-common-hdrs.h" -#define XED_OPERAND_CONVERT_INVALID_DEFINED 1 -#define XED_OPERAND_CONVERT_ZEROSTR_DEFINED 1 -#define XED_OPERAND_CONVERT_SAESTR_DEFINED 1 -#define XED_OPERAND_CONVERT_ROUNDC_DEFINED 1 -#define XED_OPERAND_CONVERT_BCASTSTR_DEFINED 1 -#define XED_OPERAND_CONVERT_LAST_DEFINED 1 -typedef enum { - XED_OPERAND_CONVERT_INVALID, - XED_OPERAND_CONVERT_ZEROSTR, - XED_OPERAND_CONVERT_SAESTR, - XED_OPERAND_CONVERT_ROUNDC, - XED_OPERAND_CONVERT_BCASTSTR, - XED_OPERAND_CONVERT_LAST -} xed_operand_convert_enum_t; - -/// This converts strings to #xed_operand_convert_enum_t types. -/// @param s A C-string. -/// @return #xed_operand_convert_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_convert_enum_t str2xed_operand_convert_enum_t(const char* s); -/// This converts strings to #xed_operand_convert_enum_t types. -/// @param p An enumeration element of type xed_operand_convert_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_operand_convert_enum_t2str(const xed_operand_convert_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_operand_convert_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_convert_enum_t xed_operand_convert_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-operand-ctype-enum.h b/target/i386/latx/include/xed/xed-operand-ctype-enum.h deleted file mode 100644 index 023ec55b972..00000000000 --- a/target/i386/latx/include/xed/xed-operand-ctype-enum.h +++ /dev/null @@ -1,66 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-ctype-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_CTYPE_ENUM_H) -# define XED_OPERAND_CTYPE_ENUM_H -#include "xed-common-hdrs.h" -#define XED_OPERAND_CTYPE_INVALID_DEFINED 1 -#define XED_OPERAND_CTYPE_XED_BITS_T_DEFINED 1 -#define XED_OPERAND_CTYPE_XED_CHIP_ENUM_T_DEFINED 1 -#define XED_OPERAND_CTYPE_XED_ERROR_ENUM_T_DEFINED 1 -#define XED_OPERAND_CTYPE_XED_ICLASS_ENUM_T_DEFINED 1 -#define XED_OPERAND_CTYPE_XED_INT64_T_DEFINED 1 -#define XED_OPERAND_CTYPE_XED_REG_ENUM_T_DEFINED 1 -#define XED_OPERAND_CTYPE_XED_UINT16_T_DEFINED 1 -#define XED_OPERAND_CTYPE_XED_UINT64_T_DEFINED 1 -#define XED_OPERAND_CTYPE_XED_UINT8_T_DEFINED 1 -#define XED_OPERAND_CTYPE_LAST_DEFINED 1 -typedef enum { - XED_OPERAND_CTYPE_INVALID, - XED_OPERAND_CTYPE_XED_BITS_T, - XED_OPERAND_CTYPE_XED_CHIP_ENUM_T, - XED_OPERAND_CTYPE_XED_ERROR_ENUM_T, - XED_OPERAND_CTYPE_XED_ICLASS_ENUM_T, - XED_OPERAND_CTYPE_XED_INT64_T, - XED_OPERAND_CTYPE_XED_REG_ENUM_T, - XED_OPERAND_CTYPE_XED_UINT16_T, - XED_OPERAND_CTYPE_XED_UINT64_T, - XED_OPERAND_CTYPE_XED_UINT8_T, - XED_OPERAND_CTYPE_LAST -} xed_operand_ctype_enum_t; - -/// This converts strings to #xed_operand_ctype_enum_t types. -/// @param s A C-string. -/// @return #xed_operand_ctype_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_ctype_enum_t str2xed_operand_ctype_enum_t(const char* s); -/// This converts strings to #xed_operand_ctype_enum_t types. -/// @param p An enumeration element of type xed_operand_ctype_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_operand_ctype_enum_t2str(const xed_operand_ctype_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_operand_ctype_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_ctype_enum_t xed_operand_ctype_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-operand-ctype-map.h b/target/i386/latx/include/xed/xed-operand-ctype-map.h deleted file mode 100644 index 13fe38b65d1..00000000000 --- a/target/i386/latx/include/xed/xed-operand-ctype-map.h +++ /dev/null @@ -1,28 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-ctype-map.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_CTYPE_MAP_H) -# define XED_OPERAND_CTYPE_MAP_H -#include "xed-internal-header.h" -xed_operand_ctype_enum_t xed_operand_get_ctype(xed_operand_enum_t opname); -unsigned int xed_operand_decider_get_width(xed_operand_enum_t opname); -#endif diff --git a/target/i386/latx/include/xed/xed-operand-element-type-enum.h b/target/i386/latx/include/xed/xed-operand-element-type-enum.h deleted file mode 100644 index 8d321a143c4..00000000000 --- a/target/i386/latx/include/xed/xed-operand-element-type-enum.h +++ /dev/null @@ -1,68 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-element-type-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_ELEMENT_TYPE_ENUM_H) -# define XED_OPERAND_ELEMENT_TYPE_ENUM_H -#include "xed-common-hdrs.h" -#define XED_OPERAND_ELEMENT_TYPE_INVALID_DEFINED 1 -#define XED_OPERAND_ELEMENT_TYPE_UINT_DEFINED 1 -#define XED_OPERAND_ELEMENT_TYPE_INT_DEFINED 1 -#define XED_OPERAND_ELEMENT_TYPE_SINGLE_DEFINED 1 -#define XED_OPERAND_ELEMENT_TYPE_DOUBLE_DEFINED 1 -#define XED_OPERAND_ELEMENT_TYPE_LONGDOUBLE_DEFINED 1 -#define XED_OPERAND_ELEMENT_TYPE_LONGBCD_DEFINED 1 -#define XED_OPERAND_ELEMENT_TYPE_STRUCT_DEFINED 1 -#define XED_OPERAND_ELEMENT_TYPE_VARIABLE_DEFINED 1 -#define XED_OPERAND_ELEMENT_TYPE_FLOAT16_DEFINED 1 -#define XED_OPERAND_ELEMENT_TYPE_BFLOAT16_DEFINED 1 -#define XED_OPERAND_ELEMENT_TYPE_LAST_DEFINED 1 -typedef enum { - XED_OPERAND_ELEMENT_TYPE_INVALID, - XED_OPERAND_ELEMENT_TYPE_UINT, ///< Unsigned integer - XED_OPERAND_ELEMENT_TYPE_INT, ///< Signed integer - XED_OPERAND_ELEMENT_TYPE_SINGLE, ///< 32b FP single precision - XED_OPERAND_ELEMENT_TYPE_DOUBLE, ///< 64b FP double precision - XED_OPERAND_ELEMENT_TYPE_LONGDOUBLE, ///< 80b FP x87 - XED_OPERAND_ELEMENT_TYPE_LONGBCD, ///< 80b decimal BCD - XED_OPERAND_ELEMENT_TYPE_STRUCT, ///< a structure of various fields - XED_OPERAND_ELEMENT_TYPE_VARIABLE, ///< depends on other fields in the instruction - XED_OPERAND_ELEMENT_TYPE_FLOAT16, ///< 16b floating point - XED_OPERAND_ELEMENT_TYPE_BFLOAT16, ///< bfloat16 floating point - XED_OPERAND_ELEMENT_TYPE_LAST -} xed_operand_element_type_enum_t; - -/// This converts strings to #xed_operand_element_type_enum_t types. -/// @param s A C-string. -/// @return #xed_operand_element_type_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_element_type_enum_t str2xed_operand_element_type_enum_t(const char* s); -/// This converts strings to #xed_operand_element_type_enum_t types. -/// @param p An enumeration element of type xed_operand_element_type_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_operand_element_type_enum_t2str(const xed_operand_element_type_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_operand_element_type_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_element_type_enum_t xed_operand_element_type_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-operand-element-xtype-enum.h b/target/i386/latx/include/xed/xed-operand-element-xtype-enum.h deleted file mode 100644 index 1de7431f498..00000000000 --- a/target/i386/latx/include/xed/xed-operand-element-xtype-enum.h +++ /dev/null @@ -1,92 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-element-xtype-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_ELEMENT_XTYPE_ENUM_H) -# define XED_OPERAND_ELEMENT_XTYPE_ENUM_H -#include "xed-common-hdrs.h" -#define XED_OPERAND_XTYPE_INVALID_DEFINED 1 -#define XED_OPERAND_XTYPE_2F16_DEFINED 1 -#define XED_OPERAND_XTYPE_B80_DEFINED 1 -#define XED_OPERAND_XTYPE_BF16_DEFINED 1 -#define XED_OPERAND_XTYPE_F16_DEFINED 1 -#define XED_OPERAND_XTYPE_F32_DEFINED 1 -#define XED_OPERAND_XTYPE_F64_DEFINED 1 -#define XED_OPERAND_XTYPE_F80_DEFINED 1 -#define XED_OPERAND_XTYPE_I1_DEFINED 1 -#define XED_OPERAND_XTYPE_I16_DEFINED 1 -#define XED_OPERAND_XTYPE_I32_DEFINED 1 -#define XED_OPERAND_XTYPE_I64_DEFINED 1 -#define XED_OPERAND_XTYPE_I8_DEFINED 1 -#define XED_OPERAND_XTYPE_INT_DEFINED 1 -#define XED_OPERAND_XTYPE_STRUCT_DEFINED 1 -#define XED_OPERAND_XTYPE_U128_DEFINED 1 -#define XED_OPERAND_XTYPE_U16_DEFINED 1 -#define XED_OPERAND_XTYPE_U256_DEFINED 1 -#define XED_OPERAND_XTYPE_U32_DEFINED 1 -#define XED_OPERAND_XTYPE_U64_DEFINED 1 -#define XED_OPERAND_XTYPE_U8_DEFINED 1 -#define XED_OPERAND_XTYPE_UINT_DEFINED 1 -#define XED_OPERAND_XTYPE_VAR_DEFINED 1 -#define XED_OPERAND_XTYPE_LAST_DEFINED 1 -typedef enum { - XED_OPERAND_XTYPE_INVALID, - XED_OPERAND_XTYPE_2F16, - XED_OPERAND_XTYPE_B80, - XED_OPERAND_XTYPE_BF16, - XED_OPERAND_XTYPE_F16, - XED_OPERAND_XTYPE_F32, - XED_OPERAND_XTYPE_F64, - XED_OPERAND_XTYPE_F80, - XED_OPERAND_XTYPE_I1, - XED_OPERAND_XTYPE_I16, - XED_OPERAND_XTYPE_I32, - XED_OPERAND_XTYPE_I64, - XED_OPERAND_XTYPE_I8, - XED_OPERAND_XTYPE_INT, - XED_OPERAND_XTYPE_STRUCT, - XED_OPERAND_XTYPE_U128, - XED_OPERAND_XTYPE_U16, - XED_OPERAND_XTYPE_U256, - XED_OPERAND_XTYPE_U32, - XED_OPERAND_XTYPE_U64, - XED_OPERAND_XTYPE_U8, - XED_OPERAND_XTYPE_UINT, - XED_OPERAND_XTYPE_VAR, - XED_OPERAND_XTYPE_LAST -} xed_operand_element_xtype_enum_t; - -/// This converts strings to #xed_operand_element_xtype_enum_t types. -/// @param s A C-string. -/// @return #xed_operand_element_xtype_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_element_xtype_enum_t str2xed_operand_element_xtype_enum_t(const char* s); -/// This converts strings to #xed_operand_element_xtype_enum_t types. -/// @param p An enumeration element of type xed_operand_element_xtype_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_operand_element_xtype_enum_t2str(const xed_operand_element_xtype_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_operand_element_xtype_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_element_xtype_enum_t xed_operand_element_xtype_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-operand-enum.h b/target/i386/latx/include/xed/xed-operand-enum.h deleted file mode 100644 index c442ec8e3d4..00000000000 --- a/target/i386/latx/include/xed/xed-operand-enum.h +++ /dev/null @@ -1,300 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_ENUM_H) -# define XED_OPERAND_ENUM_H -#include "xed-common-hdrs.h" -#define XED_OPERAND_INVALID_DEFINED 1 -#define XED_OPERAND_AGEN_DEFINED 1 -#define XED_OPERAND_AMD3DNOW_DEFINED 1 -#define XED_OPERAND_ASZ_DEFINED 1 -#define XED_OPERAND_BASE0_DEFINED 1 -#define XED_OPERAND_BASE1_DEFINED 1 -#define XED_OPERAND_BCAST_DEFINED 1 -#define XED_OPERAND_BCRC_DEFINED 1 -#define XED_OPERAND_BRDISP_WIDTH_DEFINED 1 -#define XED_OPERAND_CET_DEFINED 1 -#define XED_OPERAND_CHIP_DEFINED 1 -#define XED_OPERAND_CLDEMOTE_DEFINED 1 -#define XED_OPERAND_DEFAULT_SEG_DEFINED 1 -#define XED_OPERAND_DF32_DEFINED 1 -#define XED_OPERAND_DF64_DEFINED 1 -#define XED_OPERAND_DISP_DEFINED 1 -#define XED_OPERAND_DISP_WIDTH_DEFINED 1 -#define XED_OPERAND_DUMMY_DEFINED 1 -#define XED_OPERAND_EASZ_DEFINED 1 -#define XED_OPERAND_ELEMENT_SIZE_DEFINED 1 -#define XED_OPERAND_ENCODER_PREFERRED_DEFINED 1 -#define XED_OPERAND_ENCODE_FORCE_DEFINED 1 -#define XED_OPERAND_EOSZ_DEFINED 1 -#define XED_OPERAND_ERROR_DEFINED 1 -#define XED_OPERAND_ESRC_DEFINED 1 -#define XED_OPERAND_FIRST_F2F3_DEFINED 1 -#define XED_OPERAND_HAS_MODRM_DEFINED 1 -#define XED_OPERAND_HAS_SIB_DEFINED 1 -#define XED_OPERAND_HINT_DEFINED 1 -#define XED_OPERAND_ICLASS_DEFINED 1 -#define XED_OPERAND_ILD_F2_DEFINED 1 -#define XED_OPERAND_ILD_F3_DEFINED 1 -#define XED_OPERAND_ILD_SEG_DEFINED 1 -#define XED_OPERAND_IMM0_DEFINED 1 -#define XED_OPERAND_IMM0SIGNED_DEFINED 1 -#define XED_OPERAND_IMM1_DEFINED 1 -#define XED_OPERAND_IMM1_BYTES_DEFINED 1 -#define XED_OPERAND_IMM_WIDTH_DEFINED 1 -#define XED_OPERAND_INDEX_DEFINED 1 -#define XED_OPERAND_LAST_F2F3_DEFINED 1 -#define XED_OPERAND_LLRC_DEFINED 1 -#define XED_OPERAND_LOCK_DEFINED 1 -#define XED_OPERAND_LZCNT_DEFINED 1 -#define XED_OPERAND_MAP_DEFINED 1 -#define XED_OPERAND_MASK_DEFINED 1 -#define XED_OPERAND_MAX_BYTES_DEFINED 1 -#define XED_OPERAND_MEM0_DEFINED 1 -#define XED_OPERAND_MEM1_DEFINED 1 -#define XED_OPERAND_MEM_WIDTH_DEFINED 1 -#define XED_OPERAND_MOD_DEFINED 1 -#define XED_OPERAND_MODE_DEFINED 1 -#define XED_OPERAND_MODEP5_DEFINED 1 -#define XED_OPERAND_MODEP55C_DEFINED 1 -#define XED_OPERAND_MODE_FIRST_PREFIX_DEFINED 1 -#define XED_OPERAND_MODE_SHORT_UD0_DEFINED 1 -#define XED_OPERAND_MODRM_BYTE_DEFINED 1 -#define XED_OPERAND_MPXMODE_DEFINED 1 -#define XED_OPERAND_MUST_USE_EVEX_DEFINED 1 -#define XED_OPERAND_NEEDREX_DEFINED 1 -#define XED_OPERAND_NEED_MEMDISP_DEFINED 1 -#define XED_OPERAND_NEED_SIB_DEFINED 1 -#define XED_OPERAND_NELEM_DEFINED 1 -#define XED_OPERAND_NOMINAL_OPCODE_DEFINED 1 -#define XED_OPERAND_NOREX_DEFINED 1 -#define XED_OPERAND_NO_SCALE_DISP8_DEFINED 1 -#define XED_OPERAND_NPREFIXES_DEFINED 1 -#define XED_OPERAND_NREXES_DEFINED 1 -#define XED_OPERAND_NSEG_PREFIXES_DEFINED 1 -#define XED_OPERAND_OSZ_DEFINED 1 -#define XED_OPERAND_OUTREG_DEFINED 1 -#define XED_OPERAND_OUT_OF_BYTES_DEFINED 1 -#define XED_OPERAND_P4_DEFINED 1 -#define XED_OPERAND_POS_DISP_DEFINED 1 -#define XED_OPERAND_POS_IMM_DEFINED 1 -#define XED_OPERAND_POS_IMM1_DEFINED 1 -#define XED_OPERAND_POS_MODRM_DEFINED 1 -#define XED_OPERAND_POS_NOMINAL_OPCODE_DEFINED 1 -#define XED_OPERAND_POS_SIB_DEFINED 1 -#define XED_OPERAND_PREFIX66_DEFINED 1 -#define XED_OPERAND_PTR_DEFINED 1 -#define XED_OPERAND_REALMODE_DEFINED 1 -#define XED_OPERAND_REG_DEFINED 1 -#define XED_OPERAND_REG0_DEFINED 1 -#define XED_OPERAND_REG1_DEFINED 1 -#define XED_OPERAND_REG2_DEFINED 1 -#define XED_OPERAND_REG3_DEFINED 1 -#define XED_OPERAND_REG4_DEFINED 1 -#define XED_OPERAND_REG5_DEFINED 1 -#define XED_OPERAND_REG6_DEFINED 1 -#define XED_OPERAND_REG7_DEFINED 1 -#define XED_OPERAND_REG8_DEFINED 1 -#define XED_OPERAND_REG9_DEFINED 1 -#define XED_OPERAND_RELBR_DEFINED 1 -#define XED_OPERAND_REP_DEFINED 1 -#define XED_OPERAND_REX_DEFINED 1 -#define XED_OPERAND_REXB_DEFINED 1 -#define XED_OPERAND_REXR_DEFINED 1 -#define XED_OPERAND_REXRR_DEFINED 1 -#define XED_OPERAND_REXW_DEFINED 1 -#define XED_OPERAND_REXX_DEFINED 1 -#define XED_OPERAND_RM_DEFINED 1 -#define XED_OPERAND_ROUNDC_DEFINED 1 -#define XED_OPERAND_SAE_DEFINED 1 -#define XED_OPERAND_SCALE_DEFINED 1 -#define XED_OPERAND_SEG0_DEFINED 1 -#define XED_OPERAND_SEG1_DEFINED 1 -#define XED_OPERAND_SEG_OVD_DEFINED 1 -#define XED_OPERAND_SIBBASE_DEFINED 1 -#define XED_OPERAND_SIBINDEX_DEFINED 1 -#define XED_OPERAND_SIBSCALE_DEFINED 1 -#define XED_OPERAND_SMODE_DEFINED 1 -#define XED_OPERAND_SRM_DEFINED 1 -#define XED_OPERAND_TZCNT_DEFINED 1 -#define XED_OPERAND_UBIT_DEFINED 1 -#define XED_OPERAND_UIMM0_DEFINED 1 -#define XED_OPERAND_UIMM1_DEFINED 1 -#define XED_OPERAND_USING_DEFAULT_SEGMENT0_DEFINED 1 -#define XED_OPERAND_USING_DEFAULT_SEGMENT1_DEFINED 1 -#define XED_OPERAND_VEXDEST210_DEFINED 1 -#define XED_OPERAND_VEXDEST3_DEFINED 1 -#define XED_OPERAND_VEXDEST4_DEFINED 1 -#define XED_OPERAND_VEXVALID_DEFINED 1 -#define XED_OPERAND_VEX_C4_DEFINED 1 -#define XED_OPERAND_VEX_PREFIX_DEFINED 1 -#define XED_OPERAND_VL_DEFINED 1 -#define XED_OPERAND_WBNOINVD_DEFINED 1 -#define XED_OPERAND_ZEROING_DEFINED 1 -#define XED_OPERAND_LAST_DEFINED 1 -typedef enum { - XED_OPERAND_INVALID, - XED_OPERAND_AGEN, - XED_OPERAND_AMD3DNOW, - XED_OPERAND_ASZ, - XED_OPERAND_BASE0, - XED_OPERAND_BASE1, - XED_OPERAND_BCAST, - XED_OPERAND_BCRC, - XED_OPERAND_BRDISP_WIDTH, - XED_OPERAND_CET, - XED_OPERAND_CHIP, - XED_OPERAND_CLDEMOTE, - XED_OPERAND_DEFAULT_SEG, - XED_OPERAND_DF32, - XED_OPERAND_DF64, - XED_OPERAND_DISP, - XED_OPERAND_DISP_WIDTH, - XED_OPERAND_DUMMY, - XED_OPERAND_EASZ, - XED_OPERAND_ELEMENT_SIZE, - XED_OPERAND_ENCODER_PREFERRED, - XED_OPERAND_ENCODE_FORCE, - XED_OPERAND_EOSZ, - XED_OPERAND_ERROR, - XED_OPERAND_ESRC, - XED_OPERAND_FIRST_F2F3, - XED_OPERAND_HAS_MODRM, - XED_OPERAND_HAS_SIB, - XED_OPERAND_HINT, - XED_OPERAND_ICLASS, - XED_OPERAND_ILD_F2, - XED_OPERAND_ILD_F3, - XED_OPERAND_ILD_SEG, - XED_OPERAND_IMM0, - XED_OPERAND_IMM0SIGNED, - XED_OPERAND_IMM1, - XED_OPERAND_IMM1_BYTES, - XED_OPERAND_IMM_WIDTH, - XED_OPERAND_INDEX, - XED_OPERAND_LAST_F2F3, - XED_OPERAND_LLRC, - XED_OPERAND_LOCK, - XED_OPERAND_LZCNT, - XED_OPERAND_MAP, - XED_OPERAND_MASK, - XED_OPERAND_MAX_BYTES, - XED_OPERAND_MEM0, - XED_OPERAND_MEM1, - XED_OPERAND_MEM_WIDTH, - XED_OPERAND_MOD, - XED_OPERAND_MODE, - XED_OPERAND_MODEP5, - XED_OPERAND_MODEP55C, - XED_OPERAND_MODE_FIRST_PREFIX, - XED_OPERAND_MODE_SHORT_UD0, - XED_OPERAND_MODRM_BYTE, - XED_OPERAND_MPXMODE, - XED_OPERAND_MUST_USE_EVEX, - XED_OPERAND_NEEDREX, - XED_OPERAND_NEED_MEMDISP, - XED_OPERAND_NEED_SIB, - XED_OPERAND_NELEM, - XED_OPERAND_NOMINAL_OPCODE, - XED_OPERAND_NOREX, - XED_OPERAND_NO_SCALE_DISP8, - XED_OPERAND_NPREFIXES, - XED_OPERAND_NREXES, - XED_OPERAND_NSEG_PREFIXES, - XED_OPERAND_OSZ, - XED_OPERAND_OUTREG, - XED_OPERAND_OUT_OF_BYTES, - XED_OPERAND_P4, - XED_OPERAND_POS_DISP, - XED_OPERAND_POS_IMM, - XED_OPERAND_POS_IMM1, - XED_OPERAND_POS_MODRM, - XED_OPERAND_POS_NOMINAL_OPCODE, - XED_OPERAND_POS_SIB, - XED_OPERAND_PREFIX66, - XED_OPERAND_PTR, - XED_OPERAND_REALMODE, - XED_OPERAND_REG, - XED_OPERAND_REG0, - XED_OPERAND_REG1, - XED_OPERAND_REG2, - XED_OPERAND_REG3, - XED_OPERAND_REG4, - XED_OPERAND_REG5, - XED_OPERAND_REG6, - XED_OPERAND_REG7, - XED_OPERAND_REG8, - XED_OPERAND_REG9, - XED_OPERAND_RELBR, - XED_OPERAND_REP, - XED_OPERAND_REX, - XED_OPERAND_REXB, - XED_OPERAND_REXR, - XED_OPERAND_REXRR, - XED_OPERAND_REXW, - XED_OPERAND_REXX, - XED_OPERAND_RM, - XED_OPERAND_ROUNDC, - XED_OPERAND_SAE, - XED_OPERAND_SCALE, - XED_OPERAND_SEG0, - XED_OPERAND_SEG1, - XED_OPERAND_SEG_OVD, - XED_OPERAND_SIBBASE, - XED_OPERAND_SIBINDEX, - XED_OPERAND_SIBSCALE, - XED_OPERAND_SMODE, - XED_OPERAND_SRM, - XED_OPERAND_TZCNT, - XED_OPERAND_UBIT, - XED_OPERAND_UIMM0, - XED_OPERAND_UIMM1, - XED_OPERAND_USING_DEFAULT_SEGMENT0, - XED_OPERAND_USING_DEFAULT_SEGMENT1, - XED_OPERAND_VEXDEST210, - XED_OPERAND_VEXDEST3, - XED_OPERAND_VEXDEST4, - XED_OPERAND_VEXVALID, - XED_OPERAND_VEX_C4, - XED_OPERAND_VEX_PREFIX, - XED_OPERAND_VL, - XED_OPERAND_WBNOINVD, - XED_OPERAND_ZEROING, - XED_OPERAND_LAST -} xed_operand_enum_t; - -/// This converts strings to #xed_operand_enum_t types. -/// @param s A C-string. -/// @return #xed_operand_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_enum_t str2xed_operand_enum_t(const char* s); -/// This converts strings to #xed_operand_enum_t types. -/// @param p An enumeration element of type xed_operand_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_operand_enum_t2str(const xed_operand_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_operand_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_enum_t xed_operand_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-operand-storage.h b/target/i386/latx/include/xed/xed-operand-storage.h deleted file mode 100644 index ef2cba523cd..00000000000 --- a/target/i386/latx/include/xed/xed-operand-storage.h +++ /dev/null @@ -1,158 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-storage.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_STORAGE_H) -# define XED_OPERAND_STORAGE_H -#include "xed-chip-enum.h" -#include "xed-error-enum.h" -#include "xed-iclass-enum.h" -#include "xed-reg-enum.h" -#include "xed-operand-element-type-enum.h" -typedef struct xed_operand_storage_s { - xed_uint8_t agen; - xed_uint8_t amd3dnow; - xed_uint8_t asz; - xed_uint8_t bcrc; - xed_uint8_t cet; - xed_uint8_t cldemote; - xed_uint8_t df32; - xed_uint8_t df64; - xed_uint8_t dummy; - xed_uint8_t encoder_preferred; - xed_uint8_t encode_force; - xed_uint8_t has_sib; - xed_uint8_t ild_f2; - xed_uint8_t ild_f3; - xed_uint8_t imm0; - xed_uint8_t imm0signed; - xed_uint8_t imm1; - xed_uint8_t lock; - xed_uint8_t lzcnt; - xed_uint8_t mem0; - xed_uint8_t mem1; - xed_uint8_t modep5; - xed_uint8_t modep55c; - xed_uint8_t mode_first_prefix; - xed_uint8_t mode_short_ud0; - xed_uint8_t mpxmode; - xed_uint8_t must_use_evex; - xed_uint8_t needrex; - xed_uint8_t need_sib; - xed_uint8_t norex; - xed_uint8_t no_scale_disp8; - xed_uint8_t osz; - xed_uint8_t out_of_bytes; - xed_uint8_t p4; - xed_uint8_t prefix66; - xed_uint8_t ptr; - xed_uint8_t realmode; - xed_uint8_t relbr; - xed_uint8_t rex; - xed_uint8_t rexb; - xed_uint8_t rexr; - xed_uint8_t rexrr; - xed_uint8_t rexw; - xed_uint8_t rexx; - xed_uint8_t sae; - xed_uint8_t tzcnt; - xed_uint8_t ubit; - xed_uint8_t using_default_segment0; - xed_uint8_t using_default_segment1; - xed_uint8_t vexdest3; - xed_uint8_t vexdest4; - xed_uint8_t vex_c4; - xed_uint8_t wbnoinvd; - xed_uint8_t zeroing; - xed_uint8_t default_seg; - xed_uint8_t easz; - xed_uint8_t eosz; - xed_uint8_t first_f2f3; - xed_uint8_t has_modrm; - xed_uint8_t last_f2f3; - xed_uint8_t llrc; - xed_uint8_t mod; - xed_uint8_t mode; - xed_uint8_t rep; - xed_uint8_t sibscale; - xed_uint8_t smode; - xed_uint8_t vex_prefix; - xed_uint8_t vl; - xed_uint8_t hint; - xed_uint8_t mask; - xed_uint8_t reg; - xed_uint8_t rm; - xed_uint8_t roundc; - xed_uint8_t seg_ovd; - xed_uint8_t sibbase; - xed_uint8_t sibindex; - xed_uint8_t srm; - xed_uint8_t vexdest210; - xed_uint8_t vexvalid; - xed_uint8_t error; - xed_uint8_t esrc; - xed_uint8_t map; - xed_uint8_t nelem; - xed_uint8_t scale; - xed_uint8_t bcast; - xed_uint8_t need_memdisp; - xed_uint8_t chip; - xed_uint8_t brdisp_width; - xed_uint8_t disp_width; - xed_uint8_t ild_seg; - xed_uint8_t imm1_bytes; - xed_uint8_t imm_width; - xed_uint8_t max_bytes; - xed_uint8_t modrm_byte; - xed_uint8_t nominal_opcode; - xed_uint8_t nprefixes; - xed_uint8_t nrexes; - xed_uint8_t nseg_prefixes; - xed_uint8_t pos_disp; - xed_uint8_t pos_imm; - xed_uint8_t pos_imm1; - xed_uint8_t pos_modrm; - xed_uint8_t pos_nominal_opcode; - xed_uint8_t pos_sib; - xed_uint8_t uimm1; - xed_uint16_t base0; - xed_uint16_t base1; - xed_uint16_t element_size; - xed_uint16_t index; - xed_uint16_t outreg; - xed_uint16_t reg0; - xed_uint16_t reg1; - xed_uint16_t reg2; - xed_uint16_t reg3; - xed_uint16_t reg4; - xed_uint16_t reg5; - xed_uint16_t reg6; - xed_uint16_t reg7; - xed_uint16_t reg8; - xed_uint16_t reg9; - xed_uint16_t seg0; - xed_uint16_t seg1; - xed_uint16_t iclass; - xed_uint16_t mem_width; - xed_uint64_t disp; - xed_uint64_t uimm0; -} xed_operand_storage_t; -#endif diff --git a/target/i386/latx/include/xed/xed-operand-type-enum.h b/target/i386/latx/include/xed/xed-operand-type-enum.h deleted file mode 100644 index 59de90870bd..00000000000 --- a/target/i386/latx/include/xed/xed-operand-type-enum.h +++ /dev/null @@ -1,62 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-type-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_TYPE_ENUM_H) -# define XED_OPERAND_TYPE_ENUM_H -#include "xed-common-hdrs.h" -#define XED_OPERAND_TYPE_INVALID_DEFINED 1 -#define XED_OPERAND_TYPE_ERROR_DEFINED 1 -#define XED_OPERAND_TYPE_IMM_DEFINED 1 -#define XED_OPERAND_TYPE_IMM_CONST_DEFINED 1 -#define XED_OPERAND_TYPE_NT_LOOKUP_FN_DEFINED 1 -#define XED_OPERAND_TYPE_NT_LOOKUP_FN2_DEFINED 1 -#define XED_OPERAND_TYPE_NT_LOOKUP_FN4_DEFINED 1 -#define XED_OPERAND_TYPE_REG_DEFINED 1 -#define XED_OPERAND_TYPE_LAST_DEFINED 1 -typedef enum { - XED_OPERAND_TYPE_INVALID, - XED_OPERAND_TYPE_ERROR, - XED_OPERAND_TYPE_IMM, - XED_OPERAND_TYPE_IMM_CONST, - XED_OPERAND_TYPE_NT_LOOKUP_FN, - XED_OPERAND_TYPE_NT_LOOKUP_FN2, - XED_OPERAND_TYPE_NT_LOOKUP_FN4, - XED_OPERAND_TYPE_REG, - XED_OPERAND_TYPE_LAST -} xed_operand_type_enum_t; - -/// This converts strings to #xed_operand_type_enum_t types. -/// @param s A C-string. -/// @return #xed_operand_type_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_type_enum_t str2xed_operand_type_enum_t(const char* s); -/// This converts strings to #xed_operand_type_enum_t types. -/// @param p An enumeration element of type xed_operand_type_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_operand_type_enum_t2str(const xed_operand_type_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_operand_type_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_type_enum_t xed_operand_type_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-operand-values-interface.h b/target/i386/latx/include/xed/xed-operand-values-interface.h deleted file mode 100644 index 72d9caf2f67..00000000000 --- a/target/i386/latx/include/xed/xed-operand-values-interface.h +++ /dev/null @@ -1,522 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-values-interface.h -/// - -#if !defined(XED_OPERAND_VALUES_INTERFACE_H) -# define XED_OPERAND_VALUES_INTERFACE_H - -#include "xed-common-hdrs.h" -#include "xed-common-defs.h" -#include "xed-portability.h" -#include "xed-util.h" -#include "xed-types.h" -#include "xed-state.h" // a generated file -#include "xed-operand-enum.h" // a generated file -#include "xed-decoded-inst.h" -#include "xed-reg-enum.h" // generated -#include "xed-iclass-enum.h" // generated -/// @name Initialization -//@{ -/// @ingroup OPERANDS -/// Initializes operand structure -XED_DLL_EXPORT void xed_operand_values_init(xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Initializes the operand storage and sets mode values. -XED_DLL_EXPORT void xed_operand_values_init_set_mode(xed_operand_values_t* p, - const xed_state_t* dstate); - -/// @ingroup OPERANDS -/// Set the mode values -XED_DLL_EXPORT void -xed_operand_values_set_mode(xed_operand_values_t* p, - const xed_state_t* dstate); - -/// @ingroup OPERANDS -/// Initializes dst operand structure but preserves the existing -/// MODE/SMODE values from the src operand structure. -XED_DLL_EXPORT void -xed_operand_values_init_keep_mode( xed_operand_values_t* dst, - const xed_operand_values_t* src ); -//@} - -/////////////////////////////////////////////////////////// -/// @name String output -//@{ -/// @ingroup OPERANDS -/// Dump all the information about the operands to buf. -XED_DLL_EXPORT void -xed_operand_values_dump(const xed_operand_values_t* ov, - char* buf, - int buflen); -/// @ingroup OPERANDS -/// More tersely dump all the information about the operands to buf. -XED_DLL_EXPORT void -xed_operand_values_print_short(const xed_operand_values_t* ov, - char* buf, - int buflen); -//@} - -/// @name REP/REPNE Prefixes -//@{ -/// @ingroup OPERANDS -/// True if the instruction has a real REP prefix. This returns false if -/// there is no F2/F3 prefix or the F2/F3 prefix is used to refine the -/// opcode as in some SSE operations. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_real_rep(const xed_operand_values_t* p); -/// @ingroup OPERANDS -/// True if the instruction as a F3 REP prefix (used for opcode refining, -/// for rep for string operations, or ignored). -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_rep_prefix(const xed_operand_values_t* p); -/// @ingroup OPERANDS -/// True if the instruction as a F2 REP prefix (used for opcode refining, -/// for rep for string operations, or ignored). -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_repne_prefix(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// DO NOT USE - DEPRECATED. The correct way to do remove a rep prefix is by changing the iclass -XED_DLL_EXPORT void xed_operand_values_clear_rep(xed_operand_values_t* p); - -//@} - -/// @name Atomic / Locked operations -//@{ -/// @ingroup OPERANDS -/// Returns true if the memory operation has atomic read-modify-write -/// semantics. An XCHG accessing memory is atomic with or without a -/// LOCK prefix. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_get_atomic(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Returns true if the memory operation has a valid lock prefix. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_lock_prefix(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Returns true if the instruction could be re-encoded to have a lock -/// prefix but does not have one currently. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_lockable(const xed_operand_values_t* p); -//@} - - -/// @ingroup OPERANDS -/// Indicates if the default segment is being used. -/// @param[in] p the pointer to the #xed_operand_values_t structure. -/// @param[in] i 0 or 1, indicating which memory operation. -/// @return true if the memory operation is using the default segment for -/// the associated addressing mode base register. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_using_default_segment(const xed_operand_values_t* p, - unsigned int i); - - - -/// @ingroup OPERANDS -/// Returns The effective operand width in bits: 16/32/64. Note this is not -/// the same as the width of the operand which can vary! For 8 bit -/// operations, the effective operand width is the machine mode's default -/// width. If you also want to identify byte operations use the higher -/// level function #xed_decoded_inst_get_operand_width() . -XED_DLL_EXPORT xed_uint32_t -xed_operand_values_get_effective_operand_width(const xed_operand_values_t* p); -/// @ingroup OPERANDS -/// Returns The effective address width in bits: 16/32/64. -XED_DLL_EXPORT xed_uint32_t -xed_operand_values_get_effective_address_width(const xed_operand_values_t* p); -/// @ingroup OPERANDS -/// Returns The stack address width in bits: 16/32/64. -XED_DLL_EXPORT xed_uint32_t -xed_operand_values_get_stack_address_width(const xed_operand_values_t* p); - - -/// @ingroup OPERANDS -/// True if there is a memory displacement -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_memory_displacement(const xed_operand_values_t* p); -/// @ingroup OPERANDS -/// True if there is a branch displacement -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_branch_displacement(const xed_operand_values_t* p); -/// @ingroup OPERANDS -/// True if there is a memory or branch displacement -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_displacement(const xed_operand_values_t* p); - - -/// @ingroup OPERANDS -/// Deprecated. Compatibility function for XED0. See has_memory_displacement(). -XED_DLL_EXPORT xed_bool_t -xed_operand_values_get_displacement_for_memop(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Return true if there is an immediate operand -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_immediate(const xed_operand_values_t* p); - - -/// @ingroup OPERANDS -/// ALIAS for has_displacement(). -/// Deprecated. See has_memory_displacement() and -/// has_branch_displacement(). -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_disp(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// This indicates the presence of a 67 prefix. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_address_size_prefix(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// This does not include the cases when the 66 prefix is used an -/// opcode-refining prefix for multibyte opcodes. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_operand_size_prefix(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// This includes any 66 prefix that shows up even if it is ignored. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_66_prefix(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// This instruction has a REX prefix with the W bit set. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_rexw_prefix(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_segment_prefix(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Return the segment prefix, if any, as a #xed_reg_enum_t value. -XED_DLL_EXPORT xed_reg_enum_t -xed_operand_values_segment_prefix(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_bool_t -xed_operand_values_is_prefetch(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_bool_t -xed_operand_values_get_long_mode(const xed_operand_values_t* p); -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_bool_t -xed_operand_values_get_real_mode(const xed_operand_values_t* p); - -/// @name Memory Addressing -//@{ -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_bool_t -xed_operand_values_accesses_memory(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -XED_DLL_EXPORT unsigned int -xed_operand_values_number_of_memory_operands(const xed_operand_values_t* p); - -/// return bytes -/// @ingroup OPERANDS -XED_DLL_EXPORT unsigned int -xed_operand_values_get_memory_operand_length(const xed_operand_values_t* p, - unsigned int memop_idx); - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_reg_enum_t -xed_operand_values_get_base_reg(const xed_operand_values_t* p, - unsigned int memop_idx); - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_reg_enum_t -xed_operand_values_get_index_reg(const xed_operand_values_t* p, - unsigned int memop_idx); - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_reg_enum_t -xed_operand_values_get_seg_reg(const xed_operand_values_t* p, - unsigned int memop_idx); - -/// @ingroup OPERANDS -XED_DLL_EXPORT unsigned int -xed_operand_values_get_scale(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Returns true if the instruction access memory but without using a MODRM -/// byte limiting its addressing modes. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_memop_without_modrm(const xed_operand_values_t* p); -/// @ingroup OPERANDS -/// Returns true if the instruction has a MODRM byte. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_modrm_byte(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Returns true if the instruction has a SIB byte. -XED_DLL_EXPORT xed_bool_t -xed_operand_values_has_sib_byte(const xed_operand_values_t* p); -//@} - - -/// @ingroup OPERANDS -/// Returns true if 0x2E prefix on Jcc -XED_DLL_EXPORT xed_bool_t -xed_operand_values_branch_not_taken_hint(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Returns true if 0x3E prefix on Jcc -XED_DLL_EXPORT xed_bool_t -xed_operand_values_branch_taken_hint(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Returns true for indirect call/jmp with 0x3E prefix (if the legacy prefix rules are obeyed) -XED_DLL_EXPORT xed_bool_t -xed_operand_values_cet_no_track(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_bool_t -xed_operand_values_is_nop(const xed_operand_values_t* p); - - -/// @name Immediates -//@{ -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_int64_t -xed_operand_values_get_immediate_int64(const xed_operand_values_t* p); - - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_uint64_t -xed_operand_values_get_immediate_uint64(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Return true if the first immediate (IMM0) is signed -XED_DLL_EXPORT xed_uint_t -xed_operand_values_get_immediate_is_signed(const xed_operand_values_t* p); - - -/// @ingroup OPERANDS -/// Return the i'th byte of the immediate -XED_DLL_EXPORT xed_uint8_t -xed_operand_values_get_immediate_byte(const xed_operand_values_t* p, - unsigned int i); - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_uint8_t -xed_operand_values_get_second_immediate(const xed_operand_values_t* p); -//@} - -/// @name Memory Displacements -//@{ -/// @ingroup OPERANDS -/// Return the memory displacement width in BYTES -XED_DLL_EXPORT xed_uint32_t -xed_operand_values_get_memory_displacement_length(const xed_operand_values_t* p); -/// @ingroup OPERANDS -/// Return the memory displacement width in BITS -XED_DLL_EXPORT xed_uint32_t -xed_operand_values_get_memory_displacement_length_bits( - const xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Return the raw memory displacement width in BITS(ignores scaling) -XED_DLL_EXPORT xed_uint32_t -xed_operand_values_get_memory_displacement_length_bits_raw( - const xed_operand_values_t* p); - -/// Returns the potentially scaled value of the memory -/// displacement. Certain AVX512 memory displacements are scaled before -/// they are used. @ingroup OPERANDS -XED_DLL_EXPORT xed_int64_t -xed_operand_values_get_memory_displacement_int64(const xed_operand_values_t* p); - -/// Returns the unscaled (raw) memory displacement. Certain AVX512 memory -/// displacements are scaled before they are used. @ingroup OPERANDS -XED_DLL_EXPORT xed_int64_t -xed_operand_values_get_memory_displacement_int64_raw(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_uint8_t -xed_operand_values_get_memory_displacement_byte(const xed_operand_values_t* p, - unsigned int i); -//@} - -/// @name Branch Displacements -//@{ -/// @ingroup OPERANDS -/// Return the branch displacement width in bytes -XED_DLL_EXPORT xed_uint32_t -xed_operand_values_get_branch_displacement_length(const xed_operand_values_t* p); -/// @ingroup OPERANDS -/// Return the branch displacement width in bits -XED_DLL_EXPORT xed_uint32_t -xed_operand_values_get_branch_displacement_length_bits( - const xed_operand_values_t* p); - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_int32_t -xed_operand_values_get_branch_displacement_int32(const xed_operand_values_t* p); - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_uint8_t -xed_operand_values_get_branch_displacement_byte(const xed_operand_values_t* p, - unsigned int i); -//@} - - -/// @ingroup OPERANDS -XED_DLL_EXPORT xed_iclass_enum_t -xed_operand_values_get_iclass(const xed_operand_values_t* p); - -//////////////////////////////////////////////////// -// ENCODE API -//////////////////////////////////////////////////// -/// @name Encoding -//@{ -/// @ingroup OPERANDS -XED_DLL_EXPORT void -xed_operand_values_zero_immediate(xed_operand_values_t* p); -/// @ingroup OPERANDS -XED_DLL_EXPORT void -xed_operand_values_zero_branch_displacement(xed_operand_values_t* p); -/// @ingroup OPERANDS -XED_DLL_EXPORT void -xed_operand_values_zero_memory_displacement(xed_operand_values_t* p); - -/// @ingroup OPERANDS -XED_DLL_EXPORT void xed_operand_values_set_lock(xed_operand_values_t* p); -/// @ingroup OPERANDS -XED_DLL_EXPORT void -xed_operand_values_zero_segment_override(xed_operand_values_t* p); - - -/// @ingroup OPERANDS -XED_DLL_EXPORT void -xed_operand_values_set_iclass(xed_operand_values_t* p, - xed_iclass_enum_t iclass); - -/// @ingroup OPERANDS -/// width is bits 8, 16, 32, 64 -XED_DLL_EXPORT void -xed_operand_values_set_effective_operand_width(xed_operand_values_t* p, - unsigned int width); - -/// @ingroup OPERANDS -/// width is bits 16, 32, 64 -XED_DLL_EXPORT void -xed_operand_values_set_effective_address_width(xed_operand_values_t* p, - unsigned int width); -/// takes bytes, not bits, as an argument -/// @ingroup OPERANDS -XED_DLL_EXPORT void -xed_operand_values_set_memory_operand_length(xed_operand_values_t* p, - unsigned int memop_length); - - -/// @ingroup OPERANDS -/// Set the memory displacement using a BYTES length -XED_DLL_EXPORT void -xed_operand_values_set_memory_displacement(xed_operand_values_t* p, - xed_int64_t x, unsigned int len); -/// @ingroup OPERANDS -/// Set the memory displacement using a BITS length -XED_DLL_EXPORT void -xed_operand_values_set_memory_displacement_bits(xed_operand_values_t* p, - xed_int64_t x, - unsigned int len_bits); - -/// @ingroup OPERANDS -/// Indicate that we have a relative branch. -XED_DLL_EXPORT void xed_operand_values_set_relbr(xed_operand_values_t* p); - -/// @ingroup OPERANDS -/// Set the branch displacement using a BYTES length -XED_DLL_EXPORT void -xed_operand_values_set_branch_displacement(xed_operand_values_t* p, - xed_int32_t x, - unsigned int len); -/// @ingroup OPERANDS -/// Set the branch displacement using a BITS length -XED_DLL_EXPORT void -xed_operand_values_set_branch_displacement_bits(xed_operand_values_t* p, - xed_int32_t x, - unsigned int len_bits); - -/// @ingroup OPERANDS -/// Set the signed immediate using a BYTES length -XED_DLL_EXPORT void -xed_operand_values_set_immediate_signed(xed_operand_values_t* p, - xed_int32_t x, - unsigned int bytes); -/// @ingroup OPERANDS -/// Set the signed immediate using a BITS length -XED_DLL_EXPORT void -xed_operand_values_set_immediate_signed_bits(xed_operand_values_t* p, - xed_int32_t x, - unsigned int bits); - - -/// @ingroup OPERANDS -/// Set the unsigned immediate using a BYTE length. -XED_DLL_EXPORT void -xed_operand_values_set_immediate_unsigned(xed_operand_values_t* p, - xed_uint64_t x, - unsigned int bytes); -/// @ingroup OPERANDS -/// Set the unsigned immediate using a BIT length. -XED_DLL_EXPORT void -xed_operand_values_set_immediate_unsigned_bits(xed_operand_values_t* p, - xed_uint64_t x, - unsigned int bits); - - - -/// @ingroup OPERANDS -XED_DLL_EXPORT void xed_operand_values_set_base_reg(xed_operand_values_t* p, - unsigned int memop_idx, - xed_reg_enum_t new_base); - -/// @ingroup OPERANDS -XED_DLL_EXPORT void xed_operand_values_set_seg_reg(xed_operand_values_t* p, - unsigned int memop_idx, - xed_reg_enum_t new_seg); - -/// @ingroup OPERANDS -XED_DLL_EXPORT void xed_operand_values_set_index_reg(xed_operand_values_t* p, - unsigned int memop_idx, - xed_reg_enum_t new_index); - -/// @ingroup OPERANDS -XED_DLL_EXPORT void xed_operand_values_set_scale(xed_operand_values_t* p, - xed_uint_t memop_idx, - xed_uint_t new_scale); - - -/// @ingroup OPERANDS -/// Set the operand storage field entry named 'operand_name' to the -/// register value specified by 'reg_name'. -XED_DLL_EXPORT void -xed_operand_values_set_operand_reg(xed_operand_values_t* p, - xed_operand_enum_t operand_name, - xed_reg_enum_t reg_name); - -//@} -#endif - diff --git a/target/i386/latx/include/xed/xed-operand-visibility-enum.h b/target/i386/latx/include/xed/xed-operand-visibility-enum.h deleted file mode 100644 index f1879002013..00000000000 --- a/target/i386/latx/include/xed/xed-operand-visibility-enum.h +++ /dev/null @@ -1,54 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-visibility-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_VISIBILITY_ENUM_H) -# define XED_OPERAND_VISIBILITY_ENUM_H -#include "xed-common-hdrs.h" -#define XED_OPVIS_INVALID_DEFINED 1 -#define XED_OPVIS_EXPLICIT_DEFINED 1 -#define XED_OPVIS_IMPLICIT_DEFINED 1 -#define XED_OPVIS_SUPPRESSED_DEFINED 1 -#define XED_OPVIS_LAST_DEFINED 1 -typedef enum { - XED_OPVIS_INVALID, - XED_OPVIS_EXPLICIT, ///< Shows up in operand encoding - XED_OPVIS_IMPLICIT, ///< Part of the opcode, but listed as an operand - XED_OPVIS_SUPPRESSED, ///< Part of the opcode, but not typically listed as an operand - XED_OPVIS_LAST -} xed_operand_visibility_enum_t; - -/// This converts strings to #xed_operand_visibility_enum_t types. -/// @param s A C-string. -/// @return #xed_operand_visibility_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_visibility_enum_t str2xed_operand_visibility_enum_t(const char* s); -/// This converts strings to #xed_operand_visibility_enum_t types. -/// @param p An enumeration element of type xed_operand_visibility_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_operand_visibility_enum_t2str(const xed_operand_visibility_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_operand_visibility_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_visibility_enum_t xed_operand_visibility_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-operand-width-enum.h b/target/i386/latx/include/xed/xed-operand-width-enum.h deleted file mode 100644 index c97e00c66bf..00000000000 --- a/target/i386/latx/include/xed/xed-operand-width-enum.h +++ /dev/null @@ -1,300 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-operand-width-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_OPERAND_WIDTH_ENUM_H) -# define XED_OPERAND_WIDTH_ENUM_H -#include "xed-common-hdrs.h" -#define XED_OPERAND_WIDTH_INVALID_DEFINED 1 -#define XED_OPERAND_WIDTH_ASZ_DEFINED 1 -#define XED_OPERAND_WIDTH_SSZ_DEFINED 1 -#define XED_OPERAND_WIDTH_PSEUDO_DEFINED 1 -#define XED_OPERAND_WIDTH_PSEUDOX87_DEFINED 1 -#define XED_OPERAND_WIDTH_A16_DEFINED 1 -#define XED_OPERAND_WIDTH_A32_DEFINED 1 -#define XED_OPERAND_WIDTH_B_DEFINED 1 -#define XED_OPERAND_WIDTH_D_DEFINED 1 -#define XED_OPERAND_WIDTH_I8_DEFINED 1 -#define XED_OPERAND_WIDTH_U8_DEFINED 1 -#define XED_OPERAND_WIDTH_I16_DEFINED 1 -#define XED_OPERAND_WIDTH_U16_DEFINED 1 -#define XED_OPERAND_WIDTH_I32_DEFINED 1 -#define XED_OPERAND_WIDTH_U32_DEFINED 1 -#define XED_OPERAND_WIDTH_I64_DEFINED 1 -#define XED_OPERAND_WIDTH_U64_DEFINED 1 -#define XED_OPERAND_WIDTH_F16_DEFINED 1 -#define XED_OPERAND_WIDTH_F32_DEFINED 1 -#define XED_OPERAND_WIDTH_F64_DEFINED 1 -#define XED_OPERAND_WIDTH_DQ_DEFINED 1 -#define XED_OPERAND_WIDTH_XUB_DEFINED 1 -#define XED_OPERAND_WIDTH_XUW_DEFINED 1 -#define XED_OPERAND_WIDTH_XUD_DEFINED 1 -#define XED_OPERAND_WIDTH_XUQ_DEFINED 1 -#define XED_OPERAND_WIDTH_X128_DEFINED 1 -#define XED_OPERAND_WIDTH_XB_DEFINED 1 -#define XED_OPERAND_WIDTH_XW_DEFINED 1 -#define XED_OPERAND_WIDTH_XD_DEFINED 1 -#define XED_OPERAND_WIDTH_XQ_DEFINED 1 -#define XED_OPERAND_WIDTH_ZB_DEFINED 1 -#define XED_OPERAND_WIDTH_ZW_DEFINED 1 -#define XED_OPERAND_WIDTH_ZD_DEFINED 1 -#define XED_OPERAND_WIDTH_ZQ_DEFINED 1 -#define XED_OPERAND_WIDTH_MB_DEFINED 1 -#define XED_OPERAND_WIDTH_MW_DEFINED 1 -#define XED_OPERAND_WIDTH_MD_DEFINED 1 -#define XED_OPERAND_WIDTH_MQ_DEFINED 1 -#define XED_OPERAND_WIDTH_M64INT_DEFINED 1 -#define XED_OPERAND_WIDTH_M64REAL_DEFINED 1 -#define XED_OPERAND_WIDTH_MEM108_DEFINED 1 -#define XED_OPERAND_WIDTH_MEM14_DEFINED 1 -#define XED_OPERAND_WIDTH_MEM16_DEFINED 1 -#define XED_OPERAND_WIDTH_MEM16INT_DEFINED 1 -#define XED_OPERAND_WIDTH_MEM28_DEFINED 1 -#define XED_OPERAND_WIDTH_MEM32INT_DEFINED 1 -#define XED_OPERAND_WIDTH_MEM32REAL_DEFINED 1 -#define XED_OPERAND_WIDTH_MEM80DEC_DEFINED 1 -#define XED_OPERAND_WIDTH_MEM80REAL_DEFINED 1 -#define XED_OPERAND_WIDTH_F80_DEFINED 1 -#define XED_OPERAND_WIDTH_MEM94_DEFINED 1 -#define XED_OPERAND_WIDTH_MFPXENV_DEFINED 1 -#define XED_OPERAND_WIDTH_MXSAVE_DEFINED 1 -#define XED_OPERAND_WIDTH_MPREFETCH_DEFINED 1 -#define XED_OPERAND_WIDTH_P_DEFINED 1 -#define XED_OPERAND_WIDTH_P2_DEFINED 1 -#define XED_OPERAND_WIDTH_PD_DEFINED 1 -#define XED_OPERAND_WIDTH_PS_DEFINED 1 -#define XED_OPERAND_WIDTH_PI_DEFINED 1 -#define XED_OPERAND_WIDTH_Q_DEFINED 1 -#define XED_OPERAND_WIDTH_S_DEFINED 1 -#define XED_OPERAND_WIDTH_S64_DEFINED 1 -#define XED_OPERAND_WIDTH_SD_DEFINED 1 -#define XED_OPERAND_WIDTH_SI_DEFINED 1 -#define XED_OPERAND_WIDTH_SS_DEFINED 1 -#define XED_OPERAND_WIDTH_V_DEFINED 1 -#define XED_OPERAND_WIDTH_Y_DEFINED 1 -#define XED_OPERAND_WIDTH_W_DEFINED 1 -#define XED_OPERAND_WIDTH_Z_DEFINED 1 -#define XED_OPERAND_WIDTH_SPW8_DEFINED 1 -#define XED_OPERAND_WIDTH_SPW_DEFINED 1 -#define XED_OPERAND_WIDTH_SPW5_DEFINED 1 -#define XED_OPERAND_WIDTH_SPW3_DEFINED 1 -#define XED_OPERAND_WIDTH_SPW2_DEFINED 1 -#define XED_OPERAND_WIDTH_I1_DEFINED 1 -#define XED_OPERAND_WIDTH_I2_DEFINED 1 -#define XED_OPERAND_WIDTH_I3_DEFINED 1 -#define XED_OPERAND_WIDTH_I4_DEFINED 1 -#define XED_OPERAND_WIDTH_I5_DEFINED 1 -#define XED_OPERAND_WIDTH_I6_DEFINED 1 -#define XED_OPERAND_WIDTH_I7_DEFINED 1 -#define XED_OPERAND_WIDTH_VAR_DEFINED 1 -#define XED_OPERAND_WIDTH_BND32_DEFINED 1 -#define XED_OPERAND_WIDTH_BND64_DEFINED 1 -#define XED_OPERAND_WIDTH_PMMSZ16_DEFINED 1 -#define XED_OPERAND_WIDTH_PMMSZ32_DEFINED 1 -#define XED_OPERAND_WIDTH_QQ_DEFINED 1 -#define XED_OPERAND_WIDTH_YUB_DEFINED 1 -#define XED_OPERAND_WIDTH_YUW_DEFINED 1 -#define XED_OPERAND_WIDTH_YUD_DEFINED 1 -#define XED_OPERAND_WIDTH_YUQ_DEFINED 1 -#define XED_OPERAND_WIDTH_Y128_DEFINED 1 -#define XED_OPERAND_WIDTH_YB_DEFINED 1 -#define XED_OPERAND_WIDTH_YW_DEFINED 1 -#define XED_OPERAND_WIDTH_YD_DEFINED 1 -#define XED_OPERAND_WIDTH_YQ_DEFINED 1 -#define XED_OPERAND_WIDTH_YPS_DEFINED 1 -#define XED_OPERAND_WIDTH_YPD_DEFINED 1 -#define XED_OPERAND_WIDTH_ZBF16_DEFINED 1 -#define XED_OPERAND_WIDTH_VV_DEFINED 1 -#define XED_OPERAND_WIDTH_ZV_DEFINED 1 -#define XED_OPERAND_WIDTH_WRD_DEFINED 1 -#define XED_OPERAND_WIDTH_MSKW_DEFINED 1 -#define XED_OPERAND_WIDTH_ZMSKW_DEFINED 1 -#define XED_OPERAND_WIDTH_ZF32_DEFINED 1 -#define XED_OPERAND_WIDTH_ZF64_DEFINED 1 -#define XED_OPERAND_WIDTH_ZUB_DEFINED 1 -#define XED_OPERAND_WIDTH_ZUW_DEFINED 1 -#define XED_OPERAND_WIDTH_ZUD_DEFINED 1 -#define XED_OPERAND_WIDTH_ZUQ_DEFINED 1 -#define XED_OPERAND_WIDTH_ZI8_DEFINED 1 -#define XED_OPERAND_WIDTH_ZI16_DEFINED 1 -#define XED_OPERAND_WIDTH_ZI32_DEFINED 1 -#define XED_OPERAND_WIDTH_ZI64_DEFINED 1 -#define XED_OPERAND_WIDTH_ZU8_DEFINED 1 -#define XED_OPERAND_WIDTH_ZU16_DEFINED 1 -#define XED_OPERAND_WIDTH_ZU32_DEFINED 1 -#define XED_OPERAND_WIDTH_ZU64_DEFINED 1 -#define XED_OPERAND_WIDTH_ZU128_DEFINED 1 -#define XED_OPERAND_WIDTH_M384_DEFINED 1 -#define XED_OPERAND_WIDTH_M512_DEFINED 1 -#define XED_OPERAND_WIDTH_PTR_DEFINED 1 -#define XED_OPERAND_WIDTH_TMEMROW_DEFINED 1 -#define XED_OPERAND_WIDTH_TMEMCOL_DEFINED 1 -#define XED_OPERAND_WIDTH_TV_DEFINED 1 -#define XED_OPERAND_WIDTH_ZF16_DEFINED 1 -#define XED_OPERAND_WIDTH_Z2F16_DEFINED 1 -#define XED_OPERAND_WIDTH_LAST_DEFINED 1 -typedef enum { - XED_OPERAND_WIDTH_INVALID, - XED_OPERAND_WIDTH_ASZ, - XED_OPERAND_WIDTH_SSZ, - XED_OPERAND_WIDTH_PSEUDO, - XED_OPERAND_WIDTH_PSEUDOX87, - XED_OPERAND_WIDTH_A16, - XED_OPERAND_WIDTH_A32, - XED_OPERAND_WIDTH_B, - XED_OPERAND_WIDTH_D, - XED_OPERAND_WIDTH_I8, - XED_OPERAND_WIDTH_U8, - XED_OPERAND_WIDTH_I16, - XED_OPERAND_WIDTH_U16, - XED_OPERAND_WIDTH_I32, - XED_OPERAND_WIDTH_U32, - XED_OPERAND_WIDTH_I64, - XED_OPERAND_WIDTH_U64, - XED_OPERAND_WIDTH_F16, - XED_OPERAND_WIDTH_F32, - XED_OPERAND_WIDTH_F64, - XED_OPERAND_WIDTH_DQ, - XED_OPERAND_WIDTH_XUB, - XED_OPERAND_WIDTH_XUW, - XED_OPERAND_WIDTH_XUD, - XED_OPERAND_WIDTH_XUQ, - XED_OPERAND_WIDTH_X128, - XED_OPERAND_WIDTH_XB, - XED_OPERAND_WIDTH_XW, - XED_OPERAND_WIDTH_XD, - XED_OPERAND_WIDTH_XQ, - XED_OPERAND_WIDTH_ZB, - XED_OPERAND_WIDTH_ZW, - XED_OPERAND_WIDTH_ZD, - XED_OPERAND_WIDTH_ZQ, - XED_OPERAND_WIDTH_MB, - XED_OPERAND_WIDTH_MW, - XED_OPERAND_WIDTH_MD, - XED_OPERAND_WIDTH_MQ, - XED_OPERAND_WIDTH_M64INT, - XED_OPERAND_WIDTH_M64REAL, - XED_OPERAND_WIDTH_MEM108, - XED_OPERAND_WIDTH_MEM14, - XED_OPERAND_WIDTH_MEM16, - XED_OPERAND_WIDTH_MEM16INT, - XED_OPERAND_WIDTH_MEM28, - XED_OPERAND_WIDTH_MEM32INT, - XED_OPERAND_WIDTH_MEM32REAL, - XED_OPERAND_WIDTH_MEM80DEC, - XED_OPERAND_WIDTH_MEM80REAL, - XED_OPERAND_WIDTH_F80, - XED_OPERAND_WIDTH_MEM94, - XED_OPERAND_WIDTH_MFPXENV, - XED_OPERAND_WIDTH_MXSAVE, - XED_OPERAND_WIDTH_MPREFETCH, - XED_OPERAND_WIDTH_P, - XED_OPERAND_WIDTH_P2, - XED_OPERAND_WIDTH_PD, - XED_OPERAND_WIDTH_PS, - XED_OPERAND_WIDTH_PI, - XED_OPERAND_WIDTH_Q, - XED_OPERAND_WIDTH_S, - XED_OPERAND_WIDTH_S64, - XED_OPERAND_WIDTH_SD, - XED_OPERAND_WIDTH_SI, - XED_OPERAND_WIDTH_SS, - XED_OPERAND_WIDTH_V, - XED_OPERAND_WIDTH_Y, - XED_OPERAND_WIDTH_W, - XED_OPERAND_WIDTH_Z, - XED_OPERAND_WIDTH_SPW8, - XED_OPERAND_WIDTH_SPW, - XED_OPERAND_WIDTH_SPW5, - XED_OPERAND_WIDTH_SPW3, - XED_OPERAND_WIDTH_SPW2, - XED_OPERAND_WIDTH_I1, - XED_OPERAND_WIDTH_I2, - XED_OPERAND_WIDTH_I3, - XED_OPERAND_WIDTH_I4, - XED_OPERAND_WIDTH_I5, - XED_OPERAND_WIDTH_I6, - XED_OPERAND_WIDTH_I7, - XED_OPERAND_WIDTH_VAR, - XED_OPERAND_WIDTH_BND32, - XED_OPERAND_WIDTH_BND64, - XED_OPERAND_WIDTH_PMMSZ16, - XED_OPERAND_WIDTH_PMMSZ32, - XED_OPERAND_WIDTH_QQ, - XED_OPERAND_WIDTH_YUB, - XED_OPERAND_WIDTH_YUW, - XED_OPERAND_WIDTH_YUD, - XED_OPERAND_WIDTH_YUQ, - XED_OPERAND_WIDTH_Y128, - XED_OPERAND_WIDTH_YB, - XED_OPERAND_WIDTH_YW, - XED_OPERAND_WIDTH_YD, - XED_OPERAND_WIDTH_YQ, - XED_OPERAND_WIDTH_YPS, - XED_OPERAND_WIDTH_YPD, - XED_OPERAND_WIDTH_ZBF16, - XED_OPERAND_WIDTH_VV, - XED_OPERAND_WIDTH_ZV, - XED_OPERAND_WIDTH_WRD, - XED_OPERAND_WIDTH_MSKW, - XED_OPERAND_WIDTH_ZMSKW, - XED_OPERAND_WIDTH_ZF32, - XED_OPERAND_WIDTH_ZF64, - XED_OPERAND_WIDTH_ZUB, - XED_OPERAND_WIDTH_ZUW, - XED_OPERAND_WIDTH_ZUD, - XED_OPERAND_WIDTH_ZUQ, - XED_OPERAND_WIDTH_ZI8, - XED_OPERAND_WIDTH_ZI16, - XED_OPERAND_WIDTH_ZI32, - XED_OPERAND_WIDTH_ZI64, - XED_OPERAND_WIDTH_ZU8, - XED_OPERAND_WIDTH_ZU16, - XED_OPERAND_WIDTH_ZU32, - XED_OPERAND_WIDTH_ZU64, - XED_OPERAND_WIDTH_ZU128, - XED_OPERAND_WIDTH_M384, - XED_OPERAND_WIDTH_M512, - XED_OPERAND_WIDTH_PTR, - XED_OPERAND_WIDTH_TMEMROW, - XED_OPERAND_WIDTH_TMEMCOL, - XED_OPERAND_WIDTH_TV, - XED_OPERAND_WIDTH_ZF16, - XED_OPERAND_WIDTH_Z2F16, - XED_OPERAND_WIDTH_LAST -} xed_operand_width_enum_t; - -/// This converts strings to #xed_operand_width_enum_t types. -/// @param s A C-string. -/// @return #xed_operand_width_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_width_enum_t str2xed_operand_width_enum_t(const char* s); -/// This converts strings to #xed_operand_width_enum_t types. -/// @param p An enumeration element of type xed_operand_width_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_operand_width_enum_t2str(const xed_operand_width_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_operand_width_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_operand_width_enum_t xed_operand_width_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-patch.h b/target/i386/latx/include/xed/xed-patch.h deleted file mode 100644 index e914d42cb13..00000000000 --- a/target/i386/latx/include/xed/xed-patch.h +++ /dev/null @@ -1,63 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -#ifndef XED_PATCH_H -# define XED_PATCH_H -#include "xed-encoder-hl.h" - -/// @name Patching decoded instructions -//@{ - - -/// Replace a memory displacement. -/// The widths of original displacement and replacement must match. -/// @param xedd A decoded instruction. -/// @param itext The corresponding encoder output, byte array. -/// @param disp A xed_enc_displacement_t object describing the new displacement. -/// @returns xed_bool_t 1=success, 0=failure -/// @ingroup ENCHLPATCH -XED_DLL_EXPORT xed_bool_t -xed_patch_disp(xed_decoded_inst_t* xedd, - xed_uint8_t* itext, - xed_enc_displacement_t disp); - -/// Replace a branch displacement. -/// The widths of original displacement and replacement must match. -/// @param xedd A decoded instruction. -/// @param itext The corresponding encoder output, byte array. -/// @param disp A xed_encoder_operand_t object describing the new displacement. -/// @returns xed_bool_t 1=success, 0=failure -/// @ingroup ENCHLPATCH -XED_DLL_EXPORT xed_bool_t -xed_patch_relbr(xed_decoded_inst_t* xedd, - xed_uint8_t* itext, - xed_encoder_operand_t disp); - -/// Replace an imm0 immediate value. -/// The widths of original immediate and replacement must match. -/// @param xedd A decoded instruction. -/// @param itext The corresponding encoder output, byte array. -/// @param imm0 A xed_encoder_operand_t object describing the new immediate. -/// @returns xed_bool_t 1=success, 0=failure -/// @ingroup ENCHLPATCH -XED_DLL_EXPORT xed_bool_t -xed_patch_imm0(xed_decoded_inst_t* xedd, - xed_uint8_t* itext, - xed_encoder_operand_t imm0); - -//@} -#endif diff --git a/target/i386/latx/include/xed/xed-portability.h b/target/i386/latx/include/xed/xed-portability.h deleted file mode 100644 index 1efd9a0c821..00000000000 --- a/target/i386/latx/include/xed/xed-portability.h +++ /dev/null @@ -1,186 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-portability.h -/// - -#ifndef XED_PORTABILITY_H -# define XED_PORTABILITY_H -# include "xed-common-hdrs.h" -# include "xed-types.h" - - -#define XED_STATIC_CAST(x,y) ((x) (y)) -#define XED_REINTERPRET_CAST(x,y) ((x) (y)) -#define XED_CAST(x,y) ((x) (y)) - - - -XED_DLL_EXPORT xed_uint_t xed_strlen(const char* s); -XED_DLL_EXPORT void xed_strcat(char* dst, const char* src); -XED_DLL_EXPORT void xed_strcpy(char* dst, const char* src); - -/// returns the number of bytes remaining for the next use of -/// #xed_strncpy() or #xed_strncat() . -XED_DLL_EXPORT int xed_strncpy(char* dst, const char* src, int len); - -/// returns the number of bytes remaining for the next use of -/// #xed_strncpy() or #xed_strncat() . -XED_DLL_EXPORT int xed_strncat(char* dst, const char* src, int len); - -#if defined(__INTEL_COMPILER) -# if defined(_WIN32) && defined(_MSC_VER) -# if _MSC_VER >= 1400 -# define XED_MSVC8_OR_LATER 1 -# endif -# endif -#endif - -/* recognize VC98 */ -#if !defined(__INTEL_COMPILER) -# if defined(_WIN32) && defined(_MSC_VER) -# if _MSC_VER == 1200 -# define XED_MSVC6 1 -# endif -# endif -# if defined(_WIN32) && defined(_MSC_VER) -# if _MSC_VER == 1310 -# define XED_MSVC7 1 -# endif -# endif -# if defined(_WIN32) && defined(_MSC_VER) -# if _MSC_VER >= 1400 -# define XED_MSVC8_OR_LATER 1 -# endif -# if _MSC_VER == 1400 -# define XED_MSVC8 1 -# endif -# if _MSC_VER == 1500 -# define XED_MSVC9 1 -# endif -# if _MSC_VER >= 1500 -# define XED_MSVC9_OR_LATER 1 -# endif -# if _MSC_VER == 1600 -# define XED_MSVC10 1 -# endif -# if _MSC_VER >= 1600 -# define XED_MSVC10_OR_LATER 1 -# endif -# endif -#endif - -/* I've had compatibility problems here so I'm using a trivial indirection */ -#if defined(__GNUC__) -# if defined(__CYGWIN__) - /* cygwin's gcc 3.4.4 on windows complains */ -# define XED_FMT_X "%lx" -# define XED_FMT_08X "%08lx" -# define XED_FMT_D "%ld" -# define XED_FMT_U "%lu" -# define XED_FMT_9U "%9lu" -# else -# define XED_FMT_X "%x" -# define XED_FMT_08X "%08x" -# define XED_FMT_D "%d" -# define XED_FMT_U "%u" -# define XED_FMT_9U "%9u" -# endif -#else -# define XED_FMT_X "%x" -# define XED_FMT_08X "%08x" -# define XED_FMT_D "%d" -# define XED_FMT_U "%u" -# define XED_FMT_9U "%9u" -#endif - -// Go write portable code... Sigh -#if defined(__APPLE__) // clang *32b* and 64b -# define XED_FMT_SIZET "%lu" -#elif defined(__LP64__) // 64b gcc, icc -# define XED_FMT_SIZET "%lu" -#elif defined (_M_X64) // 64b msvs, ICL - // MSVS/x64 accepts %llu or %lu, icl/x64 does not) -# define XED_FMT_SIZET "%llu" -#else // 32b everything else -# define XED_FMT_SIZET "%u" -#endif - -#if defined(__GNUC__) && defined(__LP64__) && !defined(__APPLE__) -# define XED_FMT_LX "%lx" -# define XED_FMT_LX_UPPER "%lX" -# define XED_FMT_LU "%lu" -# define XED_FMT_LU12 "%12lu" -# define XED_FMT_LD "%ld" -# define XED_FMT_LX16 "%016lx" -# define XED_FMT_LX16_UPPER "%016lX" -#else -# define XED_FMT_LX "%llx" -# define XED_FMT_LX_UPPER "%llX" -# define XED_FMT_LU "%llu" -# define XED_FMT_LU12 "%12llu" -# define XED_FMT_LD "%lld" -# define XED_FMT_LX16 "%016llx" -# define XED_FMT_LX16_UPPER "%016llX" -#endif - -#if defined(__LP64__) || defined (_M_X64) -# define XED_64B 1 -#endif - -#if defined(_M_IA64) -# define XED_IPF -# define XED_FMT_SIZET "%lu" -#endif - -#if defined(__GNUC__) - /* gcc4.2.x has a bug with c99/gnu99 inlining */ -# if __GNUC__ == 4 && __GNUC_MINOR__ == 2 -# define XED_INLINE inline -# else -# if __GNUC__ == 2 -# define XED_INLINE -# else -# define XED_INLINE inline -# endif -# endif -# define XED_NORETURN __attribute__ ((noreturn)) -# if __GNUC__ == 2 -# define XED_NOINLINE -# else -# define XED_NOINLINE __attribute__ ((noinline)) -# endif -#else -# define XED_INLINE __inline -# if defined(XED_MSVC6) -# define XED_NOINLINE -# else -# define XED_NOINLINE __declspec(noinline) -# endif -# define XED_NORETURN __declspec(noreturn) -#endif - - - -#define XED_MAX(a, b) (((a) > (b)) ? (a):(b)) -#define XED_MIN(a, b) (((a) < (b)) ? (a):(b)) - - - - -#endif // XED_PORTABILITY_H - diff --git a/target/i386/latx/include/xed/xed-print-info.h b/target/i386/latx/include/xed/xed-print-info.h deleted file mode 100644 index 694bfffb381..00000000000 --- a/target/i386/latx/include/xed/xed-print-info.h +++ /dev/null @@ -1,101 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ - -#if !defined(XED_PRINT_INFO_H) -# define XED_PRINT_INFO_H - -#include "xed-types.h" -#include "xed-decoded-inst.h" -#include "xed-disas.h" // callback function type -#include "xed-syntax-enum.h" -#include "xed-format-options.h" - -/// @ingroup PRINT -/// This contains the information used by the various disassembly printers. -/// Call xed_init_print_info to initialize the fields. Then change the -/// required and optional fields when required. -typedef struct { - - ///////////////////////////////////////// - // REQUIRED FIELDS - users should set these - ///////////////////////////////////////// - - /// the decoded instruction to print - const xed_decoded_inst_t* p; - - /// pointer to the output buffer - char* buf; - - /// length of the output buffer. (bytes) Must be > 25 to start. - int blen; - - ///////////////////////////////////////// - // OPTIONAL FIELDS - user can set these - ///////////////////////////////////////// - - /// program counter location. Must be zero if not used. (Sometimes - /// instructions are disassembled in a temporary buffer at a different - /// location than where they may or will exist in memory). - xed_uint64_t runtime_address; - - /// disassembly_callback MUST be set to zero if not used! If zero, the - /// default disassembly callback is used (if one has been registered). - xed_disassembly_callback_fn_t disassembly_callback; - - /// passed to disassembly callback. Can be zero if not used. - void* context; - - /// default is Intel-syntax (dest on left) - xed_syntax_enum_t syntax; - - /// 1=indicated the format_options field is valid, 0=use default - /// formatting options from xed_format_set_options(). - int format_options_valid; - xed_format_options_t format_options; - - - ///////////////////////////////////////// - // NONPUBLIC FIELDS - Users should not use these! - ///////////////////////////////////////// - - /// internal, do not use - xed_bool_t emitted; - - /// internal, do not use - unsigned int operand_indx; - - /// internal, do not use - unsigned int skip_operand; - - /// internal, do not use - xed_reg_enum_t extra_index_operand; // for MPX - - /// internal, do not use - xed_bool_t implicit; - - /// internal, do not use - xed_bool_t truncate_eip_eosz16; - -} xed_print_info_t; - -// This function initializes the #xed_print_info_t structure. -// You must still set the required fields of that structure. -/// @ingroup PRINT -XED_DLL_EXPORT void xed_init_print_info(xed_print_info_t* pi); - -#endif diff --git a/target/i386/latx/include/xed/xed-reg-class-enum.h b/target/i386/latx/include/xed/xed-reg-class-enum.h deleted file mode 100644 index e97fd1177f0..00000000000 --- a/target/i386/latx/include/xed/xed-reg-class-enum.h +++ /dev/null @@ -1,102 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-reg-class-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_REG_CLASS_ENUM_H) -# define XED_REG_CLASS_ENUM_H -#include "xed-common-hdrs.h" -#define XED_REG_CLASS_INVALID_DEFINED 1 -#define XED_REG_CLASS_BNDCFG_DEFINED 1 -#define XED_REG_CLASS_BNDSTAT_DEFINED 1 -#define XED_REG_CLASS_BOUND_DEFINED 1 -#define XED_REG_CLASS_CR_DEFINED 1 -#define XED_REG_CLASS_DR_DEFINED 1 -#define XED_REG_CLASS_FLAGS_DEFINED 1 -#define XED_REG_CLASS_GPR_DEFINED 1 -#define XED_REG_CLASS_GPR16_DEFINED 1 -#define XED_REG_CLASS_GPR32_DEFINED 1 -#define XED_REG_CLASS_GPR64_DEFINED 1 -#define XED_REG_CLASS_GPR8_DEFINED 1 -#define XED_REG_CLASS_IP_DEFINED 1 -#define XED_REG_CLASS_MASK_DEFINED 1 -#define XED_REG_CLASS_MMX_DEFINED 1 -#define XED_REG_CLASS_MSR_DEFINED 1 -#define XED_REG_CLASS_MXCSR_DEFINED 1 -#define XED_REG_CLASS_PSEUDO_DEFINED 1 -#define XED_REG_CLASS_PSEUDOX87_DEFINED 1 -#define XED_REG_CLASS_SR_DEFINED 1 -#define XED_REG_CLASS_TMP_DEFINED 1 -#define XED_REG_CLASS_TREG_DEFINED 1 -#define XED_REG_CLASS_UIF_DEFINED 1 -#define XED_REG_CLASS_X87_DEFINED 1 -#define XED_REG_CLASS_XCR_DEFINED 1 -#define XED_REG_CLASS_XMM_DEFINED 1 -#define XED_REG_CLASS_YMM_DEFINED 1 -#define XED_REG_CLASS_ZMM_DEFINED 1 -#define XED_REG_CLASS_LAST_DEFINED 1 -typedef enum { - XED_REG_CLASS_INVALID, - XED_REG_CLASS_BNDCFG, - XED_REG_CLASS_BNDSTAT, - XED_REG_CLASS_BOUND, - XED_REG_CLASS_CR, - XED_REG_CLASS_DR, - XED_REG_CLASS_FLAGS, - XED_REG_CLASS_GPR, - XED_REG_CLASS_GPR16, - XED_REG_CLASS_GPR32, - XED_REG_CLASS_GPR64, - XED_REG_CLASS_GPR8, - XED_REG_CLASS_IP, - XED_REG_CLASS_MASK, - XED_REG_CLASS_MMX, - XED_REG_CLASS_MSR, - XED_REG_CLASS_MXCSR, - XED_REG_CLASS_PSEUDO, - XED_REG_CLASS_PSEUDOX87, - XED_REG_CLASS_SR, - XED_REG_CLASS_TMP, - XED_REG_CLASS_TREG, - XED_REG_CLASS_UIF, - XED_REG_CLASS_X87, - XED_REG_CLASS_XCR, - XED_REG_CLASS_XMM, - XED_REG_CLASS_YMM, - XED_REG_CLASS_ZMM, - XED_REG_CLASS_LAST -} xed_reg_class_enum_t; - -/// This converts strings to #xed_reg_class_enum_t types. -/// @param s A C-string. -/// @return #xed_reg_class_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_reg_class_enum_t str2xed_reg_class_enum_t(const char* s); -/// This converts strings to #xed_reg_class_enum_t types. -/// @param p An enumeration element of type xed_reg_class_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_reg_class_enum_t2str(const xed_reg_class_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_reg_class_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_reg_class_enum_t xed_reg_class_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-reg-class.h b/target/i386/latx/include/xed/xed-reg-class.h deleted file mode 100644 index edaf7ae095a..00000000000 --- a/target/i386/latx/include/xed/xed-reg-class.h +++ /dev/null @@ -1,62 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-reg-class.h -/// - -#ifndef XED_REG_CLASS_H -# define XED_REG_CLASS_H - -#include "xed-types.h" -#include "xed-reg-enum.h" // a generated file -#include "xed-reg-class-enum.h" // a generated file - -/// Returns the register class of the given input register. -///@ingroup REGINTFC -XED_DLL_EXPORT xed_reg_class_enum_t xed_reg_class(xed_reg_enum_t r); - -/// Returns the specific width GPR reg class (like XED_REG_CLASS_GPR32 or -/// XED_REG_CLASS_GPR64) -/// for a given GPR register. Or XED_REG_INVALID if not a GPR. -///@ingroup REGINTFC -XED_DLL_EXPORT xed_reg_class_enum_t xed_gpr_reg_class(xed_reg_enum_t r); - -/// Returns the largest enclosing register for any kind of register; This -/// is mostly useful for GPRs. (64b mode assumed) -///@ingroup REGINTFC -XED_DLL_EXPORT xed_reg_enum_t -xed_get_largest_enclosing_register(xed_reg_enum_t r); - -/// Returns the largest enclosing register for any kind of register; This -/// is mostly useful for GPRs in 32b mode. -///@ingroup REGINTFC -XED_DLL_EXPORT xed_reg_enum_t -xed_get_largest_enclosing_register32(xed_reg_enum_t r); - -/// Returns the width, in bits, of the named register. 32b mode -///@ingroup REGINTFC -XED_DLL_EXPORT xed_uint32_t -xed_get_register_width_bits(xed_reg_enum_t r); - -/// Returns the width, in bits, of the named register. 64b mode. -///@ingroup REGINTFC -XED_DLL_EXPORT xed_uint32_t -xed_get_register_width_bits64(xed_reg_enum_t r); - -//////////////////////////////////////////////////////////////////////////// - -#endif diff --git a/target/i386/latx/include/xed/xed-reg-enum.h b/target/i386/latx/include/xed/xed-reg-enum.h deleted file mode 100644 index 4e22ade5cad..00000000000 --- a/target/i386/latx/include/xed/xed-reg-enum.h +++ /dev/null @@ -1,726 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-reg-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_REG_ENUM_H) -# define XED_REG_ENUM_H -#include "xed-common-hdrs.h" -#define XED_REG_INVALID_DEFINED 1 -#define XED_REG_BNDCFGU_DEFINED 1 -#define XED_REG_BNDSTATUS_DEFINED 1 -#define XED_REG_BND0_DEFINED 1 -#define XED_REG_BND1_DEFINED 1 -#define XED_REG_BND2_DEFINED 1 -#define XED_REG_BND3_DEFINED 1 -#define XED_REG_CR0_DEFINED 1 -#define XED_REG_CR1_DEFINED 1 -#define XED_REG_CR2_DEFINED 1 -#define XED_REG_CR3_DEFINED 1 -#define XED_REG_CR4_DEFINED 1 -#define XED_REG_CR5_DEFINED 1 -#define XED_REG_CR6_DEFINED 1 -#define XED_REG_CR7_DEFINED 1 -#define XED_REG_CR8_DEFINED 1 -#define XED_REG_CR9_DEFINED 1 -#define XED_REG_CR10_DEFINED 1 -#define XED_REG_CR11_DEFINED 1 -#define XED_REG_CR12_DEFINED 1 -#define XED_REG_CR13_DEFINED 1 -#define XED_REG_CR14_DEFINED 1 -#define XED_REG_CR15_DEFINED 1 -#define XED_REG_DR0_DEFINED 1 -#define XED_REG_DR1_DEFINED 1 -#define XED_REG_DR2_DEFINED 1 -#define XED_REG_DR3_DEFINED 1 -#define XED_REG_DR4_DEFINED 1 -#define XED_REG_DR5_DEFINED 1 -#define XED_REG_DR6_DEFINED 1 -#define XED_REG_DR7_DEFINED 1 -#define XED_REG_FLAGS_DEFINED 1 -#define XED_REG_EFLAGS_DEFINED 1 -#define XED_REG_RFLAGS_DEFINED 1 -#define XED_REG_AX_DEFINED 1 -#define XED_REG_CX_DEFINED 1 -#define XED_REG_DX_DEFINED 1 -#define XED_REG_BX_DEFINED 1 -#define XED_REG_SP_DEFINED 1 -#define XED_REG_BP_DEFINED 1 -#define XED_REG_SI_DEFINED 1 -#define XED_REG_DI_DEFINED 1 -#define XED_REG_R8W_DEFINED 1 -#define XED_REG_R9W_DEFINED 1 -#define XED_REG_R10W_DEFINED 1 -#define XED_REG_R11W_DEFINED 1 -#define XED_REG_R12W_DEFINED 1 -#define XED_REG_R13W_DEFINED 1 -#define XED_REG_R14W_DEFINED 1 -#define XED_REG_R15W_DEFINED 1 -#define XED_REG_EAX_DEFINED 1 -#define XED_REG_ECX_DEFINED 1 -#define XED_REG_EDX_DEFINED 1 -#define XED_REG_EBX_DEFINED 1 -#define XED_REG_ESP_DEFINED 1 -#define XED_REG_EBP_DEFINED 1 -#define XED_REG_ESI_DEFINED 1 -#define XED_REG_EDI_DEFINED 1 -#define XED_REG_R8D_DEFINED 1 -#define XED_REG_R9D_DEFINED 1 -#define XED_REG_R10D_DEFINED 1 -#define XED_REG_R11D_DEFINED 1 -#define XED_REG_R12D_DEFINED 1 -#define XED_REG_R13D_DEFINED 1 -#define XED_REG_R14D_DEFINED 1 -#define XED_REG_R15D_DEFINED 1 -#define XED_REG_RAX_DEFINED 1 -#define XED_REG_RCX_DEFINED 1 -#define XED_REG_RDX_DEFINED 1 -#define XED_REG_RBX_DEFINED 1 -#define XED_REG_RSP_DEFINED 1 -#define XED_REG_RBP_DEFINED 1 -#define XED_REG_RSI_DEFINED 1 -#define XED_REG_RDI_DEFINED 1 -#define XED_REG_R8_DEFINED 1 -#define XED_REG_R9_DEFINED 1 -#define XED_REG_R10_DEFINED 1 -#define XED_REG_R11_DEFINED 1 -#define XED_REG_R12_DEFINED 1 -#define XED_REG_R13_DEFINED 1 -#define XED_REG_R14_DEFINED 1 -#define XED_REG_R15_DEFINED 1 -#define XED_REG_AL_DEFINED 1 -#define XED_REG_CL_DEFINED 1 -#define XED_REG_DL_DEFINED 1 -#define XED_REG_BL_DEFINED 1 -#define XED_REG_SPL_DEFINED 1 -#define XED_REG_BPL_DEFINED 1 -#define XED_REG_SIL_DEFINED 1 -#define XED_REG_DIL_DEFINED 1 -#define XED_REG_R8B_DEFINED 1 -#define XED_REG_R9B_DEFINED 1 -#define XED_REG_R10B_DEFINED 1 -#define XED_REG_R11B_DEFINED 1 -#define XED_REG_R12B_DEFINED 1 -#define XED_REG_R13B_DEFINED 1 -#define XED_REG_R14B_DEFINED 1 -#define XED_REG_R15B_DEFINED 1 -#define XED_REG_AH_DEFINED 1 -#define XED_REG_CH_DEFINED 1 -#define XED_REG_DH_DEFINED 1 -#define XED_REG_BH_DEFINED 1 -#define XED_REG_ERROR_DEFINED 1 -#define XED_REG_RIP_DEFINED 1 -#define XED_REG_EIP_DEFINED 1 -#define XED_REG_IP_DEFINED 1 -#define XED_REG_K0_DEFINED 1 -#define XED_REG_K1_DEFINED 1 -#define XED_REG_K2_DEFINED 1 -#define XED_REG_K3_DEFINED 1 -#define XED_REG_K4_DEFINED 1 -#define XED_REG_K5_DEFINED 1 -#define XED_REG_K6_DEFINED 1 -#define XED_REG_K7_DEFINED 1 -#define XED_REG_MMX0_DEFINED 1 -#define XED_REG_MMX1_DEFINED 1 -#define XED_REG_MMX2_DEFINED 1 -#define XED_REG_MMX3_DEFINED 1 -#define XED_REG_MMX4_DEFINED 1 -#define XED_REG_MMX5_DEFINED 1 -#define XED_REG_MMX6_DEFINED 1 -#define XED_REG_MMX7_DEFINED 1 -#define XED_REG_SSP_DEFINED 1 -#define XED_REG_IA32_U_CET_DEFINED 1 -#define XED_REG_MXCSR_DEFINED 1 -#define XED_REG_STACKPUSH_DEFINED 1 -#define XED_REG_STACKPOP_DEFINED 1 -#define XED_REG_GDTR_DEFINED 1 -#define XED_REG_LDTR_DEFINED 1 -#define XED_REG_IDTR_DEFINED 1 -#define XED_REG_TR_DEFINED 1 -#define XED_REG_TSC_DEFINED 1 -#define XED_REG_TSCAUX_DEFINED 1 -#define XED_REG_MSRS_DEFINED 1 -#define XED_REG_FSBASE_DEFINED 1 -#define XED_REG_GSBASE_DEFINED 1 -#define XED_REG_TILECONFIG_DEFINED 1 -#define XED_REG_X87CONTROL_DEFINED 1 -#define XED_REG_X87STATUS_DEFINED 1 -#define XED_REG_X87TAG_DEFINED 1 -#define XED_REG_X87PUSH_DEFINED 1 -#define XED_REG_X87POP_DEFINED 1 -#define XED_REG_X87POP2_DEFINED 1 -#define XED_REG_X87OPCODE_DEFINED 1 -#define XED_REG_X87LASTCS_DEFINED 1 -#define XED_REG_X87LASTIP_DEFINED 1 -#define XED_REG_X87LASTDS_DEFINED 1 -#define XED_REG_X87LASTDP_DEFINED 1 -#define XED_REG_ES_DEFINED 1 -#define XED_REG_CS_DEFINED 1 -#define XED_REG_SS_DEFINED 1 -#define XED_REG_DS_DEFINED 1 -#define XED_REG_FS_DEFINED 1 -#define XED_REG_GS_DEFINED 1 -#define XED_REG_TMP0_DEFINED 1 -#define XED_REG_TMP1_DEFINED 1 -#define XED_REG_TMP2_DEFINED 1 -#define XED_REG_TMP3_DEFINED 1 -#define XED_REG_TMP4_DEFINED 1 -#define XED_REG_TMP5_DEFINED 1 -#define XED_REG_TMP6_DEFINED 1 -#define XED_REG_TMP7_DEFINED 1 -#define XED_REG_TMP8_DEFINED 1 -#define XED_REG_TMP9_DEFINED 1 -#define XED_REG_TMP10_DEFINED 1 -#define XED_REG_TMP11_DEFINED 1 -#define XED_REG_TMP12_DEFINED 1 -#define XED_REG_TMP13_DEFINED 1 -#define XED_REG_TMP14_DEFINED 1 -#define XED_REG_TMP15_DEFINED 1 -#define XED_REG_TMM0_DEFINED 1 -#define XED_REG_TMM1_DEFINED 1 -#define XED_REG_TMM2_DEFINED 1 -#define XED_REG_TMM3_DEFINED 1 -#define XED_REG_TMM4_DEFINED 1 -#define XED_REG_TMM5_DEFINED 1 -#define XED_REG_TMM6_DEFINED 1 -#define XED_REG_TMM7_DEFINED 1 -#define XED_REG_UIF_DEFINED 1 -#define XED_REG_ST0_DEFINED 1 -#define XED_REG_ST1_DEFINED 1 -#define XED_REG_ST2_DEFINED 1 -#define XED_REG_ST3_DEFINED 1 -#define XED_REG_ST4_DEFINED 1 -#define XED_REG_ST5_DEFINED 1 -#define XED_REG_ST6_DEFINED 1 -#define XED_REG_ST7_DEFINED 1 -#define XED_REG_XCR0_DEFINED 1 -#define XED_REG_XMM0_DEFINED 1 -#define XED_REG_XMM1_DEFINED 1 -#define XED_REG_XMM2_DEFINED 1 -#define XED_REG_XMM3_DEFINED 1 -#define XED_REG_XMM4_DEFINED 1 -#define XED_REG_XMM5_DEFINED 1 -#define XED_REG_XMM6_DEFINED 1 -#define XED_REG_XMM7_DEFINED 1 -#define XED_REG_XMM8_DEFINED 1 -#define XED_REG_XMM9_DEFINED 1 -#define XED_REG_XMM10_DEFINED 1 -#define XED_REG_XMM11_DEFINED 1 -#define XED_REG_XMM12_DEFINED 1 -#define XED_REG_XMM13_DEFINED 1 -#define XED_REG_XMM14_DEFINED 1 -#define XED_REG_XMM15_DEFINED 1 -#define XED_REG_XMM16_DEFINED 1 -#define XED_REG_XMM17_DEFINED 1 -#define XED_REG_XMM18_DEFINED 1 -#define XED_REG_XMM19_DEFINED 1 -#define XED_REG_XMM20_DEFINED 1 -#define XED_REG_XMM21_DEFINED 1 -#define XED_REG_XMM22_DEFINED 1 -#define XED_REG_XMM23_DEFINED 1 -#define XED_REG_XMM24_DEFINED 1 -#define XED_REG_XMM25_DEFINED 1 -#define XED_REG_XMM26_DEFINED 1 -#define XED_REG_XMM27_DEFINED 1 -#define XED_REG_XMM28_DEFINED 1 -#define XED_REG_XMM29_DEFINED 1 -#define XED_REG_XMM30_DEFINED 1 -#define XED_REG_XMM31_DEFINED 1 -#define XED_REG_YMM0_DEFINED 1 -#define XED_REG_YMM1_DEFINED 1 -#define XED_REG_YMM2_DEFINED 1 -#define XED_REG_YMM3_DEFINED 1 -#define XED_REG_YMM4_DEFINED 1 -#define XED_REG_YMM5_DEFINED 1 -#define XED_REG_YMM6_DEFINED 1 -#define XED_REG_YMM7_DEFINED 1 -#define XED_REG_YMM8_DEFINED 1 -#define XED_REG_YMM9_DEFINED 1 -#define XED_REG_YMM10_DEFINED 1 -#define XED_REG_YMM11_DEFINED 1 -#define XED_REG_YMM12_DEFINED 1 -#define XED_REG_YMM13_DEFINED 1 -#define XED_REG_YMM14_DEFINED 1 -#define XED_REG_YMM15_DEFINED 1 -#define XED_REG_YMM16_DEFINED 1 -#define XED_REG_YMM17_DEFINED 1 -#define XED_REG_YMM18_DEFINED 1 -#define XED_REG_YMM19_DEFINED 1 -#define XED_REG_YMM20_DEFINED 1 -#define XED_REG_YMM21_DEFINED 1 -#define XED_REG_YMM22_DEFINED 1 -#define XED_REG_YMM23_DEFINED 1 -#define XED_REG_YMM24_DEFINED 1 -#define XED_REG_YMM25_DEFINED 1 -#define XED_REG_YMM26_DEFINED 1 -#define XED_REG_YMM27_DEFINED 1 -#define XED_REG_YMM28_DEFINED 1 -#define XED_REG_YMM29_DEFINED 1 -#define XED_REG_YMM30_DEFINED 1 -#define XED_REG_YMM31_DEFINED 1 -#define XED_REG_ZMM0_DEFINED 1 -#define XED_REG_ZMM1_DEFINED 1 -#define XED_REG_ZMM2_DEFINED 1 -#define XED_REG_ZMM3_DEFINED 1 -#define XED_REG_ZMM4_DEFINED 1 -#define XED_REG_ZMM5_DEFINED 1 -#define XED_REG_ZMM6_DEFINED 1 -#define XED_REG_ZMM7_DEFINED 1 -#define XED_REG_ZMM8_DEFINED 1 -#define XED_REG_ZMM9_DEFINED 1 -#define XED_REG_ZMM10_DEFINED 1 -#define XED_REG_ZMM11_DEFINED 1 -#define XED_REG_ZMM12_DEFINED 1 -#define XED_REG_ZMM13_DEFINED 1 -#define XED_REG_ZMM14_DEFINED 1 -#define XED_REG_ZMM15_DEFINED 1 -#define XED_REG_ZMM16_DEFINED 1 -#define XED_REG_ZMM17_DEFINED 1 -#define XED_REG_ZMM18_DEFINED 1 -#define XED_REG_ZMM19_DEFINED 1 -#define XED_REG_ZMM20_DEFINED 1 -#define XED_REG_ZMM21_DEFINED 1 -#define XED_REG_ZMM22_DEFINED 1 -#define XED_REG_ZMM23_DEFINED 1 -#define XED_REG_ZMM24_DEFINED 1 -#define XED_REG_ZMM25_DEFINED 1 -#define XED_REG_ZMM26_DEFINED 1 -#define XED_REG_ZMM27_DEFINED 1 -#define XED_REG_ZMM28_DEFINED 1 -#define XED_REG_ZMM29_DEFINED 1 -#define XED_REG_ZMM30_DEFINED 1 -#define XED_REG_ZMM31_DEFINED 1 -#define XED_REG_LAST_DEFINED 1 -#define XED_REG_BNDCFG_FIRST_DEFINED 1 -#define XED_REG_BNDCFG_LAST_DEFINED 1 -#define XED_REG_BNDSTAT_FIRST_DEFINED 1 -#define XED_REG_BNDSTAT_LAST_DEFINED 1 -#define XED_REG_BOUND_FIRST_DEFINED 1 -#define XED_REG_BOUND_LAST_DEFINED 1 -#define XED_REG_CR_FIRST_DEFINED 1 -#define XED_REG_CR_LAST_DEFINED 1 -#define XED_REG_DR_FIRST_DEFINED 1 -#define XED_REG_DR_LAST_DEFINED 1 -#define XED_REG_FLAGS_FIRST_DEFINED 1 -#define XED_REG_FLAGS_LAST_DEFINED 1 -#define XED_REG_GPR16_FIRST_DEFINED 1 -#define XED_REG_GPR16_LAST_DEFINED 1 -#define XED_REG_GPR32_FIRST_DEFINED 1 -#define XED_REG_GPR32_LAST_DEFINED 1 -#define XED_REG_GPR64_FIRST_DEFINED 1 -#define XED_REG_GPR64_LAST_DEFINED 1 -#define XED_REG_GPR8_FIRST_DEFINED 1 -#define XED_REG_GPR8_LAST_DEFINED 1 -#define XED_REG_GPR8h_FIRST_DEFINED 1 -#define XED_REG_GPR8h_LAST_DEFINED 1 -#define XED_REG_INVALID_FIRST_DEFINED 1 -#define XED_REG_INVALID_LAST_DEFINED 1 -#define XED_REG_IP_FIRST_DEFINED 1 -#define XED_REG_IP_LAST_DEFINED 1 -#define XED_REG_MASK_FIRST_DEFINED 1 -#define XED_REG_MASK_LAST_DEFINED 1 -#define XED_REG_MMX_FIRST_DEFINED 1 -#define XED_REG_MMX_LAST_DEFINED 1 -#define XED_REG_MSR_FIRST_DEFINED 1 -#define XED_REG_MSR_LAST_DEFINED 1 -#define XED_REG_MXCSR_FIRST_DEFINED 1 -#define XED_REG_MXCSR_LAST_DEFINED 1 -#define XED_REG_PSEUDO_FIRST_DEFINED 1 -#define XED_REG_PSEUDO_LAST_DEFINED 1 -#define XED_REG_PSEUDOX87_FIRST_DEFINED 1 -#define XED_REG_PSEUDOX87_LAST_DEFINED 1 -#define XED_REG_SR_FIRST_DEFINED 1 -#define XED_REG_SR_LAST_DEFINED 1 -#define XED_REG_TMP_FIRST_DEFINED 1 -#define XED_REG_TMP_LAST_DEFINED 1 -#define XED_REG_TREG_FIRST_DEFINED 1 -#define XED_REG_TREG_LAST_DEFINED 1 -#define XED_REG_UIF_FIRST_DEFINED 1 -#define XED_REG_UIF_LAST_DEFINED 1 -#define XED_REG_X87_FIRST_DEFINED 1 -#define XED_REG_X87_LAST_DEFINED 1 -#define XED_REG_XCR_FIRST_DEFINED 1 -#define XED_REG_XCR_LAST_DEFINED 1 -#define XED_REG_XMM_FIRST_DEFINED 1 -#define XED_REG_XMM_LAST_DEFINED 1 -#define XED_REG_YMM_FIRST_DEFINED 1 -#define XED_REG_YMM_LAST_DEFINED 1 -#define XED_REG_ZMM_FIRST_DEFINED 1 -#define XED_REG_ZMM_LAST_DEFINED 1 -typedef enum { - XED_REG_INVALID, - XED_REG_BNDCFGU, - XED_REG_BNDSTATUS, - XED_REG_BND0, - XED_REG_BND1, - XED_REG_BND2, - XED_REG_BND3, - XED_REG_CR0, - XED_REG_CR1, - XED_REG_CR2, - XED_REG_CR3, - XED_REG_CR4, - XED_REG_CR5, - XED_REG_CR6, - XED_REG_CR7, - XED_REG_CR8, - XED_REG_CR9, - XED_REG_CR10, - XED_REG_CR11, - XED_REG_CR12, - XED_REG_CR13, - XED_REG_CR14, - XED_REG_CR15, - XED_REG_DR0, - XED_REG_DR1, - XED_REG_DR2, - XED_REG_DR3, - XED_REG_DR4, - XED_REG_DR5, - XED_REG_DR6, - XED_REG_DR7, - XED_REG_FLAGS, - XED_REG_EFLAGS, - XED_REG_RFLAGS, - XED_REG_AX, - XED_REG_CX, - XED_REG_DX, - XED_REG_BX, - XED_REG_SP, - XED_REG_BP, - XED_REG_SI, - XED_REG_DI, - XED_REG_R8W, - XED_REG_R9W, - XED_REG_R10W, - XED_REG_R11W, - XED_REG_R12W, - XED_REG_R13W, - XED_REG_R14W, - XED_REG_R15W, - XED_REG_EAX, - XED_REG_ECX, - XED_REG_EDX, - XED_REG_EBX, - XED_REG_ESP, - XED_REG_EBP, - XED_REG_ESI, - XED_REG_EDI, - XED_REG_R8D, - XED_REG_R9D, - XED_REG_R10D, - XED_REG_R11D, - XED_REG_R12D, - XED_REG_R13D, - XED_REG_R14D, - XED_REG_R15D, - XED_REG_RAX, - XED_REG_RCX, - XED_REG_RDX, - XED_REG_RBX, - XED_REG_RSP, - XED_REG_RBP, - XED_REG_RSI, - XED_REG_RDI, - XED_REG_R8, - XED_REG_R9, - XED_REG_R10, - XED_REG_R11, - XED_REG_R12, - XED_REG_R13, - XED_REG_R14, - XED_REG_R15, - XED_REG_AL, - XED_REG_CL, - XED_REG_DL, - XED_REG_BL, - XED_REG_SPL, - XED_REG_BPL, - XED_REG_SIL, - XED_REG_DIL, - XED_REG_R8B, - XED_REG_R9B, - XED_REG_R10B, - XED_REG_R11B, - XED_REG_R12B, - XED_REG_R13B, - XED_REG_R14B, - XED_REG_R15B, - XED_REG_AH, - XED_REG_CH, - XED_REG_DH, - XED_REG_BH, - XED_REG_ERROR, - XED_REG_RIP, - XED_REG_EIP, - XED_REG_IP, - XED_REG_K0, - XED_REG_K1, - XED_REG_K2, - XED_REG_K3, - XED_REG_K4, - XED_REG_K5, - XED_REG_K6, - XED_REG_K7, - XED_REG_MMX0, - XED_REG_MMX1, - XED_REG_MMX2, - XED_REG_MMX3, - XED_REG_MMX4, - XED_REG_MMX5, - XED_REG_MMX6, - XED_REG_MMX7, - XED_REG_SSP, - XED_REG_IA32_U_CET, - XED_REG_MXCSR, - XED_REG_STACKPUSH, - XED_REG_STACKPOP, - XED_REG_GDTR, - XED_REG_LDTR, - XED_REG_IDTR, - XED_REG_TR, - XED_REG_TSC, - XED_REG_TSCAUX, - XED_REG_MSRS, - XED_REG_FSBASE, - XED_REG_GSBASE, - XED_REG_TILECONFIG, - XED_REG_X87CONTROL, - XED_REG_X87STATUS, - XED_REG_X87TAG, - XED_REG_X87PUSH, - XED_REG_X87POP, - XED_REG_X87POP2, - XED_REG_X87OPCODE, - XED_REG_X87LASTCS, - XED_REG_X87LASTIP, - XED_REG_X87LASTDS, - XED_REG_X87LASTDP, - XED_REG_ES, - XED_REG_CS, - XED_REG_SS, - XED_REG_DS, - XED_REG_FS, - XED_REG_GS, - XED_REG_TMP0, - XED_REG_TMP1, - XED_REG_TMP2, - XED_REG_TMP3, - XED_REG_TMP4, - XED_REG_TMP5, - XED_REG_TMP6, - XED_REG_TMP7, - XED_REG_TMP8, - XED_REG_TMP9, - XED_REG_TMP10, - XED_REG_TMP11, - XED_REG_TMP12, - XED_REG_TMP13, - XED_REG_TMP14, - XED_REG_TMP15, - XED_REG_TMM0, - XED_REG_TMM1, - XED_REG_TMM2, - XED_REG_TMM3, - XED_REG_TMM4, - XED_REG_TMM5, - XED_REG_TMM6, - XED_REG_TMM7, - XED_REG_UIF, - XED_REG_ST0, - XED_REG_ST1, - XED_REG_ST2, - XED_REG_ST3, - XED_REG_ST4, - XED_REG_ST5, - XED_REG_ST6, - XED_REG_ST7, - XED_REG_XCR0, - XED_REG_XMM0, - XED_REG_XMM1, - XED_REG_XMM2, - XED_REG_XMM3, - XED_REG_XMM4, - XED_REG_XMM5, - XED_REG_XMM6, - XED_REG_XMM7, - XED_REG_XMM8, - XED_REG_XMM9, - XED_REG_XMM10, - XED_REG_XMM11, - XED_REG_XMM12, - XED_REG_XMM13, - XED_REG_XMM14, - XED_REG_XMM15, - XED_REG_XMM16, - XED_REG_XMM17, - XED_REG_XMM18, - XED_REG_XMM19, - XED_REG_XMM20, - XED_REG_XMM21, - XED_REG_XMM22, - XED_REG_XMM23, - XED_REG_XMM24, - XED_REG_XMM25, - XED_REG_XMM26, - XED_REG_XMM27, - XED_REG_XMM28, - XED_REG_XMM29, - XED_REG_XMM30, - XED_REG_XMM31, - XED_REG_YMM0, - XED_REG_YMM1, - XED_REG_YMM2, - XED_REG_YMM3, - XED_REG_YMM4, - XED_REG_YMM5, - XED_REG_YMM6, - XED_REG_YMM7, - XED_REG_YMM8, - XED_REG_YMM9, - XED_REG_YMM10, - XED_REG_YMM11, - XED_REG_YMM12, - XED_REG_YMM13, - XED_REG_YMM14, - XED_REG_YMM15, - XED_REG_YMM16, - XED_REG_YMM17, - XED_REG_YMM18, - XED_REG_YMM19, - XED_REG_YMM20, - XED_REG_YMM21, - XED_REG_YMM22, - XED_REG_YMM23, - XED_REG_YMM24, - XED_REG_YMM25, - XED_REG_YMM26, - XED_REG_YMM27, - XED_REG_YMM28, - XED_REG_YMM29, - XED_REG_YMM30, - XED_REG_YMM31, - XED_REG_ZMM0, - XED_REG_ZMM1, - XED_REG_ZMM2, - XED_REG_ZMM3, - XED_REG_ZMM4, - XED_REG_ZMM5, - XED_REG_ZMM6, - XED_REG_ZMM7, - XED_REG_ZMM8, - XED_REG_ZMM9, - XED_REG_ZMM10, - XED_REG_ZMM11, - XED_REG_ZMM12, - XED_REG_ZMM13, - XED_REG_ZMM14, - XED_REG_ZMM15, - XED_REG_ZMM16, - XED_REG_ZMM17, - XED_REG_ZMM18, - XED_REG_ZMM19, - XED_REG_ZMM20, - XED_REG_ZMM21, - XED_REG_ZMM22, - XED_REG_ZMM23, - XED_REG_ZMM24, - XED_REG_ZMM25, - XED_REG_ZMM26, - XED_REG_ZMM27, - XED_REG_ZMM28, - XED_REG_ZMM29, - XED_REG_ZMM30, - XED_REG_ZMM31, - XED_REG_LAST, - XED_REG_BNDCFG_FIRST=XED_REG_BNDCFGU, //< PSEUDO - XED_REG_BNDCFG_LAST=XED_REG_BNDCFGU, //mmode=arg_mmode; - p->stack_addr_width=arg_stack_addr_width; - (void) arg_ignored; //pacify compiler unused arg warning -} - -/// Constructor. -/// The mode, and addresses widths are enumerations that specify the number -/// of bits. In 64b mode (#XED_MACHINE_MODE_LONG_64) the address width and -/// stack address widths are 64b (#XED_ADDRESS_WIDTH_64b). In other machine -/// modes, you must specify valid addressing widths. -/// -/// @param p the pointer to the #xed_state_t type -/// @param arg_mmode the machine mode of type #xed_machine_mode_enum_t -/// @param arg_stack_addr_width the stack address width of type #xed_address_width_enum_t (only required if not the mode is not #XED_MACHINE_MODE_LONG_64) -/// @ingroup INIT -static XED_INLINE void xed_state_init2(xed_state_t* p, - xed_machine_mode_enum_t arg_mmode, - xed_address_width_enum_t arg_stack_addr_width) { - p->mmode=arg_mmode; - p->stack_addr_width=arg_stack_addr_width; -} - -/// clear the xed_state_t -/// @ingroup INIT -static XED_INLINE void xed_state_zero(xed_state_t* p) { - p->mmode= XED_MACHINE_MODE_INVALID; - p->stack_addr_width=XED_ADDRESS_WIDTH_INVALID; -} - -//@} - -/// @name Machine mode -//@{ -/// return the machine mode -/// @ingroup INIT -static XED_INLINE xed_machine_mode_enum_t xed_state_get_machine_mode(const xed_state_t* p) { - return p->mmode; -} - - -/// true iff the machine is in LONG_64 mode -/// @ingroup INIT -static XED_INLINE xed_bool_t xed_state_long64_mode(const xed_state_t* p) { - return xed_state_get_machine_mode(p) == XED_MACHINE_MODE_LONG_64; -} - -/// @ingroup INIT -static XED_INLINE xed_bool_t xed_state_real_mode(const xed_state_t* p) { - xed_machine_mode_enum_t mmode = xed_state_get_machine_mode(p); - return ( mmode == XED_MACHINE_MODE_REAL_16 || - mmode == XED_MACHINE_MODE_REAL_32 ); -} - -/// @ingroup INIT -static XED_INLINE xed_bool_t xed_state_mode_width_16(const xed_state_t* p) { - return (xed_state_get_machine_mode(p) == XED_MACHINE_MODE_LEGACY_16) || - (xed_state_get_machine_mode(p) == XED_MACHINE_MODE_LONG_COMPAT_16); -} - -/// @ingroup INIT -static XED_INLINE xed_bool_t xed_state_mode_width_32(const xed_state_t* p) { - return (xed_state_get_machine_mode(p) == XED_MACHINE_MODE_LEGACY_32) || - (xed_state_get_machine_mode(p) == XED_MACHINE_MODE_LONG_COMPAT_32); -} - - -/// Set the machine mode which corresponds to the default data operand size -/// @ingroup INIT -static XED_INLINE void xed_state_set_machine_mode( xed_state_t* p, - xed_machine_mode_enum_t arg_mode) { - p->mmode = arg_mode; -} -//@} - -/// @name Address width -//@{ - -/// return the address width -/// @ingroup INIT -static XED_INLINE xed_address_width_enum_t -xed_state_get_address_width(const xed_state_t* p) -{ - switch(xed_state_get_machine_mode(p)) { - case XED_MACHINE_MODE_LONG_64: - return XED_ADDRESS_WIDTH_64b; - - case XED_MACHINE_MODE_REAL_16: - case XED_MACHINE_MODE_REAL_32: - /* should be 20b... but if you are working w/real mode then you're - going to have to deal with somehow. Could easily make this be - 20b if anyone cares. */ - return XED_ADDRESS_WIDTH_32b; - - case XED_MACHINE_MODE_LEGACY_32: - case XED_MACHINE_MODE_LONG_COMPAT_32: - return XED_ADDRESS_WIDTH_32b; - case XED_MACHINE_MODE_LEGACY_16: - case XED_MACHINE_MODE_LONG_COMPAT_16: - return XED_ADDRESS_WIDTH_16b; - default: - return XED_ADDRESS_WIDTH_INVALID; - } -} - -//@} - -/// @name Stack address width -//@{ -/// set the STACK address width -/// @ingroup INIT -static XED_INLINE void -xed_state_set_stack_address_width(xed_state_t* p, - xed_address_width_enum_t arg_addr_width) -{ - p->stack_addr_width = arg_addr_width; -} - - -/// Return the STACK address width -/// @ingroup INIT -static XED_INLINE xed_address_width_enum_t xed_state_get_stack_address_width(const xed_state_t* p) { - return p->stack_addr_width; -} -//@} - -/// @ingroup INIT -XED_DLL_EXPORT int xed_state_print(const xed_state_t* p, char* buf, int buflen); - -#endif - diff --git a/target/i386/latx/include/xed/xed-syntax-enum.h b/target/i386/latx/include/xed/xed-syntax-enum.h deleted file mode 100644 index 42cb9306cce..00000000000 --- a/target/i386/latx/include/xed/xed-syntax-enum.h +++ /dev/null @@ -1,54 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-syntax-enum.h - -// This file was automatically generated. -// Do not edit this file. - -#if !defined(XED_SYNTAX_ENUM_H) -# define XED_SYNTAX_ENUM_H -#include "xed-common-hdrs.h" -#define XED_SYNTAX_INVALID_DEFINED 1 -#define XED_SYNTAX_XED_DEFINED 1 -#define XED_SYNTAX_ATT_DEFINED 1 -#define XED_SYNTAX_INTEL_DEFINED 1 -#define XED_SYNTAX_LAST_DEFINED 1 -typedef enum { - XED_SYNTAX_INVALID, - XED_SYNTAX_XED, ///< XED disassembly syntax - XED_SYNTAX_ATT, ///< ATT SYSV disassembly syntax - XED_SYNTAX_INTEL, ///< Intel disassembly syntax - XED_SYNTAX_LAST -} xed_syntax_enum_t; - -/// This converts strings to #xed_syntax_enum_t types. -/// @param s A C-string. -/// @return #xed_syntax_enum_t -/// @ingroup ENUM -XED_DLL_EXPORT xed_syntax_enum_t str2xed_syntax_enum_t(const char* s); -/// This converts strings to #xed_syntax_enum_t types. -/// @param p An enumeration element of type xed_syntax_enum_t. -/// @return string -/// @ingroup ENUM -XED_DLL_EXPORT const char* xed_syntax_enum_t2str(const xed_syntax_enum_t p); - -/// Returns the last element of the enumeration -/// @return xed_syntax_enum_t The last element of the enumeration. -/// @ingroup ENUM -XED_DLL_EXPORT xed_syntax_enum_t xed_syntax_enum_t_last(void); -#endif diff --git a/target/i386/latx/include/xed/xed-types.h b/target/i386/latx/include/xed/xed-types.h deleted file mode 100644 index 46483e4b3ca..00000000000 --- a/target/i386/latx/include/xed/xed-types.h +++ /dev/null @@ -1,131 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-types.h -/// - - -#ifndef XED_TYPES_H -# define XED_TYPES_H - -//////////////////////////////////////////////////////////////////////////// - -#include "xed-common-hdrs.h" - -#if defined(__GNUC__) || defined(__ICC) -# include -# define xed_uint8_t uint8_t -# define xed_uint16_t uint16_t -# define xed_uint32_t uint32_t -# define xed_uint64_t uint64_t -# define xed_int8_t int8_t -# define xed_int16_t int16_t -# define xed_int32_t int32_t -# define xed_int64_t int64_t -#elif defined(_WIN32) -# define xed_uint8_t unsigned __int8 -# define xed_uint16_t unsigned __int16 -# define xed_uint32_t unsigned __int32 -# define xed_uint64_t unsigned __int64 -# define xed_int8_t __int8 -# define xed_int16_t __int16 -# define xed_int32_t __int32 -# define xed_int64_t __int64 -#else -# error "XED types unsupported platform? Need windows, gcc, or icc." -#endif - -typedef unsigned int xed_uint_t; -typedef int xed_int_t; -typedef unsigned int xed_bits_t; -typedef unsigned int xed_bool_t; - -#if defined(__LP64__) || defined (_M_X64) -typedef xed_uint64_t xed_addr_t; -#else -typedef xed_uint32_t xed_addr_t; -#endif - - -typedef union { - xed_uint8_t byte[2]; - xed_int8_t s_byte[2]; - - struct { - xed_uint8_t b0; /*low 8 bits*/ - xed_uint8_t b1; /*high 8 bits*/ - } b; - xed_int16_t i16; - xed_uint16_t u16; -} xed_union16_t ; - -typedef union { - xed_uint8_t byte[4]; - xed_uint16_t word[2]; - xed_int8_t s_byte[4]; - xed_int16_t s_word[2]; - - struct { - xed_uint8_t b0; /*low 8 bits*/ - xed_uint8_t b1; - xed_uint8_t b2; - xed_uint8_t b3; /*high 8 bits*/ - } b; - - struct { - xed_uint16_t w0; /*low 16 bits*/ - xed_uint16_t w1; /*high 16 bits*/ - } w; - xed_int32_t i32; - xed_uint32_t u32; -} xed_union32_t ; - -typedef union { - xed_uint8_t byte[8]; - xed_uint16_t word[4]; - xed_uint32_t dword[2]; - xed_int8_t s_byte[8]; - xed_int16_t s_word[4]; - xed_int32_t s_dword[2]; - - struct { - xed_uint8_t b0; /*low 8 bits*/ - xed_uint8_t b1; - xed_uint8_t b2; - xed_uint8_t b3; - xed_uint8_t b4; - xed_uint8_t b5; - xed_uint8_t b6; - xed_uint8_t b7; /*high 8 bits*/ - } b; - - struct { - xed_uint16_t w0; /*low 16 bits*/ - xed_uint16_t w1; - xed_uint16_t w2; - xed_uint16_t w3; /*high 16 bits*/ - } w; - struct { - xed_uint32_t lo32; - xed_uint32_t hi32; - } s; - xed_uint64_t u64; - xed_int64_t i64; -} xed_union64_t ; - -//////////////////////////////////////////////////////////////////////////// -#endif diff --git a/target/i386/latx/include/xed/xed-util.h b/target/i386/latx/include/xed/xed-util.h deleted file mode 100644 index 9d36d649f24..00000000000 --- a/target/i386/latx/include/xed/xed-util.h +++ /dev/null @@ -1,254 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ -/// @file xed-util.h -/// - - - -#ifndef XED_UTIL_H -# define XED_UTIL_H - -#include "xed-common-hdrs.h" -#include "xed-types.h" -#include "xed-portability.h" - - - -extern int xed_verbose; -#if defined(XED_MESSAGES) -# include -extern FILE* xed_log_file; -# define XED_EMIT_MESSAGES (xed_verbose >= 1) -# define XED_INFO_VERBOSE (xed_verbose >= 2) -# define XED_INFO2_VERBOSE (xed_verbose >= 3) -# define XED_VERBOSE (xed_verbose >= 4) -# define XED_MORE_VERBOSE (xed_verbose >= 5) -# define XED_VERY_VERBOSE (xed_verbose >= 6) -#else -# define XED_EMIT_MESSAGES (0) -# define XED_INFO_VERBOSE (0) -# define XED_INFO2_VERBOSE (0) -# define XED_VERBOSE (0) -# define XED_MORE_VERBOSE (0) -# define XED_VERY_VERBOSE (0) -#endif - -#if defined(__GNUC__) -# define XED_FUNCNAME __func__ -#else -# define XED_FUNCNAME "" -#endif - -#if defined(XED_MESSAGES) -#define XED2IMSG(x) \ - do { \ - if (XED_EMIT_MESSAGES) { \ - if (XED_VERY_VERBOSE) { \ - fprintf(xed_log_file,"%s:%d:%s: ", \ - __FILE__, __LINE__, XED_FUNCNAME); \ - } \ - fprintf x; \ - fflush(xed_log_file); \ - } \ - } while(0) - -#define XED2TMSG(x) \ - do { \ - if (XED_VERBOSE) { \ - if (XED_VERY_VERBOSE) { \ - fprintf(xed_log_file,"%s:%d:%s: ", \ - __FILE__, __LINE__, XED_FUNCNAME); \ - } \ - fprintf x; \ - fflush(xed_log_file); \ - } \ - } while(0) - -#define XED2VMSG(x) \ - do { \ - if (XED_VERY_VERBOSE) { \ - fprintf(xed_log_file,"%s:%d:%s: ", \ - __FILE__, __LINE__, XED_FUNCNAME); \ - fprintf x; \ - fflush(xed_log_file); \ - } \ - } while(0) - -// Example usage: -// XED2DIE((xed_log_file,"%s\n", msg)); - -#define XED2DIE(x) \ - do { \ - if (XED_EMIT_MESSAGES) { \ - fprintf(xed_log_file,"%s:%d:%s: ", \ - __FILE__, __LINE__, XED_FUNCNAME); \ - fprintf x; \ - fflush(xed_log_file); \ - } \ - xed_assert(0); \ - } while(0) - - - -#else -# define XED2IMSG(x) -# define XED2TMSG(x) -# define XED2VMSG(x) -# define XED2DIE(x) do { xed_assert(0); } while(0) -#endif - -#if defined(XED_ASSERTS) -# define xed_assert(x) do { if (( x )== 0) xed_internal_assert( #x, __FILE__, __LINE__); } while(0) -#else -# define xed_assert(x) do { } while(0) -#endif -XED_NORETURN XED_NOINLINE XED_DLL_EXPORT void xed_internal_assert(const char* s, const char* file, int line); - -typedef void (*xed_user_abort_function_t)(const char* msg, - const char* file, - int line, - void* other); - -/// @ingroup INIT -/// This is for registering a function to be called during XED's assert -/// processing. If you do not register an abort function, then the system's -/// abort function will be called. If your supplied function returns, then -/// abort() will still be called. -/// -/// @param fn This is a function pointer for a function that should handle the -/// assertion reporting. The function pointer points to a function that -/// takes 4 arguments: -/// (1) msg, the assertion message, -/// (2) file, the file name, -/// (3) line, the line number (as an integer), and -/// (4) other, a void pointer that is supplied as thei -/// 2nd argument to this registration. -/// @param other This is a void* that is passed back to your supplied function fn -/// as its 4th argument. It can be zero if you don't need this -/// feature. You can used this to convey whatever additional context -/// to your assertion handler (like FILE* pointers etc.). -/// -XED_DLL_EXPORT void xed_register_abort_function(xed_user_abort_function_t fn, - void* other); - - -XED_DLL_EXPORT int xed_itoa(char* buf, - xed_uint64_t f, - int buflen); - -/// defaults to lowercase -XED_DLL_EXPORT int xed_itoa_hex_zeros(char* buf, - xed_uint64_t f, - xed_uint_t bits_to_print, - xed_bool_t leading_zeros, - int buflen); - -/// defaults to lowercase -XED_DLL_EXPORT int xed_itoa_hex(char* buf, - xed_uint64_t f, - xed_uint_t bits_to_print, - int buflen); - -XED_DLL_EXPORT int xed_itoa_hex_ul(char* buf, - xed_uint64_t f, - xed_uint_t bits_to_print, - xed_bool_t leading_zeros, - int buflen, - xed_bool_t lowercase); - - -/// Set the FILE* for XED's log msgs. This takes a FILE* as a void* because -/// some software defines their own FILE* types creating conflicts. -XED_DLL_EXPORT void xed_set_log_file(void* o); - - -/// Set the verbosity level for XED -XED_DLL_EXPORT void xed_set_verbosity(int v); - -XED_DLL_EXPORT xed_int64_t xed_sign_extend32_64(xed_int32_t x); -XED_DLL_EXPORT xed_int64_t xed_sign_extend16_64(xed_int16_t x); -XED_DLL_EXPORT xed_int64_t xed_sign_extend8_64(xed_int8_t x); - -XED_DLL_EXPORT xed_int32_t xed_sign_extend16_32(xed_int16_t x); -XED_DLL_EXPORT xed_int32_t xed_sign_extend8_32(xed_int8_t x); - -XED_DLL_EXPORT xed_int16_t xed_sign_extend8_16(xed_int8_t x); - -///arbitrary sign extension from a qty of "bits" length to 32b -XED_DLL_EXPORT xed_int32_t xed_sign_extend_arbitrary_to_32(xed_uint32_t x, unsigned int bits); - -///arbitrary sign extension from a qty of "bits" length to 64b -XED_DLL_EXPORT xed_int64_t xed_sign_extend_arbitrary_to_64(xed_uint64_t x, unsigned int bits); - - -XED_DLL_EXPORT xed_uint64_t xed_zero_extend32_64(xed_uint32_t x); -XED_DLL_EXPORT xed_uint64_t xed_zero_extend16_64(xed_uint16_t x); -XED_DLL_EXPORT xed_uint64_t xed_zero_extend8_64(xed_uint8_t x); - -XED_DLL_EXPORT xed_uint32_t xed_zero_extend16_32(xed_uint16_t x); -XED_DLL_EXPORT xed_uint32_t xed_zero_extend8_32(xed_uint8_t x); - -XED_DLL_EXPORT xed_uint16_t xed_zero_extend8_16(xed_uint8_t x); - -#if defined(XED_LITTLE_ENDIAN_SWAPPING) -XED_DLL_EXPORT xed_int32_t -xed_little_endian_to_int32(xed_uint64_t x, unsigned int len); - -XED_DLL_EXPORT xed_int64_t -xed_little_endian_to_int64(xed_uint64_t x, unsigned int len); -XED_DLL_EXPORT xed_uint64_t -xed_little_endian_to_uint64(xed_uint64_t x, unsigned int len); - -XED_DLL_EXPORT xed_int64_t -xed_little_endian_hilo_to_int64(xed_uint32_t hi_le, xed_uint32_t lo_le, unsigned int len); -XED_DLL_EXPORT xed_uint64_t -xed_little_endian_hilo_to_uint64(xed_uint32_t hi_le, xed_uint32_t lo_le, unsigned int len); -#endif - -XED_DLL_EXPORT xed_uint8_t -xed_get_byte(xed_uint64_t x, unsigned int i, unsigned int len); - -static XED_INLINE xed_uint64_t xed_make_uint64(xed_uint32_t hi, xed_uint32_t lo) { - xed_union64_t y; - y.s.lo32= lo; - y.s.hi32= hi; - return y.u64; -} -static XED_INLINE xed_int64_t xed_make_int64(xed_uint32_t hi, xed_uint32_t lo) { - xed_union64_t y; - y.s.lo32= lo; - y.s.hi32= hi; - return y.i64; -} - -/// returns the number of bytes required to store the UNSIGNED number x -/// given a mask of legal lengths. For the legal_widths argument, bit 0 -/// implies 1 byte is a legal return width, bit 1 implies that 2 bytes is a -/// legal return width, bit 2 implies that 4 bytes is a legal return width. -/// This returns 8 (indicating 8B) if none of the provided legal widths -/// applies. -XED_DLL_EXPORT xed_uint_t xed_shortest_width_unsigned(xed_uint64_t x, xed_uint8_t legal_widths); - -/// returns the number of bytes required to store the SIGNED number x -/// given a mask of legal lengths. For the legal_widths argument, bit 0 implies 1 -/// byte is a legal return width, bit 1 implies that 2 bytes is a legal -/// return width, bit 2 implies that 4 bytes is a legal return width. This -/// returns 8 (indicating 8B) if none of the provided legal widths applies. -XED_DLL_EXPORT xed_uint_t xed_shortest_width_signed(xed_int64_t x, xed_uint8_t legal_widths); - -#endif diff --git a/target/i386/latx/include/xed/xed-version.h b/target/i386/latx/include/xed/xed-version.h deleted file mode 100644 index 25ff315c892..00000000000 --- a/target/i386/latx/include/xed/xed-version.h +++ /dev/null @@ -1,29 +0,0 @@ -/* BEGIN_LEGAL - -Copyright (c) 2021 Intel Corporation - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - -END_LEGAL */ - -#if !defined(XED_VERSION_H) -# define XED_VERSION_H -#include "xed-common-hdrs.h" - -///@ingroup INIT -/// Returns a string representing XED svn commit revision and time stamp. -XED_DLL_EXPORT char const* xed_get_version(void); -///@ingroup INIT -/// Returns a copyright string. -XED_DLL_EXPORT char const* xed_get_copyright(void); -#endif diff --git a/target/i386/latx/ir1/ir1.c b/target/i386/latx/ir1/ir1.c index 5c399f2e0ac..e354b5e08e9 100644 --- a/target/i386/latx/ir1/ir1.c +++ b/target/i386/latx/ir1/ir1.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include #include #include diff --git a/target/i386/latx/ir2/ir2-assemble.c b/target/i386/latx/ir2/ir2-assemble.c index c2451bc4619..45e473d4bef 100644 --- a/target/i386/latx/ir2/ir2-assemble.c +++ b/target/i386/latx/ir2/ir2-assemble.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "ir2.h" #include "translate.h" #include "ir2-la-assemble.h" diff --git a/target/i386/latx/ir2/ir2-relocate.c b/target/i386/latx/ir2/ir2-relocate.c index 5c671d5f5f0..ab94fcafb23 100644 --- a/target/i386/latx/ir2/ir2-relocate.c +++ b/target/i386/latx/ir2/ir2-relocate.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "ir2-relocate.h" #include "latx-options.h" #include "la-append.h" diff --git a/target/i386/latx/ir2/ir2.c b/target/i386/latx/ir2/ir2.c index 85c95fef2c0..b237e5e4630 100644 --- a/target/i386/latx/ir2/ir2.c +++ b/target/i386/latx/ir2/ir2.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "ir1.h" #include "lsenv.h" diff --git a/target/i386/latx/ir2/la-decode.c b/target/i386/latx/ir2/la-decode.c index b89380b116a..5f3ad63b2a1 100644 --- a/target/i386/latx/ir2/la-decode.c +++ b/target/i386/latx/ir2/la-decode.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "ir2.h" #define LISA_FADD_H LISA_INVALID diff --git a/target/i386/latx/ir2/la-disasm.c b/target/i386/latx/ir2/la-disasm.c index 9f2c9f541f7..24672ac745b 100644 --- a/target/i386/latx/ir2/la-disasm.c +++ b/target/i386/latx/ir2/la-disasm.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "ir2.h" #include "ir2-la-assemble.h" diff --git a/target/i386/latx/latx-config.c b/target/i386/latx/latx-config.c index 751d797ec2a..7f8db8d458c 100644 --- a/target/i386/latx/latx-config.c +++ b/target/i386/latx/latx-config.c @@ -1,6 +1,11 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "config-host.h" #include "common.h" -#include "diStorm/distorm.h" #include "ir1.h" #include "ir2.h" #include "lsenv.h" @@ -461,14 +466,19 @@ void latx_fast_jmp_cache_clear(CPUState *cs, int h) X86CPU *cpu = X86_CPU(cs); CPUX86State *env = &cpu->env; FastTB *fast_jmp_cache = (FastTB *)env->tb_jmp_cache_ptr; - qatomic_set(&fast_jmp_cache[h].pc, 0); + qatomic_set(&fast_jmp_cache[h].pc, FASTTB_INVALID_PC); } void latx_fast_jmp_cache_clear_all(CPUState *cs) { X86CPU *cpu = X86_CPU(cs); CPUX86State *env = &cpu->env; - memset(env->tb_jmp_cache_ptr, 0, sizeof(struct FastTB) * TB_JMP_CACHE_SIZE); + FastTB *fast_jmp_cache = (FastTB *)env->tb_jmp_cache_ptr; + + for (int i = 0; i < TB_JMP_CACHE_SIZE; i++) { + fast_jmp_cache[i].pc = FASTTB_INVALID_PC; + fast_jmp_cache[i].ptr = NULL; + } } bool latx_fast_jmp_cache_init(void *env) @@ -480,6 +490,9 @@ bool latx_fast_jmp_cache_init(void *env) if (!fast_jmp_cache) { return false; } + for (int i = 0; i < TB_JMP_CACHE_SIZE; i++) { + fast_jmp_cache[i].pc = FASTTB_INVALID_PC; + } x86env->tb_jmp_cache_ptr = fast_jmp_cache; return true; diff --git a/target/i386/latx/latx-disassemble-trace/capstone_git.c b/target/i386/latx/latx-disassemble-trace/capstone_git.c index 55d19ba908e..9b6ef21f6a3 100644 --- a/target/i386/latx/latx-disassemble-trace/capstone_git.c +++ b/target/i386/latx/latx-disassemble-trace/capstone_git.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "capstone_git.h" #undef X86_INS_ #define LATX_DT_X86 0 diff --git a/target/i386/latx/latx-disassemble-trace/latx-disassemble-trace.c b/target/i386/latx/latx-disassemble-trace/latx-disassemble-trace.c index e184a6e2a98..8b6c02ee3da 100644 --- a/target/i386/latx/latx-disassemble-trace/latx-disassemble-trace.c +++ b/target/i386/latx/latx-disassemble-trace/latx-disassemble-trace.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "latx-disassemble-trace.h" #ifdef LATX_DISASSEMBLE_TRACE_DEBUG int dt_debug_enable = 1; @@ -19,9 +25,6 @@ void disassemble_trace_init(int abi_bits, int args) case OPT_V1LACAPSTONE: la_disa_v1 = &gitcapstone_get; break; - case OPT_V1LAXED: - la_disa_v1 = &laxed_get; - break; case OPT_V1LAZYDIS: la_disa_v1 = &lazydis_get; break; @@ -37,9 +40,6 @@ void disassemble_trace_init(int abi_bits, int args) case OPT_V2NEXTCAPSTONE: la_disa_v2 = &gitcapstone_get; break; - case OPT_V2LAXED: - la_disa_v2 = &laxed_get; - break; case OPT_V2LAZYDIS: la_disa_v2 = &lazydis_get; break; @@ -50,7 +50,6 @@ void disassemble_trace_init(int abi_bits, int args) disassemble_trace_cmp = &disassemble_trace_loop; } gitcapstone_init(abi_bits); - laxed_init(abi_bits); lazydis_init(abi_bits); } static int64_t imm_cast(int64_t imm, uint32_t size) @@ -188,4 +187,3 @@ void disassemble_trace_loop(const uint8_t *code, size_t code_size, disassemble_trace_dump(inputinsn, ret); } } - diff --git a/target/i386/latx/latx-disassemble-trace/nextcapstone.c b/target/i386/latx/latx-disassemble-trace/nextcapstone.c index c65673a83a0..89c47a58239 100644 --- a/target/i386/latx/latx-disassemble-trace/nextcapstone.c +++ b/target/i386/latx/latx-disassemble-trace/nextcapstone.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "nextcapstone.h" #undef X86_INS_ diff --git a/target/i386/latx/latx-disassemble-trace/xed.c b/target/i386/latx/latx-disassemble-trace/xed.c deleted file mode 100644 index ab12ddc3792..00000000000 --- a/target/i386/latx/latx-disassemble-trace/xed.c +++ /dev/null @@ -1,2302 +0,0 @@ -#include "laxed.h" -#undef XED_ICLASS_ - -la_name_enum_t la_xed_insn_tr[XED_ICLASS_LAST + 1]; -la_name_enum_t la_xed_insn_reg[XED_REG_LAST + 1]; - -xed_state_t dstate[2]; -xed_decoded_inst_t xedd; -uint8_t dt_laxed_mode; -static void handle_prefix(struct la_dt_insn *ret, xed_decoded_inst_t *inputinfo) -{ - /* - *first prefix f3, f2 or f0 - */ - if (xed_operand_values_has_rep_prefix(inputinfo)) { - ret->x86.prefix[0] = 0xf3; - } else if (xed_operand_values_has_repne_prefix(inputinfo)) { - ret->x86.prefix[0] = 0xf2; - } else if (xed_operand_values_has_lock_prefix(inputinfo)) { - ret->x86.prefix[0] = 0xf0; - } - /* - *second prefix 2E, 36, 3E, 26, 64 or 65H - */ - ret->x86.prefix[1] = xed3_operand_get_ild_seg(inputinfo); - /* - *third 66 - */ - if (xed_operand_values_has_66_prefix(inputinfo)) { - ret->x86.prefix[2] = 0x66; - } - /* - *last 67 - */ - if (xed_operand_values_has_address_size_prefix(inputinfo)) { - ret->x86.prefix[3] = 0x67; - } -} -static void handle_opcode(struct la_dt_insn *ret, xed_decoded_inst_t *inputinfo) -{ - uint8_t opcode_end = xed3_operand_get_nominal_opcode(inputinfo); - char *op_str = (char *)(intptr_t)ret->address; - xed_bits_t op_ops = xed3_operand_get_pos_nominal_opcode(inputinfo); - int find_0f = 0; - /* - *0x0f is XED_ILD_LEGACY_MAP0, capstone not set. - */ - while ((op_ops > 0) && (op_str[op_ops - 1] == 0x0f)) { - op_ops--; - find_0f = 1; - } - if (find_0f) { - for (int i = op_ops, j = 0; i < 24; i++) { - ret->x86.opcode[j++] = op_str[i]; - if (op_str[i] == opcode_end) { - break; - } - } - } else { - ret->x86.opcode[0] = opcode_end; - } - -} - -#ifdef LATX_DISASSEMBLE_TRACE_DEBUG -static char xed_tolower(char c) -{ - if (c >= 'A' && c <= 'Z') { - return c - 'A' + 'a'; - } - return c; -} - -static int xed_strncat_lower(char *dst, const char *src, int len) -{ - xed_uint_t dst_len = xed_strlen(dst); - xed_uint_t orig_max = dst_len + XED_STATIC_CAST(xed_uint_t, len); - xed_uint_t i; - xed_uint_t src_len = xed_strlen(src); - xed_uint_t copy_max = src_len; - xed_uint_t ulen = (xed_uint_t)len - 1; - if (len <= 0) { - return 0; - } - - /* - * do not copy more bytes than fit in the buffer including the null - */ - - if (src_len > ulen) { - copy_max = ulen; - } - - for (i = 0; i < copy_max; i++) { - dst[dst_len + i] = xed_tolower(src[i]); - } - - dst[dst_len + copy_max] = 0; - /* - * should never go negative - */ - return XED_STATIC_CAST(int, orig_max - xed_strlen(dst)); -} - -static void handle_dis_str(struct la_dt_insn *ret, - xed_decoded_inst_t *inputinfo) -{ -#define XED_TMP_BUF_LEN (160 + 32) - char instruction_name[32] = {0}; - char buf[XED_TMP_BUF_LEN] = {0}; - char *op_start; - xed_iform_enum_t iform = xed_decoded_inst_get_iform_enum(inputinfo); - xed_strncat_lower(instruction_name, - xed_iform_to_iclass_string_intel(iform), 32); - xed_format_context(XED_SYNTAX_INTEL, inputinfo, buf, - XED_TMP_BUF_LEN, ret->address, 0, 0); - strncpy(ret->mnemonic, instruction_name, 32); - op_start = strstr(buf, instruction_name); - if (op_start) { - strncpy(ret->op_str, op_start + strlen(instruction_name) + 1, 160); - } else { - dtassert(0); - } -} -#endif - -static xed_bool_t stringop_memop(const xed_decoded_inst_t *p, - const xed_operand_t *o) -{ - xed_bool_t stringop = - (xed_decoded_inst_get_category(p) == XED_CATEGORY_STRINGOP); - if (stringop) { - xed_operand_enum_t op_name = xed_operand_name(o); - if (op_name == XED_OPERAND_MEM0 || op_name == XED_OPERAND_MEM1) { - return 1; - } - } - return 0; -} - -static void seg_prefix_for_suppressed_operands( - const xed_operand_values_t *ov, - const xed_operand_t *op) -{ - xed_uint_t i; - xed_operand_enum_t op_name = xed_operand_name(op); - /* - * suppressed memops with nondefault segments get their segment printed - */ - const xed_operand_enum_t names[] = { XED_OPERAND_MEM0, XED_OPERAND_MEM1}; - for (i = 0; i < 2; i++) { - if (op_name == names[i]) { - xed_reg_enum_t seg = XED_REG_INVALID; - switch (i) { - case 0: - seg = xed3_operand_get_seg0(ov); - break; - case 1: - seg = xed3_operand_get_seg1(ov); - break; - } - if (seg != XED_REG_INVALID && - xed_operand_values_using_default_segment(ov, i) == 0) { - dtassert(0); - } - } - } -} - -static int64_t mask_value_bybit(int64_t value, uint8_t ibits) -{ - switch (ibits) { - case 0: - break; - case 4: - value &= 0xf; - break; - case 8: - value &= 0xff; - break; - case 16: - value &= 0xffff; - break; - case 32: - value &= 0xffffffff; - break; - case 64: - value &= 0xffffffffffffffff; - break; - default: - dtassert(0); - } - return value; -} -static int64_t xed_imm_cast(int32_t imm, uint32_t size) -{ - switch (size) { - case 0: - return 0; - case 1: - return LA_STATIC_CAST(int8_t, imm); - case 2: - return LA_STATIC_CAST(int16_t, imm); - case 4: - return LA_STATIC_CAST(int32_t, imm); - case 8: - return LA_STATIC_CAST(int64_t, imm); - default: - dtassert(0); - } - return imm; -} -struct la_dt_insn *laxed_get_from_insn(int64_t address, - xed_decoded_inst_t *inputinfo, - int ir1_num, void *pir1_base) -{ - if (inputinfo == NULL) { - return NULL; - } - struct la_dt_insn *ret; - if (pir1_base) { - uint64_t current_address = (uint64_t)pir1_base + - (ir1_num * sizeof(struct la_dt_insn)); - ret = (void *)current_address; - memset(ret, 0, sizeof(struct la_dt_insn)); - } else { - ret = calloc(1, sizeof(struct la_dt_insn)); - } - ret->address = address; -#ifdef LATX_DISASSEMBLE_TRACE_DEBUG - handle_dis_str(ret, inputinfo); -#endif - xed_iclass_enum_t iclass = XED_ICLASS_INVALID; - const xed_operand_values_t *ov = xed_decoded_inst_operands_const(inputinfo); - if (xed_operand_values_has_real_rep(ov)) { - iclass = - xed_rep_remove(xed_decoded_inst_get_iclass(inputinfo)); - } else { - iclass = xed_decoded_inst_get_iclass(inputinfo); - } - dtassert((iclass <= XED_ICLASS_LAST) && - (la_xed_insn_tr[iclass].id != dt_X86_INS_INVALID)); - ret->id = la_xed_insn_tr[iclass].id; - handle_prefix(ret, inputinfo); - handle_opcode(ret, inputinfo); - ret->size = xed_decoded_inst_get_length(inputinfo); - for (int i = 0; i < ret->size; i++) { - ret->bytes[i] = xed_decoded_inst_get_byte(inputinfo, i); - } - ret->x86.addr_size = xed_operand_values_get_effective_address_width( - xed_decoded_inst_operands_const(inputinfo)) / 8; - if (dt_laxed_mode == 64) { - ret->x86.rex = xed3_operand_get_rex(inputinfo) << 6; - ret->x86.rex |= xed3_operand_get_rexb(inputinfo) << 0; - ret->x86.rex |= xed3_operand_get_rexx(inputinfo) << 1; - ret->x86.rex |= xed3_operand_get_rexr(inputinfo) << 2; - ret->x86.rex |= xed3_operand_get_rexw(inputinfo) << 3; - } - const xed_inst_t *xi = xed_decoded_inst_inst(inputinfo); - int xed_ocount = xed_inst_noperands(xi); - int opcount = 0; - int findmem[2] = {0}, memc = 0; -#define XED_GRAMMAR_MODE_32 1 -#define XED_GRAMMAR_MODE_64 2 - /*cpuid skip opnd*/ - if (iclass == XED_ICLASS_CPUID) { - goto foroperand; - } - for (int i = 0; i < xed_ocount; i++) { - const xed_operand_t *op = xed_inst_operand(xi, i); - if (xed_operand_operand_visibility(op) == XED_OPVIS_SUPPRESSED) { - if (!stringop_memop(inputinfo, op)) { - seg_prefix_for_suppressed_operands(ov, op); - continue; - } - } - xed_operand_enum_t op_name = xed_operand_name(op); - ret->x86.operands[opcount].size = - xed_decoded_inst_operand_length_bits(inputinfo, i) / 8; - switch (op_name) { - case XED_OPERAND_AGEN: - case XED_OPERAND_MEM0: - case XED_OPERAND_MEM1: { - findmem[memc++] = opcount; - ret->x86.operands[opcount++].type = dt_X86_OP_MEM; - break; - } - case XED_OPERAND_PTR: /* pointer (always in conjunction with a IMM0)*/ - case XED_OPERAND_RELBR: { /* branch displacements*/ - lsassert(xed_decoded_inst_get_branch_displacement_width(inputinfo)); - if (xed_decoded_inst_get_branch_displacement_width(inputinfo)) { - ret->x86.operands[opcount].imm = - ret->address + - xed_decoded_inst_get_branch_displacement(inputinfo); - if (op_name == XED_OPERAND_RELBR) { - ret->x86.operands[opcount].imm += ret->size; - switch (dt_laxed_mode) { - case 32: - ret->x86.operands[opcount].size = 4; - break; - case 64: - ret->x86.operands[opcount].size = 8; - break; - default: - dtassert(0); - } - } - ret->x86.operands[opcount++].type = dt_X86_OP_IMM; - } - break; - } - case XED_OPERAND_IMM0: { - xed_uint_t ibits = xed_decoded_inst_get_operand_width(inputinfo); - if (xed3_operand_get_imm0signed(inputinfo)) { - ret->x86.operands[opcount].imm = XED_STATIC_CAST(xed_uint64_t, - xed_sign_extend_arbitrary_to_64( - xed_operand_values_get_immediate_int64(ov), - ibits)); - ret->x86.operands[opcount].imm = - mask_value_bybit(ret->x86.operands[opcount].imm, ibits); - } else { - ret->x86.operands[opcount].imm = - xed_operand_values_get_immediate_uint64(ov); - } - ret->x86.operands[opcount].size = ibits / 8; - ret->x86.operands[opcount++].type = dt_X86_OP_IMM; - break; - } - case XED_OPERAND_IMM1: { /* 2nd immediate is always 1 byte.*/ - ret->x86.operands[opcount].imm = xed3_operand_get_uimm1(inputinfo); - ret->x86.operands[opcount++].type = dt_X86_OP_IMM; - break; - } - case XED_OPERAND_REG0: - case XED_OPERAND_REG1: - case XED_OPERAND_REG2: - case XED_OPERAND_REG3: - case XED_OPERAND_REG4: - case XED_OPERAND_REG5: - case XED_OPERAND_REG6: - case XED_OPERAND_REG7: - case XED_OPERAND_REG8: - case XED_OPERAND_REG9: { - xed_reg_enum_t r = xed_decoded_inst_get_reg(inputinfo, op_name); - if (((r == XED_REG_STACKPOP) || (r == XED_REG_STACKPUSH))) { - ret->x86.op_count = opcount; - goto foroperand; - } - /* skip eflag or eip */ - if (r == XED_REG_EFLAGS || r == XED_REG_EIP) { - continue; - } - ret->x86.operands[opcount].reg = la_xed_insn_reg[r].id; - ret->x86.operands[opcount++].type = dt_X86_OP_REG; - break; - } - case XED_OPERAND_BASE0: - case XED_OPERAND_BASE1: - continue; - default: - lsassert(0); - } - } -foroperand: - ret->x86.op_count = opcount; - dtassert(xed_decoded_inst_number_of_memory_operands(inputinfo) >= memc); - for (int i = 0; i < memc; i++) { - int memindex = findmem[i]; - unsigned int seg; - lsassert(memindex <= ret->x86.op_count); - lsassert(ret->x86.operands[memindex].type == dt_X86_OP_MEM); - ret->x86.operands[memindex].access = dt_CS_AC_INVALID; - if (xed_decoded_inst_mem_read(inputinfo, i)) { - ret->x86.operands[memindex].access |= dt_CS_AC_READ; - } - if (xed_decoded_inst_mem_written(inputinfo, i)) { - ret->x86.operands[memindex].access |= dt_CS_AC_WRITE; - } - seg = xed_decoded_inst_get_seg_reg(inputinfo, i); - /* skip default segment */ - if (((i == 0) && - (!xed3_operand_get_using_default_segment0(inputinfo))) || - ((i == 1) && - (!xed3_operand_get_using_default_segment1(inputinfo)))) { - ret->x86.operands[memindex].mem.segment = - la_xed_insn_reg[seg].id; - ret->x86.operands[memindex].mem.default_segment = - dt_X86_INS_INVALID; - } else { - ret->x86.operands[memindex].mem.segment = - dt_X86_INS_INVALID; - ret->x86.operands[memindex].mem.default_segment = - la_xed_insn_reg[seg].id; - } - ret->x86.operands[memindex].mem.base = - la_xed_insn_reg[xed_decoded_inst_get_base_reg(inputinfo, i)].id; - if (i == 0) { - ret->x86.operands[memindex].mem.index = - la_xed_insn_reg[xed_decoded_inst_get_index_reg(inputinfo, i)].id; - ret->x86.operands[memindex].mem.scale = - xed_decoded_inst_get_scale(inputinfo, i); - } - ret->x86.operands[memindex].mem.disp = - xed_decoded_inst_get_memory_displacement(inputinfo, i); - if (!((ret->x86.operands[memindex].mem.base != dt_X86_REG_INVALID) && - ret->x86.operands[memindex].mem.disp < 0)) { - xed_int_t disbit = - xed_decoded_inst_get_memory_displacement_width_bits( - inputinfo, i); - ret->x86.operands[memindex].mem.disp = - mask_value_bybit(ret->x86.operands[memindex].mem.disp, disbit); - } - ret->x86.operands[memindex].mem.disp = - xed_imm_cast(ret->x86.operands[memindex].mem.disp, - dt_laxed_mode / 8); - } - return ret; -} - -int laxed_get(const uint8_t *code, size_t code_size, - uint64_t address, - size_t count, struct la_dt_insn **insn, - int ir1_num, void *pir1_base, int mode) -{ - xed_error_enum_t xed_error; - struct la_dt_insn *ret; - memset(&xedd, 0, sizeof(xed_operand_values_t)); - xed_operand_values_set_mode(&xedd, &dstate[mode]); - xed_error = xed_decode(&xedd, code, code_size); - switch (xed_error) { - case XED_ERROR_NONE: - break; - case XED_ERROR_BUFFER_TOO_SHORT: - printf("Not enough bytes provided\n"); - exit(1); - case XED_ERROR_INVALID_FOR_CHIP: - printf("The instruction was not valid for the specified chip.\n"); - exit(1); - case XED_ERROR_GENERAL_ERROR: - printf("Could not decode given input.\n"); - exit(1); - default: - printf("Unhandled error code %s\n", - xed_error_enum_t2str(xed_error)); - exit(1); - } - ret = laxed_get_from_insn(address, &xedd, ir1_num, pir1_base); - *insn = ret; - return 1; -} - -static void init_insn_id(void); -static void init_insn_reg(void); -static void dt_xed_init(int abi_bits) -{ - xed_tables_init(); - xed_state_zero(&dstate[0]); - dstate[0].mmode = XED_MACHINE_MODE_LEGACY_32; - dstate[0].stack_addr_width = XED_ADDRESS_WIDTH_32b; - xed_tables_init(); - xed_state_zero(&dstate[1]); - dstate[0].mmode = XED_MACHINE_MODE_LONG_64; - -} - -void laxed_init(int abi_bits) -{ - dt_laxed_mode = abi_bits; - dt_xed_init(abi_bits); - init_insn_id(); - init_insn_reg(); -} -static void init_insn_reg(void) -{ - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, INVALID); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, AH); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, AL); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, AX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, BH); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, BL); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, BP); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, BPL); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, BX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CH); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CL); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CS); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DH); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DI); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DIL); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DL); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DS); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, EAX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, EBP); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, EBX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ECX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, EDI); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, EDX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, EFLAGS); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, EIP); -/* - * LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, EIZ); - */ - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ES); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ESI); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ESP); -/* - * LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, FPSW); - */ - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, FS); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, GS); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, IP); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, RAX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, RBP); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, RBX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, RCX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, RDI); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, RDX); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, RIP); -/* - * LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, RIZ); - */ - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, RSI); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, RSP); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, SI); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, SIL); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, SP); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, SPL); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, SS); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR0); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR1); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR2); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR3); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR4); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR5); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR6); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR7); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR8); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR9); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR10); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR11); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR12); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR13); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR14); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, CR15); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR0); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR1); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR2); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR3); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR4); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR5); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR6); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR7); -/* - * LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR8); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR9); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR10); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR11); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR12); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR13); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR14); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, DR15); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, FP0); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, FP1); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, FP2); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, FP3); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, FP4); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, FP5); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, FP6); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, FP7); - */ - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, K0); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, K1); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, K2); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, K3); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, K4); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, K5); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, K6); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, K7); - LA_X86_INSN_REENUM(la_xed_insn_reg, XED_REG_MMX0, dt_X86_REG_MM0); - LA_X86_INSN_REENUM(la_xed_insn_reg, XED_REG_MMX1, dt_X86_REG_MM1); - LA_X86_INSN_REENUM(la_xed_insn_reg, XED_REG_MMX2, dt_X86_REG_MM2); - LA_X86_INSN_REENUM(la_xed_insn_reg, XED_REG_MMX3, dt_X86_REG_MM3); - LA_X86_INSN_REENUM(la_xed_insn_reg, XED_REG_MMX4, dt_X86_REG_MM4); - LA_X86_INSN_REENUM(la_xed_insn_reg, XED_REG_MMX5, dt_X86_REG_MM5); - LA_X86_INSN_REENUM(la_xed_insn_reg, XED_REG_MMX6, dt_X86_REG_MM6); - LA_X86_INSN_REENUM(la_xed_insn_reg, XED_REG_MMX7, dt_X86_REG_MM7); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R8); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R9); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R10); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R11); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R12); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R13); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R14); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R15); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ST0); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ST1); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ST2); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ST3); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ST4); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ST5); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ST6); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ST7); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM0); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM1); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM2); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM3); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM4); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM5); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM6); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM7); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM8); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM9); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM10); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM11); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM12); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM13); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM14); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM15); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM16); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM17); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM18); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM19); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM20); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM21); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM22); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM23); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM24); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM25); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM26); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM27); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM28); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM29); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM30); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, XMM31); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM0); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM1); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM2); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM3); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM4); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM5); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM6); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM7); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM8); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM9); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM10); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM11); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM12); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM13); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM14); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM15); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM16); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM17); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM18); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM19); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM20); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM21); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM22); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM23); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM24); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM25); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM26); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM27); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM28); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM29); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM30); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, YMM31); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM0); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM1); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM2); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM3); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM4); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM5); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM6); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM7); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM8); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM9); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM10); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM11); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM12); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM13); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM14); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM15); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM16); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM17); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM18); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM19); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM20); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM21); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM22); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM23); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM24); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM25); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM26); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM27); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM28); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM29); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM30); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, ZMM31); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R8B); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R9B); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R10B); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R11B); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R12B); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R13B); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R14B); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R15B); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R8D); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R9D); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R10D); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R11D); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R12D); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R13D); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R14D); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R15D); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R8W); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R9W); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R10W); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R11W); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R12W); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R13W); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R14W); - LA_X86_INSN_ENUM(la_xed_insn_reg, XED_REG_, X86_REG_, R15W); - LA_X86_INSN_REENUM(la_xed_insn_reg, XED_REG_LAST, dt_X86_REG_ENDING); - -} - -static void init_insn_id(void) -{ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INVALID); - - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, AAA); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, AAD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, AAM); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, AAS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FABS); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, ADC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ADCX); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, ADD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ADDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ADDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ADDSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ADDSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ADDSUBPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ADDSUBPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FADD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FIADD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FADDP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ADOX); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, AESDECLAST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, AESDEC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, AESENCLAST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, AESENC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, AESIMC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, AESKEYGENASSIST); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, AND); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ANDN); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ANDNPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ANDNPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ANDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ANDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ARPL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BEXTR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLCFILL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLCI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLCIC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLCMSK); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLCS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLENDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLENDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLENDVPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLENDVPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLSFILL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLSI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLSIC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLSMSK); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BLSR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BOUND); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BSF); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BSR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BSWAP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BT); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, BTC); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, BTR); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, BTS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, BZHI); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_CALL_NEAR, dt_X86_INS_CALL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CDQE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCHS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CLAC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CLC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CLFLUSH); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CLFLUSHOPT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CLGI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CLI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CLTS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CLWB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMC); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_CMOVNBE, dt_X86_INS_CMOVA); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_CMOVNB, dt_X86_INS_CMOVAE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMOVB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMOVBE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCMOVBE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCMOVB); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_CMOVZ, dt_X86_INS_CMOVE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCMOVE); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_CMOVNLE, dt_X86_INS_CMOVG); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_CMOVNL, dt_X86_INS_CMOVGE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMOVL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMOVLE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCMOVNBE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCMOVNB); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_CMOVNZ, dt_X86_INS_CMOVNE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCMOVNE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMOVNO); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMOVNP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCMOVNU); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMOVNS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMOVO); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMOVP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCMOVU); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMOVS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPSQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPSW); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, CMPXCHG16B); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, CMPXCHG); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, CMPXCHG8B); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, COMISD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, COMISS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCOMP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCOMIP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCOMI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCOM); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCOS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CPUID); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CQO); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CRC32); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTDQ2PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTDQ2PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTPD2DQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTPD2PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTPS2DQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTPS2PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTSD2SI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTSD2SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTSI2SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTSI2SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTSS2SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTSS2SI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTTPD2DQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTTPS2DQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTTSD2SI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTTSS2SI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CWDE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, DAA); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, DAS); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, DATA16); - */ - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, DEC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, DIV); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, DIVPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, DIVPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FDIVR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FIDIVR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FDIVRP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, DIVSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, DIVSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FDIV); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FIDIV); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FDIVP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, DPPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, DPPS); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_RET_NEAR, dt_X86_INS_RET); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ENCLS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ENCLU); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ENTER); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, EXTRACTPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, EXTRQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, F2XM1); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LCALL); - */ -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LJMP); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FBLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FBSTP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FCOMPP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FDECSTP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FEMMS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FFREE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FICOM); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FICOMP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FINCSTP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FLDCW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FLDENV); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FLDL2E); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FLDL2T); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FLDLG2); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FLDLN2); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FLDPI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FNCLEX); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FNINIT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FNOP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FNSTCW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FNSTSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FPATAN); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FPREM); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FPREM1); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FPTAN); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FFREEP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FRNDINT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FRSTOR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FNSAVE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FSCALE); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FSETPM); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FSINCOS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FNSTENV); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FXAM); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FXRSTOR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FXRSTOR64); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FXSAVE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FXSAVE64); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FXTRACT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FYL2X); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FYL2XP1); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVAPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVAPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ORPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ORPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVAPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVAPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XORPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XORPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, GETSEC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, HADDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, HADDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, HLT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, HSUBPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, HSUBPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, IDIV); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FILD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, IMUL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, IN); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, INC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INSERTPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INSERTQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INT1); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INT3); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INTO); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INVD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INVEPT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INVLPG); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INVLPGA); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INVPCID); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, INVVPID); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, IRET); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, IRETD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, IRETQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FISTTP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FIST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FISTP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, UCOMISD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, UCOMISS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCOMISD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCOMISS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTSD2SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTSI2SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTSI2SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTSS2SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTTSD2SI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTTSD2USI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTTSS2SI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTTSS2USI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTUSI2SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTUSI2SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VUCOMISD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VUCOMISS); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_JNB, dt_X86_INS_JAE); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_JNBE, dt_X86_INS_JA); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JBE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JCXZ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JECXZ); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_JZ, dt_X86_INS_JE); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_JNL, dt_X86_INS_JGE); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_JNLE, dt_X86_INS_JG); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JLE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JMP); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_JNZ, dt_X86_INS_JNE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JNO); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JNP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JNS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JO); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JRCXZ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, JS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KANDB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KANDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KANDNB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KANDND); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KANDNQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KANDNW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KANDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KANDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KMOVB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KMOVD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KMOVQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KMOVW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KNOTB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KNOTD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KNOTQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KNOTW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KORB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KORD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KORQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KORTESTB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KORTESTD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KORTESTQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KORTESTW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KORW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KSHIFTLB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KSHIFTLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KSHIFTLQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KSHIFTLW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KSHIFTRB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KSHIFTRD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KSHIFTRQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KSHIFTRW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KUNPCKBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KXNORB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KXNORD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KXNORQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KXNORW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KXORB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KXORD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KXORQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, KXORW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LAHF); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LAR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LDDQU); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LDMXCSR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LDS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FLDZ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FLD1); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LEA); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LEAVE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LES); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LFENCE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LFS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LGDT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LGS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LIDT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LLDT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LMSW); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, OR); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, SUB); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, XOR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LODSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LODSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LODSQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LODSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LOOP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LOOPE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LOOPNE); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RETF); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RETFQ); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LSL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LTR); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, XADD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, LZCNT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MASKMOVDQU); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MAXPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MAXPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MAXSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MAXSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MFENCE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MINPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MINPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MINSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MINSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTPD2PI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTPI2PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTPI2PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTPS2PI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTTPD2PI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CVTTPS2PI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, EMMS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MASKMOVQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVDQ2Q); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVNTQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVQ2DQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PABSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PABSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PABSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PACKSSDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PACKSSWB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PACKUSWB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PADDB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PADDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PADDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PADDSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PADDSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PADDUSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PADDUSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PADDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PALIGNR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PANDN); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PAND); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PAVGB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PAVGW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPEQB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPEQD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPEQW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPGTB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPGTD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPGTW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PEXTRW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PHADDSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PHADDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PHADDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PHSUBD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PHSUBSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PHSUBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PINSRW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMADDUBSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMADDWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMAXSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMAXUB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMINSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMINUB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVMSKB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMULHRSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMULHUW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMULHW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMULLW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMULUDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, POR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSADBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSHUFB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSHUFW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSIGNB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSIGND); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSIGNW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSLLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSLLQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSLLW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSRAD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSRAW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSRLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSRLQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSRLW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSUBB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSUBD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSUBQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSUBSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSUBSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSUBUSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSUBUSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSUBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUNPCKHBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUNPCKHDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUNPCKHWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUNPCKLBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUNPCKLDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUNPCKLWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PXOR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MONITOR); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MONTMUL); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOV); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVABS); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVBE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVDDUP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVDQA); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVDQU); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVHLPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVHPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVHPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVLHPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVLPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVLPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVMSKPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVMSKPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVNTDQA); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVNTDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVNTI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVNTPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVNTPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVNTSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVNTSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVSB); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_MOVSD_XMM, dt_X86_INS_MOVSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVSHDUP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVSLDUP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVSQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVSX); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVSXD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVUPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVUPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MOVZX); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MPSADBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MUL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MULPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MULPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MULSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MULSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MULX); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FMUL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FIMUL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FMULP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, MWAIT); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, NEG); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, NOP); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, NOT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, OUT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, OUTSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, OUTSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, OUTSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PACKUSDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PAUSE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PAVGUSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PBLENDVB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PBLENDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCLMULQDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPEQQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPESTRI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPESTRM); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPGTQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPISTRI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCMPISTRM); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PCOMMIT); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PDEP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PEXT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PEXTRB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PEXTRD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PEXTRQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PF2ID); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PF2IW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFACC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFADD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFCMPEQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFCMPGE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFCMPGT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFMAX); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFMIN); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFMUL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFNACC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFPNACC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFRCPIT1); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFRCPIT2); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFRCP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFRSQIT1); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFRSQRT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFSUBR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PFSUB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PHMINPOSUW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PI2FD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PI2FW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PINSRB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PINSRD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PINSRQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMAXSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMAXSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMAXUD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMAXUW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMINSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMINSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMINUD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMINUW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVSXBD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVSXBQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVSXBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVSXDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVSXWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVSXWQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVZXBD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVZXBQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVZXBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVZXDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVZXWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMOVZXWQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMULDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMULHRW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PMULLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, POP); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, POPAW); - */ - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_POPAD, dt_X86_INS_POPAL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, POPCNT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, POPF); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, POPFD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, POPFQ); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PREFETCH); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PREFETCHNTA); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PREFETCHT0); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PREFETCHT1); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PREFETCHT2); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PREFETCHW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSHUFD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSHUFHW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSHUFLW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSLLDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSRLDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PSWAPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PTEST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUNPCKHQDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUNPCKLQDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUSH); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUSHAW); - */ - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_PUSHAD, dt_X86_INS_PUSHAL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUSHF); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUSHFD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, PUSHFQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RCL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RCPPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RCPSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RCR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RDFSBASE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RDGSBASE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RDMSR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RDPMC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RDRAND); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RDSEED); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RDTSC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RDTSCP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ROL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ROR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RORX); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ROUNDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ROUNDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ROUNDSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ROUNDSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RSM); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RSQRTPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, RSQRTSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SAHF); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SAL); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SALC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SAR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SARX); - LA_X86_INSN_DEF_LOCK(la_xed_insn_tr, XED_ICLASS_, SBB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SCASB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SCASD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SCASQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SCASW); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_SETNB, dt_X86_INS_SETAE); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_SETNBE, dt_X86_INS_SETA); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SETBE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SETB); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_SETZ, dt_X86_INS_SETE); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_SETNL, dt_X86_INS_SETGE); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_SETNLE, dt_X86_INS_SETG); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SETLE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SETL); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_SETNZ, dt_X86_INS_SETNE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SETNO); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SETNP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SETNS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SETO); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SETP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SETS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SFENCE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SGDT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHA1MSG1); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHA1MSG2); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHA1NEXTE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHA1RNDS4); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHA256MSG1); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHA256MSG2); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHA256RNDS2); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHLX); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHRD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHRX); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHUFPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SHUFPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SIDT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FSIN); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SKINIT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SLDT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SMSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SQRTPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SQRTPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SQRTSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SQRTSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FSQRT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, STAC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, STC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, STD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, STGI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, STI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, STMXCSR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, STOSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, STOSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, STOSQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, STOSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, STR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FSTP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FSTPNCE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FXCH); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SUBPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SUBPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FSUBR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FISUBR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FSUBRP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SUBSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SUBSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FSUB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FISUB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FSUBP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SWAPGS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SYSCALL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SYSENTER); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SYSEXIT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, SYSRET); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, T1MSKC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, TEST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, UD2); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FTST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, TZCNT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, TZMSK); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FUCOMIP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FUCOMI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FUCOMPP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FUCOMP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FUCOM); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, UD2B); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, UNPCKHPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, UNPCKHPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, UNPCKLPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, UNPCKLPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VADDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VADDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VADDSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VADDSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VADDSUBPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VADDSUBPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VAESDECLAST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VAESDEC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VAESENCLAST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VAESENC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VAESIMC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VAESKEYGENASSIST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VALIGND); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VALIGNQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VANDNPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VANDNPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VANDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VANDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VBLENDMPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VBLENDMPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VBLENDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VBLENDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VBLENDVPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VBLENDVPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VBROADCASTF128); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VBROADCASTI32X4); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VBROADCASTI64X4); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VBROADCASTSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VBROADCASTSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCOMPRESSPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCOMPRESSPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTDQ2PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTDQ2PS); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTPD2DQX); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTPD2DQ); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTPD2PSX); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTPD2PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTPD2UDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTPH2PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTPS2DQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTPS2PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTPS2PH); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTPS2UDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTSD2SI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTSD2USI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTSS2SI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTSS2USI); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTTPD2DQX); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTTPD2DQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTTPD2UDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTTPS2DQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTTPS2UDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTUDQ2PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCVTUDQ2PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VDIVPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VDIVPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VDIVSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VDIVSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VDPPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VDPPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VERR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VERW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VEXP2PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VEXP2PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VEXPANDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VEXPANDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VEXTRACTF128); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VEXTRACTF32X4); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VEXTRACTF64X4); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VEXTRACTI128); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VEXTRACTI32X4); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VEXTRACTI64X4); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VEXTRACTPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD132PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD132PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD213PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD231PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD213PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD231PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD213SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD132SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD231SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD213SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD132SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADD231SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDSUB132PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDSUB132PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDSUBPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDSUB213PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDSUB231PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDSUBPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDSUB213PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMADDSUB231PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB132PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB132PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBADD132PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBADD132PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBADDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBADD213PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBADD231PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBADDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBADD213PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBADD231PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB213PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB231PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB213PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB231PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB213SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB132SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB231SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUBSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB213SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB132SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFMSUB231SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD132PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD132PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD213PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD231PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD213PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD231PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADDSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD213SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD132SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD231SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADDSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD213SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD132SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMADD231SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB132PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB132PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUBPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB213PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB231PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUBPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB213PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB231PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUBSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB213SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB132SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB231SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUBSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB213SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB132SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFNMSUB231SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFRCZPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFRCZPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFRCZSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VFRCZSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VORPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VORPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VXORPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VXORPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERPF0DPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERPF0DPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERPF0QPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERPF0QPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERPF1DPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERPF1DPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERPF1QPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERPF1QPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERQPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VGATHERQPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VHADDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VHADDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VHSUBPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VHSUBPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VINSERTF128); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VINSERTF32X4); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VINSERTF32X8); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VINSERTF64X2); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VINSERTF64X4); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VINSERTI128); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VINSERTI32X4); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VINSERTI32X8); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VINSERTI64X2); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VINSERTI64X4); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VINSERTPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VLDDQU); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VLDMXCSR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMASKMOVDQU); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMASKMOVPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMASKMOVPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMAXPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMAXPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMAXSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMAXSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMCALL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMCLEAR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMFUNC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMINPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMINPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMINSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMINSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMLAUNCH); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMLOAD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMMCALL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVDDUP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVDQA32); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVDQA64); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVDQA); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVDQU16); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVDQU32); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVDQU64); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVDQU8); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVDQU); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVHLPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVHPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVHPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVLHPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVLPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVLPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVMSKPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVMSKPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVNTDQA); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVNTDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVNTPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVNTPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVSHDUP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVSLDUP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVUPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMOVUPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMPSADBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMPTRLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMPTRST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMREAD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMRESUME); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMRUN); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMSAVE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMULPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMULPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMULSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMULSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMWRITE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMXOFF); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VMXON); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPABSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPABSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPABSQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPABSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPACKSSDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPACKSSWB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPACKUSDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPACKUSWB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPADDB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPADDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPADDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPADDSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPADDSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPADDUSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPADDUSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPADDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPALIGNR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPANDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPANDND); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPANDNQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPANDN); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPANDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPAND); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPAVGB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPAVGW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBLENDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBLENDMB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBLENDMD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBLENDMQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBLENDMW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBLENDVB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBLENDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBROADCASTB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBROADCASTD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBROADCASTMB2Q); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBROADCASTMW2D); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBROADCASTQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPBROADCASTW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCLMULQDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMOV); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPEQB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPEQD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPEQQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPEQW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPESTRI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPESTRM); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPGTB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPGTD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPGTQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPGTW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPISTRI); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPISTRM); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPUB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPUD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPUQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPUW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCMPW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCOMB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCOMD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCOMPRESSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCOMPRESSQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCOMQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCOMUB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCOMUD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCOMUQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCOMUW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCOMW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCONFLICTD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPCONFLICTQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERM2F128); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERM2I128); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMI2D); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMI2PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMI2PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMI2Q); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMIL2PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMIL2PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMILPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMILPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMT2D); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMT2PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMT2PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPERMT2Q); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPEXPANDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPEXPANDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPEXTRB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPEXTRD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPEXTRQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPEXTRW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPGATHERDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPGATHERDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPGATHERQD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPGATHERQQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDBD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDBQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDUBD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDUBQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDUBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDUDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDUWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDUWQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDWQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHADDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHMINPOSUW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHSUBBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHSUBDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHSUBD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHSUBSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHSUBWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPHSUBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPINSRB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPINSRD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPINSRQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPINSRW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPLZCNTD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPLZCNTQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMACSDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMACSDQH); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMACSDQL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMACSSDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMACSSDQH); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMACSSDQL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMACSSWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMACSSWW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMACSWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMACSWW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMADCSSWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMADCSWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMADDUBSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMADDWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMASKMOVD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMASKMOVQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMAXSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMAXSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMAXSQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMAXSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMAXUB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMAXUD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMAXUQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMAXUW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMINSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMINSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMINSQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMINSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMINUB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMINUD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMINUQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMINUW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVDB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVM2B); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVM2D); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVM2Q); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVM2W); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVMSKB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVQB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVQD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVQW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVSDB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVSDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVSQB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVSQD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVSQW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVSXBD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVSXBQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVSXBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVSXDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVSXWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVSXWQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVUSDB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVUSDW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVUSQB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVUSQD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVUSQW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVZXBD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVZXBQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVZXBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVZXDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVZXWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMOVZXWQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMULDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMULHRSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMULHUW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMULHW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMULLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMULLQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMULLW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPMULUDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPORD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPORQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPOR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPPERM); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPROTB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPROTD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPROTQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPROTW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSADBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSCATTERDD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSCATTERDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSCATTERQD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSCATTERQQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHAB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHAD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHAQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHAW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHLB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHLQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHLW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHUFB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHUFD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHUFHW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSHUFLW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSIGNB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSIGND); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSIGNW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSLLDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSLLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSLLQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSLLVD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSLLVQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSLLW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSRAD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSRAQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSRAVD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSRAVQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSRAW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSRLDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSRLD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSRLQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSRLVD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSRLVQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSRLW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSUBB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSUBD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSUBQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSUBSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSUBSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSUBUSB); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSUBUSW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPSUBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPTESTMD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPTESTMQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPTESTNMD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPTESTNMQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPTEST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPUNPCKHBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPUNPCKHDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPUNPCKHQDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPUNPCKHWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPUNPCKLBW); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPUNPCKLDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPUNPCKLQDQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPUNPCKLWD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPXORD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPXORQ); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VPXOR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRCP14PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRCP14PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRCP14SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRCP14SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRCP28PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRCP28PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRCP28SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRCP28SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRCPPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRCPSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRNDSCALEPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRNDSCALEPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRNDSCALESD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRNDSCALESS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VROUNDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VROUNDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VROUNDSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VROUNDSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRSQRT14PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRSQRT14PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRSQRT14SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRSQRT14SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRSQRT28PD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRSQRT28PS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRSQRT28SD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRSQRT28SS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRSQRTPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VRSQRTSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERDPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERDPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERPF0DPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERPF0DPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERPF0QPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERPF0QPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERPF1DPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERPF1DPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERPF1QPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERPF1QPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERQPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSCATTERQPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSHUFPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSHUFPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSQRTPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSQRTPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSQRTSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSQRTSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSTMXCSR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSUBPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSUBPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSUBSD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VSUBSS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VTESTPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VTESTPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VUNPCKHPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VUNPCKHPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VUNPCKLPD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VUNPCKLPS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VZEROALL); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VZEROUPPER); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_FWAIT, dt_X86_INS_WAIT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, WBINVD); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, WRFSBASE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, WRGSBASE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, WRMSR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XABORT); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XACQUIRE); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XBEGIN); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XCHG); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XCRYPTCBC); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XCRYPTCFB); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XCRYPTCTR); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XCRYPTECB); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XCRYPTOFB); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XEND); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XGETBV); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_XLAT, dt_X86_INS_XLATB); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XRELEASE); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XRSTOR); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XRSTOR64); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XRSTORS); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XRSTORS64); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSAVE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSAVE64); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSAVEC); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSAVEC64); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSAVEOPT); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSAVEOPT64); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSAVES); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSAVES64); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSETBV); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSHA1); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSHA256); - */ - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XSTORE); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, XTEST); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FDISI8087_NOP); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, FENI8087_NOP); - - // pseudo instructions - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPSS); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPEQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPLTSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPLESS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPUNORDSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNEQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNLTSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNLESS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPORDSS); - */ - - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPSD); - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_CMPSD_XMM, dt_X86_INS_CMPEQSD); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPLTSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPLESD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPUNORDSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNEQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNLTSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNLESD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPORDSD); - */ - - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPPS); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPEQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPLTPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPLEPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPUNORDPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNEQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNLTPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNLEPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPORDPS); - */ - - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPPD); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPEQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPLTPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPLEPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPUNORDPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNEQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNLTPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPNLEPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, CMPORDPD); - */ - - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPSS); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLTSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLESS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPUNORDSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLTSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLESS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPORDSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_UQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGESS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGTSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPFALSESS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_OQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGESS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGTSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPTRUESS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_OSSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLT_OQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLE_OQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPUNORD_SSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_USSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLT_UQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLE_UQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPORD_SSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_USSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGE_UQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGT_UQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPFALSE_OSSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_OSSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGE_OQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGT_OQSS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPTRUE_USSS); - */ - - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPSD); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLTSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLESD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPUNORDSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLTSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLESD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPORDSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_UQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGESD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGTSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPFALSESD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_OQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGESD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGTSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPTRUESD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_OSSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLT_OQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLE_OQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPUNORD_SSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_USSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLT_UQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLE_UQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPORD_SSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_USSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGE_UQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGT_UQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPFALSE_OSSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_OSSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGE_OQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGT_OQSD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPTRUE_USSD); - */ - - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPPS); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLTPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLEPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPUNORDPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLTPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLEPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPORDPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_UQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGEPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGTPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPFALSEPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_OQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGEPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGTPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPTRUEPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_OSPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLT_OQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLE_OQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPUNORD_SPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_USPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLT_UQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLE_UQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPORD_SPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_USPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGE_UQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGT_UQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPFALSE_OSPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_OSPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGE_OQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGT_OQPS); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPTRUE_USPS); - */ - - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPPD); -/* - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLTPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLEPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPUNORDPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLTPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLEPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPORDPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_UQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGEPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGTPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPFALSEPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_OQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGEPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGTPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPTRUEPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_OSPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLT_OQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPLE_OQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPUNORD_SPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_USPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLT_UQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNLE_UQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPORD_SPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPEQ_USPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGE_UQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNGT_UQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPFALSE_OSPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPNEQ_OSPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGE_OQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPGT_OQPD); - * LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, VCMPTRUE_USPD); - */ - - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, UD0); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ENDBR32); - LA_X86_INSN_DEF(la_xed_insn_tr, XED_ICLASS_, ENDBR64); - - LA_X86_INSN_REDEF(la_xed_insn_tr, XED_ICLASS_LAST, dt_X86_INS_ENDING); -} diff --git a/target/i386/latx/latx-disassemble-trace/zydis.c b/target/i386/latx/latx-disassemble-trace/zydis.c index 59c8fcf06d2..33747c99094 100644 --- a/target/i386/latx/latx-disassemble-trace/zydis.c +++ b/target/i386/latx/latx-disassemble-trace/zydis.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "lazydis.h" #undef ZYDIS_MNEMONIC_ diff --git a/target/i386/latx/latx-options.c b/target/i386/latx/latx-options.c index e52ae462dfd..b88fa569648 100644 --- a/target/i386/latx/latx-options.c +++ b/target/i386/latx/latx-options.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "latx-options.h" #include "error.h" #include "qemu/cutils.h" @@ -7,6 +13,8 @@ #if defined(CONFIG_LATX_KZT) int option_kzt = 0; +int option_kzt_patch_guest_owner = 0; +int option_kzt_patch_shadow = 0; #endif #ifdef CONFIG_LATX_AVX_OPT @@ -473,13 +481,11 @@ void options_parse_latx_disassemble_trace_cmp(const char *args) option_latx_disassemble_trace_cmp |= OPT_V1LACAPSTONE; } else if (!strcmp(strtmp, "nextcapstone")) { option_latx_disassemble_trace_cmp |= OPT_V1NEXTCAPSTONE; - } else if (!strcmp(strtmp, "laxed")) { - option_latx_disassemble_trace_cmp |= OPT_V1LAXED; } else if (!strcmp(strtmp, "lazydis")) { option_latx_disassemble_trace_cmp |= OPT_V1LAZYDIS; } else { lsassertm(0, "V1 must be lacapstone, lazydis, " - "nextcapstone or laxed, but this V1=%s\n", strtmp); + "or nextcapstone, but this V1=%s\n", strtmp); return; } strncpy(strtmp, findSpil + 1, 99); @@ -487,15 +493,13 @@ void options_parse_latx_disassemble_trace_cmp(const char *args) option_latx_disassemble_trace_cmp |= OPT_V2LACAPSTONE; } else if (!strcmp(strtmp, "nextcapstone")) { option_latx_disassemble_trace_cmp |= OPT_V2NEXTCAPSTONE; - } else if (!strcmp(strtmp, "laxed")) { - option_latx_disassemble_trace_cmp |= OPT_V2LAXED; } else if (!strcmp(strtmp, "lazydis")) { option_latx_disassemble_trace_cmp |= OPT_V2LAZYDIS; } else if (strlen(strtmp) == 0) { /*Only want to choose la_disa_v1, No cmp.*/ } else { lsassertm(0, "V2 must be lacapstone, lazydis, " - "nextcapstone, laxed or NULL, but this V2=%s\n", strtmp); + "nextcapstone or NULL, but this V2=%s\n", strtmp); } } uint8 options_to_save(void) diff --git a/target/i386/latx/latx-perf.c b/target/i386/latx/latx-perf.c index 745426af4b0..499e2c4524c 100644 --- a/target/i386/latx/latx-perf.c +++ b/target/i386/latx/latx-perf.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file latx-perf.c * @author Hanlu Li diff --git a/target/i386/latx/latx-signal.c b/target/i386/latx/latx-signal.c index 763ab8a5874..908e04c7b5d 100644 --- a/target/i386/latx/latx-signal.c +++ b/target/i386/latx/latx-signal.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file latx-signal.c * @author Hanlu Li diff --git a/target/i386/latx/latx-special-args.c b/target/i386/latx/latx-special-args.c index e1b36a5fd8c..0cbe0441609 100644 --- a/target/i386/latx/latx-special-args.c +++ b/target/i386/latx/latx-special-args.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "latx-config.h" #include "latx-options.h" diff --git a/target/i386/latx/mem.c b/target/i386/latx/mem.c index c5f0ec7fb56..385753dcdea 100644 --- a/target/i386/latx/mem.c +++ b/target/i386/latx/mem.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "mem.h" void *mm_malloc(int size) diff --git a/target/i386/latx/meson.build b/target/i386/latx/meson.build index 9c526ecffc8..7115e6dab90 100644 --- a/target/i386/latx/meson.build +++ b/target/i386/latx/meson.build @@ -72,15 +72,6 @@ i386_ss.add(when: 'CONFIG_LATX', if_true: files( 'latx-signal.c', )) -laxed_lib = static_library('laxed', - build_by_default: false, - sources: files('latx-disassemble-trace/xed.c'), - include_directories: include_directories('include/')) - -laxed = declare_dependency(link_with: laxed_lib, - link_args: ['-L' + meson.current_source_dir() + '/exlib', '-lxed'], - include_directories: include_directories('include/')) - lazydis_lib = static_library('lazydis', build_by_default: false, sources: files('latx-disassemble-trace/zydis.c'), @@ -90,7 +81,6 @@ lazydis = declare_dependency(link_with: lazydis_lib, link_args: ['-L' + meson.current_source_dir() + '/exlib', '-lZydis', '-lZycore'], include_directories: include_directories('include/')) -i386_ss.add(when: 'CONFIG_LATX_DEBUG', if_true: laxed) i386_ss.add(when: 'CONFIG_LATX_DEBUG', if_true: lazydis) i386_ss.add(when: 'CONFIG_LATX_DEBUG', if_true: files( @@ -104,7 +94,6 @@ endif r = run_command('python3', 'convert.py', check: true) message('convert.py ->', r.stdout().strip(), r.stderr().strip()) -subdir('diStorm') subdir('ir1') subdir('ir2') subdir('optimization') diff --git a/target/i386/latx/optimization/flag-lbt.c b/target/i386/latx/optimization/flag-lbt.c index 386b4f95eb2..55f88fc07b8 100644 --- a/target/i386/latx/optimization/flag-lbt.c +++ b/target/i386/latx/optimization/flag-lbt.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "env.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/optimization/flag-reduction.c b/target/i386/latx/optimization/flag-reduction.c index 3d1e32844c1..1817f5b9a0c 100644 --- a/target/i386/latx/optimization/flag-reduction.c +++ b/target/i386/latx/optimization/flag-reduction.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "ir1.h" #include "translate.h" diff --git a/target/i386/latx/optimization/hbr.c b/target/i386/latx/optimization/hbr.c index bfa12a52f18..94ee33b17f5 100644 --- a/target/i386/latx/optimization/hbr.c +++ b/target/i386/latx/optimization/hbr.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file hbr.c * @author wwq diff --git a/target/i386/latx/optimization/imm-cache.c b/target/i386/latx/optimization/imm-cache.c index 1eb041f5aaa..1525110eef8 100644 --- a/target/i386/latx/optimization/imm-cache.c +++ b/target/i386/latx/optimization/imm-cache.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file imm-cache.c * @author liuxinpeng diff --git a/target/i386/latx/optimization/insts-pattern.c b/target/i386/latx/optimization/insts-pattern.c index f980dd90965..a1aedf4793b 100644 --- a/target/i386/latx/optimization/insts-pattern.c +++ b/target/i386/latx/optimization/insts-pattern.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file insts-pattern.c * @author huqi diff --git a/target/i386/latx/optimization/ir1-optimization.c b/target/i386/latx/optimization/ir1-optimization.c index 73532fc44ea..4e03b0645ec 100644 --- a/target/i386/latx/optimization/ir1-optimization.c +++ b/target/i386/latx/optimization/ir1-optimization.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "latx-options.h" #include "ir1.h" diff --git a/target/i386/latx/optimization/ir2-optimization.c b/target/i386/latx/optimization/ir2-optimization.c index 9025f99e24d..289bd43a6bd 100644 --- a/target/i386/latx/optimization/ir2-optimization.c +++ b/target/i386/latx/optimization/ir2-optimization.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "translate.h" #include "la-append.h" diff --git a/target/i386/latx/optimization/jrra.c b/target/i386/latx/optimization/jrra.c index 83fbe84b96a..b22bf0c5c68 100644 --- a/target/i386/latx/optimization/jrra.c +++ b/target/i386/latx/optimization/jrra.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file jrra.c * @author Hanlu Li diff --git a/target/i386/latx/optimization/profile.c b/target/i386/latx/optimization/profile.c index ed68fea09b9..8112e258ccb 100644 --- a/target/i386/latx/optimization/profile.c +++ b/target/i386/latx/optimization/profile.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "profile.h" #ifdef CONFIG_LATX_PROFILER diff --git a/target/i386/latx/optimization/syscall-tunnel.c b/target/i386/latx/optimization/syscall-tunnel.c index 70a0d46cf7c..94b3355b59a 100644 --- a/target/i386/latx/optimization/syscall-tunnel.c +++ b/target/i386/latx/optimization/syscall-tunnel.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "syscall-tunnel.h" #ifdef CONFIG_LATX_SYSCALL_TUNNEL diff --git a/target/i386/latx/optimization/ts.c b/target/i386/latx/optimization/ts.c index 9e0432fab31..bc1ed61608d 100644 --- a/target/i386/latx/optimization/ts.c +++ b/target/i386/latx/optimization/ts.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file ts.c * @author wwq diff --git a/target/i386/latx/optimization/tu.c b/target/i386/latx/optimization/tu.c index d9a6eee5960..180bcae5e79 100644 --- a/target/i386/latx/optimization/tu.c +++ b/target/i386/latx/optimization/tu.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file tu.c * @author wwq diff --git a/target/i386/latx/optimization/tunnel-lib.c b/target/i386/latx/optimization/tunnel-lib.c index e26195ac00c..5279dbc9379 100644 --- a/target/i386/latx/optimization/tunnel-lib.c +++ b/target/i386/latx/optimization/tunnel-lib.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include #include #include diff --git a/target/i386/latx/sbt/aot.c b/target/i386/latx/sbt/aot.c index c28823ae1ae..3adaa5d5fba 100644 --- a/target/i386/latx/sbt/aot.c +++ b/target/i386/latx/sbt/aot.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot.c * @author wwq diff --git a/target/i386/latx/sbt/aot_lib.c b/target/i386/latx/sbt/aot_lib.c index af8a2a6c3ad..b6ae04d4abe 100644 --- a/target/i386/latx/sbt/aot_lib.c +++ b/target/i386/latx/sbt/aot_lib.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_lib.c * @author wwq diff --git a/target/i386/latx/sbt/aot_link_seg.c b/target/i386/latx/sbt/aot_link_seg.c index b914244aa58..dc4d66b94d2 100644 --- a/target/i386/latx/sbt/aot_link_seg.c +++ b/target/i386/latx/sbt/aot_link_seg.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_link_seg.c * @author wwq diff --git a/target/i386/latx/sbt/aot_merge.c b/target/i386/latx/sbt/aot_merge.c index 0460802fdfe..ee39da348ab 100644 --- a/target/i386/latx/sbt/aot_merge.c +++ b/target/i386/latx/sbt/aot_merge.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_merge.c * @author wwq diff --git a/target/i386/latx/sbt/aot_page.c b/target/i386/latx/sbt/aot_page.c index e163a3762e0..7451464155a 100644 --- a/target/i386/latx/sbt/aot_page.c +++ b/target/i386/latx/sbt/aot_page.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_page.c * @author wwq diff --git a/target/i386/latx/sbt/aot_recover_tb.c b/target/i386/latx/sbt/aot_recover_tb.c index 9e287e14f4b..c628d1fe6ad 100644 --- a/target/i386/latx/sbt/aot_recover_tb.c +++ b/target/i386/latx/sbt/aot_recover_tb.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_recover_tb.c * @author wwq diff --git a/target/i386/latx/sbt/aot_smc.c b/target/i386/latx/sbt/aot_smc.c index 5f8ed19f3ce..061a8f4a3ab 100644 --- a/target/i386/latx/sbt/aot_smc.c +++ b/target/i386/latx/sbt/aot_smc.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file aot_smc.c * @author wwq diff --git a/target/i386/latx/sbt/file_ctx.c b/target/i386/latx/sbt/file_ctx.c index cbb39e5b981..dd2c0dab187 100644 --- a/target/i386/latx/sbt/file_ctx.c +++ b/target/i386/latx/sbt/file_ctx.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file file_ctx.c * @author wwq diff --git a/target/i386/latx/sbt/segment.c b/target/i386/latx/sbt/segment.c index 9fed517fbeb..d8334268392 100644 --- a/target/i386/latx/sbt/segment.c +++ b/target/i386/latx/sbt/segment.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file segment.c * @author wwq diff --git a/target/i386/latx/trace.h b/target/i386/latx/trace.h index f76b18fa0cf..4062e5a7f23 100644 --- a/target/i386/latx/trace.h +++ b/target/i386/latx/trace.h @@ -1 +1,7 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "trace/trace-target_i386_latx.h" diff --git a/target/i386/latx/translator/macro-helper.c b/target/i386/latx/translator/macro-helper.c index 40dc1865737..4edaf2f62d2 100644 --- a/target/i386/latx/translator/macro-helper.c +++ b/target/i386/latx/translator/macro-helper.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file macro-helper.c * @author Hanlu Li diff --git a/target/i386/latx/translator/mem-interface.c b/target/i386/latx/translator/mem-interface.c index 1d451629ea2..b453f45ca7c 100644 --- a/target/i386/latx/translator/mem-interface.c +++ b/target/i386/latx/translator/mem-interface.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file mem-interface.c * @author Hanlu Li diff --git a/target/i386/latx/translator/reg-alloc.c b/target/i386/latx/translator/reg-alloc.c index 047c4a0c0c2..4a20af2c73d 100644 --- a/target/i386/latx/translator/reg-alloc.c +++ b/target/i386/latx/translator/reg-alloc.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file reg-alloc.c * @author Hanlu Li diff --git a/target/i386/latx/translator/runtime-trace.c b/target/i386/latx/translator/runtime-trace.c index 562f458e31b..e311495955c 100644 --- a/target/i386/latx/translator/runtime-trace.c +++ b/target/i386/latx/translator/runtime-trace.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "flag-lbt.h" diff --git a/target/i386/latx/translator/tr-adx.c b/target/i386/latx/translator/tr-adx.c index dc522b4d7da..05d52394a8d 100644 --- a/target/i386/latx/translator/tr-adx.c +++ b/target/i386/latx/translator/tr-adx.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "env.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-arith.c b/target/i386/latx/translator/tr-arith.c index ce9bae251e5..604135961b2 100644 --- a/target/i386/latx/translator/tr-arith.c +++ b/target/i386/latx/translator/tr-arith.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "env.h" #include "reg-alloc.h" diff --git a/target/i386/latx/translator/tr-avx-cmp.c b/target/i386/latx/translator/tr-avx-cmp.c index da0c291fafd..ae2f29c8e64 100644 --- a/target/i386/latx/translator/tr-avx-cmp.c +++ b/target/i386/latx/translator/tr-avx-cmp.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-avx-cvt.c b/target/i386/latx/translator/tr-avx-cvt.c index 1b59866b1fb..e997164b556 100644 --- a/target/i386/latx/translator/tr-avx-cvt.c +++ b/target/i386/latx/translator/tr-avx-cvt.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "lsenv.h" diff --git a/target/i386/latx/translator/tr-avx-mov.c b/target/i386/latx/translator/tr-avx-mov.c index 03585fd1cdd..6db1c02b6ca 100644 --- a/target/i386/latx/translator/tr-avx-mov.c +++ b/target/i386/latx/translator/tr-avx-mov.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-avx-shift.c b/target/i386/latx/translator/tr-avx-shift.c index 30f62667bfc..413f43f44be 100644 --- a/target/i386/latx/translator/tr-avx-shift.c +++ b/target/i386/latx/translator/tr-avx-shift.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-avx.c b/target/i386/latx/translator/tr-avx.c index 12625da81bf..a481a4acace 100644 --- a/target/i386/latx/translator/tr-avx.c +++ b/target/i386/latx/translator/tr-avx.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-bmi.c b/target/i386/latx/translator/tr-bmi.c index 00d48680f97..c30e5730d6f 100644 --- a/target/i386/latx/translator/tr-bmi.c +++ b/target/i386/latx/translator/tr-bmi.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "env.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-btx.c b/target/i386/latx/translator/tr-btx.c index 49aac642dd5..bf82253be46 100644 --- a/target/i386/latx/translator/tr-btx.c +++ b/target/i386/latx/translator/tr-btx.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "env.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-eflag-process.c b/target/i386/latx/translator/tr-eflag-process.c index a9861b79faa..87b6ffb9ed5 100644 --- a/target/i386/latx/translator/tr-eflag-process.c +++ b/target/i386/latx/translator/tr-eflag-process.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "lsenv.h" diff --git a/target/i386/latx/translator/tr-eflag.c b/target/i386/latx/translator/tr-eflag.c index 15206cf5ca6..07624299e11 100644 --- a/target/i386/latx/translator/tr-eflag.c +++ b/target/i386/latx/translator/tr-eflag.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "lsenv.h" diff --git a/target/i386/latx/translator/tr-farith.c b/target/i386/latx/translator/tr-farith.c index ce57878b209..39074691bff 100644 --- a/target/i386/latx/translator/tr-farith.c +++ b/target/i386/latx/translator/tr-farith.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include #include "common.h" #include "reg-alloc.h" diff --git a/target/i386/latx/translator/tr-fcmovcc.c b/target/i386/latx/translator/tr-fcmovcc.c index 05383ed6faf..1c993d6ce65 100644 --- a/target/i386/latx/translator/tr-fcmovcc.c +++ b/target/i386/latx/translator/tr-fcmovcc.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "flag-lbt.h" diff --git a/target/i386/latx/translator/tr-fctrl.c b/target/i386/latx/translator/tr-fctrl.c index f314873b8db..5cab14421d0 100644 --- a/target/i386/latx/translator/tr-fctrl.c +++ b/target/i386/latx/translator/tr-fctrl.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "lsenv.h" diff --git a/target/i386/latx/translator/tr-fldst.c b/target/i386/latx/translator/tr-fldst.c index ae402fdc7cd..bf0517de720 100644 --- a/target/i386/latx/translator/tr-fldst.c +++ b/target/i386/latx/translator/tr-fldst.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include #include "common.h" #include "reg-alloc.h" diff --git a/target/i386/latx/translator/tr-jcc.c b/target/i386/latx/translator/tr-jcc.c index 82c95fc199d..46d0dde663a 100644 --- a/target/i386/latx/translator/tr-jcc.c +++ b/target/i386/latx/translator/tr-jcc.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-lock-fast-atomic.c b/target/i386/latx/translator/tr-lock-fast-atomic.c index 7c812e6892a..3a1a5b34d30 100644 --- a/target/i386/latx/translator/tr-lock-fast-atomic.c +++ b/target/i386/latx/translator/tr-lock-fast-atomic.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "env.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-lock.c b/target/i386/latx/translator/tr-lock.c index dcdf89ada33..86705dcac2a 100644 --- a/target/i386/latx/translator/tr-lock.c +++ b/target/i386/latx/translator/tr-lock.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "env.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-logic.c b/target/i386/latx/translator/tr-logic.c index 335e72b2256..d171532e6d3 100644 --- a/target/i386/latx/translator/tr-logic.c +++ b/target/i386/latx/translator/tr-logic.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "flag-lbt.h" diff --git a/target/i386/latx/translator/tr-misc.c b/target/i386/latx/translator/tr-misc.c index 582ff06dc02..91221916331 100644 --- a/target/i386/latx/translator/tr-misc.c +++ b/target/i386/latx/translator/tr-misc.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "reg-alloc.h" #include "latx-options.h" #include "latx-config.h" diff --git a/target/i386/latx/translator/tr-mov.c b/target/i386/latx/translator/tr-mov.c index e87a496261c..500e455d184 100644 --- a/target/i386/latx/translator/tr-mov.c +++ b/target/i386/latx/translator/tr-mov.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "lsenv.h" diff --git a/target/i386/latx/translator/tr-opnd-process.c b/target/i386/latx/translator/tr-opnd-process.c index 428f2e99bf5..107f374de4f 100644 --- a/target/i386/latx/translator/tr-opnd-process.c +++ b/target/i386/latx/translator/tr-opnd-process.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "ir2.h" diff --git a/target/i386/latx/translator/tr-pattern.c b/target/i386/latx/translator/tr-pattern.c index 3aed4e4e620..886807d7597 100644 --- a/target/i386/latx/translator/tr-pattern.c +++ b/target/i386/latx/translator/tr-pattern.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-setcc.c b/target/i386/latx/translator/tr-setcc.c index 95c2faa85b7..a5610717420 100644 --- a/target/i386/latx/translator/tr-setcc.c +++ b/target/i386/latx/translator/tr-setcc.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "env.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-simd-cmp.c b/target/i386/latx/translator/tr-simd-cmp.c index b3193a6dc8e..75b1c9d70a8 100644 --- a/target/i386/latx/translator/tr-simd-cmp.c +++ b/target/i386/latx/translator/tr-simd-cmp.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-simd-cvt.c b/target/i386/latx/translator/tr-simd-cvt.c index b888e4feaad..8f32328bc38 100644 --- a/target/i386/latx/translator/tr-simd-cvt.c +++ b/target/i386/latx/translator/tr-simd-cvt.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "lsenv.h" diff --git a/target/i386/latx/translator/tr-simd-f16c.c b/target/i386/latx/translator/tr-simd-f16c.c index 382dbf326f4..d723d623992 100644 --- a/target/i386/latx/translator/tr-simd-f16c.c +++ b/target/i386/latx/translator/tr-simd-f16c.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "lsenv.h" diff --git a/target/i386/latx/translator/tr-simd-fma.c b/target/i386/latx/translator/tr-simd-fma.c index f4a42cd1d90..177f81f1c98 100644 --- a/target/i386/latx/translator/tr-simd-fma.c +++ b/target/i386/latx/translator/tr-simd-fma.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-simd-mov.c b/target/i386/latx/translator/tr-simd-mov.c index d250351b197..26e79c26b68 100644 --- a/target/i386/latx/translator/tr-simd-mov.c +++ b/target/i386/latx/translator/tr-simd-mov.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-simd-sha.c b/target/i386/latx/translator/tr-simd-sha.c index 0cb155d2690..cbafe0cfa5a 100644 --- a/target/i386/latx/translator/tr-simd-sha.c +++ b/target/i386/latx/translator/tr-simd-sha.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-simd-shift.c b/target/i386/latx/translator/tr-simd-shift.c index fc1e35b6a97..a3ce25195e9 100644 --- a/target/i386/latx/translator/tr-simd-shift.c +++ b/target/i386/latx/translator/tr-simd-shift.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-simd.c b/target/i386/latx/translator/tr-simd.c index 1a983649317..f8d8066b6fb 100644 --- a/target/i386/latx/translator/tr-simd.c +++ b/target/i386/latx/translator/tr-simd.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-softfpu.c b/target/i386/latx/translator/tr-softfpu.c index 47f599f9bc6..ea4b56ff738 100644 --- a/target/i386/latx/translator/tr-softfpu.c +++ b/target/i386/latx/translator/tr-softfpu.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + /** * @file tr-softfpu.c * @author Hanlu Li diff --git a/target/i386/latx/translator/tr-vpaes.c b/target/i386/latx/translator/tr-vpaes.c index c5a4a08b432..2d26285c69e 100644 --- a/target/i386/latx/translator/tr-vpaes.c +++ b/target/i386/latx/translator/tr-vpaes.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "common.h" #include "reg-alloc.h" #include "latx-options.h" diff --git a/target/i386/latx/translator/tr-vpaes.h b/target/i386/latx/translator/tr-vpaes.h index c636c080c50..c4aefe577d0 100644 --- a/target/i386/latx/translator/tr-vpaes.h +++ b/target/i386/latx/translator/tr-vpaes.h @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #ifndef LATX_TR_VPAES_H #define LATX_TR_VPAES_H diff --git a/target/i386/latx/translator/translate.c b/target/i386/latx/translator/translate.c index b582b331831..155f8a77973 100644 --- a/target/i386/latx/translator/translate.c +++ b/target/i386/latx/translator/translate.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "lsenv.h" #include "reg-alloc.h" #include "flag-lbt.h" diff --git a/target/i386/latx/wrapper/wrapper.c b/target/i386/latx/wrapper/wrapper.c index c64b84c5d0f..7398123e8a4 100644 --- a/target/i386/latx/wrapper/wrapper.c +++ b/target/i386/latx/wrapper/wrapper.c @@ -1,3 +1,9 @@ +/* + * SPDX-FileCopyrightText: 2021-2026 LATX Project Authors + * + * SPDX-License-Identifier: GPL-2.0-only + */ + #include "translate.h" bool translate_libfunc(IR1_INST *pir1) { return false; } diff --git a/tests/latx-x86_64/kzt-guestdynamic-test.c b/tests/latx-x86_64/kzt-guestdynamic-test.c new file mode 100644 index 00000000000..3338d3775f2 --- /dev/null +++ b/tests/latx-x86_64/kzt-guestdynamic-test.c @@ -0,0 +1,438 @@ +#include "guestdynamic.h" + +#include +#include + +#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) + +static int failures; + +static void check_int(const char *name, unsigned long got, + unsigned long expected) +{ + if (got == expected) + return; + + fprintf(stderr, "%s: got 0x%lx expected 0x%lx\n", name, got, expected); + ++failures; +} + +static void test_ready_dynamic_info(void) +{ + Elf64_Dyn dynamic[] = { + {.d_tag = DT_NEEDED, .d_un.d_val = 7}, + {.d_tag = DT_RPATH, .d_un.d_val = 11}, + {.d_tag = DT_RUNPATH, .d_un.d_val = 13}, + {.d_tag = DT_STRTAB, .d_un.d_ptr = 0x1000}, + {.d_tag = DT_STRSZ, .d_un.d_val = 0x80}, + {.d_tag = DT_SYMTAB, .d_un.d_ptr = 0x2000}, + {.d_tag = DT_SYMENT, .d_un.d_val = sizeof(Elf64_Sym)}, + {.d_tag = DT_RELA, .d_un.d_ptr = 0x3000}, + {.d_tag = DT_RELASZ, .d_un.d_val = 2 * sizeof(Elf64_Rela)}, + {.d_tag = DT_RELAENT, .d_un.d_val = sizeof(Elf64_Rela)}, + {.d_tag = DT_JMPREL, .d_un.d_ptr = 0x4000}, + {.d_tag = DT_PLTRELSZ, .d_un.d_val = 3 * sizeof(Elf64_Rela)}, + {.d_tag = DT_PLTREL, .d_un.d_val = DT_RELA}, + {.d_tag = DT_PLTGOT, .d_un.d_ptr = 0x5000}, + {.d_tag = DT_INIT_ARRAY, .d_un.d_ptr = 0x6000}, + {.d_tag = DT_INIT_ARRAYSZ, .d_un.d_val = 4 * sizeof(Elf64_Addr)}, + {.d_tag = DT_FINI_ARRAY, .d_un.d_ptr = 0x7000}, + {.d_tag = DT_FINI_ARRAYSZ, .d_un.d_val = sizeof(Elf64_Addr)}, + {.d_tag = DT_VERNEED, .d_un.d_ptr = 0x8000}, + {.d_tag = DT_VERNEEDNUM, .d_un.d_val = 2}, + {.d_tag = DT_NULL}, + }; + KztDynamicView view; + KztDynamicInfo info; + + KztParseDynamicView(&view, dynamic, ARRAY_SIZE(dynamic)); + KztBuildDynamicInfo(&info, &view); + + check_int("ready.status", view.status, KZT_DYNAMIC_VIEW_READY); + check_int("ready.entries", view.entry_count, ARRAY_SIZE(dynamic) - 1); + check_int("ready.needed", view.summary.needed_count, 1); + check_int("ready.rpath", view.summary.rpath_count, 1); + check_int("ready.runpath", view.summary.runpath_count, 1); + check_int("ready.strtab", info.strtab, 0x1000); + check_int("ready.strsz", info.strsz, 0x80); + check_int("ready.symtab", info.symtab, 0x2000); + check_int("ready.rela", info.rela, 0x3000); + check_int("ready.relasz", info.relasz, 2 * sizeof(Elf64_Rela)); + check_int("ready.rela_count_available", info.has_rela_count, 1); + check_int("ready.rela_count", info.rela_count, 2); + check_int("ready.pltent", info.pltent, sizeof(Elf64_Rela)); + check_int("ready.plt_count_available", info.has_plt_count, 1); + check_int("ready.plt_count", info.plt_count, 3); + check_int("ready.initarray_count", info.initarray_count, 4); + check_int("ready.finiarray_count", info.finiarray_count, 1); + check_int("ready.verneed_count", info.verneed_count, 2); + check_int("ready.errors", info.errors, 0); +} + +static void test_empty_and_truncated_dynamic(void) +{ + Elf64_Dyn dynamic[] = { + {.d_tag = DT_NEEDED, .d_un.d_val = 1}, + }; + KztDynamicView view; + + KztParseDynamicView(&view, NULL, 16); + check_int("empty.status", view.status, KZT_DYNAMIC_VIEW_EMPTY); + check_int("empty.entries", view.entry_count, 0); + + KztParseDynamicView(&view, dynamic, ARRAY_SIZE(dynamic)); + check_int("truncated.status", view.status, KZT_DYNAMIC_VIEW_TRUNCATED); + check_int("truncated.entries", view.entry_count, ARRAY_SIZE(dynamic)); + check_int("truncated.flag", view.summary.truncated, 1); +} + +static void test_dynamic_info_errors(void) +{ + Elf64_Dyn dynamic[] = { + {.d_tag = DT_REL, .d_un.d_ptr = 0x1000}, + {.d_tag = DT_RELENT, .d_un.d_val = 1}, + {.d_tag = DT_JMPREL, .d_un.d_ptr = 0x2000}, + {.d_tag = DT_PLTREL, .d_un.d_val = DT_REL}, + {.d_tag = DT_PLTRELSZ, .d_un.d_val = sizeof(Elf64_Rel) + 1}, + {.d_tag = DT_NULL}, + }; + KztDynamicView view; + KztDynamicInfo info; + + KztParseDynamicView(&view, dynamic, ARRAY_SIZE(dynamic)); + KztBuildDynamicInfo(&info, &view); + + check_int("errors.status", view.status, KZT_DYNAMIC_VIEW_READY); + check_int("errors.flags", info.errors, + KZT_DYNAMIC_ERROR_RELENT | KZT_DYNAMIC_ERROR_PLTSZ); +} + +static void test_dynamic_string_iteration(void) +{ + static const char strtab[] = + "\0libfirst.so\0ignored-rpath\0libsecond.so\0"; + Elf64_Dyn dynamic[] = { + {.d_tag = DT_NEEDED, .d_un.d_val = 1}, + {.d_tag = DT_RPATH, .d_un.d_val = 13}, + {.d_tag = DT_NEEDED, .d_un.d_val = 27}, + {.d_tag = DT_NEEDED, .d_un.d_val = sizeof(strtab)}, + {.d_tag = DT_NULL}, + }; + KztDynamicStringTable strings = { + .data = strtab, + .size = sizeof(strtab), + }; + KztDynamicStringEntry entry; + KztDynamicView view; + size_t index = 0; + + KztParseDynamicView(&view, dynamic, ARRAY_SIZE(dynamic)); + + check_int("strings.first", KztNextDynamicString(&view, DT_NEEDED, + &index, &strings, + &entry), 1); + check_int("strings.first.offset", entry.offset, 1); + check_int("strings.first.value", entry.value[3], 'f'); + + check_int("strings.second", KztNextDynamicString(&view, DT_NEEDED, + &index, &strings, + &entry), 1); + check_int("strings.second.offset", entry.offset, 27); + check_int("strings.second.value", entry.value[3], 's'); + + check_int("strings.invalid", KztNextDynamicString(&view, DT_NEEDED, + &index, &strings, + &entry), 1); + check_int("strings.invalid.value", (uintptr_t)entry.value, 0); + + check_int("strings.done", KztNextDynamicString(&view, DT_NEEDED, + &index, &strings, + &entry), 0); +} + +static void test_dynamic_symbol_counts(void) +{ + uint32_t sysv_hash[] = { + 1, 9, 0, 0, + }; + struct { + uint32_t header[4]; + Elf64_Addr bloom[1]; + uint32_t buckets[1]; + uint32_t chains[2]; + } gnu_hash = { + .header = {1, 3, 1, 0}, + .bloom = {0}, + .buckets = {3}, + .chains = {0, 1}, + }; + KztDynamicInfo info; + + memset(&info, 0, sizeof(info)); + info.hash = (uintptr_t)sysv_hash; + check_int("symbols.sysv.available", + KztResolveDynamicSymbolCount(&info, 0), 1); + check_int("symbols.sysv.has_count", info.has_dynsym_count, 1); + check_int("symbols.sysv.count", info.dynsym_count, 9); + + memset(&info, 0, sizeof(info)); + info.gnu_hash = (uintptr_t)&gnu_hash; + check_int("symbols.gnu.available", + KztResolveDynamicSymbolCount(&info, 0), 1); + check_int("symbols.gnu.has_count", info.has_dynsym_count, 1); + check_int("symbols.gnu.count", info.dynsym_count, 5); + check_int("symbols.gnu.errors", info.errors, 0); +} + +static void test_dynamic_info_for_object(void) +{ + uint32_t sysv_hash[] = { + 1, 4, 0, 0, + }; + Elf64_Dyn dynamic[] = { + {.d_tag = DT_STRTAB, .d_un.d_ptr = 0x1000}, + {.d_tag = DT_STRSZ, .d_un.d_val = 0x20}, + {.d_tag = DT_HASH, .d_un.d_ptr = (uintptr_t)sysv_hash}, + {.d_tag = DT_NULL}, + }; + KztDynamicView view; + KztDynamicInfo info; + + KztParseDynamicView(&view, dynamic, ARRAY_SIZE(dynamic)); + KztBuildDynamicInfoForObject(&info, &view, 0); + + check_int("info-object.strtab", info.strtab, 0x1000); + check_int("info-object.has-dynsym-count", info.has_dynsym_count, 1); + check_int("info-object.dynsym-count", info.dynsym_count, 4); +} + +static void test_dynamic_symbol_entries(void) +{ + static const char strtab[] = "\0alpha\0beta\0"; + Elf64_Sym symbols[] = { + {.st_name = 1, .st_info = 0x12, .st_other = 0, + .st_shndx = 3, .st_value = 0x1000, .st_size = 0x20}, + {.st_name = 7, .st_info = 0x22, .st_other = 1, + .st_shndx = 4, .st_value = 0x2000, .st_size = 0x30}, + }; + KztDynamicSymbolTable table = { + .symbols = symbols, + .count = ARRAY_SIZE(symbols), + .strings = { + .data = strtab, + .size = sizeof(strtab), + }, + }; + KztDynamicInfo info; + KztDynamicSymbolEntry entry; + + memset(&info, 0, sizeof(info)); + info.strtab = (uintptr_t)strtab; + info.strsz = sizeof(strtab); + info.symtab = (uintptr_t)symbols; + info.dynsym_count = ARRAY_SIZE(symbols); + info.has_dynsym_count = 1; + memset(&table, 0, sizeof(table)); + check_int("symtab.from-info", + KztDynamicSymbolTableFromInfo(&info, 0, &table), 1); + check_int("symtab.from-info.count", table.count, ARRAY_SIZE(symbols)); + check_int("symtab.from-info.strtab", (uintptr_t)table.strings.data, + (uintptr_t)strtab); + + check_int("symtab.first", KztDynamicSymbolAt(&table, 0, &entry), 1); + check_int("symtab.first.name", entry.name[0], 'a'); + check_int("symtab.first.value", entry.symbol->st_value, 0x1000); + + check_int("symtab.second", KztDynamicSymbolAt(&table, 1, &entry), 1); + check_int("symtab.second.name", entry.name[0], 'b'); + check_int("symtab.second.size", entry.symbol->st_size, 0x30); + + check_int("symtab.done", KztDynamicSymbolAt(&table, 2, &entry), 0); +} + +static void test_dynamic_versym_pointer(void) +{ + Elf64_Half versym[] = {0, 2, 3}; + + check_int("versym.ptr", + (uintptr_t)KztDynamicVersymFromPtr((uintptr_t)versym, 0), + (uintptr_t)versym); + check_int("versym.null", + (uintptr_t)KztDynamicVersymFromPtr(0, 0), 0); +} + +static void test_dynamic_verneed_entries(void) +{ + static const char strtab[] = "\0libc.so.6\0GLIBC_2.2.5\0GLIBC_2.17\0"; + struct { + Elf64_Verneed need; + Elf64_Vernaux aux[2]; + } verneed = { + .need = { + .vn_version = 1, + .vn_cnt = 2, + .vn_file = 1, + .vn_aux = sizeof(Elf64_Verneed), + }, + .aux = { + { + .vna_hash = 0x1234, + .vna_other = 2, + .vna_name = 11, + .vna_next = sizeof(Elf64_Vernaux), + }, + { + .vna_hash = 0x5678, + .vna_other = 3, + .vna_name = 23, + }, + }, + }; + KztDynamicStringTable strings = { + .data = strtab, + .size = sizeof(strtab), + }; + KztDynamicVerneedEntry need; + KztDynamicVernauxEntry aux; + + check_int("verneed.ptr", + (uintptr_t)KztDynamicVerneedFromPtr((uintptr_t)&verneed, 0), + (uintptr_t)&verneed); + check_int("verneed.entry", + KztDynamicVerneedAt(&verneed.need, 0, &strings, &need), 1); + check_int("verneed.file", need.file[0], 'l'); + check_int("verneed.aux0", + KztDynamicVernauxAt(&need, 0, &strings, &aux), 1); + check_int("verneed.aux0.name", aux.name[6], '2'); + check_int("verneed.aux0.other", aux.record->vna_other, 2); + check_int("verneed.aux1", + KztDynamicVernauxAt(&need, 1, &strings, &aux), 1); + check_int("verneed.aux1.name", aux.name[8], '1'); + check_int("verneed.done", + KztDynamicVernauxAt(&need, 2, &strings, &aux), 0); + check_int("verneed.walk-limit", + KztDynamicVerneedAt(&verneed.need, + KZT_DYNAMIC_VERSION_WALK_MAX, + &strings, &need), 0); + verneed.need.vn_aux = 0; + check_int("verneed.no-aux", + KztDynamicVernauxAt(&need, 0, &strings, &aux), 0); +} + +static void test_dynamic_verdef_entries(void) +{ + static const char strtab[] = "\0libfoo.so\0FOO_1.0\0FOO_PRIVATE\0"; + struct { + Elf64_Verdef def; + Elf64_Verdaux aux[2]; + } verdef = { + .def = { + .vd_version = 1, + .vd_ndx = 2, + .vd_cnt = 2, + .vd_hash = 0x12345678, + .vd_aux = sizeof(Elf64_Verdef), + }, + .aux = { + { + .vda_name = 11, + .vda_next = sizeof(Elf64_Verdaux), + }, + { + .vda_name = 19, + }, + }, + }; + KztDynamicStringTable strings = { + .data = strtab, + .size = sizeof(strtab), + }; + KztDynamicVerdefEntry def; + KztDynamicVerdauxEntry aux; + + check_int("verdef.ptr", + (uintptr_t)KztDynamicVerdefFromPtr((uintptr_t)&verdef, 0), + (uintptr_t)&verdef); + check_int("verdef.entry", + KztDynamicVerdefAt(&verdef.def, 0, &def), 1); + check_int("verdef.index", def.record->vd_ndx, 2); + check_int("verdef.aux0", + KztDynamicVerdauxAt(&def, 0, &strings, &aux), 1); + check_int("verdef.aux0.name", aux.name[4], '1'); + check_int("verdef.aux1", + KztDynamicVerdauxAt(&def, 1, &strings, &aux), 1); + check_int("verdef.aux1.name", aux.name[4], 'P'); + check_int("verdef.done", + KztDynamicVerdauxAt(&def, 2, &strings, &aux), 0); + check_int("verdef.walk-limit", + KztDynamicVerdefAt(&verdef.def, + KZT_DYNAMIC_VERSION_WALK_MAX, &def), 0); + verdef.def.vd_aux = 0; + check_int("verdef.no-aux", + KztDynamicVerdauxAt(&def, 0, &strings, &aux), 0); +} + +static void test_dynamic_relocation_entries(void) +{ + Elf64_Rel rel[] = { + {.r_offset = 0x1000, .r_info = 0x1234}, + }; + Elf64_Rela rela[] = { + {.r_offset = 0x2000, .r_info = 0x5678, .r_addend = -8}, + }; + KztDynamicRelocationTable table; + KztDynamicRelocationEntry entry; + + check_int("relocs.ptr", + (uintptr_t)KztDynamicRelocationsFromPtr((uintptr_t)rel, 0), + (uintptr_t)rel); + check_int("relocs.null", + (uintptr_t)KztDynamicRelocationsFromPtr(0, 0), 0); + + table.entries = rel; + table.count = ARRAY_SIZE(rel); + table.entry_size = sizeof(Elf64_Rel); + check_int("relocs.rel.entry", + KztDynamicRelocationAt(&table, 0, &entry), 1); + check_int("relocs.rel.offset", entry.offset, 0x1000); + check_int("relocs.rel.info", entry.info, 0x1234); + check_int("relocs.rel.has-addend", entry.has_addend, 0); + check_int("relocs.rel.done", + KztDynamicRelocationAt(&table, 1, &entry), 0); + + table.entries = rela; + table.count = ARRAY_SIZE(rela); + table.entry_size = sizeof(Elf64_Rela); + check_int("relocs.rela.entry", + KztDynamicRelocationAt(&table, 0, &entry), 1); + check_int("relocs.rela.offset", entry.offset, 0x2000); + check_int("relocs.rela.info", entry.info, 0x5678); + check_int("relocs.rela.addend", (unsigned long)entry.addend, + (unsigned long)-8); + check_int("relocs.rela.has-addend", entry.has_addend, 1); + + table.entry_size = 1; + check_int("relocs.invalid", + KztDynamicRelocationAt(&table, 0, &entry), 0); +} + +int main(void) +{ + test_ready_dynamic_info(); + test_empty_and_truncated_dynamic(); + test_dynamic_info_errors(); + test_dynamic_string_iteration(); + test_dynamic_symbol_counts(); + test_dynamic_info_for_object(); + test_dynamic_symbol_entries(); + test_dynamic_versym_pointer(); + test_dynamic_verneed_entries(); + test_dynamic_verdef_entries(); + test_dynamic_relocation_entries(); + + if (failures) + return 1; + + puts("KZT guestdynamic tests passed"); + return 0; +} diff --git a/tests/latx-x86_64/kzt-guestobject-test.c b/tests/latx-x86_64/kzt-guestobject-test.c new file mode 100644 index 00000000000..bf479b9f283 --- /dev/null +++ b/tests/latx-x86_64/kzt-guestobject-test.c @@ -0,0 +1,106 @@ +#include "guestobject.h" + +#include +#include +#include + +void *__libc_calloc(size_t nmemb, size_t size) +{ + return calloc(nmemb, size); +} + +void *__libc_realloc(void *ptr, size_t size) +{ + return realloc(ptr, size); +} + +void __libc_free(void *ptr) +{ + free(ptr); +} + +char *box_strdup(const char *s) +{ + return strdup(s); +} + +static int failures; + +static void check_int(const char *name, unsigned long got, + unsigned long expected) +{ + if (got == expected) + return; + + fprintf(stderr, "%s: got 0x%lx expected 0x%lx\n", name, got, expected); + ++failures; +} + +static void check_string(const char *name, const char *got, + const char *expected) +{ + if (got && !strcmp(got, expected)) + return; + + fprintf(stderr, "%s: got \"%s\" expected \"%s\"\n", + name, got ? got : "(null)", expected); + ++failures; +} + +static void test_lookup_by_address(void) +{ + guest_object_registry_t *registry = NewGuestObjectRegistry(); + guest_object_lookup_t lookup; + + check_int("registry.new", registry != NULL, 1); + if (!registry) + return; + + check_int("lookup.empty", + LookupGuestObjectByAddress(registry, 0x1000, &lookup), -1); + check_int("observe.new", + ObserveGuestObject(registry, 0x10, 0x1000, 0x1800, + "/tmp/libfoo.so"), + GUEST_OBJECT_OBSERVE_NEW); + check_int("range.set", + SetGuestObjectMapRange(registry, 0x10, 0x1000, 0x3000), 0); + check_int("state.set", + SetGuestObjectState(registry, 0x10, GUEST_OBJECT_WRAPPED), 0); + + memset(&lookup, 0, sizeof(lookup)); + check_int("lookup.start", + LookupGuestObjectByAddress(registry, 0x1000, &lookup), 0); + check_int("lookup.link-map", lookup.link_map_addr, 0x10); + check_int("lookup.load-bias", lookup.load_bias, 0x1000); + check_int("lookup.dynamic", lookup.dynamic_addr, 0x1800); + check_int("lookup.map-start", lookup.map_start, 0x1000); + check_int("lookup.map-end", lookup.map_end, 0x3000); + check_int("lookup.state", lookup.state, GUEST_OBJECT_WRAPPED); + check_string("lookup.name", lookup.name, "/tmp/libfoo.so"); + + check_int("lookup.end-minus-one", + LookupGuestObjectByAddress(registry, 0x2fff, &lookup), 0); + check_int("lookup.end", + LookupGuestObjectByAddress(registry, 0x3000, &lookup), -1); + + check_int("observe.changed", + ObserveGuestObject(registry, 0x10, 0x4000, 0x4800, + "/tmp/libbar.so"), + GUEST_OBJECT_OBSERVE_CHANGED); + check_int("lookup.cleared-range", + LookupGuestObjectByAddress(registry, 0x1000, &lookup), -1); + + FreeGuestObjectRegistry(®istry); + check_int("registry.free", registry == NULL, 1); +} + +int main(void) +{ + test_lookup_by_address(); + + if (failures) + return 1; + + puts("KZT guestobject tests passed"); + return 0; +} diff --git a/tests/latx-x86_64/kzt-guestpatch-test.c b/tests/latx-x86_64/kzt-guestpatch-test.c new file mode 100644 index 00000000000..2569cf908d1 --- /dev/null +++ b/tests/latx-x86_64/kzt-guestpatch-test.c @@ -0,0 +1,307 @@ +#include "guestpatch.h" + +#include +#include + +static int failures; + +static void check_int(const char *name, unsigned long got, + unsigned long expected) +{ + if (got == expected) + return; + + fprintf(stderr, "%s: got 0x%lx expected 0x%lx\n", name, got, expected); + ++failures; +} + +static void check_string(const char *name, const char *got, + const char *expected) +{ + if (got && !strcmp(got, expected)) + return; + + fprintf(stderr, "%s: got \"%s\" expected \"%s\"\n", + name, got ? got : "(null)", expected); + ++failures; +} + +static void test_patch_decision_defaults(void) +{ + KztPatchDecision decision; + + KztPatchDecisionInit(&decision); + + check_int("defaults.version", (unsigned long)decision.symbol_version, + (unsigned long)-1); + check_int("defaults.reason", decision.reason, KZT_PATCH_REASON_NONE); + check_int("defaults.owner-relation", decision.owner_relation, + KZT_PATCH_OWNER_RELATION_UNKNOWN); + check_int("defaults.shadow-result", decision.shadow_result, + KZT_PATCH_SHADOW_DISABLED); + check_int("defaults.target-source", decision.target_source, + KZT_PATCH_TARGET_MAPLIB); + check_int("defaults.has-target", KztPatchDecisionHasTarget(&decision), 0); + check_string("defaults.reason-name", + KztPatchDecisionReasonName(decision.reason), "none"); + check_string("defaults.owner-relation-name", + KztPatchOwnerRelationName(decision.owner_relation), + "unknown"); + check_string("defaults.shadow-result-name", + KztPatchShadowResultName(decision.shadow_result), + "disabled"); + check_string("defaults.target-source-name", + KztPatchTargetSourceName(decision.target_source), "maplib"); +} + +static void test_patch_decision_names(void) +{ + check_string("reason.local", + KztPatchDecisionReasonName(KZT_PATCH_REASON_LOCAL_SYMBOL), + "local-symbol"); + check_string("reason.global", + KztPatchDecisionReasonName(KZT_PATCH_REASON_GLOBAL_SYMBOL), + "global-symbol"); + check_string("reason.lazy-resolved", + KztPatchDecisionReasonName( + KZT_PATCH_REASON_LAZY_BINDING_RESOLVED), + "lazy-binding-resolved"); + check_string("reason.lazy-current-target", + KztPatchDecisionReasonName( + KZT_PATCH_REASON_LAZY_BINDING_CURRENT_TARGET), + "lazy-binding-current-target"); + check_string("reason.plt-resolver", + KztPatchDecisionReasonName(KZT_PATCH_REASON_PLT_RESOLVER), + "plt-resolver"); + check_string("reason.guest-owner-target", + KztPatchDecisionReasonName( + KZT_PATCH_REASON_GUEST_OWNER_TARGET), + "guest-owner-target"); + check_string("reloc.glob", + KztPatchRelocationTypeName(R_X86_64_GLOB_DAT), + "R_X86_64_GLOB_DAT"); + check_string("reloc.jump", + KztPatchRelocationTypeName(R_X86_64_JUMP_SLOT), + "R_X86_64_JUMP_SLOT"); + check_string("reloc.unknown", KztPatchRelocationTypeName(-1), + "unknown"); + check_string("owner-relation.match", + KztPatchOwnerRelationName(KZT_PATCH_OWNER_RELATION_MATCH), + "match"); + check_string("owner-relation.mismatch", + KztPatchOwnerRelationName(KZT_PATCH_OWNER_RELATION_MISMATCH), + "mismatch"); + check_int("owner-relation-for.match", + KztPatchOwnerRelationForNames("/x/libfoo.so", "libfoo.so"), + KZT_PATCH_OWNER_RELATION_MATCH); + check_int("owner-relation-for.mismatch", + KztPatchOwnerRelationForNames("/x/libfoo.so", "libbar.so"), + KZT_PATCH_OWNER_RELATION_MISMATCH); + check_string("shadow.match", + KztPatchShadowResultName(KZT_PATCH_SHADOW_MATCH), "match"); + check_string("shadow.no-maplib-target", + KztPatchShadowResultName( + KZT_PATCH_SHADOW_NO_MAPLIB_TARGET), + "no-maplib-target"); + check_string("shadow.self-plt", + KztPatchShadowResultName(KZT_PATCH_SHADOW_SELF_PLT), + "self-plt"); + check_string("shadow.no-wrapper", + KztPatchShadowResultName(KZT_PATCH_SHADOW_NO_WRAPPER), + "no-wrapper"); + check_string("shadow.missing", + KztPatchShadowResultName(KZT_PATCH_SHADOW_SYMBOL_MISSING), + "symbol-missing"); + check_string("target-source.maplib", + KztPatchTargetSourceName(KZT_PATCH_TARGET_MAPLIB), "maplib"); + check_string("target-source.guest", + KztPatchTargetSourceName(KZT_PATCH_TARGET_GUEST_OWNER), + "guest-owner"); +} + +static void test_patch_decision_format(void) +{ + KztPatchDecision decision; + char buffer[1024]; + size_t size; + + KztPatchDecisionInit(&decision); + decision.object = "libfoo.so"; + decision.object_base = 0x100000; + decision.relocation = (void *)0x2000; + decision.relocation_index = 7; + decision.relocation_type = R_X86_64_JUMP_SLOT; + decision.symbol = "eglGetProcAddress"; + decision.symbol_version = 3; + decision.symbol_version_name = "EGL_1.5"; + decision.slot = 0x3000; + decision.old_target = 0x4000; + decision.old_owner = "libEGL.so.1"; + decision.old_owner_base = 0x5000; + decision.old_guest_object = "guest-libEGL.so.1"; + decision.old_guest_object_base = 0x5500; + decision.maplib_bridge = 0x5800; + decision.maplib_owner = "maplibegl"; + decision.maplib_owner_base = 0x5900; + decision.maplib_owner_relation = KZT_PATCH_OWNER_RELATION_MISMATCH; + decision.new_bridge = 0x6000; + decision.new_owner = "wrappedlibegl"; + decision.new_owner_base = 0x7000; + decision.guest_owner_bridge = 0x8000; + decision.guest_owner_library = "libEGL.so.1"; + decision.guest_owner = "guest-libEGL.so.1"; + decision.guest_owner_base = 0x5500; + decision.guest_owner_relation = KZT_PATCH_OWNER_RELATION_MATCH; + decision.reason = KZT_PATCH_REASON_GLOBAL_SYMBOL; + decision.owner_relation = KZT_PATCH_OWNER_RELATION_MISMATCH; + decision.shadow_result = KZT_PATCH_SHADOW_MATCH; + decision.target_source = KZT_PATCH_TARGET_GUEST_OWNER; + + size = KztFormatPatchDecision(buffer, sizeof(buffer), &decision); + check_int("format.nonempty", size > 0, 1); + check_int("format.contains-symbol", + strstr(buffer, "symbol=eglGetProcAddress") != NULL, 1); + check_int("format.contains-reason", + strstr(buffer, "reason=global-symbol") != NULL, 1); + check_int("format.contains-bridge", + strstr(buffer, "new_bridge=0x6000") != NULL, 1); + check_int("format.contains-maplib-bridge", + strstr(buffer, "maplib_bridge=0x5800") != NULL, 1); + check_int("format.contains-maplib-owner", + strstr(buffer, "maplib_owner=maplibegl") != NULL, 1); + check_int("format.contains-maplib-owner-relation", + strstr(buffer, "maplib_owner_relation=mismatch") != NULL, 1); + check_int("format.contains-guest-object", + strstr(buffer, "old_guest_object=guest-libEGL.so.1") != NULL, + 1); + check_int("format.contains-owner-relation", + strstr(buffer, "owner_relation=mismatch") != NULL, 1); + check_int("format.contains-guest-owner-bridge", + strstr(buffer, "guest_owner_bridge=0x8000") != NULL, 1); + check_int("format.contains-guest-owner-library", + strstr(buffer, "guest_owner_library=libEGL.so.1") != NULL, 1); + check_int("format.contains-guest-owner-relation", + strstr(buffer, "guest_owner_relation=match") != NULL, 1); + check_int("format.contains-shadow-result", + strstr(buffer, "shadow_result=match") != NULL, 1); + check_int("format.contains-target-source", + strstr(buffer, "target_source=guest-owner") != NULL, 1); +} + +static void test_patch_decision_select_guest_owner(void) +{ + KztPatchDecision decision; + + KztPatchDecisionInit(&decision); + decision.old_guest_object = "/guest/old-guest.so"; + KztPatchDecisionSetMaplibTarget(&decision, 0x1000, "maplib-owner", + 0x2000); + decision.guest_owner_bridge = 0x3000; + decision.guest_owner_library = "libold-guest.so"; + decision.guest_owner = "old-guest.so"; + decision.guest_owner_base = 0x4000; + + KztPatchDecisionSelectGuestOwnerTarget(&decision); + + check_int("select-guest.has-target", KztPatchDecisionHasTarget(&decision), + 1); + check_int("select-guest.bridge", decision.new_bridge, 0x3000); + check_string("select-guest.owner", decision.new_owner, "old-guest.so"); + check_int("select-guest.owner-base", decision.new_owner_base, 0x4000); + check_int("select-guest.owner-relation", decision.owner_relation, + KZT_PATCH_OWNER_RELATION_MATCH); + check_int("select-guest.source", decision.target_source, + KZT_PATCH_TARGET_GUEST_OWNER); + check_int("select-guest.maplib-preserved", decision.maplib_bridge, + 0x1000); + check_string("select-guest.maplib-owner-preserved", + decision.maplib_owner, "maplib-owner"); +} + +static void test_patch_decision_maplib_target(void) +{ + KztPatchDecision decision; + + KztPatchDecisionInit(&decision); + decision.old_guest_object = "/guest/libEGL.so.1"; + + KztPatchDecisionSetMaplibTarget(&decision, 0x1000, "libEGL.so.1", + 0x2000); + + check_int("maplib-target.has-target", KztPatchDecisionHasTarget(&decision), + 1); + check_int("maplib-target.maplib-bridge", decision.maplib_bridge, 0x1000); + check_string("maplib-target.maplib-owner", decision.maplib_owner, + "libEGL.so.1"); + check_int("maplib-target.maplib-owner-base", decision.maplib_owner_base, + 0x2000); + check_int("maplib-target.maplib-relation", decision.maplib_owner_relation, + KZT_PATCH_OWNER_RELATION_MATCH); + check_int("maplib-target.new-bridge", decision.new_bridge, 0x1000); + check_string("maplib-target.new-owner", decision.new_owner, + "libEGL.so.1"); + check_int("maplib-target.new-owner-base", decision.new_owner_base, + 0x2000); + check_int("maplib-target.owner-relation", decision.owner_relation, + KZT_PATCH_OWNER_RELATION_MATCH); + check_int("maplib-target.source", decision.target_source, + KZT_PATCH_TARGET_MAPLIB); +} + +static void test_patch_decision_guest_owner_result(void) +{ + KztPatchDecision decision; + + KztPatchDecisionInit(&decision); + KztPatchDecisionSetGuestOwnerFailure(&decision, + KZT_PATCH_SHADOW_NO_WRAPPER); + check_int("guest-result.failure", decision.shadow_result, + KZT_PATCH_SHADOW_NO_WRAPPER); + + KztPatchDecisionInit(&decision); + decision.maplib_bridge = 0x1000; + decision.new_bridge = decision.maplib_bridge; + KztPatchDecisionSetGuestOwnerTarget(&decision, 0x1000, "libc.so.6", + "libc-owner", 0x2000, 0); + check_int("guest-result.match", decision.shadow_result, + KZT_PATCH_SHADOW_MATCH); + check_int("guest-result.match-relation", decision.guest_owner_relation, + KZT_PATCH_OWNER_RELATION_MAPLIB_ONLY); + check_int("guest-result.match-source", decision.target_source, + KZT_PATCH_TARGET_MAPLIB); + + KztPatchDecisionSetGuestOwnerTarget(&decision, 0x3000, "libc.so.6", + "libc-owner", 0x4000, 0); + check_int("guest-result.mismatch", decision.shadow_result, + KZT_PATCH_SHADOW_MISMATCH); + + KztPatchDecisionInit(&decision); + decision.old_guest_object = "/guest/libc.so.6"; + KztPatchDecisionSetGuestOwnerTarget(&decision, 0x5000, "libc.so.6", + "libc.so.6", 0x6000, 1); + check_int("guest-result.no-maplib", decision.shadow_result, + KZT_PATCH_SHADOW_NO_MAPLIB_TARGET); + check_int("guest-result.no-maplib-source", decision.target_source, + KZT_PATCH_TARGET_GUEST_OWNER); + check_int("guest-result.no-maplib-bridge", decision.new_bridge, 0x5000); + check_int("guest-result.no-maplib-relation", decision.owner_relation, + KZT_PATCH_OWNER_RELATION_MATCH); + check_int("guest-result.no-maplib-guest-relation", + decision.guest_owner_relation, KZT_PATCH_OWNER_RELATION_MATCH); +} + +int main(void) +{ + test_patch_decision_defaults(); + test_patch_decision_names(); + test_patch_decision_format(); + test_patch_decision_maplib_target(); + test_patch_decision_select_guest_owner(); + test_patch_decision_guest_owner_result(); + + if (failures) + return 1; + + puts("KZT guestpatch tests passed"); + return 0; +} diff --git a/tests/latx-x86_64/run-kzt-guestdynamic-tests.sh b/tests/latx-x86_64/run-kzt-guestdynamic-tests.sh new file mode 100755 index 00000000000..1dd3606ffed --- /dev/null +++ b/tests/latx-x86_64/run-kzt-guestdynamic-tests.sh @@ -0,0 +1,16 @@ +#!/bin/sh +set -eu + +repo=$(CDPATH= cd -- "$(dirname -- "$0")/../.." && pwd) +cc=${CC:-cc} +tmpdir=$(mktemp -d "${TMPDIR:-/tmp}/latx-kzt-guestdynamic.XXXXXX") +trap 'rm -rf "$tmpdir"' EXIT INT TERM + +"$cc" -std=gnu99 -Wall -Wextra -Werror \ + -I"$repo/target/i386/latx/include" \ + -I"$repo/include" \ + "$repo/target/i386/latx/context/guestdynamic.c" \ + "$repo/tests/latx-x86_64/kzt-guestdynamic-test.c" \ + -o "$tmpdir/kzt-guestdynamic-test" + +"$tmpdir/kzt-guestdynamic-test" diff --git a/tests/latx-x86_64/run-kzt-guestobject-tests.sh b/tests/latx-x86_64/run-kzt-guestobject-tests.sh new file mode 100644 index 00000000000..a1ce2f92b48 --- /dev/null +++ b/tests/latx-x86_64/run-kzt-guestobject-tests.sh @@ -0,0 +1,20 @@ +#!/bin/sh +set -eu + +repo=$(CDPATH= cd -- "$(dirname -- "$0")/../.." && pwd) +cc=${CC:-cc} +glib_cflags=$(pkg-config --cflags glib-2.0) +tmpdir=$(mktemp -d "${TMPDIR:-/tmp}/latx-kzt-guestobject.XXXXXX") +trap 'rm -rf "$tmpdir"' EXIT INT TERM + +"$cc" -std=gnu99 -Wall -Wextra -Werror -Wno-unused-parameter \ + -I"$repo/target/i386/latx/include" \ + -I"$repo/include" \ + -I"$repo/build64" \ + $glib_cflags \ + "$repo/target/i386/latx/context/guestobject.c" \ + "$repo/tests/latx-x86_64/kzt-guestobject-test.c" \ + -pthread \ + -o "$tmpdir/kzt-guestobject-test" + +"$tmpdir/kzt-guestobject-test" diff --git a/tests/latx-x86_64/run-kzt-guestpatch-tests.sh b/tests/latx-x86_64/run-kzt-guestpatch-tests.sh new file mode 100755 index 00000000000..ee64d42c62d --- /dev/null +++ b/tests/latx-x86_64/run-kzt-guestpatch-tests.sh @@ -0,0 +1,16 @@ +#!/bin/sh +set -eu + +repo=$(CDPATH= cd -- "$(dirname -- "$0")/../.." && pwd) +cc=${CC:-cc} +tmpdir=$(mktemp -d "${TMPDIR:-/tmp}/latx-kzt-guestpatch.XXXXXX") +trap 'rm -rf "$tmpdir"' EXIT INT TERM + +"$cc" -std=gnu99 -Wall -Wextra -Werror \ + -I"$repo/target/i386/latx/include" \ + -I"$repo/include" \ + "$repo/target/i386/latx/context/guestpatch.c" \ + "$repo/tests/latx-x86_64/kzt-guestpatch-test.c" \ + -o "$tmpdir/kzt-guestpatch-test" + +"$tmpdir/kzt-guestpatch-test" diff --git a/tests/latx-x86_64/run-kzt-loader-regressions.sh b/tests/latx-x86_64/run-kzt-loader-regressions.sh new file mode 100755 index 00000000000..a8b7c4c6a8c --- /dev/null +++ b/tests/latx-x86_64/run-kzt-loader-regressions.sh @@ -0,0 +1,778 @@ +#!/bin/sh +set -eu + +if [ "$#" -lt 1 ] || [ "$#" -gt 2 ]; then + echo "usage: $0 /path/to/latx-x86_64 [guest-ld-prefix]" >&2 + exit 2 +fi + +latx=$1 +ld_prefix=${2:-/usr/gnemul/lat-x86_64} + +if [ ! -x "$latx" ]; then + echo "missing executable LATX binary: $latx" >&2 + exit 2 +fi +case $latx in + /*) ;; + *) latx=$(pwd)/$latx ;; +esac + +if ! command -v clang >/dev/null 2>&1; then + echo "skip: clang is required to build x86_64 guest fixtures" >&2 + exit 77 +fi + +if [ ! -e "$ld_prefix/lib64/ld-linux-x86-64.so.2" ] && + [ ! -e "$ld_prefix/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2" ]; then + echo "skip: x86_64 guest loader not found under $ld_prefix" >&2 + exit 77 +fi + +tmpdir=$(mktemp -d "${TMPDIR:-/tmp}/latx-kzt-loader.XXXXXX") +trap 'rm -rf "$tmpdir"' EXIT INT TERM + +guest_lib_dir="$ld_prefix/usr/lib/x86_64-linux-gnu" + +run_guest() +{ + name=$1 + expected=$2 + program=$3 + workdir=${4:-} + + set +e + if [ -n "$workdir" ]; then + (cd "$workdir" && LATX_KZT=1 "$latx" -L "$ld_prefix" "$program") \ + >"$tmpdir/$name.out" 2>"$tmpdir/$name.err" + else + LATX_KZT=1 "$latx" -L "$ld_prefix" "$program" \ + >"$tmpdir/$name.out" 2>"$tmpdir/$name.err" + fi + status=$? + set -e + + if [ "$status" -ne "$expected" ]; then + echo "$name failed: expected exit $expected, got $status" >&2 + cat "$tmpdir/$name.err" >&2 + exit 1 + fi +} + +cat >"$tmpdir/dynamic-no-needed-exit.S" <<'EOF' + .global _start +_start: + mov $60, %rax + mov $42, %rdi + syscall +EOF + +if ! clang --target=x86_64-linux-gnu -nostdlib -pie -fuse-ld=lld \ + -Wl,-dynamic-linker,/lib64/ld-linux-x86-64.so.2 \ + "$tmpdir/dynamic-no-needed-exit.S" \ + -o "$tmpdir/dynamic-no-needed-exit" \ + >"$tmpdir/clang.out" 2>"$tmpdir/clang.err"; then + echo "skip: failed to build x86_64 no-NEEDED guest fixture" >&2 + cat "$tmpdir/clang.err" >&2 + exit 77 +fi + +run_guest dynamic-no-needed 42 "$tmpdir/dynamic-no-needed-exit" + +if [ -e "$guest_lib_dir/libc.so.6" ] && [ -e "$guest_lib_dir/libdl.so.2" ]; then + cat >"$tmpdir/helper.S" <<'EOF' + .text + .global helper_value +helper_value: + mov $5, %eax + ret +EOF + + cat >"$tmpdir/plugin.S" <<'EOF' + .text + .global plugin_value +plugin_value: + call helper_value@PLT + add $118, %eax + ret +EOF + + cat >"$tmpdir/mixed-main.S" <"$tmpdir/self-main.S" <<'EOF' + .text + .global _start +_start: + xor %edi, %edi + mov $2, %esi + call dlopen@PLT + test %rax, %rax + je fail_self_open + mov %rax, %r12 + xor %edi, %edi + mov $2, %esi + call dlopen@PLT + test %rax, %rax + je fail_self_reopen + cmp %r12, %rax + jne fail_self_reopen + mov %rax, %rdi + lea self_sym(%rip), %rsi + call dlsym@PLT + test %rax, %rax + je fail_self_sym + call *%rax + cmp $77, %eax + jne fail_self_call + xor %edi, %edi + call exit@PLT +fail_self_open: + mov $103, %edi + call exit@PLT +fail_self_reopen: + mov $104, %edi + call exit@PLT +fail_self_sym: + mov $105, %edi + call exit@PLT +fail_self_call: + mov $106, %edi + call exit@PLT + .global self_value + .type self_value,@function +self_value: + mov $77, %eax + ret + .section .rodata +self_sym: + .asciz "self_value" +EOF + + clang --target=x86_64-linux-gnu -nostdlib -pie -fuse-ld=lld \ + -Wl,-dynamic-linker,/lib64/ld-linux-x86-64.so.2 \ + -Wl,--export-dynamic \ + "$tmpdir/self-main.S" "$guest_lib_dir/libdl.so.2" \ + "$guest_lib_dir/libc.so.6" -o "$tmpdir/self-main" + + run_guest self-dlopen-dlsym 0 "$tmpdir/self-main" + + cat >"$tmpdir/dladdr-main.S" <<'EOF' + .text + .global _start +_start: + sub $64, %rsp + lea dladdr_target(%rip), %rdi + mov %rsp, %rsi + call dladdr@PLT + test %eax, %eax + je fail_dladdr + add $64, %rsp + xor %edi, %edi + call exit@PLT +fail_dladdr: + add $64, %rsp + mov $112, %edi + call exit@PLT +dladdr_target: + ret +EOF + + clang --target=x86_64-linux-gnu -nostdlib -pie -fuse-ld=lld \ + -Wl,-dynamic-linker,/lib64/ld-linux-x86-64.so.2 \ + -Wl,--export-dynamic \ + "$tmpdir/dladdr-main.S" "$guest_lib_dir/libdl.so.2" \ + "$guest_lib_dir/libc.so.6" -o "$tmpdir/dladdr-main" + + run_guest dladdr-explicit-args 0 "$tmpdir/dladdr-main" + + cat >"$tmpdir/dlinfo-main.S" <<'EOF' + .text + .global _start +_start: + xor %edi, %edi + mov $2, %esi + call dlopen@PLT + test %rax, %rax + je fail_open + mov %rax, %rdi + mov $2, %esi + lea link_map_slot(%rip), %rdx + call dlinfo@PLT + test %eax, %eax + jne fail_dlinfo + mov link_map_slot(%rip), %rax + test %rax, %rax + je fail_link_map + xor %edi, %edi + call exit@PLT +fail_open: + mov $113, %edi + call exit@PLT +fail_dlinfo: + mov $114, %edi + call exit@PLT +fail_link_map: + mov $115, %edi + call exit@PLT + .bss + .align 8 +link_map_slot: + .quad 0 +EOF + + clang --target=x86_64-linux-gnu -nostdlib -pie -fuse-ld=lld \ + -Wl,-dynamic-linker,/lib64/ld-linux-x86-64.so.2 \ + "$tmpdir/dlinfo-main.S" "$guest_lib_dir/libdl.so.2" \ + "$guest_lib_dir/libc.so.6" -o "$tmpdir/dlinfo-main" + + run_guest dlinfo-linkmap 0 "$tmpdir/dlinfo-main" + + cat >"$tmpdir/dlvsym-main.S" <<'EOF' + .text + .global _start +_start: + lea missing_name(%rip), %rdi + mov $2, %esi + call dlopen@PLT + test %rax, %rax + jne fail_missing_open + call dlerror@PLT + test %rax, %rax + je fail_missing_error + xor %edi, %edi + lea exit_sym(%rip), %rsi + lea bad_ver(%rip), %rdx + call dlvsym@PLT + test %rax, %rax + jne fail_bad_version + call dlerror@PLT + test %rax, %rax + je fail_bad_version_error + xor %edi, %edi + lea exit_sym(%rip), %rsi + lea good_ver(%rip), %rdx + call dlvsym@PLT + test %rax, %rax + je fail_good_version + mov $-1, %rdi + lea exit_sym(%rip), %rsi + lea bad_ver(%rip), %rdx + call dlvsym@PLT + test %rax, %rax + jne fail_next_bad_version + call dlerror@PLT + test %rax, %rax + je fail_next_bad_version_error + mov $-1, %rdi + lea exit_sym(%rip), %rsi + lea good_ver(%rip), %rdx + call dlvsym@PLT + test %rax, %rax + je fail_next_good_version + lea plugin_name(%rip), %rdi + mov $2, %esi + call dlopen@PLT + test %rax, %rax + je fail_plugin_open + mov %rax, %r12 + mov %rax, %rdi + lea plugin_sym(%rip), %rsi + lea bad_ver(%rip), %rdx + call dlvsym@PLT + test %rax, %rax + jne fail_handle_bad_version + mov %r12, %rdi + lea plugin_sym(%rip), %rsi + lea plugin_ver(%rip), %rdx + call dlvsym@PLT + test %rax, %rax + je fail_handle_good_version + xor %edi, %edi + call exit@PLT +fail_bad_version: + mov $116, %edi + call exit@PLT +fail_bad_version_error: + mov $121, %edi + call exit@PLT +fail_good_version: + mov $117, %edi + call exit@PLT +fail_plugin_open: + mov $118, %edi + call exit@PLT +fail_handle_bad_version: + mov $119, %edi + call exit@PLT +fail_handle_good_version: + mov $120, %edi + call exit@PLT +fail_missing_open: + mov $122, %edi + call exit@PLT +fail_missing_error: + mov $123, %edi + call exit@PLT +fail_next_bad_version: + mov $124, %edi + call exit@PLT +fail_next_bad_version_error: + mov $125, %edi + call exit@PLT +fail_next_good_version: + mov $126, %edi + call exit@PLT + .section .rodata +exit_sym: + .asciz "exit" +missing_name: + .asciz "./libdoesnotexist-kzt.so" +plugin_name: + .asciz "./libversplugin.so" +plugin_sym: + .asciz "versioned_value" +bad_ver: + .asciz "GLIBC_999.0" +good_ver: + .asciz "GLIBC_2.2.5" +plugin_ver: + .asciz "VERS_1" +EOF + + cat >"$tmpdir/vers-plugin.S" <<'EOF' + .text + .global versioned_value +versioned_value: + mov $9, %eax + ret +EOF + + cat >"$tmpdir/vers-plugin.map" <<'EOF' +VERS_1 { + global: versioned_value; +}; +EOF + + clang --target=x86_64-linux-gnu -nostdlib -shared -fPIC -fuse-ld=lld \ + "$tmpdir/vers-plugin.S" -Wl,--version-script,"$tmpdir/vers-plugin.map" \ + -Wl,-soname,libversplugin.so -o "$tmpdir/libversplugin.so" + clang --target=x86_64-linux-gnu -nostdlib -pie -fuse-ld=lld \ + -Wl,-dynamic-linker,/lib64/ld-linux-x86-64.so.2 \ + "$tmpdir/dlvsym-main.S" "$guest_lib_dir/libdl.so.2" \ + "$guest_lib_dir/libc.so.6" -o "$tmpdir/dlvsym-main" + + run_guest dlvsym-versioned-default 0 "$tmpdir/dlvsym-main" "$tmpdir" +else + echo "skip: guest libc/libdl not found under $guest_lib_dir" >&2 +fi + +if [ -e "$guest_lib_dir/libGL.so.1" ] && [ -e "$guest_lib_dir/libEGL.so.1" ] && + [ -e "$guest_lib_dir/libc.so.6" ] && [ -e "$guest_lib_dir/libdl.so.2" ]; then + cat >"$tmpdir/gl-egl-dlsym.S" <<'EOF' + .global _start +_start: + lea gl_name(%rip), %rdi + mov $6, %esi + call dlopen@PLT + test %rax, %rax + jne fail_gl_unloaded_noload + lea gl_name(%rip), %rdi + mov $2, %esi + call dlopen@PLT + test %rax, %rax + je fail_gl_open + mov %rax, %r12 + mov %rax, %rdi + mov $2, %esi + lea gl_link_map_slot(%rip), %rdx + call dlinfo@PLT + test %eax, %eax + jne fail_gl_dlinfo + mov gl_link_map_slot(%rip), %rax + test %rax, %rax + je fail_gl_dlinfo + cmp %r12, %rax + jne fail_gl_dlopen_handle + mov %rax, %rdi + lea glx_proc(%rip), %rsi + call dlsym@PLT + test %rax, %rax + je fail_gl_dlinfo_handle + mov %r12, %rdi + mov $1, %esi + lea gl_lmid_slot(%rip), %rdx + call dlinfo@PLT + test %eax, %eax + jne fail_gl_dlinfo_lmid + mov %r12, %rax + mov %rax, %rdi + lea glx_proc(%rip), %rsi + call dlsym@PLT + test %rax, %rax + je fail_gl_sym + mov %r12, %rdi + lea gl_missing_proc(%rip), %rsi + call dlsym@PLT + test %rax, %rax + jne fail_gl_missing_sym + call dlerror@PLT + test %rax, %rax + je fail_gl_missing_sym_error + mov %r12, %rdi + lea glx_proc(%rip), %rsi + lea gl_bad_ver(%rip), %rdx + call dlvsym@PLT + test %rax, %rax + jne fail_gl_bad_dlvsym + call dlerror@PLT + test %rax, %rax + je fail_gl_bad_dlvsym_error + lea gl_name(%rip), %rdi + mov $6, %esi + call dlopen@PLT + test %rax, %rax + je fail_gl_noload + cmp %r12, %rax + jne fail_gl_noload + mov %rax, %r13 + mov %r13, %rdi + call dlclose@PLT + test %eax, %eax + jne fail_gl_noload_close + mov %r12, %rdi + lea glx_proc(%rip), %rsi + call dlsym@PLT + test %rax, %rax + je fail_gl_noload_ref + mov %r12, %rdi + call dlclose@PLT + mov %r12, %rdi + lea glx_proc(%rip), %rsi + lea gl_bad_ver(%rip), %rdx + call dlvsym@PLT + test %rax, %rax + jne fail_gl_closed_dlvsym + mov %r12, %rdi + mov $2, %esi + lea gl_link_map_slot(%rip), %rdx + call dlinfo@PLT + test %eax, %eax + je fail_gl_closed_dlinfo + call dlerror@PLT + test %rax, %rax + je fail_gl_closed_dlinfo_error + call dlerror@PLT + test %rax, %rax + jne fail_gl_closed_dlinfo_error + lea gl_name(%rip), %rdi + mov $2, %esi + call dlopen@PLT + test %rax, %rax + je fail_gl_reopen + mov %rax, %r12 + mov %rax, %rdi + lea glx_proc(%rip), %rsi + call dlsym@PLT + test %rax, %rax + je fail_gl_reopen_sym + mov %r12, %rdi + call dlclose@PLT + test %eax, %eax + jne fail_gl_reopen_close + mov %r12, %rdi + call dlclose@PLT + test %eax, %eax + je fail_gl_double_close + + lea egl_name(%rip), %rdi + mov $2, %esi + call dlopen@PLT + test %rax, %rax + je fail_egl_open + mov %rax, %r12 + mov %rax, %rdi + lea egl_proc(%rip), %rsi + call dlsym@PLT + test %rax, %rax + je fail_egl_sym + mov %r12, %rdi + call dlclose@PLT + + xor %edi, %edi + call exit@PLT +fail_gl_open: + mov $96, %edi + call exit@PLT +fail_gl_unloaded_noload: + mov $109, %edi + call exit@PLT +fail_gl_sym: + mov $97, %edi + call exit@PLT +fail_gl_missing_sym: + mov $118, %edi + call exit@PLT +fail_gl_missing_sym_error: + mov $119, %edi + call exit@PLT +fail_gl_bad_dlvsym: + mov $116, %edi + call exit@PLT +fail_gl_bad_dlvsym_error: + mov $117, %edi + call exit@PLT +fail_gl_noload: + mov $106, %edi + call exit@PLT +fail_gl_noload_close: + mov $107, %edi + call exit@PLT +fail_gl_noload_ref: + mov $108, %edi + call exit@PLT +fail_gl_dlinfo: + mov $100, %edi + call exit@PLT +fail_gl_dlopen_handle: + mov $115, %edi + call exit@PLT +fail_gl_dlinfo_handle: + mov $111, %edi + call exit@PLT +fail_gl_dlinfo_lmid: + mov $110, %edi + call exit@PLT +fail_gl_closed_dlinfo: + mov $101, %edi + call exit@PLT +fail_gl_closed_dlinfo_error: + mov $114, %edi + call exit@PLT +fail_gl_closed_dlvsym: + mov $112, %edi + call exit@PLT +fail_gl_reopen: + mov $102, %edi + call exit@PLT +fail_gl_reopen_sym: + mov $103, %edi + call exit@PLT +fail_gl_reopen_close: + mov $104, %edi + call exit@PLT +fail_gl_double_close: + mov $105, %edi + call exit@PLT +fail_egl_open: + mov $98, %edi + call exit@PLT +fail_egl_sym: + mov $99, %edi + call exit@PLT + .section .rodata +gl_name: + .asciz "libGL.so.1" +glx_proc: + .asciz "glXGetProcAddressARB" +gl_missing_proc: + .asciz "kztDefinitelyMissingGLSymbol" +gl_bad_ver: + .asciz "GLIBC_999.0" +egl_name: + .asciz "libEGL.so.1" +egl_proc: + .asciz "eglGetProcAddress" + .bss + .align 8 +gl_link_map_slot: + .quad 0 +gl_lmid_slot: + .quad 0 +EOF + + clang --target=x86_64-linux-gnu -nostdlib -pie -fuse-ld=lld \ + -Wl,-dynamic-linker,/lib64/ld-linux-x86-64.so.2 \ + "$tmpdir/gl-egl-dlsym.S" "$guest_lib_dir/libdl.so.2" \ + "$guest_lib_dir/libc.so.6" -o "$tmpdir/gl-egl-dlsym" + + run_guest gl-egl-dlsym 0 "$tmpdir/gl-egl-dlsym" +else + echo "skip: guest libGL/libEGL/libc/libdl set not found under $guest_lib_dir" >&2 +fi + +echo "KZT loader regressions passed"