From 33d3ded40b70ee058cebb4fcc4e188355220be26 Mon Sep 17 00:00:00 2001 From: _xeroxz Date: Thu, 24 Jun 2021 01:09:51 -0700 Subject: [PATCH] added fcml to the project... testing it out... need to remove the rat though.... --- .gitmodules | 3 + dependencies/cli-parser | 1 + dependencies/fcml/fcml.dll | Bin 0 -> 559104 bytes dependencies/fcml/fcml.lib | Bin 0 -> 58828 bytes dependencies/fcml/include/fcml_assembler.h | 227 + dependencies/fcml/include/fcml_assembler.hpp | 946 ++ dependencies/fcml/include/fcml_choosers.h | 87 + dependencies/fcml/include/fcml_common.h | 832 ++ dependencies/fcml/include/fcml_common.hpp | 9142 +++++++++++++++++ dependencies/fcml/include/fcml_common_utils.h | 660 ++ dependencies/fcml/include/fcml_dialect.h | 53 + dependencies/fcml/include/fcml_dialect.hpp | 129 + dependencies/fcml/include/fcml_disassembler.h | 356 + .../fcml/include/fcml_disassembler.hpp | 2329 +++++ dependencies/fcml/include/fcml_env.h | 96 + dependencies/fcml/include/fcml_errors.h | 187 + dependencies/fcml/include/fcml_errors.hpp | 388 + dependencies/fcml/include/fcml_gas_dialect.h | 62 + .../fcml/include/fcml_gas_dialect.hpp | 66 + .../fcml/include/fcml_gas_mnemonics.cpp | 1934 ++++ .../fcml/include/fcml_gas_mnemonics.h | 1931 ++++ .../fcml/include/fcml_gas_mnemonics.hpp | 1938 ++++ dependencies/fcml/include/fcml_instructions.h | 1548 +++ .../fcml/include/fcml_intel_dialect.h | 58 + .../fcml/include/fcml_intel_dialect.hpp | 66 + .../fcml/include/fcml_intel_mnemonics.cpp | 1716 ++++ .../fcml/include/fcml_intel_mnemonics.h | 1715 ++++ .../fcml/include/fcml_intel_mnemonics.hpp | 1724 ++++ .../fcml/include/fcml_lag_assembler.h | 121 + .../fcml/include/fcml_lag_assembler.hpp | 479 + dependencies/fcml/include/fcml_lib_export.h | 63 + dependencies/fcml/include/fcml_optimizers.h | 144 + dependencies/fcml/include/fcml_parser.h | 166 + dependencies/fcml/include/fcml_parser.hpp | 486 + dependencies/fcml/include/fcml_registers.cpp | 288 + dependencies/fcml/include/fcml_registers.hpp | 288 + dependencies/fcml/include/fcml_renderer.h | 124 + dependencies/fcml/include/fcml_renderer.hpp | 226 + .../fcml/include/fcml_stateful_assembler.hpp | 554 + .../include/fcml_stateful_disassembler.hpp | 210 + dependencies/fcml/include/fcml_symbols.h | 149 + dependencies/fcml/include/fcml_symbols.hpp | 265 + dependencies/fcml/include/fcml_types.h | 271 + include/llodctor_pe.hpp | 2 +- include/lloiff.hpp | 5 - llo-s1.vcxproj | 43 + llo-s1.vcxproj.filters | 120 + src/main.cpp | 22 +- 48 files changed, 32209 insertions(+), 11 deletions(-) create mode 100644 .gitmodules create mode 160000 dependencies/cli-parser create mode 100644 dependencies/fcml/fcml.dll create mode 100644 dependencies/fcml/fcml.lib create mode 100644 dependencies/fcml/include/fcml_assembler.h create mode 100644 dependencies/fcml/include/fcml_assembler.hpp create mode 100644 dependencies/fcml/include/fcml_choosers.h create mode 100644 dependencies/fcml/include/fcml_common.h create mode 100644 dependencies/fcml/include/fcml_common.hpp create mode 100644 dependencies/fcml/include/fcml_common_utils.h create mode 100644 dependencies/fcml/include/fcml_dialect.h create mode 100644 dependencies/fcml/include/fcml_dialect.hpp create mode 100644 dependencies/fcml/include/fcml_disassembler.h create mode 100644 dependencies/fcml/include/fcml_disassembler.hpp create mode 100644 dependencies/fcml/include/fcml_env.h create mode 100644 dependencies/fcml/include/fcml_errors.h create mode 100644 dependencies/fcml/include/fcml_errors.hpp create mode 100644 dependencies/fcml/include/fcml_gas_dialect.h create mode 100644 dependencies/fcml/include/fcml_gas_dialect.hpp create mode 100644 dependencies/fcml/include/fcml_gas_mnemonics.cpp create mode 100644 dependencies/fcml/include/fcml_gas_mnemonics.h create mode 100644 dependencies/fcml/include/fcml_gas_mnemonics.hpp create mode 100644 dependencies/fcml/include/fcml_instructions.h create mode 100644 dependencies/fcml/include/fcml_intel_dialect.h create mode 100644 dependencies/fcml/include/fcml_intel_dialect.hpp create mode 100644 dependencies/fcml/include/fcml_intel_mnemonics.cpp create mode 100644 dependencies/fcml/include/fcml_intel_mnemonics.h create mode 100644 dependencies/fcml/include/fcml_intel_mnemonics.hpp create mode 100644 dependencies/fcml/include/fcml_lag_assembler.h create mode 100644 dependencies/fcml/include/fcml_lag_assembler.hpp create mode 100644 dependencies/fcml/include/fcml_lib_export.h create mode 100644 dependencies/fcml/include/fcml_optimizers.h create mode 100644 dependencies/fcml/include/fcml_parser.h create mode 100644 dependencies/fcml/include/fcml_parser.hpp create mode 100644 dependencies/fcml/include/fcml_registers.cpp create mode 100644 dependencies/fcml/include/fcml_registers.hpp create mode 100644 dependencies/fcml/include/fcml_renderer.h create mode 100644 dependencies/fcml/include/fcml_renderer.hpp create mode 100644 dependencies/fcml/include/fcml_stateful_assembler.hpp create mode 100644 dependencies/fcml/include/fcml_stateful_disassembler.hpp create mode 100644 dependencies/fcml/include/fcml_symbols.h create mode 100644 dependencies/fcml/include/fcml_symbols.hpp create mode 100644 dependencies/fcml/include/fcml_types.h diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..6f6a91b --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "dependencies/cli-parser"] + path = dependencies/cli-parser + url = https://githacks.org/_xeroxz/cli-parser.git diff --git a/dependencies/cli-parser b/dependencies/cli-parser new file mode 160000 index 0000000..1aedaf8 --- /dev/null +++ b/dependencies/cli-parser @@ -0,0 +1 @@ +Subproject commit 1aedaf8bb7f383f54b7cd498767611535526da85 diff --git a/dependencies/fcml/fcml.dll b/dependencies/fcml/fcml.dll new file mode 100644 index 0000000000000000000000000000000000000000..4f9d23de7f235f5b91bc80c612a7441358bc67e9 GIT binary patch literal 559104 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

_ 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ΔR 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

rH{nZ^ZV!C2)zM%)Ra5sN7QK{%=9xlzD#g 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 RyvvJ=*lq_HJYt$Q{y(}HO`ZS% literal 0 HcmV?d00001 diff --git a/dependencies/fcml/include/fcml_assembler.h b/dependencies/fcml/include/fcml_assembler.h new file mode 100644 index 0000000..3018c86 --- /dev/null +++ b/dependencies/fcml/include/fcml_assembler.h @@ -0,0 +1,227 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_assembler.h + * Structures and functions declarations related to one-line FCML assembler. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ASSEMBLER_H_ +#define FCML_ASSEMBLER_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_common.h" +#include "fcml_dialect.h" +#include "fcml_optimizers.h" +#include "fcml_choosers.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Abstract assembler representation. */ +typedef struct fcml_st_assembler fcml_st_assembler; + +/** + * Assembler runtime configuration. + */ +typedef struct fcml_st_assembler_conf { + /** Set to true in order to force assembler to increment IP address by + * length of the assembled instruction. */ + fcml_bool increment_ip; + /** True if optional error and warning messages should be collected + * during processing. */ + fcml_bool enable_error_messages; + /** If there are SIB and "ModR/M only" encodings available, choose + * the SIB based one. */ + fcml_bool choose_sib_encoding; + /** If memory address can be encoded as relative or absolute value choose + * the absolute addressing. It works in 64 bit mode only. */ + fcml_bool choose_abs_encoding; + /** Sometimes REX prefix is useless so it is just omitted in the final + * machine code. By setting this flag to true you can force this prefix +to be added anyway. */ + fcml_bool force_rex_prefix; + /** Every 2 byte VEX/XOP prefix can be encoded using three byte form. + * Setting this flag to true forces it. */ + fcml_bool force_three_byte_VEX; + /** Optimizer implementation that should be used by assembler. Setting it + * to NULL causes assembler to use default one. */ + fcml_fnp_asm_optimizer optimizer; + /** This field is passed to the chosen optimizer. It can be used to + * configure its behavior. */ + fcml_uint16_t optimizer_flags; + /** instruction chooser implementation that should be used by assembler + * to choose most appropriate instruction encoding. Setting this value to + * NULL cause assembler to use default instruction chooser. */ + fcml_fnp_asm_instruction_chooser chooser; +} fcml_st_assembler_conf; + +/** + * Encoded instruction. + * Every instruction might be encoded to more than one binary form. + * This chain holds all forms assembler was able to assemble instruction to. + */ +typedef struct fcml_st_assembled_instruction { + /** Next assembled instruction in the chain. */ + struct fcml_st_assembled_instruction *next; + /** Warning messages related to assembled instruction.*/ + fcml_st_ceh_error_container warnings; + /** Instruction machine code.*/ + fcml_uint8_t *code; + /** Instruction code length in bytes.*/ + fcml_usize code_length; +#ifdef FCML_DEBUG + fcml_uint8_t __def_index; +#endif +} fcml_st_assembled_instruction; + +/** Assembler result. */ +typedef struct fcml_st_assembler_result { + /** Error and warning messages from assembler.*/ + fcml_st_ceh_error_container errors; + /** Chain of assembled instructions. */ + fcml_st_assembled_instruction *instructions; + /** Instruction chosen by used instruction chooser; otherwise NULL.*/ + fcml_st_assembled_instruction *chosen_instruction; + /** Number of encoded instruction forms. */ + fcml_usize number_of_instructions; +} fcml_st_assembler_result; + +/** Assembler runtime context. */ +typedef struct fcml_st_assembler_context { + /** Assembler instance that should be used to assemble instructions. */ + fcml_st_assembler *assembler; + /** Assembler behavior can be configured here.*/ + fcml_st_assembler_conf configuration; + /** Instruction entry point configuration. */ + fcml_st_entry_point entry_point; +} fcml_st_assembler_context; + +/** + * Initializes assembler for given dialect. + * Initializes assembler instance for given dialect (Intel, AT&T). Assembler + * initialized in such a way is dialect dependent and supports GIM with the + * syntax supported by it. Every assembler instance has to be freed using + * fcml_fn_assembler_free() function as soon as it is not needed anymore. + * + * @param dialect Dialect instance. + * @param[out] assembler Initialized assembler instance. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_assembler_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_assembler_init( + const fcml_st_dialect *dialect, fcml_st_assembler **assembler); + +/** + * Assembles one instruction encoded in the generic instruction model. + * Instruction is proceeded using configuration and assembler provided + * in given fcml_st_assembler_context instance. Assembled code as well + * as potential errors or warnings are accessible via provided reusable + * result holder instance. Result holder has to be allocated by the + * user and appropriately prepared using fcml_fn_assembler_result_prepare() + * function. As long as the instruction context and the result holder + * are not shared across multiple function calls assembling process is + * thread safe. + * + * @param context Assembler context (Assembler, Entry Point, Configuration). + * @param instruction Instruction encoded as generic instruction model + * (Dialect dependent). + * @param result Result holder (Remember to prepare it appropriately). + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_assembler_result_prepare fcml_fn_assembler_init + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_assemble( + fcml_st_assembler_context *context, + const fcml_st_instruction *instruction, + fcml_st_assembler_result *result); + +/** + * Prepares reusable result holder for assembler. + * Every instance of fcml_st_assembler_result structure is reusable from + * the assembler's point of view, so it has to be prepared in the right way + * in order to allow assembler to reuse it correctly. It is up to the library + * user to allocate space for the holder itself. This function is only + * responsible for cleaning the structure correctly and preparing it for the + * first assembling process. Notice that assembler has to clean the result + * holder at the beginning so you can not pass an uninitialized memory block + * because it can even cause a crash due to illegal memory access. + * + * @param result Result holder instance to be prepared. + */ +LIB_EXPORT void LIB_CALL fcml_fn_assembler_result_prepare( + fcml_st_assembler_result *result); + +/** + * Cleans result holder. + * Frees all memory blocks allocated by the assembler and held inside the + * result holder (Instructions, errors etc.). Notice that result holder itself + * is not freed and can be even safety reused after call to this function. In + * fact this function is also called internally by the assembler in order to + * clean result holder before reusing it. + * @param result Result holder to clean. + */ +LIB_EXPORT void LIB_CALL fcml_fn_assembler_result_free( + fcml_st_assembler_result *result); + +/** + * Frees assembled instruction. + * Take into account that it does not free whole chain recursively but only + * the one instruction you have provided. + * @param instruction Instruction to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_assembler_instruction_free( + fcml_st_assembled_instruction *instruction); + +/** + * Detaches given instruction from the instructions chain. + * Removes given assembled instruction from the provided chain in order + * to prevent premature freeing of memory while assembler cleans result holder + * reusing it. Detached instructions are not automatically deallocated by + * fcml_fn_assemble() or fcml_fn_assembler_result_free() functions, so + * it is up to you to free it using fcml_fn_assembler_instruction_free() + * function when it is not needed anymore. Function may be useful + * when you need to store assembled instructions across multiple calls + * to the assembler if you reuse the same result holder. If there is only one + * instruction in the chain its pointer will be set to NULL after detaching it. + * @param chain Pointer to the instructions chain pointer. + * @param instruction Instruction to be detached from the chain. + * + */ +LIB_EXPORT void LIB_CALL fcml_fn_assembler_instruction_detach( + fcml_st_assembled_instruction **chain, + fcml_st_assembled_instruction *instruction); + +/** + * Frees assembler instance. + * Every assembler instance manages some resources internally and as such it has + * to be deallocated as soon as it is not needed anymore. + * @param assembler Assembler to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_assembler_free(fcml_st_assembler *assembler); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_ASSEMBLER_H_ */ diff --git a/dependencies/fcml/include/fcml_assembler.hpp b/dependencies/fcml/include/fcml_assembler.hpp new file mode 100644 index 0000000..4fc57dd --- /dev/null +++ b/dependencies/fcml/include/fcml_assembler.hpp @@ -0,0 +1,946 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_assembler.hpp + * C++ wrapper for FCML assembler. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ASSEMBLER_HPP_ +#define FCML_ASSEMBLER_HPP_ + +#include +#include + +#include "fcml_assembler.h" + +#include "fcml_common.hpp" +#include "fcml_errors.hpp" +#include "fcml_dialect.hpp" + +namespace fcml { + +/** + * Assembling failed. + * @since 1.1.0 + */ +class AssemblingFailedException: public ErrorContainerAwareException { +public: + AssemblingFailedException(const fcml_cstring msg, + ErrorContainer errorContainer = ErrorContainer(), + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR) : + ErrorContainerAwareException(msg, errorContainer, error) { + } +}; + +/** Describes an assembled instruction. + * @since 1.1.0 + */ +class AssembledInstruction { +public: + + /** + * Creates an assembled instruction basing on given code buffer and errors. + * + * @param buffer Pointer to the machine code buffer. + * @param len Number of machine code bytes. + * @param errorContainer Potential warnings related to the + * assembled instruction. + * @since 1.1.0 + * + */ + AssembledInstruction(const fcml_uint8_t *buffer, fcml_usize len, + const ErrorContainer &errorContainer) { + set(buffer, len, errorContainer); + } + + /** + * Copy constructor. + * @since 1.1.0 + */ + AssembledInstruction(const AssembledInstruction &cpy) { + set(cpy._code, cpy._codeLength, cpy._warningContainer); + } + + /** + * Copies one instruction into another. + * + * @param cpy The source instruction. + * @return A reference to the destination instruction. + * @since 1.1.0 + */ + AssembledInstruction& operator=(const AssembledInstruction &cpy) { + if (&cpy != this) { + if (this->_code) { + delete[] this->_code; + } + set(cpy._code, cpy._codeLength, cpy._warningContainer); + } + return *this; + } + + /** + * @since 1.1.0 + */ + virtual ~AssembledInstruction() { + if (_code) { + delete[] _code; + _code = NULL; + } + } + +public: + + /** + * Gets pointer to machine code buffer. + * + * @return Pointer to machine code buffer. + * @since 1.1.0 + */ + const fcml_uint8_t* getCode() const { + return _code; + } + + /** + * Gets number of bytes in the buffer. + * + * @return Number of bytes in the buffer. + * @since 1.1.0 + */ + fcml_usize getCodeLength() const { + return _codeLength; + } + + /** + * Gets reference to the errors container. + * + * @return A reference to the errors container. + * @since 1.1.0 + */ + const ErrorContainer& getWarningContainer() const { + return _warningContainer; + } + +private: + + /** + * Fills the assembled instruction with new data. + * + * @param buffer The code buffer. + * @param len The code buffer lenght. + * @param warnings The warnings container. + * @since 1.1.0 + */ + void set(const fcml_uint8_t *buffer, fcml_usize len, + const ErrorContainer warnigns) { + _warningContainer = warnigns; + if (len > 0) { + _code = new fcml_uint8_t[len]; + for (fcml_usize i = 0; i < len; i++) { + _code[i] = buffer[i]; + } + } else { + _code = NULL; + } + _codeLength = len; + } + +private: + + /** Warnings related to this instruction. */ + ErrorContainer _warningContainer; + + /** Pointer to the instruction machine code. */ + fcml_uint8_t *_code; + + /** Number of machine code bytes in the array above. */ + fcml_usize _codeLength; + +}; + +class Assembler; + +/** Assembler result. */ +class AssemblerResult { +public: + + /** + * @since 1.1.0 + */ + AssemblerResult() : + _chosenInstructionIndex(-1) { + } + +public: + + /** + * Gets instruction chosen by the assembler as the preferred one. + * + * @return Preferred instruction. + * @since 1.1.0 + */ + const AssembledInstruction* getChosenInstruction() const { + if (_chosenInstructionIndex == -1) { + return NULL; + } + return &(_assembledInstructions[_chosenInstructionIndex]); + } + + /** + * Gets errors container. + * + * @return Errors container. + * @since 1.1.0 + */ + const ErrorContainer& getErrorContainer() const { + return _errorContainer; + } + + /** + * Gets number of instructions alternatives available in the result. + * + * @return Number of available instructions. + * @since 1.1.0 + */ + fcml_usize getSize() const { + return static_cast(_assembledInstructions.size()); + } + + /** + * Gets pointer to the chosen instruction. + * + * @return Pointer to the chosen instruction. + * @since 1.1.0 + */ + operator const AssembledInstruction*() const { + if (_chosenInstructionIndex == -1) { + return NULL; + } + return &(_assembledInstructions[_chosenInstructionIndex]); + } + + /** + * Gets an assembled instruction reference by its index. + * + * @return The assembled instruction for given index. + * @throw BadArgumentException Array index out of bound. + * @since 1.1.0 + */ + const AssembledInstruction& operator[](fcml_usize index) const { + if (index > _assembledInstructions.size()) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _assembledInstructions[index]; + } + + /** + * Copies machine code of the chosen instruction to the output stream. + * + * @param[out] out Output stream. + * @param result Assembler result. + * @return Output stream from the parameter. + * @since 1.1.0 + */ + friend std::basic_ostream& operator<<( + std::basic_ostream &out, + const AssemblerResult &result) { + const AssembledInstruction *assembled = result.getChosenInstruction(); + if (assembled) { + // If chosen instruction is not available, do not + // stream anything. It's not so common, because + // instructions choosers are obliged to chose something. + if (assembled->getCode() && assembled->getCodeLength() > 0) { + out.write(assembled->getCode(), assembled->getCodeLength()); + } + } + return out; + } + + /** + * Clears assembler result by removing all assembled instructions, + * errors and reseting the chosen instruction. + * @since 1.1.0 + */ + void clear() { + _errorContainer.clean(); + _assembledInstructions.clear(); + _chosenInstructionIndex = -1; + } + +protected: + + friend Assembler; + + void setErrorContainer(const ErrorContainer &errorContainer) { + _errorContainer = errorContainer; + } + + std::vector& getAssembledInstructions() { + return _assembledInstructions; + } + + void setChoosenInstructionIndex(fcml_int index) { + _chosenInstructionIndex = index; + } + +private: + + /** Assembling errors. */ + ErrorContainer _errorContainer; + /** All assembled instructions are going here. */ + std::vector _assembledInstructions; + /** Index for the chosen instruction. */ + fcml_int _chosenInstructionIndex; + +}; + +/** Assembler configuration. + * For more information about the flags, see fcml_st_assembler_conf + * structure documentation. + * @since 1.1.0 + */ +class AssemblerConf { +public: + + /** + * @since 1.1.0 + */ + AssemblerConf() : + _throwExceptionOnError(true), + _incrementIp(true), + _enableErrorMessages(true), + _chooseSibEncoding(false), + _chooseAbsEncoding(false), + _forceRexPrefix(false), + _forceThreeByteVEX(false), + _noBranchPrediction(false), + _optimizer(NULL), + _optimizerFlags(0), + _chooser(NULL) { + } + +public: + + /** + * @since 1.1.0 + */ + bool isChooseAbsEncoding() const { + return _chooseAbsEncoding; + } + + /** + * @since 1.1.0 + */ + void setChooseAbsEncoding(bool chooseAbsEncoding) { + _chooseAbsEncoding = chooseAbsEncoding; + } + + /** + * @since 1.1.0 + */ + fcml_fnp_asm_instruction_chooser getChooser() const { + return _chooser; + } + + /** + * @since 1.1.0 + */ + void setChooser(fcml_fnp_asm_instruction_chooser chooser) { + _chooser = chooser; + } + + /** + * @since 1.1.0 + */ + bool isChooseSibEncoding() const { + return _chooseSibEncoding; + } + + /** + * @since 1.1.0 + */ + void setChooseSibEncoding(bool chooseSibEncoding) { + _chooseSibEncoding = chooseSibEncoding; + } + + /** + * @since 1.1.0 + */ + bool isEnableErrorMessages() const { + return _enableErrorMessages; + } + + /** + * @since 1.1.0 + */ + void setEnableErrorMessages(bool enableErrorMessages) { + _enableErrorMessages = enableErrorMessages; + } + + /** + * @since 1.1.0 + */ + bool isForceRexPrefix() const { + return _forceRexPrefix; + } + + /** + * @since 1.1.0 + */ + void setForceRexPrefix(bool forceRexPrefix) { + _forceRexPrefix = forceRexPrefix; + } + + /** + * @since 1.1.0 + */ + bool isForceThreeByteVex() const { + return _forceThreeByteVEX; + } + + /** + * @since 1.1.0 + */ + void setForceThreeByteVex(bool forceThreeByteVex) { + _forceThreeByteVEX = forceThreeByteVex; + } + + /** + * @since 1.1.0 + */ + bool isIncrementIp() const { + return _incrementIp; + } + + /** + * @since 1.1.0 + */ + void setIncrementIp(bool incrementIp) { + _incrementIp = incrementIp; + } + + /** + * @since 1.1.0 + */ + fcml_fnp_asm_optimizer getOptimizer() const { + return _optimizer; + } + + /** + * @since 1.1.0 + */ + void setOptimizer(fcml_fnp_asm_optimizer optimizer) { + _optimizer = optimizer; + } + + /** + * @since 1.1.0 + */ + fcml_uint16_t getOptimizerFlags() const { + return _optimizerFlags; + } + + /** + * @since 1.1.0 + */ + void setOptimizerFlags(fcml_uint16_t optimizerFlags) { + _optimizerFlags = optimizerFlags; + } + + /** + * Returns true if exception should be thrown when assembling fails. + * + * @return True if exception is the preferred way of error handling + * in case of failure. + * @since 1.1.0 + */ + bool isThrowExceptionOnError() const { + return _throwExceptionOnError; + } + + /** + * Sets the way how the error handling is done. + * + * @param throwExceptionOnError True if exception should be thrown + * in case of failure. + * @since 1.1.0 + */ + void setThrowExceptionOnError(bool throwExceptionOnError) { + _throwExceptionOnError = throwExceptionOnError; + } + +private: + bool _throwExceptionOnError; + bool _incrementIp; + bool _enableErrorMessages; + bool _chooseSibEncoding; + bool _chooseAbsEncoding; + bool _forceRexPrefix; + bool _forceThreeByteVEX; + bool _noBranchPrediction; + fcml_fnp_asm_optimizer _optimizer; + fcml_uint16_t _optimizerFlags; + fcml_fnp_asm_instruction_chooser _chooser; +}; + +/** Assembler context. + * + * It is a counterpart to the fcml_st_assembler_context structure. + * @since 1.1.0 + */ +class AssemblerContext { + +public: + + /** + * @since 1.1.0 + */ + AssemblerContext() { + } + + /** + * Creates an entry point instance for given operating mode + * and optional instruction pointer. + * + * @param operatingMode The processor operating mode. + * @param ip The instruction pointer. + * @since 1.1.0 + */ + AssemblerContext(EntryPoint::OperatingMode operatingMode, fcml_ip ip = 0) : + _entryPoint(operatingMode, ip) { + } + +public: + + /** + * Gets constant assembler configuration associated with the context. + * + * @return Assembler configuration. + * @since 1.1.0 + */ + const AssemblerConf& getConfig() const { + return _config; + } + + /** + * Gets assembler configuration associated with the context. + * + * @return Assembler configuration. + * @since 1.1.0 + */ + AssemblerConf& getConfig() { + return _config; + } + + /** + * Copies given configuration to the instance associated with the context. + * Deep copy is performed, so passed object not need to be maintained as + * long as the context is used. + * + * @param config Configuration that is copied to the context. + * @since 1.1.0 + */ + void setConfig(const AssemblerConf &config) { + _config = config; + } + + /** + * Gets reference to the constant entry point instance + * associated with the context. + * + * @return Reference to the constant entry point. + * @since 1.1.0 + */ + const EntryPoint& getEntryPoint() const { + return _entryPoint; + } + + /** + * Gets reference to the entry point instance associated with the context. + * + * @return Reference to the entry point. + * @since 1.1.0 + */ + EntryPoint& getEntryPoint() { + return _entryPoint; + } + /** + * Copies given entry point to the instance associated with the context. + * Deep copy is performed, so passed object not need to be maintained as + * long as the context is used. + * + * @param entryPoint The entry point. + * @since 1.1.0 + */ + void setEntryPoint(const EntryPoint &entryPoint) { + _entryPoint = entryPoint; + } + + /** + * Sets instruction pointer directly into the entry point. + * + * @param ip The new IP. + * @since 1.1.0 + */ + void setIP(fcml_ip ip) { + _entryPoint.setIP(ip); + } + + /** + * Increments entry point by given number of bytes. + * + * @param ip Number of bytes the instruction pointer + * has to be incremented by. + * @since 1.1.0 + */ + void incrementIP(fcml_ip ip) { + _entryPoint.incrementIP(ip); + } + + /** + * Sets processor operating mode directly into the entry point. + * + * @param operatingMode Processor operating mode to be set. + * @since 1.1.0 + */ + void setOperatingMode(EntryPoint::OperatingMode operatingMode) { + _entryPoint.setOpMode(operatingMode); + } + + /** + * Sets a new address size attribute for the entry point. + * + * @param addressSizeAttribute The address size attribute. + * @since 1.1.0 + */ + void setAddressSizeAttribute(fcml_usize addressSizeAttribute) { + _entryPoint.setAddressSizeAttribute(addressSizeAttribute); + } + + /** + * Sets a new operand size attribute for the entry point. + * + * @param operandSizeAttribute The operand size attribute. + * @since 1.1.0 + */ + void setOperandSizeAttribute(fcml_usize operandSizeAttribute) { + _entryPoint.setOperandSizeAttribute(operandSizeAttribute); + } + +private: + + /** Entry point associated with the context. */ + EntryPoint _entryPoint; + /** Assembler configuration associated with the context. */ + AssemblerConf _config; + +}; + +/** Converts objects to their structures counterparts. + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class AssemblerTypeConverter { +public: + + static void convert(const fcml_st_assembler_context &src, + AssemblerContext &dest) { + // Converts assembler configuration and entry point. + // Both of them have dedicated conversion methods. + convert(src.configuration, dest.getConfig()); + TypeConverter::convert(src.entry_point, dest.getEntryPoint()); + } + + static void convert(const AssemblerContext &src, + fcml_st_assembler_context &dest) { + // Converts assembler configuration and entry point. Both of them + // have dedicated conversion methods. + convert(src.getConfig(), dest.configuration); + TypeConverter::convert(src.getEntryPoint(), dest.entry_point); + } + + static void convert(const fcml_st_assembler_conf &src, + AssemblerConf &dest) { + dest.setChooseAbsEncoding(FCML_TO_CPP_BOOL(src.choose_abs_encoding)); + dest.setChooseSibEncoding(FCML_TO_CPP_BOOL(src.choose_sib_encoding)); + dest.setChooser(src.chooser); + dest.setEnableErrorMessages( + FCML_TO_CPP_BOOL(src.enable_error_messages)); + dest.setForceRexPrefix(FCML_TO_CPP_BOOL(src.force_rex_prefix)); + dest.setForceThreeByteVex(FCML_TO_CPP_BOOL(src.force_three_byte_VEX)); + dest.setIncrementIp(FCML_TO_CPP_BOOL(src.increment_ip)); + dest.setOptimizer(src.optimizer); + dest.setOptimizerFlags(src.optimizer_flags); + } + + static void convert(const AssemblerConf &src, + fcml_st_assembler_conf &dest) { + dest.choose_abs_encoding = src.isChooseAbsEncoding(); + dest.choose_sib_encoding = src.isChooseSibEncoding(); + dest.chooser = src.getChooser(); + dest.enable_error_messages = src.isEnableErrorMessages(); + dest.force_rex_prefix = src.isForceRexPrefix(); + dest.force_three_byte_VEX = src.isForceThreeByteVex(); + dest.increment_ip = src.isIncrementIp(); + dest.optimizer = src.getOptimizer(); + dest.optimizer_flags = src.getOptimizerFlags(); + } + +}; + +/** + * An assembler wrapper. + * As you can see the assembler instance is managed internally + * and is not exposed outside. + * @since 1.1.0 + * @remarks This class is thread-safe. + */ +class Assembler: public NonCopyable, protected DialectAware { +public: + + /** + * Creates an assembler instance for given dialect. + * + * @param dialect The dialect for the assembler instance. + * @throw InitException Cannot initialize the assembler. + * @since 1.1.0 + */ + Assembler(Dialect &dialect) : + _dialect(dialect) { + fcml_ceh_error error = ::fcml_fn_assembler_init(extractDialect(dialect), + &_assembler); + if (error) { + throw InitException(FCML_TEXT("Cannot initialize the assembler."), + error); + } + } + + /** + * @since 1.1.0 + */ + virtual ~Assembler() { + if (_assembler) { + ::fcml_fn_assembler_free(_assembler); + _assembler = NULL; + } + } + +public: + + /** + * Assembles given generic instruction model. + * + * @param ctx The assembler context. + * @param instruction The generic instruction model to be assembled. + * @param[out] result Assembler result. + * @throw AssemblingFailedException Thrown if assembling fails + * and AssemblerConf.isThrowExceptionOnError returns true. + * @return Error code. + * @since 1.1.0 + */ + fcml_ceh_error assemble(AssemblerContext &ctx, + const Instruction &instruction, AssemblerResult &result) { + + // Prepare assembler context. + fcml_st_assembler_context context; + AssemblerTypeConverter::convert(ctx, context); + + context.assembler = _assembler; + + // Prepare instruction. + fcml_st_instruction inst; + TypeConverter::convert(instruction, inst); + + // Prepare assembler result. + fcml_st_assembler_result res; + ::fcml_fn_assembler_result_prepare(&res); + + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR; + + try { + + result.clear(); + + error = ::fcml_fn_assemble(&context, &inst, &res); + + // Free instruction mnemonic. + TypeConverter::free(inst); + + // Failed or not, convert assembler errors. + ErrorContainer errorContainer; + ErrorTypeConverter::convert(res.errors, errorContainer); + + // Prepares assembler result. + result.setErrorContainer(errorContainer); + + if (error && ctx.getConfig().isThrowExceptionOnError()) { + ::fcml_fn_assembler_result_free(&res); + throw AssemblingFailedException(FCML_TEXT("Assembling failed."), + errorContainer, error); + } + + if (!error) { + + std::vector &assembledInstructions = + result.getAssembledInstructions(); + + assembledInstructions.clear(); + + if (res.number_of_instructions > 0) { + ErrorContainer instructionWarnings; + fcml_int i = 0; + fcml_st_assembled_instruction *next_instruction = + res.instructions; + while (next_instruction) { + fcml_st_ceh_error_container &instruction_warnings = + next_instruction->warnings; + ErrorTypeConverter::convert(instruction_warnings, + instructionWarnings); + AssembledInstruction assembledInstruction( + next_instruction->code, + next_instruction->code_length, + instructionWarnings); + assembledInstructions.push_back(assembledInstruction); + if (next_instruction == res.chosen_instruction) { + result.setChoosenInstructionIndex(i); + } + next_instruction = next_instruction->next; + i++; + } + } + + // Convert it back to the context because it might have been + // modified during assembling process (IP incrementing etc). + TypeConverter::convert(context.entry_point, + ctx.getEntryPoint()); + + } + + ::fcml_fn_assembler_result_free(&res); + + } catch (std::exception &exc) { + // If anything failed, free assembler results. + TypeConverter::free(inst); + ::fcml_fn_assembler_result_free(&res); + throw exc; + } + + return error; + } + + /** + * Gets dialect associated with the assembler. + * @return The dialect instance associated with the assembler. + * @since 1.1.0 + */ + Dialect& getDialect() const { + return _dialect; + } + +private: + + // A dialect used by the assembler. + Dialect &_dialect; + + // An initialized assembler instance. + fcml_st_assembler *_assembler; + +}; + +/** Iterates over machine code bytes from assembled instructions. + * @since 1.1.0 + */ +class CodeIterator: public Iterator { +public: + + /** + * Creates a code iterator instance. + * @param assembledInstructions Assembled instructions. + * @since 1.1.0 + */ + CodeIterator(std::vector &assembledInstructions) : + _buffer(NULL), _len(0), _pos(0), _iterator( + assembledInstructions.begin()), _assembledInstructions( + assembledInstructions) { + } + + /** + * @since 1.1.0 + */ + virtual ~CodeIterator() { + } + + /** + * Gets true if there is an another element in the iterator. + * + * @return True if there is another byte in the iterator. + * @since 1.1.0 + */ + bool hasNext() { + if (_buffer && _pos >= _len) { + _buffer = NULL; + } + if (!_buffer) { + if (_iterator == _assembledInstructions.end()) { + return false; + } + AssembledInstruction ¤t = *_iterator++; + _buffer = current.getCode(); + _len = current.getCodeLength(); + _pos = 0; + } + return true; + } + + /** + * Gets the next element from the iterator. + * + * @return Next machine code byte. + * @throw IllegalStateException If iterator is empty. + * @since 1.1.0 + */ + fcml_uint8_t next() { + if ((!_buffer || _pos >= _len) && !hasNext()) { + throw IllegalStateException( + FCML_TEXT("No more elements in the iterator.")); + } + return _buffer[_pos++]; + } + +private: + + /** Code of the current instruction iterator points to. */ + const fcml_uint8_t *_buffer; + /** Code length in bytes. */ + fcml_usize _len; + /** Position in the code buffer */ + fcml_usize _pos; + /** Assembled instructions iterator. */ + std::vector::iterator _iterator; + /** Vector with assembled instructions. */ + std::vector &_assembledInstructions; + +}; + +} + +#endif //FCML_ASSEMBLER_HPP_ diff --git a/dependencies/fcml/include/fcml_choosers.h b/dependencies/fcml/include/fcml_choosers.h new file mode 100644 index 0000000..24469b0 --- /dev/null +++ b/dependencies/fcml/include/fcml_choosers.h @@ -0,0 +1,87 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_choosers.h + * + * API for instruction choosers. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_CHOOSER_H_ +#define FCML_CHOOSER_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Returns next instructions from the iterator. + * Instruction chooser uses this function to get next instruction from the chain. + * @param instruction Current instruction. + */ +typedef fcml_ptr (*fcml_fnp_chooser_next)(fcml_ptr instruction); + +/** Gets instruction code from current abstract instruction pointer. + * Gets instruction pointer and fills given instruction code + * holder with the binary code of the instruction. + * @param instruction Instruction pointer. + * @param instruction_code Holder for the instruction code. + */ +typedef void (*fcml_fnp_chooser_extract)(fcml_ptr instruction, + fcml_st_instruction_code *instruction_code); + +/** Instruction chooser context used to communicate with environment. */ +typedef struct fcml_st_chooser_context { + /** First instruction in the chain. */ + fcml_ptr instruction; + /** Gets next instruction code from iterator. */ + fcml_fnp_chooser_next next; + /** Extracts instruction code from abstract instruction pointer.*/ + fcml_fnp_chooser_extract extract; +} fcml_st_chooser_context; + +/** Instruction chooser function pointer declaration. + * @param chooser_context Instruction chooser context. + */ +typedef fcml_ptr (LIB_CALL *fcml_fnp_asm_instruction_chooser)( + fcml_st_chooser_context *chooser_context); + +/** Default instruction chooser which chooses the shortest instruction available. + * @param chooser_context Instruction chooser context. + */ +fcml_ptr LIB_EXPORT LIB_CALL fcml_fn_asm_default_instruction_chooser( + fcml_st_chooser_context *chooser_context); + +/** NULL chooser which do not chose anything. + * @param chooser_context Instruction chooser context. + */ +fcml_ptr LIB_EXPORT LIB_CALL fcml_fn_asm_no_instruction_chooser( + fcml_st_chooser_context *chooser_context); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_CHOOSER_H_ */ diff --git a/dependencies/fcml/include/fcml_common.h b/dependencies/fcml/include/fcml_common.h new file mode 100644 index 0000000..bd3d6a0 --- /dev/null +++ b/dependencies/fcml/include/fcml_common.h @@ -0,0 +1,832 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_common.h + * Definitions of common structures used by FCML components. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_INT_COMMON_H_ +#define FCML_INT_COMMON_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_instructions.h" + +/** Maximal number of the instruction operands. */ +#define FCML_OPERANDS_COUNT 5 +/** Maximal number of bytes instruction can use. */ +#define FCML_INSTRUCTION_SIZE 15 +/** Number of opcode bytes. */ +#define FCML_OPCODES_NUM 3 + +/** + * @defgroup PREFIX_GROUP Explicit prefixes + * List of prefixes that can be explicitly defined for instruction. + * @{ + */ + +/** LOCK prefix (0xF0)*/ +#define FCML_PREFIX_LOCK 0x0001 +/** REPNE prefix (0xF2) */ +#define FCML_PREFIX_REPNE 0x0002 +/** REPNZ prefix (0xF2) */ +#define FCML_PREFIX_REPNZ FCML_PREFIX_REPNE +/** REP prefix (0xF3) */ +#define FCML_PREFIX_REP 0x0004 +/** REPE prefix (0xF3) */ +#define FCML_PREFIX_REPE FCML_PREFIX_REP +/** REPZ prefix (0xF3) */ +#define FCML_PREFIX_REPZ FCML_PREFIX_REP +/** XACQUIRE prefix (0xF2) */ +#define FCML_PREFIX_XACQUIRE 0x0008 +/** XRELEASE prefix (0xF3) */ +#define FCML_PREFIX_XRELEASE 0x0010 +/** branch hint (0x2E) (SSE2 extension)*/ +#define FCML_PREFIX_BRANCH_HINT 0x0020 +/** nobranch hint (0x3E) (SSE2 extension)*/ +#define FCML_PREFIX_NOBRANCH_HINT 0x0040 + +/** @} */ + +/** + * Supported processor operating modes. + */ +typedef enum fcml_en_operating_mode { + /** Real-addressing mode, virtual 8086 mode. */ + FCML_OM_16_BIT = 1, + /** Protected/Compatibility mode when 'D' segment descriptor + * flag is set to 1. */ + FCML_OM_32_BIT, + /** 64-bit mode. ('L' flag of segment descriptor set to 1.) */ + FCML_OM_64_BIT, +} fcml_en_operating_mode; + +/* Simple types. */ + +/** Type used for storing instruction and operand hint masks. */ +typedef fcml_uint16_t fcml_hints; + +/** + * Type for explicit instruction prefixes bit mask. + */ +typedef fcml_uint16_t fcml_prefixes; + +/** + * General instruction pointer holder. + */ +typedef fcml_int64_t fcml_ip; + +/* Register numbers.*/ + +/** + * @defgroup REGISTERS_GROUP Registers. + * All supported x64_64 registers are defined here. + * @{ + */ + +#define FCML_REG_AL 0 +#define FCML_REG_AX 0 +#define FCML_REG_EAX 0 +#define FCML_REG_RAX 0 +#define FCML_REG_MM0 0 +#define FCML_REG_XMM0 0 +#define FCML_REG_YMM0 0 +#define FCML_REG_ZMM0 0 + +#define FCML_REG_CL 1 +#define FCML_REG_CX 1 +#define FCML_REG_ECX 1 +#define FCML_REG_RCX 1 +#define FCML_REG_MM1 1 +#define FCML_REG_XMM1 1 +#define FCML_REG_YMM1 1 +#define FCML_REG_ZMM1 1 + +#define FCML_REG_DL 2 +#define FCML_REG_DX 2 +#define FCML_REG_EDX 2 +#define FCML_REG_RDX 2 +#define FCML_REG_MM2 2 +#define FCML_REG_XMM2 2 +#define FCML_REG_YMM2 2 +#define FCML_REG_ZMM2 2 + +#define FCML_REG_BL 3 +#define FCML_REG_BX 3 +#define FCML_REG_EBX 3 +#define FCML_REG_RBX 3 +#define FCML_REG_MM3 3 +#define FCML_REG_XMM3 3 +#define FCML_REG_YMM3 3 +#define FCML_REG_ZMM3 3 + +#define FCML_REG_AH 4 +#define FCML_REG_SP 4 +#define FCML_REG_SPL 4 +#define FCML_REG_ESP 4 +#define FCML_REG_RSP 4 +#define FCML_REG_MM4 4 +#define FCML_REG_XMM4 4 +#define FCML_REG_YMM4 4 +#define FCML_REG_ZMM4 4 + +#define FCML_REG_CH 5 +#define FCML_REG_BP 5 +#define FCML_REG_BPL 5 +#define FCML_REG_EBP 5 +#define FCML_REG_RBP 5 +#define FCML_REG_MM5 5 +#define FCML_REG_XMM5 5 +#define FCML_REG_YMM5 5 +#define FCML_REG_ZMM5 5 + +#define FCML_REG_DH 6 +#define FCML_REG_SI 6 +#define FCML_REG_SIL 6 +#define FCML_REG_ESI 6 +#define FCML_REG_RSI 6 +#define FCML_REG_MM6 6 +#define FCML_REG_XMM6 6 +#define FCML_REG_YMM6 6 +#define FCML_REG_ZMM6 6 + +#define FCML_REG_BH 7 +#define FCML_REG_DI 7 +#define FCML_REG_DIL 7 +#define FCML_REG_EDI 7 +#define FCML_REG_RDI 7 +#define FCML_REG_MM7 7 +#define FCML_REG_XMM7 7 +#define FCML_REG_YMM7 7 +#define FCML_REG_ZMM7 7 + +#define FCML_REG_R8L 8 +#define FCML_REG_R8W 8 +#define FCML_REG_R8D 8 +#define FCML_REG_R8 8 +#define FCML_REG_XMM8 8 +#define FCML_REG_YMM8 8 +#define FCML_REG_ZMM8 8 + +#define FCML_REG_R9L 9 +#define FCML_REG_R9W 9 +#define FCML_REG_R9D 9 +#define FCML_REG_R9 9 +#define FCML_REG_XMM9 9 +#define FCML_REG_YMM9 9 +#define FCML_REG_ZMM9 9 + +#define FCML_REG_R10L 10 +#define FCML_REG_R10W 10 +#define FCML_REG_R10D 10 +#define FCML_REG_R10 10 +#define FCML_REG_XMM10 10 +#define FCML_REG_YMM10 10 +#define FCML_REG_ZMM10 10 + +#define FCML_REG_R11L 11 +#define FCML_REG_R11W 11 +#define FCML_REG_R11D 11 +#define FCML_REG_R11 11 +#define FCML_REG_XMM11 11 +#define FCML_REG_YMM11 11 +#define FCML_REG_ZMM11 11 + +#define FCML_REG_R12L 12 +#define FCML_REG_R12W 12 +#define FCML_REG_R12D 12 +#define FCML_REG_R12 12 +#define FCML_REG_XMM12 12 +#define FCML_REG_YMM12 12 +#define FCML_REG_ZMM12 12 + +#define FCML_REG_R13L 13 +#define FCML_REG_R13W 13 +#define FCML_REG_R13D 13 +#define FCML_REG_R13 13 +#define FCML_REG_XMM13 13 +#define FCML_REG_YMM13 13 +#define FCML_REG_ZMM13 13 + +#define FCML_REG_R14L 14 +#define FCML_REG_R14W 14 +#define FCML_REG_R14D 14 +#define FCML_REG_R14 14 +#define FCML_REG_XMM14 14 +#define FCML_REG_YMM14 14 +#define FCML_REG_ZMM14 14 + +#define FCML_REG_R15L 15 +#define FCML_REG_R15W 15 +#define FCML_REG_R15D 15 +#define FCML_REG_R15 15 +#define FCML_REG_XMM15 15 +#define FCML_REG_YMM15 15 +#define FCML_REG_ZMM15 15 + +#define FCML_REG_XMM16 16 +#define FCML_REG_YMM16 16 +#define FCML_REG_ZMM16 16 + +#define FCML_REG_XMM17 17 +#define FCML_REG_YMM17 17 +#define FCML_REG_ZMM17 17 + +#define FCML_REG_XMM18 18 +#define FCML_REG_YMM18 18 +#define FCML_REG_ZMM18 18 + +#define FCML_REG_XMM19 19 +#define FCML_REG_YMM19 19 +#define FCML_REG_ZMM19 19 + +#define FCML_REG_XMM20 20 +#define FCML_REG_YMM20 20 +#define FCML_REG_ZMM20 20 + +#define FCML_REG_XMM21 21 +#define FCML_REG_YMM21 21 +#define FCML_REG_ZMM21 21 + +#define FCML_REG_XMM22 22 +#define FCML_REG_YMM22 22 +#define FCML_REG_ZMM22 22 + +#define FCML_REG_XMM23 23 +#define FCML_REG_YMM23 23 +#define FCML_REG_ZMM23 23 + +#define FCML_REG_XMM24 24 +#define FCML_REG_YMM24 24 +#define FCML_REG_ZMM24 24 + +#define FCML_REG_XMM25 25 +#define FCML_REG_YMM25 25 +#define FCML_REG_ZMM25 25 + +#define FCML_REG_XMM26 26 +#define FCML_REG_YMM26 26 +#define FCML_REG_ZMM26 26 + +#define FCML_REG_XMM27 27 +#define FCML_REG_YMM27 27 +#define FCML_REG_ZMM27 27 + +#define FCML_REG_XMM28 28 +#define FCML_REG_YMM28 28 +#define FCML_REG_ZMM28 28 + +#define FCML_REG_XMM29 29 +#define FCML_REG_YMM29 29 +#define FCML_REG_ZMM29 29 + +#define FCML_REG_XMM30 30 +#define FCML_REG_YMM30 30 +#define FCML_REG_ZMM30 30 + +#define FCML_REG_XMM31 31 +#define FCML_REG_YMM31 31 +#define FCML_REG_ZMM31 31 + +/* Segment registers. */ + +#define FCML_REG_ES 0 +#define FCML_REG_CS 1 +#define FCML_REG_SS 2 +#define FCML_REG_DS 3 +#define FCML_REG_FS 4 +#define FCML_REG_GS 5 + +/* FPU registers */ + +#define FCML_REG_ST0 0 +#define FCML_REG_ST1 1 +#define FCML_REG_ST2 2 +#define FCML_REG_ST3 3 +#define FCML_REG_ST4 4 +#define FCML_REG_ST5 5 +#define FCML_REG_ST6 6 +#define FCML_REG_ST7 7 + +/* Control registers. */ + +#define FCML_REG_CR0 0 +#define FCML_REG_CR2 2 +#define FCML_REG_CR3 3 +#define FCML_REG_CR4 4 +#define FCML_REG_CR8 8 + +/* Debug register. */ + +#define FCML_REG_DR0 0 +#define FCML_REG_DR1 1 +#define FCML_REG_DR2 2 +#define FCML_REG_DR3 3 +#define FCML_REG_DR4 4 +#define FCML_REG_DR5 5 +#define FCML_REG_DR6 6 +#define FCML_REG_DR7 7 + +/* Opmask registers. */ + +#define FCML_REG_K0 0 +#define FCML_REG_K1 1 +#define FCML_REG_K2 2 +#define FCML_REG_K3 3 +#define FCML_REG_K4 4 +#define FCML_REG_K5 5 +#define FCML_REG_K6 6 +#define FCML_REG_K7 7 + +/** @} */ + +/** + * @defgroup DATA_SIZE_GROUP Constants used to describe data size. + * @{instrunction->hints + */ + +#define FCML_DS_UNDEF 0 +#define FCML_DS_8 8 +#define FCML_DS_16 16 +#define FCML_DS_32 32 +#define FCML_DS_64 64 +#define FCML_DS_128 128 +#define FCML_DS_256 256 +#define FCML_DS_512 512 + +/** @} */ + +/* Size operators. */ + +#define FCML_OS_UNDEFINED 0 +#define FCML_OS_BYTE 8 +#define FCML_OS_WORD 16 +#define FCML_OS_DWORD 32 +#define FCML_OS_FWORD 48 +#define FCML_OS_QWORD 64 +#define FCML_OS_MWORD 64 +#define FCML_OS_TBYTE 80 +#define FCML_OS_OWORD 128 +#define FCML_OS_XWORD 128 +#define FCML_OS_YWORD 256 +#define FCML_OS_ZWORD 512 + +/* SIMD tuple types. */ + +/* Instructions affected by embedded broadcast */ +#define FCML_TT_NONE 0 +#define FCML_TT_FV 1 +#define FCML_TT_HV 2 + +/* Instructions not affected by embedded broadcast */ +#define FCML_TT_FVM 3 /* Full Mem */ +#define FCML_TT_T1S 4 +#define FCML_TT_T1F 5 +#define FCML_TT_T2 6 +#define FCML_TT_T4 7 +#define FCML_TT_T8 8 +#define FCML_TT_HVM 9 +#define FCML_TT_QVM 10 +#define FCML_TT_OVM 11 +#define FCML_TT_M128 12 +#define FCML_TT_DUP 13 +#define FCML_TT_T1x4 14 /* Tuple1_4X */ + +/* Embedded rounding mode. */ + +#define FCML_ER_RN_SAE 0 +#define FCML_ER_RD_SAE 1 +#define FCML_ER_RU_SAE 2 +#define FCML_ER_RZ_SAE 3 + +/** + * Register type. + * Every register is represented as an integer value and it's + * register type. This enumeration provides all supported register types. + */ +typedef enum fcml_en_register { + /** Undefined register type. */ + FCML_REG_UNDEFINED = 0, + /** General purpose register. */ + FCML_REG_GPR, + /** SIMD (SSE, MMX) register. */ + FCML_REG_SIMD, + /** FPU register. */ + FCML_REG_FPU, + /** Segment register */ + FCML_REG_SEG, + /** Control register. */ + FCML_REG_CR, + /** Debug register */ + FCML_REG_DR, + /** Instruction pointer register. Used for relative RIP addressing. */ + FCML_REG_IP, + /** Operand mask register. */ + FCML_REG_OPMASK +} fcml_en_register; + +/** + * Structure describes x86_64 register. + */ +typedef struct fcml_st_register { + /** Register type. */ + fcml_en_register type; + /** Register size in bits. */ + fcml_usize size; + /** Register itself as a positive integer. @see REGISTERS_GROUP */ + fcml_uint8_t reg; + /** In case of SPL,BPL,SIL,DIL GPR registers has to be set to true. */ + fcml_bool x64_exp; +} fcml_st_register; + +/********************************* + * Conditions. + *********************************/ + +/** Number of supported condition types. */ +#define FCML_NUMBER_OF_CONDITIONS 8 + +/** + * Condition type. + * Every conditional instruction has an appropriate condition type set. + * Following enumeration defines all supported types. + */ +typedef enum fcml_en_condition_type { + /** 0 Overflow*/ + FCML_CONDITION_O = 0, + /** 1 Below*/ + FCML_CONDITION_B, + /** 2 Equal*/ + FCML_CONDITION_E, + /** 3 Below or equal*/ + FCML_CONDITION_BE, + /** 4 Sign*/ + FCML_CONDITION_S, + /** 5 Parity*/ + FCML_CONDITION_P, + /** 6 Less than*/ + FCML_CONDITION_L, + /** 7 Less than or equal to*/ + FCML_CONDITION_LE +} fcml_en_condition_type; + +/** + * Defines instruction's condition. + */ +typedef struct fcml_st_condition { + /* Condition type.*/ + fcml_en_condition_type condition_type; + /* True if condition should be negated.*/ + fcml_bool is_negation; +} fcml_st_condition; + +/********************************* + * Size attributes flags. + *********************************/ + +/** + * @defgroup SUPPORTED_SIZE_GROUP These values can be used in order to + * prepare a mask of supported sizes. Used mainly by optimizers where + * instructions can be assembled using different attribute sizes. + * @{ + */ + +#define FCML_EN_ASF_ANY 0x00 +#define FCML_EN_ASF_16 0x01 +#define FCML_EN_ASF_32 0x02 +#define FCML_EN_ASF_64 0x04 +#define FCML_EN_ASF_ALL FCML_EN_ASF_16 | FCML_EN_ASF_32 | FCML_EN_ASF_64 + +/** @} */ + +/** + * Nullable wrapper for mask of size flags. + */ +typedef struct fcml_st_nullable_size_flags { + /** True if mask is set. */ + fcml_bool is_set; + /** Mask of supported size values. */ + fcml_flags flags; +} fcml_st_nullable_size_flags; + +/********************************* + * Operands. + *********************************/ + +/** + * Operand access mode. + */ +typedef enum fcml_en_access_mode { + /** Undefined mode. */ + FCML_AM_ACCESS_MODE_UNDEFINED = 0, + /** Operand is read by instruction. */ + FCML_AM_READ = 0x01, + /** Operand is set by instruction */ + FCML_AM_WRITE = 0x02, + /** Operand is read but can be also set. */ + FCML_AM_READ_WRITE = FCML_AM_READ | FCML_AM_WRITE +} fcml_en_access_mode; + +/** + * Representation of far pointer operand. + */ +typedef struct fcml_st_far_pointer { + /** 16-bit Code segment. */ + fcml_uint16_t segment; + /** Size of the offset. */ + fcml_usize offset_size; + /** 16-bit offset. */ + fcml_int16_t offset16; + /** 32-bit offset. */ + fcml_int32_t offset32; +} fcml_st_far_pointer; + +/********************************************/ +/** Memory addressing using ModR/M field **/ +/********************************************/ + +/** + * Addressing form. + * Distinguish between two types of addressing forms: effective addressing + * and explicit absolute offset. + */ +typedef enum fcml_en_address_form { + /** Default value set if memory addressing hasn't been configured. */ + FCML_AF_UNDEFINED, + /** Absolute offset (address). */ + FCML_AF_OFFSET, + /** Effective address combined from address components like base register, + * index registers, factor, displacement etc... */ + FCML_AF_COMBINED +} fcml_en_effective_address_form; + +/** + * Absolute offset. + */ +typedef struct fcml_st_offset { + /** Offset size 16,32 or 64 bits. */ + fcml_usize size; + /** True if offset should be treated as signed value. */ + fcml_bool is_signed; + /** Place for 16-bit absolute offset. */ + fcml_int16_t off16; + /** Place for 32-bit absolute offset. */ + fcml_int32_t off32; + /** Place for 64-bit absolute offset. */ + fcml_int64_t off64; +} fcml_st_offset; + +/** + * Effective address. + */ +typedef struct fcml_st_effective_address { + /** GPR base register. @see fcml_st_register. */ + fcml_st_register base; + /** GPR index register. @see fcml_st_register. */ + fcml_st_register index; + /** Scale factor 1,2,4 or 8. */ + fcml_uint8_t scale_factor; + /** Displacement value. @see fcml_st_integer. */ + fcml_st_integer displacement; +} fcml_st_effective_address; + +/** + * Describes segment register. + */ +typedef struct fcml_st_segment_selector { + /** Used segment register. @see fcml_st_register*/ + fcml_st_register segment_selector; + /** Set to true if given segment register is a default one in given + * context. This value is set by disassembler. + */ + fcml_bool is_default_reg; +} fcml_st_segment_selector; + +/** + * Generic memory addressing operator. + */ +typedef struct fcml_st_address { + /** Size of data accessed in memory.*/ + fcml_usize size_operator; + /** Memory addressing format: absolute offset/effective address. + * @see fcml_en_effective_address_form + */ + fcml_en_effective_address_form address_form; + /** Segment register.*/ + fcml_st_segment_selector segment_selector; + /** Memory address for FCML_AF_COMBINED form.*/ + fcml_st_effective_address effective_address; + /** Memory address for FCML_AF_OFFSET form.*/ + fcml_st_offset offset; +} fcml_st_address; + +/** + * Rounding mode. + */ +typedef enum fcml_en_embeeded_rounding_control { + FCML_ERC_RNE, FCML_ERC_RD, FCML_ERC_RU, FCML_ERC_RZ +} fcml_en_embeeded_rounding_control; + +/** + * Container for operand decorators. + * @since 1.2.0 + */ +typedef struct fcml_st_operand_decorators { + /** Broadcasting: 2, 4, 8, 16, 32, 64. */ + fcml_nuint8_t bcast; + /** Zeroing masking. */ + fcml_bool z; + /** The 64-bit k registers are: k0 through k7. */ + fcml_st_register operand_mask_reg; + /** Embedded rounding control. */ + fcml_nuint8_t er; + /** Indicates support for SAE (Suppress All Exceptions). */ + fcml_bool sae; +} fcml_st_operand_decorators; + +/** + * Supported operand types. + */ +typedef enum fcml_en_operand_type { + /** Operand not used. */ + FCML_OT_NONE, + /** Immediate integer value. */ + FCML_OT_IMMEDIATE, + /** Direct far pointer. */ + FCML_OT_FAR_POINTER, + /** Memory address. */ + FCML_OT_ADDRESS, + /** Processor register. */ + FCML_OT_REGISTER, + /** + * Not an operand in a strict sense, + * only a container for attributes. + */ + FCML_OT_VIRTUAL +} fcml_en_operand_type; + +/** + * Operand hints. + * Hints dedicated for instruction operands. + */ +typedef enum fcml_en_operand_hints { + /** + * Undefined. + */ + FCML_OP_HINT_UNDEFIEND = 0x0000, + /** + * SIMD operand. All operands which uses SIMD registers (mmx, xmm, ymm) + * have this flag set. It is for instance used by Intel syntax renderer + * for data size operators (mmword ptr, xmmword ptr, ymmword ptr). + */ + FCML_OP_HINT_MULTIMEDIA_INSTRUCTION = 0x0001, + /** + * Relative address. Flags set for all branches which use jumps + * calculated by displacement relative to the IP of the next instructions. + */ + FCML_OP_HINT_DISPLACEMENT_RELATIVE_ADDRESS = 0x0002, + /** + * Pseudo opcode. Hint set for last operand (Intel syntax) which contains + * comparison predicate of the following instructions: CMPSD, VCMPSD, CMPSS, + * VCMPSS, VPCOMB, VPCOMW, VPCOMD, VPCOMQ, VPCOMUB, VPCOMUW, + * VPCOMUD, VPCOMUQ. + */ + FCML_OP_HINT_PSEUDO_OPCODE = 0x0004, + /** + * Offset should be encoded as absolute address. + */ + FCML_OP_HINT_ABSOLUTE_ADDRESSING = 0x0008, + /** + * Offset should be encoded as relative address. + */ + FCML_OP_HINT_RELATIVE_ADDRESSING = 0x0010, + /** + * Encode ModR/M with optional SIB byte if possible. + **/ + FCML_OP_HINT_SIB_ENCODING = 0x0020 +} fcml_en_operand_hints; + +/** Instruction operand. + * Structure represents one instruction operand. + */ +typedef struct fcml_st_operand { + /** Operand type */ + fcml_en_operand_type type; + /** Optional operand level hints. */ + fcml_hints hints; + /** Immediate value operand. */ + fcml_st_integer immediate; + /** Far pointer operand. */ + fcml_st_far_pointer far_pointer; + /** Effective address or absolute offset. */ + fcml_st_address address; + /** Register operand. */ + fcml_st_register reg; + /** Operand decorators. */ + fcml_st_operand_decorators decorators; +} fcml_st_operand; + +/********************************* + * Instruction definition. + *********************************/ + +/** + * Instruction level hints. + * Set of the hints that can be only defined on the + * level of the whole instruction. They can not be used + * with operands. + */ +typedef enum fcml_en_instruction_hints { + /** No hints defined. */ + FCML_HINT_NO_HINTS, + /** Hints instruction to use FAR pointer to address the memory. */ + FCML_HINT_FAR_POINTER = 0x0001, + /** Hints instruction to use NEAR pointer to address the memory. */ + FCML_HINT_NEAR_POINTER = 0x0002, + /** This hint is used only by assembler in order to force it to generate + * three byte VEX/XOP prefix even if prefix fields fits into two bytes. */ + FCML_HINT_LONG_FORM_POINTER = 0x0004, + /** Hints instruction to use INDIRECT pointer to address the memory. */ + FCML_HINT_INDIRECT_POINTER = 0x0008, + /** Hints instruction to use DIRECT memory addressing. */ + FCML_HINT_DIRECT_POINTER = 0x0010 +} fcml_en_instruction_hints; + +/** + * Generic instruction model. + * Generic instruction model (GIM) is a common structure used to describe + * instruction in a common way used by FCML assembler and disassembler. + */ +typedef struct fcml_st_instruction { + /** Describes explicit instruction prefixes. @ref PREFIX_GROUP "List + * of explicit prefixes." */ + fcml_prefixes prefixes; + /** Holds instruction level hints. */ + fcml_hints hints; + /** Dialect-dependent instruction mnemonic. + * @see fcml_en_instruction_hints */ + fcml_char *mnemonic; + /** True for conditional instructions. */ + fcml_bool is_conditional; + /** Describes condition used by assembled/disassembled + * conditional instruction. */ + fcml_st_condition condition; + /** Fixed size array of instruction operands. */ + fcml_st_operand operands[FCML_OPERANDS_COUNT]; + /** Number of operands defined for instruction. */ + fcml_int operands_count; +} fcml_st_instruction; + +/********************************* + * Instruction definition. + *********************************/ + +/** + * An encoded instruction. + */ +typedef struct fcml_st_instruction_code { + /** Pointer to the instruction code. */ + fcml_uint8_t *code; + /** Instruction code length. */ + fcml_usize code_length; +} fcml_st_instruction_code; + +/**************************** + * Instruction entry point. + ****************************/ + +/** + * Describes address of an instruction code. + */ +typedef struct fcml_st_entry_point { + /** Processor operating mode 16/32/64-bit.*/ + fcml_en_operating_mode op_mode; + /** Default address size attribute (See 'D' flag of segment descriptor.)*/ + fcml_usize address_size_attribute; + /** Default operand size attribute (See 'D' flag of segment descriptor.)*/ + fcml_usize operand_size_attribute; + /** Instruction pointer EIP/RIP. Take into account that even in 16 bit + * mode EIP register is used.*/ + fcml_ip ip; +} fcml_st_entry_point; + +#endif /* FCML_INT_COMMON_H_ */ diff --git a/dependencies/fcml/include/fcml_common.hpp b/dependencies/fcml/include/fcml_common.hpp new file mode 100644 index 0000000..ba801a6 --- /dev/null +++ b/dependencies/fcml/include/fcml_common.hpp @@ -0,0 +1,9142 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_common.hpp + * C++ wrappers common classes. + * + * @copyright Copyright (C) 2010-2017 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_COMMON_HPP_ +#define FCML_COMMON_HPP_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "fcml_types.h" +#include "fcml_common.h" +#include "fcml_common_utils.h" +#include "fcml_errors.h" + +namespace fcml { + +#define FCML_TO_CPP_BOOL( x ) ( (x) ? true : false ) + +/** + * By using this type definition here, it will be definitely much + * easier to support UNICODE in future releases. + * @since 1.1.0 + */ +typedef std::basic_string fcml_cstring; + +/** + * String output stream. + * @since 1.1.0 + */ +typedef std::basic_ostringstream fcml_costream; + +/** + * Exposes API responsible for environment specific operations, even if standard CPP library is used + * to implement them. + * + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class Env { +public: + /** + * @throw std::bad_alloc + * @since 1.1.0 + */ + static fcml_string strDup( const fcml_string str ) { + if ( !str ) { + return NULL; + } +#if defined(FCML_MSCC) + fcml_string newStr = _strdup( str ); +#else + fcml_string newStr = strdup( str ); +#endif + if ( !newStr ) { + throw std::bad_alloc(); + } + return newStr; + } + static void strFree( fcml_string str ) { + free( str ); + } +}; + +/** + * A base iterator interface. + * @since 1.1.0 + */ +template +class Iterator { +public: + + Iterator() {} + + virtual ~Iterator() {} + + /** + * Gets true if there is an another element in the iterator. + */ + virtual bool hasNext() = 0; + + /** + * Gets a next element from the iterator. + */ + virtual T next() = 0; +}; + +/** Wrapper for nullable value types. + * @since 1.1.0 + */ +template +class Nullable { +public: + + Nullable( const T& value, bool is_not_null = true ) : + _value( value ), _is_not_null( is_not_null ) { + } + + Nullable() : + _is_not_null( false ) { + } + + bool isNotNull() const { + return _is_not_null; + } + + void setNotNull(bool isNull) { + _is_not_null = isNull; + } + + T getValue() const { + return _value; + } + + T& getValue() { + return _value; + } + + void setValue(const T& value) { + this->_value = value; + } + +public: + + /** + * Checks if two nullable values are equal. + * + * @param nullable The source nullable value. + * @return True if they are equal; otherwise false. + * @since 1.2.0 + */ + bool operator==(const Nullable &nullable) const { + return _value == nullable._value && + _is_not_null == nullable._is_not_null; + } + + /** + * Checks if two nullable values are not equal. + * + * @param nullable The source nullable value. + * @return True if they are not equal; otherwise false. + * @since 1.2.0 + */ + bool operator!=(const Nullable &nullable) const { + return !(nullable == *this); + } + +private: + /** Value. */ + T _value; + /** Information if value is set or not. */ + bool _is_not_null; +}; + +/** + * Base exception for all exceptions exposed by FCML library. + * @since 1.1.0 + */ +class BaseException { +public: + BaseException( fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) { + this->_error = error; + } + BaseException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) { + this->_msg = msg; + this->_error = error; + } + BaseException( const BaseException &cpy ) { + this->_msg = cpy._msg; + this->_error = cpy._error; + } + virtual ~BaseException() { + } + BaseException& operator=( const BaseException &exc ) { + if ( &exc != this ) { + this->_msg = exc._msg; + this->_error = exc._error; + } + return *this; + } +public: + const fcml_cstring getMsg() const { + return _msg; + } + const fcml_ceh_error& getError() const { + return _error; + } +private: + void* operator new( size_t size ) { + return ::operator new( size ); + } +private: + /** Error message. */ + fcml_cstring _msg; + /** Error code */ + fcml_ceh_error _error; +}; + +/** + * Component can not be initialized correctly. + * @since 1.1.0 + */ +class InitException: public BaseException { +public: + InitException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) : + BaseException( msg, error ) { + } +}; + +/** + * Bad arguments. + * @since 1.1.0 + */ +class BadArgumentException: public BaseException { +public: + BadArgumentException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) : + BaseException( msg, error ) { + } +}; + +/** + * Illegal state exception. + * @since 1.1.0 + */ +class IllegalStateException: public BaseException { +public: + IllegalStateException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) : + BaseException( msg, error ) { + } +}; + +/** + * Illegal argument exception. + * @since 1.1.0 + */ +class IllegalArgumentException: public BaseException { +public: + IllegalArgumentException( const fcml_cstring &msg, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) : + BaseException( msg, error ) { + } +}; + +/** + * Operation is not supported. + * @since 1.1.0 + */ +class OperationNotSupportedException: public BaseException { +public: + OperationNotSupportedException( const fcml_cstring &msg ) : + BaseException( msg ) { + } + OperationNotSupportedException() { + } +}; + +/** + * Object which shouldn't be copied can inherit from this class. + * @since 1.1.0 + */ +class NonCopyable { +protected: + NonCopyable() { + } +private: + /** + * @throw OperationNotSupportedException + */ + NonCopyable( const NonCopyable &cpy ) { + throw OperationNotSupportedException(); + } + /** + * @throw OperationNotSupportedException + */ + NonCopyable& operator=( const NonCopyable &exc ) { + throw OperationNotSupportedException(); + } +}; + +/** Wraps instruction prefix and prepares factory methods for the hints. + * The static method "create" is used here just to avoid the constructor overloading + * what can be a bit problematic because fcml_prefix is an ordinal integer type. + * @since 1.1.0 + */ +class InstructionPrefix { +private: + /** + * Creates an instance of the instruction prefix for the given FCML prefix. + * @param prefix The native FCML prefix. + * @return Instruction prefix instance. + */ + static InstructionPrefix create( fcml_prefixes prefix ) { + InstructionPrefix instructionPrefix; + instructionPrefix._prefix = prefix; + return instructionPrefix; + } +public: + /** + * Creates instruction prefix: LOCK. + * @return Created instruction prefix. + */ + static const InstructionPrefix LOCK() { + return create(FCML_PREFIX_LOCK); + } + /** + * Creates instruction prefix: REPNE. + * @return Created instruction prefix. + */ + static const InstructionPrefix REPNE() { + return create(FCML_PREFIX_REPNE); + } + /** + * Creates instruction prefix: REPNZ. + * @return Created instruction prefix. + */ + static const InstructionPrefix REPNZ() { + return create(FCML_PREFIX_REPNZ); + } + /** + * Creates instruction prefix: REP. + * @return Created instruction prefix. + */ + static const InstructionPrefix REP() { + return create(FCML_PREFIX_REP); + } + /** + * Creates instruction prefix: REPE. + * @return Created instruction prefix. + */ + static const InstructionPrefix REPE() { + return create(FCML_PREFIX_REPE); + } + /** + * Creates instruction prefix: REPZ. + * @return Created instruction prefix. + */ + static const InstructionPrefix REPZ() { + return create(FCML_PREFIX_REPZ); + } + /** + * Creates instruction prefix: XACQUIRE. + * @return Created instruction prefix. + */ + static const InstructionPrefix XACQUIRE() { + return create(FCML_PREFIX_XACQUIRE); + } + /** + * Creates instruction prefix: XRELEASE. + * @return Created instruction prefix. + */ + static const InstructionPrefix XRELEASE() { + return create(FCML_PREFIX_XRELEASE); + } + /** + * Creates instruction prefix: BRANCH_HINT. + * @return Created instruction prefix. + */ + static const InstructionPrefix BRANCH_HINT() { + return create(FCML_PREFIX_BRANCH_HINT); + } + /** + * Creates instruction prefix: NOBRANCH_HINT. + * @return Created instruction prefix. + */ + static const InstructionPrefix NOBRANCH_HINT() { + return create(FCML_PREFIX_NOBRANCH_HINT); + } +public: + fcml_prefixes _prefix; +}; + +/** Wraps instruction hint and exposes factory methods for instruction hints. + * @since 1.1.0 + */ +struct InstructionHint { +private: + /** + * Creates an instruction level hints for given native FCML hints. + * @param hints The hints set. + */ + InstructionHint(fcml_en_instruction_hints hints) : + _hint(hints) { + } +public: + /** + * Creates instruction hint: NO_HINTS. + * @return Instruction hint. + */ + static const InstructionHint NO_HINTS() { + return InstructionHint(FCML_HINT_NO_HINTS); + } + /** + * Creates instruction hint: NEAR_POINTER. + * @return Instruction hint. + */ + static const InstructionHint NEAR_POINTER() { + return InstructionHint(FCML_HINT_NEAR_POINTER); + } + /** + * Creates instruction hint: FAR_POINTER. + * @return Instruction hint. + */ + static const InstructionHint FAR_POINTER() { + return InstructionHint(FCML_HINT_FAR_POINTER); + } + /** + * Creates instruction hint: LONG_FORM_POINTER. + * @return Instruction hint. + */ + static const InstructionHint LONG_FORM_POINTER() { + return InstructionHint(FCML_HINT_LONG_FORM_POINTER); + } + /** + * Creates instruction hint: INDIRECT_POINTER. + * @return Instruction hint. + */ + static const InstructionHint INDIRECT_POINTER() { + return InstructionHint(FCML_HINT_INDIRECT_POINTER); + } + /** + * Creates instruction hint: DIRECT_POINTER. + * @return Instruction hint. + */ + static const InstructionHint DIRECT_POINTER() { + return InstructionHint(FCML_HINT_DIRECT_POINTER); + } +public: + fcml_en_instruction_hints _hint; +}; + +/** Wraps operand hint and exposes factory methods for instruction hints. + * @since 1.1.0 + */ +struct OperandHint { +private: + OperandHint(fcml_en_operand_hints hint) : + _hint(hint) { + } +public: + /** + * Creates operand level hint: UNDEFIEND. + * @return Operand level hint. + */ + static const OperandHint UNDEFIEND() { + return OperandHint(FCML_OP_HINT_UNDEFIEND); + } + /** + * Creates operand level hint: MULTIMEDIA_INSTRUCTION. + * @return Operand level hint. + */ + static const OperandHint MULTIMEDIA() { + return OperandHint(FCML_OP_HINT_MULTIMEDIA_INSTRUCTION); + } + /** + * Creates operand level hint: DISPLACEMENT_RELATIVE_ADDRESS. + * @return Operand level hint. + */ + static const OperandHint DISPLACEMENT_RELATIVE_ADDRESS() { + return OperandHint(FCML_OP_HINT_DISPLACEMENT_RELATIVE_ADDRESS); + } + /** + * Creates operand level hint: PSEUDO_OPCODE. + * @return Operand level hint. + */ + static const OperandHint PSEUDO_OPCODE() { + return OperandHint(FCML_OP_HINT_PSEUDO_OPCODE); + } + /** + * Creates operand level hint: ABSOLUTE_ADDRESSING. + * @return Operand level hint. + */ + static const OperandHint ABSOLUTE_ADDRESSING() { + return OperandHint(FCML_OP_HINT_ABSOLUTE_ADDRESSING); + } + /** + * Creates operand level hint: RELATIVE_ADDRESSING. + * @return Operand level hint. + */ + static const OperandHint RELATIVE_ADDRESSING() { + return OperandHint(FCML_OP_HINT_RELATIVE_ADDRESSING); + } + /** + * Creates operand level hint: SIB_ENCODING. + * @return Operand level hint. + */ + static const OperandHint SIB_ENCODING() { + return OperandHint(FCML_OP_HINT_SIB_ENCODING); + } +public: + fcml_en_operand_hints _hint; +}; + +/** + * Holds instruction pointer, processor operating mode and memory segment flags. + * @since 1.1.0 + */ +class EntryPoint { +public: + + /** + * Supported operating modes. + * @since 1.1.0 + */ + enum OperatingMode { + OM_16_BIT = FCML_OM_16_BIT, + OM_32_BIT = FCML_OM_32_BIT, + OM_64_BIT = FCML_OM_64_BIT + }; + + /** + * Creates an empty entry point instance. + * @since 1.1.0 + */ + EntryPoint() : + _opMode(OM_32_BIT), + _addressSizeAttribute(FCML_DS_32), + _operandSizeAttribute(FCML_DS_32), + _ip(0) { + } + + /** + * Creates an entry point instance for given processor operating mode, instruction pointer and optionally size attributes. + * @param opMode The processor operating mode. + * @param ip The instruction pointer. + * @param addressSizeAttribute The optional address size attribute. + * @param operandSizeAttribute The optional operand size attribute. + * @since 1.1.0 + */ + EntryPoint(OperatingMode opMode, fcml_ip ip = 0, fcml_usize addressSizeAttribute = FCML_DS_UNDEF, fcml_usize operandSizeAttribute = FCML_DS_UNDEF ) : + _opMode(opMode), + _addressSizeAttribute(addressSizeAttribute), + _operandSizeAttribute(operandSizeAttribute), + _ip(ip) { + } + + virtual ~EntryPoint() { + } + +public: + + /** + * Checks if two entry points are equal. + * + * @param ep The source entry point. + * @return True if they are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const EntryPoint &ep ) const { + return _opMode == ep._opMode && + _ip == ep._ip && + _operandSizeAttribute == ep._operandSizeAttribute && + _addressSizeAttribute == ep._addressSizeAttribute; + } + + /** + * Checks if two entry points are not equal. + * + * @param ep The source entry point. + * @return True if they are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const EntryPoint &ep ) const { + return !(ep == *this); + } + +public: + + /** + * Gets address size attribute held by the entry point. + * + * @return Address size attribute. + * @since 1.1.0 + */ + fcml_usize getAddressSizeAttribute() const { + return _addressSizeAttribute; + } + + /** + * Sets a new address size attribute for the entry point. + * + * @param addressSizeAttribute The address size attribute. + * @since 1.1.0 + */ + void setAddressSizeAttribute( fcml_usize addressSizeAttribute ) { + _addressSizeAttribute = addressSizeAttribute; + } + + /** + * Gets operand size attribute held by the entry point. + * + * @return Operand size attribute. + * @since 1.1.0 + */ + fcml_usize getOperandSizeAttribute() const { + return _operandSizeAttribute; + } + + /** + * Sets a new operand size attribute for the entry point. + * + * @param operandSizeAttribute The operand size attribute. + * @since 1.1.0 + */ + void setOperandSizeAttribute( fcml_usize operandSizeAttribute ) { + _operandSizeAttribute = operandSizeAttribute; + } + + /** + * Gets instruction pointer held by the entry point. + * + * @return Instruction pointer. + * @since 1.1.0 + */ + fcml_ip getIP() const { + return _ip; + } + + /** + * Sets a new instruction pointer for the entry point. + * + * @param ip The new instruction pointer. + * @since 1.1.0 + */ + void setIP( fcml_ip ip ) { + _ip = ip; + } + + /** + * Gets processor operating mode. + * + * @return Processor operating mode. + * @since 1.1.0 + */ + OperatingMode getOpMode() const { + return _opMode; + } + + /** + * Sets a new processor operating mode for the entry point. + * + * @param opMode The new processor operating mode. + * @since 1.1.0 + */ + void setOpMode( OperatingMode opMode ) { + _opMode = opMode; + } + + /** + * Increments the instruction pointer by given number of bytes. + * + * @param ip Number for bytes the instruction pointer should be incremented by. + * @since 1.1.0 + */ + void incrementIP( fcml_ip ip ) { + _ip += ip; + } + +private: + /** Processor operating mode */ + OperatingMode _opMode; + /** Size of the address size attribute. */ + fcml_usize _addressSizeAttribute; + /** Size of the operand size attribute. */ + fcml_usize _operandSizeAttribute; + /** Instruction pointer. Content of the EIP/RIP register. */ + fcml_ip _ip; +}; + +/** + * Represents integer value. + * @since 1.1.0 + */ +class Integer { +public: + + /** @since 1.1.0 */ + Integer() : + _size( FCML_DS_64 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( 0 ), _vint32( 0 ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_int8_t value ) : + _size( FCML_DS_8 ), _isSigned( FCML_TRUE ), _vint8( value ), _vint16( 0 ), _vint32( 0 ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_int16_t value ) : + _size( FCML_DS_16 ), _isSigned( FCML_TRUE ), _vint8( 0 ), _vint16( value ), _vint32( 0 ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_int32_t value ) : + _size( FCML_DS_32 ), _isSigned( FCML_TRUE ), _vint8( 0 ), _vint16( 0 ), _vint32( value ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_int64_t value ) : + _size( FCML_DS_64 ), _isSigned( FCML_TRUE ), _vint8( 0 ), _vint16( 0 ), _vint32( 0 ), _vint64( value ) { + } + + /** @since 1.1.0 */ + Integer( fcml_uint8_t value ) : + _size( FCML_DS_8 ), _isSigned( FCML_FALSE ), _vint8( static_cast( value ) ), _vint16( 0 ), _vint32( 0 ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_uint16_t value ) : + _size( FCML_DS_16 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( static_cast( value ) ), _vint32( 0 ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_uint32_t value ) : + _size( FCML_DS_32 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( 0 ), _vint32( static_cast( value ) ), _vint64( 0 ) { + } + + /** @since 1.1.0 */ + Integer( fcml_uint64_t value ) : + _size( FCML_DS_64 ), _isSigned( FCML_FALSE ), _vint8( 0 ), _vint16( 0 ), _vint32( 0 ), _vint64( static_cast( value ) ) { + } + + /** @since 1.1.0 */ + virtual ~Integer() { + } + +public: + + /** @since 1.1.0 */ + fcml_int16_t getInt16() const { + return _vint16; + } + + /** @since 1.1.0 */ + Integer& setInt16( fcml_int16_t int16 ) { + _vint16 = int16; + return *this; + } + + /** @since 1.1.0 */ + fcml_int32_t getInt32() const { + return _vint32; + } + + /** @since 1.1.0 */ + Integer& setInt32( fcml_int32_t int32 ) { + _vint32 = int32; + return *this; + } + + /** @since 1.1.0 */ + fcml_int64_t getInt64() const { + return _vint64; + } + + /** @since 1.1.0 */ + Integer& setInt64( fcml_int64_t int64 ) { + _vint64 = int64; + return *this; + } + + /** @since 1.1.0 */ + fcml_int8_t getInt8() const { + return _vint8; + } + + /** @since 1.1.0 */ + Integer& setInt8( fcml_int8_t int8 ) { + _vint8 = int8; + return *this; + } + + /** @since 1.1.0 */ + fcml_bool isSigned() const { + return _isSigned; + } + + /** @since 1.1.0 */ + Integer& setSigned( fcml_bool isSigned ) { + _isSigned = isSigned; + return *this; + } + + /** @since 1.1.0 */ + fcml_usize getSize() const { + return _size; + } + + /** @since 1.1.0 */ + Integer& setSize( fcml_usize size ) { + _size = size; + return *this; + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_uint8_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_int8_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_uint16_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_int16_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_uint32_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_int32_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_uint64_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const fcml_int64_t value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are equal; otherwise false. + * @since 1.1.0 + */ + bool operator==( const Integer &value ) const { + return _isSigned ? static_cast( *this ) == static_cast( value ) : static_cast( *this ) == static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_uint8_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_int8_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_uint16_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_int16_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_uint32_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_int32_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_uint64_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const fcml_int64_t value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * Checks if the integer is not equal to the passed value. + * + * @param value The source value to be compared with the integer. + * @return True if values are not equal; otherwise false. + * @since 1.1.0 + */ + bool operator!=( const Integer &value ) const { + return _isSigned ? static_cast( *this ) != static_cast( value ) : static_cast( *this ) != static_cast( value ); + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong data size. + */ + operator fcml_int8_t() const { + fcml_int8_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong indeger size. + */ + operator fcml_uint8_t() const { + fcml_uint8_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_int16_t() const { + fcml_int16_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_uint16_t() const { + fcml_uint16_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_int32_t() const { + fcml_int32_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_uint32_t() const { + fcml_uint32_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_int64_t() const { + fcml_int64_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * A casting operator. + * @since 1.1.0 + * @throw BadArgumentException Wrong integer size. + */ + operator fcml_uint64_t() const { + fcml_uint64_t result; + switch ( _size ) { + case FCML_DS_8: + result = static_cast( _isSigned ? _vint8 : (fcml_uint8_t)_vint8 ); + break; + case FCML_DS_16: + result = static_cast( _isSigned ? _vint16 : (fcml_uint16_t)_vint16 ); + break; + case FCML_DS_32: + result = static_cast( _isSigned ? _vint32 : (fcml_uint32_t)_vint32 ); + break; + case FCML_DS_64: + result = static_cast( _isSigned ? _vint64 : (fcml_uint64_t)_vint64 ); + break; + default: + throw BadArgumentException( FCML_TEXT( "Wrong size." ) ); + } + return result; + } + + /** + * Addition assignment. + * @since 1.1.0 + */ + Integer& operator +=( const Integer &arg ) { + plus( *this, arg ); + return ( *this ); + } + + /** + * Multiplication assignment. + * @since 1.1.0 + */ + Integer& operator *=( const Integer &arg ) { + mul( *this, arg ); + return ( *this ); + } + + /** + * Division assignment. + * @since 1.1.0 + */ + Integer& operator /=( const Integer &arg ) { + div( *this, arg ); + return ( *this ); + } + + /** + * Subtraction assignment. + * @since 1.1.0 + */ + Integer& operator -=( const Integer &arg ) { + minus( *this, arg ); + return ( *this ); + } + + /** + * Addition operator. + * @since 1.1.0 + */ + Integer operator+( const Integer &src ) const { + const Integer &thisRef = *this; + Integer result( thisRef ); + plus( result, src ); + return result; + } + + /** + * Subtraction operator. + * @since 1.1.0 + */ + Integer operator-( const Integer &src ) const { + const Integer &thisRef = *this; + Integer result( thisRef ); + minus( result, src ); + return result; + } + + /** + * Multiplication operator. + * @since 1.1.0 + */ + Integer operator*( const Integer &src ) const { + const Integer &thisRef = *this; + Integer result( thisRef ); + mul( result, src ); + return result; + } + + /** + * Division operator. + * @since 1.1.0 + */ + Integer operator/( const Integer &src ) const { + const Integer &thisRef = *this; + Integer result( thisRef ); + div( result, src ); + return result; + } + +public: + + /** + * Factory method which creates an instance fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer int8( fcml_int8_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an instance fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer uint8( fcml_uint8_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an instance fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer int16( fcml_int16_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an instance fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer uint16( fcml_uint16_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an insatnce fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer int32( fcml_int32_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an insatnce fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer uint32( fcml_uint32_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an insatnce fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer int64( fcml_int64_t value ) { + return Integer( value ); + } + + /** + * Factory method which creates an insatnce fo the Integer for given parameter. + * @param value The value for the newly created Integer. + * @return The created Integer instance. + * @since 1.1.0 + */ + static Integer uint64( fcml_uint64_t value ) { + return Integer( value ); + } + +private: + + /** + * @remark An internal API. + * @since 1.1.0 + */ + void minus( Integer &result, const Integer &src ) const { + callMathExpression( &doMinus, &doUMinus, result, src ); + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + void mul( Integer &result, const Integer &src ) const { + callMathExpression( &doMul, &doUMul, result, src ); + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + void div( Integer &result, const Integer &src ) const { + callMathExpression( &doDiv, &doUDiv, result, src ); + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + void plus( Integer &result, const Integer &src ) const { + callMathExpression( &doPlus, &doUPlus, result, src ); + } + +private: + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_int64_t doPlus( fcml_int64_t thisValue, fcml_int64_t thatValue ) { + return thisValue + thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_int64_t doMinus( fcml_int64_t thisValue, fcml_int64_t thatValue ) { + return thisValue - thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_int64_t doMul( fcml_int64_t thisValue, fcml_int64_t thatValue ) { + return thisValue * thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_int64_t doDiv( fcml_int64_t thisValue, fcml_int64_t thatValue ) { + return thisValue / thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_uint64_t doUPlus( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) { + return thisValue + thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_uint64_t doUMinus( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) { + return thisValue - thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_uint64_t doUMul( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) { + return thisValue * thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + static fcml_uint64_t doUDiv( fcml_uint64_t thisValue, fcml_uint64_t thatValue ) { + return thisValue / thatValue; + } + + /** + * @remark An internal API. + * @since 1.1.0 + */ + void callMathExpression( fcml_int64_t (*signedExpressionFn)( fcml_int64_t thisValue, fcml_int64_t thatValue ), + fcml_uint64_t (*unsignedExpressionFn)( fcml_uint64_t thisValue, fcml_uint64_t thatValue ), + Integer &result, const Integer &src ) const { + + if( _isSigned ) { + + fcml_int64_t thisValue; + fcml_int64_t thatValue; + + // Prepare "that". It has to be converted to the same sign. + switch( src._size ) { + case FCML_DS_8: + thatValue = src._isSigned ? src._vint8 : static_cast( src._vint8 ); + break; + case FCML_DS_16: + thatValue = src._isSigned ? src._vint16 : static_cast( src._vint16 ); + break; + case FCML_DS_32: + thatValue = src._isSigned ? src._vint32 : static_cast( src._vint32 ); + break; + case FCML_DS_64: + thatValue = src._isSigned ? src._vint64 : static_cast( src._vint64 ); + break; + } + + // Now "this". + switch( result._size ) { + case FCML_DS_8: + thisValue = result._isSigned ? result._vint8 : static_cast(result._vint8 ); + thisValue = (*signedExpressionFn)( thisValue, thatValue ); + result._vint8 = static_cast( thisValue ); + break; + case FCML_DS_16: + thisValue = result._isSigned ? result._vint16 : static_cast( result._vint16 ); + thisValue = (*signedExpressionFn)( thisValue, thatValue ); + result._vint16 = static_cast( thisValue ); + break; + case FCML_DS_32: + thisValue = result._isSigned ? result._vint32 : static_cast( result._vint32 ); + thisValue = (*signedExpressionFn)( thisValue, thatValue ); + result._vint32 = static_cast( thisValue ); + break; + case FCML_DS_64: + thisValue = result._isSigned ? result._vint64 : static_cast( result._vint64 ); + thisValue = (*signedExpressionFn)( thisValue, thatValue ); + result._vint64 = thisValue; + break; + } + + } else { + + fcml_uint64_t thisValue; + fcml_uint64_t thatValue; + + // Prepare "that". It has to be converted to the same sign. + switch( src._size ) { + case FCML_DS_8: + thatValue = src._isSigned ? src._vint8 : static_cast( src._vint8 ); + break; + case FCML_DS_16: + thatValue = src._isSigned ? src._vint16 : static_cast( src._vint16 ); + break; + case FCML_DS_32: + thatValue = src._isSigned ? src._vint32 : static_cast( src._vint32 ); + break; + case FCML_DS_64: + thatValue = src._isSigned ? src._vint64 : static_cast( src._vint64 ); + break; + } + + // Now "this". + switch( result._size ) { + case FCML_DS_8: + thisValue = result._isSigned ? result._vint8 : static_cast( result._vint8 ); + thisValue = (*unsignedExpressionFn)( thisValue, thatValue ); + result._vint8 = static_cast( thisValue ); + break; + case FCML_DS_16: + thisValue = result._isSigned ? result._vint16 : static_cast( result._vint16 ); + thisValue = (*unsignedExpressionFn)( thisValue, thatValue ); + result._vint16 = static_cast( thisValue ); + break; + case FCML_DS_32: + thisValue = result._isSigned ? result._vint32 : static_cast( result._vint32 ); + thisValue = (*unsignedExpressionFn)( thisValue, thatValue ); + result._vint32 = static_cast( thisValue ); + break; + case FCML_DS_64: + thisValue = result._isSigned ? result._vint64 : static_cast( result._vint64 ); + thisValue = (*unsignedExpressionFn)( thisValue, thatValue ); + result._vint64 = thisValue; + break; + } + } + + } + +private: + fcml_usize _size; + fcml_bool _isSigned; + fcml_int8_t _vint8; + fcml_int16_t _vint16; + fcml_int32_t _vint32; + fcml_int64_t _vint64; +}; + +/** + * x86 - 64 register representation. + * @since 1.1.0 + */ +class Register { +public: + + // TODO: Do we need this REG_ prefix here? + /** Register types. + * @since 1.1.0 + */ + enum RegisterType { + /** Undefined register type. */ + REG_UNDEFINED = FCML_REG_UNDEFINED, + /** General purpose register. */ + REG_GPR = FCML_REG_GPR, + /** SIMD (SSE, MMX) register. */ + REG_SIMD = FCML_REG_SIMD, + /** FPU register. */ + REG_FPU = FCML_REG_FPU, + /** Segment register */ + REG_SEG = FCML_REG_SEG, + /** Control register. */ + REG_CR = FCML_REG_CR, + /** Debug register */ + REG_DR = FCML_REG_DR, + /** Instruction pointer register. Used for relative RIP addressing. */ + REG_IP = FCML_REG_IP, + /** Opmask register + * @since 1.2.0 + */ + REG_OPMASK = FCML_REG_OPMASK + }; + + /** + * Creates an empty register instance. + * @since 1.1.0 + */ + Register() : + _type(REG_UNDEFINED), + _size(0), + _reg(0), + _x64_exp(FCML_FALSE) { + } + + /** + * Creates a register instance for given register structure. + * @param reg The source register as the FCML structure. + * @since 1.1.0 + */ + Register( const fcml_st_register ® ) : + _type(static_cast( reg.type )), + _size(reg.size), + _reg(reg.reg), + _x64_exp(reg.x64_exp? true : false) { + } + + /** + * Creates a register instance for given parameters. + * @param reg The FCML register number. + * @param size The register size. + * @param type The register type. + * @param x64_exp True if it's a 8-bit general purpose register for REX aware instruction. See manual. + * @since 1.1.0 + */ + Register( fcml_uint8_t reg, fcml_usize size, RegisterType type = REG_GPR, fcml_bool x64_exp = FCML_FALSE ) : + _type(type), + _size(size), + _reg(reg), + _x64_exp(x64_exp?true:false) { + } + + /** + * @since 1.1.0 + */ + virtual ~Register() { + } + +public: + + /** + * Gets the register number. + * @return The register number. + * @since 1.1.0 + */ + fcml_uint8_t getReg() const { + return _reg; + } + + /** + * Sets the register number. + * @param reg The register number. + * @since 1.1.0 + */ + void setReg( fcml_uint8_t reg ) { + _reg = reg; + } + + /** + * Gets the register size. + * @return The register size. + * @since 1.1.0 + */ + fcml_usize getSize() const { + return _size; + } + + /** + * Sets the register size. + * @param size The register size. + * @since 1.1.0 + */ + void setSize( fcml_usize size ) { + _size = size; + } + + /** + * Gets the register type. + * @return The register type. + * @since 1.1.0 + */ + RegisterType getType() const { + return _type; + } + + /** + * Sets the register type. + * @param type The register type. + * @since 1.1.0 + */ + void setType( RegisterType type ) { + _type = type; + } + + /** + * Gets true if it's a 8-bit general purpose register for REX aware instruction. See manual. + * @return True if it's a 8-bit general purpose register for REX aware instruction. See manual.. + * @since 1.1.0 + */ + bool getX64Exp() const { + return _x64_exp; + } + + /** + * Sets x64exp flag, see manual. + * @param x64Exp The flag value. + * @since 1.1.0 + */ + void setX64Exp( bool x64Exp ) { + _x64_exp = x64Exp; + } + +public: + + /** + * Compares registers. + * @param reg The source register. + * @return True if registers are equal. + * @since 1.1.0 + */ + bool operator==( const Register ® ) const { + return _reg == reg._reg && _type == reg._type && _size == reg._size && _x64_exp == reg._x64_exp; + } + + /** + * Compares registers. + * @param reg The source register. + * @return True if registers are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const Register ® ) const { + return !( reg == *this ); + } + +public: + + /** + * Factory method for an undefined register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register UNDEF() { + Register reg( 0, 0, Register::REG_UNDEFINED, FCML_FALSE ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register AL() { + Register reg( ::fcml_reg_AL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register AX() { + Register reg( ::fcml_reg_AX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EAX() { + Register reg( ::fcml_reg_EAX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RAX() { + Register reg( ::fcml_reg_RAX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM0() { + Register reg( ::fcml_reg_MM0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM0() { + Register reg( ::fcml_reg_XMM0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM0() { + Register reg( ::fcml_reg_YMM0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM0() { + Register reg( ::fcml_reg_ZMM0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CL() { + Register reg( ::fcml_reg_CL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CX() { + Register reg( ::fcml_reg_CX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ECX() { + Register reg( ::fcml_reg_ECX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RCX() { + Register reg( ::fcml_reg_RCX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM1() { + Register reg( ::fcml_reg_MM1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM1() { + Register reg( ::fcml_reg_XMM1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM1() { + Register reg( ::fcml_reg_YMM1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM1() { + Register reg( ::fcml_reg_ZMM1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DL() { + Register reg( ::fcml_reg_DL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DX() { + Register reg( ::fcml_reg_DX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EDX() { + Register reg( ::fcml_reg_EDX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RDX() { + Register reg( ::fcml_reg_RDX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM2() { + Register reg( ::fcml_reg_MM2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM2() { + Register reg( ::fcml_reg_XMM2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM2() { + Register reg( ::fcml_reg_YMM2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM2() { + Register reg( ::fcml_reg_ZMM2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register BL() { + Register reg( ::fcml_reg_BL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register BX() { + Register reg( ::fcml_reg_BX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EBX() { + Register reg( ::fcml_reg_EBX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RBX() { + Register reg( ::fcml_reg_RBX ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM3() { + Register reg( ::fcml_reg_MM3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM3() { + Register reg( ::fcml_reg_XMM3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM3() { + Register reg( ::fcml_reg_YMM3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM3() { + Register reg( ::fcml_reg_ZMM3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register AH() { + Register reg( ::fcml_reg_AH ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register SPL() { + Register reg( ::fcml_reg_SPL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register SP() { + Register reg( ::fcml_reg_SP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ESP() { + Register reg( ::fcml_reg_ESP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RSP() { + Register reg( ::fcml_reg_RSP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM4() { + Register reg( ::fcml_reg_MM4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM4() { + Register reg( ::fcml_reg_XMM4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM4() { + Register reg( ::fcml_reg_YMM4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM4() { + Register reg( ::fcml_reg_ZMM4 ); + return reg; + } + + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CH() { + Register reg( ::fcml_reg_CH ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register BPL() { + Register reg( ::fcml_reg_BPL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register BP() { + Register reg( ::fcml_reg_BP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EBP() { + Register reg( ::fcml_reg_EBP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RBP() { + Register reg( ::fcml_reg_RBP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM5() { + Register reg( ::fcml_reg_MM5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM5() { + Register reg( ::fcml_reg_XMM5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM5() { + Register reg( ::fcml_reg_YMM5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM5() { + Register reg( ::fcml_reg_ZMM5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DH() { + Register reg( ::fcml_reg_DH ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register SIL() { + Register reg( ::fcml_reg_SIL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register SI() { + Register reg( ::fcml_reg_SI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ESI() { + Register reg( ::fcml_reg_ESI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RSI() { + Register reg( ::fcml_reg_RSI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM6() { + Register reg( ::fcml_reg_MM6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM6() { + Register reg( ::fcml_reg_XMM6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM6() { + Register reg( ::fcml_reg_YMM6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM6() { + Register reg( ::fcml_reg_ZMM6 ); + return reg; + } + + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register BH() { + Register reg( ::fcml_reg_BH ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DIL() { + Register reg( ::fcml_reg_DIL ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DI() { + Register reg( ::fcml_reg_DI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EDI() { + Register reg( ::fcml_reg_EDI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RDI() { + Register reg( ::fcml_reg_RDI ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register MM7() { + Register reg( ::fcml_reg_MM7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM7() { + Register reg( ::fcml_reg_XMM7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM7() { + Register reg( ::fcml_reg_YMM7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM7() { + Register reg( ::fcml_reg_ZMM7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R8L() { + Register reg( ::fcml_reg_R8L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R8W() { + Register reg( ::fcml_reg_R8W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R8D() { + Register reg( ::fcml_reg_R8D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R8() { + Register reg( ::fcml_reg_R8 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM8() { + Register reg( ::fcml_reg_XMM8 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM8() { + Register reg( ::fcml_reg_YMM8 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM8() { + Register reg( ::fcml_reg_ZMM8 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R9L() { + Register reg( ::fcml_reg_R9L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R9W() { + Register reg( ::fcml_reg_R9W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R9D() { + Register reg( ::fcml_reg_R9D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R9() { + Register reg( ::fcml_reg_R9 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM9() { + Register reg( ::fcml_reg_XMM9 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM9() { + Register reg( ::fcml_reg_YMM9 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM9() { + Register reg( ::fcml_reg_ZMM9 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R10L() { + Register reg( ::fcml_reg_R10L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R10W() { + Register reg( ::fcml_reg_R10W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R10D() { + Register reg( ::fcml_reg_R10D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R10() { + Register reg( ::fcml_reg_R10 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM10() { + Register reg( ::fcml_reg_XMM10 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM10() { + Register reg( ::fcml_reg_YMM10 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM10() { + Register reg( ::fcml_reg_ZMM10 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R11L() { + Register reg( ::fcml_reg_R11L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R11W() { + Register reg( ::fcml_reg_R11W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R11D() { + Register reg( ::fcml_reg_R11D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R11() { + Register reg( ::fcml_reg_R11 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM11() { + Register reg( ::fcml_reg_XMM11 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM11() { + Register reg( ::fcml_reg_YMM11 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM11() { + Register reg( ::fcml_reg_ZMM11 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R12L() { + Register reg( ::fcml_reg_R12L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R12W() { + Register reg( ::fcml_reg_R12W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R12D() { + Register reg( ::fcml_reg_R12D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R12() { + Register reg( ::fcml_reg_R12 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM12() { + Register reg( ::fcml_reg_XMM12 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM12() { + Register reg( ::fcml_reg_YMM12 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM12() { + Register reg( ::fcml_reg_ZMM12 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R13L() { + Register reg( ::fcml_reg_R13L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R13W() { + Register reg( ::fcml_reg_R13W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R13D() { + Register reg( ::fcml_reg_R13D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R13() { + Register reg( ::fcml_reg_R13 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM13() { + Register reg( ::fcml_reg_XMM13 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM13() { + Register reg( ::fcml_reg_YMM13 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM13() { + Register reg( ::fcml_reg_ZMM13 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R14L() { + Register reg( ::fcml_reg_R14L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R14W() { + Register reg( ::fcml_reg_R14W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R14D() { + Register reg( ::fcml_reg_R14D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R14() { + Register reg( ::fcml_reg_R14 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM14() { + Register reg( ::fcml_reg_XMM14 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM14() { + Register reg( ::fcml_reg_YMM14 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM14() { + Register reg( ::fcml_reg_ZMM14 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R15L() { + Register reg( ::fcml_reg_R15L ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R15W() { + Register reg( ::fcml_reg_R15W ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R15D() { + Register reg( ::fcml_reg_R15D ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register R15() { + Register reg( ::fcml_reg_R15 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register XMM15() { + Register reg( ::fcml_reg_XMM15 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register YMM15() { + Register reg( ::fcml_reg_YMM15 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM15() { + Register reg( ::fcml_reg_ZMM15 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM16() { + Register reg( ::fcml_reg_XMM16 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM16() { + Register reg( ::fcml_reg_YMM16 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM16() { + Register reg( ::fcml_reg_ZMM16 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM17() { + Register reg( ::fcml_reg_XMM17 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM17() { + Register reg( ::fcml_reg_YMM17 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM17() { + Register reg( ::fcml_reg_ZMM17 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM18() { + Register reg( ::fcml_reg_XMM18 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM18() { + Register reg( ::fcml_reg_YMM18 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM18() { + Register reg( ::fcml_reg_ZMM18 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM19() { + Register reg( ::fcml_reg_XMM19 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM19() { + Register reg( ::fcml_reg_YMM19 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM19() { + Register reg( ::fcml_reg_ZMM19 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM20() { + Register reg( ::fcml_reg_XMM20 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM20() { + Register reg( ::fcml_reg_YMM20 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM20() { + Register reg( ::fcml_reg_ZMM20 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM21() { + Register reg( ::fcml_reg_XMM21 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM21() { + Register reg( ::fcml_reg_YMM21 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM21() { + Register reg( ::fcml_reg_ZMM21 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM22() { + Register reg( ::fcml_reg_XMM22 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM22() { + Register reg( ::fcml_reg_YMM22 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM22() { + Register reg( ::fcml_reg_ZMM22 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM23() { + Register reg( ::fcml_reg_XMM23 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM23() { + Register reg( ::fcml_reg_YMM23 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM23() { + Register reg( ::fcml_reg_ZMM23 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM24() { + Register reg( ::fcml_reg_XMM24 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM24() { + Register reg( ::fcml_reg_YMM24 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM24() { + Register reg( ::fcml_reg_ZMM24 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM25() { + Register reg( ::fcml_reg_XMM25 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM25() { + Register reg( ::fcml_reg_YMM25 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM25() { + Register reg( ::fcml_reg_ZMM25 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM26() { + Register reg( ::fcml_reg_XMM26 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM26() { + Register reg( ::fcml_reg_YMM26 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM26() { + Register reg( ::fcml_reg_ZMM26 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM27() { + Register reg( ::fcml_reg_XMM27 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM27() { + Register reg( ::fcml_reg_YMM27 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM27() { + Register reg( ::fcml_reg_ZMM27 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM28() { + Register reg( ::fcml_reg_XMM28 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM28() { + Register reg( ::fcml_reg_YMM28 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM28() { + Register reg( ::fcml_reg_ZMM28 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM29() { + Register reg( ::fcml_reg_XMM29 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM29() { + Register reg( ::fcml_reg_YMM29 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM29() { + Register reg( ::fcml_reg_ZMM29 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM30() { + Register reg( ::fcml_reg_XMM30 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM30() { + Register reg( ::fcml_reg_YMM30 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM30() { + Register reg( ::fcml_reg_ZMM30 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register XMM31() { + Register reg( ::fcml_reg_XMM31 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register YMM31() { + Register reg( ::fcml_reg_YMM31 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register ZMM31() { + Register reg( ::fcml_reg_ZMM31 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ES() { + Register reg( ::fcml_reg_ES ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CS() { + Register reg( ::fcml_reg_CS ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register SS() { + Register reg( ::fcml_reg_SS ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DS() { + Register reg( ::fcml_reg_DS ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register FS() { + Register reg( ::fcml_reg_FS ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register GS() { + Register reg( ::fcml_reg_GS ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST0() { + Register reg( ::fcml_reg_ST0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST1() { + Register reg( ::fcml_reg_ST1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST2() { + Register reg( ::fcml_reg_ST2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST3() { + Register reg( ::fcml_reg_ST3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST4() { + Register reg( ::fcml_reg_ST4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST5() { + Register reg( ::fcml_reg_ST5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST6() { + Register reg( ::fcml_reg_ST6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register ST7() { + Register reg( ::fcml_reg_ST7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CR0() { + Register reg( ::fcml_reg_CR0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CR2() { + Register reg( ::fcml_reg_CR2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CR3() { + Register reg( ::fcml_reg_CR3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CR4() { + Register reg( ::fcml_reg_CR4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register CR8() { + Register reg( ::fcml_reg_CR8 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR0() { + Register reg( ::fcml_reg_DR0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR1() { + Register reg( ::fcml_reg_DR1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR2() { + Register reg( ::fcml_reg_DR2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR3() { + Register reg( ::fcml_reg_DR3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR4() { + Register reg( ::fcml_reg_DR4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR5() { + Register reg( ::fcml_reg_DR5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR6() { + Register reg( ::fcml_reg_DR6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register DR7() { + Register reg( ::fcml_reg_DR7 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register IP() { + Register reg( ::fcml_reg_IP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register EIP() { + Register reg( ::fcml_reg_EIP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.1.0 + */ + static const Register RIP() { + Register reg( ::fcml_reg_RIP ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K0() { + Register reg( ::fcml_reg_K0 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K1() { + Register reg( ::fcml_reg_K1 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K2() { + Register reg( ::fcml_reg_K2 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K3() { + Register reg( ::fcml_reg_K3 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K4() { + Register reg( ::fcml_reg_K4 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K5() { + Register reg( ::fcml_reg_K5 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K6() { + Register reg( ::fcml_reg_K6 ); + return reg; + } + + /** + * Factory method for a register. + * @return A register instance. + * @since 1.2.0 + */ + static const Register K7() { + Register reg( ::fcml_reg_K7 ); + return reg; + } + +private: + + /** Register type. */ + RegisterType _type; + /** Register size in bits. */ + fcml_usize _size; + /** Register itself as a positive integer. @see REGISTERS_GROUP */ + fcml_uint8_t _reg; + /** In case of SPL,BPL,SIL,DIL GPR registers has to be set to true. */ + bool _x64_exp; + +}; + +/** + * Describes far pointer. + * @since 1.1.0 + */ +class FarPointer { + +public: + + /** + * Creates an far pointer instance. + * @since 1.1.0 + */ + FarPointer() : + _segment(0), + _offset_size(0), + _offset16(0), + _offset32(0) { + } + + /** + * Creates an far pointer instance. + * @param segment A segment selector. + * @param offset16 A 16-bit offset in the given segment. + * @since 1.1.0 + */ + FarPointer( fcml_uint16_t segment, fcml_int16_t offset16 ) : + _segment(segment), + _offset_size(FCML_DS_16), + _offset16(offset16), + _offset32(0) { + } + /** + * Creates an far pointer instance. + * @param segment A segment selector. + * @param offset32 A 32-bit offset in the given segment. + * @since 1.1.0 + */ + FarPointer( fcml_uint16_t segment, fcml_int32_t offset32 ) : + _segment(segment), + _offset_size(FCML_DS_32), + _offset16(0), + _offset32(offset32) { + } + + virtual ~FarPointer() { + } + +public: + + /** + * Compares two far pointers. + * @param fp The far pointer to be compared with the current one. + * @return True if they are equal. + * @since 1.1.0 + */ + bool operator==( const FarPointer &fp ) const { + fcml_int32_t thisOffset; + switch( _offset_size ) { + case FCML_DS_32: + thisOffset = _offset32; + break; + case FCML_DS_16: + thisOffset = _offset16; + break; + } + fcml_int32_t thatOffset; + switch( fp._offset_size ) { + case FCML_DS_32: + thatOffset = fp._offset32; + break; + case FCML_DS_16: + thatOffset = fp._offset16; + break; + } + return thisOffset == thatOffset; + } + + /** + * Compares two far pointers. + * @param fp The far pointer to be compared with the current one. + * @return True if they are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const FarPointer &fp) const { + return !(fp == *this); + } + +public: + + /** + * Creates FarPointer instance for 16 bit segment and 16-bit offset. + * + * @param segment Segment selector. + * @param offset 16-bit address. + * @return FarPointer instance. + * @since 1.1.0 + */ + static FarPointer off16( fcml_uint16_t segment, fcml_int16_t offset ) { + return FarPointer(segment, offset); + } + + /** + * Creates FarPointer instance for 16 bit segment and 32-bit offset. + * + * @param segment Segment selector. + * @param offset 32-bit address. + * @return FarPointer instance. + */ + static FarPointer off32( fcml_uint16_t segment, fcml_int32_t offset ) { + return FarPointer(segment, offset); + } + +public: + + /** + * Gets offset size. + * + * @return Offset size. + * @since 1.1.0 + */ + fcml_usize getOffsetSize() const { + return _offset_size; + } + + /** + * Sets offset size. + * + * @param offsetSize The new offset size to be set. + * @since 1.1.0 + */ + void setOffsetSize( fcml_usize offsetSize ) { + _offset_size = offsetSize; + } + + /** + * Gets the 16-bit offset. + * + * @return 16-bit offset. + * @since 1.1.0 + */ + fcml_int16_t getOffset16() const { + return _offset16; + } + + /** + * Sets 16-bit offset. + * + * @param offset16 Sets 16-bit offset. + * @since 1.1.0 + */ + void setOffset16( fcml_int16_t offset16 ) { + _offset16 = offset16; + } + + /** + * Gets 32-bit offset. + * + * @return 32-bit offset. + * @since 1.1.0 + */ + fcml_int32_t getOffset32() const { + return _offset32; + } + + /** + * Sets 32-bit offset. + * + * @param offset32 Sets 32-bit offset. + * @since 1.1.0 + */ + void setOffset32( fcml_int32_t offset32 ) { + _offset32 = offset32; + } + + /** + * Gets segment selector. + * + * @return 16-bit segment selector. + * @since 1.1.0 + */ + fcml_uint16_t getSegment() const { + return _segment; + } + + /** + * Sets segment selector. + * + * @param segment Segment selector. + * @since 1.1.0 + */ + void setSegment( fcml_uint16_t segment ) { + _segment = segment; + } + +private: + + /** 16-bit Code segment. */ + fcml_uint16_t _segment; + /** Size of the offset. */ + fcml_usize _offset_size; + /** 16-bit offset. */ + fcml_int16_t _offset16; + /** 32-bit offset. */ + fcml_int32_t _offset32; + +}; + +/** + * Describes segment register. + * @since 1.1.0 + */ +class SegmentSelector { +public: + + /** + * Creates an empty segment selector instance. + * @since 1.1.0 + */ + SegmentSelector() : + _segmentSelector(), + _isDefaultReg(false) { + } + + /** + * Creates a segment selector instance for given parameters. + * @param segmentSelector A segment register. + * @param isDefaultReg Information if the register is the default one. + * @since 1.1.0 + */ + SegmentSelector( const Register &segmentSelector, bool isDefaultReg = FCML_TRUE ) : + _segmentSelector(segmentSelector), + _isDefaultReg(isDefaultReg) { + } + + virtual ~SegmentSelector() { + } + +public: + + /** + * Checks if two segment selector are equal. + * @param segmentSelector The source segment selector. + * @return True if they are equal. + * @since 1.1.0 + */ + bool operator==( const SegmentSelector &segmentSelector ) const { + // It really doesn't matter if it is the default segment register in a given context. + return segmentSelector._segmentSelector == _segmentSelector; + } + + /** + * Checks if two segment selector are not equal. + * @param segmentSelector The source segment selector. + * @return True if they are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const SegmentSelector &segmentSelector ) const { + return !(*this == segmentSelector); + } + + /** + * Casting operator. + * @return The segment register. + * @since 1.1.0 + */ + operator Register() const { + return _segmentSelector; + } + + /** + * Copies one segment selector to another. + * @param reg The source segment selector. + * @return The destination segment selector. + * @since 1.1.0 + */ + SegmentSelector& operator=( const SegmentSelector ® ) { + if( ® != this ) { + _isDefaultReg = reg._isDefaultReg; + _segmentSelector = reg._segmentSelector; + } + return *this; + } + +public: + + /** + * Creates segment selector for the given register. + * + * @param segmentSelector Segment register. + * @param isDefaultReg True if the register is the default one in the given context. + * @return Prepared segment selector. + * @since 1.1.0 + */ + static SegmentSelector seg( const Register &segmentSelector, bool isDefaultReg ) { + return SegmentSelector( segmentSelector, isDefaultReg ); + } + +public: + + /** + * Returns true if a register stored in the segment selector is the default one + * in the context the segment selector is used. + * + * @return True if register is the default one. + * @since 1.1.0 + */ + bool isDefaultReg() const { + return _isDefaultReg; + } + + /** + * Sets "default" flag for the segment selector. + * + * @param isDefaultReg True if the register is the default one in the given context. + * @since 1.1.0 + */ + void setDefaultReg( bool isDefaultReg ) { + _isDefaultReg = isDefaultReg; + } + + /** + * Gets constant segment register associated with the selector. + * + * @return Constant segment register. + * @since 1.1.0 + */ + const Register& getSegmentSelector() const { + return _segmentSelector; + } + + /** + * Gets segment register associated with the selector. + * + * @return Segment register. + * @since 1.1.0 + */ + Register& getSegmentSelector() { + return _segmentSelector; + } + + /** + * Sets segment register for the selector. + * + * @param segmentSelector Segment register. + * @since 1.1.0 + */ + void setSegmentSelector( const Register& segmentSelector ) { + _segmentSelector = segmentSelector; + } + +private: + /** Segment register. */ + Register _segmentSelector; + /** True if this is a default segment register. */ + bool _isDefaultReg; +}; + +/** + * Describes effective address. + * + * It's a counterpart to the fcml_st_effective_address structure. + * @since 1.1.0 + */ +class EffectiveAddress { +public: + + /** + * Creates an empry effective address. + * @since 1.1.0 + */ + EffectiveAddress() : + _scaleFactor(0){ + } + + /** + * Creates an effective address instance with the displacement only. + * @param displacement The displacement value. + * @since 1.1.0 + */ + EffectiveAddress( const Integer &displacement ) : + _scaleFactor(0), + _displacement(displacement) { + } + + /** + * Creates an effective address instance with the base register only. + * @param base The base register. + * @since 1.1.0 + */ + EffectiveAddress( const Register &base ) : + _base(base), + _scaleFactor(0) { + } + + /** + * Creates an effective address instance with the base register and displacement only. + * @param base The base register. + * @param displacement The displacement value. + * @since 1.1.0 + */ + EffectiveAddress( const Register &base, const Integer &displacement ) : + _base(base), + _scaleFactor(0), + _displacement(displacement) { + } + + /** + * Creates an effective address instance with the index register, scale factor and displacement. + * @param index The index register. + * @param scaleFactor The scale factor value. + * @param displacement The displacement. + * @since 1.1.0 + */ + EffectiveAddress( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) : + _index(index), + _scaleFactor(scaleFactor), + _displacement(displacement) { + } + + /** + * Creates an effective address instance with the base register and index register. + * @param base The base register. + * @param index The index register. + * @since 1.1.0 + */ + EffectiveAddress( const Register &base, const Register &index ) : + _base(base), + _index(index), + _scaleFactor(0) { + } + + /** + * Creates an effective address instance with the base register, index register and scale factor set. + * @param base The base register. + * @param index THe index register. + * @param scaleFactor The scale factor. + * @since 1.1.0 + */ + EffectiveAddress( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) : + _base(base), + _index(index), + _scaleFactor(scaleFactor) { + } + + /** + * Creates an effective address instance with the base register, index register, scale factor and displacement set. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor value. + * @param displacement The displacement. + * @since 1.1.0 + */ + EffectiveAddress( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) : + _base(base), + _index(index), + _scaleFactor(scaleFactor), + _displacement(displacement) { + } + + /** + * @since 1.1.0 + */ + virtual ~EffectiveAddress() { + } + +public: + + /** + * Checks whether two effective addresses are equal or not. + * @param address The source address to be compared. + * @return True if they are equal. + * @since 1.1.0 + */ + bool operator==( const EffectiveAddress &address ) const { + if( &address == this ) { + return true; + } + return _base == address._base && + _index == address._index && + _scaleFactor == address._scaleFactor && + _displacement == address._displacement; + } + + /** + * Checks whether two effective addresses are equal or not. + * @param address The source address to be compared. + * @return True if they are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const EffectiveAddress &address ) const { + return !(address == *this); + } + +public: + + /** + * Factory method which creates an effective address instance with the displacement only. + * @param displacement The displacement value. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Integer &displacement ) { + return EffectiveAddress( displacement ); + } + + /** + * Factory method which creates an effective address instance with the base register only. + * @param base The base register. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &base ) { + return EffectiveAddress( base ); + } + + /** + * Factory method which creates an effective address instance with the base register and displacement. + * @param base The base register. + * @param displacement The displacement value. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &base, const Integer &displacement ) { + return EffectiveAddress( base, displacement ); + } + + /** + * Factory method which creates an effective address instance with the index register, scale factor and displacement. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return EffectiveAddress( index, scaleFactor, displacement ); + } + + /** + * Factory method which creates an effective address instance with the base register and index register. + * @param base The base register. + * @param index The index register. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &base, const Register &index ) { + return EffectiveAddress( base, index, 0 ); + } + + /** + * Factory method which creates an effective address instance with the base register, index register and scale factor. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + return EffectiveAddress( base, index, scaleFactor ); + } + + /** + * Factory method which creates an effective address instance with the base register, index register, scale factor and displacement. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @since 1.1.0 + */ + static EffectiveAddress addr( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return EffectiveAddress( base, index, scaleFactor, displacement ); + } + +public: + + /** + * Gets the constant base register associated with the effective address. + * + * @return The constant base register. + * @since 1.1.0 + */ + const Register& getBase() const { + return _base; + } + + /** + * Gets the base register associated with the effective address. + * + * @return The base register. + * @since 1.1.0 + */ + Register& getBase() { + return _base; + } + + /** + * Sets a new base register for the effective address. + * + * @param base The new base register to be set. + * @return Effective address itself. + * @since 1.1.0 + */ + EffectiveAddress& setBase( const Register &base ) { + _base = base; + return *this; + } + + /** + * Gets the constant displacement associated with the effective address. + * + * @return The constant displacement. + * @since 1.1.0 + */ + const Integer& getDisplacement() const { + return _displacement; + } + + /** + * Gets the displacement associated with the effective address. + * + * @return The displacement. + * @since 1.1.0 + */ + Integer& getDisplacement() { + return _displacement; + } + + /** + * Sets a new displacement value for the effective address. + * + * @param displacement The new displacement for effective address. + * @return The effective address itself. + * @since 1.1.0 + */ + EffectiveAddress& setDisplacement( const Integer &displacement ) { + _displacement = displacement; + return *this; + } + + /** + * Gets the constant index register associated with the effective address. + * + * @return The index register. + * @since 1.1.0 + */ + const Register& getIndex() const { + return _index; + } + + /** + * Gets the index register associated with the effective address. + * + * @return The index register. + * @since 1.1.0 + */ + Register& getIndex() { + return _index; + } + + /** + * Sets a new index register for the effective address. + * + * @param index The new index register for the effective address. + * @return The effective address itself. + * @since 1.1.0 + */ + EffectiveAddress& setIndex( const Register &index ) { + _index = index; + return *this; + } + + /** + * Gets a scale factor value associated with the effective address. + * + * @return The scale factor. + * @since 1.1.0 + */ + fcml_uint8_t getScaleFactor() const { + return _scaleFactor; + } + + /** + * Sets a new scale factor for the effective address. + * + * @param scaleFactor The new scale factor value. + * @return Effective address itself. + * @since 1.1.0 + */ + EffectiveAddress& setScaleFactor( fcml_uint8_t scaleFactor ) { + _scaleFactor = scaleFactor; + return *this; + } + +private: + /** Base register. */ + Register _base; + /** Index register. */ + Register _index; + /** Scale factor. */ + fcml_uint8_t _scaleFactor; + /** Displacement. */ + Integer _displacement; +}; + +/** Address operand. + * + * It's a counterpart to the fcml_st_address structure. + * @since 1.1.0 + */ +class Address { + +public: + + /** Addressing type, see fcml_en_address_form enumerator. + * @since 1.1.0 + */ + enum AddressForm { + /** Default value set if memory addressing hasn't been configured. */ + AF_UNDEFINED = FCML_AF_UNDEFINED, + /** Absolute offset (address). */ + AF_OFFSET = FCML_AF_OFFSET, + /** Effective address combined from address components like base register, index registers, factor, displacement etc... */ + AF_COMBINED = FCML_AF_COMBINED + }; + + /** + * Creates an empty address. + * @since 1.1.0 + */ + Address() : + _size_operator( FCML_DS_UNDEF ), + _address_form( AF_UNDEFINED ) { + } + + /** + * Creates an address instance with an offset and optional size operator set. + * + * @param offset Offset to be set for the address. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @since 1.1.0 + */ + Address( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) : + _size_operator( sizeOperator ), + _address_form( AF_OFFSET ), + _offset( offset ) { + } + + /** + * Creates an address instance with an effective address and optional size operator set. + * + * @param effectiveAddress The effective address to be set for the address. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @since 1.1.0 + */ + Address( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) : + _size_operator( sizeOperator ), + _address_form( AF_COMBINED ), + _effective_address( effectiveAddress ) { + } + + /** + * Creates an address instance with an effective address, segment selector and optional size operator set. + * + * @param effectiveAddress The effective address to be set for the address. + * @param segmentSelector The segment selector. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @since 1.1.0 + */ + Address( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) : + _size_operator( sizeOperator ), + _address_form( AF_COMBINED ), + _segment_selector( segmentSelector ), + _effective_address( effectiveAddress ) { + } + + /** @since 1.1.0 */ + virtual ~Address() { + } + +public: + + /** + * Factory method which creates an effective address instance with the displacement only. + * @param displacement The displacement value. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the base register only. + * @param base The base register. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &base, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( base ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the base register and displacement. + * @param base The base register. + * @param displacement The displacement value. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &base, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( base, displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the index register, scale factor and displacement. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( index, scaleFactor, displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the base register and index register. + * @param base The base register. + * @param index The index register. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &base, const Register &index, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( base, index, 0 ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the base register, index register and scale factor. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &base, const Register &index, fcml_uint8_t scaleFactor, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( base, index, scaleFactor ), sizeOperator ); + } + + /** + * Factory method which creates an effective address instance with the base register, index register, scale factor and displacement. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator Size operator. + * @since 1.1.0 + */ + static Address effective( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return effective( EffectiveAddress( base, index, scaleFactor, displacement ), sizeOperator ); + } + + +public: + + /** + * Checks if two addresses are equal or not. + * @param address The address to be compared with the current one. + * @return True if they are equal. + * @since 1.1.0 + */ + bool operator==( const Address &address ) const { + if( &address == this ) { + return true; + } + return _size_operator == address._size_operator && + _address_form == address._address_form && + _segment_selector == address._segment_selector && + _effective_address == address._effective_address && + _offset == address._offset; + } + + /** + * Checks if two addresses are equal or not. + * @param address The address to be compared with the current one. + * @return True if they are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const Address &address ) const { + return !(address == *this ); + } + +public: + + /** + * Factor method which creates an instance of the address for an effective address, segment selector and optional size operator. + * + * @param effectiveAddress The effective address to be set for the address. + * @param segmentSelector The segment selector. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @return The created address instance. + * @since 1.1.0 + */ + static Address effective( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Address( effectiveAddress, segmentSelector, sizeOperator ); + } + + /** + * Factor method which creates an address instance with an effective address and optional size operator set. + * + * @param effectiveAddress The effective address to be set for the address. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @return The created address instance. + * @since 1.1.0 + */ + static Address effective( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Address( effectiveAddress, sizeOperator ); + } + + /** + * Factor method which creates an address instance with an offset and optional size operator set. + * + * @param offset The offset to be set for the address. + * @param sizeOperator The optional size operator, set to FCML_DS_UNDEF by default. + * @return The created address instance. + * @since 1.1.0 + */ + static Address offset( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Address( offset, sizeOperator ); + } + +public: + + /** + * Returns true if address holds effective address. + * + * @return Returns true if address holds effective address. + * @since 1.1.0 + */ + bool isEffectiveAddress() const { + return _address_form == AF_COMBINED; + } + + /** + * Returns true if address holds an offset only. + * + * @return Returns true if address holds an offset only. + * @since 1.1.0 + */ + bool isOffset() const { + return _address_form == AF_OFFSET; + } + + /** + * Gets an address form. See fcml_en_address_form for more details. + * + * @return The address form. + * @since 1.1.0 + */ + AddressForm getAddressForm() const { + return _address_form; + } + + /** + * Sets a new address form for the effective address. + * + * @param addressForm The address form to be set for the effective address. + * + * @return Address itself. + * @since 1.1.0 + */ + Address& setAddressForm( AddressForm addressForm ) { + _address_form = addressForm; + return *this; + } + + /** + * Gets reference to the constant effective address associated with the address. + * + * @return The constant effective address. + * @since 1.1.0 + */ + const EffectiveAddress& getEffectiveAddress() const { + return _effective_address; + } + + /** + * Gets reference to the effective address associated with the address. + * + * @return The effective address. + * @since 1.1.0 + */ + EffectiveAddress& getEffectiveAddress() { + return _effective_address; + } + + /** + * Sets a new effective address for the address. + * + * @param effectiveAddress The new address to be set for the effective address. + * @return The address itself. + * @since 1.1.0 + */ + Address& setEffectiveAddress( const EffectiveAddress& effectiveAddress ) { + _effective_address = effectiveAddress; + return *this; + } + + /** + * Gets the constant offset associated with the address. + * + * @return The offset associated with the address. + * @since 1.1.0 + */ + const Integer& getOffset() const { + return _offset; + } + + /** + * Gets the offset associated with the address. + * + * @return The offset associated with the address. + * @since 1.1.0 + */ + Integer& getOffset() { + return _offset; + } + + /** + * Sets a new offset for the address. + * + * @param offset The enw offset to be set for the address. + * @return The address itself. + * @since 1.1.0 + */ + Address& setOffset( const Integer &offset ) { + this->_offset = offset; + return *this; + } + + /** + * Gets the constant segment selector associated with the address. + * + * @return The segment selector associated with the address. + * @since 1.1.0 + */ + const SegmentSelector& getSegmentSelector() const { + return _segment_selector; + } + + /** + * Gets the segment selector associated with the address. + * + * @return The segment selector associated with the address. + * @since 1.1.0 + */ + SegmentSelector& getSegmentSelector() { + return _segment_selector; + } + + /** + * Sets a new segment selector for the address. + * + * @param segmentSelector The new segment selector for the address. + * @return The address itself. + * @since 1.1.0 + */ + Address& setSegmentSelector( const SegmentSelector &segmentSelector ) { + _segment_selector = segmentSelector; + return *this; + } + + /** + * Gets the size operator associated with the address. + * + * @return The size operator. + * @since 1.1.0 + */ + fcml_usize getSizeOperator() const { + return _size_operator; + } + + /** + * Sets a new size operator for the address. + * + * @param sizeOperator The size operator. + * @since 1.1.0 + */ + Address& setSizeOperator( fcml_usize sizeOperator ) { + _size_operator = sizeOperator; + return *this; + } + +private: + + /** Size of data accessed in memory.*/ + fcml_usize _size_operator; + /** Memory addressing format: absolute offset/effective address. @see fcml_en_effective_address_form*/ + AddressForm _address_form; + /** Segment register.*/ + SegmentSelector _segment_selector; + /** Memory address for FCML_AF_COMBINED form.*/ + EffectiveAddress _effective_address; + /** Memory address for FCML_AF_OFFSET form.*/ + Integer _offset; + +}; + +/** Holds operand decorators. + * @since 1.2.0 + */ +class Decorators { +public: + + /** + * Rounding mode. + */ + enum EmbeededRoundingControl { + FCML_ERC_RNE = 0, + FCML_ERC_RD, + FCML_ERC_RU, + FCML_ERC_RZ + }; + + /** + * Creates an empty operand decorators container. + * @since 1.2.0 + */ + Decorators() : _z(FCML_FALSE), _operandMaskReg(Register::UNDEF()), + _sae(FCML_FALSE) { + } + + /** + * Sets a new AVX-512 {z} decorator. + * + * @param z {z} decorator. + * @return Decorators. + * @since 1.2.0 + */ + Decorators& setZ(fcml_bool z) { + _z = z; + return *this; + } + + /** + * Sets a new AVX-512 {bcast} decorator. + * + * @param bcast Decorator value. + * @return Decorators.. + * @since 1.2.0 + */ + Decorators& setBcast(const Nullable &bcast) { + _bcast = bcast; + return *this; + } + + /** + * Sets AVX-512 opmask register for {k} decorator. + * + * @param opmaskReg Opmask register. + * @since 1.2.0 + */ + Decorators& setOpmaskReg( const Register& opmaskReg ) { + _operandMaskReg = opmaskReg; + return *this; + } + + /** + * Sets AVX-512 {er} decorator. + * + * @param er {er} decorator. + * @since 1.2.0 + */ + Decorators& setEr(const Nullable &er) { + _er = er; + return *this; + } + + /** + * Sets AVX-512 {sae} decorator. + * + * @param sae {sae} decorator. + * @since 1.2.0 + */ + Decorators& setSae(const fcml_bool sae) { + _sae = sae; + return *this; + } + + /** + * Gets AVX-512 {z} operator. + * + * @return {z} operator. + * @since 1.2.0 + */ + fcml_bool isZ() const { + return _z; + } + + /** + * Gets AVX-512 {bcast} decorator. + * + * @return Value of {bcast} decorator. + * @since 1.2.0 + */ + const Nullable& getBcast() const { + return _bcast; + } + + /** + * Gets constant AVX-512 opmask register for {k} decorator. + * + * @return Opmask register. + * @since 1.2.0 + */ + const Register& getOpmaskReg() const { + return _operandMaskReg; + } + + /** + * Gets AVX-512 opmask register for {k} decorator. + * + * @return Opmask register. + * @since 1.2.0 + */ + Register& getOpmaskReg() { + return _operandMaskReg; + } + + /** + * Gets AVX-512 {er} decorator. + * + * @return Value of {er} decorator. + * @since 1.2.0 + */ + const Nullable& getEr() const { + return _er; + } + + /** + * Gets AVX-512 {sae} decorator. + * + * @return True if {sae} is set. + * @since 1.2.0 + */ + fcml_bool isSae() const { + return _sae; + } + +public: + + /** + * Checks if two decorators containers are equal or not. + * @param decorators Decorators. + * @return True if they are equal. + * @since 1.2.0 + */ + bool operator==(const Decorators &decorators) const { + if(&decorators == this) { + return true; + } + return _z == decorators._z && + _bcast == decorators._bcast && + _operandMaskReg == decorators._operandMaskReg && + _er == decorators._er && + _sae == decorators._sae; + } + + /** + * Checks if two decorators are equal or not. + * @param decorators Decorators. + * @return True if they are NOT equal. + * @since 1.2.0 + */ + bool operator!=(const Decorators &decorators) const { + return !(decorators == *this); + } + +private: + /** Broadcasting: 2, 4, 8, 16, 32, 64. */ + Nullable _bcast; + /** Zeroing masking. */ + fcml_bool _z; + /** The 64-bit k registers are: k0 through k7. */ + Register _operandMaskReg; + /** Embedded rounding control. */ + Nullable _er; + /** Indicates support for SAE (Suppress All Exceptions). */ + fcml_bool _sae; +}; + +/** Instruction operand. + * @since 1.1.0 + */ +class Operand { +public: + + /** See fcml_en_operand_type structure for more details. + * @since 1.1.0 + */ + enum OperandType { + /** Operand not used. */ + OT_NONE = FCML_OT_NONE, + /** Immediate integer value. */ + OT_IMMEDIATE = FCML_OT_IMMEDIATE, + /** Direct far pointer. */ + OT_FAR_POINTER = FCML_OT_FAR_POINTER, + /** Memory address. */ + OT_ADDRESS = FCML_OT_ADDRESS, + /** Processor register. */ + OT_REGISTER = FCML_OT_REGISTER, + /** Virtual operand */ + OT_VIRTUAL = FCML_OT_VIRTUAL + }; + + /** + * Creates an undefined operand. + * @since 1.1.0 + */ + Operand() : + _hints( FCML_OP_HINT_UNDEFIEND ), + _operandType( OT_NONE ) { + } + + /** + * Creates an immediate value operand for given integer. + * + * @param imm The immediate value as integer. + * @param hints Optional operand level hints. + * @since 1.1.0 + */ + Operand( const Integer &imm, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) : + _hints( hints ), + _operandType(OT_IMMEDIATE ), + _immediate( imm ) { + } + + /** + * Creates a far pointer operand for given far pointer. + * + * @param pointer The far pointer for the operand. + * @param hints Optional operand level hints. + * @since 1.1.0 + */ + Operand( const FarPointer &pointer, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) : + _hints( hints ), + _operandType( OT_FAR_POINTER ), + _farPointer( pointer ) { + } + + /** + * Creates an address operand for given address. + * + * @param address The address for the created operand. + * @param hints Optional operand level hints. + * @since 1.1.0 + */ + Operand( const Address &address, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) : + _hints( hints ), + _operandType( OT_ADDRESS ), + _address( address ) { + } + + /** + * Creates a new register operand for given register. + * + * @param reg The register for the new operand being created. + * @param hints Optional operand level hints. + * @since 1.1.0 + */ + Operand( const Register ®, fcml_hints hints = FCML_OP_HINT_UNDEFIEND ) : + _hints( hints ), + _operandType( OT_REGISTER ), + _register( reg ) { + } + +public: + + /** + * Checks if two operands are equal or not. + * + * @param op The operand to be compared with the current one. + * @return True if the operands are equal. + * @since 1.1.0 + */ + bool operator==( const Operand &op ) const { + if( &op == this ) { + return true; + } + bool equal = false; + switch( _operandType ) { + case OT_ADDRESS: + equal = _address == op._address; + break; + case OT_FAR_POINTER: + equal = _farPointer == op._farPointer; + break; + case OT_IMMEDIATE: + equal = _immediate == op._immediate; + break; + case OT_REGISTER: + equal = _register == op._register; + break; + case OT_VIRTUAL: + equal = true; + break; + case OT_NONE: + equal = true; + break; + } + return equal && op._hints == _hints && op._decorators == _decorators; + } + + /** + * Checks if two operands are equal or not. + * + * @param op The operand to be compared with the current one. + * @return True if the operands are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const Operand &op ) const { + return !(op == *this); + } + +public: + + /** + * Converts operand to the undefined one. + * @since 1.1.0 + */ + void undef() { + _operandType = OT_NONE; + } + + /** + * Sets given immediate value for the operand and makes it to be an immediate operand. + * + * @param imm The immediate value. + * @since 1.1.0 + */ + void imm( const Integer &imm ) { + _operandType = OT_IMMEDIATE; + _immediate = imm; + } + + /** + * Converts operand to the far pointer and sets the segment selector and offset for it. + * + * @param seg The segment selector. + * @param addr Offset. + * @since 1.1.0 + */ + void far_ptr( fcml_uint16_t seg, fcml_int16_t addr ) { + _operandType = OT_FAR_POINTER; + _farPointer = FarPointer( seg, addr ); + } + + /** + * Prepares far pointer operand for given components. + * + * @param seg The segment selector. + * @param addr The offset. + * @since 1.1.0 + */ + void far_ptr( fcml_uint16_t seg, fcml_int32_t addr ) { + _operandType = OT_FAR_POINTER; + _farPointer = FarPointer( seg, addr ); + } + + /** + * Prepares far pointer operand for given far pointer. + * + * @param pointer Far pointer to be set for the operand. + * @since 1.1.0 + */ + void far_ptr( const FarPointer &pointer ) { + _operandType = OT_FAR_POINTER; + _farPointer = pointer; + } + + /** + * Prepares address operand for given address. + * + * @param address The address to be set for the operand. + * @since 1.1.0 + */ + void addr( const Address &address ) { + _operandType = OT_ADDRESS; + _address = address; + } + + /** + * Prepares address operand for given offset. + * + * @param offset The offset to be set for the operand. + * @param sizeOperator The size operator to be set for the address. + * @since 1.1.0 + */ + void off( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + _operandType = OT_ADDRESS; + _address = Address( offset, sizeOperator ); + } + + /** + * Prepares an address operand for given effective address and optional size operator. + * + * @param effectiveAddress The effective address. + * @param sizeOperator The size operator. + * @since 1.1.0 + */ + void addr( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + _operandType = OT_ADDRESS; + _address = Address( effectiveAddress, sizeOperator ); + } + + /** + * Prepares address operator for given parameters. + * + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @param sizeOperator The size operator. + * @since 1.1.0 + */ + void addr( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + _operandType = OT_ADDRESS; + _address = Address( effectiveAddress, segmentSelector, sizeOperator ); + } + + /** + * Prepares operator for the given register. + * + * @param reg The register for the operator. + * @since 1.1.0 + */ + void reg( const Register ® ) { + _operandType = OT_REGISTER; + _register = reg; + } + + /** + * Prepares an register operator for given register compounds. + * + * @param reg A register number. + * @param size A register size. + * @param type A register type. + * @param x64_exp An optional marker for the SPL, BPL, SIL etc. registers. See manual for more information. + * @since 1.1.0 + */ + void reg( fcml_uint8_t reg, fcml_usize size, Register::RegisterType type = Register::REG_GPR, fcml_bool x64_exp = FCML_FALSE ) { + _operandType = OT_REGISTER; + _register = Register( reg, size, type, x64_exp ); + } + +public: + + /** + * Returns true if operand is an immediate value operand. + * + * @return True if operand is an immediate value operand. + * @since 1.1.0 + */ + bool isImm() const { + return _operandType == OT_IMMEDIATE; + } + + /** + * Returns true if operand is a register operand. + * + * @return True if operand is a register operand. + * @since 1.1.0 + */ + bool isReg() const { + return _operandType == OT_REGISTER; + } + + /** + * Returns true if operand is an address operand. + * + * @return True if operand is an address operand. + * @since 1.1.0 + */ + bool isAddr() const { + return _operandType == OT_ADDRESS; + } + + /** + * Returns true if operand is a far pointer operand. + * + * @return True if operand is a far pointer operand. + * @since 1.1.0 + */ + bool isFar() const { + return _operandType == OT_FAR_POINTER; + } + + /** + * Gets reference to the constant address associated with the operand. + * + * @return The reference to the address. + * @since 1.1.0 + */ + const Address& getAddress() const { + return _address; + } + + /** + * Gets reference to the address associated with the operand. + * + * @return The reference to the address. + * @since 1.1.0 + */ + Address& getAddress() { + return _address; + } + + /** + * Sets a new address for the operand. + * + * @param address The new address. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setAddress( const Address &address ) { + _address = address; + return *this; + } + + /** + * Gets a reference to the constant far pointer instance associated with the address. + * + * @return The far pointer instance associated with the address. + * @since 1.1.0 + */ + const FarPointer& getFarPointer() const { + return _farPointer; + } + + /** + * Gets a reference to the far pointer instance associated with the address. + * + * @return The far pointer instance associated with the address. + * @since 1.1.0 + */ + FarPointer& getFarPointer() { + return _farPointer; + } + + /** + * Sets a new far pointer for the operand. + * + * @param farPointer The new far pointer instance. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setFarPointer( const FarPointer &farPointer ) { + _farPointer = farPointer; + return *this; + } + + /** + * Gets a reference to the constant immediate value associated with the operand. + * + * @return The immediate value. + * @since 1.1.0 + */ + const Integer& getImmediate() const { + return _immediate; + } + + /** + * Gets a reference to the immediate value associated with the operand. + * + * @return The immediate value. + * @since 1.1.0 + */ + Integer& getImmediate() { + return _immediate; + } + + /** + * Sets a new immediate value for the address. + * + * @param immediate The new immediate value. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setImmediate( const Integer &immediate ) { + _immediate = immediate; + return *this; + } + + /** + * Gets operand type. + * + * @return The operand type. + * @since 1.1.0 + */ + OperandType getOperandType() const { + return _operandType; + } + + /** + * Sets a new operand type. + * + * @param operandType The new operand type. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setOperandType( OperandType operandType ) { + _operandType = operandType; + return *this; + } + + /** + * Returns a reference to the constant register associated with the operand. + * + * @return The reference to the register associated with the operand. + * @since 1.1.0 + */ + const Register& getRegister() const { + return _register; + } + + /** + * Returns a reference to the register associated with the operand. + * + * @return The reference to the register associated with the operand. + * @since 1.1.0 + */ + Register& getRegister() { + return _register; + } + + /** + * Sets a new register for the operand. + * + * @param reg The new register. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setRegister( const Register ® ) { + this->_register = reg; + return *this; + } + + /** + * Gets hits associated with the operand. + * + * @return The hits associated with the operand. + * @since 1.1.0 + */ + fcml_hints getHints() const { + return _hints; + } + + /** + * Sets new operand level hits for the operand. + * + * @param hints The new hits to be set. + * @return The operand itself. + * @since 1.1.0 + */ + Operand& setHints( fcml_hints hints ) { + _hints = hints; + return *this; + } + + /** + * Gets constant decorators associated with the operand. + * + * @return The decorators associated with the operand. + * @since 1.2.0 + */ + const Decorators& getDecorators() const { + return _decorators; + } + + /** + * Gets decorators associated with the operand. + * + * @return The decorators associated with the operand. + * @since 1.2.0 + */ + Decorators& getDecorators() { + return _decorators; + } + + /** + * Sets new operand decorators for the operand. + * + * @param decorators The new decorators to be set. + * @return The operand itself. + * @since 1.2.0 + */ + Operand& setDecorators(const Decorators& decorators) { + _decorators = decorators; + return *this; + } + + // Hints + + /** + * Returns information if the operand is multimedia one or not. For more details about the + * multimedia operand head over to the manual pages. + * + * @return true if it's a multimedia operand. + * @since 1.1.0 + */ + bool isMultimedia() const { + return _hints & FCML_OP_HINT_MULTIMEDIA_INSTRUCTION; + } + + /** + * Returns true if it's an displacement relative address. + * + * @return True if it's an displacement relative address. + * @since 1.1.0 + */ + bool isDisRelativeAddress() const { + return ( _hints & FCML_OP_HINT_DISPLACEMENT_RELATIVE_ADDRESS ) ? true : false; + } + + /** + * Returns true if it's pseudo opcode operand. More information + * about pseudo opcodes in the manual. + * + * @return True if it's pseudo opcode operand. + * @since 1.1.0 + */ + bool isPseudoOpcode() const { + return ( _hints & FCML_OP_HINT_PSEUDO_OPCODE ) ? true : false; + } + + /** + * Returns true if it's an absolute offset being set in the operand. + * + * @return True in case of absolute addressing being used. + * @since 1.1.0 + */ + bool isAbsoluteAddressing() const { + return ( _hints & FCML_OP_HINT_ABSOLUTE_ADDRESSING ) ? true : false; + } + + /** + * Returns true is relative addressing is used. + * + * @return True in case of relative addressing. + * @since 1.1.0 + */ + bool isRelativeAddressing() const { + return ( _hints & FCML_OP_HINT_RELATIVE_ADDRESSING ) ? true : false; + } + + /** + * Returns true if the SIB byte is used. + * + * @return True if the SIB byte is used. + * @since 1.1.0 + */ + bool isSIBEncoding() const { + return ( _hints & FCML_OP_HINT_SIB_ENCODING ) ? true : false; + } + +public: + + /** + * A casting operator. + * @since 1.1.0 + */ + operator const Integer&() const { + return _immediate; + } + + /** + * A casting operator. + * @since 1.1.0 + */ + operator const FarPointer&() const { + return _farPointer; + } + + /** + * A casting operator. + * @since 1.1.0 + */ + operator const Address&() const { + return _address; + } + + /** + * A casting operator. + * @since 1.1.0 + */ + operator const Register&() const { + return _register; + } + +private: + + /** Operand hints */ + fcml_hints _hints; + /** Operand type */ + OperandType _operandType; + /** Describes immediate operand */ + Integer _immediate; + /** Describes far pointer. */ + FarPointer _farPointer; + /** Describes address. */ + Address _address; + /** Describes register. */ + Register _register; + /** Operand decorators. + * since 1.2.0 + */ + Decorators _decorators; + +}; + +/** Operand builder. + * A builder that exposes various factory methods that can be used to create + * several types of the instruction operands. These methods are very simple + * so no API documentation has been provided for now. Just take a look at + * the source code. + * + * @since 1.1.0 + */ +class OB { +public: + + /** + * Factory method which builds an empty operand. + * @return The empty operand. + * @since 1.1.0 + */ + static Operand undef() { + return Operand(); + } + + /** + * Factory method which builds an immediate operand. + * @return The immediate operand. + * @since 1.1.0 + */ + static Operand imm( const Integer &imm ) { + return Operand( imm ); + } + + /** + * Factory method which builds a far pointer operand. + * @param seg A segment selector. + * @param addr An 16-bit offset value. + * @return The far pointer operand. + * @since 1.1.0 + */ + static Operand far_ptr( fcml_uint16_t seg, fcml_int16_t addr ) { + return Operand( FarPointer( seg, addr ) ); + } + + /** + * Factory method which builds a far pointer operand. + * @param seg A segment selector. + * @param addr An 32-bit offset value. + * @return The far pointer operand. + * @since 1.1.0 + */ + static Operand far_ptr( fcml_uint16_t seg, fcml_int32_t addr ) { + return Operand( FarPointer( seg, addr ) ); + } + + /** + * Factory method which builds a far pointer operand. + * @param pointer A far pointer instance. + * @return The far pointer operand. + * @since 1.1.0 + */ + static Operand far_ptr( const FarPointer &pointer ) { + return Operand( pointer ); + } + + /** + * Factory method which builds an address operand. + * @param address An address instance. + * @return The address operand. + * @since 1.1.0 + */ + static Operand addr( const Address &address ) { + return Operand( address ); + } + + /** + * Factory method which builds an address operand. + * @param offset An offset instance. + * @param sizeOperator An optional size operator. + * @return The address operand. + * @since 1.1.0 + */ + static Operand off( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Operand( Address( offset, sizeOperator ) ); + } + + /** + * Factory method which builds an offset based address operand with byte size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + static Operand offb( const Integer &offset ) { + return Operand( Address( offset, FCML_DS_8 ) ); + } + + /** + * Factory method which builds an offset based address operand with word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + static Operand offw( const Integer &offset ) { + return Operand( Address( offset, FCML_DS_16 ) ); + } + + /** + * Factory method which builds an offset based address operand with double word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + static Operand offd( const Integer &offset ) { + return Operand( Address( offset, FCML_DS_32 ) ); + } + + /** + * Factory method which builds an offset based address operand with quadro word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + static Operand offq( const Integer &offset ) { + return Operand( Address( offset, FCML_DS_64 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and optional size operator. + * @param effectiveAddress The effective address. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addr( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Operand( Address( effectiveAddress, sizeOperator ) ); + } + + /** + * Factory method which creates address type operand for given effective address and byte size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrb( const EffectiveAddress &effectiveAddress ) { + return Operand( Address( effectiveAddress, FCML_DS_8 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrw( const EffectiveAddress &effectiveAddress ) { + return Operand( Address( effectiveAddress, FCML_DS_16 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and double word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrd( const EffectiveAddress &effectiveAddress ) { + return Operand( Address( effectiveAddress, FCML_DS_32 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and quadro word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrq( const EffectiveAddress &effectiveAddress ) { + return Operand( Address( effectiveAddress, FCML_DS_64 ) ); + } + + /** + * Factory method which creates address type operand for given segment selector, effective address and optional size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addr( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return Operand( Address( effectiveAddress, segmentSelector, sizeOperator ) ); + } + + /** + * Factory method which creates address type operand for given effective address and byte size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrb( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_8 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and word size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrw( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_16 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and double word size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrd( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_32 ) ); + } + + /** + * Factory method which creates address type operand for given effective address and quadro word size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + static Operand addrq( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + return Operand( Address( effectiveAddress, segmentSelector, FCML_DS_64 ) ); + } + + /** + * Factory method which creates an register based operator for given register. + * @param reg The register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand reg( const Register ® ) { + return Operand( reg ); + } + + /** + * Factory method which creates an register based operator for given parameters. + * @param reg The FCML register number. + * @param size The register size. + * @param type The register type. + * @param x64_exp See manual for more information. + * @return The created operator. + * @since 1.1.0 + */ + static Operand reg( fcml_uint8_t reg, fcml_usize size, Register::RegisterType type = Register::REG_GPR, fcml_bool x64_exp = FCML_FALSE ) { + return Operand( Register( reg, size, type, x64_exp ) ); + } + + /** + * Factory method which creates an effective address based operator for a displacement and optional size operator. + * @param displacement The displacement value. + * @param sizeOperator The size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a displacement and byte size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Integer &displacement ) { + return addr( EffectiveAddress( displacement ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a displacement and word size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Integer &displacement ) { + return addr( EffectiveAddress( displacement ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a displacement and double word size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Integer &displacement ) { + return addr( EffectiveAddress( displacement ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a displacement and quadro byte size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Integer &displacement ) { + return addr( EffectiveAddress( displacement ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for a base register and optional size operator. + * @param base The base register. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &base, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( base ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a base register and byte size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &base ) { + return addr( EffectiveAddress( base ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a base register and word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &base ) { + return addr( EffectiveAddress( base ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a base register and double word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &base ) { + return addr( EffectiveAddress( base ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a base register and quadro word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &base ) { + return addr( EffectiveAddress( base ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, displacement and optional size operator. + * @param base The base register. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &base, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( base, displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a base register, displacement and byte size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &base, const Integer &displacement ) { + return addr( EffectiveAddress( base, displacement ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, displacement and word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &base, const Integer &displacement ) { + return addr( EffectiveAddress( base, displacement ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, displacement and double word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &base, const Integer &displacement ) { + return addr( EffectiveAddress( base, displacement ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, displacement and quadro word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &base, const Integer &displacement ) { + return addr( EffectiveAddress( base, displacement ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for an index register, scaleFactor, displacement and optional size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( index, scaleFactor, displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for an index register, scaleFactor, displacement and byte size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for an index register, scaleFactor, displacement and word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for an index register, scaleFactor, displacement and double word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for an index register, scaleFactor, displacement and quadro word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register and optional size operator. + * @param base The base register. + * @param index The index register. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &base, const Register &index, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( base, index ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register and byte size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &base, const Register &index ) { + return addr( EffectiveAddress( base, index ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register and word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &base, const Register &index ) { + return addr( EffectiveAddress( base, index ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register and double word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &base, const Register &index ) { + return addr( EffectiveAddress( base, index ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register and quadro word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &base, const Register &index ) { + return addr( EffectiveAddress( base, index ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and optional size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( base, index, scaleFactor ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and byte size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and double word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and quadro word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + return addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_64 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and optional size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + static Operand eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + return addr( EffectiveAddress( base, index, scaleFactor, displacement ), sizeOperator ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and byte size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_8 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_16 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and double word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_32 ); + } + + /** + * Factory method which creates an effective address based operator for a base register, index register, scale factor and quardo word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + static Operand effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + return addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_64 ); + } + +}; + +/** Instruction condition. + * + * It's counterpart to the fcml_st_condition structure. + * + * @since 1.1.0 + */ +class Condition { + +public: + + /** See fcml_st_condition for more details. + * @since 1.1.0 + */ + enum ConditionType { + /** 0 Overflow*/ + CONDITION_O = FCML_CONDITION_O, + /** 1 Below*/ + CONDITION_B = FCML_CONDITION_B, + /** 2 Equal*/ + CONDITION_E = FCML_CONDITION_E, + /** 3 Below or equal*/ + CONDITION_BE = FCML_CONDITION_BE, + /** 4 Sign*/ + CONDITION_S = FCML_CONDITION_S, + /** 5 Parity*/ + CONDITION_P = FCML_CONDITION_P, + /** 6 Less than*/ + CONDITION_L = FCML_CONDITION_L, + /** 7 Less than or equal to*/ + CONDITION_LE = FCML_CONDITION_LE + }; + + /** + * Creates an empty condition. + * @since 1.1.0 + */ + Condition() : + _conditionType(CONDITION_O), + _isNegation(false) { + } + + /** + * Creates a condition for given parameters. + * + * @param type A condition type. + * @param negation True in order to negate condition. + * @since 1.1.0 + */ + Condition( ConditionType type, bool negation = false ) : + _conditionType( type ), + _isNegation( negation ) { + } + +public: + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isO() const { + return check( CONDITION_O ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition O() { + const Condition condition( CONDITION_O ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNO() const { + return check( CONDITION_O, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NO() { + const Condition condition( CONDITION_O ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isB() const { + return check( CONDITION_B ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition B() { + const Condition condition( CONDITION_B ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNB() const { + return check( CONDITION_B, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NB() { + const Condition condition( CONDITION_B, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNAE() const { + return check( CONDITION_B ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NAE() { + const Condition condition( CONDITION_B ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isAE() const { + return check( CONDITION_B, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition AE() { + const Condition condition( CONDITION_B, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isC() const { + return check( CONDITION_B ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition C() { + const Condition condition( CONDITION_B ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNC() const { + return check( CONDITION_B, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NC() { + const Condition condition( CONDITION_B, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isE() const { + return check( CONDITION_E ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition E() { + const Condition condition( CONDITION_E ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isZ() const { + return check( CONDITION_E ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition Z() { + const Condition condition( CONDITION_E ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNE() const { + return check( CONDITION_E, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NE() { + const Condition condition( CONDITION_E, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNZ() const { + return check( CONDITION_E, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NZ() { + const Condition condition( CONDITION_E, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isBE() const { + return check( CONDITION_BE ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition BE() { + const Condition condition( CONDITION_BE ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNA() const { + return check( CONDITION_BE ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NA() { + const Condition condition( CONDITION_BE ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNBE() const { + return check( CONDITION_BE, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NBE() { + const Condition condition( CONDITION_BE, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isA() const { + return check( CONDITION_BE, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition A() { + const Condition condition( CONDITION_BE, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isS() const { + return check( CONDITION_S ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition S() { + const Condition condition( CONDITION_S ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNS() const { + return check( CONDITION_S, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NS() { + const Condition condition( CONDITION_S, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isP() const { + return check( CONDITION_P ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition P() { + const Condition condition( CONDITION_P ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isPE() const { + return check( CONDITION_P ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition PE() { + const Condition condition( CONDITION_P ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNP() const { + return check( CONDITION_P, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NP() { + const Condition condition( CONDITION_P, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isPO() const { + return check( CONDITION_P, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition PO() { + const Condition condition( CONDITION_P, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isL() const { + return check( CONDITION_L ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition L() { + const Condition condition( CONDITION_L ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNGE() const { + return check( CONDITION_L ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NGE() { + const Condition condition( CONDITION_L ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNL() const { + return check( CONDITION_L, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NL() { + const Condition condition( CONDITION_L, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isGE() const { + return check( CONDITION_L, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition GE() { + const Condition condition( CONDITION_L, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isLE() const { + return check( CONDITION_LE ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition LE() { + const Condition condition( CONDITION_LE ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNG() const { + return check( CONDITION_LE ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NG() { + const Condition condition( CONDITION_LE ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isNLE() const { + return check( CONDITION_LE, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition NLE() { + const Condition condition( CONDITION_LE, true ); + return condition; + } + + /** + * Gets true the condition is of a given type. + * @return True the condition is of a given type. + * @since 1.1.0 + */ + bool isG() const { + return check( CONDITION_LE, true ); + } + + /** + * Factory method which creates a condition of a given type. + * @return The condition with a type described by the method name. + * @since 1.1.0 + */ + static const Condition G() { + const Condition condition( CONDITION_LE, true ); + return condition; + } + +public: + + /** + * Checks if two condition are equal. + * + * @param cond The condition to be compared to the current one. + * @return True if they are equal. + * @since 1.1.0 + */ + bool operator==( const Condition &cond ) const { + return cond._conditionType == _conditionType && cond._isNegation == _isNegation; + } + + /** + * Checks if two condition are equal. + * + * @param cond The condition to be compared to the current one. + * @return True if they are NOT equal. + * @since 1.1.0 + */ + bool operator!=( const Condition &cond ) const { + return !(*this == cond); + } + +public: + + /** + * Gets a type of the condition. + * + * @return The type of the condition. + * @since 1.1.0 + */ + ConditionType getConditionType() const { + return _conditionType; + } + + /** + * Sets condition type. + * + * @param conditionType The condition type to be set. + * @since 1.1.0 + */ + Condition& setConditionType( ConditionType conditionType ) { + _conditionType = conditionType; + return *this; + } + + /** + * Returns true if condition is negated. + * + * @return True if condition is negated. + * @since 1.1.0 + */ + bool isNegation() const { + return _isNegation; + } + + /** + * Sets negation flag for the condition. + * + * @param isNegation The negation flag. + * @since 1.1.0 + */ + Condition& setNegation( bool isNegation ) { + _isNegation = isNegation; + return *this; + } + +private: + + /** + * Checks if the condition is of given type and negation flag. + * + * @param type The condition type. + * @param negation The negation flag. + * @return True if the condition has the same type and negation set. + * @since 1.1.0 + */ + bool check( ConditionType type, bool negation = false ) const { + return _conditionType == type && _isNegation == negation; + } + +private: + + /* Condition type.*/ + ConditionType _conditionType; + /* True if condition should be negated.*/ + bool _isNegation; + +}; + +/** Describes an instruction. + * + * It's counterpart to the fcml_st_instruction structure. + * @since 1.1.0 + */ +class Instruction { +public: + + /** + * Creates an empty instruction. + * @since 1.1.0 + */ + Instruction() : + _prefixes(0), + _hints(FCML_HINT_NO_HINTS), + _isConditional(false), + _operandsCount(0) { + } + + /** + * Creates an empty instruction for given mnemonic. + * + * @param mnemonic The mnemonic for the newly created instruction. + * @since 1.1.0 + */ + Instruction( const fcml_cstring &mnemonic ) : + _prefixes(0), + _hints(FCML_HINT_NO_HINTS), + _mnemonic(mnemonic), + _isConditional(false), + _operandsCount(0) { + } + +public: + + /** + * Adds a new operand to the instruction. + * + * @param operand The operand to be added to the instruction. + * @throw IllegalStateException No more operands allowed. + * @since 1.1.0 + */ + void add( const Operand &operand ) { + if( _operandsCount == FCML_OPERANDS_COUNT ) { + throw IllegalStateException( FCML_TEXT( "No more operands allowed." ) ); + } + _operands[_operandsCount++] = operand; + } + + /** + * Sets a new oeprand for the instruction at given index. + * + * @param operand The operand to be set. + * @param index The index operand should be set at. + * @throw IllegalStateException Operand's number exceeds maximal number of operands allowed. + * @since 1.1.0 + */ + void setOperand( const Operand &operand, fcml_int index ) { + if( index >= FCML_OPERANDS_COUNT ) { + throw IllegalStateException( FCML_TEXT( "Operand's number exceeds maximal number of operands allowed." ) ); + } + _operands[index] = operand; + } + + /** + * Gets reference to the constant operand at given index. + * + * @param index The operand index. + * @return The operand available at given index. + * @since 1.1.0 + */ + const Operand & operator[]( fcml_int index ) const { + checkArrayAccess(index); + return _operands[index]; + } + + /** + * Gets reference to the operand at given index. + * + * @param index The operand index. + * @return The operand available at given index. + * @since 1.1.0 + */ + Operand & operator[]( fcml_int index ) { + checkArrayAccess(index); + return _operands[index]; + } + + /** + * Cleans the instruction by removing all operands from it. + * @since 1.1.0 + */ + void clean() { + for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) { + // Clean the operand. + _operands[i] = Operand(); + } + _operandsCount = 0; + } + +public: + + /** + * Gets a pointer to the constant condition associated with the instruction. + * + * @return A reference to the condition. + * @since 1.1.0 + */ + const Condition& getCondition() const { + return _condition; + } + + /** + * Gets a pointer to the condition associated with the instruction. + * + * @return A reference to the condition. + * @since 1.1.0 + */ + Condition& getCondition() { + return _condition; + } + + /** + * Sets a new condition for the instruction. + * + * @param condition The condition to be set for the instruction. + * @return The instruction itself. + * @since 1.1.0 + */ + Instruction& setCondition( const Condition &condition ) { + _condition = condition; + return *this; + } + + /** + * Gets instruction level hits associated with the instruction. + * + * @return The instruction level hits associated with the instruction. + * @since 1.1.0 + */ + fcml_hints getHints() const { + return _hints; + } + + /** + * Sets new instruction hints. + * + * @param hints The hints to be set. + * @return The instruction itself. + * @since 1.1.0 + */ + Instruction& setHints( fcml_hints hints ) { + _hints = hints; + return *this; + } + + /** + * Gets true if it's a conditional instruction. + * + * @return True in case of the conditional instruction. + * @since 1.1.0 + */ + bool isConditional() const { + return _isConditional; + } + + /** + * Sets conditional flag for the instruction. + * + * @param isConditional Set to true in order to mark instruction as conditional one. + * @return The instruction itself. + * @since 1.1.0 + */ + Instruction& setConditional( bool isConditional ) { + _isConditional = isConditional; + return *this; + } + + /** + * Gets the mnemonic associated with the instruction. + * + * @return The mnemonic associated with the instruction. + * @since 1.1.0 + */ + const fcml_cstring& getMnemonic() const { + return _mnemonic; + } + + /** + * Sets a new mnemonic for the instruction. + * + * @param mnemonic The new mnemonic. + * @return The instruction itself. + * @since 1.1.0 + */ + Instruction& setMnemonic( const fcml_cstring &mnemonic ) { + _mnemonic = mnemonic; + return *this; + } + + /** + * Gets number of operands associated with the instruction. + * + * @return The number of operands in the instruction. + * @since 1.1.0 + */ + fcml_int getOperandsCount() const { + return _operandsCount; + } + + /** + * Sets number of operands available in the instruction. + * + * @param operandsCount Number of operands. + * @return The number of instructions. + * @since 1.1.0 + */ + Instruction& setOperandsCount( fcml_int operandsCount ) { + _operandsCount = operandsCount; + return *this; + } + + /** + * Gets prefixes associated with the instruction. + * + * @return The prefixes. + * @since 1.1.0 + */ + fcml_prefixes getPrefixes() const { + return _prefixes; + } + + /** + * Sets a new set of prefixes for the instruction. + * + * @param prefixes The set of prefixes to be set for the instruction. + * @return The instruction itself. + * @since 1.1.0 + */ + Instruction& setPrefixes( fcml_prefixes prefixes ) { + _prefixes = prefixes; + return *this; + } + +public: + + // Helper methods to identify prefixes and hints. + + /** + * Returns true if lock prefix is set. + * @return True if lock prefix is set. + * @since 1.1.0 + */ + bool isLock() const { + return ( _prefixes & FCML_PREFIX_LOCK ) ? true : false; + } + + /** + * Returns true if repne prefix is set. + * @return True if repne prefix is set. + * @since 1.1.0 + */ + bool isRepne() const { + return ( _prefixes & FCML_PREFIX_REPNE ) ? true : false; + } + + /** + * Returns true if lock repnz is set. + * @return True if lock repnz is set. + * @since 1.1.0 + */ + bool isRepnz() const { + return ( _prefixes & FCML_PREFIX_REPNZ ) ? true : false; + } + + /** + * Returns true if rep prefix is set. + * @return True if rep prefix is set. + * @since 1.1.0 + */ + bool isRep() const { + return ( _prefixes & FCML_PREFIX_REP ) ? true : false; + } + + /** + * Returns true if repe prefix is set. + * @return True if repe prefix is set. + * @since 1.1.0 + */ + bool isRepe() const { + return ( _prefixes & FCML_PREFIX_REPE ) ? true : false; + } + + /** + * Returns true if repz prefix is set. + * @return True if repz prefix is set. + * @since 1.1.0 + */ + bool isRepz() const { + return ( _prefixes & FCML_PREFIX_REPZ ) ? true : false; + } + + /** + * Returns true if xacquire prefix is set. + * @return True if xacquire prefix is set. + * @since 1.1.0 + */ + bool isXAcquire() const { + return ( _prefixes & FCML_PREFIX_XACQUIRE ) ? true : false; + } + + /** + * Returns true if xrelease prefix is set. + * @return True if xrelease prefix is set. + * @since 1.1.0 + */ + bool isXRelease() const { + return ( _prefixes & FCML_PREFIX_XRELEASE ) ? true : false; + } + + /** + * Returns true if branch_hint prefix is set. + * @return True if branch_hint prefix is set. + * @since 1.1.0 + */ + bool isBranchHint() const { + return ( _prefixes & FCML_PREFIX_BRANCH_HINT ) ? true : false; + } + + /** + * Returns true if no_branch_hint prefix is set. + * @return True if no_branch_hint prefix is set. + * @since 1.1.0 + */ + bool isNoBranchHint() const { + return ( _prefixes & FCML_PREFIX_NOBRANCH_HINT ) ? true : false; + } + + /** + * Returns true if far pointer hint is set. + * @return True if far pointer hint is set. + * @since 1.1.0 + */ + bool isFarPointer() const { + return ( _hints & FCML_HINT_FAR_POINTER ) ? true : false; + } + + /** + * Returns true if near pointer hint is set. + * @return True if near pointer hint is set. + * @since 1.1.0 + */ + bool isNearPointer() const { + return ( _hints & FCML_HINT_NEAR_POINTER ) ? true : false; + } + + /** + * Returns true if long form pointer hint is set. See manual for more information about this hint. + * @return True if long form pointer hint is set. + * @since 1.1.0 + */ + bool isLongFormPointer() const { + return ( _hints & FCML_HINT_LONG_FORM_POINTER ) ? true : false; + } + + /** + * Returns true if indirect pointer hint is set. + * @return True if indirect pointer hint is set. + * @since 1.1.0 + */ + bool isIndirectPointer() const { + return ( _hints & FCML_HINT_INDIRECT_POINTER ) ? true : false; + } + + /** + * Returns true if direct pointer hint is set. + * @return True if direct pointer hint is set. + * @since 1.1.0 + */ + bool isDirectPointer() const { + return ( _hints & FCML_HINT_DIRECT_POINTER ) ? true : false; + } + +private: + + /** + * Throws if given operand index is wrong. + * @throw BadArgumentException Index exceeds the allowed number of operands. + * @remarks An internal API, not intended to be used outside. + */ + void checkArrayAccess( fcml_int index) const { + if( index < 0 || index >= FCML_OPERANDS_COUNT ) { + throw BadArgumentException( FCML_TEXT( "Index exceeds the allowed number of operands." ) ); + } + } + +private: + + /** Describes explicit instruction prefixes. @ref PREFIX_GROUP "List of explicit prefixes." */ + fcml_prefixes _prefixes; + /** Holds instruction level hints. */ + fcml_hints _hints; + /** Dialect-dependent instruction mnemonic. @see fcml_en_instruction_hints */ + fcml_cstring _mnemonic; + /** True for conditional instructions. */ + bool _isConditional; + /** Describes condition used by assembled/disassembled conditional instruction. */ + Condition _condition; + /** Fixed size array of instruction operands. */ + Operand _operands[FCML_OPERANDS_COUNT]; + /** Number of operands defined for instruction. */ + fcml_int _operandsCount; + +}; + +/** An instruction builder. + * + * A classic builder that can be used to prepare instruction in a + * more convenient way than doing it manually using setters. + * + * @since 1.1.0 + */ +class IB { + +public: + + /** Creates builder for the given mnemonic. + * + * @param mnemonic Mnemonic for the instruction being created. + * @since 1.1.0 + */ + IB( const fcml_cstring &mnemonic ) : + _hints(FCML_HINT_NO_HINTS), + _prefixes(0), + _mnemonic(mnemonic), + _operandsCount(0) { + } + + /** + * Creates builder for the given mnemonic and prefixes. + * + * @param prefixes The prefixes for the new instruction. + * @param mnemonic Mnemonic for the instruction being created. + * @since 1.1.0 + */ + IB( fcml_prefixes prefixes, const fcml_cstring &mnemonic ) : + _hints(FCML_HINT_NO_HINTS), + _prefixes(prefixes), + _mnemonic(mnemonic), + _operandsCount(0) { + } + + /** + * Creates an instruction builder for given mnemonic and hints. + * + * @param mnemonic The instruction mnemonic. + * @param hints The instruction hints. + * @since 1.1.0 + */ + IB( const fcml_cstring &mnemonic, fcml_hints hints) : + _hints(hints), + _prefixes(0), + _mnemonic(mnemonic), + _operandsCount(0) { + } + + /** + * Creates an instruction builder for given prefixes, mnemonic and hints. + * + * @param prefixes The instruction prefixes. + * @param mnemonic The instruction mnemonic. + * @param hints The instruction hints. + * @since 1.1.0 + */ + IB( fcml_prefixes prefixes, const fcml_cstring &mnemonic, fcml_hints hints ) : + _hints(hints), + _prefixes(prefixes), + _mnemonic(mnemonic), + _operandsCount(0) { + } + + /** + * Converts builder to the instruction instance. + * @since 1.1.0 + * @return The built instruction. + */ + operator Instruction() const { + return build(); + } + + /** + * Builds an instruction instance for the current state of the builder. + * + * @return The built instruction instance. + * @since 1.1.0 + */ + Instruction build() const { + Instruction instruction(_mnemonic); + instruction.setHints(_hints); + instruction.setPrefixes(_prefixes); + instruction.setOperandsCount(_operandsCount); + for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) { + instruction.setOperand( _operands[i], i ); + } + return instruction; + } + + /** + * Sets a next operand for the instruction. + * + * @param operand The next operand to be added to the instruction. + * @throw IllegalStateException No more operands allowed. + * @since 1.1.0 + */ + void op( const Operand &operand ) { + if( _operandsCount == FCML_OPERANDS_COUNT ) { + throw IllegalStateException( FCML_TEXT( "No more operands allowed." ) ); + } + _operands[_operandsCount++] = operand; + } + + /** + * Factory method that can be used to create instruction builder. + * + * @param mnemonic The mnemonic for the instruction builder. + * @return Instruction builder instance. + * @since 1.1.0 + */ + static IB inst( const fcml_cstring &mnemonic ) { + return IB(mnemonic); + } + + // Hints. + + /** + * Creates a hint instance described by the name of the method. Such a hint can be then used + * together with shift operator overridden by the builder in order to set an appropriate hint + * for the instruction being built. + * @return The hint indicator for the builder. + * @since 1.1.0 + */ + static const InstructionHint FAR_PTR() { + return InstructionHint::FAR_POINTER(); + } + + /** + * Sets a hint described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate hint set. + * @since 1.1.0 + */ + IB& farPtr() { + _hints |= FCML_HINT_FAR_POINTER; + return *this; + } + + /** + * Creates a hint instance described by the name of the method. Such a hint can be then used + * together with shift operator overridden by the builder in order to set an appropriate hint + * for the instruction being built. + * @return The hint indicator for the builder. + * @since 1.1.0 + */ + static const InstructionHint NEAR_PTR() { + return InstructionHint::NEAR_POINTER(); + } + + /** + * Sets a hint described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate hint set. + * @since 1.1.0 + */ + IB& nearPtr() { + _hints |= FCML_HINT_NEAR_POINTER; + return *this; + } + + /** + * Creates a hint instance described by the name of the method. Such a hint can be then used + * together with shift operator overridden by the builder in order to set an appropriate hint + * for the instruction being built. + * @return The hint indicator for the builder. + * @since 1.1.0 + */ + static const InstructionHint LONG_FORM_PTR() { + return InstructionHint::LONG_FORM_POINTER(); + } + + /** + * Sets a hint described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate hint set. + * @since 1.1.0 + */ + IB& longFormPtr() { + _hints |= FCML_HINT_LONG_FORM_POINTER; + return *this; + } + + /** + * Creates a hint instance described by the name of the method. Such a hint can be then used + * together with shift operator overridden by the builder in order to set an appropriate hint + * for the instruction being built. + * @return The hint indicator for the builder. + * @since 1.1.0 + */ + static const InstructionHint INDIRECT_PTR() { + return InstructionHint::INDIRECT_POINTER(); + } + + /** + * Sets a hint described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate hint set. + * @since 1.1.0 + */ + IB& indirectPtr() { + _hints |= FCML_HINT_INDIRECT_POINTER; + return *this; + } + + /** + * Creates a hint instance described by the name of the method. Such a hint can be then used + * together with shift operator overridden by the builder in order to set an appropriate hint + * for the instruction being built. + * @return The hint indicator for the builder. + * @since 1.1.0 + */ + static const InstructionHint DIRECT_PTR() { + return InstructionHint::DIRECT_POINTER(); + } + + /** + * Sets a hint described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate hint set. + * @since 1.1.0 + */ + IB& directPtr() { + _hints |= FCML_HINT_DIRECT_POINTER; + return *this; + } + + // Prefixes. + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix LOCK() { + return InstructionPrefix::LOCK(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& lock() { + _prefixes |= FCML_PREFIX_LOCK; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix REPNE() { + return InstructionPrefix::REPNE(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& repne() { + _prefixes |= FCML_PREFIX_REPNE; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix REPNZ() { + return InstructionPrefix::REPNZ(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& repnz() { + _prefixes |= FCML_PREFIX_REPNZ; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix REP() { + return InstructionPrefix::REP(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& rep() { + _prefixes |= FCML_PREFIX_REP; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix REPE() { + return InstructionPrefix::REPE(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& repe() { + _prefixes |= FCML_PREFIX_REPE; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix REPZ() { + return InstructionPrefix::REPZ(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& repz() { + _prefixes |= FCML_PREFIX_REPZ; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix XACQUIRE() { + return InstructionPrefix::XACQUIRE(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& xacquire() { + _prefixes |= FCML_PREFIX_XACQUIRE; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix XRELEASE() { + return InstructionPrefix::XRELEASE(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& xrelease() { + _prefixes |= FCML_PREFIX_XRELEASE; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix BRANCH() { + return InstructionPrefix::BRANCH_HINT(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& branchHint() { + _prefixes |= FCML_PREFIX_BRANCH_HINT; + return *this; + } + + /** + * Creates a prefix instance described by the name of the method. Such a prefix can be then used + * together with the shift operator overridden by the builder in order to set an appropriate prefix + * for the instruction being built. + * @return The prefix indicator for the builder. + * @since 1.1.0 + */ + static const InstructionPrefix NO_BRANCH() { + return InstructionPrefix::NOBRANCH_HINT(); + } + + /** + * Sets a prefix described by the name of the method for the instruction being built. + * @return The instruction builder with the appropriate prefix set. + * @since 1.1.0 + */ + IB& nobranchHint() { + _prefixes |= FCML_PREFIX_NOBRANCH_HINT; + return *this; + } + + /** + * Gets multimedia hint for the operand. + * @return The multimedia hint. + */ + static const OperandHint OP_MULTIMEDIA_HINT() { + return OperandHint::MULTIMEDIA(); + } + + /** + * Gets relative address hint for the operand. + * @return The multimedia hint. + */ + static const OperandHint OP_RELATIVE_ADDRESSING() { + return OperandHint::RELATIVE_ADDRESSING(); + } + + /** + * Gets absolute hint for the operand. + * @return The multimedia hint. + */ + static const OperandHint OP_ABSOLUTE_ADDRESSING() { + return OperandHint::ABSOLUTE_ADDRESSING(); + } + + /** + * Gets SIB encoding hint for the operand. + * @return The SIB encoding hint. + */ + static const OperandHint OP_SIB_ENCODING() { + return OperandHint::SIB_ENCODING(); + } + + /** + * Marks the lastly added operand as a multimedia one. + * @return The instruction builder itself. + */ + IB& operandMultimediaHint() { + set( OP_MULTIMEDIA_HINT() ); + return *this; + } + + /** + * Marks the lastly added address operand as a relative one. + * @return The instruction builder itself. + */ + IB& operandRelativeHint() { + set( OP_MULTIMEDIA_HINT() ); + return *this; + } + + /** + * Marks the lastly added address operand as a absolute one. + * @return The instruction builder itself. + */ + IB& operandAbsoluteHint() { + set( OP_MULTIMEDIA_HINT() ); + return *this; + } + + /** + * Sets preferred encoding to SIB for the lastly added ModR/M operand. + * @return The instruction builder itself. + */ + IB& operandSIBEncodingHint() { + set( OP_MULTIMEDIA_HINT() ); + return *this; + } + + // Operands. + + /** + * Adds an immediate operand. + * @return The immediate operand. + * @since 1.1.0 + */ + IB& imm( const Integer &imm ) { + sanityCheck(); + _operands[_operandsCount++].imm(imm); + return *this; + } + + /** + * Adds a far pointer operand. + * @param seg A segment selector. + * @param addr An 16-bit offset value. + * @return The far pointer operand. + * @since 1.1.0 + */ + IB& far_ptr( fcml_uint16_t seg, fcml_int16_t addr ) { + sanityCheck(); + _operands[_operandsCount++].far_ptr(seg, addr); + return *this; + } + + /** + * Adds a far pointer operand. + * @param seg A segment selector. + * @param addr An 32-bit offset value. + * @return The far pointer operand. + * @since 1.1.0 + */ + IB& far_ptr( fcml_uint16_t seg, fcml_int32_t addr ) { + sanityCheck(); + _operands[_operandsCount++].far_ptr(seg, addr); + return *this; + } + + /** + * Adds a far pointer operand. + * @param pointer A far pointer instance. + * @return The far pointer operand. + * @since 1.1.0 + */ + IB& far_ptr( const FarPointer &pointer ) { + sanityCheck(); + _operands[_operandsCount++].far_ptr( pointer ); + return *this; + } + + /** + * Adds an address operand. + * @param address An address instance. + * @return The address operand. + * @since 1.1.0 + */ + IB& addr( const Address &address ) { + sanityCheck(); + _operands[_operandsCount++].addr(address); + return *this; + } + + /** + * Adds an offset operand. + * @param offset An offset instance. + * @param sizeOperator An optional size operator. + * @return The address operand. + * @since 1.1.0 + */ + IB& off( const Integer &offset, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + sanityCheck(); + _operands[_operandsCount++].off( offset, sizeOperator ); + return *this; + } + + /** + * Adds an offset based address operand with byte size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + IB& offb( const Integer &offset ) { + sanityCheck(); + _operands[_operandsCount++].off( offset, FCML_DS_8 ); + return *this; + } + + /** + * Adds an offset based address operand with word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + IB& offw( const Integer &offset ) { + sanityCheck(); + _operands[_operandsCount++].off( offset, FCML_DS_16 ); + return *this; + } + + /** + * Adds an offset based address operand with double word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + IB& offd( const Integer &offset ) { + sanityCheck(); + _operands[_operandsCount++].off( offset, FCML_DS_32 ); + return *this; + } + + /** + * Adds an offset based address operand with quadro word size operator. + * @param offset An offset instance. + * @return The address operand. + * @since 1.1.0 + */ + IB& offq( const Integer &offset ) { + sanityCheck(); + _operands[_operandsCount++].off( offset, FCML_DS_64 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and optional size operator. + * @param effectiveAddress The effective address. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& addr( const EffectiveAddress &effectiveAddress, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, sizeOperator ); + return *this; + } + + /** + * Adds an address type operand for given effective address and byte size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrb( const EffectiveAddress &effectiveAddress ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_8 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrw( const EffectiveAddress &effectiveAddress ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_16 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and double word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrd( const EffectiveAddress &effectiveAddress ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_32 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and quadro word size operator. + * @param effectiveAddress The effective address. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrq( const EffectiveAddress &effectiveAddress ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, FCML_DS_64 ); + return *this; + } + + /** + * Adds an address type operand for given segment selector, effective address and optional size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& addr( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, sizeOperator ); + return *this; + } + + /** + * Adds an address type operand for given effective address and byte size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrb( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and byte size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrw( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and double word size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrd( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 ); + return *this; + } + + /** + * Adds an address type operand for given effective address and quadro word size operator. + * @param effectiveAddress The effective address. + * @param segmentSelector The segment selector. + * @return The created operator. + * @since 1.1.0 + */ + IB& addrq( const EffectiveAddress &effectiveAddress, const SegmentSelector &segmentSelector ) { + sanityCheck(); + _operands[_operandsCount++].addr( effectiveAddress, segmentSelector, FCML_DS_8 ); + return *this; + } + + /** + * Adds an an register based operator for given register. + * @param reg The register. + * @return The created operator. + * @since 1.1.0 + */ + IB& reg( const Register ® ) { + sanityCheck(); + _operands[_operandsCount++].reg( reg ); + return *this; + } + + /** + * Adds an an register based operator for given parameters. + * @param reg The FCML register number. + * @param size The register size. + * @param type The register type. + * @param x64_exp See manual for more information. + * @return The created operator. + * @since 1.1.0 + */ + IB& reg( fcml_uint8_t reg, fcml_usize size, Register::RegisterType type = Register::REG_GPR, fcml_bool x64_exp = FCML_FALSE ) { + sanityCheck(); + _operands[_operandsCount++].reg( Register( reg, size, type, x64_exp ) ); + return *this; + } + + /** + * Adds an an effective address based operator for a displacement and optional size operator. + * @param displacement The displacement value. + * @param sizeOperator The size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress(displacement), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a displacement and byte size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Integer &displacement ) { + next().addr( EffectiveAddress(displacement), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a displacement and word size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Integer &displacement ) { + next().addr( EffectiveAddress(displacement), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a displacement and double word size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Integer &displacement ) { + next().addr( EffectiveAddress(displacement), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a displacement and quadro byte size operator. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Integer &displacement ) { + next().addr( EffectiveAddress(displacement), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register and optional size operator. + * @param base The base register. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &base, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress(base), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register and byte size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &base ) { + next().addr( EffectiveAddress(base), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register and word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &base ) { + next().addr( EffectiveAddress(base), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register and double word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &base ) { + next().addr( EffectiveAddress(base), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register and quadro word size operator. + * @param base The base register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &base ) { + next().addr( EffectiveAddress(base), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, displacement and optional size operator. + * @param base The base register. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &base, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress( base, displacement ), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, displacement and byte size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &base, const Integer &displacement ) { + next().addr( EffectiveAddress( base, displacement ), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, displacement and word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &base, const Integer &displacement ) { + next().addr( EffectiveAddress( base, displacement ), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, displacement and double word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &base, const Integer &displacement ) { + next().addr( EffectiveAddress( base, displacement ), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, displacement and quadro word size operator. + * @param base The base register. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &base, const Integer &displacement ) { + next().addr( EffectiveAddress( base, displacement ), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for an index register, scaleFactor, displacement and optional size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress( index, scaleFactor, displacement ), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for an index register, scaleFactor, displacement and byte size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for an index register, scaleFactor, displacement and word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for an index register, scaleFactor, displacement and double word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for an index register, scaleFactor, displacement and quadro word size operator. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( index, scaleFactor, displacement ), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register and optional size operator. + * @param base The base register. + * @param index The index register. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &base, const Register &index, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress( base, index ), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register and byte size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &base, const Register &index ) { + next().addr( EffectiveAddress( base, index ), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register and word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &base, const Register &index ) { + next().addr( EffectiveAddress( base, index ), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register and double word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &base, const Register &index ) { + next().addr( EffectiveAddress( base, index ), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register and quadro word size operator. + * @param base The base register. + * @param index The index register. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &base, const Register &index ) { + next().addr( EffectiveAddress( base, index ), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and optional size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress( base, index, scaleFactor ), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and byte size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and double word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and quadro word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor ) { + next().addr( EffectiveAddress( base, index, scaleFactor ), FCML_DS_64 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and optional size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @param sizeOperator The optional size operator. + * @return The created operator. + * @since 1.1.0 + */ + IB& eff( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement, fcml_usize sizeOperator = FCML_DS_UNDEF ) { + next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), sizeOperator ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and byte size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effb( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_8 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effw( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_16 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and double word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effd( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_32 ); + return *this; + } + + /** + * Adds an an effective address based operator for a base register, index register, scale factor and quardo word size operator. + * @param base The base register. + * @param index The index register. + * @param scaleFactor The scale factor. + * @param displacement The displacement value. + * @return The created operator. + * @since 1.1.0 + */ + IB& effq( const Register &base, const Register &index, fcml_uint8_t scaleFactor, const Integer &displacement ) { + next().addr( EffectiveAddress( base, index, scaleFactor, displacement ), FCML_DS_64 ); + return *this; + } + + /** + * Adds an operand to the instruction being built. + * @param operand The operand to be added. + * @return The instruction builder with the new operand added to it. + * @since 1.1.0 + */ + IB& operator <<(const Operand &operand) { + next() = operand; + return *this; + } + + /** + * Adds a prefix to the instruction being built. + * @param prefix The prefix to be added. + * @return The instruction builder with the new prefix set for it. + * @since 1.1.0 + */ + IB& operator <<(const InstructionPrefix &prefix) { + return set(prefix); + } + + /** + * Adds an instruction level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + IB& operator <<(const InstructionHint &hint) { + return set( hint ); + } + + /** + * Adds an operand level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + IB& operator <<(const OperandHint &hint) { + return set( hint ); + } + + /** + * Adds a prefix to the instruction being built. + * @param prefix The prefix to be added. + * @return The instruction builder with the new prefix set for it. + * @since 1.1.0 + */ + IB& set( const InstructionPrefix &prefix ) { + _prefixes |= prefix._prefix; + return *this; + } + + /** + * Adds an instruction level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + IB& set( const InstructionHint &hint ) { + _hints |= hint._hint; + return *this; + } + + /** + * Adds an operand level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + IB& set( const OperandHint &hint ) { + if( _operandsCount == 0 ) { + throw IllegalStateException( FCML_TEXT( "There are no operands yet for the current instruction.." ) ); + } + _operands[_operandsCount-1].setHints( _operands[_operandsCount-1].getHints() | hint._hint ); + return *this; + } + +private: + + /** + * Gets the next instruction operand. + * @return A reference to the next instruction operand. + * @since 1.1.0 + */ + Operand& next() { + sanityCheck(); + return _operands[_operandsCount++]; + } + + /** + * Throws exception if there is no more space for new operands in the builder. + * @throw IllegalStateException Operand's number exceeds maximal number of operands allowed. + * @since 1.1.0 + */ + void sanityCheck() const { + if( _operandsCount == FCML_OPERANDS_COUNT ) { + throw IllegalStateException( FCML_TEXT( "Operand's number exceeds maximal number of operands allowed." ) ); + } + } + +private: + + /** Instruction hints. */ + fcml_hints _hints; + /** Instruction prefixes.*/ + fcml_prefixes _prefixes; + /** Instruction mnemonic. */ + fcml_cstring _mnemonic; + /** Number of operands available in the builder. */ + fcml_int _operandsCount; + /** Operands for the built instruction. */ + Operand _operands[FCML_OPERANDS_COUNT]; + +}; + +/** Two way conversion for common types. + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class TypeConverter { +public: + + static void convert( const fcml_st_entry_point &src, EntryPoint &dest ) { + dest.setIP( src.ip ); + dest.setOpMode( static_cast( src.op_mode ) ); + dest.setAddressSizeAttribute( src.address_size_attribute ); + dest.setOperandSizeAttribute( src.operand_size_attribute ); + } + + static void convert( const EntryPoint &src, fcml_st_entry_point &dest ) { + dest.ip = src.getIP(); + dest.op_mode = static_cast( src.getOpMode() ); + dest.address_size_attribute = src.getAddressSizeAttribute(); + dest.operand_size_attribute = src.getOperandSizeAttribute(); + } + + static void convert( const fcml_st_integer &src, Integer &dest ) { + dest.setInt8( src.int8 ); + dest.setInt16( src.int16 ); + dest.setInt32( src.int32 ); + dest.setInt64( src.int64 ); + dest.setSigned( src.is_signed ); + dest.setSize( src.size ); + } + + static void convert( const Integer &src, fcml_st_integer &dest ) { + dest.int8 = src.getInt8(); + dest.int16 = src.getInt16(); + dest.int32 = src.getInt32(); + dest.int64 = src.getInt64(); + dest.is_signed = src.isSigned(); + dest.size = src.getSize(); + } + + static void convert( const fcml_st_offset &src, Integer &dest ) { + dest.setInt16( src.off16 ); + dest.setInt32( src.off32 ); + dest.setInt64( src.off64 ); + dest.setSigned( src.is_signed ); + dest.setSize( src.size ); + } + + static void convert( const Integer &src, fcml_st_offset &dest ) { + dest.off16 = src.getSize() == FCML_DS_8 ? src.getInt8() : src.getInt16(); + dest.off32 = src.getInt32(); + dest.off64 = src.getInt64(); + dest.is_signed = src.isSigned(); + dest.size = src.getSize(); + } + + static void convert( const fcml_st_register &src, Register &dest ) { + dest.setReg( src.reg ); + dest.setSize( src.size ); + dest.setType( static_cast( src.type ) ); + dest.setX64Exp( src.x64_exp ? true : false ); + } + + static void convert( const Register &src, fcml_st_register &dest ) { + dest.reg = src.getReg(); + dest.size = src.getSize(); + dest.type = static_cast( src.getType() ); + dest.x64_exp = src.getX64Exp(); + } + + static void convert( const fcml_st_far_pointer &src, FarPointer &dest ) { + dest.setOffset16( src.offset16 ); + dest.setOffset32( src.offset32 ); + dest.setOffsetSize( src.offset_size ); + dest.setSegment( src.segment ); + } + + static void convert( const FarPointer &src, fcml_st_far_pointer &dest ) { + dest.offset16 = src.getOffset16(); + dest.offset32 = src.getOffset32(); + dest.offset_size = src.getOffsetSize(); + dest.segment = src.getSegment(); + } + + static void convert( const fcml_st_segment_selector &src, SegmentSelector &dest ) { + dest.setDefaultReg( src.is_default_reg ? true : false ); + convert( src.segment_selector, dest.getSegmentSelector() ); + } + + static void convert( const SegmentSelector &src, fcml_st_segment_selector &dest ) { + dest.is_default_reg = src.isDefaultReg(); + convert( src.getSegmentSelector(), dest.segment_selector ); + } + + static void convert( const fcml_st_effective_address &src, EffectiveAddress &dest ) { + convert( src.base, dest.getBase() ); + convert( src.index, dest.getIndex() ); + convert( src.displacement, dest.getDisplacement() ); + dest.setScaleFactor(src.scale_factor); + } + + static void convert( const EffectiveAddress &src, fcml_st_effective_address &dest ) { + convert( src.getBase(), dest.base ); + convert( src.getIndex(), dest.index ); + convert( src.getDisplacement(), dest.displacement ); + dest.scale_factor = src.getScaleFactor(); + } + + static void convert( const fcml_st_address &src, Address &dest ) { + dest.setAddressForm( static_cast( src.address_form ) ); + dest.setSizeOperator( src.size_operator ); + convert( src.segment_selector, dest.getSegmentSelector() ); + convert( src.effective_address, dest.getEffectiveAddress() ); + convert( src.offset, dest.getOffset() ); + } + + static void convert( const Address &src, fcml_st_address &dest ) { + dest.address_form = static_cast( src.getAddressForm() ); + dest.size_operator = src.getSizeOperator(); + convert( src.getSegmentSelector(), dest.segment_selector ); + convert( src.getEffectiveAddress(), dest.effective_address ); + convert( src.getOffset(), dest.offset ); + } + + static void convert(const fcml_st_operand &src, Operand &dest) { + dest.setHints(src.hints); + dest.setOperandType(static_cast(src.type)); + convert(src.address, dest.getAddress()); + convert(src.far_pointer, dest.getFarPointer()); + convert(src.immediate, dest.getImmediate()); + convert(src.reg, dest.getRegister()); + convert(src.decorators, dest.getDecorators()); + } + + static void convert(const Operand &src, fcml_st_operand &dest) { + dest.hints = src.getHints(); + dest.type = static_cast(src.getOperandType()); + convert(src.getAddress(), dest.address); + convert(src.getFarPointer(), dest.far_pointer); + convert(src.getImmediate(), dest.immediate); + convert(src.getRegister(), dest.reg); + convert(src.getDecorators(), dest.decorators); + } + + static void convert(const fcml_st_operand_decorators &src, + Decorators &dest) { + Nullable bcast; + bcast.setNotNull(FCML_TO_CPP_BOOL(src.bcast.is_not_null)); + bcast.setValue(src.bcast.value); + dest.setBcast(bcast); + Nullable er; + er.setNotNull(FCML_TO_CPP_BOOL(src.er.is_not_null)); + er.setValue(static_cast(src.er.value)); + dest.setEr(er); + dest.setZ(src.z); + dest.setSae(src.sae); + convert(src.operand_mask_reg, dest.getOpmaskReg()); + } + + static void convert(const Decorators &src, fcml_st_operand_decorators &dest) { + dest.bcast.is_not_null = src.getBcast().isNotNull(); + dest.bcast.value = src.getBcast().getValue(); + dest.er.is_not_null = src.getEr().isNotNull(); + dest.er.value = static_cast(src.getEr().getValue()); + dest.z = src.isZ(); + dest.sae = src.isSae(); + convert(src.getOpmaskReg(), dest.operand_mask_reg); + } + + static void convert( const fcml_st_condition &src, Condition &dest ) { + dest.setConditionType( static_cast( src.condition_type ) ); + dest.setNegation( src.is_negation ? true : false ); + } + + static void convert( const Condition &src, fcml_st_condition &dest ) { + dest.condition_type = static_cast( src.getConditionType() ); + dest.is_negation = src.isNegation(); + } + + static void convert( const fcml_st_instruction &src, Instruction &dest ) { + dest.setMnemonic( src.mnemonic ); + convert( src.condition, dest.getCondition() ); + dest.setHints( src.hints ); + dest.setPrefixes( src.prefixes ); + dest.setConditional( src.is_conditional ? true : false ); + for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) { + convert( src.operands[i], dest[i] ); + } + dest.setOperandsCount(src.operands_count); + } + + static void convert( const Instruction &src, fcml_st_instruction &dest ) { + // Bear in mind that you are responsible for freeing mnemonic duplicated here. + dest.mnemonic = Env::strDup( src.getMnemonic().c_str() ); + convert( src.getCondition(), dest.condition ); + dest.hints = src.getHints(); + dest.prefixes = src.getPrefixes(); + dest.is_conditional = src.isConditional(); + for( int i = 0; i < FCML_OPERANDS_COUNT; i++ ) { + convert( src[i], dest.operands[i] ); + } + dest.operands_count = src.getOperandsCount(); + } + + static void free( fcml_st_instruction &instruction ) { + if( instruction.mnemonic ) { + Env::strFree( instruction.mnemonic ); + instruction.mnemonic = NULL; + } + } +}; + +} + +#endif //FCML_COMMON_HPP_ diff --git a/dependencies/fcml/include/fcml_common_utils.h b/dependencies/fcml/include/fcml_common_utils.h new file mode 100644 index 0000000..29363ea --- /dev/null +++ b/dependencies/fcml/include/fcml_common_utils.h @@ -0,0 +1,660 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_common_utils.h + * + * Common general purpose utility functions. + * + * @copyright Copyright (C) 2010-2017 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_COMMON_UTILS_H_ +#define FCML_COMMON_UTILS_H_ + +#include "fcml_lib_export.h" + +#include "fcml_common.h" +#include "fcml_assembler.h" +#include "fcml_disassembler.h" +#include "fcml_instructions.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup REG_STRUCTURES_GROUP Registers + * Declarations of structures describing all available registers. + * @{ + */ + +extern LIB_EXPORT fcml_st_register fcml_reg_AL; +extern LIB_EXPORT fcml_st_register fcml_reg_AX; +extern LIB_EXPORT fcml_st_register fcml_reg_EAX; +extern LIB_EXPORT fcml_st_register fcml_reg_RAX; +extern LIB_EXPORT fcml_st_register fcml_reg_MM0; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM0; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM0; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM0; + +extern LIB_EXPORT fcml_st_register fcml_reg_CL; +extern LIB_EXPORT fcml_st_register fcml_reg_CX; +extern LIB_EXPORT fcml_st_register fcml_reg_ECX; +extern LIB_EXPORT fcml_st_register fcml_reg_RCX; +extern LIB_EXPORT fcml_st_register fcml_reg_MM1; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM1; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM1; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM1; + +extern LIB_EXPORT fcml_st_register fcml_reg_DL; +extern LIB_EXPORT fcml_st_register fcml_reg_DX; +extern LIB_EXPORT fcml_st_register fcml_reg_EDX; +extern LIB_EXPORT fcml_st_register fcml_reg_RDX; +extern LIB_EXPORT fcml_st_register fcml_reg_MM2; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM2; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM2; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM2; + +extern LIB_EXPORT fcml_st_register fcml_reg_BL; +extern LIB_EXPORT fcml_st_register fcml_reg_BX; +extern LIB_EXPORT fcml_st_register fcml_reg_EBX; +extern LIB_EXPORT fcml_st_register fcml_reg_RBX; +extern LIB_EXPORT fcml_st_register fcml_reg_MM3; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM3; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM3; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM3; + +extern LIB_EXPORT fcml_st_register fcml_reg_AH; +extern LIB_EXPORT fcml_st_register fcml_reg_SPL; +extern LIB_EXPORT fcml_st_register fcml_reg_SP; +extern LIB_EXPORT fcml_st_register fcml_reg_ESP; +extern LIB_EXPORT fcml_st_register fcml_reg_RSP; +extern LIB_EXPORT fcml_st_register fcml_reg_MM4; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM4; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM4; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM4; + +extern LIB_EXPORT fcml_st_register fcml_reg_CH; +extern LIB_EXPORT fcml_st_register fcml_reg_BPL; +extern LIB_EXPORT fcml_st_register fcml_reg_BP; +extern LIB_EXPORT fcml_st_register fcml_reg_EBP; +extern LIB_EXPORT fcml_st_register fcml_reg_RBP; +extern LIB_EXPORT fcml_st_register fcml_reg_MM5; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM5; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM5; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM5; + +extern LIB_EXPORT fcml_st_register fcml_reg_DH; +extern LIB_EXPORT fcml_st_register fcml_reg_SIL; +extern LIB_EXPORT fcml_st_register fcml_reg_SI; +extern LIB_EXPORT fcml_st_register fcml_reg_ESI; +extern LIB_EXPORT fcml_st_register fcml_reg_RSI; +extern LIB_EXPORT fcml_st_register fcml_reg_MM6; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM6; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM6; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM6; + +extern LIB_EXPORT fcml_st_register fcml_reg_BH; +extern LIB_EXPORT fcml_st_register fcml_reg_DIL; +extern LIB_EXPORT fcml_st_register fcml_reg_DI; +extern LIB_EXPORT fcml_st_register fcml_reg_EDI; +extern LIB_EXPORT fcml_st_register fcml_reg_RDI; +extern LIB_EXPORT fcml_st_register fcml_reg_MM7; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM7; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM7; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM7; + +extern LIB_EXPORT fcml_st_register fcml_reg_R8L; +extern LIB_EXPORT fcml_st_register fcml_reg_R8W; +extern LIB_EXPORT fcml_st_register fcml_reg_R8D; +extern LIB_EXPORT fcml_st_register fcml_reg_R8; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM8; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM8; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM8; + +extern LIB_EXPORT fcml_st_register fcml_reg_R9L; +extern LIB_EXPORT fcml_st_register fcml_reg_R9W; +extern LIB_EXPORT fcml_st_register fcml_reg_R9D; +extern LIB_EXPORT fcml_st_register fcml_reg_R9; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM9; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM9; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM9; + +extern LIB_EXPORT fcml_st_register fcml_reg_R10L; +extern LIB_EXPORT fcml_st_register fcml_reg_R10W; +extern LIB_EXPORT fcml_st_register fcml_reg_R10D; +extern LIB_EXPORT fcml_st_register fcml_reg_R10; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM10; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM10; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM10; + +extern LIB_EXPORT fcml_st_register fcml_reg_R11L; +extern LIB_EXPORT fcml_st_register fcml_reg_R11W; +extern LIB_EXPORT fcml_st_register fcml_reg_R11D; +extern LIB_EXPORT fcml_st_register fcml_reg_R11; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM11; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM11; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM11; + +extern LIB_EXPORT fcml_st_register fcml_reg_R12L; +extern LIB_EXPORT fcml_st_register fcml_reg_R12W; +extern LIB_EXPORT fcml_st_register fcml_reg_R12D; +extern LIB_EXPORT fcml_st_register fcml_reg_R12; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM12; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM12; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM12; + +extern LIB_EXPORT fcml_st_register fcml_reg_R13L; +extern LIB_EXPORT fcml_st_register fcml_reg_R13W; +extern LIB_EXPORT fcml_st_register fcml_reg_R13D; +extern LIB_EXPORT fcml_st_register fcml_reg_R13; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM13; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM13; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM13; + +extern LIB_EXPORT fcml_st_register fcml_reg_R14L; +extern LIB_EXPORT fcml_st_register fcml_reg_R14W; +extern LIB_EXPORT fcml_st_register fcml_reg_R14D; +extern LIB_EXPORT fcml_st_register fcml_reg_R14; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM14; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM14; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM14; + +extern LIB_EXPORT fcml_st_register fcml_reg_R15L; +extern LIB_EXPORT fcml_st_register fcml_reg_R15W; +extern LIB_EXPORT fcml_st_register fcml_reg_R15D; +extern LIB_EXPORT fcml_st_register fcml_reg_R15; +extern LIB_EXPORT fcml_st_register fcml_reg_XMM15; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM15; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM15; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM16; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM16; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM16; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM17; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM17; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM17; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM18; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM18; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM18; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM19; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM19; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM19; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM20; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM20; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM20; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM21; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM21; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM21; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM22; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM22; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM22; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM23; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM23; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM23; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM24; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM24; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM24; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM25; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM25; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM25; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM26; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM26; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM26; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM27; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM27; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM27; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM28; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM28; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM28; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM29; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM29; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM29; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM30; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM30; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM30; + +extern LIB_EXPORT fcml_st_register fcml_reg_XMM31; +extern LIB_EXPORT fcml_st_register fcml_reg_YMM31; +extern LIB_EXPORT fcml_st_register fcml_reg_ZMM31; + +extern LIB_EXPORT fcml_st_register fcml_reg_ES; +extern LIB_EXPORT fcml_st_register fcml_reg_CS; +extern LIB_EXPORT fcml_st_register fcml_reg_SS; +extern LIB_EXPORT fcml_st_register fcml_reg_DS; +extern LIB_EXPORT fcml_st_register fcml_reg_FS; +extern LIB_EXPORT fcml_st_register fcml_reg_GS; + +extern LIB_EXPORT fcml_st_register fcml_reg_ST0; +extern LIB_EXPORT fcml_st_register fcml_reg_ST1; +extern LIB_EXPORT fcml_st_register fcml_reg_ST2; +extern LIB_EXPORT fcml_st_register fcml_reg_ST3; +extern LIB_EXPORT fcml_st_register fcml_reg_ST4; +extern LIB_EXPORT fcml_st_register fcml_reg_ST5; +extern LIB_EXPORT fcml_st_register fcml_reg_ST6; +extern LIB_EXPORT fcml_st_register fcml_reg_ST7; + +extern LIB_EXPORT fcml_st_register fcml_reg_CR0; +extern LIB_EXPORT fcml_st_register fcml_reg_CR2; +extern LIB_EXPORT fcml_st_register fcml_reg_CR3; +extern LIB_EXPORT fcml_st_register fcml_reg_CR4; +extern LIB_EXPORT fcml_st_register fcml_reg_CR8; + +extern LIB_EXPORT fcml_st_register fcml_reg_DR0; +extern LIB_EXPORT fcml_st_register fcml_reg_DR1; +extern LIB_EXPORT fcml_st_register fcml_reg_DR2; +extern LIB_EXPORT fcml_st_register fcml_reg_DR3; +extern LIB_EXPORT fcml_st_register fcml_reg_DR4; +extern LIB_EXPORT fcml_st_register fcml_reg_DR5; +extern LIB_EXPORT fcml_st_register fcml_reg_DR6; +extern LIB_EXPORT fcml_st_register fcml_reg_DR7; + +extern LIB_EXPORT fcml_st_register fcml_reg_K0; +extern LIB_EXPORT fcml_st_register fcml_reg_K1; +extern LIB_EXPORT fcml_st_register fcml_reg_K2; +extern LIB_EXPORT fcml_st_register fcml_reg_K3; +extern LIB_EXPORT fcml_st_register fcml_reg_K4; +extern LIB_EXPORT fcml_st_register fcml_reg_K5; +extern LIB_EXPORT fcml_st_register fcml_reg_K6; +extern LIB_EXPORT fcml_st_register fcml_reg_K7; + +extern LIB_EXPORT fcml_st_register fcml_reg_IP; +extern LIB_EXPORT fcml_st_register fcml_reg_EIP; +extern LIB_EXPORT fcml_st_register fcml_reg_RIP; + +/** @} */ + +/** Prepares register operand for given register. + * @param reg Register for instruction operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_reg( + fcml_st_register *reg); + +/* IMM.*/ + +/** Prepares immediate operand for unsigned int8. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_unsigned_imm_8( + fcml_uint8_t value); +/** Prepares immediate operand for signed int8. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_signed_imm_8( + fcml_int8_t value); +/** Prepares immediate operand for unsigned int16. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_unsigned_imm_16( + fcml_uint16_t value); +/** Prepares immediate operand for signed int16. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_signed_imm_16( + fcml_int16_t value); +/** Prepares immediate operand for unsigned int32. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_unsigned_imm_32( + fcml_uint32_t value); +/** Prepares immediate operand for signed int32. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_signed_imm_32( + fcml_int32_t value); +/** Prepares immediate operand for unsigned int64. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_unsigned_imm_64( + fcml_uint64_t value); +/** Prepares immediate operand for signed int64. + * @param value Value for immediate operand. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_signed_imm_64( + fcml_int64_t value); + +/* Memory addressing.*/ + +/** Prepares far pointer operand for given segment and offset. + * @param seg 16-bit code segment. + * @param offset 16-bit code offset. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_far_pointer_offset16( + fcml_int16_t seg, fcml_int16_t offset); +/** Prepares far pointer operand for given segment and offset. + * @param seg 16-bit code segment. + * @param offset 32-bit code offset. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_far_pointer_offset32( + fcml_int16_t seg, fcml_int32_t offset); +/** Prepares memory addressing operand for 16-bit absolute offset. + * @param offset 16-bit absolute offset. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_offset_16( + fcml_int16_t offset, fcml_usize size_operator); +/** Prepares memory addressing operand for 32-bit absolute offset. + * @param offset 32-bit absolute offset. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_offset_32( + fcml_int32_t offset, fcml_usize size_operator); +/** Prepares memory addressing operand for 64-bit absolute offset. Function + * sets operand level hint: FCML_OP_HINT_ABSOLUTE_ADDRESSING. + * @param offset 64-bit absolute offset. + * @param size_operator Size operator. + * @return Prepared operand. + * @see RIP addressing. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_offset_abs_64( + fcml_int64_t offset, fcml_usize size_operator); +/** Prepares memory addressing operand for 64-bit absolute offset. Function + * sets operand level hint: FCML_OP_HINT_RELATIVE_ADDRESSING. + * @param offset 64-bit absolute offset. + * @param size_operator Size operator. + * @return Prepared operand. + * @see RIP addressing. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_offset_rel_64( + fcml_int64_t offset, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 16-bit displacement. + * @param disp 16-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_disp_16( + fcml_int16_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 32-bit displacement. + * @param disp 32-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_disp_32( + fcml_int32_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 64-bit displacement. + * @param disp 64-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_disp_64( + fcml_int64_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 8-bit displacement + * and base register. + * @param base Base register. + * @param disp 8-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_b_disp_8( + fcml_st_register *base, fcml_int8_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 16-bit displacement + * and base register. + * @param base Base register. + * @param disp 16-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_b_disp_16( + fcml_st_register *base, fcml_int16_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 32-bit displacement + * and base register. + * @param base Base register. + * @param disp 32-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_b_disp_32( + fcml_st_register *base, fcml_int32_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 64-bit displacement + * and base register. + * @param base Base register. + * @param disp 64-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_b_disp_64( + fcml_st_register *base, fcml_int64_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 8-bit displacement, + * scale factor and index register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 8-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_is_disp_8( + fcml_st_register *index, fcml_uint8_t scale_factor, fcml_int8_t disp, + fcml_usize size_operator); +/** Prepares effective memory addressing operand for 16-bit displacement, + * scale factor and index register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 16-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_is_disp_32( + fcml_st_register *index, fcml_uint8_t scale_factor, fcml_int32_t disp, + fcml_usize size_operator); +/** Prepares effective memory addressing operand for 32-bit displacement, + * scale factor and index register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 32-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_is_disp_64( + fcml_st_register *index, fcml_uint8_t scale_factor, fcml_int64_t disp, + fcml_usize size_operator); +/** Prepares effective memory addressing operand for 8-bit displacement, + * base register, scale factor and index register. + * @param base Base register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 8-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_bis_disp_8( + fcml_st_register *base, fcml_st_register *index, + fcml_uint8_t scale_factor, fcml_int8_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 16-bit displacement, + * base register, scale factor and index register. + * @param base Base register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 16-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_bis_disp_32( + fcml_st_register *base, fcml_st_register *index, + fcml_uint8_t scale_factor, fcml_int32_t disp, fcml_usize size_operator); +/** Prepares effective memory addressing operand for 32-bit displacement, + * base register, scale factor and index register. + * @param base Base register. + * @param index Index register. + * @param scale_factor Scale factor. + * @param disp 32-bit displacement. + * @param size_operator Size operator. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_operand_addr_bis_disp_64( + fcml_st_register *base, fcml_st_register *index, + fcml_uint8_t scale_factor, fcml_int64_t disp, fcml_usize size_operator); + +/** Adds hints to the operand. + * @param operand Operand for hints. + * @param hints Hints mask. + * @return Prepared operand. + */ +LIB_EXPORT fcml_st_operand LIB_CALL fcml_fn_cu_add_operand_hints( + fcml_st_operand operand, fcml_hints hints); + +/** Clones given instruction. + * Allocates new instance of instruction and makes a deep copy of + * all fields. Remember that cloned instructions have to be freed + * using fcml_fn_cu_free_instruction() function. Do not try to free + * it on your own because it might be allocated on different + * dedicated memory heap. + * @param instruction Instruction to be cloned. + * @return Cloned instruction. + */ +LIB_EXPORT fcml_st_instruction* LIB_CALL fcml_fn_cu_clone_instruction( + fcml_st_instruction *instruction); + +/** Frees given instruction. + * Frees instruction allocated by fcml_fn_cu_clone_instruction() function. + * @param instruction Instruction to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_cu_free_instruction( + fcml_st_instruction *instruction); + +/** Gets operand of given type or NULL if there is no such operand. + * If more than one operand of given type exist, the first one is returned. + * @param instruction Finds an operand of the given type for for + * given instruction. + * @param operand_type Operand type. + * @return Pointer to the operand of given type. + */ +LIB_EXPORT fcml_st_operand* fcml_fn_cu_find_operand( + fcml_st_instruction *instruction, fcml_en_operand_type operand_type); + +/* Some shortcuts for those who prefer to use macros instead of functions.*/ + +#define FCML_IMM8_S( x ) fcml_fn_cu_operand_signed_imm_8( x ) +#define FCML_IMM8( x ) fcml_fn_cu_operand_unsigned_imm_8( x ) +#define FCML_IMM16_S( x ) fcml_fn_cu_operand_signed_imm_16( x ) +#define FCML_IMM16( x ) fcml_fn_cu_operand_unsigned_imm_16( x ) +#define FCML_IMM32_S( x ) fcml_fn_cu_operand_signed_imm_32( x ) +#define FCML_IMM32( x ) fcml_fn_cu_operand_unsigned_imm_32( x ) +#define FCML_IMM64_S( x ) fcml_fn_cu_operand_signed_imm_64( x ) +#define FCML_IMM64( x ) fcml_fn_cu_operand_unsigned_imm_64( x ) + +#ifdef FCML_USE_SHORT_REG +#define FCML_REG( x ) fcml_fn_cu_operand_reg( &fcml_reg_##x ) +#else +#define FCML_REG( x ) fcml_fn_cu_operand_reg( &x ) +#endif + +#define FCML_FAR_POINTER_16( seg, offset ) \ + fcml_fn_cu_operand_addr_far_pointer_offset16( seg, offset ) +#define FCML_FAR_POINTER_32( seg, offset ) \ + fcml_fn_cu_operand_addr_far_pointer_offset32( seg, offset ) +#define FCML_OFFSET_16( offset ) \ + fcml_fn_cu_operand_addr_offset_16( offset ) +#define FCML_OFFSET_32( offset ) \ + fcml_fn_cu_operand_addr_offset_32( offset ) +#define FCML_OFFSET_ABS_64( offset ) \ + fcml_fn_cu_operand_addr_offset_abs_64( offset ) +#define FCML_OFFSET_REL_64( offset ) \ + fcml_fn_cu_operand_addr_offset_rel_64( offset ) +#define FCML_DISP_16( offset ) \ + fcml_fn_cu_operand_addr_disp_16( offset ) +#define FCML_DISP_32( offset ) \ + fcml_fn_cu_operand_addr_disp_32( offset ) +#define FCML_DISP_64( offset ) \ + fcml_fn_cu_operand_addr_disp_64( offset ) + +#ifdef FCML_USE_SHORT_REG +#define FCML_B_DISP_8(base, offset) \ +fcml_fn_cu_operand_addr_b_disp_8( &fcml_reg_##base, offset ) +#define FCML_B_DISP_16(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_16( &fcml_reg_##base, offset ) +#define FCML_B_DISP_32(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_32( &fcml_reg_##base, offset ) +#define FCML_B_DISP_64(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_64( &fcml_reg_##base, offset ) +#define FCML_IS_DISP_8(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_8( &fcml_reg_##index, scale, offset ) +#define FCML_IS_DISP_16(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_32( &fcml_reg_##index, scale, offset ) +#define FCML_IS_DISP_32(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_64( &fcml_reg_##index, scale, offset ) +#define FCML_BIS_DISP_8(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_8( &fcml_reg_##base, &fcml_reg_##index, \ + scale, offset ) +#define FCML_BIS_DISP_16(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_32( &fcml_reg_##base, &fcml_reg_##index, \ + scale, offset ) +#define FCML_BIS_DISP_32(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_64( &fcml_reg_##base, &fcml_reg_##index, \ + scale, offset ) +#else +#define FCML_B_DISP_8(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_8( &base, offset ) +#define FCML_B_DISP_16(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_16( &base, offset ) +#define FCML_B_DISP_32(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_32( &base, offset ) +#define FCML_B_DISP_64(base, offset) \ + fcml_fn_cu_operand_addr_b_disp_64( &base, offset ) +#define FCML_IS_DISP_8(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_8( &index, scale, offset ) +#define FCML_IS_DISP_16(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_32( &index, scale, offset ) +#define FCML_IS_DISP_32(index, scale, offset) \ + fcml_fn_cu_operand_addr_is_disp_64( &index, scale, offset ) +#define FCML_BIS_DISP_8(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_8( &base, &index, scale, offset ) +#define FCML_BIS_DISP_16(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_32( &base, &index, scale, offset ) +#define FCML_BIS_DISP_32(base, index, scale, offset) \ + fcml_fn_cu_operand_addr_bis_disp_64( &base, &index, scale, offset ) +#endif + +#define FCML_IS_INSTRUCTION_GROUP(result, group) \ + ( result.instruction_details.instruction_group & ( group ) ) +#define FCML_IS_INSTRUCTION_CODE(result, _ins) \ + ( result.instruction_details.instruction == _ins ) + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_COMMON_UTILS_H_ */ diff --git a/dependencies/fcml/include/fcml_dialect.h b/dependencies/fcml/include/fcml_dialect.h new file mode 100644 index 0000000..75571c5 --- /dev/null +++ b/dependencies/fcml/include/fcml_dialect.h @@ -0,0 +1,53 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_dialect.h + * Structures and functions related to dialects. + * Functions and structures used for developing new dialects are not exposed + * as public API. If you are interested in implementing another dialect + * you have to use internal headers. + * + * @copyright Copyright (C) 2010-2019 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_DIALECT_H_ +#define FCML_DIALECT_H_ + +#include "fcml_lib_export.h" + +/** Assembler dialect.*/ +typedef struct fcml_st_dialect fcml_st_dialect; + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Frees dialect instance. + * Frees all resources occupied by the dialect instance. + * @param dialect Dialect to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_dialect_free( fcml_st_dialect *dialect ); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_DIALECT_H_ */ diff --git a/dependencies/fcml/include/fcml_dialect.hpp b/dependencies/fcml/include/fcml_dialect.hpp new file mode 100644 index 0000000..1bea71c --- /dev/null +++ b/dependencies/fcml/include/fcml_dialect.hpp @@ -0,0 +1,129 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_dialect.hpp + * C++ wrapper for the base dialect. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_DIALECT_HPP_ +#define FCML_DIALECT_HPP_ + +#include "fcml_common.hpp" + +#include "fcml_dialect.h" + +namespace fcml { + +/** + * An abstract dialect. It's a base class for all supported dialects. + * @since 1.1.0 + * @remarks This class is thread-safe. + */ +class Dialect: public NonCopyable { +protected: + + /** + * Default constructor. + * @since 1.1.0 + */ + Dialect() { + _dialect = NULL; + } + + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~Dialect() { + if (_dialect) { + ::fcml_fn_dialect_free(_dialect); + _dialect = NULL; + } + } + +protected: + + friend class DialectAware; + + /** + * Gets the wrapped FCML dialect. + * + * @return The wrapped FCML dialect. + * @since 1.1.0 + */ + fcml_st_dialect* getDialect() const { + return _dialect; + } + + /** + * Sets a new dialect for the wrapper. + * + * @param dialect The new dialect for the wrapper. + * @since 1.1.0 + */ + void setDialect(fcml_st_dialect *dialect) { + this->_dialect = dialect; + } + +private: + + /** Wrapped dialect */ + fcml_st_dialect *_dialect; + +}; + +/** Inherit from this class in order to get access to the native FCML + * dialect structure. + * @since 1.1.0 + */ +class DialectAware { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + DialectAware() { + } + + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~DialectAware() { + } + + /** + * Extracts the native FCML dialect from the dialect object. + * + * @param dialect The wrapper. + * @return The wrapped FCML dialect. + * @since 1.1.0 + */ + fcml_st_dialect* extractDialect(const Dialect &dialect) const { + return dialect.getDialect(); + } +}; + +} + +#endif /* FCML_DIALECT_HPP_ */ diff --git a/dependencies/fcml/include/fcml_disassembler.h b/dependencies/fcml/include/fcml_disassembler.h new file mode 100644 index 0000000..00da9e9 --- /dev/null +++ b/dependencies/fcml/include/fcml_disassembler.h @@ -0,0 +1,356 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_disassembler.h + * Structures and functions declarations related to FCML disassembler. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_DISASSEMBLER_H_ +#define FCML_DISASSEMBLER_H_ + +#include "fcml_lib_export.h" + +#include "fcml_instructions.h" +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_common.h" +#include "fcml_dialect.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Maximal number of instruction prefixes. */ +#define FCML_DASM_PREFIXES_COUNT 12 + +/** First group of conditional suffixes (See FCML manual). */ +#define FCML_DASM_CONDITIONAL_GROUP_1 0x00 +/** Second group of conditional suffixes (See FCML manual). */ +#define FCML_DASM_CONDITIONAL_GROUP_2 0x01 + +/** This structure and type declaration represents an abstract disassembler. */ +typedef struct fcml_st_disassembler fcml_st_disassembler; + +/** Disassembler configuration. */ +typedef struct fcml_st_disassembler_conf { + /** Set to true in order to make disassembler to increment IP address by + * length of the disassembled instruction. */ + fcml_bool increment_ip; + /** True if optional error and warning messages should be collected + * during processing. */ + fcml_bool enable_error_messages; + /** True if suffixes for carry flag has to be used by disassembler.*/ + fcml_bool carry_flag_conditional_suffix; + /** There are two groups of suffixes for conditional instructions, you + * can choose which one should be used. */ + fcml_uint8_t conditional_group; + /** Set to true in order to use short forms. + * For instance 'cmpsb' will be used instead of + * 'cmps byte ptr [si],byte ptr [di]' + */ + fcml_bool short_forms; + /** True if displacement should be sign extended to effective + * address size; otherwise false. */ + fcml_bool extend_disp_to_asa; + /** If set to true assembler will return FCML_CEH_GEC_UNKNOWN_INSTRUCTION + * error code if instruction is not known. + */ + fcml_bool fail_if_unknown_instruction; +} fcml_st_disassembler_conf; + +/** Disassembler context. */ +typedef struct fcml_st_disassembler_context { + /** Disassembler used to decode instructions. */ + fcml_st_disassembler *disassembler; + /** Disassembler configuration. */ + fcml_st_disassembler_conf configuration; + /** Instruction entry point configuration. */ + fcml_st_entry_point entry_point; + /** Pointer to the encoded instruction. */ + fcml_ptr code; + /** Size of the code in the buffer above. */ + fcml_usize code_length; +} fcml_st_disassembler_context; + +/* Prefixes */ + +/** Available types of instruction prefixes. For more information see + * Intel/AMD Architecture Manual. */ +typedef enum fcml_en_prefix_types { + FCML_PT_GROUP_UNKNOWN = 0, + FCML_PT_GROUP_1 = 1, + FCML_PT_GROUP_2, + FCML_PT_GROUP_3, + FCML_PT_GROUP_4, + FCML_PT_REX, + FCML_PT_VEX, + FCML_PT_XOP, + FCML_PT_EVEX +} fcml_en_prefix_types; + +/** Describes one decoded prefix. */ +typedef struct fcml_st_instruction_prefix { + /** Prefix itself as raw byte. */ + fcml_uint8_t prefix; + /** Type of the prefix. */ + fcml_en_prefix_types prefix_type; + /** FCML_TRUE if prefix is treated as mandatory one. */ + fcml_bool mandatory_prefix; + /** Place for additional bytes of VEX/EVEX/XOP prefix. + * since 1.2.0 + */ + fcml_uint8_t avx_bytes[3]; +} fcml_st_instruction_prefix; + +/** + * Contains some additional information about all decoded + * instruction prefixes. + */ +typedef struct fcml_st_prefixes_details { + /** Array with decoded prefixes. */ + fcml_st_instruction_prefix prefixes[FCML_DASM_PREFIXES_COUNT]; + /** Number of decoded prefixes. */ + fcml_int prefixes_count; + /** Number of bytes used by all decoded prefixes. */ + fcml_int prefixes_bytes_count; + /** FCML_TRUE if branch prefix exists. */ + fcml_bool is_branch; + /** FCML_TRUE if nobranch prefix exists. */ + fcml_bool is_nobranch; + /** FCML_TRUE if lock explicit prefix exists. */ + fcml_bool is_lock; + /** FCML_TRUE if rep explicit prefix exists. */ + fcml_bool is_rep; + /** FCML_TRUE if repne explicit prefix exists. */ + fcml_bool is_repne; + /** FCML_TRUE if xrelease explicit prefix exists. */ + fcml_bool is_xrelease; + /** FCML_TRUE if xacquire explicit prefix exists. */ + fcml_bool is_xacquire; + /** FCML_TRUE if VEX prefix exists. */ + fcml_bool is_vex; + /** FCML TRUE if EVEX prefix exists. */ + fcml_bool is_evex; + /** FCML_TRUE if XOP prefix exists. */ + fcml_bool is_xop; + /** True if it is an AVX instruction (VEX/XOP/EVEX). */ + fcml_bool is_avx; + /** FCML_TRUE if REX prefix exists. */ + fcml_bool is_rex; + /** First byte of AVX prefix. */ + fcml_uint8_t avx_first_byte; + /** R field of REX,XOP or VEX prefix. */ + fcml_uint8_t R; + /** EVEX R’ High-16 register specifier modifier. */ + fcml_uint8_t R_prim; + /** X field of REX,XOP or VEX prefix. */ + fcml_uint8_t X; + /** B field of REX,XOP or VEX prefix. */ + fcml_uint8_t B; + /** b field of EVEX prefix. */ + fcml_uint8_t b; + /** W field of REX,XOP or VEX/EVEX prefix. */ + fcml_uint8_t W; + /** L field of XOP or VEX prefix. */ + fcml_uint8_t L; + /** L’ field of EVEX prefix. */ + fcml_uint8_t L_prim; + /** m-mmmm field of XOP or VEX prefix. */ + fcml_uint8_t mmmm; + /** vvvv field of XOP or VEX prefix. */ + fcml_uint8_t vvvv; + /** pp field of XOP or VEX/EVEX prefix. */ + fcml_uint8_t pp; + /** z field of EVEX prefix */ + fcml_uint8_t z; + /** V’ field of EVEX prefix. */ + fcml_uint8_t V_prim; + /** Embedded opmask register specifier. */ + fcml_uint8_t aaa; +} fcml_st_prefixes_details; + +/** Some additional disassembler specific information about decoded operands. */ +typedef struct fcml_st_operand_details { + /** Instruction operand access mode READ, WRITE or both. */ + fcml_en_access_mode access_mode; +} fcml_st_operand_details; + +/** + * Displacement in raw form. + */ +typedef struct fcml_st_raw_displacement { + /** Displacement as encoded in disp8/disp16/disp32/disp8*N. */ + fcml_st_integer displacement; + /** Scaling factor N in EVEX specific compressed disp8*N. */ + fcml_nuint32_t N; +} fcml_st_raw_displacement; + +/** Some basic information about decoded ModR/M and SIB bytes. */ +typedef struct fcml_st_decoded_modrm_details { + /** ModR/M byte if exists.*/ + fcml_uint8_t modrm; + /** SIB byte if exists.*/ + fcml_nuint8_t sib; + /** True if RIP encoding is used by decoded instruction. This flag is + * used only in 64 bit mode. */ + fcml_bool is_rip; + /** True if ModR/M exists. */ + fcml_bool is_modrm; + /** Raw displacement */ + fcml_st_raw_displacement displacement; +} fcml_st_decoded_modrm_details; + +/** Additional instruction details provided by disassembler. */ +typedef struct fcml_st_instruction_details { + /** True if this is a shortcut. + * A good example of such instruction is 'cmpsb' as opposed to + * 'cmps byte ptr [si],byte ptr [di]'. It is very important to take this + * information into consideration when instruction models are analyzed + * because there is no operands in the GIM for shortcuts. + */ + fcml_bool is_shortcut; + /** True if given instruction is a short form of pseudo-ops instructions. + * See 'vcmpunordsd' for instance. */ + fcml_bool is_pseudo_op; + /** Code of the disassembled instruction. */ + fcml_uint8_t instruction_code[FCML_INSTRUCTION_SIZE]; + /** Instruction size in bytes. */ + fcml_usize instruction_size; + /** Some additional information about decoded instruction prefixes. */ + fcml_st_prefixes_details prefixes_details; + /** All disassembler specific information about operands going there. */ + fcml_st_operand_details operand_details[FCML_OPERANDS_COUNT]; + /** Details about decoded ModR/M and SIB bytes. */ + fcml_st_decoded_modrm_details modrm_details; + /** Opcode field 's'. + * This is set only for informational purpose only and you should not + * use it for any critical functionality. + */ + fcml_bool opcode_field_s_bit; + /** Opcode field 'w'. + * This is set only for informational purpose only and you should not + * use it for any critical functionality. + */ + fcml_bool opcode_field_w_bit; + /** Instruction code/number. @see fcml_instructions.h header file. */ + fcml_en_instruction instruction; + /** Pseudo operation code. */ + fcml_en_pseudo_operations pseudo_op; + /** Code of the instruction form/addressing mode of the instruction + * above. */ + fcml_uint16_t addr_mode; + /** Instruction group. */ + fcml_uint64_t instruction_group; + /** avx-512 tuple type */ + fcml_uint8_t tuple_type; +} fcml_st_instruction_details; + +/** Reusable disassembler result holder. */ +typedef struct fcml_st_disassembler_result { + /** All errors and warnings messages going here. */ + fcml_st_ceh_error_container errors; + /** Additional disassembler specific information about decoded + * instruction. */ + fcml_st_instruction_details instruction_details; + /** Decoded instruction in its generic form.*/ + fcml_st_instruction instruction; +} fcml_st_disassembler_result; + +/** + * Initializes disassembler instance. + * Initializes disassembler instance for given dialect. Disassembler + * initialized in such a way is dialect dependent and generates generic + * instruction models compliant to the syntax supported by the dialect + * (Intel, AT&T). Every disassembler instance has to be freed using + * fcml_fn_disassembler_free() function as soon as it is not needed anymore. + * + * @param dialect Dialect for newly created disassembler. + * @param[out] disassembler Initialized disassembler instance. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_disassembler_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_disassembler_init( + const fcml_st_dialect *dialect, fcml_st_disassembler **disassembler); + +/** + * Disassembles one instruction from provided code buffer. + * Disassembles the first instruction available in the provided code buffer + * using disassembler instance, configuration and entry point accessible through + * the disassembler context. Disassembled instruction model as well as potential + * errors are returned in reusable result holder given in the second parameter. + * Result holder has to be allocated by the user and appropriately prepared + * using fcml_fn_disassembler_result_prepare() function. As long as the + * instruction context and the result holder are not shared across multiple + * function calls disassembling process is thread safe. + * + * @param context Disassembler context. + * @param result Appropriately prepared result holder. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_disassembler_result_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_disassemble( + fcml_st_disassembler_context *context, + fcml_st_disassembler_result *result); + +/** + * Prepares reusable result holder for disassembler. + * Every instance of fcml_st_disassembler_result structure is reusable from + * the disassembler's point of view, so it has to be prepared in the right + * way in order to allow disassembler to reuse it correctly. It is up to the + * library user to allocate space for the holder itself. This function is only + * responsible for cleaning the structure correctly and preparing it for first + * disassembling process. Notice that disassembler has to clean the result + * holder at the beginning so you can not pass an uninitialized memory + * block because it can even cause a crash due to illegal memory access. + * + * @param result Result holder instance to be prepared. + * @see fcml_fn_disassembler_result_free + */ +LIB_EXPORT void LIB_CALL fcml_fn_disassembler_result_prepare( + fcml_st_disassembler_result *result); + +/** + * Cleans result holder. + * Frees all memory blocks allocated by the disassembler and held inside + * the result holder (Instructions, errors etc.). Notice that result holder + * itself is not freed and can be even safety reused after calling this + * function. In fact this function is also called internally by assembler in + * order to clean result holder before reusing it. + * + * @param result Result holder to clean. + */ +LIB_EXPORT void LIB_CALL fcml_fn_disassembler_result_free( + fcml_st_disassembler_result *result); + +/** + * Frees disassembler instance. + * Every disassembler instance manages some resources internally and as + * such it has to be deallocated as soon as it is not needed anymore. + * @param disassembler Disassembler to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_disassembler_free( + fcml_st_disassembler *disassembler); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_DISASSEMBLER_H_ */ diff --git a/dependencies/fcml/include/fcml_disassembler.hpp b/dependencies/fcml/include/fcml_disassembler.hpp new file mode 100644 index 0000000..4660e5c --- /dev/null +++ b/dependencies/fcml/include/fcml_disassembler.hpp @@ -0,0 +1,2329 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_disassembler.hpp + * C++ wrapper for the FCML disassembler. + * + * @copyright Copyright (C) 2010-2017 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_DISASSEMBLER_HPP_ +#define FCML_DISASSEMBLER_HPP_ + +#include + +#include "fcml_disassembler.h" + +#include "fcml_common.hpp" +#include "fcml_errors.hpp" +#include "fcml_dialect.hpp" + +namespace fcml { + +/** + * Component can not be initialized correctly. + * @since 1.1.0 + */ +class DisassemblingFailedException: public ErrorContainerAwareException { +public: + DisassemblingFailedException(const fcml_cstring &msg, + const ErrorContainer &errorContainer, + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR) : + ErrorContainerAwareException(msg, errorContainer, error) { + } +}; + +/** Disassembler configuration. + * + * It's counterpart to the fcml_st_disassembler_conf structure. + * @since 1.1.0 + */ +class DisassemblerConf { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + DisassemblerConf() : + _throwExceptionOnError(true), + _incrementIP(true), + _enableErrorMessages(true), + _carryFlagConditionalSuffix(false), + _conditionalGroup(false), + _shortForms(false), + _extendDispToASA(false), + _failIfUnknownInstruction(false) { + } + + /** @since 1.1.0 */ + bool isCarryFlagConditionalSuffix() const { + return _carryFlagConditionalSuffix; + } + + /** @since 1.1.0 */ + void setCarryFlagConditionalSuffix(bool carryFlagConditionalSuffix) { + _carryFlagConditionalSuffix = carryFlagConditionalSuffix; + } + + /** @since 1.1.0 */ + fcml_uint8_t getConditionalGroup() const { + return _conditionalGroup; + } + + /** @since 1.1.0 */ + void setConditionalGroup(fcml_uint8_t conditionalGroup) { + _conditionalGroup = conditionalGroup; + } + + /** @since 1.1.0 */ + bool isEnableErrorMessages() const { + return _enableErrorMessages; + } + + /** @since 1.1.0 */ + void setEnableErrorMessages(bool enableErrorMessages) { + _enableErrorMessages = enableErrorMessages; + } + + /** @since 1.1.0 */ + bool isExtendDispToAsa() const { + return _extendDispToASA; + } + + /** @since 1.1.0 */ + void setExtendDispToAsa(bool extendDispToAsa) { + _extendDispToASA = extendDispToAsa; + } + + /** @since 1.1.0 */ + bool isFailIfUnknownInstruction() const { + return _failIfUnknownInstruction; + } + + /** @since 1.1.0 */ + void setFailIfUnknownInstruction(bool failIfUnknownInstruction) { + _failIfUnknownInstruction = failIfUnknownInstruction; + } + + /** @since 1.1.0 */ + bool isIncrementIp() const { + return _incrementIP; + } + + /** @since 1.1.0 */ + void setIncrementIp(bool incrementIp) { + _incrementIP = incrementIp; + } + + /** @since 1.1.0 */ + bool isShortForms() const { + return _shortForms; + } + + /** @since 1.1.0 */ + void setShortForms(bool shortForms) { + _shortForms = shortForms; + } + + /** + * Returns true if exception should be thrown when disassembling fails. + * + * @return True if exception is the preferred way of error + * handling in case of failure. + * @since 1.1.0 + */ + bool isThrowExceptionOnError() const { + return _throwExceptionOnError; + } + + /** + * Sets the way how the error handling is done. + * + * @param throwExceptionOnError True if exception should be thrown + * in case of failure. + * @since 1.1.0 + */ + void setThrowExceptionOnError(bool throwExceptionOnError) { + _throwExceptionOnError = throwExceptionOnError; + } + +private: + bool _throwExceptionOnError; + bool _incrementIP; + bool _enableErrorMessages; + bool _carryFlagConditionalSuffix; + fcml_uint8_t _conditionalGroup; + bool _shortForms; + bool _extendDispToASA; + bool _failIfUnknownInstruction; + +}; + +/** Disassembler context. + * @since 1.1.0 + */ +class DisassemblerContext { +public: + + /** + * Creates empty disassembler context. + * @since 1.1.0 + */ + DisassemblerContext() : + _code(NULL), _codeLength(0) { + } + + /** + * Creates disassembler context for given piece of machine code. + * + * @param code A buffer with the machine code. + * @param codeLength Size of the buffer in bytes. + * @since 1.1.0 + */ + DisassemblerContext(fcml_ptr code, fcml_usize codeLength) : + _code(code), _codeLength(codeLength) { + } + +public: + + /** + * Gets pointer to the machine code buffer. + * + * @return A pointer to the machine code. + * @since 1.1.0 + */ + fcml_ptr getCode() const { + return _code; + } + + /** + * Sets a new buffer with machine code for the context. + * + * @param code The new code buffer. + * @since 1.1.0 + */ + void setCode(fcml_ptr code) { + _code = code; + } + + /** + * Gets length of the buffer in bytes. + * + * @return Size of the buffer. + * @since 1.1.0 + */ + fcml_usize getCodeLength() const { + return _codeLength; + } + + /** + * Sets length of the code buffer in bytes. + * + * @param codeLength Size of the code. + * @since 1.1.0 + */ + void setCodeLength(fcml_usize codeLength) { + _codeLength = codeLength; + } + + /** + * Gets a reference to the configuration object associated with the context. + * + * @return The disassembler configuration. + * @since 1.1.0 + */ + const DisassemblerConf& getDisassemblerConf() const { + return _disassemblerConf; + } + + /** + * Gets a reference to the configuration object associated with the context. + * + * @return The disassembler configuration. + * @since 1.1.0 + */ + DisassemblerConf& getDisassemblerConf() { + return _disassemblerConf; + } + + /** + * Sets a new disassembler configuration for the context. + * + * @param disassemblerConf The new disassembler configuration. + * @since 1.1.0 + */ + void setDisassemblerConf(DisassemblerConf disassemblerConf) { + _disassemblerConf = disassemblerConf; + } + + /** + * Gets reference to the constant entry point instance + * associated with the context. + * + * @return Reference to the constant entry point. + * @since 1.1.0 + */ + const EntryPoint& getEntryPoint() const { + return _entryPoint; + } + + /** + * Gets reference to the entry point instance associated with the context. + * + * @return Reference to the entry point. + * @since 1.1.0 + */ + EntryPoint& getEntryPoint() { + return _entryPoint; + } + /** + * Copies given entry point to the instance associated with the context. + * Deep copy is performed, so passed object not need to be maintained as + * long as the context is used. + * + * @param entryPoint The entry point which is copied to the context. + * @since 1.1.0 + */ + void setEntryPoint(const EntryPoint &entryPoint) { + _entryPoint = entryPoint; + } + + /** + * Sets instruction pointer directly into the entry point. + * + * @param ip The new IP. + * @since 1.1.0 + */ + void setIP(fcml_ip ip) { + _entryPoint.setIP(ip); + } + + /** + * Increments entry point by given number of bytes. + * + * @param ip Number of bytes the instruction pointer has to be + * incremented by. + * @since 1.1.0 + */ + void incrementIP(fcml_ip ip) { + _entryPoint.incrementIP(ip); + } + + /** + * Sets processor operating mode directly into the entry point. + * + * @param operatingMode Processor operating mode to be set. + * @since 1.1.0 + */ + void setOperatingMode(EntryPoint::OperatingMode operatingMode) { + _entryPoint.setOpMode(operatingMode); + } + + /** + * Sets a new address size attribute for the entry point. + * + * @param addressSizeAttribute The address size attribute. + * @since 1.1.0 + */ + void setAddressSizeAttribute(fcml_usize addressSizeAttribute) { + _entryPoint.setAddressSizeAttribute(addressSizeAttribute); + } + + /** + * Sets a new operand size attribute for the entry point. + * + * @param operandSizeAttribute The operand size attribute. + * @since 1.1.0 + */ + void setOperandSizeAttribute(fcml_usize operandSizeAttribute) { + _entryPoint.setOperandSizeAttribute(operandSizeAttribute); + } + +private: + /** Disassembler configuration. */ + DisassemblerConf _disassemblerConf; + /** Entry point. */ + EntryPoint _entryPoint; + /** Code buffer. */ + fcml_ptr _code; + /** Code length. */ + fcml_usize _codeLength; +}; + +/** Instruction prefix. + * @since 1.1.0 + */ +class InstructionPrefixDetails { +public: + + /** Type of the instruction prefix. + * @since 1.1.0 + */ + enum PrefixType { + PT_GROUP_UNKNOWN = FCML_PT_GROUP_UNKNOWN, + PT_GROUP_1 = FCML_PT_GROUP_1, + PT_GROUP_2 = FCML_PT_GROUP_2, + PT_GROUP_3 = FCML_PT_GROUP_3, + PT_GROUP_4 = FCML_PT_GROUP_4, + PT_REX = FCML_PT_REX, + PT_VEX = FCML_PT_VEX, + PT_XOP = FCML_PT_XOP, + PT_EVEX = FCML_PT_EVEX + }; + + /** + * Returns true if it's a mandatory prefix. + * + * @return True if it's a mandatory prefix. + * @since 1.1.0 + */ + bool isMandatoryPrefix() const { + return _mandatoryPrefix; + } + + /** + * Sets mandatory prefix flag for the prefix. + * + * @param mandatoryPrefix Set to true in order to make the + * prefix mandatory one. + * @since 1.1.0 + */ + void setMandatoryPrefix(bool mandatoryPrefix) { + _mandatoryPrefix = mandatoryPrefix; + } + + /** + * Gets the prefix byte. + * + * @return The prefix byte. + * @since 1.1.0 + */ + fcml_uint8_t getPrefix() const { + return _prefix; + } + + /** + * Sets the prefix byte. + * + * @param prefix The prefix byte. + * @since 1.1.0 + */ + void setPrefix(fcml_uint8_t prefix) { + _prefix = prefix; + } + + /** + * Gets the prefix type. + * + * @return The prefix byte. + * @since 1.1.0 + */ + PrefixType getPrefixType() const { + return _prefixType; + } + + /** + * Sets a new prefix type. + * + * @param prefixType The prefix byte to be set. + * @since 1.1.0 + */ + void setPrefixType(PrefixType prefixType) { + _prefixType = prefixType; + } + + /** + * Gets the second and third bytes of the XOP/VEX prefix. + * + * @return A pointer to the VEX/XOP bytes. + * @since 1.2.0 + */ + const fcml_uint8_t* getAvxBytes() const { + return _AvxBytes; + } + + /** + * Gets the second and third bytes of the XOP/VEX prefix. + * + * @return A pointer to the VEX/XOP bytes. + * @since 1.2.0 + */ + fcml_uint8_t* getAvxBytes() { + return _AvxBytes; + } + +private: + /** The first byte of the prefix. */ + fcml_uint8_t _prefix; + /** Tye type of the prefix. */ + PrefixType _prefixType; + /** True if the prefix is a mandatory one. */ + bool _mandatoryPrefix; + /** The second and third byte of the AVX prefix. + * since 1.2.0 + */ + fcml_uint8_t _AvxBytes[3]; +}; + +/** Prefixes details. + * @since 1.1.0 + */ +class PrefixesDetails { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + PrefixesDetails() : + _prefixesCount(0), + _prefixesBytesCount(0), + _isBranch(false), + _isNobranch(false), + _isLock(false), + _isRep(false), + _isRepne(false), + _isXrelease(false), + _isXacquire(false), + _isVex(false), + _isEvex(false), + _isXop(false), + _isAvx(false), + _isRex(false), + _AvxPrefixFirstByte(false), + _R(0), + _RPrim(0), + _X(0), + _B(0), + _W(0), + _L(0), + _LPrim(0), + _mmmm(0), + _vvvv(0), + _VPrim(0), + _pp(0), + _aaa(0), + _b(false), + _z(false) { + } + + /** + * Gets reference to the instruction prefix at given index. + * @param index Number of the prefix. + * @return The instruction prefix for given index. + * @throw IllegalArgumentException Index out of bound. + * @since 1.1.0 + */ + const InstructionPrefixDetails& operator[](fcml_usize index) const { + if (index >= FCML_DASM_PREFIXES_COUNT) { + throw IllegalArgumentException(FCML_TEXT("Index out of bound.")); + } + return _prefixes[index]; + } + + /** + * Gets reference to the instruction prefix at given index. + * @param index Number of the prefix. + * @return The instruction prefix for given index. + * @throw IllegalArgumentException Index out of bound. + * @since 1.1.0 + */ + InstructionPrefixDetails& operator[](fcml_usize index) { + if (index >= FCML_DASM_PREFIXES_COUNT) { + throw IllegalArgumentException(FCML_TEXT("Index out of bound.")); + } + return _prefixes[index]; + } + + /** + * Gets b flag. + * + * @return The B flag. + * @since 1.1.0 + */ + fcml_uint8_t getB() const { + return _B; + } + + /** + * Sets B flag. + * + * @param b The B flag. + * @since 1.1.0 + */ + void setB(fcml_uint8_t B) { + _B = B; + } + + /** + * Gets true if branch prefix is available. + * + * @return True if branch prefix is available. + * @since 1.1.0 + */ + bool isBranch() const { + return _isBranch; + } + + /** + * Sets branch prefix availability. + * + * @param isBranch True if branch prefix is available. + * @since 1.1.0 + */ + void setBranch(bool isBranch) { + _isBranch = isBranch; + } + + /** + * Gets true if lock prefix is available. + * + * @return True if lock prefix is available. + * @since 1.1.0 + */ + bool isLock() const { + return _isLock; + } + + /** + * Sets lock prefix availability. + * + * @param isLock True if lock prefix is available. + * @since 1.1.0 + */ + void setLock(bool isLock) { + _isLock = isLock; + } + + /** + * Gets true if no-branch prefix is available. + * + * @return True if no-branch prefix is available. + * @since 1.1.0 + */ + bool isNobranch() const { + return _isNobranch; + } + + /** + * Sets no-branch prefix availability. + * + * @param isNobranch True if no-branch prefix is available. + * @since 1.1.0 + */ + void setNobranch(bool isNobranch) { + _isNobranch = isNobranch; + } + + /** + * Gets true if Rep prefix is available. + * + * @return True if Rep prefix is available. + * @since 1.1.0 + */ + bool isRep() const { + return _isRep; + } + + /** + * Sets Rep prefix availability. + * + * @param isRep True if Rep prefix is available. + * @since 1.1.0 + */ + void setRep(bool isRep) { + _isRep = isRep; + } + + /** + * Gets true if Repne prefix is available. + * + * @return True if Repne prefix is available. + * @since 1.1.0 + */ + bool isRepne() const { + return _isRepne; + } + + /** + * Sets Repne prefix availability. + * + * @param isRepne True if branch prefix is available. + * @since 1.1.0 + */ + void setRepne(bool isRepne) { + _isRepne = isRepne; + } + + /** + * Gets true if Rex prefix is available. + * + * @return True if Rex prefix is available. + * @since 1.1.0 + */ + bool isRex() const { + return _isRex; + } + + /** + * Sets REX prefix availability. + * + * @param isRex True if REX prefix is available. + * @since 1.1.0 + */ + void setRex(bool isRex) { + _isRex = isRex; + } + + /** + * Gets true if Vex prefix is available. + * + * @return True if Vex prefix is available. + * @since 1.1.0 + */ + bool isVex() const { + return _isVex; + } + + /** + * Sets VEX prefix availability. + * + * @param isVex True if VEX prefix is available. + * @since 1.1.0 + */ + void setVex(bool isVex) { + _isVex = isVex; + } + + /** + * Sets EVEX prefix availability. + * + * @param isEvex True if EVEX prefix is available. + * @since 1.2.0 + */ + void setEvex(bool isEvex) { + _isEvex = isEvex; + } + + /** + * Gets true if EVEX prefix is available. + * + * @return True if EVEX prefix is available. + * @since 1.2.0 + */ + bool isEvex() const { + return _isEvex; + } + + /** + * Gets true if xacquire prefix is available. + * + * @return True if xacquire prefix is available. + * @since 1.1.0 + */ + bool isXacquire() const { + return _isXacquire; + } + + /** + * Sets xacquire prefix availability. + * + * @param isXacquire True if xacquire prefix is available. + * @since 1.1.0 + */ + void setXacquire(bool isXacquire) { + _isXacquire = isXacquire; + } + + /** + * Gets true if XOP prefix is available. + * + * @return True if XOP prefix is available. + * @since 1.1.0 + */ + bool isXop() const { + return _isXop; + } + + /** + * Sets XOP prefix availability. + * + * @param isXop True if XOP prefix is available. + * @since 1.1.0 + */ + void setXop(bool isXop) { + _isXop = isXop; + } + + /** + * Gets true if any AVX prefix is available. + * + * @return True if any AVX prefix is available. + * @since 1.2.0 + */ + bool isAvx() const { + return _isAvx; + } + + /** + * Sets XOP prefix availability. + * + * @param isXop True if XOP prefix is available. + * @since 1.2.0 + */ + void setAvx(bool isAvx) { + _isAvx = isAvx; + } + + /** + * Gets true if xrelease prefix is available. + * + * @return True if xrelease prefix is available. + * @since 1.1.0 + */ + bool isXrelease() const { + return _isXrelease; + } + + /** + * Sets xrelease prefix availability. + * + * @param isXrelease True if xrelease prefix is available. + * @since 1.1.0 + */ + void setXrelease(bool isXrelease) { + _isXrelease = isXrelease; + } + + /** + * Gets L flag. + * + * @return The L flag. + * @since 1.1.0 + */ + fcml_uint8_t getL() const { + return _L; + } + + /** + * Sets L flag. + * + * @param l The L flag. + * @since 1.1.0 + */ + void setL(fcml_uint8_t L) { + _L = L; + } + + /** + * Gets L' flag. + * + * @return The L' flag. + * @since 1.2.0 + */ + fcml_uint8_t getLPrim() const { + return _LPrim; + } + + /** + * Sets L' flag. + * + * @param l The L' flag. + * @since 1.2.0 + */ + void setLPrim(fcml_uint8_t lPrim) { + _LPrim = lPrim; + } + + /** + * Gets MMMM field. + * + * @return MMMM field. + * @since 1.1.0 + */ + fcml_uint8_t getMmmm() const { + return _mmmm; + } + + /** + * Sets MMMM field. + * + * @param mmmm MMMM field. + * @since 1.1.0 + */ + void setMmmm(fcml_uint8_t mmmm) { + _mmmm = mmmm; + } + + /** + * Gets PP field. + * + * @return The PP field. + * @since 1.1.0 + */ + fcml_uint8_t getPp() const { + return _pp; + } + + /** + * Sets PP field. + * + * @param pp PP field. + * @since 1.1.0 + */ + void setPp(fcml_uint8_t pp) { + _pp = pp; + } + + /** + * Gets a reference to the prefix of the given index. + * + * @param index Index for the prefix. + * @return The prefix at given index. + * @throw BadArgumentException Array index out of bound. + * @since 1.1.0 + */ + const InstructionPrefixDetails& getPrefixes(fcml_usize index) const { + if (index > FCML_DASM_PREFIXES_COUNT) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _prefixes[index]; + } + + /** + * Gets a reference to the prefix of the given index. + * + * @param index Index for the prefix. + * @return The prefix at given index. + * @throw BadArgumentException Array index out of bound. + * @since 1.1.0 + */ + InstructionPrefixDetails& getPrefixes(fcml_usize index) { + if (index > FCML_DASM_PREFIXES_COUNT) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _prefixes[index]; + } + + /** + * Gets number of bytes interpreted to be prefixes. + * + * @return Number of prefixes bytes. + * @since 1.1.0 + */ + fcml_int getPrefixesBytesCount() const { + return _prefixesBytesCount; + } + + /** + * Sets number of prefixes bytes available for the instruction. + * + * @param prefixesBytesCount Number of the prefixes bytes. + * @since 1.1.0 + */ + void setPrefixesBytesCount(fcml_int prefixesBytesCount) { + _prefixesBytesCount = prefixesBytesCount; + } + + /** + * Gets number of prefixes available for the instruction. + * + * @return Number of the prefixes for the instruction. + * @since 1.1.0 + */ + fcml_int getPrefixesCount() const { + return _prefixesCount; + } + + /** + * Sets number of prefixes available for the instruction. + * + * @param prefixesCount Number of the available prefixes. + * @since 1.1.0 + */ + void setPrefixesCount(fcml_int prefixesCount) { + _prefixesCount = prefixesCount; + } + + /** + * Gets R flag. + * + * @return The R flag. + * @since 1.1.0 + */ + fcml_uint8_t getR() const { + return _R; + } + + /** + * Sets R flag. + * + * @param r The R flag. + * @since 1.1.0 + */ + void setR(fcml_uint8_t r) { + _R = r; + } + + /** + * Gets R' flag. + * + * @return The R' flag. + * @since 1.2.0 + */ + fcml_uint8_t getRPrim() const { + return _RPrim; + } + + /** + * Sets R' flag. + * + * @param rPrim The R' flag. + * @since 1.2.0 + */ + void setRPrim(fcml_uint8_t rPrim) { + _RPrim = rPrim; + } + + /** + * Gets the first byte of the AVX prefix. + * + * @return The first byte of the AVX prefix. + * @since 1.2.0 + */ + fcml_uint8_t getAvxFirstByte() const { + return _AvxPrefixFirstByte; + } + + /** + * Sets a first byte of the XOP/VEX prefix. + * + * @param avxFirstByte The first AVX prefix byte. + * @since 1.2.0 + */ + void setAvxFirstByte(fcml_uint8_t avxFirstByte) { + _AvxPrefixFirstByte = avxFirstByte; + } + + /** + * Gets VVVV field of the XOP/VEX prefix. + * + * @return VVVV field of the XOP/VEX prefix. + * @since 1.1.0 + */ + fcml_uint8_t getVvvv() const { + return _vvvv; + } + + /** + * Sets VVVV field of the XOP/VEX prefix. + * + * @param vvvv The VVVV field. + * @since 1.1.0 + */ + void setVvvv(fcml_uint8_t vvvv) { + _vvvv = vvvv; + } + + /** + * Gets 'aaa' field of the EVEX prefix. + * + * @return aaa field of the EVEX prefix. + * @since 1.2.0 + */ + fcml_uint8_t getAaa() const { + return _aaa; + } + + /** + * Sets 'aaa' field of the EVEX prefix. + * + * @param aaa The 'aaa' field. + * @since 1.1.0 + */ + void setAaa(fcml_uint8_t aaa) { + _aaa = aaa; + } + + /** + * Gets V' flag. + * + * @return The V' flag. + * @since 1.2.0 + */ + fcml_uint8_t getVPrim() const { + return _VPrim; + } + + /** + * Sets V' flag. + * + * @param vPrim The V' flag. + * @since 1.2.0 + */ + void setVPrim(fcml_uint8_t vPrim) { + _VPrim = vPrim; + } + + /** + * Gets W flag. + * + * @return The W flag. + * @since 1.1.0 + */ + fcml_uint8_t getW() const { + return _W; + } + + /** + * Sets W flag. + * + * @param w The W flag. + * @since 1.1.0 + */ + void setW(fcml_uint8_t W) { + _W = W; + } + + /** + * Gets X flag. + * + * @return The X flag. + * @since 1.1.0 + */ + fcml_uint8_t getX() const { + return _X; + } + + /** + * Sets X flag. + * + * @param x The X flag. + * @since 1.1.0 + */ + void setX(fcml_uint8_t X) { + _X = X; + } + + /** + * Gets EVEX.b bit. + * + * @return The EVEX.b bit. + * @since 1.2.0 + */ + bool getBcast() const { + return _b; + } + + /** + * Sets EVEX.b bit. + * + * @param b The EVEX.b bit. + * @since 1.2.0 + */ + void setBcast(bool b) { + _b = b; + } + + /** + * Gets EVEX.z bit. + * + * @return The EVEX.z bit. + * @since 1.2.0 + */ + bool getZ() const { + return _z; + } + + /** + * Sets EVEX.z bit. + * + * @param z The EVEX.z bit. + * @since 1.2.0 + */ + void setZ(bool z) { + _z = z; + } + +private: + /** Array with decoded prefixes. */ + InstructionPrefixDetails _prefixes[FCML_DASM_PREFIXES_COUNT]; + /** Number of decoded prefixes. */ + fcml_int _prefixesCount; + /** Number of bytes used by all decoded prefixes. */ + fcml_int _prefixesBytesCount; + /** FCML_TRUE if branch prefix exists. */ + bool _isBranch; + /** FCML_TRUE if nobranch prefix exists. */ + bool _isNobranch; + /** FCML_TRUE if lock explicit prefix exists. */ + bool _isLock; + /** FCML_TRUE if rep explicit prefix exists. */ + bool _isRep; + /** FCML_TRUE if repne explicit prefix exists. */ + bool _isRepne; + /** FCML_TRUE if xrelease explicit prefix exists. */ + bool _isXrelease; + /** FCML_TRUE if xacquire explicit prefix exists. */ + bool _isXacquire; + /** FCML_TRUE if VEX prefix exists. */ + bool _isVex; + /** FCML_TRUE if EVEX prefix exists. + * since 1.2.0 + */ + bool _isEvex; + /** FCML_TRUE if XOP prefix exists. */ + bool _isXop; + /** FCML_TRUE if any AVX prefix exists. + * @since 1.2.0 + */ + bool _isAvx; + /** FCML_TRUE if REX prefix exists. */ + bool _isRex; + /** Various fields encoded inside decoded prefixes. + * since 1.2.0 + */ + fcml_uint8_t _AvxPrefixFirstByte; + /** R field of REX,XOP,VEX or EVEX prefix. */ + fcml_uint8_t _R; + /** R' field of EVEX prefix. + * since 1.2.0 + */ + fcml_uint8_t _RPrim; + /** X field of REX,XOP,VEX or EVEX prefix. */ + fcml_uint8_t _X; + /** B field of REX,XOP,VEX or EVEX prefix. */ + fcml_uint8_t _B; + /** W field of REX,XOP,VEX or EVEX prefix. */ + fcml_uint8_t _W; + /** L field of XOP, VEX or EVEX prefix. */ + fcml_uint8_t _L; + /** L' field of EVEX prefix. + * since 1.2.0 + */ + fcml_uint8_t _LPrim; + /** m-mmmm field of XOP or VEX prefix. */ + fcml_uint8_t _mmmm; + /** vvvv field of XOP or VEX prefix. */ + fcml_uint8_t _vvvv; + /** V' field of EVEX prefix. + * since 1.2.0 + */ + fcml_uint8_t _VPrim; + /** pp field of XOP or VEX prefix. */ + fcml_uint8_t _pp; + /** aaa field of EVEX prefix. + * since 1.2.0 + */ + fcml_uint8_t _aaa; + /** EVEX.b bit. + * since 1.2.0 + */ + bool _b; + /** EVEX.z bit. + * since 1.2.0 + */ + bool _z; +}; + +/** Operand details. + * @since 1.1.0 + */ +class OperandDetails { +public: + + /** @since 1.1.0 */ + enum AccessMode { + /** Undefined mode. */ + AM_ACCESS_MODE_UNDEFINED = FCML_AM_ACCESS_MODE_UNDEFINED, + /** Operand is read by instruction. */ + AM_READ = FCML_AM_READ, + /** Operand is set by instruction */ + AM_WRITE = FCML_AM_WRITE, + /** Operand is read but can be also set. */ + AM_READ_WRITE = AM_READ | AM_WRITE + }; + + /** + * Creates default operand details with an undefined access mode. + * @since 1.1.0 + */ + OperandDetails() : + _accessMode(AM_ACCESS_MODE_UNDEFINED) { + } + + /** + * Creates operand details for given access mode. + * + * @param accessMode Access mode. + * @since 1.1.0 + */ + OperandDetails(AccessMode accessMode) : + _accessMode(accessMode) { + } + + /** + * Gets access mode for the operand. + * + * @return Access mode. + * @since 1.1.0 + */ + AccessMode getAccessMode() const { + return _accessMode; + } + + /** + * Sets an access mode for the operand. + * + * @param accessMode The access mode for the operand. + * @since 1.1.0 + */ + void setAccessMode(AccessMode accessMode) { + _accessMode = accessMode; + } + +private: + /** Operan's access mode. */ + AccessMode _accessMode; +}; + +/** ModRM details. + * @since 1.1.0 + */ +class DecodedModRMDetails { +public: + + /** + * Creates an empty ModR/M details. + * @since 1.1.0 + */ + DecodedModRMDetails() : + _isRip(false) { + } + + /** + * Gets true if RIP byte is available. + * + * @return True if RIP byte is available. + * @since 1.1.0 + */ + bool isRip() const { + return _isRip; + } + + /** + * Sets RIP byte availability. + * + * @param isRip True if RIP byte is available. + * @since 1.1.0 + */ + void setRip(bool isRip) { + _isRip = isRip; + } + + /** + * Gets ModR/M nullable byte. + * + * @return ModR/M nullable byte. + * @since 1.1.0 + */ + const Nullable& getModRM() const { + return _modRM; + } + + /** + * Gets ModR/M nullable byte. + * + * @return ModR/M nullable byte. + * @since 1.1.0 + */ + Nullable& getModRM() { + return _modRM; + } + + /** + * Sets ModR/M nullable byte. + * + * @param modRM ModR/M nullable byte. + * @since 1.1.0 + */ + void setModRM(const Nullable &modRM) { + _modRM = modRM; + } + + /** + * Gets SIB nullable byte. + * + * @return SIB nullable byte. + * @since 1.1.0 + */ + const Nullable& getSib() const { + return _sib; + } + + /** + * Gets SIB nullable byte. + * + * @return SIB nullable byte. + * @since 1.1.0 + */ + Nullable& getSib() { + return _sib; + } + + /** + * Sets SIB nullable byte. + * + * @param sib The SIB nullable byte. + * @since 1.1.0 + */ + void setSib(const Nullable &sib) { + _sib = sib; + } + + /** + * Gets constant N (see AVX-512 compressed disp8). + * + * @return N as nullable value. + * @since 1.2.0 + */ + const Nullable& getN() const { + return _N; + } + + /** + * Gets N (see compressed AVX-512 disp8). + * + * @return N nullable value. + * @since 1.2.0 + */ + Nullable& getN() { + return _N; + } + + /** + * Sets N (see compressed AVX-512 disp8). + * + * @param N N nullable value. + * @since 1.2.0 + */ + void setN(const Nullable &N) { + _N = N; + } + + /** + * Gets constant raw displacement. + * + * @return Displacement. + * @since 1.2.0 + */ + const Integer& getDisplacement() const { + return _displacement; + } + + /** + * Gets raw displacement. + * + * @return Displacement. + * @since 1.2.0 + */ + Integer& getDisplacement() { + return _displacement; + } + + /** + * Sets displacement. + * + * @param displacement Displacement. + * @since 1.2.0 + */ + void setDisplacement(const Integer &displacement) { + _displacement = displacement; + } + +private: + /** ModR/M byte if exists.*/ + Nullable _modRM; + /** SIB byte if exists.*/ + Nullable _sib; + /** True if RIP encoding is used by decoded instruction. This flag is + * used only in 64 bit mode. */ + bool _isRip; + /** Raw displacement. + * since 1.2.0 + */ + Integer _displacement; + /* N from AVX-512 compressed disp8. + * since 1.2.0 + */ + Nullable _N; +}; + +/** Additional details about an instruction. + * @since 1.1.0 + */ +class InstructionDetails { +public: + + /** + * Gets address mode/instruction form. This information is used + * internally and is rather useless in day to day usage, but if + * you are interested in it do not hesitate to take a look at + * the manual. + * + * @return Instruction form. + * @since 1.1.0 + */ + fcml_uint16_t getAddrMode() const { + return _addrMode; + } + + /** + * Sets instruction form. + * + * @param addrMode Addressing mode. + * @since 1.1.0 + */ + void setAddrMode(fcml_uint16_t addrMode) { + _addrMode = addrMode; + } + + /** + * Gets instruction code. See fcml_en_instruction for more details. + * + * @return Instruction code. + * @since 1.1.0 + */ + fcml_en_instruction getInstruction() const { + return _instruction; + } + + /** + * Gets a new instruction code for the instruction. + * + * @param instruction The new instruction code. + * @since 1.1.0 + */ + void setInstruction(fcml_en_instruction instruction) { + _instruction = instruction; + } + + /** + * Gets a pointer to the instruction code. See fcml_en_instruction + * for more details. + * + * @return The pointer to the instruction code. + * @since 1.1.0 + */ + const fcml_uint8_t* getInstructionCode() const { + return _instructionCode; + } + + /** + * Gets a pointer to the instruction code. See fcml_en_instruction + * for more details. + * + * @return The pointer to the instruction code. + * @since 1.1.0 + */ + fcml_uint8_t* getInstructionCode() { + return _instructionCode; + } + + /** + * Gets instruction group. See fcml_instructions.h for all + * available groups. + * + * @return The instruction group. + * @since 1.1.0 + */ + fcml_uint64_t getInstructionGroup() const { + return _instructionGroup; + } + + /** + * Sets an instruction group. See fcml_instructions.h for all + * available groups. + * + * @param instructionGroup The instruction group. + * @since 1.1.0 + */ + void setInstructionGroup(fcml_uint64_t instructionGroup) { + _instructionGroup = instructionGroup; + } + + /** + * Instruction size in bytes. + * + * @return Size of the instruction in bytes. + * @since 1.1.0 + */ + fcml_usize getInstructionSize() const { + return _instructionSize; + } + + /** + * Sets the instruction size in bytes. + * + * @param instructionSize The instruction size. + * @since 1.1.0 + */ + void setInstructionSize(fcml_usize instructionSize) { + _instructionSize = instructionSize; + } + + /** + * Gets true if it's a shortcut instruction. + * + * @return True if it's a shortcut instruction. + * @since 1.1.0 + */ + bool isShortcut() const { + return _isShortcut; + } + + /** + * Marks the instruction as a shortcut. + * + * @param isShortcut True if it's a shortcut instruction. + * @since 1.1.0 + */ + void setShortcut(bool isShortcut) { + _isShortcut = isShortcut; + } + + /** + * Gets ModR/M instruction details. + * + * @return ModR/M details. + * @since 1.1.0 + */ + const DecodedModRMDetails& getModRmDetails() const { + return _modRMDetails; + } + + /** + * Gets ModR/M instruction details. + * + * @return ModR/M details. + * @since 1.1.0 + */ + DecodedModRMDetails& getModRmDetails() { + return _modRMDetails; + } + + /** + * Sets a new instruction details for the instruction. + * + * @param modRmDetails The new instruction details. + * @since 1.1.0 + */ + void setModRmDetails(const DecodedModRMDetails &modRmDetails) { + _modRMDetails = modRmDetails; + } + + /** + * Gets opcode field 'S'. + * + * @return 'S' opcode field. + * @since 1.1.0 + */ + bool isOpcodeFieldSBit() const { + return _opcodeFieldSBit; + } + + /** + * Sets 'S' field of the opcode byte. + * + * @param opcodeFieldSBit 'S' opcode byte field. + * @since 1.1.0 + */ + void setOpcodeFieldSBit(bool opcodeFieldSBit) { + _opcodeFieldSBit = opcodeFieldSBit; + } + + /** + * Gets opcode field 'W'. + * + * @return 'W' opcode field. + * @since 1.1.0 + */ + bool isOpcodeFieldWBit() const { + return _opcodeFieldWBit; + } + + /** + * Sets 'W' field of the opcode byte. + * + * @param opcodeFieldWBit 'W' opcode byte field. + * @since 1.1.0 + */ + void setOpcodeFieldWBit(bool opcodeFieldWBit) { + _opcodeFieldWBit = opcodeFieldWBit; + } + + /** + * Gets the operand details for given index. + * + * @param index Index of the instruction details. + * @return The operand details for the given index. + * @throw BadArgumentException Array index out of bound. + * @since 1.1.0 + */ + const OperandDetails& getOperandDetails(fcml_usize index) const { + if (index > FCML_OPERANDS_COUNT) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _operandDetails[index]; + } + + /** + * Gets the operand details for given index. + * + * @param index Index of the instruction details. + * @return The operand details for the given index. + * @throw BadArgumentException Array index out of bound. + * @since 1.1.0 + */ + OperandDetails& getOperandDetails(fcml_usize index) { + if (index > FCML_OPERANDS_COUNT) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _operandDetails[index]; + } + + /** + * Gets instruction prefixes details. + * + * @return The instruction prefix details. + * @since 1.1.0 + */ + const PrefixesDetails& getPrefixesDetails() const { + return _prefixesDetails; + } + + /** + * Gets instruction prefixes details. + * + * @return The instruction prefix details. + * @since 1.1.0 + */ + PrefixesDetails& getPrefixesDetails() { + return _prefixesDetails; + } + + /** + * Sets a new instruction prefixes details. + * + * @param prefixesDetails The new prefixes details. + * @since 1.1.0 + */ + void setPrefixesDetails(const PrefixesDetails &prefixesDetails) { + _prefixesDetails = prefixesDetails; + } + + /** + * Gets pseudo operation code. + * + * @return The pseudo operation associated with the instruction. + * @since 1.1.0 + */ + fcml_en_pseudo_operations getPseudoOp() const { + return _pseudoOp; + } + + /** + * Sets pseudo operation for the instruction. + * + * @param pseudoOp The pseudo operation. + * @since 1.1.0 + */ + void setPseudoOp(fcml_en_pseudo_operations pseudoOp) { + _pseudoOp = pseudoOp; + } + + /** + * Gets true is it's a pseudo operation. + * + * @return True if the instruction is a pseudo operation. + * @since 1.1.0 + */ + bool isPseudoOp() const { + return _isPseudoOp; + } + + /** + * Sets pseudo operation flag. + * + * @param isPseudoOp True if the instruction is a pseudo operation. + * @since 1.1.0 + */ + void setIsPseudoOp(bool isPseudoOp) { + _isPseudoOp = isPseudoOp; + } + + /** + * Gets avx-512 tuple type. + * @since 1.2.0 + */ + fcml_uint8_t getTupleType() const { + return _tupleType; + } + + /** + * Sets avx-512 tuple type. + * + * @param isPseudoOp True if the instruction is a pseudo operation. + * @since 1.2.0 + */ + void setTupleType(fcml_uint8_t tupleType) { + _tupleType = tupleType; + } + +private: + + /** + * True if this is a shortcut. + * A good example of such instruction is 'cmpsb' as opposed to 'cmps + * byte ptr [si],byte ptr [di]'. It is very important to take this + * information into consideration when instruction models are analyzed + * because there is no operands in the GIM for shortcuts. + */ + bool _isShortcut; + /** + * True if given instruction is a short form of pseudo-ops instructions. + * See 'vcmpunordsd' for instance. + */ + bool _isPseudoOp; + /** + * Code of the disassembled instruction. + */ + fcml_uint8_t _instructionCode[FCML_INSTRUCTION_SIZE]; + /** + * Instruction size in bytes. + */ + fcml_usize _instructionSize; + /** + * Some additional information about decoded instruction prefixes. + */ + PrefixesDetails _prefixesDetails; + /** + * All disassembler specific information about operands going there. + */ + OperandDetails _operandDetails[FCML_OPERANDS_COUNT]; + /** + * Details about decoded ModR/M and SIB bytes. + */ + DecodedModRMDetails _modRMDetails; + /** Opcode field 's'. + * This is set only for informational purpose only and you should not use + * it for any critical functionality. + */ + bool _opcodeFieldSBit; + /** Opcode field 'w'. + * This is set only for informational purpose only and you should not + * use it for any critical functionality. + */ + bool _opcodeFieldWBit; + /** + * Instruction code/number. @see fcml_instructions.h header file. + */ + fcml_en_instruction _instruction; + /** + * Pseudo operation code. + */ + fcml_en_pseudo_operations _pseudoOp; + /** + * Code of the instruction form/addressing mode of the instruction above. + */ + fcml_uint16_t _addrMode; + /** + * Instruction group. + */ + fcml_uint64_t _instructionGroup; + /** + * Tuple type used by avx-512 instructions to calculate disp8. + */ + fcml_uint8_t _tupleType; +}; + +/** Disassembler result. + * + * It's a counterpart to the fcml_st_disassembler_result structure. + * @since 1.1.0 + */ +class DisassemblerResult { + +public: + + /** + * Gets errors container with errors related to the failed + * disassembling process. + * + * @return The error container. + * @since 1.1.0 + */ + const ErrorContainer& getErrorContainer() const { + return _errorContainer; + } + + /** + * Gets errors container with errors related to the failed + * disassembling process. + * + * @return The error container. + * @since 1.1.0 + */ + const Instruction& getInstruction() const { + return _instruction; + } + + /** + * Gets instruction details associated with the instruction. + * + * @return The instruction details. + * @since 1.1.0 + */ + const InstructionDetails& getInstructionDetails() const { + return _instructionDetails; + } + + /** + * Cleans the disassembling result. + * @since 1.1.0 + */ + void clean() { + _errorContainer.clean(); + _instructionDetails = InstructionDetails(); + _instruction = Instruction(); + } + +protected: + + friend class Disassembler; + friend class DisassemblerTypeConverter; + + /** + * Gets mutable instruction details. + * @return Instruction details. + * @since 1.1.0 + */ + InstructionDetails& getInstructionDetailsInternal() { + return _instructionDetails; + } + + /** + * Sets new instruction details for the disassembler. + * @param instructionDetails The instruction details. + * @since 1.1.0 + */ + void setInstructionDetails(const InstructionDetails &instructionDetails) { + _instructionDetails = instructionDetails; + } + + /** + * Gets mutable instruction. + * @return The mutable instruction. + * @since 1.1.0 + */ + Instruction& getInstructionInternal() { + return _instruction; + } + + /** + * Sets a new instruction for the result. + * @param instruction The instruction to be copied to the result. + * @since 1.1.0 + */ + void setInstruction(const Instruction &instruction) { + _instruction = instruction; + } + + /** + * Sets error container. + * @param errorContainer The error container. + * @since 1.1.0 + */ + void setErrorContainer(const ErrorContainer &errorContainer) { + _errorContainer = errorContainer; + } + +private: + + /** Errors container */ + ErrorContainer _errorContainer; + /** Instruction details. */ + InstructionDetails _instructionDetails; + /** The disassembled instruction. */ + Instruction _instruction; + +}; + +/** + * Converts objects to their structures counterparts. + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class DisassemblerTypeConverter { + +public: + + static void convert(const DisassemblerContext &src, + fcml_st_disassembler_context &dest) { + dest.code = src.getCode(); + dest.code_length = src.getCodeLength(); + TypeConverter::convert(src.getEntryPoint(), dest.entry_point); + convert(src.getDisassemblerConf(), dest.configuration); + } + + static void convert(const DisassemblerConf &src, + fcml_st_disassembler_conf &dest) { + dest.conditional_group = src.getConditionalGroup(); + dest.carry_flag_conditional_suffix = src.isCarryFlagConditionalSuffix(); + dest.enable_error_messages = src.isEnableErrorMessages(); + dest.extend_disp_to_asa = src.isExtendDispToAsa(); + dest.fail_if_unknown_instruction = src.isFailIfUnknownInstruction(); + dest.increment_ip = src.isIncrementIp(); + dest.short_forms = src.isShortForms(); + } + + static void convert(const fcml_st_decoded_modrm_details &src, + DecodedModRMDetails &dest) { + dest.setRip(FCML_TO_CPP_BOOL(src.is_rip)); + Nullable &modRM = dest.getModRM(); + modRM.setNotNull(FCML_TO_CPP_BOOL(src.is_modrm)); + modRM.setValue(src.modrm); + Nullable &sib = dest.getSib(); + sib.setNotNull(FCML_TO_CPP_BOOL(src.sib.is_not_null)); + sib.setValue(src.sib.value); + TypeConverter::convert(src.displacement.displacement, + dest.getDisplacement()); + Nullable N; + N.setNotNull(FCML_TO_CPP_BOOL(src.displacement.N.is_not_null)); + N.setValue(src.displacement.N.value); + dest.setN(N); + } + + static void convert(const DecodedModRMDetails &src, + fcml_st_decoded_modrm_details &dest) { + dest.is_modrm = src.getModRM().isNotNull(); + dest.is_rip = src.isRip(); + dest.modrm = src.getModRM().getValue(); + fcml_nuint8_t &sib = dest.sib; + sib.is_not_null = src.getSib().isNotNull(); + sib.value = src.getSib().getValue(); + TypeConverter::convert(src.getDisplacement(), + dest.displacement.displacement); + dest.displacement.N.is_not_null = src.getN().isNotNull(); + dest.displacement.N.value = src.getN().getValue(); + } + + static void convert(const fcml_st_operand_details &src, + OperandDetails &dest) { + dest.setAccessMode( + static_cast(src.access_mode)); + } + + static void convert(const OperandDetails &src, + fcml_st_operand_details &dest) { + dest.access_mode = + static_cast(src.getAccessMode()); + } + + static void convert(const fcml_st_instruction_prefix &src, + InstructionPrefixDetails &dest) { + dest.setMandatoryPrefix(FCML_TO_CPP_BOOL(src.mandatory_prefix)); + dest.setPrefix(src.prefix); + dest.setPrefixType( + static_cast(src.prefix_type)); + ::memcpy(dest.getAvxBytes(), src.avx_bytes, sizeof(src.avx_bytes)); + } + + static void convert(const InstructionPrefixDetails &src, + fcml_st_instruction_prefix &dest) { + dest.mandatory_prefix = src.isMandatoryPrefix(); + dest.prefix = src.getPrefix(); + dest.prefix_type = + static_cast(src.getPrefixType()); + ::memcpy(dest.avx_bytes, src.getAvxBytes(), sizeof(dest.avx_bytes)); + } + + static void convert(const fcml_st_prefixes_details src, + PrefixesDetails &dest) { + for (int i = 0; i < FCML_DASM_PREFIXES_COUNT; i++) { + convert(src.prefixes[i], dest.getPrefixes(i)); + } + dest.setPrefixesCount(src.prefixes_count); + dest.setPrefixesBytesCount(src.prefixes_bytes_count); + dest.setBranch(FCML_TO_CPP_BOOL(src.is_branch)); + dest.setNobranch(FCML_TO_CPP_BOOL(src.is_nobranch)); + dest.setLock(FCML_TO_CPP_BOOL(src.is_lock)); + dest.setRep(FCML_TO_CPP_BOOL(src.is_rep)); + dest.setRepne(FCML_TO_CPP_BOOL(src.is_repne)); + dest.setXrelease(FCML_TO_CPP_BOOL(src.is_xrelease)); + dest.setXacquire(FCML_TO_CPP_BOOL(src.is_xacquire)); + dest.setVex(FCML_TO_CPP_BOOL(src.is_vex)); + dest.setEvex(FCML_TO_CPP_BOOL(src.is_evex)); + dest.setXop(FCML_TO_CPP_BOOL(src.is_xop)); + dest.setAvx(FCML_TO_CPP_BOOL(src.is_avx)); + dest.setRex(FCML_TO_CPP_BOOL(src.is_rex)); + dest.setAvxFirstByte(src.avx_first_byte); + dest.setR(src.R); + dest.setRPrim(src.R_prim); + dest.setX(src.X); + dest.setB(src.B); + dest.setW(src.W); + dest.setL(src.L); + dest.setLPrim(src.L_prim); + dest.setMmmm(src.mmmm); + dest.setVvvv(src.vvvv); + dest.setVPrim(src.V_prim); + dest.setPp(src.pp); + dest.setAaa(src.aaa); + dest.setBcast(src.b); + dest.setZ(src.z); + } + + static void convert(const PrefixesDetails src, + fcml_st_prefixes_details &dest) { + for (int i = 0; i < FCML_DASM_PREFIXES_COUNT; i++) { + convert(src.getPrefixes(i), dest.prefixes[i]); + } + dest.prefixes_count = src.getPrefixesCount(); + dest.prefixes_bytes_count = src.getPrefixesBytesCount(); + dest.is_branch = src.isBranch(); + dest.is_nobranch = src.isNobranch(); + dest.is_lock = src.isLock(); + dest.is_rep = src.isRep(); + dest.is_repne = src.isRepne(); + dest.is_xrelease = src.isXrelease(); + dest.is_xacquire = src.isXacquire(); + dest.is_vex = src.isVex(); + dest.is_xop = src.isXop(); + dest.is_avx = src.isAvx(); + dest.is_evex = src.isEvex(); + dest.is_rex = src.isRex(); + dest.avx_first_byte = src.getAvxFirstByte(); + dest.R = src.getR(); + dest.R_prim = src.getRPrim(); + dest.X = src.getX(); + dest.B = src.getB(); + dest.W = src.getW(); + dest.L = src.getL(); + dest.L_prim = src.getLPrim(); + dest.mmmm = src.getMmmm(); + dest.vvvv = src.getVvvv(); + dest.V_prim = src.getVPrim(); + dest.pp = src.getPp(); + dest.aaa = src.getAaa(); + dest.b = src.getBcast(); + dest.z = src.getZ() ? 1 : 0; + } + + static void convert(const fcml_st_instruction_details &src, + InstructionDetails &dest) { + dest.setTupleType(src.tuple_type); + dest.setAddrMode(src.addr_mode); + dest.setInstruction(src.instruction); + dest.setInstructionGroup(src.instruction_group); + dest.setInstructionSize(src.instruction_size); + dest.setOpcodeFieldSBit(FCML_TO_CPP_BOOL(src.opcode_field_s_bit)); + dest.setOpcodeFieldWBit(FCML_TO_CPP_BOOL(src.opcode_field_w_bit)); + dest.setIsPseudoOp(FCML_TO_CPP_BOOL(src.is_pseudo_op)); + dest.setPseudoOp(src.pseudo_op); + dest.setShortcut(FCML_TO_CPP_BOOL(src.is_shortcut)); + convert(src.modrm_details, dest.getModRmDetails()); + for (int i = 0; i < FCML_OPERANDS_COUNT; i++) { + convert(src.operand_details[i], dest.getOperandDetails(i)); + } + fcml_uint8_t *code = dest.getInstructionCode(); + for (int i = 0; i < FCML_INSTRUCTION_SIZE; i++) { + code[i] = src.instruction_code[i]; + } + convert(src.prefixes_details, dest.getPrefixesDetails()); + } + + static void convert(const InstructionDetails &src, + fcml_st_instruction_details &dest) { + dest.tuple_type = src.getTupleType(); + dest.addr_mode = src.getAddrMode(); + dest.instruction = src.getInstruction(); + dest.instruction_group = src.getInstructionGroup(); + dest.instruction_size = src.getInstructionSize(); + dest.opcode_field_s_bit = src.isOpcodeFieldSBit(); + dest.opcode_field_w_bit = src.isOpcodeFieldWBit(); + dest.is_pseudo_op = src.isPseudoOp(); + dest.pseudo_op = src.getPseudoOp(); + dest.is_shortcut = src.isShortcut(); + convert(src.getModRmDetails(), dest.modrm_details); + for (int i = 0; i < FCML_OPERANDS_COUNT; i++) { + convert(src.getOperandDetails(i), dest.operand_details[i]); + } + for (int i = 0; i < FCML_INSTRUCTION_SIZE; i++) { + dest.instruction_code[i] = src.getInstructionCode()[i]; + } + convert(src.getPrefixesDetails(), dest.prefixes_details); + } + + static void convert(const fcml_st_disassembler_result &src, + DisassemblerResult &dest) { + TypeConverter::convert(src.instruction, dest.getInstructionInternal()); + convert(src.instruction_details, dest.getInstructionDetailsInternal()); + } + + static void convert(const DisassemblerResult &src, + fcml_st_disassembler_result &dest) { + TypeConverter::convert(src.getInstruction(), dest.instruction); + convert(src.getInstructionDetails(), dest.instruction_details); + } + + static void free(fcml_st_disassembler_result &src) { + TypeConverter::free(src.instruction); + } + +}; + +/** Disassembler wrapper. + * @since 1.1.0 + */ +class Disassembler: public NonCopyable, protected DialectAware { +public: + + /** + * Creates a disassembler instance for the given dialect. + * + * @param dialect The dialect for the disassembler. + * @throw InitException Cannot initialize the disassembler. + * @since 1.1.0 + */ + Disassembler(Dialect &dialect) : + _dialect(dialect) { + fcml_ceh_error error = ::fcml_fn_disassembler_init( + extractDialect(dialect), &_disassembler); + if (error) { + throw InitException( + FCML_TEXT("Cannot initialize the disassembler."), error); + } + } + + /** + * Destructor. + * @since 1.1.0 + */ + virtual ~Disassembler() { + if (_disassembler) { + ::fcml_fn_disassembler_free(_disassembler); + _disassembler = NULL; + } + } + +public: + + /** + * Disassembled the next instruction from the context. + * + * @param ctx Context describing the next instruction to disassemble. + * @param[out] disassemblerResult Disassembler result. + * @throw DisassemblingFailedException Disassemblation failed. + * @return Error code. + * @since 1.1.0 + */ + fcml_ceh_error disassemble(DisassemblerContext &ctx, + DisassemblerResult &disassemblerResult) { + + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR; + + fcml_st_disassembler_context context; + DisassemblerTypeConverter::convert(ctx, context); + + context.disassembler = _disassembler; + + /* Prepare assembler result. */ + fcml_st_disassembler_result disassembler_result; + ::fcml_fn_disassembler_result_prepare(&disassembler_result); + + try { + + disassemblerResult.clean(); + + error = ::fcml_fn_disassemble(&context, &disassembler_result); + + ErrorContainer errorContainer; + ErrorTypeConverter::convert(disassembler_result.errors, + errorContainer); + + disassemblerResult.setErrorContainer(errorContainer); + + if (error && ctx.getDisassemblerConf().isThrowExceptionOnError()) { + ::fcml_fn_disassembler_result_free(&disassembler_result); + throw DisassemblingFailedException( + FCML_TEXT("Assembling failed."), errorContainer, error); + } + + if (!error) { + + // Convert result. + DisassemblerTypeConverter::convert(disassembler_result, + disassemblerResult); + + ctx.getEntryPoint().setIP(context.entry_point.ip); + ctx.setCode(context.code); + ctx.setCodeLength(context.code_length); + + } + + ::fcml_fn_disassembler_result_free(&disassembler_result); + + } catch (std::exception &exc) { + // If anything failed, free assembler results. + ::fcml_fn_disassembler_result_free(&disassembler_result); + throw exc; + } + + return error; + } + + /** + * Gets dialect associated with the disassembler. + * @return The dialect instance associated with the disassembler. + * @since 1.1.0 + */ + Dialect& getDialect() const { + return _dialect; + } + +private: + + /** The dialect associated with the disassembler. */ + Dialect &_dialect; + /** The disassembler instance. */ + fcml_st_disassembler *_disassembler; + +}; + +} + +#endif //FCML_DISASSEMBLER_HPP_ + diff --git a/dependencies/fcml/include/fcml_env.h b/dependencies/fcml/include/fcml_env.h new file mode 100644 index 0000000..7813884 --- /dev/null +++ b/dependencies/fcml/include/fcml_env.h @@ -0,0 +1,96 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_env.h + * API for environment configuration. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ENV_H_ +#define FCML_ENV_H_ + +#include "fcml_types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Memory allocator handler function pointer declaration. + * Memory allocation handlers are used to allocate requested memory in + * environment specific way. + * @param size Size of the memory to allocate. + * @return The allocated memory block or NULL in case of out of memory. + */ +typedef fcml_ptr (*fcml_fp_env_memory_alloc_handler)(fcml_usize size); + +/** Memory reallocator handler function pointer declaration. + * Memory reallocation handlers are used to reallocate requested memory in + * environment specific way. + * @param ptr The memory block to be reallocated. + * @param size Size of the memory to allocate. + * @return The reallocated memory block or NULL in case of out of memory. + */ +typedef fcml_ptr (*fcml_fp_env_memory_realloc_handler)(fcml_ptr ptr, + fcml_usize size); + +/** Memory deallocator handler function pointer declaration. + * Memory deallocation handlers are used to free requested memory blocks in + * environment specific way. + * @param memory_block The memory block to free. + */ +typedef void (*fcml_fp_env_memory_free_handler)(fcml_ptr memory_block); + +/** + * Registers the new dedicated handler responsible for allocating + * memory for the sake of internal FCML implementation. + * @param handler New memory allocation handler. + * @return The replaced memory handler. + */ +LIB_EXPORT fcml_fp_env_memory_alloc_handler LIB_CALL + fcml_fn_env_register_memory_alloc_handler( + fcml_fp_env_memory_alloc_handler handler); + +/** + * Registers the new dedicated handler responsible for reallocating + * memory for the sake + * of internal FCML implementation. + * @param handler New memory reallocation handler. + * @return The replaced memory handler. + */ +LIB_EXPORT fcml_fp_env_memory_realloc_handler LIB_CALL + fcml_fn_env_register_memory_realloc_handler( + fcml_fp_env_memory_realloc_handler handler); + +/** + * Registers the new dedicated handler responsible for deallocating the + * memory for the sake + * of internal FCML implementation. + * @param handler New memory deallocation handler. + * @return The replaced memory handler. + */ +LIB_EXPORT fcml_fp_env_memory_free_handler LIB_CALL + fcml_fn_env_register_memory_free_handler( + fcml_fp_env_memory_free_handler handler); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_ENV_H_ */ diff --git a/dependencies/fcml/include/fcml_errors.h b/dependencies/fcml/include/fcml_errors.h new file mode 100644 index 0000000..3e5fb26 --- /dev/null +++ b/dependencies/fcml/include/fcml_errors.h @@ -0,0 +1,187 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_errors.h + * Global error handling related declarations. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ASM_ERRORS_H_ +#define FCML_ASM_ERRORS_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" + +/** + * @defgroup ERRORS_GROUP Global error codes + * Describes all available global error codes. + * @{ + */ + +/** All global error codes are placed here. */ +enum fcml_en_ceh_error_globals { + /** Operation succeed. */ + FCML_CEH_GEC_NO_ERROR = 0, + /** There is not enough memory to complete operation. */ + FCML_CEH_GEC_OUT_OF_MEMORY = 1, + /** Invalid function arguments. */ + FCML_CEH_GEC_INVALID_INPUT = 2, + /** An internal error occurred. Enable tracing in order to get more + * detailed information. */ + FCML_CEH_GEC_INTERNAL_ERROR = 3, + /** Component hasn't been initialized yet. */ + FCML_CEH_GEC_NOT_INITIALIZED = 4, + /** Incomplete instruction. */ + FCML_CEH_GEC_EOF = 5, + /** Used mainly in case of integers and offsets. */ + FCML_CEH_GEC_VALUE_OUT_OF_RANGE = 6, + /** Chosen operation is not supported in case of given configuration. */ + FCML_CEH_GEC_FEATURE_NOT_SUPPORTED = 7, + /** Unsupported operating mode. For instance encoded instruction needs 16 + * bit operating mode, but we are in 64 bit mode. */ + FCML_CEH_GEC_INVALID_OPERATING_MODE = 8, + /** Chosen addressing form can not be encoded as for example ModR/M field. */ + FCML_CEH_GEC_INVALID_ADDRESSING_FORM = 9, + /** Unsupported instruction form (Instruction may be supported, but not + * with given set of operands). */ + FCML_CEH_GEC_INVALID_INSTRUCTION_FORM = 10, + /** Instruction do not support one of the defined operands. */ + FCML_CEH_GEC_INVALID_OPPERAND = 11, + /** Unknown mnemonic. */ + FCML_CEH_GEC_UNKNOWN_MNEMONIC = 12, + /** Operand size (Operand size attribute) is not allowed in given context. */ + FCML_CEH_GEC_INVALID_OPPERAND_SIZE = 13, + /** Address size (Address size attribute) is not allowed in given context. */ + FCML_CEH_GEC_INVALID_ADDRESS_SIZE = 14, + /** User chosen unsupported addressing form */ + FCML_CEH_GEC_UNKNOWN_INSTRUCTION = 15, + /** Assembler can return this error code if there is not allowed prefix + * defined for given instruction. */ + FCML_CEH_GEC_INVALID_PREFIX = 16, + /** Wrong register type. */ + FCML_CEH_GEC_INVALID_REGISTER_TYPE = 17, + /** Wrong register. */ + FCML_CEH_GEC_INVALID_REGISTER = 18, + /** Error returned by parsers when there is undefined symbol used. */ + FCML_CEH_GEC_UNDEFINED_SYMBOL = 19, + /** Labels are not supported. */ + FCML_CEH_GEC_UNSUPPORTED_LABEL_DECLARATION = 20, + /** Required operand decorator is missing. */ + FCML_CEH_GEC_MISSING_DECORATOR = 21, + /** Given operand decorator is not supported by operand. */ + FCML_CEH_GEC_NOT_SUPPORTED_DECORATOR = 22, + /** Gap between operands found. */ + FCML_CEH_GEC_INVALID_INSTRUCTION_MODEL = 23, + /* Decorator is invalid. For example wrong register type is used in + * opmask decorator. */ + FCML_CEH_GEC_INVALID_OPERAND_DECORATOR = 24 +}; + +/** @} */ + +/** + * @defgroup MESSAGE_ERRORS_GROUP Error codes for textual messages + * Describes all available error codes dedicated to textual errors. + * @{ + */ + +/** Error codes dedicated to textual messages. + * In some cases they are a bit more detailed than corresponding + * global error codes returned in case of errors. Remember that global + * error codes also can be used in place of error codes for textual + * messages. It is why they use different code ranges. + */ +enum fcml_en_ceh_message_errors { + /** Segment register can not be overridden. */ + FCML_CEH_MEC_ERROR_ILLEGAL_SEG_REG_OVERRIDE = 1000, + /** To many operands passed to parser. */ + FCML_CEH_MEC_ERROR_TO_MANY_OPERANDS = 1001, + /** Unsupported pseudo-op value. */ + FCML_CEH_MEC_ERROR_INVALID_PSEUDO_OPCODE_VALUE = 1002, + /** HLE prefix is not allowed in given context. */ + FCML_CEH_MEC_ERROR_HLE_PREFIX_NOT_ALLOWED = 1003, + /** There is more than one HLE prefix. */ + FCML_CEH_MEC_ERROR_HLE_MORE_THAN_ONE_PREFIX = 1004, + /** Expression attempts to divide by 0 */ + FCML_CEH_MEC_ERROR_DIVISION_BY_0 = 1005, + /** Wrong value type used in given context. For example float used + * in place of integer. */ + FCML_CEH_MEC_ERROR_WRONG_VALUE_FORMAT = 1006, + /** Value out of range, for example 32 bit value used as + * segment selector. */ + FCML_CEH_MEC_ERROR_VALUE_OUT_OF_RANGE = 1007, + /** Syntax error from parser. */ + FCML_CEH_MEC_ERROR_INVALID_SYNTAX = 1008, + /** Wrong register type used in place of segment register. */ + FCML_CEH_MEC_ERROR_INVALID_REGISTER_TYPE_SEG = 1009, + /** Symbol is already defined in parser's symbol table. */ + FCML_CEH_MEC_ERROR_SYMBOL_ALREADY_DEFINED = 1010, + /** Symbol is undefined. */ + FCML_CEH_MEC_ERROR_UNDEFINED_SYMBOL = 1011, + /** Parsed line exceed maximal allowed length. */ + FCML_CEH_MEC_ERROR_PARSED_LINE_TOO_LONG = 1012, + /** Invalid vector length size. */ + FCML_CEH_MEC_ERROR_INVALID_VECTOR_LENGTH = 1013 +}; + +/** Codes for textual warnings. */ +enum fcml_en_ceh_message_warnings { + /** Value out of range */ + FCML_CEH_MEW_WARN_VALUE_OUT_OF_RANGE = 2000, + /** Invalid addressing mode. */ + FCML_CEH_MEW_WARN_INVALID_ADDRESSING_MODE = 2001 +}; + +/** @} */ + +/** All error codes should be held in variables of this type. */ +typedef fcml_uint16_t fcml_ceh_error; + +/** Error levels. */ +typedef enum fcml_en_ceh_error_level { + /** Warnings are reported when processing does not need to be stopped. */ + FCML_EN_CEH_EL_WARN, + /** Errors are reported when something more important happened and + * processing should be stopped. */ + FCML_EN_CEH_EL_ERROR +} fcml_en_ceh_error_level; + +/** Information about one particular error/warning. */ +typedef struct fcml_st_ceh_error_info { + /** Next error/warning on the list. */ + struct fcml_st_ceh_error_info *next_error; + /** Error message. */ + fcml_string message; + /** Error code */ + fcml_ceh_error code; + /** Error level. */ + fcml_en_ceh_error_level level; +} fcml_st_ceh_error_info; + +/** Container for all collected errors and warnings. */ +typedef struct fcml_st_ceh_error_container { + /** All errors and warnings going here. */ + fcml_st_ceh_error_info *errors; + /** Pointer to the last error/warning on the list. */ + fcml_st_ceh_error_info *last_error; +} fcml_st_ceh_error_container; + +#endif /* FCML_ASM_ERRORS_H_ */ diff --git a/dependencies/fcml/include/fcml_errors.hpp b/dependencies/fcml/include/fcml_errors.hpp new file mode 100644 index 0000000..2057094 --- /dev/null +++ b/dependencies/fcml/include/fcml_errors.hpp @@ -0,0 +1,388 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_errors.hpp + * C++ wrapper for the FCML errors handling. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ERRORS_HPP_ +#define FCML_ERRORS_HPP_ + +#include + +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_common.hpp" + +namespace fcml { + +/** + * Contains an error message together with error level and error code. + * @since 1.1.0 + */ +class ErrorInfo { +public: + + /** Error level. + * @since 1.1.0 + */ + enum ErrorLevel { + EL_ERROR, + EL_WARN + }; + +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + ErrorInfo() : + _code( FCML_CEH_GEC_NO_ERROR ), + _level( EL_ERROR ) { + } + + /** + * Creates an error for given message and optional error code and level. + * @param message The error message. + * @param code The error code. + * @param level The error level. + * @since 1.1.0 + */ + ErrorInfo( const fcml_cstring &message, fcml_ceh_error code = FCML_CEH_GEC_NO_ERROR, ErrorLevel level = EL_ERROR ) : + _message( message ), + _code( code ), + _level( level ) { + } + +public: + + /** + * Gets error code. + * @return The error code. + * @since 1.1.0 + */ + fcml_ceh_error getCode() const { + return _code; + } + + /** + * Sets a new error code. + * @param code The new error code. + * @since 1.1.0 + */ + void setCode(fcml_ceh_error code) { + _code = code; + } + + /** + * Gets error level. + * @return The error level. + * @since 1.1.0 + */ + ErrorLevel getLevel() const { + return _level; + } + + /** + * Sets error level. + * @param level The error level. + * @since 1.1.0 + */ + void setLevel(ErrorLevel level) { + _level = level; + } + + /** + * Gets error message. + * @return The error message. + * @since 1.1.0 + */ + const fcml_cstring& getMessage() const { + return _message; + } + + /** + * Sets error message. + * @param message The error message. + * @since 1.1.0 + */ + void setMessage(const fcml_cstring& message) { + _message = message; + } + +private: + + /** Error message. */ + fcml_cstring _message; + /** Error code */ + fcml_ceh_error _code; + /** Error level. */ + ErrorLevel _level; + +}; + +/** + * Wraps multiple errors into one component. + * @since 1.1.0 + */ +class ErrorContainer { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + ErrorContainer() : + _isWarn(false), + _isError(false) { + } + + /** + * Gets number of errors in the container. + * @return The number of errors. + * @since 1.1.0 + */ + fcml_usize getSize() const { + return static_cast( _errorInfos.size() ); + } + + /** + * Gets an error at given index. + * @param index The error index. + * @return The error at given index. + * @throw BadArgumentException If index is out of bound. + * @since 1.1.0 + */ + const ErrorInfo& operator[]( fcml_usize index ) const { + checkVectorAccess( index ); + return _errorInfos[index]; + } + + /** + * Gets an error at given index. + * @param index The error index. + * @return The error at given index. + * @since 1.1.0 + */ + ErrorInfo& operator[]( fcml_usize index ) { + checkVectorAccess( index ); + return _errorInfos[index]; + } + + /** + * Adds a new error into the container. + * @param errorInfo The new error to add. + * @since 1.1.0 + */ + void addErrorInfo( const ErrorInfo &errorInfo ) { + _errorInfos.push_back(errorInfo); + switch( errorInfo.getLevel() ) { + case ErrorInfo::EL_ERROR: + _isError = true; + break; + case ErrorInfo::EL_WARN: + _isWarn = true; + break; + } + } + + /** + * Returns true if there is any error in the container. + * @return True if there is any error in the container. + * @since 1.1.0 + */ + bool isError() const { + return _isError; + } + + /** + * Returns true if there is any warning in the container. + * @return True if there is any warning in the container. + * @since 1.1.0 + */ + bool isWarn() const { + return _isWarn; + } + + /** + * Gets true if there is any error or warning in the container. + * @return True if there is any error or warning in the container. + * @since 1.1.0 + */ + bool isEmpty() const { + return _errorInfos.empty(); + } + + /** + * Returns the first error from the container. + * @return The first error. + * @throw IllegalStateException Container is empty. + * @since 1.1.0 + */ + const ErrorInfo& getFirstError() const { + if( isEmpty() ) { + throw IllegalStateException( FCML_TEXT( "Container is empty." ) ); + } + return _errorInfos[0]; + } + + /** + * Returns the first error from the container. + * @return The first error. + * @throw IllegalStateException Container is empty. + * @since 1.1.0 + */ + ErrorInfo& getFirstError() { + if( isEmpty() ) { + throw IllegalStateException( FCML_TEXT( "Container is empty." ) ); + } + return _errorInfos[0]; + } + + /** + * Returns the first error message from the container. + * @return The first error message. + * @since 1.1.0 + */ + fcml_cstring getFirstErrorMessage() const { + fcml_cstring message; + try { + const ErrorInfo &errorInfo = getFirstError(); + message = errorInfo.getMessage(); + } catch( IllegalStateException &exc ) { + } + return message; + } + + /** + * Prepares an error message basing on the first error in the container. + * @param message A prefix for the destination error message. + * @return Error message. + * @since 1.1.0 + */ + fcml_cstring prepareErrorMessage( const fcml_cstring &message ) const { + const fcml_cstring errorMessage = getFirstErrorMessage(); + if( errorMessage.empty() ) { + return message + FCML_TEXT('.'); + } else { + return message + FCML_TEXT(": ") + errorMessage; + } + } + + /** + * Cleans all errors and warnings. + * @since 1.1.0 + */ + void clean() { + _errorInfos.clear(); + _isWarn = false; + _isError = false; + } + +private: + + /** + * Checks bounds of the index. + * @param index The index to check. + * @throw BadArgumentException Index out of bound. + * @since 1.1.0 + */ + void checkVectorAccess( fcml_usize index ) const { + if( index >= _errorInfos.size() ) { + throw BadArgumentException( FCML_TEXT( "Index exceeds the allowed number of error info structures." ) ); + } + } + +private: + /** Error messages. */ + std::vector _errorInfos; + /* Sets if there is any warning in the container. */ + bool _isWarn; + /* Sets if there is any error in the container. */ + bool _isError; +}; + +/** + * Types converter. + * @since 1.1.0 + */ +class ErrorTypeConverter { +public: + + static void convert( const fcml_st_ceh_error_container &src, ErrorContainer &dest ) { + fcml_st_ceh_error_info *error = src.errors; + while( error ) { + ErrorInfo::ErrorLevel level = ( error->level == FCML_EN_CEH_EL_ERROR ) ? ErrorInfo::EL_ERROR : ErrorInfo::EL_WARN; + dest.addErrorInfo( ErrorInfo( error->message, error->code, level ) ); + error = error->next_error; + } + } + +}; + +/** + * Base class for all exceptions that are aware of ErrorContainer. + * @since 1.1.0 + */ +class ErrorContainerAwareException: public BaseException { +public: + + /** + * Creates an error container aware exception instance and sets basic information for it. + * @param msg An error message. + * @param errorContainer An error container for exception. + * @param error An optional FCML error code. + * @since 1.1.0 + */ + ErrorContainerAwareException( const fcml_cstring &msg, const ErrorContainer &errorContainer, fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR ) : + BaseException( msg, error ), _errorContainer( errorContainer ) { + } + + /** + * Gets a reference to an error container associated with the exception. + * @return The error container. + * @since 1.1.0 + */ + const ErrorContainer& getErrorContainer() const { + return _errorContainer; + } + + /** + * Sets a new error container for the exception. + * @param errorContainer The new error container to be set for the exception. + * @since 1.1.0 + */ + void setErrorContainer(const ErrorContainer& errorContainer) { + _errorContainer = errorContainer; + } + +private: + + /** A container for errors. */ + ErrorContainer _errorContainer; + +}; + +} + +#endif // FCML_ERRORS_HPP_ diff --git a/dependencies/fcml/include/fcml_gas_dialect.h b/dependencies/fcml/include/fcml_gas_dialect.h new file mode 100644 index 0000000..a0e0697 --- /dev/null +++ b/dependencies/fcml/include/fcml_gas_dialect.h @@ -0,0 +1,62 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_gas_dialect.h + * AT&T dialect implementation. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ASM_DIALECT_GAS_H_ +#define FCML_ASM_DIALECT_GAS_H_ + +#include "fcml_lib_export.h" + +#include "fcml_errors.h" +#include "fcml_dialect.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Disables "SystemV/386 SVR3.2" compatibility for the non-commutative + * arithmetic floating point operations with two register operands. */ +#define FCML_GAS_DIALECT_CF_SYSV_SVR32_INCOMPATIBLE 0x00000001 + +/** Default combination of configuration flags. */ +#define FCML_GAS_DIALECT_CF_DEFAULT 0 + +/** + * Initializes AT&T dialect. + * Prepares new instance of AT&T dialect for given set of configuration flags. + * Every dialect has to be freed using fcml_fn_dialect_free() function. + * + * @param config_flags Configuration flags dedicated to the dialect. + * @param[out] dialect Prepared dialect instance. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_dialect_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_dialect_init_gas( + fcml_uint32_t config_flags, fcml_st_dialect **dialect); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_ASM_DIALECT_GAS_H_ */ diff --git a/dependencies/fcml/include/fcml_gas_dialect.hpp b/dependencies/fcml/include/fcml_gas_dialect.hpp new file mode 100644 index 0000000..7080193 --- /dev/null +++ b/dependencies/fcml/include/fcml_gas_dialect.hpp @@ -0,0 +1,66 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_gas_dialect.hpp + * C++ wrapper for the AT&T dialect. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_GAS_DIALECT_HPP_ +#define FCML_GAS_DIALECT_HPP_ + +#include "fcml_dialect.hpp" + +#include "fcml_gas_dialect.h" + +namespace fcml { + +/** Wraps the AT&T dialect. + * @since 1.1.0 + */ +class GASDialect: public Dialect { +public: + /** + * Creates AT&T dialect. + * + * @param flags Optional flags. + * @since 1.1.0 + */ + GASDialect(fcml_uint32_t flags = FCML_GAS_DIALECT_CF_DEFAULT) { + fcml_st_dialect *dialect; + fcml_ceh_error error = ::fcml_fn_dialect_init_gas(flags, &dialect); + if (error) { + throw InitException( + FCML_TEXT("Can not initialize the AT&T dialect."), error); + } + setDialect(dialect); + } + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~GASDialect() { + } +}; + +} + +#endif /* FCML_GAS_DIALECT_HPP_ */ diff --git a/dependencies/fcml/include/fcml_gas_mnemonics.cpp b/dependencies/fcml/include/fcml_gas_mnemonics.cpp new file mode 100644 index 0000000..4623b13 --- /dev/null +++ b/dependencies/fcml/include/fcml_gas_mnemonics.cpp @@ -0,0 +1,1934 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_gas_mnemonics.cpp + * Definitions of AT&T mnemonics for C++. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#include "fcml_gas_mnemonics.hpp" + +namespace fcml { +namespace gas { + +extern const fcml_cstring M_AAA = _FT("aaa"); +extern const fcml_cstring M_AAD = _FT("aad"); +extern const fcml_cstring M_AAM = _FT("aam"); +extern const fcml_cstring M_AAS = _FT("aas"); +extern const fcml_cstring M_ADC = _FT("adc"); +extern const fcml_cstring M_ADCB = _FT("adcb"); +extern const fcml_cstring M_ADCL = _FT("adcl"); +extern const fcml_cstring M_ADCQ = _FT("adcq"); +extern const fcml_cstring M_ADCW = _FT("adcw"); +extern const fcml_cstring M_ADCX = _FT("adcx"); +extern const fcml_cstring M_ADD = _FT("add"); +extern const fcml_cstring M_ADDB = _FT("addb"); +extern const fcml_cstring M_ADDL = _FT("addl"); +extern const fcml_cstring M_ADDPD = _FT("addpd"); +extern const fcml_cstring M_ADDPS = _FT("addps"); +extern const fcml_cstring M_ADDQ = _FT("addq"); +extern const fcml_cstring M_ADDSD = _FT("addsd"); +extern const fcml_cstring M_ADDSS = _FT("addss"); +extern const fcml_cstring M_ADDSUBPD = _FT("addsubpd"); +extern const fcml_cstring M_ADDSUBPS = _FT("addsubps"); +extern const fcml_cstring M_ADDW = _FT("addw"); +extern const fcml_cstring M_ADOX = _FT("adox"); +extern const fcml_cstring M_AESDEC = _FT("aesdec"); +extern const fcml_cstring M_AESDECLAST = _FT("aesdeclast"); +extern const fcml_cstring M_AESENC = _FT("aesenc"); +extern const fcml_cstring M_AESENCLAST = _FT("aesenclast"); +extern const fcml_cstring M_AESIMC = _FT("aesimc"); +extern const fcml_cstring M_AESKEYGENASSIST = _FT("aeskeygenassist"); +extern const fcml_cstring M_AND = _FT("and"); +extern const fcml_cstring M_ANDB = _FT("andb"); +extern const fcml_cstring M_ANDL = _FT("andl"); +extern const fcml_cstring M_ANDN = _FT("andn"); +extern const fcml_cstring M_ANDNPD = _FT("andnpd"); +extern const fcml_cstring M_ANDNPS = _FT("andnps"); +extern const fcml_cstring M_ANDPD = _FT("andpd"); +extern const fcml_cstring M_ANDPS = _FT("andps"); +extern const fcml_cstring M_ANDQ = _FT("andq"); +extern const fcml_cstring M_ANDW = _FT("andw"); +extern const fcml_cstring M_ARPL = _FT("arpl"); +extern const fcml_cstring M_BEXR = _FT("bexr"); +extern const fcml_cstring M_BEXTR = _FT("bextr"); +extern const fcml_cstring M_BLCFILL = _FT("blcfill"); +extern const fcml_cstring M_BLCI = _FT("blci"); +extern const fcml_cstring M_BLCIC = _FT("blcic"); +extern const fcml_cstring M_BLCMSK = _FT("blcmsk"); +extern const fcml_cstring M_BLCS = _FT("blcs"); +extern const fcml_cstring M_BLENDPD = _FT("blendpd"); +extern const fcml_cstring M_BLENDPS = _FT("blendps"); +extern const fcml_cstring M_BLENDVPD = _FT("blendvpd"); +extern const fcml_cstring M_BLENDVPS = _FT("blendvps"); +extern const fcml_cstring M_BLSFILL = _FT("blsfill"); +extern const fcml_cstring M_BLSI = _FT("blsi"); +extern const fcml_cstring M_BLSIC = _FT("blsic"); +extern const fcml_cstring M_BLSMSK = _FT("blsmsk"); +extern const fcml_cstring M_BLSR = _FT("blsr"); +extern const fcml_cstring M_BOUND = _FT("bound"); +extern const fcml_cstring M_BSF = _FT("bsf"); +extern const fcml_cstring M_BSR = _FT("bsr"); +extern const fcml_cstring M_BSWAP = _FT("bswap"); +extern const fcml_cstring M_BT = _FT("bt"); +extern const fcml_cstring M_BTC = _FT("btc"); +extern const fcml_cstring M_BTCL = _FT("btcl"); +extern const fcml_cstring M_BTCQ = _FT("btcq"); +extern const fcml_cstring M_BTCW = _FT("btcw"); +extern const fcml_cstring M_BTL = _FT("btl"); +extern const fcml_cstring M_BTQ = _FT("btq"); +extern const fcml_cstring M_BTR = _FT("btr"); +extern const fcml_cstring M_BTRL = _FT("btrl"); +extern const fcml_cstring M_BTRQ = _FT("btrq"); +extern const fcml_cstring M_BTRW = _FT("btrw"); +extern const fcml_cstring M_BTS = _FT("bts"); +extern const fcml_cstring M_BTSL = _FT("btsl"); +extern const fcml_cstring M_BTSQ = _FT("btsq"); +extern const fcml_cstring M_BTSW = _FT("btsw"); +extern const fcml_cstring M_BTW = _FT("btw"); +extern const fcml_cstring M_BZHI = _FT("bzhi"); +extern const fcml_cstring M_CALL = _FT("call"); +extern const fcml_cstring M_CALLQ = _FT("callq"); +extern const fcml_cstring M_CALLW = _FT("callw"); +extern const fcml_cstring M_CBTW = _FT("cbtw"); +extern const fcml_cstring M_CLAC = _FT("clac"); +extern const fcml_cstring M_CLC = _FT("clc"); +extern const fcml_cstring M_CLD = _FT("cld"); +extern const fcml_cstring M_CLFLUSH = _FT("clflush"); +extern const fcml_cstring M_CLGI = _FT("clgi"); +extern const fcml_cstring M_CLI = _FT("cli"); +extern const fcml_cstring M_CLTD = _FT("cltd"); +extern const fcml_cstring M_CLTQ = _FT("cltq"); +extern const fcml_cstring M_CLTS = _FT("clts"); +extern const fcml_cstring M_CMC = _FT("cmc"); +extern const fcml_cstring M_CMOVA = _FT("cmova"); +extern const fcml_cstring M_CMOVAE = _FT("cmovae"); +extern const fcml_cstring M_CMOVB = _FT("cmovb"); +extern const fcml_cstring M_CMOVBE = _FT("cmovbe"); +extern const fcml_cstring M_CMOVC = _FT("cmovc"); +extern const fcml_cstring M_CMOVENE = _FT("cmovene"); +extern const fcml_cstring M_CMOVG = _FT("cmovg"); +extern const fcml_cstring M_CMOVGE = _FT("cmovge"); +extern const fcml_cstring M_CMOVL = _FT("cmovl"); +extern const fcml_cstring M_CMOVLE = _FT("cmovle"); +extern const fcml_cstring M_CMOVNA = _FT("cmovna"); +extern const fcml_cstring M_CMOVNAE = _FT("cmovnae"); +extern const fcml_cstring M_CMOVNB = _FT("cmovnb"); +extern const fcml_cstring M_CMOVNBE = _FT("cmovnbe"); +extern const fcml_cstring M_CMOVNC = _FT("cmovnc"); +extern const fcml_cstring M_CMOVNG = _FT("cmovng"); +extern const fcml_cstring M_CMOVNGE = _FT("cmovnge"); +extern const fcml_cstring M_CMOVNL = _FT("cmovnl"); +extern const fcml_cstring M_CMOVNLE = _FT("cmovnle"); +extern const fcml_cstring M_CMOVNO = _FT("cmovno"); +extern const fcml_cstring M_CMOVNP = _FT("cmovnp"); +extern const fcml_cstring M_CMOVNS = _FT("cmovns"); +extern const fcml_cstring M_CMOVNZ = _FT("cmovnz"); +extern const fcml_cstring M_CMOVO = _FT("cmovo"); +extern const fcml_cstring M_CMOVP = _FT("cmovp"); +extern const fcml_cstring M_CMOVPE = _FT("cmovpe"); +extern const fcml_cstring M_CMOVPO = _FT("cmovpo"); +extern const fcml_cstring M_CMOVS = _FT("cmovs"); +extern const fcml_cstring M_CMOVZ = _FT("cmovz"); +extern const fcml_cstring M_CMP = _FT("cmp"); +extern const fcml_cstring M_CMPB = _FT("cmpb"); +extern const fcml_cstring M_CMPEQPD = _FT("cmpeqpd"); +extern const fcml_cstring M_CMPEQPS = _FT("cmpeqps"); +extern const fcml_cstring M_CMPEQSD = _FT("cmpeqsd"); +extern const fcml_cstring M_CMPEQSS = _FT("cmpeqss"); +extern const fcml_cstring M_CMPL = _FT("cmpl"); +extern const fcml_cstring M_CMPLEPD = _FT("cmplepd"); +extern const fcml_cstring M_CMPLEPS = _FT("cmpleps"); +extern const fcml_cstring M_CMPLESD = _FT("cmplesd"); +extern const fcml_cstring M_CMPLESS = _FT("cmpless"); +extern const fcml_cstring M_CMPLTPD = _FT("cmpltpd"); +extern const fcml_cstring M_CMPLTPS = _FT("cmpltps"); +extern const fcml_cstring M_CMPLTSD = _FT("cmpltsd"); +extern const fcml_cstring M_CMPLTSS = _FT("cmpltss"); +extern const fcml_cstring M_CMPNEQPD = _FT("cmpneqpd"); +extern const fcml_cstring M_CMPNEQPS = _FT("cmpneqps"); +extern const fcml_cstring M_CMPNEQSD = _FT("cmpneqsd"); +extern const fcml_cstring M_CMPNEQSS = _FT("cmpneqss"); +extern const fcml_cstring M_CMPNLEPD = _FT("cmpnlepd"); +extern const fcml_cstring M_CMPNLEPS = _FT("cmpnleps"); +extern const fcml_cstring M_CMPNLESD = _FT("cmpnlesd"); +extern const fcml_cstring M_CMPNLESS = _FT("cmpnless"); +extern const fcml_cstring M_CMPNLTPD = _FT("cmpnltpd"); +extern const fcml_cstring M_CMPNLTPS = _FT("cmpnltps"); +extern const fcml_cstring M_CMPNLTSD = _FT("cmpnltsd"); +extern const fcml_cstring M_CMPNLTSS = _FT("cmpnltss"); +extern const fcml_cstring M_CMPORDPD = _FT("cmpordpd"); +extern const fcml_cstring M_CMPORDPS = _FT("cmpordps"); +extern const fcml_cstring M_CMPORDSD = _FT("cmpordsd"); +extern const fcml_cstring M_CMPORDSS = _FT("cmpordss"); +extern const fcml_cstring M_CMPPD = _FT("cmppd"); +extern const fcml_cstring M_CMPPS = _FT("cmpps"); +extern const fcml_cstring M_CMPQ = _FT("cmpq"); +extern const fcml_cstring M_CMPSB = _FT("cmpsb"); +extern const fcml_cstring M_CMPSD = _FT("cmpsd"); +extern const fcml_cstring M_CMPSL = _FT("cmpsl"); +extern const fcml_cstring M_CMPSQ = _FT("cmpsq"); +extern const fcml_cstring M_CMPSS = _FT("cmpss"); +extern const fcml_cstring M_CMPSW = _FT("cmpsw"); +extern const fcml_cstring M_CMPUNORDPD = _FT("cmpunordpd"); +extern const fcml_cstring M_CMPUNORDPS = _FT("cmpunordps"); +extern const fcml_cstring M_CMPUNORDSD = _FT("cmpunordsd"); +extern const fcml_cstring M_CMPUNORDSS = _FT("cmpunordss"); +extern const fcml_cstring M_CMPW = _FT("cmpw"); +extern const fcml_cstring M_CMPXCHG = _FT("cmpxchg"); +extern const fcml_cstring M_CMPXCHG16B = _FT("cmpxchg16b"); +extern const fcml_cstring M_CMPXCHG8B = _FT("cmpxchg8b"); +extern const fcml_cstring M_COMISD = _FT("comisd"); +extern const fcml_cstring M_COMISS = _FT("comiss"); +extern const fcml_cstring M_CPUID = _FT("cpuid"); +extern const fcml_cstring M_CQTO = _FT("cqto"); +extern const fcml_cstring M_CRC32B = _FT("crc32b"); +extern const fcml_cstring M_CRC32L = _FT("crc32l"); +extern const fcml_cstring M_CRC32Q = _FT("crc32q"); +extern const fcml_cstring M_CRC32W = _FT("crc32w"); +extern const fcml_cstring M_CVTDQ2PD = _FT("cvtdq2pd"); +extern const fcml_cstring M_CVTDQ2PS = _FT("cvtdq2ps"); +extern const fcml_cstring M_CVTPD2DQ = _FT("cvtpd2dq"); +extern const fcml_cstring M_CVTPD2PI = _FT("cvtpd2pi"); +extern const fcml_cstring M_CVTPD2PS = _FT("cvtpd2ps"); +extern const fcml_cstring M_CVTPI2PD = _FT("cvtpi2pd"); +extern const fcml_cstring M_CVTPI2PS = _FT("cvtpi2ps"); +extern const fcml_cstring M_CVTPS2DQ = _FT("cvtps2dq"); +extern const fcml_cstring M_CVTPS2PD = _FT("cvtps2pd"); +extern const fcml_cstring M_CVTPS2PI = _FT("cvtps2pi"); +extern const fcml_cstring M_CVTSD2SI = _FT("cvtsd2si"); +extern const fcml_cstring M_CVTSD2SS = _FT("cvtsd2ss"); +extern const fcml_cstring M_CVTSI2SDL = _FT("cvtsi2sdl"); +extern const fcml_cstring M_CVTSI2SDQ = _FT("cvtsi2sdq"); +extern const fcml_cstring M_CVTSI2SSL = _FT("cvtsi2ssl"); +extern const fcml_cstring M_CVTSI2SSQ = _FT("cvtsi2ssq"); +extern const fcml_cstring M_CVTSS2SD = _FT("cvtss2sd"); +extern const fcml_cstring M_CVTSS2SI = _FT("cvtss2si"); +extern const fcml_cstring M_CVTTPD2DQ = _FT("cvttpd2dq"); +extern const fcml_cstring M_CVTTPD2PI = _FT("cvttpd2pi"); +extern const fcml_cstring M_CVTTPS2DQ = _FT("cvttps2dq"); +extern const fcml_cstring M_CVTTPS2PI = _FT("cvttps2pi"); +extern const fcml_cstring M_CVTTSD2SI = _FT("cvttsd2si"); +extern const fcml_cstring M_CVTTSS2SI = _FT("cvttss2si"); +extern const fcml_cstring M_CWTD = _FT("cwtd"); +extern const fcml_cstring M_CWTL = _FT("cwtl"); +extern const fcml_cstring M_DAA = _FT("daa"); +extern const fcml_cstring M_DAS = _FT("das"); +extern const fcml_cstring M_DEC = _FT("dec"); +extern const fcml_cstring M_DECB = _FT("decb"); +extern const fcml_cstring M_DECL = _FT("decl"); +extern const fcml_cstring M_DECQ = _FT("decq"); +extern const fcml_cstring M_DECW = _FT("decw"); +extern const fcml_cstring M_DIV = _FT("div"); +extern const fcml_cstring M_DIVB = _FT("divb"); +extern const fcml_cstring M_DIVL = _FT("divl"); +extern const fcml_cstring M_DIVPD = _FT("divpd"); +extern const fcml_cstring M_DIVPS = _FT("divps"); +extern const fcml_cstring M_DIVQ = _FT("divq"); +extern const fcml_cstring M_DIVSD = _FT("divsd"); +extern const fcml_cstring M_DIVSS = _FT("divss"); +extern const fcml_cstring M_DIVW = _FT("divw"); +extern const fcml_cstring M_DPPD = _FT("dppd"); +extern const fcml_cstring M_DPPS = _FT("dpps"); +extern const fcml_cstring M_EMMS = _FT("emms"); +extern const fcml_cstring M_ENTER = _FT("enter"); +extern const fcml_cstring M_ENTERQ = _FT("enterq"); +extern const fcml_cstring M_EXTRACTPS = _FT("extractps"); +extern const fcml_cstring M_EXTRQ = _FT("extrq"); +extern const fcml_cstring M_F2XM1 = _FT("f2xm1"); +extern const fcml_cstring M_FABS = _FT("fabs"); +extern const fcml_cstring M_FADD = _FT("fadd"); +extern const fcml_cstring M_FADDL = _FT("faddl"); +extern const fcml_cstring M_FADDP = _FT("faddp"); +extern const fcml_cstring M_FADDS = _FT("fadds"); +extern const fcml_cstring M_FBLD = _FT("fbld"); +extern const fcml_cstring M_FBSTP = _FT("fbstp"); +extern const fcml_cstring M_FCHS = _FT("fchs"); +extern const fcml_cstring M_FCLEX = _FT("fclex"); +extern const fcml_cstring M_FCMOVB = _FT("fcmovb"); +extern const fcml_cstring M_FCMOVBE = _FT("fcmovbe"); +extern const fcml_cstring M_FCMOVE = _FT("fcmove"); +extern const fcml_cstring M_FCMOVNB = _FT("fcmovnb"); +extern const fcml_cstring M_FCMOVNBE = _FT("fcmovnbe"); +extern const fcml_cstring M_FCMOVNE = _FT("fcmovne"); +extern const fcml_cstring M_FCMOVNU = _FT("fcmovnu"); +extern const fcml_cstring M_FCMOVU = _FT("fcmovu"); +extern const fcml_cstring M_FCOM = _FT("fcom"); +extern const fcml_cstring M_FCOMI = _FT("fcomi"); +extern const fcml_cstring M_FCOMIP = _FT("fcomip"); +extern const fcml_cstring M_FCOML = _FT("fcoml"); +extern const fcml_cstring M_FCOMP = _FT("fcomp"); +extern const fcml_cstring M_FCOMPL = _FT("fcompl"); +extern const fcml_cstring M_FCOMPP = _FT("fcompp"); +extern const fcml_cstring M_FCOMPS = _FT("fcomps"); +extern const fcml_cstring M_FCOMS = _FT("fcoms"); +extern const fcml_cstring M_FCOS = _FT("fcos"); +extern const fcml_cstring M_FDECSTP = _FT("fdecstp"); +extern const fcml_cstring M_FDIV = _FT("fdiv"); +extern const fcml_cstring M_FDIVL = _FT("fdivl"); +extern const fcml_cstring M_FDIVP = _FT("fdivp"); +extern const fcml_cstring M_FDIVR = _FT("fdivr"); +extern const fcml_cstring M_FDIVRL = _FT("fdivrl"); +extern const fcml_cstring M_FDIVRP = _FT("fdivrp"); +extern const fcml_cstring M_FDIVRS = _FT("fdivrs"); +extern const fcml_cstring M_FDIVS = _FT("fdivs"); +extern const fcml_cstring M_FEMMS = _FT("femms"); +extern const fcml_cstring M_FFREE = _FT("ffree"); +extern const fcml_cstring M_FIADD = _FT("fiadd"); +extern const fcml_cstring M_FIADDL = _FT("fiaddl"); +extern const fcml_cstring M_FICOM = _FT("ficom"); +extern const fcml_cstring M_FICOML = _FT("ficoml"); +extern const fcml_cstring M_FICOMP = _FT("ficomp"); +extern const fcml_cstring M_FICOMPL = _FT("ficompl"); +extern const fcml_cstring M_FIDIV = _FT("fidiv"); +extern const fcml_cstring M_FIDIVL = _FT("fidivl"); +extern const fcml_cstring M_FIDIVR = _FT("fidivr"); +extern const fcml_cstring M_FIDIVRL = _FT("fidivrl"); +extern const fcml_cstring M_FILD = _FT("fild"); +extern const fcml_cstring M_FILDL = _FT("fildl"); +extern const fcml_cstring M_FILDLL = _FT("fildll"); +extern const fcml_cstring M_FIMUL = _FT("fimul"); +extern const fcml_cstring M_FIMULL = _FT("fimull"); +extern const fcml_cstring M_FINCSTP = _FT("fincstp"); +extern const fcml_cstring M_FINIT = _FT("finit"); +extern const fcml_cstring M_FIST = _FT("fist"); +extern const fcml_cstring M_FISTL = _FT("fistl"); +extern const fcml_cstring M_FISTP = _FT("fistp"); +extern const fcml_cstring M_FISTPL = _FT("fistpl"); +extern const fcml_cstring M_FISTPLL = _FT("fistpll"); +extern const fcml_cstring M_FISTTP = _FT("fisttp"); +extern const fcml_cstring M_FISTTPL = _FT("fisttpl"); +extern const fcml_cstring M_FISTTPLL = _FT("fisttpll"); +extern const fcml_cstring M_FISUB = _FT("fisub"); +extern const fcml_cstring M_FISUBL = _FT("fisubl"); +extern const fcml_cstring M_FISUBR = _FT("fisubr"); +extern const fcml_cstring M_FISUBRL = _FT("fisubrl"); +extern const fcml_cstring M_FLD = _FT("fld"); +extern const fcml_cstring M_FLD1 = _FT("fld1"); +extern const fcml_cstring M_FLDCW = _FT("fldcw"); +extern const fcml_cstring M_FLDENV = _FT("fldenv"); +extern const fcml_cstring M_FLDENVS = _FT("fldenvs"); +extern const fcml_cstring M_FLDL = _FT("fldl"); +extern const fcml_cstring M_FLDL2E = _FT("fldl2e"); +extern const fcml_cstring M_FLDL2T = _FT("fldl2t"); +extern const fcml_cstring M_FLDLG2 = _FT("fldlg2"); +extern const fcml_cstring M_FLDLN2 = _FT("fldln2"); +extern const fcml_cstring M_FLDPI = _FT("fldpi"); +extern const fcml_cstring M_FLDS = _FT("flds"); +extern const fcml_cstring M_FLDT = _FT("fldt"); +extern const fcml_cstring M_FLDZ = _FT("fldz"); +extern const fcml_cstring M_FMUL = _FT("fmul"); +extern const fcml_cstring M_FMULL = _FT("fmull"); +extern const fcml_cstring M_FMULP = _FT("fmulp"); +extern const fcml_cstring M_FMULS = _FT("fmuls"); +extern const fcml_cstring M_FNCLEX = _FT("fnclex"); +extern const fcml_cstring M_FNINIT = _FT("fninit"); +extern const fcml_cstring M_FNOP = _FT("fnop"); +extern const fcml_cstring M_FNSAVE = _FT("fnsave"); +extern const fcml_cstring M_FNSAVES = _FT("fnsaves"); +extern const fcml_cstring M_FNSTCW = _FT("fnstcw"); +extern const fcml_cstring M_FNSTENV = _FT("fnstenv"); +extern const fcml_cstring M_FNSTENVS = _FT("fnstenvs"); +extern const fcml_cstring M_FNSTSW = _FT("fnstsw"); +extern const fcml_cstring M_FPATAN = _FT("fpatan"); +extern const fcml_cstring M_FPREM = _FT("fprem"); +extern const fcml_cstring M_FPREM1 = _FT("fprem1"); +extern const fcml_cstring M_FPTAN = _FT("fptan"); +extern const fcml_cstring M_FRNDINT = _FT("frndint"); +extern const fcml_cstring M_FRSTOR = _FT("frstor"); +extern const fcml_cstring M_FRSTORS = _FT("frstors"); +extern const fcml_cstring M_FSAVE = _FT("fsave"); +extern const fcml_cstring M_FSAVES = _FT("fsaves"); +extern const fcml_cstring M_FSCALE = _FT("fscale"); +extern const fcml_cstring M_FSIN = _FT("fsin"); +extern const fcml_cstring M_FSINCOS = _FT("fsincos"); +extern const fcml_cstring M_FSQRT = _FT("fsqrt"); +extern const fcml_cstring M_FST = _FT("fst"); +extern const fcml_cstring M_FSTCW = _FT("fstcw"); +extern const fcml_cstring M_FSTENV = _FT("fstenv"); +extern const fcml_cstring M_FSTENVS = _FT("fstenvs"); +extern const fcml_cstring M_FSTL = _FT("fstl"); +extern const fcml_cstring M_FSTP = _FT("fstp"); +extern const fcml_cstring M_FSTPL = _FT("fstpl"); +extern const fcml_cstring M_FSTPS = _FT("fstps"); +extern const fcml_cstring M_FSTPT = _FT("fstpt"); +extern const fcml_cstring M_FSTS = _FT("fsts"); +extern const fcml_cstring M_FSTSW = _FT("fstsw"); +extern const fcml_cstring M_FSUB = _FT("fsub"); +extern const fcml_cstring M_FSUBL = _FT("fsubl"); +extern const fcml_cstring M_FSUBP = _FT("fsubp"); +extern const fcml_cstring M_FSUBR = _FT("fsubr"); +extern const fcml_cstring M_FSUBRL = _FT("fsubrl"); +extern const fcml_cstring M_FSUBRP = _FT("fsubrp"); +extern const fcml_cstring M_FSUBRS = _FT("fsubrs"); +extern const fcml_cstring M_FSUBS = _FT("fsubs"); +extern const fcml_cstring M_FTST = _FT("ftst"); +extern const fcml_cstring M_FUCOM = _FT("fucom"); +extern const fcml_cstring M_FUCOMI = _FT("fucomi"); +extern const fcml_cstring M_FUCOMIP = _FT("fucomip"); +extern const fcml_cstring M_FUCOMP = _FT("fucomp"); +extern const fcml_cstring M_FUCOMPP = _FT("fucompp"); +extern const fcml_cstring M_FWAIT = _FT("fwait"); +extern const fcml_cstring M_FXAM = _FT("fxam"); +extern const fcml_cstring M_FXCH = _FT("fxch"); +extern const fcml_cstring M_FXRSTOR = _FT("fxrstor"); +extern const fcml_cstring M_FXRSTOR64 = _FT("fxrstor64"); +extern const fcml_cstring M_FXSAVE = _FT("fxsave"); +extern const fcml_cstring M_FXSAVE64 = _FT("fxsave64"); +extern const fcml_cstring M_FXTRACT = _FT("fxtract"); +extern const fcml_cstring M_FYL2X = _FT("fyl2x"); +extern const fcml_cstring M_FYL2XP1 = _FT("fyl2xp1"); +extern const fcml_cstring M_GETSEC = _FT("getsec"); +extern const fcml_cstring M_HADDPD = _FT("haddpd"); +extern const fcml_cstring M_HADDPS = _FT("haddps"); +extern const fcml_cstring M_HLT = _FT("hlt"); +extern const fcml_cstring M_HSUBPD = _FT("hsubpd"); +extern const fcml_cstring M_HSUBPS = _FT("hsubps"); +extern const fcml_cstring M_IDIV = _FT("idiv"); +extern const fcml_cstring M_IDIVB = _FT("idivb"); +extern const fcml_cstring M_IDIVL = _FT("idivl"); +extern const fcml_cstring M_IDIVQ = _FT("idivq"); +extern const fcml_cstring M_IDIVW = _FT("idivw"); +extern const fcml_cstring M_IMUL = _FT("imul"); +extern const fcml_cstring M_IMULB = _FT("imulb"); +extern const fcml_cstring M_IMULL = _FT("imull"); +extern const fcml_cstring M_IMULQ = _FT("imulq"); +extern const fcml_cstring M_IMULW = _FT("imulw"); +extern const fcml_cstring M_IN = _FT("in"); +extern const fcml_cstring M_INC = _FT("inc"); +extern const fcml_cstring M_INCB = _FT("incb"); +extern const fcml_cstring M_INCL = _FT("incl"); +extern const fcml_cstring M_INCQ = _FT("incq"); +extern const fcml_cstring M_INCW = _FT("incw"); +extern const fcml_cstring M_INSB = _FT("insb"); +extern const fcml_cstring M_INSERTPS = _FT("insertps"); +extern const fcml_cstring M_INSERTQ = _FT("insertq"); +extern const fcml_cstring M_INSL = _FT("insl"); +extern const fcml_cstring M_INSW = _FT("insw"); +extern const fcml_cstring M_INT = _FT("int"); +extern const fcml_cstring M_INT3 = _FT("int3"); +extern const fcml_cstring M_INTO = _FT("into"); +extern const fcml_cstring M_INVD = _FT("invd"); +extern const fcml_cstring M_INVEPT = _FT("invept"); +extern const fcml_cstring M_INVLPG = _FT("invlpg"); +extern const fcml_cstring M_INVLPGA = _FT("invlpga"); +extern const fcml_cstring M_INVPCID = _FT("invpcid"); +extern const fcml_cstring M_INVVPID = _FT("invvpid"); +extern const fcml_cstring M_IRET = _FT("iret"); +extern const fcml_cstring M_IRETQ = _FT("iretq"); +extern const fcml_cstring M_IRETW = _FT("iretw"); +extern const fcml_cstring M_JA = _FT("ja"); +extern const fcml_cstring M_JAE = _FT("jae"); +extern const fcml_cstring M_JB = _FT("jb"); +extern const fcml_cstring M_JBE = _FT("jbe"); +extern const fcml_cstring M_JC = _FT("jc"); +extern const fcml_cstring M_JCXZ = _FT("jcxz"); +extern const fcml_cstring M_JECXZ = _FT("jecxz"); +extern const fcml_cstring M_JENE = _FT("jene"); +extern const fcml_cstring M_JG = _FT("jg"); +extern const fcml_cstring M_JGE = _FT("jge"); +extern const fcml_cstring M_JL = _FT("jl"); +extern const fcml_cstring M_JLE = _FT("jle"); +extern const fcml_cstring M_JMP = _FT("jmp"); +extern const fcml_cstring M_JMPQ = _FT("jmpq"); +extern const fcml_cstring M_JMPW = _FT("jmpw"); +extern const fcml_cstring M_JNA = _FT("jna"); +extern const fcml_cstring M_JNAE = _FT("jnae"); +extern const fcml_cstring M_JNB = _FT("jnb"); +extern const fcml_cstring M_JNBE = _FT("jnbe"); +extern const fcml_cstring M_JNC = _FT("jnc"); +extern const fcml_cstring M_JNG = _FT("jng"); +extern const fcml_cstring M_JNGE = _FT("jnge"); +extern const fcml_cstring M_JNL = _FT("jnl"); +extern const fcml_cstring M_JNLE = _FT("jnle"); +extern const fcml_cstring M_JNO = _FT("jno"); +extern const fcml_cstring M_JNP = _FT("jnp"); +extern const fcml_cstring M_JNS = _FT("jns"); +extern const fcml_cstring M_JNZ = _FT("jnz"); +extern const fcml_cstring M_JO = _FT("jo"); +extern const fcml_cstring M_JP = _FT("jp"); +extern const fcml_cstring M_JPE = _FT("jpe"); +extern const fcml_cstring M_JPO = _FT("jpo"); +extern const fcml_cstring M_JRCXZ = _FT("jrcxz"); +extern const fcml_cstring M_JS = _FT("js"); +extern const fcml_cstring M_JZ = _FT("jz"); +extern const fcml_cstring M_KADDB = _FT("kaddb"); +extern const fcml_cstring M_KADDD = _FT("kaddd"); +extern const fcml_cstring M_KADDQ = _FT("kaddq"); +extern const fcml_cstring M_KADDW = _FT("kaddw"); +extern const fcml_cstring M_KANDB = _FT("kandb"); +extern const fcml_cstring M_KANDD = _FT("kandd"); +extern const fcml_cstring M_KANDNB = _FT("kandnb"); +extern const fcml_cstring M_KANDND = _FT("kandnd"); +extern const fcml_cstring M_KANDNQ = _FT("kandnq"); +extern const fcml_cstring M_KANDNW = _FT("kandnw"); +extern const fcml_cstring M_KANDQ = _FT("kandq"); +extern const fcml_cstring M_KANDW = _FT("kandw"); +extern const fcml_cstring M_KMOVB = _FT("kmovb"); +extern const fcml_cstring M_KMOVD = _FT("kmovd"); +extern const fcml_cstring M_KMOVQ = _FT("kmovq"); +extern const fcml_cstring M_KMOVW = _FT("kmovw"); +extern const fcml_cstring M_KNOTB = _FT("knotb"); +extern const fcml_cstring M_KNOTD = _FT("knotd"); +extern const fcml_cstring M_KNOTQ = _FT("knotq"); +extern const fcml_cstring M_KNOTW = _FT("knotw"); +extern const fcml_cstring M_KORB = _FT("korb"); +extern const fcml_cstring M_KORD = _FT("kord"); +extern const fcml_cstring M_KORQ = _FT("korq"); +extern const fcml_cstring M_KORTESTB = _FT("kortestb"); +extern const fcml_cstring M_KORTESTD = _FT("kortestd"); +extern const fcml_cstring M_KORTESTQ = _FT("kortestq"); +extern const fcml_cstring M_KORTESTW = _FT("kortestw"); +extern const fcml_cstring M_KORW = _FT("korw"); +extern const fcml_cstring M_KSHIFTLB = _FT("kshiftlb"); +extern const fcml_cstring M_KSHIFTLD = _FT("kshiftld"); +extern const fcml_cstring M_KSHIFTLQ = _FT("kshiftlq"); +extern const fcml_cstring M_KSHIFTLW = _FT("kshiftlw"); +extern const fcml_cstring M_KSHIFTRB = _FT("kshiftrb"); +extern const fcml_cstring M_KSHIFTRD = _FT("kshiftrd"); +extern const fcml_cstring M_KSHIFTRQ = _FT("kshiftrq"); +extern const fcml_cstring M_KSHIFTRW = _FT("kshiftrw"); +extern const fcml_cstring M_KTESTB = _FT("ktestb"); +extern const fcml_cstring M_KTESTD = _FT("ktestd"); +extern const fcml_cstring M_KTESTQ = _FT("ktestq"); +extern const fcml_cstring M_KTESTW = _FT("ktestw"); +extern const fcml_cstring M_KXNORB = _FT("kxnorb"); +extern const fcml_cstring M_KXNORD = _FT("kxnord"); +extern const fcml_cstring M_KXNORQ = _FT("kxnorq"); +extern const fcml_cstring M_KXNORW = _FT("kxnorw"); +extern const fcml_cstring M_KXORB = _FT("kxorb"); +extern const fcml_cstring M_KXORD = _FT("kxord"); +extern const fcml_cstring M_KXORQ = _FT("kxorq"); +extern const fcml_cstring M_KXORW = _FT("kxorw"); +extern const fcml_cstring M_LAHF = _FT("lahf"); +extern const fcml_cstring M_LAR = _FT("lar"); +extern const fcml_cstring M_LCALL = _FT("lcall"); +extern const fcml_cstring M_LCALLQ = _FT("lcallq"); +extern const fcml_cstring M_LCALLW = _FT("lcallw"); +extern const fcml_cstring M_LDDQU = _FT("lddqu"); +extern const fcml_cstring M_LDMXCSR = _FT("ldmxcsr"); +extern const fcml_cstring M_LDS = _FT("lds"); +extern const fcml_cstring M_LEA = _FT("lea"); +extern const fcml_cstring M_LEAVE = _FT("leave"); +extern const fcml_cstring M_LES = _FT("les"); +extern const fcml_cstring M_LFENCE = _FT("lfence"); +extern const fcml_cstring M_LFS = _FT("lfs"); +extern const fcml_cstring M_LGDT = _FT("lgdt"); +extern const fcml_cstring M_LGS = _FT("lgs"); +extern const fcml_cstring M_LIDT = _FT("lidt"); +extern const fcml_cstring M_LJMP = _FT("ljmp"); +extern const fcml_cstring M_LJMPL = _FT("ljmpl"); +extern const fcml_cstring M_LJMPQ = _FT("ljmpq"); +extern const fcml_cstring M_LJMPW = _FT("ljmpw"); +extern const fcml_cstring M_LLDT = _FT("lldt"); +extern const fcml_cstring M_LLWPCB = _FT("llwpcb"); +extern const fcml_cstring M_LMSW = _FT("lmsw"); +extern const fcml_cstring M_LODS = _FT("lods"); +extern const fcml_cstring M_LODSB = _FT("lodsb"); +extern const fcml_cstring M_LODSL = _FT("lodsl"); +extern const fcml_cstring M_LODSQ = _FT("lodsq"); +extern const fcml_cstring M_LODSW = _FT("lodsw"); +extern const fcml_cstring M_LOOP = _FT("loop"); +extern const fcml_cstring M_LOOPE = _FT("loope"); +extern const fcml_cstring M_LOOPNE = _FT("loopne"); +extern const fcml_cstring M_LOOPNZ = _FT("loopnz"); +extern const fcml_cstring M_LOOPZ = _FT("loopz"); +extern const fcml_cstring M_LRET = _FT("lret"); +extern const fcml_cstring M_LRETQ = _FT("lretq"); +extern const fcml_cstring M_LRETW = _FT("lretw"); +extern const fcml_cstring M_LSL = _FT("lsl"); +extern const fcml_cstring M_LSS = _FT("lss"); +extern const fcml_cstring M_LTR = _FT("ltr"); +extern const fcml_cstring M_LWPINS = _FT("lwpins"); +extern const fcml_cstring M_LWPVAL = _FT("lwpval"); +extern const fcml_cstring M_LZCNT = _FT("lzcnt"); +extern const fcml_cstring M_MASKMOVDQU = _FT("maskmovdqu"); +extern const fcml_cstring M_MASKMOVQ = _FT("maskmovq"); +extern const fcml_cstring M_MAXPD = _FT("maxpd"); +extern const fcml_cstring M_MAXPS = _FT("maxps"); +extern const fcml_cstring M_MAXSD = _FT("maxsd"); +extern const fcml_cstring M_MAXSS = _FT("maxss"); +extern const fcml_cstring M_MFENCE = _FT("mfence"); +extern const fcml_cstring M_MINPD = _FT("minpd"); +extern const fcml_cstring M_MINPS = _FT("minps"); +extern const fcml_cstring M_MINSD = _FT("minsd"); +extern const fcml_cstring M_MINSS = _FT("minss"); +extern const fcml_cstring M_MONITOR = _FT("monitor"); +extern const fcml_cstring M_MOV = _FT("mov"); +extern const fcml_cstring M_MOVABS = _FT("movabs"); +extern const fcml_cstring M_MOVAPD = _FT("movapd"); +extern const fcml_cstring M_MOVAPS = _FT("movaps"); +extern const fcml_cstring M_MOVB = _FT("movb"); +extern const fcml_cstring M_MOVBE = _FT("movbe"); +extern const fcml_cstring M_MOVD = _FT("movd"); +extern const fcml_cstring M_MOVDDUP = _FT("movddup"); +extern const fcml_cstring M_MOVDQ2Q = _FT("movdq2q"); +extern const fcml_cstring M_MOVDQA = _FT("movdqa"); +extern const fcml_cstring M_MOVDQU = _FT("movdqu"); +extern const fcml_cstring M_MOVHLPS = _FT("movhlps"); +extern const fcml_cstring M_MOVHPD = _FT("movhpd"); +extern const fcml_cstring M_MOVHPS = _FT("movhps"); +extern const fcml_cstring M_MOVL = _FT("movl"); +extern const fcml_cstring M_MOVLHPS = _FT("movlhps"); +extern const fcml_cstring M_MOVLPD = _FT("movlpd"); +extern const fcml_cstring M_MOVLPS = _FT("movlps"); +extern const fcml_cstring M_MOVMSKPD = _FT("movmskpd"); +extern const fcml_cstring M_MOVMSKPS = _FT("movmskps"); +extern const fcml_cstring M_MOVNTDQ = _FT("movntdq"); +extern const fcml_cstring M_MOVNTDQA = _FT("movntdqa"); +extern const fcml_cstring M_MOVNTI = _FT("movnti"); +extern const fcml_cstring M_MOVNTPD = _FT("movntpd"); +extern const fcml_cstring M_MOVNTPS = _FT("movntps"); +extern const fcml_cstring M_MOVNTQ = _FT("movntq"); +extern const fcml_cstring M_MOVNTSD = _FT("movntsd"); +extern const fcml_cstring M_MOVNTSS = _FT("movntss"); +extern const fcml_cstring M_MOVQ = _FT("movq"); +extern const fcml_cstring M_MOVQ2DQ = _FT("movq2dq"); +extern const fcml_cstring M_MOVS = _FT("movs"); +extern const fcml_cstring M_MOVSB = _FT("movsb"); +extern const fcml_cstring M_MOVSBL = _FT("movsbl"); +extern const fcml_cstring M_MOVSBQ = _FT("movsbq"); +extern const fcml_cstring M_MOVSBW = _FT("movsbw"); +extern const fcml_cstring M_MOVSD = _FT("movsd"); +extern const fcml_cstring M_MOVSHDUP = _FT("movshdup"); +extern const fcml_cstring M_MOVSL = _FT("movsl"); +extern const fcml_cstring M_MOVSLDUP = _FT("movsldup"); +extern const fcml_cstring M_MOVSQ = _FT("movsq"); +extern const fcml_cstring M_MOVSS = _FT("movss"); +extern const fcml_cstring M_MOVSW = _FT("movsw"); +extern const fcml_cstring M_MOVSWL = _FT("movswl"); +extern const fcml_cstring M_MOVSWQ = _FT("movswq"); +extern const fcml_cstring M_MOVSWW = _FT("movsww"); +extern const fcml_cstring M_MOVSXD = _FT("movsxd"); +extern const fcml_cstring M_MOVUPD = _FT("movupd"); +extern const fcml_cstring M_MOVUPS = _FT("movups"); +extern const fcml_cstring M_MOVW = _FT("movw"); +extern const fcml_cstring M_MOVZBL = _FT("movzbl"); +extern const fcml_cstring M_MOVZBQ = _FT("movzbq"); +extern const fcml_cstring M_MOVZBW = _FT("movzbw"); +extern const fcml_cstring M_MOVZWL = _FT("movzwl"); +extern const fcml_cstring M_MOVZWQ = _FT("movzwq"); +extern const fcml_cstring M_MOVZWW = _FT("movzww"); +extern const fcml_cstring M_MPSADBW = _FT("mpsadbw"); +extern const fcml_cstring M_MUL = _FT("mul"); +extern const fcml_cstring M_MULB = _FT("mulb"); +extern const fcml_cstring M_MULL = _FT("mull"); +extern const fcml_cstring M_MULPD = _FT("mulpd"); +extern const fcml_cstring M_MULPS = _FT("mulps"); +extern const fcml_cstring M_MULQ = _FT("mulq"); +extern const fcml_cstring M_MULSD = _FT("mulsd"); +extern const fcml_cstring M_MULSS = _FT("mulss"); +extern const fcml_cstring M_MULW = _FT("mulw"); +extern const fcml_cstring M_MULX = _FT("mulx"); +extern const fcml_cstring M_MWAIT = _FT("mwait"); +extern const fcml_cstring M_NEG = _FT("neg"); +extern const fcml_cstring M_NEGB = _FT("negb"); +extern const fcml_cstring M_NEGL = _FT("negl"); +extern const fcml_cstring M_NEGQ = _FT("negq"); +extern const fcml_cstring M_NEGW = _FT("negw"); +extern const fcml_cstring M_NOP = _FT("nop"); +extern const fcml_cstring M_NOPL = _FT("nopl"); +extern const fcml_cstring M_NOPQ = _FT("nopq"); +extern const fcml_cstring M_NOPW = _FT("nopw"); +extern const fcml_cstring M_NOT = _FT("not"); +extern const fcml_cstring M_NOTB = _FT("notb"); +extern const fcml_cstring M_NOTL = _FT("notl"); +extern const fcml_cstring M_NOTQ = _FT("notq"); +extern const fcml_cstring M_NOTW = _FT("notw"); +extern const fcml_cstring M_OR = _FT("or"); +extern const fcml_cstring M_ORB = _FT("orb"); +extern const fcml_cstring M_ORL = _FT("orl"); +extern const fcml_cstring M_ORPD = _FT("orpd"); +extern const fcml_cstring M_ORPS = _FT("orps"); +extern const fcml_cstring M_ORQ = _FT("orq"); +extern const fcml_cstring M_ORW = _FT("orw"); +extern const fcml_cstring M_OUT = _FT("out"); +extern const fcml_cstring M_OUTSB = _FT("outsb"); +extern const fcml_cstring M_OUTSL = _FT("outsl"); +extern const fcml_cstring M_OUTSW = _FT("outsw"); +extern const fcml_cstring M_PABSB = _FT("pabsb"); +extern const fcml_cstring M_PABSD = _FT("pabsd"); +extern const fcml_cstring M_PABSW = _FT("pabsw"); +extern const fcml_cstring M_PACKSSDW = _FT("packssdw"); +extern const fcml_cstring M_PACKSSWB = _FT("packsswb"); +extern const fcml_cstring M_PACKUSDW = _FT("packusdw"); +extern const fcml_cstring M_PACKUSWB = _FT("packuswb"); +extern const fcml_cstring M_PADDB = _FT("paddb"); +extern const fcml_cstring M_PADDD = _FT("paddd"); +extern const fcml_cstring M_PADDQ = _FT("paddq"); +extern const fcml_cstring M_PADDSB = _FT("paddsb"); +extern const fcml_cstring M_PADDSW = _FT("paddsw"); +extern const fcml_cstring M_PADDUSB = _FT("paddusb"); +extern const fcml_cstring M_PADDUSW = _FT("paddusw"); +extern const fcml_cstring M_PADDW = _FT("paddw"); +extern const fcml_cstring M_PALIGNR = _FT("palignr"); +extern const fcml_cstring M_PAND = _FT("pand"); +extern const fcml_cstring M_PANDN = _FT("pandn"); +extern const fcml_cstring M_PAUSE = _FT("pause"); +extern const fcml_cstring M_PAVGB = _FT("pavgb"); +extern const fcml_cstring M_PAVGUSB = _FT("pavgusb"); +extern const fcml_cstring M_PAVGW = _FT("pavgw"); +extern const fcml_cstring M_PBLENDVB = _FT("pblendvb"); +extern const fcml_cstring M_PBLENDW = _FT("pblendw"); +extern const fcml_cstring M_PCLMULQDQ = _FT("pclmulqdq"); +extern const fcml_cstring M_PCMPEQB = _FT("pcmpeqb"); +extern const fcml_cstring M_PCMPEQD = _FT("pcmpeqd"); +extern const fcml_cstring M_PCMPEQQ = _FT("pcmpeqq"); +extern const fcml_cstring M_PCMPEQW = _FT("pcmpeqw"); +extern const fcml_cstring M_PCMPESTRI = _FT("pcmpestri"); +extern const fcml_cstring M_PCMPESTRM = _FT("pcmpestrm"); +extern const fcml_cstring M_PCMPGTB = _FT("pcmpgtb"); +extern const fcml_cstring M_PCMPGTD = _FT("pcmpgtd"); +extern const fcml_cstring M_PCMPGTQ = _FT("pcmpgtq"); +extern const fcml_cstring M_PCMPGTW = _FT("pcmpgtw"); +extern const fcml_cstring M_PCMPISTRI = _FT("pcmpistri"); +extern const fcml_cstring M_PCMPISTRM = _FT("pcmpistrm"); +extern const fcml_cstring M_PDEP = _FT("pdep"); +extern const fcml_cstring M_PEXT = _FT("pext"); +extern const fcml_cstring M_PEXTRB = _FT("pextrb"); +extern const fcml_cstring M_PEXTRD = _FT("pextrd"); +extern const fcml_cstring M_PEXTRQ = _FT("pextrq"); +extern const fcml_cstring M_PEXTRW = _FT("pextrw"); +extern const fcml_cstring M_PF2ID = _FT("pf2id"); +extern const fcml_cstring M_PF2IW = _FT("pf2iw"); +extern const fcml_cstring M_PFACC = _FT("pfacc"); +extern const fcml_cstring M_PFADD = _FT("pfadd"); +extern const fcml_cstring M_PFCMPEQ = _FT("pfcmpeq"); +extern const fcml_cstring M_PFCMPGE = _FT("pfcmpge"); +extern const fcml_cstring M_PFCMPGT = _FT("pfcmpgt"); +extern const fcml_cstring M_PFMAX = _FT("pfmax"); +extern const fcml_cstring M_PFMIN = _FT("pfmin"); +extern const fcml_cstring M_PFMUL = _FT("pfmul"); +extern const fcml_cstring M_PFNACC = _FT("pfnacc"); +extern const fcml_cstring M_PFPNACC = _FT("pfpnacc"); +extern const fcml_cstring M_PFRCP = _FT("pfrcp"); +extern const fcml_cstring M_PFRCPIT1 = _FT("pfrcpit1"); +extern const fcml_cstring M_PFRCPIT2 = _FT("pfrcpit2"); +extern const fcml_cstring M_PFRSQIT1 = _FT("pfrsqit1"); +extern const fcml_cstring M_PFRSQRT = _FT("pfrsqrt"); +extern const fcml_cstring M_PFSUB = _FT("pfsub"); +extern const fcml_cstring M_PFSUBR = _FT("pfsubr"); +extern const fcml_cstring M_PHADDD = _FT("phaddd"); +extern const fcml_cstring M_PHADDSW = _FT("phaddsw"); +extern const fcml_cstring M_PHADDW = _FT("phaddw"); +extern const fcml_cstring M_PHMINPOSUW = _FT("phminposuw"); +extern const fcml_cstring M_PHSUBD = _FT("phsubd"); +extern const fcml_cstring M_PHSUBSW = _FT("phsubsw"); +extern const fcml_cstring M_PHSUBW = _FT("phsubw"); +extern const fcml_cstring M_PI2FD = _FT("pi2fd"); +extern const fcml_cstring M_PI2FW = _FT("pi2fw"); +extern const fcml_cstring M_PINSRB = _FT("pinsrb"); +extern const fcml_cstring M_PINSRD = _FT("pinsrd"); +extern const fcml_cstring M_PINSRQ = _FT("pinsrq"); +extern const fcml_cstring M_PINSRW = _FT("pinsrw"); +extern const fcml_cstring M_PMADDUBSW = _FT("pmaddubsw"); +extern const fcml_cstring M_PMADDWD = _FT("pmaddwd"); +extern const fcml_cstring M_PMAXSB = _FT("pmaxsb"); +extern const fcml_cstring M_PMAXSD = _FT("pmaxsd"); +extern const fcml_cstring M_PMAXSW = _FT("pmaxsw"); +extern const fcml_cstring M_PMAXUB = _FT("pmaxub"); +extern const fcml_cstring M_PMAXUD = _FT("pmaxud"); +extern const fcml_cstring M_PMAXUW = _FT("pmaxuw"); +extern const fcml_cstring M_PMINSB = _FT("pminsb"); +extern const fcml_cstring M_PMINSD = _FT("pminsd"); +extern const fcml_cstring M_PMINSW = _FT("pminsw"); +extern const fcml_cstring M_PMINUB = _FT("pminub"); +extern const fcml_cstring M_PMINUD = _FT("pminud"); +extern const fcml_cstring M_PMINUW = _FT("pminuw"); +extern const fcml_cstring M_PMOVMSKB = _FT("pmovmskb"); +extern const fcml_cstring M_PMOVSXBD = _FT("pmovsxbd"); +extern const fcml_cstring M_PMOVSXBQ = _FT("pmovsxbq"); +extern const fcml_cstring M_PMOVSXBW = _FT("pmovsxbw"); +extern const fcml_cstring M_PMOVSXDQ = _FT("pmovsxdq"); +extern const fcml_cstring M_PMOVSXWD = _FT("pmovsxwd"); +extern const fcml_cstring M_PMOVSXWQ = _FT("pmovsxwq"); +extern const fcml_cstring M_PMOVZXBD = _FT("pmovzxbd"); +extern const fcml_cstring M_PMOVZXBQ = _FT("pmovzxbq"); +extern const fcml_cstring M_PMOVZXBW = _FT("pmovzxbw"); +extern const fcml_cstring M_PMOVZXDQ = _FT("pmovzxdq"); +extern const fcml_cstring M_PMOVZXWD = _FT("pmovzxwd"); +extern const fcml_cstring M_PMOVZXWQ = _FT("pmovzxwq"); +extern const fcml_cstring M_PMULDQ = _FT("pmuldq"); +extern const fcml_cstring M_PMULHRSW = _FT("pmulhrsw"); +extern const fcml_cstring M_PMULHRW = _FT("pmulhrw"); +extern const fcml_cstring M_PMULHUW = _FT("pmulhuw"); +extern const fcml_cstring M_PMULHW = _FT("pmulhw"); +extern const fcml_cstring M_PMULLD = _FT("pmulld"); +extern const fcml_cstring M_PMULLW = _FT("pmullw"); +extern const fcml_cstring M_PMULUDQ = _FT("pmuludq"); +extern const fcml_cstring M_POP = _FT("pop"); +extern const fcml_cstring M_POPA = _FT("popa"); +extern const fcml_cstring M_POPAW = _FT("popaw"); +extern const fcml_cstring M_POPCNT = _FT("popcnt"); +extern const fcml_cstring M_POPF = _FT("popf"); +extern const fcml_cstring M_POPFQ = _FT("popfq"); +extern const fcml_cstring M_POPFW = _FT("popfw"); +extern const fcml_cstring M_POPL = _FT("popl"); +extern const fcml_cstring M_POPQ = _FT("popq"); +extern const fcml_cstring M_POPW = _FT("popw"); +extern const fcml_cstring M_POR = _FT("por"); +extern const fcml_cstring M_PREFETCH = _FT("prefetch"); +extern const fcml_cstring M_PREFETCHNTA = _FT("prefetchnta"); +extern const fcml_cstring M_PREFETCHT0 = _FT("prefetcht0"); +extern const fcml_cstring M_PREFETCHT1 = _FT("prefetcht1"); +extern const fcml_cstring M_PREFETCHT2 = _FT("prefetcht2"); +extern const fcml_cstring M_PREFETCHW = _FT("prefetchw"); +extern const fcml_cstring M_PREFETCHWT1 = _FT("prefetchwt1"); +extern const fcml_cstring M_PSADBW = _FT("psadbw"); +extern const fcml_cstring M_PSHUFB = _FT("pshufb"); +extern const fcml_cstring M_PSHUFD = _FT("pshufd"); +extern const fcml_cstring M_PSHUFHW = _FT("pshufhw"); +extern const fcml_cstring M_PSHUFLW = _FT("pshuflw"); +extern const fcml_cstring M_PSHUFW = _FT("pshufw"); +extern const fcml_cstring M_PSIGNB = _FT("psignb"); +extern const fcml_cstring M_PSIGND = _FT("psignd"); +extern const fcml_cstring M_PSIGNW = _FT("psignw"); +extern const fcml_cstring M_PSLLD = _FT("pslld"); +extern const fcml_cstring M_PSLLDQ = _FT("pslldq"); +extern const fcml_cstring M_PSLLQ = _FT("psllq"); +extern const fcml_cstring M_PSLLW = _FT("psllw"); +extern const fcml_cstring M_PSRAD = _FT("psrad"); +extern const fcml_cstring M_PSRAW = _FT("psraw"); +extern const fcml_cstring M_PSRLD = _FT("psrld"); +extern const fcml_cstring M_PSRLDQ = _FT("psrldq"); +extern const fcml_cstring M_PSRLQ = _FT("psrlq"); +extern const fcml_cstring M_PSRLW = _FT("psrlw"); +extern const fcml_cstring M_PSUBB = _FT("psubb"); +extern const fcml_cstring M_PSUBD = _FT("psubd"); +extern const fcml_cstring M_PSUBQ = _FT("psubq"); +extern const fcml_cstring M_PSUBSB = _FT("psubsb"); +extern const fcml_cstring M_PSUBSW = _FT("psubsw"); +extern const fcml_cstring M_PSUBUSB = _FT("psubusb"); +extern const fcml_cstring M_PSUBUSW = _FT("psubusw"); +extern const fcml_cstring M_PSUBW = _FT("psubw"); +extern const fcml_cstring M_PSWAPD = _FT("pswapd"); +extern const fcml_cstring M_PTEST = _FT("ptest"); +extern const fcml_cstring M_PUNPCKHBW = _FT("punpckhbw"); +extern const fcml_cstring M_PUNPCKHDQ = _FT("punpckhdq"); +extern const fcml_cstring M_PUNPCKHQDQ = _FT("punpckhqdq"); +extern const fcml_cstring M_PUNPCKHWD = _FT("punpckhwd"); +extern const fcml_cstring M_PUNPCKLBW = _FT("punpcklbw"); +extern const fcml_cstring M_PUNPCKLDQ = _FT("punpckldq"); +extern const fcml_cstring M_PUNPCKLQDQ = _FT("punpcklqdq"); +extern const fcml_cstring M_PUNPCKLWD = _FT("punpcklwd"); +extern const fcml_cstring M_PUSH = _FT("push"); +extern const fcml_cstring M_PUSHA = _FT("pusha"); +extern const fcml_cstring M_PUSHAW = _FT("pushaw"); +extern const fcml_cstring M_PUSHB = _FT("pushb"); +extern const fcml_cstring M_PUSHF = _FT("pushf"); +extern const fcml_cstring M_PUSHFQ = _FT("pushfq"); +extern const fcml_cstring M_PUSHFW = _FT("pushfw"); +extern const fcml_cstring M_PUSHL = _FT("pushl"); +extern const fcml_cstring M_PUSHQ = _FT("pushq"); +extern const fcml_cstring M_PUSHW = _FT("pushw"); +extern const fcml_cstring M_PXOR = _FT("pxor"); +extern const fcml_cstring M_RCL = _FT("rcl"); +extern const fcml_cstring M_RCLB = _FT("rclb"); +extern const fcml_cstring M_RCLL = _FT("rcll"); +extern const fcml_cstring M_RCLQ = _FT("rclq"); +extern const fcml_cstring M_RCLW = _FT("rclw"); +extern const fcml_cstring M_RCPPS = _FT("rcpps"); +extern const fcml_cstring M_RCPSS = _FT("rcpss"); +extern const fcml_cstring M_RCR = _FT("rcr"); +extern const fcml_cstring M_RCRB = _FT("rcrb"); +extern const fcml_cstring M_RCRL = _FT("rcrl"); +extern const fcml_cstring M_RCRQ = _FT("rcrq"); +extern const fcml_cstring M_RCRW = _FT("rcrw"); +extern const fcml_cstring M_RDFSBASE = _FT("rdfsbase"); +extern const fcml_cstring M_RDGSBASE = _FT("rdgsbase"); +extern const fcml_cstring M_RDMSR = _FT("rdmsr"); +extern const fcml_cstring M_RDPMC = _FT("rdpmc"); +extern const fcml_cstring M_RDRAND = _FT("rdrand"); +extern const fcml_cstring M_RDSEED = _FT("rdseed"); +extern const fcml_cstring M_RDTSC = _FT("rdtsc"); +extern const fcml_cstring M_RDTSCP = _FT("rdtscp"); +extern const fcml_cstring M_RET = _FT("ret"); +extern const fcml_cstring M_RETQ = _FT("retq"); +extern const fcml_cstring M_RETW = _FT("retw"); +extern const fcml_cstring M_ROL = _FT("rol"); +extern const fcml_cstring M_ROLB = _FT("rolb"); +extern const fcml_cstring M_ROLL = _FT("roll"); +extern const fcml_cstring M_ROLQ = _FT("rolq"); +extern const fcml_cstring M_ROLW = _FT("rolw"); +extern const fcml_cstring M_ROR = _FT("ror"); +extern const fcml_cstring M_RORB = _FT("rorb"); +extern const fcml_cstring M_RORL = _FT("rorl"); +extern const fcml_cstring M_RORQ = _FT("rorq"); +extern const fcml_cstring M_RORW = _FT("rorw"); +extern const fcml_cstring M_RORX = _FT("rorx"); +extern const fcml_cstring M_ROUNDPD = _FT("roundpd"); +extern const fcml_cstring M_ROUNDPS = _FT("roundps"); +extern const fcml_cstring M_ROUNDSD = _FT("roundsd"); +extern const fcml_cstring M_ROUNDSS = _FT("roundss"); +extern const fcml_cstring M_RSM = _FT("rsm"); +extern const fcml_cstring M_RSQRTPS = _FT("rsqrtps"); +extern const fcml_cstring M_RSQRTSS = _FT("rsqrtss"); +extern const fcml_cstring M_SAHF = _FT("sahf"); +extern const fcml_cstring M_SAL = _FT("sal"); +extern const fcml_cstring M_SALB = _FT("salb"); +extern const fcml_cstring M_SALL = _FT("sall"); +extern const fcml_cstring M_SALQ = _FT("salq"); +extern const fcml_cstring M_SALW = _FT("salw"); +extern const fcml_cstring M_SAR = _FT("sar"); +extern const fcml_cstring M_SARB = _FT("sarb"); +extern const fcml_cstring M_SARL = _FT("sarl"); +extern const fcml_cstring M_SARQ = _FT("sarq"); +extern const fcml_cstring M_SARW = _FT("sarw"); +extern const fcml_cstring M_SARX = _FT("sarx"); +extern const fcml_cstring M_SBB = _FT("sbb"); +extern const fcml_cstring M_SBBB = _FT("sbbb"); +extern const fcml_cstring M_SBBL = _FT("sbbl"); +extern const fcml_cstring M_SBBQ = _FT("sbbq"); +extern const fcml_cstring M_SBBW = _FT("sbbw"); +extern const fcml_cstring M_SCAS = _FT("scas"); +extern const fcml_cstring M_SCASB = _FT("scasb"); +extern const fcml_cstring M_SCASL = _FT("scasl"); +extern const fcml_cstring M_SCASQ = _FT("scasq"); +extern const fcml_cstring M_SCASW = _FT("scasw"); +extern const fcml_cstring M_SETA = _FT("seta"); +extern const fcml_cstring M_SETAE = _FT("setae"); +extern const fcml_cstring M_SETB = _FT("setb"); +extern const fcml_cstring M_SETBE = _FT("setbe"); +extern const fcml_cstring M_SETC = _FT("setc"); +extern const fcml_cstring M_SETENE = _FT("setene"); +extern const fcml_cstring M_SETG = _FT("setg"); +extern const fcml_cstring M_SETGE = _FT("setge"); +extern const fcml_cstring M_SETL = _FT("setl"); +extern const fcml_cstring M_SETLE = _FT("setle"); +extern const fcml_cstring M_SETNA = _FT("setna"); +extern const fcml_cstring M_SETNAE = _FT("setnae"); +extern const fcml_cstring M_SETNB = _FT("setnb"); +extern const fcml_cstring M_SETNBE = _FT("setnbe"); +extern const fcml_cstring M_SETNC = _FT("setnc"); +extern const fcml_cstring M_SETNG = _FT("setng"); +extern const fcml_cstring M_SETNGE = _FT("setnge"); +extern const fcml_cstring M_SETNL = _FT("setnl"); +extern const fcml_cstring M_SETNLE = _FT("setnle"); +extern const fcml_cstring M_SETNO = _FT("setno"); +extern const fcml_cstring M_SETNP = _FT("setnp"); +extern const fcml_cstring M_SETNS = _FT("setns"); +extern const fcml_cstring M_SETNZ = _FT("setnz"); +extern const fcml_cstring M_SETO = _FT("seto"); +extern const fcml_cstring M_SETP = _FT("setp"); +extern const fcml_cstring M_SETPE = _FT("setpe"); +extern const fcml_cstring M_SETPO = _FT("setpo"); +extern const fcml_cstring M_SETS = _FT("sets"); +extern const fcml_cstring M_SETZ = _FT("setz"); +extern const fcml_cstring M_SFENCE = _FT("sfence"); +extern const fcml_cstring M_SGDT = _FT("sgdt"); +extern const fcml_cstring M_SHL = _FT("shl"); +extern const fcml_cstring M_SHLB = _FT("shlb"); +extern const fcml_cstring M_SHLD = _FT("shld"); +extern const fcml_cstring M_SHLL = _FT("shll"); +extern const fcml_cstring M_SHLQ = _FT("shlq"); +extern const fcml_cstring M_SHLW = _FT("shlw"); +extern const fcml_cstring M_SHLX = _FT("shlx"); +extern const fcml_cstring M_SHR = _FT("shr"); +extern const fcml_cstring M_SHRB = _FT("shrb"); +extern const fcml_cstring M_SHRD = _FT("shrd"); +extern const fcml_cstring M_SHRL = _FT("shrl"); +extern const fcml_cstring M_SHRQ = _FT("shrq"); +extern const fcml_cstring M_SHRW = _FT("shrw"); +extern const fcml_cstring M_SHRX = _FT("shrx"); +extern const fcml_cstring M_SHUFPD = _FT("shufpd"); +extern const fcml_cstring M_SHUFPS = _FT("shufps"); +extern const fcml_cstring M_SIDT = _FT("sidt"); +extern const fcml_cstring M_SKINIT = _FT("skinit"); +extern const fcml_cstring M_SLDT = _FT("sldt"); +extern const fcml_cstring M_SLWPCB = _FT("slwpcb"); +extern const fcml_cstring M_SMSW = _FT("smsw"); +extern const fcml_cstring M_SQRTPD = _FT("sqrtpd"); +extern const fcml_cstring M_SQRTPS = _FT("sqrtps"); +extern const fcml_cstring M_SQRTSD = _FT("sqrtsd"); +extern const fcml_cstring M_SQRTSS = _FT("sqrtss"); +extern const fcml_cstring M_STAC = _FT("stac"); +extern const fcml_cstring M_STC = _FT("stc"); +extern const fcml_cstring M_STD = _FT("std"); +extern const fcml_cstring M_STGI = _FT("stgi"); +extern const fcml_cstring M_STI = _FT("sti"); +extern const fcml_cstring M_STMXCSR = _FT("stmxcsr"); +extern const fcml_cstring M_STOS = _FT("stos"); +extern const fcml_cstring M_STOSB = _FT("stosb"); +extern const fcml_cstring M_STOSL = _FT("stosl"); +extern const fcml_cstring M_STOSQ = _FT("stosq"); +extern const fcml_cstring M_STOSW = _FT("stosw"); +extern const fcml_cstring M_STR = _FT("str"); +extern const fcml_cstring M_SUB = _FT("sub"); +extern const fcml_cstring M_SUBB = _FT("subb"); +extern const fcml_cstring M_SUBL = _FT("subl"); +extern const fcml_cstring M_SUBPD = _FT("subpd"); +extern const fcml_cstring M_SUBPS = _FT("subps"); +extern const fcml_cstring M_SUBQ = _FT("subq"); +extern const fcml_cstring M_SUBSD = _FT("subsd"); +extern const fcml_cstring M_SUBSS = _FT("subss"); +extern const fcml_cstring M_SUBW = _FT("subw"); +extern const fcml_cstring M_SWAPGS = _FT("swapgs"); +extern const fcml_cstring M_SYSCALL = _FT("syscall"); +extern const fcml_cstring M_SYSENTER = _FT("sysenter"); +extern const fcml_cstring M_SYSEXIT = _FT("sysexit"); +extern const fcml_cstring M_SYSRET = _FT("sysret"); +extern const fcml_cstring M_T1MSKC = _FT("t1mskc"); +extern const fcml_cstring M_TEST = _FT("test"); +extern const fcml_cstring M_TESTB = _FT("testb"); +extern const fcml_cstring M_TESTL = _FT("testl"); +extern const fcml_cstring M_TESTQ = _FT("testq"); +extern const fcml_cstring M_TESTW = _FT("testw"); +extern const fcml_cstring M_TZCNT = _FT("tzcnt"); +extern const fcml_cstring M_TZMSK = _FT("tzmsk"); +extern const fcml_cstring M_UCOMISD = _FT("ucomisd"); +extern const fcml_cstring M_UCOMISS = _FT("ucomiss"); +extern const fcml_cstring M_UD2 = _FT("ud2"); +extern const fcml_cstring M_UNPCKHPD = _FT("unpckhpd"); +extern const fcml_cstring M_UNPCKHPS = _FT("unpckhps"); +extern const fcml_cstring M_UNPCKLPD = _FT("unpcklpd"); +extern const fcml_cstring M_UNPCKLPS = _FT("unpcklps"); +extern const fcml_cstring M_V4FMADDPS = _FT("v4fmaddps"); +extern const fcml_cstring M_V4FMADDSS = _FT("v4fmaddss"); +extern const fcml_cstring M_V4FNMADDPS = _FT("v4fnmaddps"); +extern const fcml_cstring M_V4FNMADDSS = _FT("v4fnmaddss"); +extern const fcml_cstring M_VADDPD = _FT("vaddpd"); +extern const fcml_cstring M_VADDPS = _FT("vaddps"); +extern const fcml_cstring M_VADDSD = _FT("vaddsd"); +extern const fcml_cstring M_VADDSS = _FT("vaddss"); +extern const fcml_cstring M_VADDSUBPD = _FT("vaddsubpd"); +extern const fcml_cstring M_VADDSUBPS = _FT("vaddsubps"); +extern const fcml_cstring M_VAESDEC = _FT("vaesdec"); +extern const fcml_cstring M_VAESDECLAST = _FT("vaesdeclast"); +extern const fcml_cstring M_VAESENC = _FT("vaesenc"); +extern const fcml_cstring M_VAESENCLAST = _FT("vaesenclast"); +extern const fcml_cstring M_VAESIMC = _FT("vaesimc"); +extern const fcml_cstring M_VAESKEYGENASSIST = _FT("vaeskeygenassist"); +extern const fcml_cstring M_VALIGND = _FT("valignd"); +extern const fcml_cstring M_VALIGNQ = _FT("valignq"); +extern const fcml_cstring M_VANDNPD = _FT("vandnpd"); +extern const fcml_cstring M_VANDNPS = _FT("vandnps"); +extern const fcml_cstring M_VANDPD = _FT("vandpd"); +extern const fcml_cstring M_VANDPS = _FT("vandps"); +extern const fcml_cstring M_VBLENDMPD = _FT("vblendmpd"); +extern const fcml_cstring M_VBLENDMPS = _FT("vblendmps"); +extern const fcml_cstring M_VBLENDPD = _FT("vblendpd"); +extern const fcml_cstring M_VBLENDPS = _FT("vblendps"); +extern const fcml_cstring M_VBLENDVPD = _FT("vblendvpd"); +extern const fcml_cstring M_VBLENDVPS = _FT("vblendvps"); +extern const fcml_cstring M_VBROADCASTF128 = _FT("vbroadcastf128"); +extern const fcml_cstring M_VBROADCASTF32X2 = _FT("vbroadcastf32x2"); +extern const fcml_cstring M_VBROADCASTF32X4 = _FT("vbroadcastf32x4"); +extern const fcml_cstring M_VBROADCASTF32X8 = _FT("vbroadcastf32x8"); +extern const fcml_cstring M_VBROADCASTF64X2 = _FT("vbroadcastf64x2"); +extern const fcml_cstring M_VBROADCASTF64X4 = _FT("vbroadcastf64x4"); +extern const fcml_cstring M_VBROADCASTI128 = _FT("vbroadcasti128"); +extern const fcml_cstring M_VBROADCASTI32X2 = _FT("vbroadcasti32x2"); +extern const fcml_cstring M_VBROADCASTI32X4 = _FT("vbroadcasti32x4"); +extern const fcml_cstring M_VBROADCASTI32X8 = _FT("vbroadcasti32x8"); +extern const fcml_cstring M_VBROADCASTI64X2 = _FT("vbroadcasti64x2"); +extern const fcml_cstring M_VBROADCASTI64X4 = _FT("vbroadcasti64x4"); +extern const fcml_cstring M_VBROADCASTSD = _FT("vbroadcastsd"); +extern const fcml_cstring M_VBROADCASTSS = _FT("vbroadcastss"); +extern const fcml_cstring M_VCMPEQ_OSPD = _FT("vcmpeq_ospd"); +extern const fcml_cstring M_VCMPEQ_OSPS = _FT("vcmpeq_osps"); +extern const fcml_cstring M_VCMPEQ_OSSD = _FT("vcmpeq_ossd"); +extern const fcml_cstring M_VCMPEQ_OSSS = _FT("vcmpeq_osss"); +extern const fcml_cstring M_VCMPEQ_UQPD = _FT("vcmpeq_uqpd"); +extern const fcml_cstring M_VCMPEQ_UQPS = _FT("vcmpeq_uqps"); +extern const fcml_cstring M_VCMPEQ_UQSD = _FT("vcmpeq_uqsd"); +extern const fcml_cstring M_VCMPEQ_UQSS = _FT("vcmpeq_uqss"); +extern const fcml_cstring M_VCMPEQ_USPD = _FT("vcmpeq_uspd"); +extern const fcml_cstring M_VCMPEQ_USPS = _FT("vcmpeq_usps"); +extern const fcml_cstring M_VCMPEQ_USSD = _FT("vcmpeq_ussd"); +extern const fcml_cstring M_VCMPEQ_USSS = _FT("vcmpeq_usss"); +extern const fcml_cstring M_VCMPEQPD = _FT("vcmpeqpd"); +extern const fcml_cstring M_VCMPEQPS = _FT("vcmpeqps"); +extern const fcml_cstring M_VCMPEQSD = _FT("vcmpeqsd"); +extern const fcml_cstring M_VCMPEQSS = _FT("vcmpeqss"); +extern const fcml_cstring M_VCMPFALSE_OSPD = _FT("vcmpfalse_ospd"); +extern const fcml_cstring M_VCMPFALSE_OSPS = _FT("vcmpfalse_osps"); +extern const fcml_cstring M_VCMPFALSE_OSSD = _FT("vcmpfalse_ossd"); +extern const fcml_cstring M_VCMPFALSE_OSSS = _FT("vcmpfalse_osss"); +extern const fcml_cstring M_VCMPFALSEPD = _FT("vcmpfalsepd"); +extern const fcml_cstring M_VCMPFALSEPS = _FT("vcmpfalseps"); +extern const fcml_cstring M_VCMPFALSESD = _FT("vcmpfalsesd"); +extern const fcml_cstring M_VCMPFALSESS = _FT("vcmpfalsess"); +extern const fcml_cstring M_VCMPGE_OQPD = _FT("vcmpge_oqpd"); +extern const fcml_cstring M_VCMPGE_OQPS = _FT("vcmpge_oqps"); +extern const fcml_cstring M_VCMPGE_OQSD = _FT("vcmpge_oqsd"); +extern const fcml_cstring M_VCMPGE_OQSS = _FT("vcmpge_oqss"); +extern const fcml_cstring M_VCMPGEPD = _FT("vcmpgepd"); +extern const fcml_cstring M_VCMPGEPS = _FT("vcmpgeps"); +extern const fcml_cstring M_VCMPGESD = _FT("vcmpgesd"); +extern const fcml_cstring M_VCMPGESS = _FT("vcmpgess"); +extern const fcml_cstring M_VCMPGT_OQPD = _FT("vcmpgt_oqpd"); +extern const fcml_cstring M_VCMPGT_OQPS = _FT("vcmpgt_oqps"); +extern const fcml_cstring M_VCMPGT_OQSD = _FT("vcmpgt_oqsd"); +extern const fcml_cstring M_VCMPGT_OQSS = _FT("vcmpgt_oqss"); +extern const fcml_cstring M_VCMPGTPD = _FT("vcmpgtpd"); +extern const fcml_cstring M_VCMPGTPS = _FT("vcmpgtps"); +extern const fcml_cstring M_VCMPGTSD = _FT("vcmpgtsd"); +extern const fcml_cstring M_VCMPGTSS = _FT("vcmpgtss"); +extern const fcml_cstring M_VCMPLE_OQPD = _FT("vcmple_oqpd"); +extern const fcml_cstring M_VCMPLE_OQPS = _FT("vcmple_oqps"); +extern const fcml_cstring M_VCMPLE_OQSD = _FT("vcmple_oqsd"); +extern const fcml_cstring M_VCMPLE_OQSS = _FT("vcmple_oqss"); +extern const fcml_cstring M_VCMPLEPD = _FT("vcmplepd"); +extern const fcml_cstring M_VCMPLEPS = _FT("vcmpleps"); +extern const fcml_cstring M_VCMPLESD = _FT("vcmplesd"); +extern const fcml_cstring M_VCMPLESS = _FT("vcmpless"); +extern const fcml_cstring M_VCMPLT_OQPD = _FT("vcmplt_oqpd"); +extern const fcml_cstring M_VCMPLT_OQPS = _FT("vcmplt_oqps"); +extern const fcml_cstring M_VCMPLT_OQSD = _FT("vcmplt_oqsd"); +extern const fcml_cstring M_VCMPLT_OQSS = _FT("vcmplt_oqss"); +extern const fcml_cstring M_VCMPLTPD = _FT("vcmpltpd"); +extern const fcml_cstring M_VCMPLTPS = _FT("vcmpltps"); +extern const fcml_cstring M_VCMPLTSD = _FT("vcmpltsd"); +extern const fcml_cstring M_VCMPLTSS = _FT("vcmpltss"); +extern const fcml_cstring M_VCMPNEQ_OQPD = _FT("vcmpneq_oqpd"); +extern const fcml_cstring M_VCMPNEQ_OQPS = _FT("vcmpneq_oqps"); +extern const fcml_cstring M_VCMPNEQ_OQSD = _FT("vcmpneq_oqsd"); +extern const fcml_cstring M_VCMPNEQ_OQSS = _FT("vcmpneq_oqss"); +extern const fcml_cstring M_VCMPNEQ_OSPD = _FT("vcmpneq_ospd"); +extern const fcml_cstring M_VCMPNEQ_OSPS = _FT("vcmpneq_osps"); +extern const fcml_cstring M_VCMPNEQ_OSSD = _FT("vcmpneq_ossd"); +extern const fcml_cstring M_VCMPNEQ_OSSS = _FT("vcmpneq_osss"); +extern const fcml_cstring M_VCMPNEQ_USPD = _FT("vcmpneq_uspd"); +extern const fcml_cstring M_VCMPNEQ_USPS = _FT("vcmpneq_usps"); +extern const fcml_cstring M_VCMPNEQ_USSD = _FT("vcmpneq_ussd"); +extern const fcml_cstring M_VCMPNEQ_USSS = _FT("vcmpneq_usss"); +extern const fcml_cstring M_VCMPNEQPD = _FT("vcmpneqpd"); +extern const fcml_cstring M_VCMPNEQPS = _FT("vcmpneqps"); +extern const fcml_cstring M_VCMPNEQSD = _FT("vcmpneqsd"); +extern const fcml_cstring M_VCMPNEQSS = _FT("vcmpneqss"); +extern const fcml_cstring M_VCMPNGE_UQPD = _FT("vcmpnge_uqpd"); +extern const fcml_cstring M_VCMPNGE_UQPS = _FT("vcmpnge_uqps"); +extern const fcml_cstring M_VCMPNGE_UQSD = _FT("vcmpnge_uqsd"); +extern const fcml_cstring M_VCMPNGE_UQSS = _FT("vcmpnge_uqss"); +extern const fcml_cstring M_VCMPNGEPD = _FT("vcmpngepd"); +extern const fcml_cstring M_VCMPNGEPS = _FT("vcmpngeps"); +extern const fcml_cstring M_VCMPNGESD = _FT("vcmpngesd"); +extern const fcml_cstring M_VCMPNGESS = _FT("vcmpngess"); +extern const fcml_cstring M_VCMPNGT_UQPD = _FT("vcmpngt_uqpd"); +extern const fcml_cstring M_VCMPNGT_UQPS = _FT("vcmpngt_uqps"); +extern const fcml_cstring M_VCMPNGT_UQSD = _FT("vcmpngt_uqsd"); +extern const fcml_cstring M_VCMPNGT_UQSS = _FT("vcmpngt_uqss"); +extern const fcml_cstring M_VCMPNGTPD = _FT("vcmpngtpd"); +extern const fcml_cstring M_VCMPNGTPS = _FT("vcmpngtps"); +extern const fcml_cstring M_VCMPNGTSD = _FT("vcmpngtsd"); +extern const fcml_cstring M_VCMPNGTSS = _FT("vcmpngtss"); +extern const fcml_cstring M_VCMPNLE_UQPD = _FT("vcmpnle_uqpd"); +extern const fcml_cstring M_VCMPNLE_UQPS = _FT("vcmpnle_uqps"); +extern const fcml_cstring M_VCMPNLE_UQSD = _FT("vcmpnle_uqsd"); +extern const fcml_cstring M_VCMPNLE_UQSS = _FT("vcmpnle_uqss"); +extern const fcml_cstring M_VCMPNLEPD = _FT("vcmpnlepd"); +extern const fcml_cstring M_VCMPNLEPS = _FT("vcmpnleps"); +extern const fcml_cstring M_VCMPNLESD = _FT("vcmpnlesd"); +extern const fcml_cstring M_VCMPNLESS = _FT("vcmpnless"); +extern const fcml_cstring M_VCMPNLT_UQPD = _FT("vcmpnlt_uqpd"); +extern const fcml_cstring M_VCMPNLT_UQPS = _FT("vcmpnlt_uqps"); +extern const fcml_cstring M_VCMPNLT_UQSD = _FT("vcmpnlt_uqsd"); +extern const fcml_cstring M_VCMPNLT_UQSS = _FT("vcmpnlt_uqss"); +extern const fcml_cstring M_VCMPNLTPD = _FT("vcmpnltpd"); +extern const fcml_cstring M_VCMPNLTPS = _FT("vcmpnltps"); +extern const fcml_cstring M_VCMPNLTSD = _FT("vcmpnltsd"); +extern const fcml_cstring M_VCMPNLTSS = _FT("vcmpnltss"); +extern const fcml_cstring M_VCMPORD_SPD = _FT("vcmpord_spd"); +extern const fcml_cstring M_VCMPORD_SPS = _FT("vcmpord_sps"); +extern const fcml_cstring M_VCMPORD_SSD = _FT("vcmpord_ssd"); +extern const fcml_cstring M_VCMPORD_SSS = _FT("vcmpord_sss"); +extern const fcml_cstring M_VCMPORDPD = _FT("vcmpordpd"); +extern const fcml_cstring M_VCMPORDPS = _FT("vcmpordps"); +extern const fcml_cstring M_VCMPORDSD = _FT("vcmpordsd"); +extern const fcml_cstring M_VCMPORDSS = _FT("vcmpordss"); +extern const fcml_cstring M_VCMPPD = _FT("vcmppd"); +extern const fcml_cstring M_VCMPPS = _FT("vcmpps"); +extern const fcml_cstring M_VCMPSD = _FT("vcmpsd"); +extern const fcml_cstring M_VCMPSS = _FT("vcmpss"); +extern const fcml_cstring M_VCMPTRUE_USPD = _FT("vcmptrue_uspd"); +extern const fcml_cstring M_VCMPTRUE_USPS = _FT("vcmptrue_usps"); +extern const fcml_cstring M_VCMPTRUE_USSD = _FT("vcmptrue_ussd"); +extern const fcml_cstring M_VCMPTRUE_USSS = _FT("vcmptrue_usss"); +extern const fcml_cstring M_VCMPTRUEPD = _FT("vcmptruepd"); +extern const fcml_cstring M_VCMPTRUEPS = _FT("vcmptrueps"); +extern const fcml_cstring M_VCMPTRUESD = _FT("vcmptruesd"); +extern const fcml_cstring M_VCMPTRUESS = _FT("vcmptruess"); +extern const fcml_cstring M_VCMPUNORD_SPD = _FT("vcmpunord_spd"); +extern const fcml_cstring M_VCMPUNORD_SPS = _FT("vcmpunord_sps"); +extern const fcml_cstring M_VCMPUNORD_SSD = _FT("vcmpunord_ssd"); +extern const fcml_cstring M_VCMPUNORD_SSS = _FT("vcmpunord_sss"); +extern const fcml_cstring M_VCMPUNORDPD = _FT("vcmpunordpd"); +extern const fcml_cstring M_VCMPUNORDPS = _FT("vcmpunordps"); +extern const fcml_cstring M_VCMPUNORDSD = _FT("vcmpunordsd"); +extern const fcml_cstring M_VCMPUNORDSS = _FT("vcmpunordss"); +extern const fcml_cstring M_VCOMISD = _FT("vcomisd"); +extern const fcml_cstring M_VCOMISS = _FT("vcomiss"); +extern const fcml_cstring M_VCOMPRESSPD = _FT("vcompresspd"); +extern const fcml_cstring M_VCOMPRESSPS = _FT("vcompressps"); +extern const fcml_cstring M_VCVTDQ2PD = _FT("vcvtdq2pd"); +extern const fcml_cstring M_VCVTDQ2PS = _FT("vcvtdq2ps"); +extern const fcml_cstring M_VCVTPD2DQ = _FT("vcvtpd2dq"); +extern const fcml_cstring M_VCVTPD2DQX = _FT("vcvtpd2dqx"); +extern const fcml_cstring M_VCVTPD2DQY = _FT("vcvtpd2dqy"); +extern const fcml_cstring M_VCVTPD2PS = _FT("vcvtpd2ps"); +extern const fcml_cstring M_VCVTPD2PSX = _FT("vcvtpd2psx"); +extern const fcml_cstring M_VCVTPD2PSY = _FT("vcvtpd2psy"); +extern const fcml_cstring M_VCVTPD2QQ = _FT("vcvtpd2qq"); +extern const fcml_cstring M_VCVTPD2UDQ = _FT("vcvtpd2udq"); +extern const fcml_cstring M_VCVTPD2UDQX = _FT("vcvtpd2udqx"); +extern const fcml_cstring M_VCVTPD2UDQY = _FT("vcvtpd2udqy"); +extern const fcml_cstring M_VCVTPD2UQQ = _FT("vcvtpd2uqq"); +extern const fcml_cstring M_VCVTPH2PS = _FT("vcvtph2ps"); +extern const fcml_cstring M_VCVTPS2DQ = _FT("vcvtps2dq"); +extern const fcml_cstring M_VCVTPS2PD = _FT("vcvtps2pd"); +extern const fcml_cstring M_VCVTPS2PH = _FT("vcvtps2ph"); +extern const fcml_cstring M_VCVTPS2QQ = _FT("vcvtps2qq"); +extern const fcml_cstring M_VCVTPS2UDQ = _FT("vcvtps2udq"); +extern const fcml_cstring M_VCVTPS2UQQ = _FT("vcvtps2uqq"); +extern const fcml_cstring M_VCVTQQ2PD = _FT("vcvtqq2pd"); +extern const fcml_cstring M_VCVTQQ2PS = _FT("vcvtqq2ps"); +extern const fcml_cstring M_VCVTQQ2PSX = _FT("vcvtqq2psx"); +extern const fcml_cstring M_VCVTQQ2PSY = _FT("vcvtqq2psy"); +extern const fcml_cstring M_VCVTSD2SI = _FT("vcvtsd2si"); +extern const fcml_cstring M_VCVTSD2SS = _FT("vcvtsd2ss"); +extern const fcml_cstring M_VCVTSD2USI = _FT("vcvtsd2usi"); +extern const fcml_cstring M_VCVTSI2SDL = _FT("vcvtsi2sdl"); +extern const fcml_cstring M_VCVTSI2SDQ = _FT("vcvtsi2sdq"); +extern const fcml_cstring M_VCVTSI2SSL = _FT("vcvtsi2ssl"); +extern const fcml_cstring M_VCVTSI2SSQ = _FT("vcvtsi2ssq"); +extern const fcml_cstring M_VCVTSS2SD = _FT("vcvtss2sd"); +extern const fcml_cstring M_VCVTSS2SI = _FT("vcvtss2si"); +extern const fcml_cstring M_VCVTSS2USI = _FT("vcvtss2usi"); +extern const fcml_cstring M_VCVTTPD2DQ = _FT("vcvttpd2dq"); +extern const fcml_cstring M_VCVTTPD2DQX = _FT("vcvttpd2dqx"); +extern const fcml_cstring M_VCVTTPD2DQY = _FT("vcvttpd2dqy"); +extern const fcml_cstring M_VCVTTPD2QQ = _FT("vcvttpd2qq"); +extern const fcml_cstring M_VCVTTPD2UDQ = _FT("vcvttpd2udq"); +extern const fcml_cstring M_VCVTTPD2UDQX = _FT("vcvttpd2udqx"); +extern const fcml_cstring M_VCVTTPD2UDQY = _FT("vcvttpd2udqy"); +extern const fcml_cstring M_VCVTTPD2UQQ = _FT("vcvttpd2uqq"); +extern const fcml_cstring M_VCVTTPS2DQ = _FT("vcvttps2dq"); +extern const fcml_cstring M_VCVTTPS2QQ = _FT("vcvttps2qq"); +extern const fcml_cstring M_VCVTTPS2UDQ = _FT("vcvttps2udq"); +extern const fcml_cstring M_VCVTTPS2UQQ = _FT("vcvttps2uqq"); +extern const fcml_cstring M_VCVTTSD2SI = _FT("vcvttsd2si"); +extern const fcml_cstring M_VCVTTSD2USI = _FT("vcvttsd2usi"); +extern const fcml_cstring M_VCVTTSS2SI = _FT("vcvttss2si"); +extern const fcml_cstring M_VCVTTSS2USI = _FT("vcvttss2usi"); +extern const fcml_cstring M_VCVTUDQ2PD = _FT("vcvtudq2pd"); +extern const fcml_cstring M_VCVTUDQ2PS = _FT("vcvtudq2ps"); +extern const fcml_cstring M_VCVTUQQ2PD = _FT("vcvtuqq2pd"); +extern const fcml_cstring M_VCVTUQQ2PS = _FT("vcvtuqq2ps"); +extern const fcml_cstring M_VCVTUQQ2PSX = _FT("vcvtuqq2psx"); +extern const fcml_cstring M_VCVTUQQ2PSY = _FT("vcvtuqq2psy"); +extern const fcml_cstring M_VCVTUSI2SD = _FT("vcvtusi2sd"); +extern const fcml_cstring M_VCVTUSI2SS = _FT("vcvtusi2ss"); +extern const fcml_cstring M_VDBPSADBW = _FT("vdbpsadbw"); +extern const fcml_cstring M_VDIVPD = _FT("vdivpd"); +extern const fcml_cstring M_VDIVPS = _FT("vdivps"); +extern const fcml_cstring M_VDIVSD = _FT("vdivsd"); +extern const fcml_cstring M_VDIVSS = _FT("vdivss"); +extern const fcml_cstring M_VDPPD = _FT("vdppd"); +extern const fcml_cstring M_VDPPS = _FT("vdpps"); +extern const fcml_cstring M_VERR = _FT("verr"); +extern const fcml_cstring M_VERW = _FT("verw"); +extern const fcml_cstring M_VEXP2PD = _FT("vexp2pd"); +extern const fcml_cstring M_VEXP2PS = _FT("vexp2ps"); +extern const fcml_cstring M_VEXPANDPD = _FT("vexpandpd"); +extern const fcml_cstring M_VEXPANDPS = _FT("vexpandps"); +extern const fcml_cstring M_VEXTRACTF128 = _FT("vextractf128"); +extern const fcml_cstring M_VEXTRACTF32X4 = _FT("vextractf32x4"); +extern const fcml_cstring M_VEXTRACTF32X8 = _FT("vextractf32x8"); +extern const fcml_cstring M_VEXTRACTF64X2 = _FT("vextractf64x2"); +extern const fcml_cstring M_VEXTRACTF64X4 = _FT("vextractf64x4"); +extern const fcml_cstring M_VEXTRACTI128 = _FT("vextracti128"); +extern const fcml_cstring M_VEXTRACTI32X4 = _FT("vextracti32x4"); +extern const fcml_cstring M_VEXTRACTI32X8 = _FT("vextracti32x8"); +extern const fcml_cstring M_VEXTRACTI64X2 = _FT("vextracti64x2"); +extern const fcml_cstring M_VEXTRACTI64X4 = _FT("vextracti64x4"); +extern const fcml_cstring M_VEXTRACTPS = _FT("vextractps"); +extern const fcml_cstring M_VFIXUPIMMPD = _FT("vfixupimmpd"); +extern const fcml_cstring M_VFIXUPIMMPS = _FT("vfixupimmps"); +extern const fcml_cstring M_VFIXUPIMMSD = _FT("vfixupimmsd"); +extern const fcml_cstring M_VFIXUPIMMSS = _FT("vfixupimmss"); +extern const fcml_cstring M_VFMADD132PD = _FT("vfmadd132pd"); +extern const fcml_cstring M_VFMADD132PS = _FT("vfmadd132ps"); +extern const fcml_cstring M_VFMADD132SD = _FT("vfmadd132sd"); +extern const fcml_cstring M_VFMADD132SS = _FT("vfmadd132ss"); +extern const fcml_cstring M_VFMADD213PD = _FT("vfmadd213pd"); +extern const fcml_cstring M_VFMADD213PS = _FT("vfmadd213ps"); +extern const fcml_cstring M_VFMADD213SD = _FT("vfmadd213sd"); +extern const fcml_cstring M_VFMADD213SS = _FT("vfmadd213ss"); +extern const fcml_cstring M_VFMADD231PD = _FT("vfmadd231pd"); +extern const fcml_cstring M_VFMADD231PS = _FT("vfmadd231ps"); +extern const fcml_cstring M_VFMADD231SD = _FT("vfmadd231sd"); +extern const fcml_cstring M_VFMADD231SS = _FT("vfmadd231ss"); +extern const fcml_cstring M_VFMADDPD = _FT("vfmaddpd"); +extern const fcml_cstring M_VFMADDPS = _FT("vfmaddps"); +extern const fcml_cstring M_VFMADDSD = _FT("vfmaddsd"); +extern const fcml_cstring M_VFMADDSS = _FT("vfmaddss"); +extern const fcml_cstring M_VFMADDSUB132PD = _FT("vfmaddsub132pd"); +extern const fcml_cstring M_VFMADDSUB132PS = _FT("vfmaddsub132ps"); +extern const fcml_cstring M_VFMADDSUB213PD = _FT("vfmaddsub213pd"); +extern const fcml_cstring M_VFMADDSUB213PS = _FT("vfmaddsub213ps"); +extern const fcml_cstring M_VFMADDSUB231PD = _FT("vfmaddsub231pd"); +extern const fcml_cstring M_VFMADDSUB231PS = _FT("vfmaddsub231ps"); +extern const fcml_cstring M_VFMADDSUBPD = _FT("vfmaddsubpd"); +extern const fcml_cstring M_VFMADDSUBPS = _FT("vfmaddsubps"); +extern const fcml_cstring M_VFMSUB132PD = _FT("vfmsub132pd"); +extern const fcml_cstring M_VFMSUB132PS = _FT("vfmsub132ps"); +extern const fcml_cstring M_VFMSUB132SD = _FT("vfmsub132sd"); +extern const fcml_cstring M_VFMSUB132SS = _FT("vfmsub132ss"); +extern const fcml_cstring M_VFMSUB213PD = _FT("vfmsub213pd"); +extern const fcml_cstring M_VFMSUB213PS = _FT("vfmsub213ps"); +extern const fcml_cstring M_VFMSUB213SD = _FT("vfmsub213sd"); +extern const fcml_cstring M_VFMSUB213SS = _FT("vfmsub213ss"); +extern const fcml_cstring M_VFMSUB231PD = _FT("vfmsub231pd"); +extern const fcml_cstring M_VFMSUB231PS = _FT("vfmsub231ps"); +extern const fcml_cstring M_VFMSUB231SD = _FT("vfmsub231sd"); +extern const fcml_cstring M_VFMSUB231SS = _FT("vfmsub231ss"); +extern const fcml_cstring M_VFMSUBADD132PD = _FT("vfmsubadd132pd"); +extern const fcml_cstring M_VFMSUBADD132PS = _FT("vfmsubadd132ps"); +extern const fcml_cstring M_VFMSUBADD213PD = _FT("vfmsubadd213pd"); +extern const fcml_cstring M_VFMSUBADD213PS = _FT("vfmsubadd213ps"); +extern const fcml_cstring M_VFMSUBADD231PD = _FT("vfmsubadd231pd"); +extern const fcml_cstring M_VFMSUBADD231PS = _FT("vfmsubadd231ps"); +extern const fcml_cstring M_VFMSUBADDPD = _FT("vfmsubaddpd"); +extern const fcml_cstring M_VFMSUBADDPS = _FT("vfmsubaddps"); +extern const fcml_cstring M_VFMSUBPD = _FT("vfmsubpd"); +extern const fcml_cstring M_VFMSUBPS = _FT("vfmsubps"); +extern const fcml_cstring M_VFMSUBSD = _FT("vfmsubsd"); +extern const fcml_cstring M_VFMSUBSS = _FT("vfmsubss"); +extern const fcml_cstring M_VFNMADD132PD = _FT("vfnmadd132pd"); +extern const fcml_cstring M_VFNMADD132PS = _FT("vfnmadd132ps"); +extern const fcml_cstring M_VFNMADD132SD = _FT("vfnmadd132sd"); +extern const fcml_cstring M_VFNMADD132SS = _FT("vfnmadd132ss"); +extern const fcml_cstring M_VFNMADD213PD = _FT("vfnmadd213pd"); +extern const fcml_cstring M_VFNMADD213PS = _FT("vfnmadd213ps"); +extern const fcml_cstring M_VFNMADD213SD = _FT("vfnmadd213sd"); +extern const fcml_cstring M_VFNMADD213SS = _FT("vfnmadd213ss"); +extern const fcml_cstring M_VFNMADD231PD = _FT("vfnmadd231pd"); +extern const fcml_cstring M_VFNMADD231PS = _FT("vfnmadd231ps"); +extern const fcml_cstring M_VFNMADD231SD = _FT("vfnmadd231sd"); +extern const fcml_cstring M_VFNMADD231SS = _FT("vfnmadd231ss"); +extern const fcml_cstring M_VFNMADDPD = _FT("vfnmaddpd"); +extern const fcml_cstring M_VFNMADDPS = _FT("vfnmaddps"); +extern const fcml_cstring M_VFNMADDSD = _FT("vfnmaddsd"); +extern const fcml_cstring M_VFNMADDSS = _FT("vfnmaddss"); +extern const fcml_cstring M_VFNMSUB132PD = _FT("vfnmsub132pd"); +extern const fcml_cstring M_VFNMSUB132PS = _FT("vfnmsub132ps"); +extern const fcml_cstring M_VFNMSUB132SD = _FT("vfnmsub132sd"); +extern const fcml_cstring M_VFNMSUB132SS = _FT("vfnmsub132ss"); +extern const fcml_cstring M_VFNMSUB213PD = _FT("vfnmsub213pd"); +extern const fcml_cstring M_VFNMSUB213PS = _FT("vfnmsub213ps"); +extern const fcml_cstring M_VFNMSUB213SD = _FT("vfnmsub213sd"); +extern const fcml_cstring M_VFNMSUB213SS = _FT("vfnmsub213ss"); +extern const fcml_cstring M_VFNMSUB231PD = _FT("vfnmsub231pd"); +extern const fcml_cstring M_VFNMSUB231PS = _FT("vfnmsub231ps"); +extern const fcml_cstring M_VFNMSUB231SD = _FT("vfnmsub231sd"); +extern const fcml_cstring M_VFNMSUB231SS = _FT("vfnmsub231ss"); +extern const fcml_cstring M_VFNMSUBPD = _FT("vfnmsubpd"); +extern const fcml_cstring M_VFNMSUBPS = _FT("vfnmsubps"); +extern const fcml_cstring M_VFNMSUBSD = _FT("vfnmsubsd"); +extern const fcml_cstring M_VFNMSUBSS = _FT("vfnmsubss"); +extern const fcml_cstring M_VFPCLASSPD = _FT("vfpclasspd"); +extern const fcml_cstring M_VFPCLASSPS = _FT("vfpclassps"); +extern const fcml_cstring M_VFPCLASSSD = _FT("vfpclasssd"); +extern const fcml_cstring M_VFPCLASSSS = _FT("vfpclassss"); +extern const fcml_cstring M_VFRCZPD = _FT("vfrczpd"); +extern const fcml_cstring M_VFRCZPS = _FT("vfrczps"); +extern const fcml_cstring M_VFRCZSD = _FT("vfrczsd"); +extern const fcml_cstring M_VFRCZSS = _FT("vfrczss"); +extern const fcml_cstring M_VGATHERDPD = _FT("vgatherdpd"); +extern const fcml_cstring M_VGATHERDPS = _FT("vgatherdps"); +extern const fcml_cstring M_VGATHERPF0DPD = _FT("vgatherpf0dpd"); +extern const fcml_cstring M_VGATHERPF0DPS = _FT("vgatherpf0dps"); +extern const fcml_cstring M_VGATHERPF0QPD = _FT("vgatherpf0qpd"); +extern const fcml_cstring M_VGATHERPF0QPS = _FT("vgatherpf0qps"); +extern const fcml_cstring M_VGATHERPF1DPD = _FT("vgatherpf1dpd"); +extern const fcml_cstring M_VGATHERPF1DPS = _FT("vgatherpf1dps"); +extern const fcml_cstring M_VGATHERPF1QPD = _FT("vgatherpf1qpd"); +extern const fcml_cstring M_VGATHERPF1QPS = _FT("vgatherpf1qps"); +extern const fcml_cstring M_VGATHERQPD = _FT("vgatherqpd"); +extern const fcml_cstring M_VGATHERQPS = _FT("vgatherqps"); +extern const fcml_cstring M_VGETEXPPD = _FT("vgetexppd"); +extern const fcml_cstring M_VGETEXPPS = _FT("vgetexpps"); +extern const fcml_cstring M_VGETEXPSD = _FT("vgetexpsd"); +extern const fcml_cstring M_VGETEXPSS = _FT("vgetexpss"); +extern const fcml_cstring M_VGETMANTPD = _FT("vgetmantpd"); +extern const fcml_cstring M_VGETMANTPS = _FT("vgetmantps"); +extern const fcml_cstring M_VGETMANTSD = _FT("vgetmantsd"); +extern const fcml_cstring M_VGETMANTSS = _FT("vgetmantss"); +extern const fcml_cstring M_VHADDPD = _FT("vhaddpd"); +extern const fcml_cstring M_VHADDPS = _FT("vhaddps"); +extern const fcml_cstring M_VHSUBPD = _FT("vhsubpd"); +extern const fcml_cstring M_VHSUBPS = _FT("vhsubps"); +extern const fcml_cstring M_VINSERTF128 = _FT("vinsertf128"); +extern const fcml_cstring M_VINSERTF32X4 = _FT("vinsertf32x4"); +extern const fcml_cstring M_VINSERTF32X8 = _FT("vinsertf32x8"); +extern const fcml_cstring M_VINSERTF64X2 = _FT("vinsertf64x2"); +extern const fcml_cstring M_VINSERTF64X4 = _FT("vinsertf64x4"); +extern const fcml_cstring M_VINSERTI128 = _FT("vinserti128"); +extern const fcml_cstring M_VINSERTI32X4 = _FT("vinserti32x4"); +extern const fcml_cstring M_VINSERTI32X8 = _FT("vinserti32x8"); +extern const fcml_cstring M_VINSERTI64X2 = _FT("vinserti64x2"); +extern const fcml_cstring M_VINSERTI64X4 = _FT("vinserti64x4"); +extern const fcml_cstring M_VINSERTPS = _FT("vinsertps"); +extern const fcml_cstring M_VLDDQU = _FT("vlddqu"); +extern const fcml_cstring M_VLDMXCSR = _FT("vldmxcsr"); +extern const fcml_cstring M_VMASKMOVDQU = _FT("vmaskmovdqu"); +extern const fcml_cstring M_VMASKMOVPD = _FT("vmaskmovpd"); +extern const fcml_cstring M_VMASKMOVPS = _FT("vmaskmovps"); +extern const fcml_cstring M_VMAXPD = _FT("vmaxpd"); +extern const fcml_cstring M_VMAXPS = _FT("vmaxps"); +extern const fcml_cstring M_VMAXSD = _FT("vmaxsd"); +extern const fcml_cstring M_VMAXSS = _FT("vmaxss"); +extern const fcml_cstring M_VMCALL = _FT("vmcall"); +extern const fcml_cstring M_VMCLEAR = _FT("vmclear"); +extern const fcml_cstring M_VMFUNC = _FT("vmfunc"); +extern const fcml_cstring M_VMINPD = _FT("vminpd"); +extern const fcml_cstring M_VMINPS = _FT("vminps"); +extern const fcml_cstring M_VMINSD = _FT("vminsd"); +extern const fcml_cstring M_VMINSS = _FT("vminss"); +extern const fcml_cstring M_VMLAUNCH = _FT("vmlaunch"); +extern const fcml_cstring M_VMLOAD = _FT("vmload"); +extern const fcml_cstring M_VMMCALL = _FT("vmmcall"); +extern const fcml_cstring M_VMOVAPD = _FT("vmovapd"); +extern const fcml_cstring M_VMOVAPS = _FT("vmovaps"); +extern const fcml_cstring M_VMOVD = _FT("vmovd"); +extern const fcml_cstring M_VMOVDDUP = _FT("vmovddup"); +extern const fcml_cstring M_VMOVDQA = _FT("vmovdqa"); +extern const fcml_cstring M_VMOVDQA32 = _FT("vmovdqa32"); +extern const fcml_cstring M_VMOVDQA64 = _FT("vmovdqa64"); +extern const fcml_cstring M_VMOVDQU = _FT("vmovdqu"); +extern const fcml_cstring M_VMOVDQU16 = _FT("vmovdqu16"); +extern const fcml_cstring M_VMOVDQU32 = _FT("vmovdqu32"); +extern const fcml_cstring M_VMOVDQU64 = _FT("vmovdqu64"); +extern const fcml_cstring M_VMOVDQU8 = _FT("vmovdqu8"); +extern const fcml_cstring M_VMOVHLPS = _FT("vmovhlps"); +extern const fcml_cstring M_VMOVHPD = _FT("vmovhpd"); +extern const fcml_cstring M_VMOVHPS = _FT("vmovhps"); +extern const fcml_cstring M_VMOVLHPS = _FT("vmovlhps"); +extern const fcml_cstring M_VMOVLPD = _FT("vmovlpd"); +extern const fcml_cstring M_VMOVLPS = _FT("vmovlps"); +extern const fcml_cstring M_VMOVMSKPD = _FT("vmovmskpd"); +extern const fcml_cstring M_VMOVMSKPS = _FT("vmovmskps"); +extern const fcml_cstring M_VMOVNTDQ = _FT("vmovntdq"); +extern const fcml_cstring M_VMOVNTDQA = _FT("vmovntdqa"); +extern const fcml_cstring M_VMOVNTPD = _FT("vmovntpd"); +extern const fcml_cstring M_VMOVNTPS = _FT("vmovntps"); +extern const fcml_cstring M_VMOVQ = _FT("vmovq"); +extern const fcml_cstring M_VMOVSD = _FT("vmovsd"); +extern const fcml_cstring M_VMOVSHDUP = _FT("vmovshdup"); +extern const fcml_cstring M_VMOVSLDUP = _FT("vmovsldup"); +extern const fcml_cstring M_VMOVSS = _FT("vmovss"); +extern const fcml_cstring M_VMOVUPD = _FT("vmovupd"); +extern const fcml_cstring M_VMOVUPS = _FT("vmovups"); +extern const fcml_cstring M_VMPSADBW = _FT("vmpsadbw"); +extern const fcml_cstring M_VMPTRLD = _FT("vmptrld"); +extern const fcml_cstring M_VMPTRST = _FT("vmptrst"); +extern const fcml_cstring M_VMREAD = _FT("vmread"); +extern const fcml_cstring M_VMRESUME = _FT("vmresume"); +extern const fcml_cstring M_VMRUN = _FT("vmrun"); +extern const fcml_cstring M_VMSAVE = _FT("vmsave"); +extern const fcml_cstring M_VMULPD = _FT("vmulpd"); +extern const fcml_cstring M_VMULPS = _FT("vmulps"); +extern const fcml_cstring M_VMULSD = _FT("vmulsd"); +extern const fcml_cstring M_VMULSS = _FT("vmulss"); +extern const fcml_cstring M_VMWRITE = _FT("vmwrite"); +extern const fcml_cstring M_VMXOFF = _FT("vmxoff"); +extern const fcml_cstring M_VMXON = _FT("vmxon"); +extern const fcml_cstring M_VORPD = _FT("vorpd"); +extern const fcml_cstring M_VORPS = _FT("vorps"); +extern const fcml_cstring M_VP4DPWSSD = _FT("vp4dpwssd"); +extern const fcml_cstring M_VP4DPWSSDS = _FT("vp4dpwssds"); +extern const fcml_cstring M_VPABSB = _FT("vpabsb"); +extern const fcml_cstring M_VPABSD = _FT("vpabsd"); +extern const fcml_cstring M_VPABSQ = _FT("vpabsq"); +extern const fcml_cstring M_VPABSW = _FT("vpabsw"); +extern const fcml_cstring M_VPACKSSDW = _FT("vpackssdw"); +extern const fcml_cstring M_VPACKSSWB = _FT("vpacksswb"); +extern const fcml_cstring M_VPACKUSDW = _FT("vpackusdw"); +extern const fcml_cstring M_VPACKUSWB = _FT("vpackuswb"); +extern const fcml_cstring M_VPADDB = _FT("vpaddb"); +extern const fcml_cstring M_VPADDD = _FT("vpaddd"); +extern const fcml_cstring M_VPADDQ = _FT("vpaddq"); +extern const fcml_cstring M_VPADDSB = _FT("vpaddsb"); +extern const fcml_cstring M_VPADDSW = _FT("vpaddsw"); +extern const fcml_cstring M_VPADDUSB = _FT("vpaddusb"); +extern const fcml_cstring M_VPADDUSW = _FT("vpaddusw"); +extern const fcml_cstring M_VPADDW = _FT("vpaddw"); +extern const fcml_cstring M_VPALIGNR = _FT("vpalignr"); +extern const fcml_cstring M_VPAND = _FT("vpand"); +extern const fcml_cstring M_VPANDD = _FT("vpandd"); +extern const fcml_cstring M_VPANDN = _FT("vpandn"); +extern const fcml_cstring M_VPANDND = _FT("vpandnd"); +extern const fcml_cstring M_VPANDNQ = _FT("vpandnq"); +extern const fcml_cstring M_VPANDQ = _FT("vpandq"); +extern const fcml_cstring M_VPAVGB = _FT("vpavgb"); +extern const fcml_cstring M_VPAVGW = _FT("vpavgw"); +extern const fcml_cstring M_VPBLENDD = _FT("vpblendd"); +extern const fcml_cstring M_VPBLENDMB = _FT("vpblendmb"); +extern const fcml_cstring M_VPBLENDMD = _FT("vpblendmd"); +extern const fcml_cstring M_VPBLENDMQ = _FT("vpblendmq"); +extern const fcml_cstring M_VPBLENDMW = _FT("vpblendmw"); +extern const fcml_cstring M_VPBLENDVB = _FT("vpblendvb"); +extern const fcml_cstring M_VPBLENDW = _FT("vpblendw"); +extern const fcml_cstring M_VPBROADCASTB = _FT("vpbroadcastb"); +extern const fcml_cstring M_VPBROADCASTD = _FT("vpbroadcastd"); +extern const fcml_cstring M_VPBROADCASTMB2Q = _FT("vpbroadcastmb2q"); +extern const fcml_cstring M_VPBROADCASTMW2D = _FT("vpbroadcastmw2d"); +extern const fcml_cstring M_VPBROADCASTQ = _FT("vpbroadcastq"); +extern const fcml_cstring M_VPBROADCASTW = _FT("vpbroadcastw"); +extern const fcml_cstring M_VPCLMULQDQ = _FT("vpclmulqdq"); +extern const fcml_cstring M_VPCMOV = _FT("vpcmov"); +extern const fcml_cstring M_VPCMPB = _FT("vpcmpb"); +extern const fcml_cstring M_VPCMPD = _FT("vpcmpd"); +extern const fcml_cstring M_VPCMPEQB = _FT("vpcmpeqb"); +extern const fcml_cstring M_VPCMPEQD = _FT("vpcmpeqd"); +extern const fcml_cstring M_VPCMPEQQ = _FT("vpcmpeqq"); +extern const fcml_cstring M_VPCMPEQW = _FT("vpcmpeqw"); +extern const fcml_cstring M_VPCMPESTRI = _FT("vpcmpestri"); +extern const fcml_cstring M_VPCMPESTRM = _FT("vpcmpestrm"); +extern const fcml_cstring M_VPCMPGTB = _FT("vpcmpgtb"); +extern const fcml_cstring M_VPCMPGTD = _FT("vpcmpgtd"); +extern const fcml_cstring M_VPCMPGTQ = _FT("vpcmpgtq"); +extern const fcml_cstring M_VPCMPGTW = _FT("vpcmpgtw"); +extern const fcml_cstring M_VPCMPISTRI = _FT("vpcmpistri"); +extern const fcml_cstring M_VPCMPISTRM = _FT("vpcmpistrm"); +extern const fcml_cstring M_VPCMPQ = _FT("vpcmpq"); +extern const fcml_cstring M_VPCMPUB = _FT("vpcmpub"); +extern const fcml_cstring M_VPCMPUD = _FT("vpcmpud"); +extern const fcml_cstring M_VPCMPUQ = _FT("vpcmpuq"); +extern const fcml_cstring M_VPCMPUW = _FT("vpcmpuw"); +extern const fcml_cstring M_VPCMPW = _FT("vpcmpw"); +extern const fcml_cstring M_VPCOMB = _FT("vpcomb"); +extern const fcml_cstring M_VPCOMD = _FT("vpcomd"); +extern const fcml_cstring M_VPCOMEQB = _FT("vpcomeqb"); +extern const fcml_cstring M_VPCOMEQD = _FT("vpcomeqd"); +extern const fcml_cstring M_VPCOMEQQ = _FT("vpcomeqq"); +extern const fcml_cstring M_VPCOMEQUB = _FT("vpcomequb"); +extern const fcml_cstring M_VPCOMEQUD = _FT("vpcomequd"); +extern const fcml_cstring M_VPCOMEQUQ = _FT("vpcomequq"); +extern const fcml_cstring M_VPCOMEQUW = _FT("vpcomequw"); +extern const fcml_cstring M_VPCOMEQW = _FT("vpcomeqw"); +extern const fcml_cstring M_VPCOMFALSEB = _FT("vpcomfalseb"); +extern const fcml_cstring M_VPCOMFALSED = _FT("vpcomfalsed"); +extern const fcml_cstring M_VPCOMFALSEQ = _FT("vpcomfalseq"); +extern const fcml_cstring M_VPCOMFALSEUB = _FT("vpcomfalseub"); +extern const fcml_cstring M_VPCOMFALSEUD = _FT("vpcomfalseud"); +extern const fcml_cstring M_VPCOMFALSEUQ = _FT("vpcomfalseuq"); +extern const fcml_cstring M_VPCOMFALSEUW = _FT("vpcomfalseuw"); +extern const fcml_cstring M_VPCOMFALSEW = _FT("vpcomfalsew"); +extern const fcml_cstring M_VPCOMGEB = _FT("vpcomgeb"); +extern const fcml_cstring M_VPCOMGED = _FT("vpcomged"); +extern const fcml_cstring M_VPCOMGEQ = _FT("vpcomgeq"); +extern const fcml_cstring M_VPCOMGEUB = _FT("vpcomgeub"); +extern const fcml_cstring M_VPCOMGEUD = _FT("vpcomgeud"); +extern const fcml_cstring M_VPCOMGEUQ = _FT("vpcomgeuq"); +extern const fcml_cstring M_VPCOMGEUW = _FT("vpcomgeuw"); +extern const fcml_cstring M_VPCOMGEW = _FT("vpcomgew"); +extern const fcml_cstring M_VPCOMGTB = _FT("vpcomgtb"); +extern const fcml_cstring M_VPCOMGTD = _FT("vpcomgtd"); +extern const fcml_cstring M_VPCOMGTQ = _FT("vpcomgtq"); +extern const fcml_cstring M_VPCOMGTUB = _FT("vpcomgtub"); +extern const fcml_cstring M_VPCOMGTUD = _FT("vpcomgtud"); +extern const fcml_cstring M_VPCOMGTUQ = _FT("vpcomgtuq"); +extern const fcml_cstring M_VPCOMGTUW = _FT("vpcomgtuw"); +extern const fcml_cstring M_VPCOMGTW = _FT("vpcomgtw"); +extern const fcml_cstring M_VPCOMLEB = _FT("vpcomleb"); +extern const fcml_cstring M_VPCOMLED = _FT("vpcomled"); +extern const fcml_cstring M_VPCOMLEQ = _FT("vpcomleq"); +extern const fcml_cstring M_VPCOMLEUB = _FT("vpcomleub"); +extern const fcml_cstring M_VPCOMLEUD = _FT("vpcomleud"); +extern const fcml_cstring M_VPCOMLEUQ = _FT("vpcomleuq"); +extern const fcml_cstring M_VPCOMLEUW = _FT("vpcomleuw"); +extern const fcml_cstring M_VPCOMLEW = _FT("vpcomlew"); +extern const fcml_cstring M_VPCOMLTB = _FT("vpcomltb"); +extern const fcml_cstring M_VPCOMLTD = _FT("vpcomltd"); +extern const fcml_cstring M_VPCOMLTQ = _FT("vpcomltq"); +extern const fcml_cstring M_VPCOMLTUB = _FT("vpcomltub"); +extern const fcml_cstring M_VPCOMLTUD = _FT("vpcomltud"); +extern const fcml_cstring M_VPCOMLTUQ = _FT("vpcomltuq"); +extern const fcml_cstring M_VPCOMLTUW = _FT("vpcomltuw"); +extern const fcml_cstring M_VPCOMLTW = _FT("vpcomltw"); +extern const fcml_cstring M_VPCOMNEQB = _FT("vpcomneqb"); +extern const fcml_cstring M_VPCOMNEQD = _FT("vpcomneqd"); +extern const fcml_cstring M_VPCOMNEQQ = _FT("vpcomneqq"); +extern const fcml_cstring M_VPCOMNEQUB = _FT("vpcomnequb"); +extern const fcml_cstring M_VPCOMNEQUD = _FT("vpcomnequd"); +extern const fcml_cstring M_VPCOMNEQUQ = _FT("vpcomnequq"); +extern const fcml_cstring M_VPCOMNEQUW = _FT("vpcomnequw"); +extern const fcml_cstring M_VPCOMNEQW = _FT("vpcomneqw"); +extern const fcml_cstring M_VPCOMPRESSD = _FT("vpcompressd"); +extern const fcml_cstring M_VPCOMPRESSQ = _FT("vpcompressq"); +extern const fcml_cstring M_VPCOMQ = _FT("vpcomq"); +extern const fcml_cstring M_VPCOMTRUEB = _FT("vpcomtrueb"); +extern const fcml_cstring M_VPCOMTRUED = _FT("vpcomtrued"); +extern const fcml_cstring M_VPCOMTRUEQ = _FT("vpcomtrueq"); +extern const fcml_cstring M_VPCOMTRUEUB = _FT("vpcomtrueub"); +extern const fcml_cstring M_VPCOMTRUEUD = _FT("vpcomtrueud"); +extern const fcml_cstring M_VPCOMTRUEUQ = _FT("vpcomtrueuq"); +extern const fcml_cstring M_VPCOMTRUEUW = _FT("vpcomtrueuw"); +extern const fcml_cstring M_VPCOMTRUEW = _FT("vpcomtruew"); +extern const fcml_cstring M_VPCOMUB = _FT("vpcomub"); +extern const fcml_cstring M_VPCOMUD = _FT("vpcomud"); +extern const fcml_cstring M_VPCOMUQ = _FT("vpcomuq"); +extern const fcml_cstring M_VPCOMUW = _FT("vpcomuw"); +extern const fcml_cstring M_VPCOMW = _FT("vpcomw"); +extern const fcml_cstring M_VPERM2F128 = _FT("vperm2f128"); +extern const fcml_cstring M_VPERM2I128 = _FT("vperm2i128"); +extern const fcml_cstring M_VPERMB = _FT("vpermb"); +extern const fcml_cstring M_VPERMD = _FT("vpermd"); +extern const fcml_cstring M_VPERMI2B = _FT("vpermi2b"); +extern const fcml_cstring M_VPERMI2D = _FT("vpermi2d"); +extern const fcml_cstring M_VPERMI2PD = _FT("vpermi2pd"); +extern const fcml_cstring M_VPERMI2PS = _FT("vpermi2ps"); +extern const fcml_cstring M_VPERMI2Q = _FT("vpermi2q"); +extern const fcml_cstring M_VPERMI2W = _FT("vpermi2w"); +extern const fcml_cstring M_VPERMIL2PD = _FT("vpermil2pd"); +extern const fcml_cstring M_VPERMIL2PS = _FT("vpermil2ps"); +extern const fcml_cstring M_VPERMILPD = _FT("vpermilpd"); +extern const fcml_cstring M_VPERMILPS = _FT("vpermilps"); +extern const fcml_cstring M_VPERMPD = _FT("vpermpd"); +extern const fcml_cstring M_VPERMPS = _FT("vpermps"); +extern const fcml_cstring M_VPERMQ = _FT("vpermq"); +extern const fcml_cstring M_VPERMT2B = _FT("vpermt2b"); +extern const fcml_cstring M_VPERMT2D = _FT("vpermt2d"); +extern const fcml_cstring M_VPERMT2PD = _FT("vpermt2pd"); +extern const fcml_cstring M_VPERMT2PS = _FT("vpermt2ps"); +extern const fcml_cstring M_VPERMT2Q = _FT("vpermt2q"); +extern const fcml_cstring M_VPERMT2W = _FT("vpermt2w"); +extern const fcml_cstring M_VPERMW = _FT("vpermw"); +extern const fcml_cstring M_VPEXPANDD = _FT("vpexpandd"); +extern const fcml_cstring M_VPEXPANDQ = _FT("vpexpandq"); +extern const fcml_cstring M_VPEXTRB = _FT("vpextrb"); +extern const fcml_cstring M_VPEXTRD = _FT("vpextrd"); +extern const fcml_cstring M_VPEXTRQ = _FT("vpextrq"); +extern const fcml_cstring M_VPEXTRW = _FT("vpextrw"); +extern const fcml_cstring M_VPGATHERDD = _FT("vpgatherdd"); +extern const fcml_cstring M_VPGATHERDQ = _FT("vpgatherdq"); +extern const fcml_cstring M_VPGATHERQD = _FT("vpgatherqd"); +extern const fcml_cstring M_VPGATHERQQ = _FT("vpgatherqq"); +extern const fcml_cstring M_VPHADDBD = _FT("vphaddbd"); +extern const fcml_cstring M_VPHADDBQ = _FT("vphaddbq"); +extern const fcml_cstring M_VPHADDBW = _FT("vphaddbw"); +extern const fcml_cstring M_VPHADDD = _FT("vphaddd"); +extern const fcml_cstring M_VPHADDDQ = _FT("vphadddq"); +extern const fcml_cstring M_VPHADDSW = _FT("vphaddsw"); +extern const fcml_cstring M_VPHADDUBD = _FT("vphaddubd"); +extern const fcml_cstring M_VPHADDUBQ = _FT("vphaddubq"); +extern const fcml_cstring M_VPHADDUBW = _FT("vphaddubw"); +extern const fcml_cstring M_VPHADDUDQ = _FT("vphaddudq"); +extern const fcml_cstring M_VPHADDUWD = _FT("vphadduwd"); +extern const fcml_cstring M_VPHADDUWQ = _FT("vphadduwq"); +extern const fcml_cstring M_VPHADDW = _FT("vphaddw"); +extern const fcml_cstring M_VPHADDWD = _FT("vphaddwd"); +extern const fcml_cstring M_VPHADDWQ = _FT("vphaddwq"); +extern const fcml_cstring M_VPHMINPOSUW = _FT("vphminposuw"); +extern const fcml_cstring M_VPHSUBBW = _FT("vphsubbw"); +extern const fcml_cstring M_VPHSUBD = _FT("vphsubd"); +extern const fcml_cstring M_VPHSUBDQ = _FT("vphsubdq"); +extern const fcml_cstring M_VPHSUBSW = _FT("vphsubsw"); +extern const fcml_cstring M_VPHSUBW = _FT("vphsubw"); +extern const fcml_cstring M_VPHSUBWD = _FT("vphsubwd"); +extern const fcml_cstring M_VPINSRB = _FT("vpinsrb"); +extern const fcml_cstring M_VPINSRD = _FT("vpinsrd"); +extern const fcml_cstring M_VPINSRQ = _FT("vpinsrq"); +extern const fcml_cstring M_VPINSRW = _FT("vpinsrw"); +extern const fcml_cstring M_VPLZCNTD = _FT("vplzcntd"); +extern const fcml_cstring M_VPLZCNTQ = _FT("vplzcntq"); +extern const fcml_cstring M_VPMACSDD = _FT("vpmacsdd"); +extern const fcml_cstring M_VPMACSDQH = _FT("vpmacsdqh"); +extern const fcml_cstring M_VPMACSDQL = _FT("vpmacsdql"); +extern const fcml_cstring M_VPMACSSDD = _FT("vpmacssdd"); +extern const fcml_cstring M_VPMACSSDQH = _FT("vpmacssdqh"); +extern const fcml_cstring M_VPMACSSDQL = _FT("vpmacssdql"); +extern const fcml_cstring M_VPMACSSWD = _FT("vpmacsswd"); +extern const fcml_cstring M_VPMACSSWW = _FT("vpmacssww"); +extern const fcml_cstring M_VPMACSWD = _FT("vpmacswd"); +extern const fcml_cstring M_VPMACSWW = _FT("vpmacsww"); +extern const fcml_cstring M_VPMADCSSWD = _FT("vpmadcsswd"); +extern const fcml_cstring M_VPMADCSWD = _FT("vpmadcswd"); +extern const fcml_cstring M_VPMADD52HUQ = _FT("vpmadd52huq"); +extern const fcml_cstring M_VPMADD52LUQ = _FT("vpmadd52luq"); +extern const fcml_cstring M_VPMADDUBSW = _FT("vpmaddubsw"); +extern const fcml_cstring M_VPMADDWD = _FT("vpmaddwd"); +extern const fcml_cstring M_VPMASKMOV = _FT("vpmaskmov"); +extern const fcml_cstring M_VPMASKMOVD = _FT("vpmaskmovd"); +extern const fcml_cstring M_VPMASKMOVQ = _FT("vpmaskmovq"); +extern const fcml_cstring M_VPMAXSB = _FT("vpmaxsb"); +extern const fcml_cstring M_VPMAXSD = _FT("vpmaxsd"); +extern const fcml_cstring M_VPMAXSQ = _FT("vpmaxsq"); +extern const fcml_cstring M_VPMAXSW = _FT("vpmaxsw"); +extern const fcml_cstring M_VPMAXUB = _FT("vpmaxub"); +extern const fcml_cstring M_VPMAXUD = _FT("vpmaxud"); +extern const fcml_cstring M_VPMAXUQ = _FT("vpmaxuq"); +extern const fcml_cstring M_VPMAXUW = _FT("vpmaxuw"); +extern const fcml_cstring M_VPMINSB = _FT("vpminsb"); +extern const fcml_cstring M_VPMINSD = _FT("vpminsd"); +extern const fcml_cstring M_VPMINSQ = _FT("vpminsq"); +extern const fcml_cstring M_VPMINSW = _FT("vpminsw"); +extern const fcml_cstring M_VPMINUB = _FT("vpminub"); +extern const fcml_cstring M_VPMINUD = _FT("vpminud"); +extern const fcml_cstring M_VPMINUQ = _FT("vpminuq"); +extern const fcml_cstring M_VPMINUW = _FT("vpminuw"); +extern const fcml_cstring M_VPMOVB2M = _FT("vpmovb2m"); +extern const fcml_cstring M_VPMOVD2M = _FT("vpmovd2m"); +extern const fcml_cstring M_VPMOVDB = _FT("vpmovdb"); +extern const fcml_cstring M_VPMOVDW = _FT("vpmovdw"); +extern const fcml_cstring M_VPMOVM2B = _FT("vpmovm2b"); +extern const fcml_cstring M_VPMOVM2D = _FT("vpmovm2d"); +extern const fcml_cstring M_VPMOVM2Q = _FT("vpmovm2q"); +extern const fcml_cstring M_VPMOVM2W = _FT("vpmovm2w"); +extern const fcml_cstring M_VPMOVMSKB = _FT("vpmovmskb"); +extern const fcml_cstring M_VPMOVQ2M = _FT("vpmovq2m"); +extern const fcml_cstring M_VPMOVQB = _FT("vpmovqb"); +extern const fcml_cstring M_VPMOVQD = _FT("vpmovqd"); +extern const fcml_cstring M_VPMOVQW = _FT("vpmovqw"); +extern const fcml_cstring M_VPMOVSDB = _FT("vpmovsdb"); +extern const fcml_cstring M_VPMOVSDW = _FT("vpmovsdw"); +extern const fcml_cstring M_VPMOVSQB = _FT("vpmovsqb"); +extern const fcml_cstring M_VPMOVSQD = _FT("vpmovsqd"); +extern const fcml_cstring M_VPMOVSQW = _FT("vpmovsqw"); +extern const fcml_cstring M_VPMOVSWB = _FT("vpmovswb"); +extern const fcml_cstring M_VPMOVSXBD = _FT("vpmovsxbd"); +extern const fcml_cstring M_VPMOVSXBQ = _FT("vpmovsxbq"); +extern const fcml_cstring M_VPMOVSXBW = _FT("vpmovsxbw"); +extern const fcml_cstring M_VPMOVSXDQ = _FT("vpmovsxdq"); +extern const fcml_cstring M_VPMOVSXWD = _FT("vpmovsxwd"); +extern const fcml_cstring M_VPMOVSXWQ = _FT("vpmovsxwq"); +extern const fcml_cstring M_VPMOVUSDB = _FT("vpmovusdb"); +extern const fcml_cstring M_VPMOVUSDW = _FT("vpmovusdw"); +extern const fcml_cstring M_VPMOVUSQB = _FT("vpmovusqb"); +extern const fcml_cstring M_VPMOVUSQD = _FT("vpmovusqd"); +extern const fcml_cstring M_VPMOVUSQW = _FT("vpmovusqw"); +extern const fcml_cstring M_VPMOVUSWB = _FT("vpmovuswb"); +extern const fcml_cstring M_VPMOVW2M = _FT("vpmovw2m"); +extern const fcml_cstring M_VPMOVWB = _FT("vpmovwb"); +extern const fcml_cstring M_VPMOVZXBD = _FT("vpmovzxbd"); +extern const fcml_cstring M_VPMOVZXBQ = _FT("vpmovzxbq"); +extern const fcml_cstring M_VPMOVZXBW = _FT("vpmovzxbw"); +extern const fcml_cstring M_VPMOVZXDQ = _FT("vpmovzxdq"); +extern const fcml_cstring M_VPMOVZXWD = _FT("vpmovzxwd"); +extern const fcml_cstring M_VPMOVZXWQ = _FT("vpmovzxwq"); +extern const fcml_cstring M_VPMULDQ = _FT("vpmuldq"); +extern const fcml_cstring M_VPMULHRSW = _FT("vpmulhrsw"); +extern const fcml_cstring M_VPMULHUW = _FT("vpmulhuw"); +extern const fcml_cstring M_VPMULHW = _FT("vpmulhw"); +extern const fcml_cstring M_VPMULLD = _FT("vpmulld"); +extern const fcml_cstring M_VPMULLQ = _FT("vpmullq"); +extern const fcml_cstring M_VPMULLW = _FT("vpmullw"); +extern const fcml_cstring M_VPMULTISHIFTQB = _FT("vpmultishiftqb"); +extern const fcml_cstring M_VPMULUDQ = _FT("vpmuludq"); +extern const fcml_cstring M_VPOR = _FT("vpor"); +extern const fcml_cstring M_VPORD = _FT("vpord"); +extern const fcml_cstring M_VPORQ = _FT("vporq"); +extern const fcml_cstring M_VPPERM = _FT("vpperm"); +extern const fcml_cstring M_VPROLD = _FT("vprold"); +extern const fcml_cstring M_VPROLQ = _FT("vprolq"); +extern const fcml_cstring M_VPROLVD = _FT("vprolvd"); +extern const fcml_cstring M_VPROLVQ = _FT("vprolvq"); +extern const fcml_cstring M_VPRORD = _FT("vprord"); +extern const fcml_cstring M_VPRORQ = _FT("vprorq"); +extern const fcml_cstring M_VPRORVD = _FT("vprorvd"); +extern const fcml_cstring M_VPRORVQ = _FT("vprorvq"); +extern const fcml_cstring M_VPROTB = _FT("vprotb"); +extern const fcml_cstring M_VPROTD = _FT("vprotd"); +extern const fcml_cstring M_VPROTQ = _FT("vprotq"); +extern const fcml_cstring M_VPROTW = _FT("vprotw"); +extern const fcml_cstring M_VPSADBW = _FT("vpsadbw"); +extern const fcml_cstring M_VPSCATTERDD = _FT("vpscatterdd"); +extern const fcml_cstring M_VPSCATTERDQ = _FT("vpscatterdq"); +extern const fcml_cstring M_VPSCATTERQD = _FT("vpscatterqd"); +extern const fcml_cstring M_VPSCATTERQQ = _FT("vpscatterqq"); +extern const fcml_cstring M_VPSHAB = _FT("vpshab"); +extern const fcml_cstring M_VPSHAD = _FT("vpshad"); +extern const fcml_cstring M_VPSHAQ = _FT("vpshaq"); +extern const fcml_cstring M_VPSHAW = _FT("vpshaw"); +extern const fcml_cstring M_VPSHLB = _FT("vpshlb"); +extern const fcml_cstring M_VPSHLD = _FT("vpshld"); +extern const fcml_cstring M_VPSHLQ = _FT("vpshlq"); +extern const fcml_cstring M_VPSHLW = _FT("vpshlw"); +extern const fcml_cstring M_VPSHUFB = _FT("vpshufb"); +extern const fcml_cstring M_VPSHUFD = _FT("vpshufd"); +extern const fcml_cstring M_VPSHUFHW = _FT("vpshufhw"); +extern const fcml_cstring M_VPSHUFLW = _FT("vpshuflw"); +extern const fcml_cstring M_VPSIGNB = _FT("vpsignb"); +extern const fcml_cstring M_VPSIGND = _FT("vpsignd"); +extern const fcml_cstring M_VPSIGNW = _FT("vpsignw"); +extern const fcml_cstring M_VPSLLD = _FT("vpslld"); +extern const fcml_cstring M_VPSLLDQ = _FT("vpslldq"); +extern const fcml_cstring M_VPSLLQ = _FT("vpsllq"); +extern const fcml_cstring M_VPSLLVD = _FT("vpsllvd"); +extern const fcml_cstring M_VPSLLVQ = _FT("vpsllvq"); +extern const fcml_cstring M_VPSLLVW = _FT("vpsllvw"); +extern const fcml_cstring M_VPSLLW = _FT("vpsllw"); +extern const fcml_cstring M_VPSRAD = _FT("vpsrad"); +extern const fcml_cstring M_VPSRAQ = _FT("vpsraq"); +extern const fcml_cstring M_VPSRAVD = _FT("vpsravd"); +extern const fcml_cstring M_VPSRAVQ = _FT("vpsravq"); +extern const fcml_cstring M_VPSRAVW = _FT("vpsravw"); +extern const fcml_cstring M_VPSRAW = _FT("vpsraw"); +extern const fcml_cstring M_VPSRLD = _FT("vpsrld"); +extern const fcml_cstring M_VPSRLDQ = _FT("vpsrldq"); +extern const fcml_cstring M_VPSRLQ = _FT("vpsrlq"); +extern const fcml_cstring M_VPSRLVD = _FT("vpsrlvd"); +extern const fcml_cstring M_VPSRLVQ = _FT("vpsrlvq"); +extern const fcml_cstring M_VPSRLVW = _FT("vpsrlvw"); +extern const fcml_cstring M_VPSRLW = _FT("vpsrlw"); +extern const fcml_cstring M_VPSUBB = _FT("vpsubb"); +extern const fcml_cstring M_VPSUBD = _FT("vpsubd"); +extern const fcml_cstring M_VPSUBQ = _FT("vpsubq"); +extern const fcml_cstring M_VPSUBSB = _FT("vpsubsb"); +extern const fcml_cstring M_VPSUBSW = _FT("vpsubsw"); +extern const fcml_cstring M_VPSUBUSB = _FT("vpsubusb"); +extern const fcml_cstring M_VPSUBUSW = _FT("vpsubusw"); +extern const fcml_cstring M_VPSUBW = _FT("vpsubw"); +extern const fcml_cstring M_VPTERNLOGD = _FT("vpternlogd"); +extern const fcml_cstring M_VPTERNLOGQ = _FT("vpternlogq"); +extern const fcml_cstring M_VPTEST = _FT("vptest"); +extern const fcml_cstring M_VPTESTMB = _FT("vptestmb"); +extern const fcml_cstring M_VPTESTMD = _FT("vptestmd"); +extern const fcml_cstring M_VPTESTMQ = _FT("vptestmq"); +extern const fcml_cstring M_VPTESTMW = _FT("vptestmw"); +extern const fcml_cstring M_VPTESTNMB = _FT("vptestnmb"); +extern const fcml_cstring M_VPTESTNMD = _FT("vptestnmd"); +extern const fcml_cstring M_VPTESTNMQ = _FT("vptestnmq"); +extern const fcml_cstring M_VPTESTNMW = _FT("vptestnmw"); +extern const fcml_cstring M_VPUNPCKHBW = _FT("vpunpckhbw"); +extern const fcml_cstring M_VPUNPCKHDQ = _FT("vpunpckhdq"); +extern const fcml_cstring M_VPUNPCKHQDQ = _FT("vpunpckhqdq"); +extern const fcml_cstring M_VPUNPCKHWD = _FT("vpunpckhwd"); +extern const fcml_cstring M_VPUNPCKLBW = _FT("vpunpcklbw"); +extern const fcml_cstring M_VPUNPCKLDQ = _FT("vpunpckldq"); +extern const fcml_cstring M_VPUNPCKLQDQ = _FT("vpunpcklqdq"); +extern const fcml_cstring M_VPUNPCKLWD = _FT("vpunpcklwd"); +extern const fcml_cstring M_VPXOR = _FT("vpxor"); +extern const fcml_cstring M_VPXORD = _FT("vpxord"); +extern const fcml_cstring M_VPXORQ = _FT("vpxorq"); +extern const fcml_cstring M_VRANGEPD = _FT("vrangepd"); +extern const fcml_cstring M_VRANGEPS = _FT("vrangeps"); +extern const fcml_cstring M_VRANGESD = _FT("vrangesd"); +extern const fcml_cstring M_VRANGESS = _FT("vrangess"); +extern const fcml_cstring M_VRCP14PD = _FT("vrcp14pd"); +extern const fcml_cstring M_VRCP14PS = _FT("vrcp14ps"); +extern const fcml_cstring M_VRCP14SD = _FT("vrcp14sd"); +extern const fcml_cstring M_VRCP14SS = _FT("vrcp14ss"); +extern const fcml_cstring M_VRCP28PD = _FT("vrcp28pd"); +extern const fcml_cstring M_VRCP28PS = _FT("vrcp28ps"); +extern const fcml_cstring M_VRCP28SD = _FT("vrcp28sd"); +extern const fcml_cstring M_VRCP28SS = _FT("vrcp28ss"); +extern const fcml_cstring M_VRCPPS = _FT("vrcpps"); +extern const fcml_cstring M_VRCPSS = _FT("vrcpss"); +extern const fcml_cstring M_VREDUCEPD = _FT("vreducepd"); +extern const fcml_cstring M_VREDUCEPS = _FT("vreduceps"); +extern const fcml_cstring M_VREDUCESD = _FT("vreducesd"); +extern const fcml_cstring M_VREDUCESS = _FT("vreducess"); +extern const fcml_cstring M_VRNDSCALEPD = _FT("vrndscalepd"); +extern const fcml_cstring M_VRNDSCALEPS = _FT("vrndscaleps"); +extern const fcml_cstring M_VRNDSCALESD = _FT("vrndscalesd"); +extern const fcml_cstring M_VRNDSCALESS = _FT("vrndscaless"); +extern const fcml_cstring M_VROUNDPD = _FT("vroundpd"); +extern const fcml_cstring M_VROUNDPS = _FT("vroundps"); +extern const fcml_cstring M_VROUNDSD = _FT("vroundsd"); +extern const fcml_cstring M_VROUNDSS = _FT("vroundss"); +extern const fcml_cstring M_VRSQRT14PD = _FT("vrsqrt14pd"); +extern const fcml_cstring M_VRSQRT14PS = _FT("vrsqrt14ps"); +extern const fcml_cstring M_VRSQRT14SD = _FT("vrsqrt14sd"); +extern const fcml_cstring M_VRSQRT14SS = _FT("vrsqrt14ss"); +extern const fcml_cstring M_VRSQRT28PD = _FT("vrsqrt28pd"); +extern const fcml_cstring M_VRSQRT28PS = _FT("vrsqrt28ps"); +extern const fcml_cstring M_VRSQRT28SD = _FT("vrsqrt28sd"); +extern const fcml_cstring M_VRSQRT28SS = _FT("vrsqrt28ss"); +extern const fcml_cstring M_VRSQRTPS = _FT("vrsqrtps"); +extern const fcml_cstring M_VRSQRTSS = _FT("vrsqrtss"); +extern const fcml_cstring M_VSCALEFPD = _FT("vscalefpd"); +extern const fcml_cstring M_VSCALEFPS = _FT("vscalefps"); +extern const fcml_cstring M_VSCALEFSD = _FT("vscalefsd"); +extern const fcml_cstring M_VSCALEFSS = _FT("vscalefss"); +extern const fcml_cstring M_VSCATTERDPD = _FT("vscatterdpd"); +extern const fcml_cstring M_VSCATTERDPS = _FT("vscatterdps"); +extern const fcml_cstring M_VSCATTERPF0DPD = _FT("vscatterpf0dpd"); +extern const fcml_cstring M_VSCATTERPF0DPS = _FT("vscatterpf0dps"); +extern const fcml_cstring M_VSCATTERPF0QPD = _FT("vscatterpf0qpd"); +extern const fcml_cstring M_VSCATTERPF0QPS = _FT("vscatterpf0qps"); +extern const fcml_cstring M_VSCATTERPF1DPD = _FT("vscatterpf1dpd"); +extern const fcml_cstring M_VSCATTERPF1DPS = _FT("vscatterpf1dps"); +extern const fcml_cstring M_VSCATTERPF1QPD = _FT("vscatterpf1qpd"); +extern const fcml_cstring M_VSCATTERPF1QPS = _FT("vscatterpf1qps"); +extern const fcml_cstring M_VSCATTERQPD = _FT("vscatterqpd"); +extern const fcml_cstring M_VSCATTERQPS = _FT("vscatterqps"); +extern const fcml_cstring M_VSHUFF32X4 = _FT("vshuff32x4"); +extern const fcml_cstring M_VSHUFF64X2 = _FT("vshuff64x2"); +extern const fcml_cstring M_VSHUFI32X4 = _FT("vshufi32x4"); +extern const fcml_cstring M_VSHUFI64X2 = _FT("vshufi64x2"); +extern const fcml_cstring M_VSHUFPD = _FT("vshufpd"); +extern const fcml_cstring M_VSHUFPS = _FT("vshufps"); +extern const fcml_cstring M_VSQRTPD = _FT("vsqrtpd"); +extern const fcml_cstring M_VSQRTPS = _FT("vsqrtps"); +extern const fcml_cstring M_VSQRTSD = _FT("vsqrtsd"); +extern const fcml_cstring M_VSQRTSS = _FT("vsqrtss"); +extern const fcml_cstring M_VSTMXCSR = _FT("vstmxcsr"); +extern const fcml_cstring M_VSUBPD = _FT("vsubpd"); +extern const fcml_cstring M_VSUBPS = _FT("vsubps"); +extern const fcml_cstring M_VSUBSD = _FT("vsubsd"); +extern const fcml_cstring M_VSUBSS = _FT("vsubss"); +extern const fcml_cstring M_VTESTPD = _FT("vtestpd"); +extern const fcml_cstring M_VTESTPS = _FT("vtestps"); +extern const fcml_cstring M_VUCOMISD = _FT("vucomisd"); +extern const fcml_cstring M_VUCOMISS = _FT("vucomiss"); +extern const fcml_cstring M_VUNPCKHPD = _FT("vunpckhpd"); +extern const fcml_cstring M_VUNPCKHPS = _FT("vunpckhps"); +extern const fcml_cstring M_VUNPCKLPD = _FT("vunpcklpd"); +extern const fcml_cstring M_VUNPCKLPS = _FT("vunpcklps"); +extern const fcml_cstring M_VXORPD = _FT("vxorpd"); +extern const fcml_cstring M_VXORPS = _FT("vxorps"); +extern const fcml_cstring M_VZEROALL = _FT("vzeroall"); +extern const fcml_cstring M_VZEROUPPER = _FT("vzeroupper"); +extern const fcml_cstring M_WAIT = _FT("wait"); +extern const fcml_cstring M_WBINVD = _FT("wbinvd"); +extern const fcml_cstring M_WRFSBASE = _FT("wrfsbase"); +extern const fcml_cstring M_WRGSBASE = _FT("wrgsbase"); +extern const fcml_cstring M_WRMSR = _FT("wrmsr"); +extern const fcml_cstring M_XABORT = _FT("xabort"); +extern const fcml_cstring M_XADD = _FT("xadd"); +extern const fcml_cstring M_XBEGIN = _FT("xbegin"); +extern const fcml_cstring M_XCHG = _FT("xchg"); +extern const fcml_cstring M_XEND = _FT("xend"); +extern const fcml_cstring M_XGETBV = _FT("xgetbv"); +extern const fcml_cstring M_XLAT = _FT("xlat"); +extern const fcml_cstring M_XLATB = _FT("xlatb"); +extern const fcml_cstring M_XOR = _FT("xor"); +extern const fcml_cstring M_XORB = _FT("xorb"); +extern const fcml_cstring M_XORL = _FT("xorl"); +extern const fcml_cstring M_XORPD = _FT("xorpd"); +extern const fcml_cstring M_XORPS = _FT("xorps"); +extern const fcml_cstring M_XORQ = _FT("xorq"); +extern const fcml_cstring M_XORW = _FT("xorw"); +extern const fcml_cstring M_XRSTOR = _FT("xrstor"); +extern const fcml_cstring M_XRSTOR64 = _FT("xrstor64"); +extern const fcml_cstring M_XSAVE = _FT("xsave"); +extern const fcml_cstring M_XSAVE64 = _FT("xsave64"); +extern const fcml_cstring M_XSAVEOPT = _FT("xsaveopt"); +extern const fcml_cstring M_XSAVEOPT64 = _FT("xsaveopt64"); +extern const fcml_cstring M_XSETBV = _FT("xsetbv"); +extern const fcml_cstring M_XTEST = _FT("xtest"); + +} +} + + diff --git a/dependencies/fcml/include/fcml_gas_mnemonics.h b/dependencies/fcml/include/fcml_gas_mnemonics.h new file mode 100644 index 0000000..f12e38e --- /dev/null +++ b/dependencies/fcml/include/fcml_gas_mnemonics.h @@ -0,0 +1,1931 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_gas_mnemonics.h + * Declarations of AT&T mnemonics for C. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_GAS_MNEMONICS_H_ +#define FCML_GAS_MNEMONICS_H_ + +#include "fcml_types.h" + +#define M_AAA FCML_TEXT("aaa") +#define M_AAD FCML_TEXT("aad") +#define M_AAM FCML_TEXT("aam") +#define M_AAS FCML_TEXT("aas") +#define M_ADC FCML_TEXT("adc") +#define M_ADCB FCML_TEXT("adcb") +#define M_ADCL FCML_TEXT("adcl") +#define M_ADCQ FCML_TEXT("adcq") +#define M_ADCW FCML_TEXT("adcw") +#define M_ADCX FCML_TEXT("adcx") +#define M_ADD FCML_TEXT("add") +#define M_ADDB FCML_TEXT("addb") +#define M_ADDL FCML_TEXT("addl") +#define M_ADDPD FCML_TEXT("addpd") +#define M_ADDPS FCML_TEXT("addps") +#define M_ADDQ FCML_TEXT("addq") +#define M_ADDSD FCML_TEXT("addsd") +#define M_ADDSS FCML_TEXT("addss") +#define M_ADDSUBPD FCML_TEXT("addsubpd") +#define M_ADDSUBPS FCML_TEXT("addsubps") +#define M_ADDW FCML_TEXT("addw") +#define M_ADOX FCML_TEXT("adox") +#define M_AESDEC FCML_TEXT("aesdec") +#define M_AESDECLAST FCML_TEXT("aesdeclast") +#define M_AESENC FCML_TEXT("aesenc") +#define M_AESENCLAST FCML_TEXT("aesenclast") +#define M_AESIMC FCML_TEXT("aesimc") +#define M_AESKEYGENASSIST FCML_TEXT("aeskeygenassist") +#define M_AND FCML_TEXT("and") +#define M_ANDB FCML_TEXT("andb") +#define M_ANDL FCML_TEXT("andl") +#define M_ANDN FCML_TEXT("andn") +#define M_ANDNPD FCML_TEXT("andnpd") +#define M_ANDNPS FCML_TEXT("andnps") +#define M_ANDPD FCML_TEXT("andpd") +#define M_ANDPS FCML_TEXT("andps") +#define M_ANDQ FCML_TEXT("andq") +#define M_ANDW FCML_TEXT("andw") +#define M_ARPL FCML_TEXT("arpl") +#define M_BEXR FCML_TEXT("bexr") +#define M_BEXTR FCML_TEXT("bextr") +#define M_BLCFILL FCML_TEXT("blcfill") +#define M_BLCI FCML_TEXT("blci") +#define M_BLCIC FCML_TEXT("blcic") +#define M_BLCMSK FCML_TEXT("blcmsk") +#define M_BLCS FCML_TEXT("blcs") +#define M_BLENDPD FCML_TEXT("blendpd") +#define M_BLENDPS FCML_TEXT("blendps") +#define M_BLENDVPD FCML_TEXT("blendvpd") +#define M_BLENDVPS FCML_TEXT("blendvps") +#define M_BLSFILL FCML_TEXT("blsfill") +#define M_BLSI FCML_TEXT("blsi") +#define M_BLSIC FCML_TEXT("blsic") +#define M_BLSMSK FCML_TEXT("blsmsk") +#define M_BLSR FCML_TEXT("blsr") +#define M_BOUND FCML_TEXT("bound") +#define M_BSF FCML_TEXT("bsf") +#define M_BSR FCML_TEXT("bsr") +#define M_BSWAP FCML_TEXT("bswap") +#define M_BT FCML_TEXT("bt") +#define M_BTC FCML_TEXT("btc") +#define M_BTCL FCML_TEXT("btcl") +#define M_BTCQ FCML_TEXT("btcq") +#define M_BTCW FCML_TEXT("btcw") +#define M_BTL FCML_TEXT("btl") +#define M_BTQ FCML_TEXT("btq") +#define M_BTR FCML_TEXT("btr") +#define M_BTRL FCML_TEXT("btrl") +#define M_BTRQ FCML_TEXT("btrq") +#define M_BTRW FCML_TEXT("btrw") +#define M_BTS FCML_TEXT("bts") +#define M_BTSL FCML_TEXT("btsl") +#define M_BTSQ FCML_TEXT("btsq") +#define M_BTSW FCML_TEXT("btsw") +#define M_BTW FCML_TEXT("btw") +#define M_BZHI FCML_TEXT("bzhi") +#define M_CALL FCML_TEXT("call") +#define M_CALLQ FCML_TEXT("callq") +#define M_CALLW FCML_TEXT("callw") +#define M_CBTW FCML_TEXT("cbtw") +#define M_CLAC FCML_TEXT("clac") +#define M_CLC FCML_TEXT("clc") +#define M_CLD FCML_TEXT("cld") +#define M_CLFLUSH FCML_TEXT("clflush") +#define M_CLGI FCML_TEXT("clgi") +#define M_CLI FCML_TEXT("cli") +#define M_CLTD FCML_TEXT("cltd") +#define M_CLTQ FCML_TEXT("cltq") +#define M_CLTS FCML_TEXT("clts") +#define M_CMC FCML_TEXT("cmc") +#define M_CMOVA FCML_TEXT("cmova") +#define M_CMOVAE FCML_TEXT("cmovae") +#define M_CMOVB FCML_TEXT("cmovb") +#define M_CMOVBE FCML_TEXT("cmovbe") +#define M_CMOVC FCML_TEXT("cmovc") +#define M_CMOVENE FCML_TEXT("cmovene") +#define M_CMOVG FCML_TEXT("cmovg") +#define M_CMOVGE FCML_TEXT("cmovge") +#define M_CMOVL FCML_TEXT("cmovl") +#define M_CMOVLE FCML_TEXT("cmovle") +#define M_CMOVNA FCML_TEXT("cmovna") +#define M_CMOVNAE FCML_TEXT("cmovnae") +#define M_CMOVNB FCML_TEXT("cmovnb") +#define M_CMOVNBE FCML_TEXT("cmovnbe") +#define M_CMOVNC FCML_TEXT("cmovnc") +#define M_CMOVNG FCML_TEXT("cmovng") +#define M_CMOVNGE FCML_TEXT("cmovnge") +#define M_CMOVNL FCML_TEXT("cmovnl") +#define M_CMOVNLE FCML_TEXT("cmovnle") +#define M_CMOVNO FCML_TEXT("cmovno") +#define M_CMOVNP FCML_TEXT("cmovnp") +#define M_CMOVNS FCML_TEXT("cmovns") +#define M_CMOVNZ FCML_TEXT("cmovnz") +#define M_CMOVO FCML_TEXT("cmovo") +#define M_CMOVP FCML_TEXT("cmovp") +#define M_CMOVPE FCML_TEXT("cmovpe") +#define M_CMOVPO FCML_TEXT("cmovpo") +#define M_CMOVS FCML_TEXT("cmovs") +#define M_CMOVZ FCML_TEXT("cmovz") +#define M_CMP FCML_TEXT("cmp") +#define M_CMPB FCML_TEXT("cmpb") +#define M_CMPEQPD FCML_TEXT("cmpeqpd") +#define M_CMPEQPS FCML_TEXT("cmpeqps") +#define M_CMPEQSD FCML_TEXT("cmpeqsd") +#define M_CMPEQSS FCML_TEXT("cmpeqss") +#define M_CMPL FCML_TEXT("cmpl") +#define M_CMPLEPD FCML_TEXT("cmplepd") +#define M_CMPLEPS FCML_TEXT("cmpleps") +#define M_CMPLESD FCML_TEXT("cmplesd") +#define M_CMPLESS FCML_TEXT("cmpless") +#define M_CMPLTPD FCML_TEXT("cmpltpd") +#define M_CMPLTPS FCML_TEXT("cmpltps") +#define M_CMPLTSD FCML_TEXT("cmpltsd") +#define M_CMPLTSS FCML_TEXT("cmpltss") +#define M_CMPNEQPD FCML_TEXT("cmpneqpd") +#define M_CMPNEQPS FCML_TEXT("cmpneqps") +#define M_CMPNEQSD FCML_TEXT("cmpneqsd") +#define M_CMPNEQSS FCML_TEXT("cmpneqss") +#define M_CMPNLEPD FCML_TEXT("cmpnlepd") +#define M_CMPNLEPS FCML_TEXT("cmpnleps") +#define M_CMPNLESD FCML_TEXT("cmpnlesd") +#define M_CMPNLESS FCML_TEXT("cmpnless") +#define M_CMPNLTPD FCML_TEXT("cmpnltpd") +#define M_CMPNLTPS FCML_TEXT("cmpnltps") +#define M_CMPNLTSD FCML_TEXT("cmpnltsd") +#define M_CMPNLTSS FCML_TEXT("cmpnltss") +#define M_CMPORDPD FCML_TEXT("cmpordpd") +#define M_CMPORDPS FCML_TEXT("cmpordps") +#define M_CMPORDSD FCML_TEXT("cmpordsd") +#define M_CMPORDSS FCML_TEXT("cmpordss") +#define M_CMPPD FCML_TEXT("cmppd") +#define M_CMPPS FCML_TEXT("cmpps") +#define M_CMPQ FCML_TEXT("cmpq") +#define M_CMPSB FCML_TEXT("cmpsb") +#define M_CMPSD FCML_TEXT("cmpsd") +#define M_CMPSL FCML_TEXT("cmpsl") +#define M_CMPSQ FCML_TEXT("cmpsq") +#define M_CMPSS FCML_TEXT("cmpss") +#define M_CMPSW FCML_TEXT("cmpsw") +#define M_CMPUNORDPD FCML_TEXT("cmpunordpd") +#define M_CMPUNORDPS FCML_TEXT("cmpunordps") +#define M_CMPUNORDSD FCML_TEXT("cmpunordsd") +#define M_CMPUNORDSS FCML_TEXT("cmpunordss") +#define M_CMPW FCML_TEXT("cmpw") +#define M_CMPXCHG FCML_TEXT("cmpxchg") +#define M_CMPXCHG16B FCML_TEXT("cmpxchg16b") +#define M_CMPXCHG8B FCML_TEXT("cmpxchg8b") +#define M_COMISD FCML_TEXT("comisd") +#define M_COMISS FCML_TEXT("comiss") +#define M_CPUID FCML_TEXT("cpuid") +#define M_CQTO FCML_TEXT("cqto") +#define M_CRC32B FCML_TEXT("crc32b") +#define M_CRC32L FCML_TEXT("crc32l") +#define M_CRC32Q FCML_TEXT("crc32q") +#define M_CRC32W FCML_TEXT("crc32w") +#define M_CVTDQ2PD FCML_TEXT("cvtdq2pd") +#define M_CVTDQ2PS FCML_TEXT("cvtdq2ps") +#define M_CVTPD2DQ FCML_TEXT("cvtpd2dq") +#define M_CVTPD2PI FCML_TEXT("cvtpd2pi") +#define M_CVTPD2PS FCML_TEXT("cvtpd2ps") +#define M_CVTPI2PD FCML_TEXT("cvtpi2pd") +#define M_CVTPI2PS FCML_TEXT("cvtpi2ps") +#define M_CVTPS2DQ FCML_TEXT("cvtps2dq") +#define M_CVTPS2PD FCML_TEXT("cvtps2pd") +#define M_CVTPS2PI FCML_TEXT("cvtps2pi") +#define M_CVTSD2SI FCML_TEXT("cvtsd2si") +#define M_CVTSD2SS FCML_TEXT("cvtsd2ss") +#define M_CVTSI2SDL FCML_TEXT("cvtsi2sdl") +#define M_CVTSI2SDQ FCML_TEXT("cvtsi2sdq") +#define M_CVTSI2SSL FCML_TEXT("cvtsi2ssl") +#define M_CVTSI2SSQ FCML_TEXT("cvtsi2ssq") +#define M_CVTSS2SD FCML_TEXT("cvtss2sd") +#define M_CVTSS2SI FCML_TEXT("cvtss2si") +#define M_CVTTPD2DQ FCML_TEXT("cvttpd2dq") +#define M_CVTTPD2PI FCML_TEXT("cvttpd2pi") +#define M_CVTTPS2DQ FCML_TEXT("cvttps2dq") +#define M_CVTTPS2PI FCML_TEXT("cvttps2pi") +#define M_CVTTSD2SI FCML_TEXT("cvttsd2si") +#define M_CVTTSS2SI FCML_TEXT("cvttss2si") +#define M_CWTD FCML_TEXT("cwtd") +#define M_CWTL FCML_TEXT("cwtl") +#define M_DAA FCML_TEXT("daa") +#define M_DAS FCML_TEXT("das") +#define M_DEC FCML_TEXT("dec") +#define M_DECB FCML_TEXT("decb") +#define M_DECL FCML_TEXT("decl") +#define M_DECQ FCML_TEXT("decq") +#define M_DECW FCML_TEXT("decw") +#define M_DIV FCML_TEXT("div") +#define M_DIVB FCML_TEXT("divb") +#define M_DIVL FCML_TEXT("divl") +#define M_DIVPD FCML_TEXT("divpd") +#define M_DIVPS FCML_TEXT("divps") +#define M_DIVQ FCML_TEXT("divq") +#define M_DIVSD FCML_TEXT("divsd") +#define M_DIVSS FCML_TEXT("divss") +#define M_DIVW FCML_TEXT("divw") +#define M_DPPD FCML_TEXT("dppd") +#define M_DPPS FCML_TEXT("dpps") +#define M_EMMS FCML_TEXT("emms") +#define M_ENTER FCML_TEXT("enter") +#define M_ENTERQ FCML_TEXT("enterq") +#define M_EXTRACTPS FCML_TEXT("extractps") +#define M_EXTRQ FCML_TEXT("extrq") +#define M_F2XM1 FCML_TEXT("f2xm1") +#define M_FABS FCML_TEXT("fabs") +#define M_FADD FCML_TEXT("fadd") +#define M_FADDL FCML_TEXT("faddl") +#define M_FADDP FCML_TEXT("faddp") +#define M_FADDS FCML_TEXT("fadds") +#define M_FBLD FCML_TEXT("fbld") +#define M_FBSTP FCML_TEXT("fbstp") +#define M_FCHS FCML_TEXT("fchs") +#define M_FCLEX FCML_TEXT("fclex") +#define M_FCMOVB FCML_TEXT("fcmovb") +#define M_FCMOVBE FCML_TEXT("fcmovbe") +#define M_FCMOVE FCML_TEXT("fcmove") +#define M_FCMOVNB FCML_TEXT("fcmovnb") +#define M_FCMOVNBE FCML_TEXT("fcmovnbe") +#define M_FCMOVNE FCML_TEXT("fcmovne") +#define M_FCMOVNU FCML_TEXT("fcmovnu") +#define M_FCMOVU FCML_TEXT("fcmovu") +#define M_FCOM FCML_TEXT("fcom") +#define M_FCOMI FCML_TEXT("fcomi") +#define M_FCOMIP FCML_TEXT("fcomip") +#define M_FCOML FCML_TEXT("fcoml") +#define M_FCOMP FCML_TEXT("fcomp") +#define M_FCOMPL FCML_TEXT("fcompl") +#define M_FCOMPP FCML_TEXT("fcompp") +#define M_FCOMPS FCML_TEXT("fcomps") +#define M_FCOMS FCML_TEXT("fcoms") +#define M_FCOS FCML_TEXT("fcos") +#define M_FDECSTP FCML_TEXT("fdecstp") +#define M_FDIV FCML_TEXT("fdiv") +#define M_FDIVL FCML_TEXT("fdivl") +#define M_FDIVP FCML_TEXT("fdivp") +#define M_FDIVR FCML_TEXT("fdivr") +#define M_FDIVRL FCML_TEXT("fdivrl") +#define M_FDIVRP FCML_TEXT("fdivrp") +#define M_FDIVRS FCML_TEXT("fdivrs") +#define M_FDIVS FCML_TEXT("fdivs") +#define M_FEMMS FCML_TEXT("femms") +#define M_FFREE FCML_TEXT("ffree") +#define M_FIADD FCML_TEXT("fiadd") +#define M_FIADDL FCML_TEXT("fiaddl") +#define M_FICOM FCML_TEXT("ficom") +#define M_FICOML FCML_TEXT("ficoml") +#define M_FICOMP FCML_TEXT("ficomp") +#define M_FICOMPL FCML_TEXT("ficompl") +#define M_FIDIV FCML_TEXT("fidiv") +#define M_FIDIVL FCML_TEXT("fidivl") +#define M_FIDIVR FCML_TEXT("fidivr") +#define M_FIDIVRL FCML_TEXT("fidivrl") +#define M_FILD FCML_TEXT("fild") +#define M_FILDL FCML_TEXT("fildl") +#define M_FILDLL FCML_TEXT("fildll") +#define M_FIMUL FCML_TEXT("fimul") +#define M_FIMULL FCML_TEXT("fimull") +#define M_FINCSTP FCML_TEXT("fincstp") +#define M_FINIT FCML_TEXT("finit") +#define M_FIST FCML_TEXT("fist") +#define M_FISTL FCML_TEXT("fistl") +#define M_FISTP FCML_TEXT("fistp") +#define M_FISTPL FCML_TEXT("fistpl") +#define M_FISTPLL FCML_TEXT("fistpll") +#define M_FISTTP FCML_TEXT("fisttp") +#define M_FISTTPL FCML_TEXT("fisttpl") +#define M_FISTTPLL FCML_TEXT("fisttpll") +#define M_FISUB FCML_TEXT("fisub") +#define M_FISUBL FCML_TEXT("fisubl") +#define M_FISUBR FCML_TEXT("fisubr") +#define M_FISUBRL FCML_TEXT("fisubrl") +#define M_FLD FCML_TEXT("fld") +#define M_FLD1 FCML_TEXT("fld1") +#define M_FLDCW FCML_TEXT("fldcw") +#define M_FLDENV FCML_TEXT("fldenv") +#define M_FLDENVS FCML_TEXT("fldenvs") +#define M_FLDL FCML_TEXT("fldl") +#define M_FLDL2E FCML_TEXT("fldl2e") +#define M_FLDL2T FCML_TEXT("fldl2t") +#define M_FLDLG2 FCML_TEXT("fldlg2") +#define M_FLDLN2 FCML_TEXT("fldln2") +#define M_FLDPI FCML_TEXT("fldpi") +#define M_FLDS FCML_TEXT("flds") +#define M_FLDT FCML_TEXT("fldt") +#define M_FLDZ FCML_TEXT("fldz") +#define M_FMUL FCML_TEXT("fmul") +#define M_FMULL FCML_TEXT("fmull") +#define M_FMULP FCML_TEXT("fmulp") +#define M_FMULS FCML_TEXT("fmuls") +#define M_FNCLEX FCML_TEXT("fnclex") +#define M_FNINIT FCML_TEXT("fninit") +#define M_FNOP FCML_TEXT("fnop") +#define M_FNSAVE FCML_TEXT("fnsave") +#define M_FNSAVES FCML_TEXT("fnsaves") +#define M_FNSTCW FCML_TEXT("fnstcw") +#define M_FNSTENV FCML_TEXT("fnstenv") +#define M_FNSTENVS FCML_TEXT("fnstenvs") +#define M_FNSTSW FCML_TEXT("fnstsw") +#define M_FPATAN FCML_TEXT("fpatan") +#define M_FPREM FCML_TEXT("fprem") +#define M_FPREM1 FCML_TEXT("fprem1") +#define M_FPTAN FCML_TEXT("fptan") +#define M_FRNDINT FCML_TEXT("frndint") +#define M_FRSTOR FCML_TEXT("frstor") +#define M_FRSTORS FCML_TEXT("frstors") +#define M_FSAVE FCML_TEXT("fsave") +#define M_FSAVES FCML_TEXT("fsaves") +#define M_FSCALE FCML_TEXT("fscale") +#define M_FSIN FCML_TEXT("fsin") +#define M_FSINCOS FCML_TEXT("fsincos") +#define M_FSQRT FCML_TEXT("fsqrt") +#define M_FST FCML_TEXT("fst") +#define M_FSTCW FCML_TEXT("fstcw") +#define M_FSTENV FCML_TEXT("fstenv") +#define M_FSTENVS FCML_TEXT("fstenvs") +#define M_FSTL FCML_TEXT("fstl") +#define M_FSTP FCML_TEXT("fstp") +#define M_FSTPL FCML_TEXT("fstpl") +#define M_FSTPS FCML_TEXT("fstps") +#define M_FSTPT FCML_TEXT("fstpt") +#define M_FSTS FCML_TEXT("fsts") +#define M_FSTSW FCML_TEXT("fstsw") +#define M_FSUB FCML_TEXT("fsub") +#define M_FSUBL FCML_TEXT("fsubl") +#define M_FSUBP FCML_TEXT("fsubp") +#define M_FSUBR FCML_TEXT("fsubr") +#define M_FSUBRL FCML_TEXT("fsubrl") +#define M_FSUBRP FCML_TEXT("fsubrp") +#define M_FSUBRS FCML_TEXT("fsubrs") +#define M_FSUBS FCML_TEXT("fsubs") +#define M_FTST FCML_TEXT("ftst") +#define M_FUCOM FCML_TEXT("fucom") +#define M_FUCOMI FCML_TEXT("fucomi") +#define M_FUCOMIP FCML_TEXT("fucomip") +#define M_FUCOMP FCML_TEXT("fucomp") +#define M_FUCOMPP FCML_TEXT("fucompp") +#define M_FWAIT FCML_TEXT("fwait") +#define M_FXAM FCML_TEXT("fxam") +#define M_FXCH FCML_TEXT("fxch") +#define M_FXRSTOR FCML_TEXT("fxrstor") +#define M_FXRSTOR64 FCML_TEXT("fxrstor64") +#define M_FXSAVE FCML_TEXT("fxsave") +#define M_FXSAVE64 FCML_TEXT("fxsave64") +#define M_FXTRACT FCML_TEXT("fxtract") +#define M_FYL2X FCML_TEXT("fyl2x") +#define M_FYL2XP1 FCML_TEXT("fyl2xp1") +#define M_GETSEC FCML_TEXT("getsec") +#define M_HADDPD FCML_TEXT("haddpd") +#define M_HADDPS FCML_TEXT("haddps") +#define M_HLT FCML_TEXT("hlt") +#define M_HSUBPD FCML_TEXT("hsubpd") +#define M_HSUBPS FCML_TEXT("hsubps") +#define M_IDIV FCML_TEXT("idiv") +#define M_IDIVB FCML_TEXT("idivb") +#define M_IDIVL FCML_TEXT("idivl") +#define M_IDIVQ FCML_TEXT("idivq") +#define M_IDIVW FCML_TEXT("idivw") +#define M_IMUL FCML_TEXT("imul") +#define M_IMULB FCML_TEXT("imulb") +#define M_IMULL FCML_TEXT("imull") +#define M_IMULQ FCML_TEXT("imulq") +#define M_IMULW FCML_TEXT("imulw") +#define M_IN FCML_TEXT("in") +#define M_INC FCML_TEXT("inc") +#define M_INCB FCML_TEXT("incb") +#define M_INCL FCML_TEXT("incl") +#define M_INCQ FCML_TEXT("incq") +#define M_INCW FCML_TEXT("incw") +#define M_INSB FCML_TEXT("insb") +#define M_INSERTPS FCML_TEXT("insertps") +#define M_INSERTQ FCML_TEXT("insertq") +#define M_INSL FCML_TEXT("insl") +#define M_INSW FCML_TEXT("insw") +#define M_INT FCML_TEXT("int") +#define M_INT3 FCML_TEXT("int3") +#define M_INTO FCML_TEXT("into") +#define M_INVD FCML_TEXT("invd") +#define M_INVEPT FCML_TEXT("invept") +#define M_INVLPG FCML_TEXT("invlpg") +#define M_INVLPGA FCML_TEXT("invlpga") +#define M_INVPCID FCML_TEXT("invpcid") +#define M_INVVPID FCML_TEXT("invvpid") +#define M_IRET FCML_TEXT("iret") +#define M_IRETQ FCML_TEXT("iretq") +#define M_IRETW FCML_TEXT("iretw") +#define M_JA FCML_TEXT("ja") +#define M_JAE FCML_TEXT("jae") +#define M_JB FCML_TEXT("jb") +#define M_JBE FCML_TEXT("jbe") +#define M_JC FCML_TEXT("jc") +#define M_JCXZ FCML_TEXT("jcxz") +#define M_JECXZ FCML_TEXT("jecxz") +#define M_JENE FCML_TEXT("jene") +#define M_JG FCML_TEXT("jg") +#define M_JGE FCML_TEXT("jge") +#define M_JL FCML_TEXT("jl") +#define M_JLE FCML_TEXT("jle") +#define M_JMP FCML_TEXT("jmp") +#define M_JMPQ FCML_TEXT("jmpq") +#define M_JMPW FCML_TEXT("jmpw") +#define M_JNA FCML_TEXT("jna") +#define M_JNAE FCML_TEXT("jnae") +#define M_JNB FCML_TEXT("jnb") +#define M_JNBE FCML_TEXT("jnbe") +#define M_JNC FCML_TEXT("jnc") +#define M_JNG FCML_TEXT("jng") +#define M_JNGE FCML_TEXT("jnge") +#define M_JNL FCML_TEXT("jnl") +#define M_JNLE FCML_TEXT("jnle") +#define M_JNO FCML_TEXT("jno") +#define M_JNP FCML_TEXT("jnp") +#define M_JNS FCML_TEXT("jns") +#define M_JNZ FCML_TEXT("jnz") +#define M_JO FCML_TEXT("jo") +#define M_JP FCML_TEXT("jp") +#define M_JPE FCML_TEXT("jpe") +#define M_JPO FCML_TEXT("jpo") +#define M_JRCXZ FCML_TEXT("jrcxz") +#define M_JS FCML_TEXT("js") +#define M_JZ FCML_TEXT("jz") +#define M_KADDB FCML_TEXT("kaddb") +#define M_KADDD FCML_TEXT("kaddd") +#define M_KADDQ FCML_TEXT("kaddq") +#define M_KADDW FCML_TEXT("kaddw") +#define M_KANDB FCML_TEXT("kandb") +#define M_KANDD FCML_TEXT("kandd") +#define M_KANDNB FCML_TEXT("kandnb") +#define M_KANDND FCML_TEXT("kandnd") +#define M_KANDNQ FCML_TEXT("kandnq") +#define M_KANDNW FCML_TEXT("kandnw") +#define M_KANDQ FCML_TEXT("kandq") +#define M_KANDW FCML_TEXT("kandw") +#define M_KMOVB FCML_TEXT("kmovb") +#define M_KMOVD FCML_TEXT("kmovd") +#define M_KMOVQ FCML_TEXT("kmovq") +#define M_KMOVW FCML_TEXT("kmovw") +#define M_KNOTB FCML_TEXT("knotb") +#define M_KNOTD FCML_TEXT("knotd") +#define M_KNOTQ FCML_TEXT("knotq") +#define M_KNOTW FCML_TEXT("knotw") +#define M_KORB FCML_TEXT("korb") +#define M_KORD FCML_TEXT("kord") +#define M_KORQ FCML_TEXT("korq") +#define M_KORTESTB FCML_TEXT("kortestb") +#define M_KORTESTD FCML_TEXT("kortestd") +#define M_KORTESTQ FCML_TEXT("kortestq") +#define M_KORTESTW FCML_TEXT("kortestw") +#define M_KORW FCML_TEXT("korw") +#define M_KSHIFTLB FCML_TEXT("kshiftlb") +#define M_KSHIFTLD FCML_TEXT("kshiftld") +#define M_KSHIFTLQ FCML_TEXT("kshiftlq") +#define M_KSHIFTLW FCML_TEXT("kshiftlw") +#define M_KSHIFTRB FCML_TEXT("kshiftrb") +#define M_KSHIFTRD FCML_TEXT("kshiftrd") +#define M_KSHIFTRQ FCML_TEXT("kshiftrq") +#define M_KSHIFTRW FCML_TEXT("kshiftrw") +#define M_KTESTB FCML_TEXT("ktestb") +#define M_KTESTD FCML_TEXT("ktestd") +#define M_KTESTQ FCML_TEXT("ktestq") +#define M_KTESTW FCML_TEXT("ktestw") +#define M_KXNORB FCML_TEXT("kxnorb") +#define M_KXNORD FCML_TEXT("kxnord") +#define M_KXNORQ FCML_TEXT("kxnorq") +#define M_KXNORW FCML_TEXT("kxnorw") +#define M_KXORB FCML_TEXT("kxorb") +#define M_KXORD FCML_TEXT("kxord") +#define M_KXORQ FCML_TEXT("kxorq") +#define M_KXORW FCML_TEXT("kxorw") +#define M_LAHF FCML_TEXT("lahf") +#define M_LAR FCML_TEXT("lar") +#define M_LCALL FCML_TEXT("lcall") +#define M_LCALLQ FCML_TEXT("lcallq") +#define M_LCALLW FCML_TEXT("lcallw") +#define M_LDDQU FCML_TEXT("lddqu") +#define M_LDMXCSR FCML_TEXT("ldmxcsr") +#define M_LDS FCML_TEXT("lds") +#define M_LEA FCML_TEXT("lea") +#define M_LEAVE FCML_TEXT("leave") +#define M_LES FCML_TEXT("les") +#define M_LFENCE FCML_TEXT("lfence") +#define M_LFS FCML_TEXT("lfs") +#define M_LGDT FCML_TEXT("lgdt") +#define M_LGS FCML_TEXT("lgs") +#define M_LIDT FCML_TEXT("lidt") +#define M_LJMP FCML_TEXT("ljmp") +#define M_LJMPL FCML_TEXT("ljmpl") +#define M_LJMPQ FCML_TEXT("ljmpq") +#define M_LJMPW FCML_TEXT("ljmpw") +#define M_LLDT FCML_TEXT("lldt") +#define M_LLWPCB FCML_TEXT("llwpcb") +#define M_LMSW FCML_TEXT("lmsw") +#define M_LODS FCML_TEXT("lods") +#define M_LODSB FCML_TEXT("lodsb") +#define M_LODSL FCML_TEXT("lodsl") +#define M_LODSQ FCML_TEXT("lodsq") +#define M_LODSW FCML_TEXT("lodsw") +#define M_LOOP FCML_TEXT("loop") +#define M_LOOPE FCML_TEXT("loope") +#define M_LOOPNE FCML_TEXT("loopne") +#define M_LOOPNZ FCML_TEXT("loopnz") +#define M_LOOPZ FCML_TEXT("loopz") +#define M_LRET FCML_TEXT("lret") +#define M_LRETQ FCML_TEXT("lretq") +#define M_LRETW FCML_TEXT("lretw") +#define M_LSL FCML_TEXT("lsl") +#define M_LSS FCML_TEXT("lss") +#define M_LTR FCML_TEXT("ltr") +#define M_LWPINS FCML_TEXT("lwpins") +#define M_LWPVAL FCML_TEXT("lwpval") +#define M_LZCNT FCML_TEXT("lzcnt") +#define M_MASKMOVDQU FCML_TEXT("maskmovdqu") +#define M_MASKMOVQ FCML_TEXT("maskmovq") +#define M_MAXPD FCML_TEXT("maxpd") +#define M_MAXPS FCML_TEXT("maxps") +#define M_MAXSD FCML_TEXT("maxsd") +#define M_MAXSS FCML_TEXT("maxss") +#define M_MFENCE FCML_TEXT("mfence") +#define M_MINPD FCML_TEXT("minpd") +#define M_MINPS FCML_TEXT("minps") +#define M_MINSD FCML_TEXT("minsd") +#define M_MINSS FCML_TEXT("minss") +#define M_MONITOR FCML_TEXT("monitor") +#define M_MOV FCML_TEXT("mov") +#define M_MOVABS FCML_TEXT("movabs") +#define M_MOVAPD FCML_TEXT("movapd") +#define M_MOVAPS FCML_TEXT("movaps") +#define M_MOVB FCML_TEXT("movb") +#define M_MOVBE FCML_TEXT("movbe") +#define M_MOVD FCML_TEXT("movd") +#define M_MOVDDUP FCML_TEXT("movddup") +#define M_MOVDQ2Q FCML_TEXT("movdq2q") +#define M_MOVDQA FCML_TEXT("movdqa") +#define M_MOVDQU FCML_TEXT("movdqu") +#define M_MOVHLPS FCML_TEXT("movhlps") +#define M_MOVHPD FCML_TEXT("movhpd") +#define M_MOVHPS FCML_TEXT("movhps") +#define M_MOVL FCML_TEXT("movl") +#define M_MOVLHPS FCML_TEXT("movlhps") +#define M_MOVLPD FCML_TEXT("movlpd") +#define M_MOVLPS FCML_TEXT("movlps") +#define M_MOVMSKPD FCML_TEXT("movmskpd") +#define M_MOVMSKPS FCML_TEXT("movmskps") +#define M_MOVNTDQ FCML_TEXT("movntdq") +#define M_MOVNTDQA FCML_TEXT("movntdqa") +#define M_MOVNTI FCML_TEXT("movnti") +#define M_MOVNTPD FCML_TEXT("movntpd") +#define M_MOVNTPS FCML_TEXT("movntps") +#define M_MOVNTQ FCML_TEXT("movntq") +#define M_MOVNTSD FCML_TEXT("movntsd") +#define M_MOVNTSS FCML_TEXT("movntss") +#define M_MOVQ FCML_TEXT("movq") +#define M_MOVQ2DQ FCML_TEXT("movq2dq") +#define M_MOVS FCML_TEXT("movs") +#define M_MOVSB FCML_TEXT("movsb") +#define M_MOVSBL FCML_TEXT("movsbl") +#define M_MOVSBQ FCML_TEXT("movsbq") +#define M_MOVSBW FCML_TEXT("movsbw") +#define M_MOVSD FCML_TEXT("movsd") +#define M_MOVSHDUP FCML_TEXT("movshdup") +#define M_MOVSL FCML_TEXT("movsl") +#define M_MOVSLDUP FCML_TEXT("movsldup") +#define M_MOVSQ FCML_TEXT("movsq") +#define M_MOVSS FCML_TEXT("movss") +#define M_MOVSW FCML_TEXT("movsw") +#define M_MOVSWL FCML_TEXT("movswl") +#define M_MOVSWQ FCML_TEXT("movswq") +#define M_MOVSWW FCML_TEXT("movsww") +#define M_MOVSXD FCML_TEXT("movsxd") +#define M_MOVUPD FCML_TEXT("movupd") +#define M_MOVUPS FCML_TEXT("movups") +#define M_MOVW FCML_TEXT("movw") +#define M_MOVZBL FCML_TEXT("movzbl") +#define M_MOVZBQ FCML_TEXT("movzbq") +#define M_MOVZBW FCML_TEXT("movzbw") +#define M_MOVZWL FCML_TEXT("movzwl") +#define M_MOVZWQ FCML_TEXT("movzwq") +#define M_MOVZWW FCML_TEXT("movzww") +#define M_MPSADBW FCML_TEXT("mpsadbw") +#define M_MUL FCML_TEXT("mul") +#define M_MULB FCML_TEXT("mulb") +#define M_MULL FCML_TEXT("mull") +#define M_MULPD FCML_TEXT("mulpd") +#define M_MULPS FCML_TEXT("mulps") +#define M_MULQ FCML_TEXT("mulq") +#define M_MULSD FCML_TEXT("mulsd") +#define M_MULSS FCML_TEXT("mulss") +#define M_MULW FCML_TEXT("mulw") +#define M_MULX FCML_TEXT("mulx") +#define M_MWAIT FCML_TEXT("mwait") +#define M_NEG FCML_TEXT("neg") +#define M_NEGB FCML_TEXT("negb") +#define M_NEGL FCML_TEXT("negl") +#define M_NEGQ FCML_TEXT("negq") +#define M_NEGW FCML_TEXT("negw") +#define M_NOP FCML_TEXT("nop") +#define M_NOPL FCML_TEXT("nopl") +#define M_NOPQ FCML_TEXT("nopq") +#define M_NOPW FCML_TEXT("nopw") +#define M_NOT FCML_TEXT("not") +#define M_NOTB FCML_TEXT("notb") +#define M_NOTL FCML_TEXT("notl") +#define M_NOTQ FCML_TEXT("notq") +#define M_NOTW FCML_TEXT("notw") +#define M_OR FCML_TEXT("or") +#define M_ORB FCML_TEXT("orb") +#define M_ORL FCML_TEXT("orl") +#define M_ORPD FCML_TEXT("orpd") +#define M_ORPS FCML_TEXT("orps") +#define M_ORQ FCML_TEXT("orq") +#define M_ORW FCML_TEXT("orw") +#define M_OUT FCML_TEXT("out") +#define M_OUTSB FCML_TEXT("outsb") +#define M_OUTSL FCML_TEXT("outsl") +#define M_OUTSW FCML_TEXT("outsw") +#define M_PABSB FCML_TEXT("pabsb") +#define M_PABSD FCML_TEXT("pabsd") +#define M_PABSW FCML_TEXT("pabsw") +#define M_PACKSSDW FCML_TEXT("packssdw") +#define M_PACKSSWB FCML_TEXT("packsswb") +#define M_PACKUSDW FCML_TEXT("packusdw") +#define M_PACKUSWB FCML_TEXT("packuswb") +#define M_PADDB FCML_TEXT("paddb") +#define M_PADDD FCML_TEXT("paddd") +#define M_PADDQ FCML_TEXT("paddq") +#define M_PADDSB FCML_TEXT("paddsb") +#define M_PADDSW FCML_TEXT("paddsw") +#define M_PADDUSB FCML_TEXT("paddusb") +#define M_PADDUSW FCML_TEXT("paddusw") +#define M_PADDW FCML_TEXT("paddw") +#define M_PALIGNR FCML_TEXT("palignr") +#define M_PAND FCML_TEXT("pand") +#define M_PANDN FCML_TEXT("pandn") +#define M_PAUSE FCML_TEXT("pause") +#define M_PAVGB FCML_TEXT("pavgb") +#define M_PAVGUSB FCML_TEXT("pavgusb") +#define M_PAVGW FCML_TEXT("pavgw") +#define M_PBLENDVB FCML_TEXT("pblendvb") +#define M_PBLENDW FCML_TEXT("pblendw") +#define M_PCLMULQDQ FCML_TEXT("pclmulqdq") +#define M_PCMPEQB FCML_TEXT("pcmpeqb") +#define M_PCMPEQD FCML_TEXT("pcmpeqd") +#define M_PCMPEQQ FCML_TEXT("pcmpeqq") +#define M_PCMPEQW FCML_TEXT("pcmpeqw") +#define M_PCMPESTRI FCML_TEXT("pcmpestri") +#define M_PCMPESTRM FCML_TEXT("pcmpestrm") +#define M_PCMPGTB FCML_TEXT("pcmpgtb") +#define M_PCMPGTD FCML_TEXT("pcmpgtd") +#define M_PCMPGTQ FCML_TEXT("pcmpgtq") +#define M_PCMPGTW FCML_TEXT("pcmpgtw") +#define M_PCMPISTRI FCML_TEXT("pcmpistri") +#define M_PCMPISTRM FCML_TEXT("pcmpistrm") +#define M_PDEP FCML_TEXT("pdep") +#define M_PEXT FCML_TEXT("pext") +#define M_PEXTRB FCML_TEXT("pextrb") +#define M_PEXTRD FCML_TEXT("pextrd") +#define M_PEXTRQ FCML_TEXT("pextrq") +#define M_PEXTRW FCML_TEXT("pextrw") +#define M_PF2ID FCML_TEXT("pf2id") +#define M_PF2IW FCML_TEXT("pf2iw") +#define M_PFACC FCML_TEXT("pfacc") +#define M_PFADD FCML_TEXT("pfadd") +#define M_PFCMPEQ FCML_TEXT("pfcmpeq") +#define M_PFCMPGE FCML_TEXT("pfcmpge") +#define M_PFCMPGT FCML_TEXT("pfcmpgt") +#define M_PFMAX FCML_TEXT("pfmax") +#define M_PFMIN FCML_TEXT("pfmin") +#define M_PFMUL FCML_TEXT("pfmul") +#define M_PFNACC FCML_TEXT("pfnacc") +#define M_PFPNACC FCML_TEXT("pfpnacc") +#define M_PFRCP FCML_TEXT("pfrcp") +#define M_PFRCPIT1 FCML_TEXT("pfrcpit1") +#define M_PFRCPIT2 FCML_TEXT("pfrcpit2") +#define M_PFRSQIT1 FCML_TEXT("pfrsqit1") +#define M_PFRSQRT FCML_TEXT("pfrsqrt") +#define M_PFSUB FCML_TEXT("pfsub") +#define M_PFSUBR FCML_TEXT("pfsubr") +#define M_PHADDD FCML_TEXT("phaddd") +#define M_PHADDSW FCML_TEXT("phaddsw") +#define M_PHADDW FCML_TEXT("phaddw") +#define M_PHMINPOSUW FCML_TEXT("phminposuw") +#define M_PHSUBD FCML_TEXT("phsubd") +#define M_PHSUBSW FCML_TEXT("phsubsw") +#define M_PHSUBW FCML_TEXT("phsubw") +#define M_PI2FD FCML_TEXT("pi2fd") +#define M_PI2FW FCML_TEXT("pi2fw") +#define M_PINSRB FCML_TEXT("pinsrb") +#define M_PINSRD FCML_TEXT("pinsrd") +#define M_PINSRQ FCML_TEXT("pinsrq") +#define M_PINSRW FCML_TEXT("pinsrw") +#define M_PMADDUBSW FCML_TEXT("pmaddubsw") +#define M_PMADDWD FCML_TEXT("pmaddwd") +#define M_PMAXSB FCML_TEXT("pmaxsb") +#define M_PMAXSD FCML_TEXT("pmaxsd") +#define M_PMAXSW FCML_TEXT("pmaxsw") +#define M_PMAXUB FCML_TEXT("pmaxub") +#define M_PMAXUD FCML_TEXT("pmaxud") +#define M_PMAXUW FCML_TEXT("pmaxuw") +#define M_PMINSB FCML_TEXT("pminsb") +#define M_PMINSD FCML_TEXT("pminsd") +#define M_PMINSW FCML_TEXT("pminsw") +#define M_PMINUB FCML_TEXT("pminub") +#define M_PMINUD FCML_TEXT("pminud") +#define M_PMINUW FCML_TEXT("pminuw") +#define M_PMOVMSKB FCML_TEXT("pmovmskb") +#define M_PMOVSXBD FCML_TEXT("pmovsxbd") +#define M_PMOVSXBQ FCML_TEXT("pmovsxbq") +#define M_PMOVSXBW FCML_TEXT("pmovsxbw") +#define M_PMOVSXDQ FCML_TEXT("pmovsxdq") +#define M_PMOVSXWD FCML_TEXT("pmovsxwd") +#define M_PMOVSXWQ FCML_TEXT("pmovsxwq") +#define M_PMOVZXBD FCML_TEXT("pmovzxbd") +#define M_PMOVZXBQ FCML_TEXT("pmovzxbq") +#define M_PMOVZXBW FCML_TEXT("pmovzxbw") +#define M_PMOVZXDQ FCML_TEXT("pmovzxdq") +#define M_PMOVZXWD FCML_TEXT("pmovzxwd") +#define M_PMOVZXWQ FCML_TEXT("pmovzxwq") +#define M_PMULDQ FCML_TEXT("pmuldq") +#define M_PMULHRSW FCML_TEXT("pmulhrsw") +#define M_PMULHRW FCML_TEXT("pmulhrw") +#define M_PMULHUW FCML_TEXT("pmulhuw") +#define M_PMULHW FCML_TEXT("pmulhw") +#define M_PMULLD FCML_TEXT("pmulld") +#define M_PMULLW FCML_TEXT("pmullw") +#define M_PMULUDQ FCML_TEXT("pmuludq") +#define M_POP FCML_TEXT("pop") +#define M_POPA FCML_TEXT("popa") +#define M_POPAW FCML_TEXT("popaw") +#define M_POPCNT FCML_TEXT("popcnt") +#define M_POPF FCML_TEXT("popf") +#define M_POPFQ FCML_TEXT("popfq") +#define M_POPFW FCML_TEXT("popfw") +#define M_POPL FCML_TEXT("popl") +#define M_POPQ FCML_TEXT("popq") +#define M_POPW FCML_TEXT("popw") +#define M_POR FCML_TEXT("por") +#define M_PREFETCH FCML_TEXT("prefetch") +#define M_PREFETCHNTA FCML_TEXT("prefetchnta") +#define M_PREFETCHT0 FCML_TEXT("prefetcht0") +#define M_PREFETCHT1 FCML_TEXT("prefetcht1") +#define M_PREFETCHT2 FCML_TEXT("prefetcht2") +#define M_PREFETCHW FCML_TEXT("prefetchw") +#define M_PREFETCHWT1 FCML_TEXT("prefetchwt1") +#define M_PSADBW FCML_TEXT("psadbw") +#define M_PSHUFB FCML_TEXT("pshufb") +#define M_PSHUFD FCML_TEXT("pshufd") +#define M_PSHUFHW FCML_TEXT("pshufhw") +#define M_PSHUFLW FCML_TEXT("pshuflw") +#define M_PSHUFW FCML_TEXT("pshufw") +#define M_PSIGNB FCML_TEXT("psignb") +#define M_PSIGND FCML_TEXT("psignd") +#define M_PSIGNW FCML_TEXT("psignw") +#define M_PSLLD FCML_TEXT("pslld") +#define M_PSLLDQ FCML_TEXT("pslldq") +#define M_PSLLQ FCML_TEXT("psllq") +#define M_PSLLW FCML_TEXT("psllw") +#define M_PSRAD FCML_TEXT("psrad") +#define M_PSRAW FCML_TEXT("psraw") +#define M_PSRLD FCML_TEXT("psrld") +#define M_PSRLDQ FCML_TEXT("psrldq") +#define M_PSRLQ FCML_TEXT("psrlq") +#define M_PSRLW FCML_TEXT("psrlw") +#define M_PSUBB FCML_TEXT("psubb") +#define M_PSUBD FCML_TEXT("psubd") +#define M_PSUBQ FCML_TEXT("psubq") +#define M_PSUBSB FCML_TEXT("psubsb") +#define M_PSUBSW FCML_TEXT("psubsw") +#define M_PSUBUSB FCML_TEXT("psubusb") +#define M_PSUBUSW FCML_TEXT("psubusw") +#define M_PSUBW FCML_TEXT("psubw") +#define M_PSWAPD FCML_TEXT("pswapd") +#define M_PTEST FCML_TEXT("ptest") +#define M_PUNPCKHBW FCML_TEXT("punpckhbw") +#define M_PUNPCKHDQ FCML_TEXT("punpckhdq") +#define M_PUNPCKHQDQ FCML_TEXT("punpckhqdq") +#define M_PUNPCKHWD FCML_TEXT("punpckhwd") +#define M_PUNPCKLBW FCML_TEXT("punpcklbw") +#define M_PUNPCKLDQ FCML_TEXT("punpckldq") +#define M_PUNPCKLQDQ FCML_TEXT("punpcklqdq") +#define M_PUNPCKLWD FCML_TEXT("punpcklwd") +#define M_PUSH FCML_TEXT("push") +#define M_PUSHA FCML_TEXT("pusha") +#define M_PUSHAW FCML_TEXT("pushaw") +#define M_PUSHB FCML_TEXT("pushb") +#define M_PUSHF FCML_TEXT("pushf") +#define M_PUSHFQ FCML_TEXT("pushfq") +#define M_PUSHFW FCML_TEXT("pushfw") +#define M_PUSHL FCML_TEXT("pushl") +#define M_PUSHQ FCML_TEXT("pushq") +#define M_PUSHW FCML_TEXT("pushw") +#define M_PXOR FCML_TEXT("pxor") +#define M_RCL FCML_TEXT("rcl") +#define M_RCLB FCML_TEXT("rclb") +#define M_RCLL FCML_TEXT("rcll") +#define M_RCLQ FCML_TEXT("rclq") +#define M_RCLW FCML_TEXT("rclw") +#define M_RCPPS FCML_TEXT("rcpps") +#define M_RCPSS FCML_TEXT("rcpss") +#define M_RCR FCML_TEXT("rcr") +#define M_RCRB FCML_TEXT("rcrb") +#define M_RCRL FCML_TEXT("rcrl") +#define M_RCRQ FCML_TEXT("rcrq") +#define M_RCRW FCML_TEXT("rcrw") +#define M_RDFSBASE FCML_TEXT("rdfsbase") +#define M_RDGSBASE FCML_TEXT("rdgsbase") +#define M_RDMSR FCML_TEXT("rdmsr") +#define M_RDPMC FCML_TEXT("rdpmc") +#define M_RDRAND FCML_TEXT("rdrand") +#define M_RDSEED FCML_TEXT("rdseed") +#define M_RDTSC FCML_TEXT("rdtsc") +#define M_RDTSCP FCML_TEXT("rdtscp") +#define M_RET FCML_TEXT("ret") +#define M_RETQ FCML_TEXT("retq") +#define M_RETW FCML_TEXT("retw") +#define M_ROL FCML_TEXT("rol") +#define M_ROLB FCML_TEXT("rolb") +#define M_ROLL FCML_TEXT("roll") +#define M_ROLQ FCML_TEXT("rolq") +#define M_ROLW FCML_TEXT("rolw") +#define M_ROR FCML_TEXT("ror") +#define M_RORB FCML_TEXT("rorb") +#define M_RORL FCML_TEXT("rorl") +#define M_RORQ FCML_TEXT("rorq") +#define M_RORW FCML_TEXT("rorw") +#define M_RORX FCML_TEXT("rorx") +#define M_ROUNDPD FCML_TEXT("roundpd") +#define M_ROUNDPS FCML_TEXT("roundps") +#define M_ROUNDSD FCML_TEXT("roundsd") +#define M_ROUNDSS FCML_TEXT("roundss") +#define M_RSM FCML_TEXT("rsm") +#define M_RSQRTPS FCML_TEXT("rsqrtps") +#define M_RSQRTSS FCML_TEXT("rsqrtss") +#define M_SAHF FCML_TEXT("sahf") +#define M_SAL FCML_TEXT("sal") +#define M_SALB FCML_TEXT("salb") +#define M_SALL FCML_TEXT("sall") +#define M_SALQ FCML_TEXT("salq") +#define M_SALW FCML_TEXT("salw") +#define M_SAR FCML_TEXT("sar") +#define M_SARB FCML_TEXT("sarb") +#define M_SARL FCML_TEXT("sarl") +#define M_SARQ FCML_TEXT("sarq") +#define M_SARW FCML_TEXT("sarw") +#define M_SARX FCML_TEXT("sarx") +#define M_SBB FCML_TEXT("sbb") +#define M_SBBB FCML_TEXT("sbbb") +#define M_SBBL FCML_TEXT("sbbl") +#define M_SBBQ FCML_TEXT("sbbq") +#define M_SBBW FCML_TEXT("sbbw") +#define M_SCAS FCML_TEXT("scas") +#define M_SCASB FCML_TEXT("scasb") +#define M_SCASL FCML_TEXT("scasl") +#define M_SCASQ FCML_TEXT("scasq") +#define M_SCASW FCML_TEXT("scasw") +#define M_SETA FCML_TEXT("seta") +#define M_SETAE FCML_TEXT("setae") +#define M_SETB FCML_TEXT("setb") +#define M_SETBE FCML_TEXT("setbe") +#define M_SETC FCML_TEXT("setc") +#define M_SETENE FCML_TEXT("setene") +#define M_SETG FCML_TEXT("setg") +#define M_SETGE FCML_TEXT("setge") +#define M_SETL FCML_TEXT("setl") +#define M_SETLE FCML_TEXT("setle") +#define M_SETNA FCML_TEXT("setna") +#define M_SETNAE FCML_TEXT("setnae") +#define M_SETNB FCML_TEXT("setnb") +#define M_SETNBE FCML_TEXT("setnbe") +#define M_SETNC FCML_TEXT("setnc") +#define M_SETNG FCML_TEXT("setng") +#define M_SETNGE FCML_TEXT("setnge") +#define M_SETNL FCML_TEXT("setnl") +#define M_SETNLE FCML_TEXT("setnle") +#define M_SETNO FCML_TEXT("setno") +#define M_SETNP FCML_TEXT("setnp") +#define M_SETNS FCML_TEXT("setns") +#define M_SETNZ FCML_TEXT("setnz") +#define M_SETO FCML_TEXT("seto") +#define M_SETP FCML_TEXT("setp") +#define M_SETPE FCML_TEXT("setpe") +#define M_SETPO FCML_TEXT("setpo") +#define M_SETS FCML_TEXT("sets") +#define M_SETZ FCML_TEXT("setz") +#define M_SFENCE FCML_TEXT("sfence") +#define M_SGDT FCML_TEXT("sgdt") +#define M_SHL FCML_TEXT("shl") +#define M_SHLB FCML_TEXT("shlb") +#define M_SHLD FCML_TEXT("shld") +#define M_SHLL FCML_TEXT("shll") +#define M_SHLQ FCML_TEXT("shlq") +#define M_SHLW FCML_TEXT("shlw") +#define M_SHLX FCML_TEXT("shlx") +#define M_SHR FCML_TEXT("shr") +#define M_SHRB FCML_TEXT("shrb") +#define M_SHRD FCML_TEXT("shrd") +#define M_SHRL FCML_TEXT("shrl") +#define M_SHRQ FCML_TEXT("shrq") +#define M_SHRW FCML_TEXT("shrw") +#define M_SHRX FCML_TEXT("shrx") +#define M_SHUFPD FCML_TEXT("shufpd") +#define M_SHUFPS FCML_TEXT("shufps") +#define M_SIDT FCML_TEXT("sidt") +#define M_SKINIT FCML_TEXT("skinit") +#define M_SLDT FCML_TEXT("sldt") +#define M_SLWPCB FCML_TEXT("slwpcb") +#define M_SMSW FCML_TEXT("smsw") +#define M_SQRTPD FCML_TEXT("sqrtpd") +#define M_SQRTPS FCML_TEXT("sqrtps") +#define M_SQRTSD FCML_TEXT("sqrtsd") +#define M_SQRTSS FCML_TEXT("sqrtss") +#define M_STAC FCML_TEXT("stac") +#define M_STC FCML_TEXT("stc") +#define M_STD FCML_TEXT("std") +#define M_STGI FCML_TEXT("stgi") +#define M_STI FCML_TEXT("sti") +#define M_STMXCSR FCML_TEXT("stmxcsr") +#define M_STOS FCML_TEXT("stos") +#define M_STOSB FCML_TEXT("stosb") +#define M_STOSL FCML_TEXT("stosl") +#define M_STOSQ FCML_TEXT("stosq") +#define M_STOSW FCML_TEXT("stosw") +#define M_STR FCML_TEXT("str") +#define M_SUB FCML_TEXT("sub") +#define M_SUBB FCML_TEXT("subb") +#define M_SUBL FCML_TEXT("subl") +#define M_SUBPD FCML_TEXT("subpd") +#define M_SUBPS FCML_TEXT("subps") +#define M_SUBQ FCML_TEXT("subq") +#define M_SUBSD FCML_TEXT("subsd") +#define M_SUBSS FCML_TEXT("subss") +#define M_SUBW FCML_TEXT("subw") +#define M_SWAPGS FCML_TEXT("swapgs") +#define M_SYSCALL FCML_TEXT("syscall") +#define M_SYSENTER FCML_TEXT("sysenter") +#define M_SYSEXIT FCML_TEXT("sysexit") +#define M_SYSRET FCML_TEXT("sysret") +#define M_T1MSKC FCML_TEXT("t1mskc") +#define M_TEST FCML_TEXT("test") +#define M_TESTB FCML_TEXT("testb") +#define M_TESTL FCML_TEXT("testl") +#define M_TESTQ FCML_TEXT("testq") +#define M_TESTW FCML_TEXT("testw") +#define M_TZCNT FCML_TEXT("tzcnt") +#define M_TZMSK FCML_TEXT("tzmsk") +#define M_UCOMISD FCML_TEXT("ucomisd") +#define M_UCOMISS FCML_TEXT("ucomiss") +#define M_UD2 FCML_TEXT("ud2") +#define M_UNPCKHPD FCML_TEXT("unpckhpd") +#define M_UNPCKHPS FCML_TEXT("unpckhps") +#define M_UNPCKLPD FCML_TEXT("unpcklpd") +#define M_UNPCKLPS FCML_TEXT("unpcklps") +#define M_V4FMADDPS FCML_TEXT("v4fmaddps") +#define M_V4FMADDSS FCML_TEXT("v4fmaddss") +#define M_V4FNMADDPS FCML_TEXT("v4fnmaddps") +#define M_V4FNMADDSS FCML_TEXT("v4fnmaddss") +#define M_VADDPD FCML_TEXT("vaddpd") +#define M_VADDPS FCML_TEXT("vaddps") +#define M_VADDSD FCML_TEXT("vaddsd") +#define M_VADDSS FCML_TEXT("vaddss") +#define M_VADDSUBPD FCML_TEXT("vaddsubpd") +#define M_VADDSUBPS FCML_TEXT("vaddsubps") +#define M_VAESDEC FCML_TEXT("vaesdec") +#define M_VAESDECLAST FCML_TEXT("vaesdeclast") +#define M_VAESENC FCML_TEXT("vaesenc") +#define M_VAESENCLAST FCML_TEXT("vaesenclast") +#define M_VAESIMC FCML_TEXT("vaesimc") +#define M_VAESKEYGENASSIST FCML_TEXT("vaeskeygenassist") +#define M_VALIGND FCML_TEXT("valignd") +#define M_VALIGNQ FCML_TEXT("valignq") +#define M_VANDNPD FCML_TEXT("vandnpd") +#define M_VANDNPS FCML_TEXT("vandnps") +#define M_VANDPD FCML_TEXT("vandpd") +#define M_VANDPS FCML_TEXT("vandps") +#define M_VBLENDMPD FCML_TEXT("vblendmpd") +#define M_VBLENDMPS FCML_TEXT("vblendmps") +#define M_VBLENDPD FCML_TEXT("vblendpd") +#define M_VBLENDPS FCML_TEXT("vblendps") +#define M_VBLENDVPD FCML_TEXT("vblendvpd") +#define M_VBLENDVPS FCML_TEXT("vblendvps") +#define M_VBROADCASTF128 FCML_TEXT("vbroadcastf128") +#define M_VBROADCASTF32X2 FCML_TEXT("vbroadcastf32x2") +#define M_VBROADCASTF32X4 FCML_TEXT("vbroadcastf32x4") +#define M_VBROADCASTF32X8 FCML_TEXT("vbroadcastf32x8") +#define M_VBROADCASTF64X2 FCML_TEXT("vbroadcastf64x2") +#define M_VBROADCASTF64X4 FCML_TEXT("vbroadcastf64x4") +#define M_VBROADCASTI128 FCML_TEXT("vbroadcasti128") +#define M_VBROADCASTI32X2 FCML_TEXT("vbroadcasti32x2") +#define M_VBROADCASTI32X4 FCML_TEXT("vbroadcasti32x4") +#define M_VBROADCASTI32X8 FCML_TEXT("vbroadcasti32x8") +#define M_VBROADCASTI64X2 FCML_TEXT("vbroadcasti64x2") +#define M_VBROADCASTI64X4 FCML_TEXT("vbroadcasti64x4") +#define M_VBROADCASTSD FCML_TEXT("vbroadcastsd") +#define M_VBROADCASTSS FCML_TEXT("vbroadcastss") +#define M_VCMPEQ_OSPD FCML_TEXT("vcmpeq_ospd") +#define M_VCMPEQ_OSPS FCML_TEXT("vcmpeq_osps") +#define M_VCMPEQ_OSSD FCML_TEXT("vcmpeq_ossd") +#define M_VCMPEQ_OSSS FCML_TEXT("vcmpeq_osss") +#define M_VCMPEQ_UQPD FCML_TEXT("vcmpeq_uqpd") +#define M_VCMPEQ_UQPS FCML_TEXT("vcmpeq_uqps") +#define M_VCMPEQ_UQSD FCML_TEXT("vcmpeq_uqsd") +#define M_VCMPEQ_UQSS FCML_TEXT("vcmpeq_uqss") +#define M_VCMPEQ_USPD FCML_TEXT("vcmpeq_uspd") +#define M_VCMPEQ_USPS FCML_TEXT("vcmpeq_usps") +#define M_VCMPEQ_USSD FCML_TEXT("vcmpeq_ussd") +#define M_VCMPEQ_USSS FCML_TEXT("vcmpeq_usss") +#define M_VCMPEQPD FCML_TEXT("vcmpeqpd") +#define M_VCMPEQPS FCML_TEXT("vcmpeqps") +#define M_VCMPEQSD FCML_TEXT("vcmpeqsd") +#define M_VCMPEQSS FCML_TEXT("vcmpeqss") +#define M_VCMPFALSE_OSPD FCML_TEXT("vcmpfalse_ospd") +#define M_VCMPFALSE_OSPS FCML_TEXT("vcmpfalse_osps") +#define M_VCMPFALSE_OSSD FCML_TEXT("vcmpfalse_ossd") +#define M_VCMPFALSE_OSSS FCML_TEXT("vcmpfalse_osss") +#define M_VCMPFALSEPD FCML_TEXT("vcmpfalsepd") +#define M_VCMPFALSEPS FCML_TEXT("vcmpfalseps") +#define M_VCMPFALSESD FCML_TEXT("vcmpfalsesd") +#define M_VCMPFALSESS FCML_TEXT("vcmpfalsess") +#define M_VCMPGE_OQPD FCML_TEXT("vcmpge_oqpd") +#define M_VCMPGE_OQPS FCML_TEXT("vcmpge_oqps") +#define M_VCMPGE_OQSD FCML_TEXT("vcmpge_oqsd") +#define M_VCMPGE_OQSS FCML_TEXT("vcmpge_oqss") +#define M_VCMPGEPD FCML_TEXT("vcmpgepd") +#define M_VCMPGEPS FCML_TEXT("vcmpgeps") +#define M_VCMPGESD FCML_TEXT("vcmpgesd") +#define M_VCMPGESS FCML_TEXT("vcmpgess") +#define M_VCMPGT_OQPD FCML_TEXT("vcmpgt_oqpd") +#define M_VCMPGT_OQPS FCML_TEXT("vcmpgt_oqps") +#define M_VCMPGT_OQSD FCML_TEXT("vcmpgt_oqsd") +#define M_VCMPGT_OQSS FCML_TEXT("vcmpgt_oqss") +#define M_VCMPGTPD FCML_TEXT("vcmpgtpd") +#define M_VCMPGTPS FCML_TEXT("vcmpgtps") +#define M_VCMPGTSD FCML_TEXT("vcmpgtsd") +#define M_VCMPGTSS FCML_TEXT("vcmpgtss") +#define M_VCMPLE_OQPD FCML_TEXT("vcmple_oqpd") +#define M_VCMPLE_OQPS FCML_TEXT("vcmple_oqps") +#define M_VCMPLE_OQSD FCML_TEXT("vcmple_oqsd") +#define M_VCMPLE_OQSS FCML_TEXT("vcmple_oqss") +#define M_VCMPLEPD FCML_TEXT("vcmplepd") +#define M_VCMPLEPS FCML_TEXT("vcmpleps") +#define M_VCMPLESD FCML_TEXT("vcmplesd") +#define M_VCMPLESS FCML_TEXT("vcmpless") +#define M_VCMPLT_OQPD FCML_TEXT("vcmplt_oqpd") +#define M_VCMPLT_OQPS FCML_TEXT("vcmplt_oqps") +#define M_VCMPLT_OQSD FCML_TEXT("vcmplt_oqsd") +#define M_VCMPLT_OQSS FCML_TEXT("vcmplt_oqss") +#define M_VCMPLTPD FCML_TEXT("vcmpltpd") +#define M_VCMPLTPS FCML_TEXT("vcmpltps") +#define M_VCMPLTSD FCML_TEXT("vcmpltsd") +#define M_VCMPLTSS FCML_TEXT("vcmpltss") +#define M_VCMPNEQ_OQPD FCML_TEXT("vcmpneq_oqpd") +#define M_VCMPNEQ_OQPS FCML_TEXT("vcmpneq_oqps") +#define M_VCMPNEQ_OQSD FCML_TEXT("vcmpneq_oqsd") +#define M_VCMPNEQ_OQSS FCML_TEXT("vcmpneq_oqss") +#define M_VCMPNEQ_OSPD FCML_TEXT("vcmpneq_ospd") +#define M_VCMPNEQ_OSPS FCML_TEXT("vcmpneq_osps") +#define M_VCMPNEQ_OSSD FCML_TEXT("vcmpneq_ossd") +#define M_VCMPNEQ_OSSS FCML_TEXT("vcmpneq_osss") +#define M_VCMPNEQ_USPD FCML_TEXT("vcmpneq_uspd") +#define M_VCMPNEQ_USPS FCML_TEXT("vcmpneq_usps") +#define M_VCMPNEQ_USSD FCML_TEXT("vcmpneq_ussd") +#define M_VCMPNEQ_USSS FCML_TEXT("vcmpneq_usss") +#define M_VCMPNEQPD FCML_TEXT("vcmpneqpd") +#define M_VCMPNEQPS FCML_TEXT("vcmpneqps") +#define M_VCMPNEQSD FCML_TEXT("vcmpneqsd") +#define M_VCMPNEQSS FCML_TEXT("vcmpneqss") +#define M_VCMPNGE_UQPD FCML_TEXT("vcmpnge_uqpd") +#define M_VCMPNGE_UQPS FCML_TEXT("vcmpnge_uqps") +#define M_VCMPNGE_UQSD FCML_TEXT("vcmpnge_uqsd") +#define M_VCMPNGE_UQSS FCML_TEXT("vcmpnge_uqss") +#define M_VCMPNGEPD FCML_TEXT("vcmpngepd") +#define M_VCMPNGEPS FCML_TEXT("vcmpngeps") +#define M_VCMPNGESD FCML_TEXT("vcmpngesd") +#define M_VCMPNGESS FCML_TEXT("vcmpngess") +#define M_VCMPNGT_UQPD FCML_TEXT("vcmpngt_uqpd") +#define M_VCMPNGT_UQPS FCML_TEXT("vcmpngt_uqps") +#define M_VCMPNGT_UQSD FCML_TEXT("vcmpngt_uqsd") +#define M_VCMPNGT_UQSS FCML_TEXT("vcmpngt_uqss") +#define M_VCMPNGTPD FCML_TEXT("vcmpngtpd") +#define M_VCMPNGTPS FCML_TEXT("vcmpngtps") +#define M_VCMPNGTSD FCML_TEXT("vcmpngtsd") +#define M_VCMPNGTSS FCML_TEXT("vcmpngtss") +#define M_VCMPNLE_UQPD FCML_TEXT("vcmpnle_uqpd") +#define M_VCMPNLE_UQPS FCML_TEXT("vcmpnle_uqps") +#define M_VCMPNLE_UQSD FCML_TEXT("vcmpnle_uqsd") +#define M_VCMPNLE_UQSS FCML_TEXT("vcmpnle_uqss") +#define M_VCMPNLEPD FCML_TEXT("vcmpnlepd") +#define M_VCMPNLEPS FCML_TEXT("vcmpnleps") +#define M_VCMPNLESD FCML_TEXT("vcmpnlesd") +#define M_VCMPNLESS FCML_TEXT("vcmpnless") +#define M_VCMPNLT_UQPD FCML_TEXT("vcmpnlt_uqpd") +#define M_VCMPNLT_UQPS FCML_TEXT("vcmpnlt_uqps") +#define M_VCMPNLT_UQSD FCML_TEXT("vcmpnlt_uqsd") +#define M_VCMPNLT_UQSS FCML_TEXT("vcmpnlt_uqss") +#define M_VCMPNLTPD FCML_TEXT("vcmpnltpd") +#define M_VCMPNLTPS FCML_TEXT("vcmpnltps") +#define M_VCMPNLTSD FCML_TEXT("vcmpnltsd") +#define M_VCMPNLTSS FCML_TEXT("vcmpnltss") +#define M_VCMPORD_SPD FCML_TEXT("vcmpord_spd") +#define M_VCMPORD_SPS FCML_TEXT("vcmpord_sps") +#define M_VCMPORD_SSD FCML_TEXT("vcmpord_ssd") +#define M_VCMPORD_SSS FCML_TEXT("vcmpord_sss") +#define M_VCMPORDPD FCML_TEXT("vcmpordpd") +#define M_VCMPORDPS FCML_TEXT("vcmpordps") +#define M_VCMPORDSD FCML_TEXT("vcmpordsd") +#define M_VCMPORDSS FCML_TEXT("vcmpordss") +#define M_VCMPPD FCML_TEXT("vcmppd") +#define M_VCMPPS FCML_TEXT("vcmpps") +#define M_VCMPSD FCML_TEXT("vcmpsd") +#define M_VCMPSS FCML_TEXT("vcmpss") +#define M_VCMPTRUE_USPD FCML_TEXT("vcmptrue_uspd") +#define M_VCMPTRUE_USPS FCML_TEXT("vcmptrue_usps") +#define M_VCMPTRUE_USSD FCML_TEXT("vcmptrue_ussd") +#define M_VCMPTRUE_USSS FCML_TEXT("vcmptrue_usss") +#define M_VCMPTRUEPD FCML_TEXT("vcmptruepd") +#define M_VCMPTRUEPS FCML_TEXT("vcmptrueps") +#define M_VCMPTRUESD FCML_TEXT("vcmptruesd") +#define M_VCMPTRUESS FCML_TEXT("vcmptruess") +#define M_VCMPUNORD_SPD FCML_TEXT("vcmpunord_spd") +#define M_VCMPUNORD_SPS FCML_TEXT("vcmpunord_sps") +#define M_VCMPUNORD_SSD FCML_TEXT("vcmpunord_ssd") +#define M_VCMPUNORD_SSS FCML_TEXT("vcmpunord_sss") +#define M_VCMPUNORDPD FCML_TEXT("vcmpunordpd") +#define M_VCMPUNORDPS FCML_TEXT("vcmpunordps") +#define M_VCMPUNORDSD FCML_TEXT("vcmpunordsd") +#define M_VCMPUNORDSS FCML_TEXT("vcmpunordss") +#define M_VCOMISD FCML_TEXT("vcomisd") +#define M_VCOMISS FCML_TEXT("vcomiss") +#define M_VCOMPRESSPD FCML_TEXT("vcompresspd") +#define M_VCOMPRESSPS FCML_TEXT("vcompressps") +#define M_VCVTDQ2PD FCML_TEXT("vcvtdq2pd") +#define M_VCVTDQ2PS FCML_TEXT("vcvtdq2ps") +#define M_VCVTPD2DQ FCML_TEXT("vcvtpd2dq") +#define M_VCVTPD2DQX FCML_TEXT("vcvtpd2dqx") +#define M_VCVTPD2DQY FCML_TEXT("vcvtpd2dqy") +#define M_VCVTPD2PS FCML_TEXT("vcvtpd2ps") +#define M_VCVTPD2PSX FCML_TEXT("vcvtpd2psx") +#define M_VCVTPD2PSY FCML_TEXT("vcvtpd2psy") +#define M_VCVTPD2QQ FCML_TEXT("vcvtpd2qq") +#define M_VCVTPD2UDQ FCML_TEXT("vcvtpd2udq") +#define M_VCVTPD2UDQX FCML_TEXT("vcvtpd2udqx") +#define M_VCVTPD2UDQY FCML_TEXT("vcvtpd2udqy") +#define M_VCVTPD2UQQ FCML_TEXT("vcvtpd2uqq") +#define M_VCVTPH2PS FCML_TEXT("vcvtph2ps") +#define M_VCVTPS2DQ FCML_TEXT("vcvtps2dq") +#define M_VCVTPS2PD FCML_TEXT("vcvtps2pd") +#define M_VCVTPS2PH FCML_TEXT("vcvtps2ph") +#define M_VCVTPS2QQ FCML_TEXT("vcvtps2qq") +#define M_VCVTPS2UDQ FCML_TEXT("vcvtps2udq") +#define M_VCVTPS2UQQ FCML_TEXT("vcvtps2uqq") +#define M_VCVTQQ2PD FCML_TEXT("vcvtqq2pd") +#define M_VCVTQQ2PS FCML_TEXT("vcvtqq2ps") +#define M_VCVTQQ2PSX FCML_TEXT("vcvtqq2psx") +#define M_VCVTQQ2PSY FCML_TEXT("vcvtqq2psy") +#define M_VCVTSD2SI FCML_TEXT("vcvtsd2si") +#define M_VCVTSD2SS FCML_TEXT("vcvtsd2ss") +#define M_VCVTSD2USI FCML_TEXT("vcvtsd2usi") +#define M_VCVTSI2SDL FCML_TEXT("vcvtsi2sdl") +#define M_VCVTSI2SDQ FCML_TEXT("vcvtsi2sdq") +#define M_VCVTSI2SSL FCML_TEXT("vcvtsi2ssl") +#define M_VCVTSI2SSQ FCML_TEXT("vcvtsi2ssq") +#define M_VCVTSS2SD FCML_TEXT("vcvtss2sd") +#define M_VCVTSS2SI FCML_TEXT("vcvtss2si") +#define M_VCVTSS2USI FCML_TEXT("vcvtss2usi") +#define M_VCVTTPD2DQ FCML_TEXT("vcvttpd2dq") +#define M_VCVTTPD2DQX FCML_TEXT("vcvttpd2dqx") +#define M_VCVTTPD2DQY FCML_TEXT("vcvttpd2dqy") +#define M_VCVTTPD2QQ FCML_TEXT("vcvttpd2qq") +#define M_VCVTTPD2UDQ FCML_TEXT("vcvttpd2udq") +#define M_VCVTTPD2UDQX FCML_TEXT("vcvttpd2udqx") +#define M_VCVTTPD2UDQY FCML_TEXT("vcvttpd2udqy") +#define M_VCVTTPD2UQQ FCML_TEXT("vcvttpd2uqq") +#define M_VCVTTPS2DQ FCML_TEXT("vcvttps2dq") +#define M_VCVTTPS2QQ FCML_TEXT("vcvttps2qq") +#define M_VCVTTPS2UDQ FCML_TEXT("vcvttps2udq") +#define M_VCVTTPS2UQQ FCML_TEXT("vcvttps2uqq") +#define M_VCVTTSD2SI FCML_TEXT("vcvttsd2si") +#define M_VCVTTSD2USI FCML_TEXT("vcvttsd2usi") +#define M_VCVTTSS2SI FCML_TEXT("vcvttss2si") +#define M_VCVTTSS2USI FCML_TEXT("vcvttss2usi") +#define M_VCVTUDQ2PD FCML_TEXT("vcvtudq2pd") +#define M_VCVTUDQ2PS FCML_TEXT("vcvtudq2ps") +#define M_VCVTUQQ2PD FCML_TEXT("vcvtuqq2pd") +#define M_VCVTUQQ2PS FCML_TEXT("vcvtuqq2ps") +#define M_VCVTUQQ2PSX FCML_TEXT("vcvtuqq2psx") +#define M_VCVTUQQ2PSY FCML_TEXT("vcvtuqq2psy") +#define M_VCVTUSI2SD FCML_TEXT("vcvtusi2sd") +#define M_VCVTUSI2SS FCML_TEXT("vcvtusi2ss") +#define M_VDBPSADBW FCML_TEXT("vdbpsadbw") +#define M_VDIVPD FCML_TEXT("vdivpd") +#define M_VDIVPS FCML_TEXT("vdivps") +#define M_VDIVSD FCML_TEXT("vdivsd") +#define M_VDIVSS FCML_TEXT("vdivss") +#define M_VDPPD FCML_TEXT("vdppd") +#define M_VDPPS FCML_TEXT("vdpps") +#define M_VERR FCML_TEXT("verr") +#define M_VERW FCML_TEXT("verw") +#define M_VEXP2PD FCML_TEXT("vexp2pd") +#define M_VEXP2PS FCML_TEXT("vexp2ps") +#define M_VEXPANDPD FCML_TEXT("vexpandpd") +#define M_VEXPANDPS FCML_TEXT("vexpandps") +#define M_VEXTRACTF128 FCML_TEXT("vextractf128") +#define M_VEXTRACTF32X4 FCML_TEXT("vextractf32x4") +#define M_VEXTRACTF32X8 FCML_TEXT("vextractf32x8") +#define M_VEXTRACTF64X2 FCML_TEXT("vextractf64x2") +#define M_VEXTRACTF64X4 FCML_TEXT("vextractf64x4") +#define M_VEXTRACTI128 FCML_TEXT("vextracti128") +#define M_VEXTRACTI32X4 FCML_TEXT("vextracti32x4") +#define M_VEXTRACTI32X8 FCML_TEXT("vextracti32x8") +#define M_VEXTRACTI64X2 FCML_TEXT("vextracti64x2") +#define M_VEXTRACTI64X4 FCML_TEXT("vextracti64x4") +#define M_VEXTRACTPS FCML_TEXT("vextractps") +#define M_VFIXUPIMMPD FCML_TEXT("vfixupimmpd") +#define M_VFIXUPIMMPS FCML_TEXT("vfixupimmps") +#define M_VFIXUPIMMSD FCML_TEXT("vfixupimmsd") +#define M_VFIXUPIMMSS FCML_TEXT("vfixupimmss") +#define M_VFMADD132PD FCML_TEXT("vfmadd132pd") +#define M_VFMADD132PS FCML_TEXT("vfmadd132ps") +#define M_VFMADD132SD FCML_TEXT("vfmadd132sd") +#define M_VFMADD132SS FCML_TEXT("vfmadd132ss") +#define M_VFMADD213PD FCML_TEXT("vfmadd213pd") +#define M_VFMADD213PS FCML_TEXT("vfmadd213ps") +#define M_VFMADD213SD FCML_TEXT("vfmadd213sd") +#define M_VFMADD213SS FCML_TEXT("vfmadd213ss") +#define M_VFMADD231PD FCML_TEXT("vfmadd231pd") +#define M_VFMADD231PS FCML_TEXT("vfmadd231ps") +#define M_VFMADD231SD FCML_TEXT("vfmadd231sd") +#define M_VFMADD231SS FCML_TEXT("vfmadd231ss") +#define M_VFMADDPD FCML_TEXT("vfmaddpd") +#define M_VFMADDPS FCML_TEXT("vfmaddps") +#define M_VFMADDSD FCML_TEXT("vfmaddsd") +#define M_VFMADDSS FCML_TEXT("vfmaddss") +#define M_VFMADDSUB132PD FCML_TEXT("vfmaddsub132pd") +#define M_VFMADDSUB132PS FCML_TEXT("vfmaddsub132ps") +#define M_VFMADDSUB213PD FCML_TEXT("vfmaddsub213pd") +#define M_VFMADDSUB213PS FCML_TEXT("vfmaddsub213ps") +#define M_VFMADDSUB231PD FCML_TEXT("vfmaddsub231pd") +#define M_VFMADDSUB231PS FCML_TEXT("vfmaddsub231ps") +#define M_VFMADDSUBPD FCML_TEXT("vfmaddsubpd") +#define M_VFMADDSUBPS FCML_TEXT("vfmaddsubps") +#define M_VFMSUB132PD FCML_TEXT("vfmsub132pd") +#define M_VFMSUB132PS FCML_TEXT("vfmsub132ps") +#define M_VFMSUB132SD FCML_TEXT("vfmsub132sd") +#define M_VFMSUB132SS FCML_TEXT("vfmsub132ss") +#define M_VFMSUB213PD FCML_TEXT("vfmsub213pd") +#define M_VFMSUB213PS FCML_TEXT("vfmsub213ps") +#define M_VFMSUB213SD FCML_TEXT("vfmsub213sd") +#define M_VFMSUB213SS FCML_TEXT("vfmsub213ss") +#define M_VFMSUB231PD FCML_TEXT("vfmsub231pd") +#define M_VFMSUB231PS FCML_TEXT("vfmsub231ps") +#define M_VFMSUB231SD FCML_TEXT("vfmsub231sd") +#define M_VFMSUB231SS FCML_TEXT("vfmsub231ss") +#define M_VFMSUBADD132PD FCML_TEXT("vfmsubadd132pd") +#define M_VFMSUBADD132PS FCML_TEXT("vfmsubadd132ps") +#define M_VFMSUBADD213PD FCML_TEXT("vfmsubadd213pd") +#define M_VFMSUBADD213PS FCML_TEXT("vfmsubadd213ps") +#define M_VFMSUBADD231PD FCML_TEXT("vfmsubadd231pd") +#define M_VFMSUBADD231PS FCML_TEXT("vfmsubadd231ps") +#define M_VFMSUBADDPD FCML_TEXT("vfmsubaddpd") +#define M_VFMSUBADDPS FCML_TEXT("vfmsubaddps") +#define M_VFMSUBPD FCML_TEXT("vfmsubpd") +#define M_VFMSUBPS FCML_TEXT("vfmsubps") +#define M_VFMSUBSD FCML_TEXT("vfmsubsd") +#define M_VFMSUBSS FCML_TEXT("vfmsubss") +#define M_VFNMADD132PD FCML_TEXT("vfnmadd132pd") +#define M_VFNMADD132PS FCML_TEXT("vfnmadd132ps") +#define M_VFNMADD132SD FCML_TEXT("vfnmadd132sd") +#define M_VFNMADD132SS FCML_TEXT("vfnmadd132ss") +#define M_VFNMADD213PD FCML_TEXT("vfnmadd213pd") +#define M_VFNMADD213PS FCML_TEXT("vfnmadd213ps") +#define M_VFNMADD213SD FCML_TEXT("vfnmadd213sd") +#define M_VFNMADD213SS FCML_TEXT("vfnmadd213ss") +#define M_VFNMADD231PD FCML_TEXT("vfnmadd231pd") +#define M_VFNMADD231PS FCML_TEXT("vfnmadd231ps") +#define M_VFNMADD231SD FCML_TEXT("vfnmadd231sd") +#define M_VFNMADD231SS FCML_TEXT("vfnmadd231ss") +#define M_VFNMADDPD FCML_TEXT("vfnmaddpd") +#define M_VFNMADDPS FCML_TEXT("vfnmaddps") +#define M_VFNMADDSD FCML_TEXT("vfnmaddsd") +#define M_VFNMADDSS FCML_TEXT("vfnmaddss") +#define M_VFNMSUB132PD FCML_TEXT("vfnmsub132pd") +#define M_VFNMSUB132PS FCML_TEXT("vfnmsub132ps") +#define M_VFNMSUB132SD FCML_TEXT("vfnmsub132sd") +#define M_VFNMSUB132SS FCML_TEXT("vfnmsub132ss") +#define M_VFNMSUB213PD FCML_TEXT("vfnmsub213pd") +#define M_VFNMSUB213PS FCML_TEXT("vfnmsub213ps") +#define M_VFNMSUB213SD FCML_TEXT("vfnmsub213sd") +#define M_VFNMSUB213SS FCML_TEXT("vfnmsub213ss") +#define M_VFNMSUB231PD FCML_TEXT("vfnmsub231pd") +#define M_VFNMSUB231PS FCML_TEXT("vfnmsub231ps") +#define M_VFNMSUB231SD FCML_TEXT("vfnmsub231sd") +#define M_VFNMSUB231SS FCML_TEXT("vfnmsub231ss") +#define M_VFNMSUBPD FCML_TEXT("vfnmsubpd") +#define M_VFNMSUBPS FCML_TEXT("vfnmsubps") +#define M_VFNMSUBSD FCML_TEXT("vfnmsubsd") +#define M_VFNMSUBSS FCML_TEXT("vfnmsubss") +#define M_VFPCLASSPD FCML_TEXT("vfpclasspd") +#define M_VFPCLASSPS FCML_TEXT("vfpclassps") +#define M_VFPCLASSSD FCML_TEXT("vfpclasssd") +#define M_VFPCLASSSS FCML_TEXT("vfpclassss") +#define M_VFRCZPD FCML_TEXT("vfrczpd") +#define M_VFRCZPS FCML_TEXT("vfrczps") +#define M_VFRCZSD FCML_TEXT("vfrczsd") +#define M_VFRCZSS FCML_TEXT("vfrczss") +#define M_VGATHERDPD FCML_TEXT("vgatherdpd") +#define M_VGATHERDPS FCML_TEXT("vgatherdps") +#define M_VGATHERPF0DPD FCML_TEXT("vgatherpf0dpd") +#define M_VGATHERPF0DPS FCML_TEXT("vgatherpf0dps") +#define M_VGATHERPF0QPD FCML_TEXT("vgatherpf0qpd") +#define M_VGATHERPF0QPS FCML_TEXT("vgatherpf0qps") +#define M_VGATHERPF1DPD FCML_TEXT("vgatherpf1dpd") +#define M_VGATHERPF1DPS FCML_TEXT("vgatherpf1dps") +#define M_VGATHERPF1QPD FCML_TEXT("vgatherpf1qpd") +#define M_VGATHERPF1QPS FCML_TEXT("vgatherpf1qps") +#define M_VGATHERQPD FCML_TEXT("vgatherqpd") +#define M_VGATHERQPS FCML_TEXT("vgatherqps") +#define M_VGETEXPPD FCML_TEXT("vgetexppd") +#define M_VGETEXPPS FCML_TEXT("vgetexpps") +#define M_VGETEXPSD FCML_TEXT("vgetexpsd") +#define M_VGETEXPSS FCML_TEXT("vgetexpss") +#define M_VGETMANTPD FCML_TEXT("vgetmantpd") +#define M_VGETMANTPS FCML_TEXT("vgetmantps") +#define M_VGETMANTSD FCML_TEXT("vgetmantsd") +#define M_VGETMANTSS FCML_TEXT("vgetmantss") +#define M_VHADDPD FCML_TEXT("vhaddpd") +#define M_VHADDPS FCML_TEXT("vhaddps") +#define M_VHSUBPD FCML_TEXT("vhsubpd") +#define M_VHSUBPS FCML_TEXT("vhsubps") +#define M_VINSERTF128 FCML_TEXT("vinsertf128") +#define M_VINSERTF32X4 FCML_TEXT("vinsertf32x4") +#define M_VINSERTF32X8 FCML_TEXT("vinsertf32x8") +#define M_VINSERTF64X2 FCML_TEXT("vinsertf64x2") +#define M_VINSERTF64X4 FCML_TEXT("vinsertf64x4") +#define M_VINSERTI128 FCML_TEXT("vinserti128") +#define M_VINSERTI32X4 FCML_TEXT("vinserti32x4") +#define M_VINSERTI32X8 FCML_TEXT("vinserti32x8") +#define M_VINSERTI64X2 FCML_TEXT("vinserti64x2") +#define M_VINSERTI64X4 FCML_TEXT("vinserti64x4") +#define M_VINSERTPS FCML_TEXT("vinsertps") +#define M_VLDDQU FCML_TEXT("vlddqu") +#define M_VLDMXCSR FCML_TEXT("vldmxcsr") +#define M_VMASKMOVDQU FCML_TEXT("vmaskmovdqu") +#define M_VMASKMOVPD FCML_TEXT("vmaskmovpd") +#define M_VMASKMOVPS FCML_TEXT("vmaskmovps") +#define M_VMAXPD FCML_TEXT("vmaxpd") +#define M_VMAXPS FCML_TEXT("vmaxps") +#define M_VMAXSD FCML_TEXT("vmaxsd") +#define M_VMAXSS FCML_TEXT("vmaxss") +#define M_VMCALL FCML_TEXT("vmcall") +#define M_VMCLEAR FCML_TEXT("vmclear") +#define M_VMFUNC FCML_TEXT("vmfunc") +#define M_VMINPD FCML_TEXT("vminpd") +#define M_VMINPS FCML_TEXT("vminps") +#define M_VMINSD FCML_TEXT("vminsd") +#define M_VMINSS FCML_TEXT("vminss") +#define M_VMLAUNCH FCML_TEXT("vmlaunch") +#define M_VMLOAD FCML_TEXT("vmload") +#define M_VMMCALL FCML_TEXT("vmmcall") +#define M_VMOVAPD FCML_TEXT("vmovapd") +#define M_VMOVAPS FCML_TEXT("vmovaps") +#define M_VMOVD FCML_TEXT("vmovd") +#define M_VMOVDDUP FCML_TEXT("vmovddup") +#define M_VMOVDQA FCML_TEXT("vmovdqa") +#define M_VMOVDQA32 FCML_TEXT("vmovdqa32") +#define M_VMOVDQA64 FCML_TEXT("vmovdqa64") +#define M_VMOVDQU FCML_TEXT("vmovdqu") +#define M_VMOVDQU16 FCML_TEXT("vmovdqu16") +#define M_VMOVDQU32 FCML_TEXT("vmovdqu32") +#define M_VMOVDQU64 FCML_TEXT("vmovdqu64") +#define M_VMOVDQU8 FCML_TEXT("vmovdqu8") +#define M_VMOVHLPS FCML_TEXT("vmovhlps") +#define M_VMOVHPD FCML_TEXT("vmovhpd") +#define M_VMOVHPS FCML_TEXT("vmovhps") +#define M_VMOVLHPS FCML_TEXT("vmovlhps") +#define M_VMOVLPD FCML_TEXT("vmovlpd") +#define M_VMOVLPS FCML_TEXT("vmovlps") +#define M_VMOVMSKPD FCML_TEXT("vmovmskpd") +#define M_VMOVMSKPS FCML_TEXT("vmovmskps") +#define M_VMOVNTDQ FCML_TEXT("vmovntdq") +#define M_VMOVNTDQA FCML_TEXT("vmovntdqa") +#define M_VMOVNTPD FCML_TEXT("vmovntpd") +#define M_VMOVNTPS FCML_TEXT("vmovntps") +#define M_VMOVQ FCML_TEXT("vmovq") +#define M_VMOVSD FCML_TEXT("vmovsd") +#define M_VMOVSHDUP FCML_TEXT("vmovshdup") +#define M_VMOVSLDUP FCML_TEXT("vmovsldup") +#define M_VMOVSS FCML_TEXT("vmovss") +#define M_VMOVUPD FCML_TEXT("vmovupd") +#define M_VMOVUPS FCML_TEXT("vmovups") +#define M_VMPSADBW FCML_TEXT("vmpsadbw") +#define M_VMPTRLD FCML_TEXT("vmptrld") +#define M_VMPTRST FCML_TEXT("vmptrst") +#define M_VMREAD FCML_TEXT("vmread") +#define M_VMRESUME FCML_TEXT("vmresume") +#define M_VMRUN FCML_TEXT("vmrun") +#define M_VMSAVE FCML_TEXT("vmsave") +#define M_VMULPD FCML_TEXT("vmulpd") +#define M_VMULPS FCML_TEXT("vmulps") +#define M_VMULSD FCML_TEXT("vmulsd") +#define M_VMULSS FCML_TEXT("vmulss") +#define M_VMWRITE FCML_TEXT("vmwrite") +#define M_VMXOFF FCML_TEXT("vmxoff") +#define M_VMXON FCML_TEXT("vmxon") +#define M_VORPD FCML_TEXT("vorpd") +#define M_VORPS FCML_TEXT("vorps") +#define M_VP4DPWSSD FCML_TEXT("vp4dpwssd") +#define M_VP4DPWSSDS FCML_TEXT("vp4dpwssds") +#define M_VPABSB FCML_TEXT("vpabsb") +#define M_VPABSD FCML_TEXT("vpabsd") +#define M_VPABSQ FCML_TEXT("vpabsq") +#define M_VPABSW FCML_TEXT("vpabsw") +#define M_VPACKSSDW FCML_TEXT("vpackssdw") +#define M_VPACKSSWB FCML_TEXT("vpacksswb") +#define M_VPACKUSDW FCML_TEXT("vpackusdw") +#define M_VPACKUSWB FCML_TEXT("vpackuswb") +#define M_VPADDB FCML_TEXT("vpaddb") +#define M_VPADDD FCML_TEXT("vpaddd") +#define M_VPADDQ FCML_TEXT("vpaddq") +#define M_VPADDSB FCML_TEXT("vpaddsb") +#define M_VPADDSW FCML_TEXT("vpaddsw") +#define M_VPADDUSB FCML_TEXT("vpaddusb") +#define M_VPADDUSW FCML_TEXT("vpaddusw") +#define M_VPADDW FCML_TEXT("vpaddw") +#define M_VPALIGNR FCML_TEXT("vpalignr") +#define M_VPAND FCML_TEXT("vpand") +#define M_VPANDD FCML_TEXT("vpandd") +#define M_VPANDN FCML_TEXT("vpandn") +#define M_VPANDND FCML_TEXT("vpandnd") +#define M_VPANDNQ FCML_TEXT("vpandnq") +#define M_VPANDQ FCML_TEXT("vpandq") +#define M_VPAVGB FCML_TEXT("vpavgb") +#define M_VPAVGW FCML_TEXT("vpavgw") +#define M_VPBLENDD FCML_TEXT("vpblendd") +#define M_VPBLENDMB FCML_TEXT("vpblendmb") +#define M_VPBLENDMD FCML_TEXT("vpblendmd") +#define M_VPBLENDMQ FCML_TEXT("vpblendmq") +#define M_VPBLENDMW FCML_TEXT("vpblendmw") +#define M_VPBLENDVB FCML_TEXT("vpblendvb") +#define M_VPBLENDW FCML_TEXT("vpblendw") +#define M_VPBROADCASTB FCML_TEXT("vpbroadcastb") +#define M_VPBROADCASTD FCML_TEXT("vpbroadcastd") +#define M_VPBROADCASTMB2Q FCML_TEXT("vpbroadcastmb2q") +#define M_VPBROADCASTMW2D FCML_TEXT("vpbroadcastmw2d") +#define M_VPBROADCASTQ FCML_TEXT("vpbroadcastq") +#define M_VPBROADCASTW FCML_TEXT("vpbroadcastw") +#define M_VPCLMULQDQ FCML_TEXT("vpclmulqdq") +#define M_VPCMOV FCML_TEXT("vpcmov") +#define M_VPCMPB FCML_TEXT("vpcmpb") +#define M_VPCMPD FCML_TEXT("vpcmpd") +#define M_VPCMPEQB FCML_TEXT("vpcmpeqb") +#define M_VPCMPEQD FCML_TEXT("vpcmpeqd") +#define M_VPCMPEQQ FCML_TEXT("vpcmpeqq") +#define M_VPCMPEQW FCML_TEXT("vpcmpeqw") +#define M_VPCMPESTRI FCML_TEXT("vpcmpestri") +#define M_VPCMPESTRM FCML_TEXT("vpcmpestrm") +#define M_VPCMPGTB FCML_TEXT("vpcmpgtb") +#define M_VPCMPGTD FCML_TEXT("vpcmpgtd") +#define M_VPCMPGTQ FCML_TEXT("vpcmpgtq") +#define M_VPCMPGTW FCML_TEXT("vpcmpgtw") +#define M_VPCMPISTRI FCML_TEXT("vpcmpistri") +#define M_VPCMPISTRM FCML_TEXT("vpcmpistrm") +#define M_VPCMPQ FCML_TEXT("vpcmpq") +#define M_VPCMPUB FCML_TEXT("vpcmpub") +#define M_VPCMPUD FCML_TEXT("vpcmpud") +#define M_VPCMPUQ FCML_TEXT("vpcmpuq") +#define M_VPCMPUW FCML_TEXT("vpcmpuw") +#define M_VPCMPW FCML_TEXT("vpcmpw") +#define M_VPCOMB FCML_TEXT("vpcomb") +#define M_VPCOMD FCML_TEXT("vpcomd") +#define M_VPCOMEQB FCML_TEXT("vpcomeqb") +#define M_VPCOMEQD FCML_TEXT("vpcomeqd") +#define M_VPCOMEQQ FCML_TEXT("vpcomeqq") +#define M_VPCOMEQUB FCML_TEXT("vpcomequb") +#define M_VPCOMEQUD FCML_TEXT("vpcomequd") +#define M_VPCOMEQUQ FCML_TEXT("vpcomequq") +#define M_VPCOMEQUW FCML_TEXT("vpcomequw") +#define M_VPCOMEQW FCML_TEXT("vpcomeqw") +#define M_VPCOMFALSEB FCML_TEXT("vpcomfalseb") +#define M_VPCOMFALSED FCML_TEXT("vpcomfalsed") +#define M_VPCOMFALSEQ FCML_TEXT("vpcomfalseq") +#define M_VPCOMFALSEUB FCML_TEXT("vpcomfalseub") +#define M_VPCOMFALSEUD FCML_TEXT("vpcomfalseud") +#define M_VPCOMFALSEUQ FCML_TEXT("vpcomfalseuq") +#define M_VPCOMFALSEUW FCML_TEXT("vpcomfalseuw") +#define M_VPCOMFALSEW FCML_TEXT("vpcomfalsew") +#define M_VPCOMGEB FCML_TEXT("vpcomgeb") +#define M_VPCOMGED FCML_TEXT("vpcomged") +#define M_VPCOMGEQ FCML_TEXT("vpcomgeq") +#define M_VPCOMGEUB FCML_TEXT("vpcomgeub") +#define M_VPCOMGEUD FCML_TEXT("vpcomgeud") +#define M_VPCOMGEUQ FCML_TEXT("vpcomgeuq") +#define M_VPCOMGEUW FCML_TEXT("vpcomgeuw") +#define M_VPCOMGEW FCML_TEXT("vpcomgew") +#define M_VPCOMGTB FCML_TEXT("vpcomgtb") +#define M_VPCOMGTD FCML_TEXT("vpcomgtd") +#define M_VPCOMGTQ FCML_TEXT("vpcomgtq") +#define M_VPCOMGTUB FCML_TEXT("vpcomgtub") +#define M_VPCOMGTUD FCML_TEXT("vpcomgtud") +#define M_VPCOMGTUQ FCML_TEXT("vpcomgtuq") +#define M_VPCOMGTUW FCML_TEXT("vpcomgtuw") +#define M_VPCOMGTW FCML_TEXT("vpcomgtw") +#define M_VPCOMLEB FCML_TEXT("vpcomleb") +#define M_VPCOMLED FCML_TEXT("vpcomled") +#define M_VPCOMLEQ FCML_TEXT("vpcomleq") +#define M_VPCOMLEUB FCML_TEXT("vpcomleub") +#define M_VPCOMLEUD FCML_TEXT("vpcomleud") +#define M_VPCOMLEUQ FCML_TEXT("vpcomleuq") +#define M_VPCOMLEUW FCML_TEXT("vpcomleuw") +#define M_VPCOMLEW FCML_TEXT("vpcomlew") +#define M_VPCOMLTB FCML_TEXT("vpcomltb") +#define M_VPCOMLTD FCML_TEXT("vpcomltd") +#define M_VPCOMLTQ FCML_TEXT("vpcomltq") +#define M_VPCOMLTUB FCML_TEXT("vpcomltub") +#define M_VPCOMLTUD FCML_TEXT("vpcomltud") +#define M_VPCOMLTUQ FCML_TEXT("vpcomltuq") +#define M_VPCOMLTUW FCML_TEXT("vpcomltuw") +#define M_VPCOMLTW FCML_TEXT("vpcomltw") +#define M_VPCOMNEQB FCML_TEXT("vpcomneqb") +#define M_VPCOMNEQD FCML_TEXT("vpcomneqd") +#define M_VPCOMNEQQ FCML_TEXT("vpcomneqq") +#define M_VPCOMNEQUB FCML_TEXT("vpcomnequb") +#define M_VPCOMNEQUD FCML_TEXT("vpcomnequd") +#define M_VPCOMNEQUQ FCML_TEXT("vpcomnequq") +#define M_VPCOMNEQUW FCML_TEXT("vpcomnequw") +#define M_VPCOMNEQW FCML_TEXT("vpcomneqw") +#define M_VPCOMPRESSD FCML_TEXT("vpcompressd") +#define M_VPCOMPRESSQ FCML_TEXT("vpcompressq") +#define M_VPCOMQ FCML_TEXT("vpcomq") +#define M_VPCOMTRUEB FCML_TEXT("vpcomtrueb") +#define M_VPCOMTRUED FCML_TEXT("vpcomtrued") +#define M_VPCOMTRUEQ FCML_TEXT("vpcomtrueq") +#define M_VPCOMTRUEUB FCML_TEXT("vpcomtrueub") +#define M_VPCOMTRUEUD FCML_TEXT("vpcomtrueud") +#define M_VPCOMTRUEUQ FCML_TEXT("vpcomtrueuq") +#define M_VPCOMTRUEUW FCML_TEXT("vpcomtrueuw") +#define M_VPCOMTRUEW FCML_TEXT("vpcomtruew") +#define M_VPCOMUB FCML_TEXT("vpcomub") +#define M_VPCOMUD FCML_TEXT("vpcomud") +#define M_VPCOMUQ FCML_TEXT("vpcomuq") +#define M_VPCOMUW FCML_TEXT("vpcomuw") +#define M_VPCOMW FCML_TEXT("vpcomw") +#define M_VPERM2F128 FCML_TEXT("vperm2f128") +#define M_VPERM2I128 FCML_TEXT("vperm2i128") +#define M_VPERMB FCML_TEXT("vpermb") +#define M_VPERMD FCML_TEXT("vpermd") +#define M_VPERMI2B FCML_TEXT("vpermi2b") +#define M_VPERMI2D FCML_TEXT("vpermi2d") +#define M_VPERMI2PD FCML_TEXT("vpermi2pd") +#define M_VPERMI2PS FCML_TEXT("vpermi2ps") +#define M_VPERMI2Q FCML_TEXT("vpermi2q") +#define M_VPERMI2W FCML_TEXT("vpermi2w") +#define M_VPERMIL2PD FCML_TEXT("vpermil2pd") +#define M_VPERMIL2PS FCML_TEXT("vpermil2ps") +#define M_VPERMILPD FCML_TEXT("vpermilpd") +#define M_VPERMILPS FCML_TEXT("vpermilps") +#define M_VPERMPD FCML_TEXT("vpermpd") +#define M_VPERMPS FCML_TEXT("vpermps") +#define M_VPERMQ FCML_TEXT("vpermq") +#define M_VPERMT2B FCML_TEXT("vpermt2b") +#define M_VPERMT2D FCML_TEXT("vpermt2d") +#define M_VPERMT2PD FCML_TEXT("vpermt2pd") +#define M_VPERMT2PS FCML_TEXT("vpermt2ps") +#define M_VPERMT2Q FCML_TEXT("vpermt2q") +#define M_VPERMT2W FCML_TEXT("vpermt2w") +#define M_VPERMW FCML_TEXT("vpermw") +#define M_VPEXPANDD FCML_TEXT("vpexpandd") +#define M_VPEXPANDQ FCML_TEXT("vpexpandq") +#define M_VPEXTRB FCML_TEXT("vpextrb") +#define M_VPEXTRD FCML_TEXT("vpextrd") +#define M_VPEXTRQ FCML_TEXT("vpextrq") +#define M_VPEXTRW FCML_TEXT("vpextrw") +#define M_VPGATHERDD FCML_TEXT("vpgatherdd") +#define M_VPGATHERDQ FCML_TEXT("vpgatherdq") +#define M_VPGATHERQD FCML_TEXT("vpgatherqd") +#define M_VPGATHERQQ FCML_TEXT("vpgatherqq") +#define M_VPHADDBD FCML_TEXT("vphaddbd") +#define M_VPHADDBQ FCML_TEXT("vphaddbq") +#define M_VPHADDBW FCML_TEXT("vphaddbw") +#define M_VPHADDD FCML_TEXT("vphaddd") +#define M_VPHADDDQ FCML_TEXT("vphadddq") +#define M_VPHADDSW FCML_TEXT("vphaddsw") +#define M_VPHADDUBD FCML_TEXT("vphaddubd") +#define M_VPHADDUBQ FCML_TEXT("vphaddubq") +#define M_VPHADDUBW FCML_TEXT("vphaddubw") +#define M_VPHADDUDQ FCML_TEXT("vphaddudq") +#define M_VPHADDUWD FCML_TEXT("vphadduwd") +#define M_VPHADDUWQ FCML_TEXT("vphadduwq") +#define M_VPHADDW FCML_TEXT("vphaddw") +#define M_VPHADDWD FCML_TEXT("vphaddwd") +#define M_VPHADDWQ FCML_TEXT("vphaddwq") +#define M_VPHMINPOSUW FCML_TEXT("vphminposuw") +#define M_VPHSUBBW FCML_TEXT("vphsubbw") +#define M_VPHSUBD FCML_TEXT("vphsubd") +#define M_VPHSUBDQ FCML_TEXT("vphsubdq") +#define M_VPHSUBSW FCML_TEXT("vphsubsw") +#define M_VPHSUBW FCML_TEXT("vphsubw") +#define M_VPHSUBWD FCML_TEXT("vphsubwd") +#define M_VPINSRB FCML_TEXT("vpinsrb") +#define M_VPINSRD FCML_TEXT("vpinsrd") +#define M_VPINSRQ FCML_TEXT("vpinsrq") +#define M_VPINSRW FCML_TEXT("vpinsrw") +#define M_VPLZCNTD FCML_TEXT("vplzcntd") +#define M_VPLZCNTQ FCML_TEXT("vplzcntq") +#define M_VPMACSDD FCML_TEXT("vpmacsdd") +#define M_VPMACSDQH FCML_TEXT("vpmacsdqh") +#define M_VPMACSDQL FCML_TEXT("vpmacsdql") +#define M_VPMACSSDD FCML_TEXT("vpmacssdd") +#define M_VPMACSSDQH FCML_TEXT("vpmacssdqh") +#define M_VPMACSSDQL FCML_TEXT("vpmacssdql") +#define M_VPMACSSWD FCML_TEXT("vpmacsswd") +#define M_VPMACSSWW FCML_TEXT("vpmacssww") +#define M_VPMACSWD FCML_TEXT("vpmacswd") +#define M_VPMACSWW FCML_TEXT("vpmacsww") +#define M_VPMADCSSWD FCML_TEXT("vpmadcsswd") +#define M_VPMADCSWD FCML_TEXT("vpmadcswd") +#define M_VPMADD52HUQ FCML_TEXT("vpmadd52huq") +#define M_VPMADD52LUQ FCML_TEXT("vpmadd52luq") +#define M_VPMADDUBSW FCML_TEXT("vpmaddubsw") +#define M_VPMADDWD FCML_TEXT("vpmaddwd") +#define M_VPMASKMOV FCML_TEXT("vpmaskmov") +#define M_VPMASKMOVD FCML_TEXT("vpmaskmovd") +#define M_VPMASKMOVQ FCML_TEXT("vpmaskmovq") +#define M_VPMAXSB FCML_TEXT("vpmaxsb") +#define M_VPMAXSD FCML_TEXT("vpmaxsd") +#define M_VPMAXSQ FCML_TEXT("vpmaxsq") +#define M_VPMAXSW FCML_TEXT("vpmaxsw") +#define M_VPMAXUB FCML_TEXT("vpmaxub") +#define M_VPMAXUD FCML_TEXT("vpmaxud") +#define M_VPMAXUQ FCML_TEXT("vpmaxuq") +#define M_VPMAXUW FCML_TEXT("vpmaxuw") +#define M_VPMINSB FCML_TEXT("vpminsb") +#define M_VPMINSD FCML_TEXT("vpminsd") +#define M_VPMINSQ FCML_TEXT("vpminsq") +#define M_VPMINSW FCML_TEXT("vpminsw") +#define M_VPMINUB FCML_TEXT("vpminub") +#define M_VPMINUD FCML_TEXT("vpminud") +#define M_VPMINUQ FCML_TEXT("vpminuq") +#define M_VPMINUW FCML_TEXT("vpminuw") +#define M_VPMOVB2M FCML_TEXT("vpmovb2m") +#define M_VPMOVD2M FCML_TEXT("vpmovd2m") +#define M_VPMOVDB FCML_TEXT("vpmovdb") +#define M_VPMOVDW FCML_TEXT("vpmovdw") +#define M_VPMOVM2B FCML_TEXT("vpmovm2b") +#define M_VPMOVM2D FCML_TEXT("vpmovm2d") +#define M_VPMOVM2Q FCML_TEXT("vpmovm2q") +#define M_VPMOVM2W FCML_TEXT("vpmovm2w") +#define M_VPMOVMSKB FCML_TEXT("vpmovmskb") +#define M_VPMOVQ2M FCML_TEXT("vpmovq2m") +#define M_VPMOVQB FCML_TEXT("vpmovqb") +#define M_VPMOVQD FCML_TEXT("vpmovqd") +#define M_VPMOVQW FCML_TEXT("vpmovqw") +#define M_VPMOVSDB FCML_TEXT("vpmovsdb") +#define M_VPMOVSDW FCML_TEXT("vpmovsdw") +#define M_VPMOVSQB FCML_TEXT("vpmovsqb") +#define M_VPMOVSQD FCML_TEXT("vpmovsqd") +#define M_VPMOVSQW FCML_TEXT("vpmovsqw") +#define M_VPMOVSWB FCML_TEXT("vpmovswb") +#define M_VPMOVSXBD FCML_TEXT("vpmovsxbd") +#define M_VPMOVSXBQ FCML_TEXT("vpmovsxbq") +#define M_VPMOVSXBW FCML_TEXT("vpmovsxbw") +#define M_VPMOVSXDQ FCML_TEXT("vpmovsxdq") +#define M_VPMOVSXWD FCML_TEXT("vpmovsxwd") +#define M_VPMOVSXWQ FCML_TEXT("vpmovsxwq") +#define M_VPMOVUSDB FCML_TEXT("vpmovusdb") +#define M_VPMOVUSDW FCML_TEXT("vpmovusdw") +#define M_VPMOVUSQB FCML_TEXT("vpmovusqb") +#define M_VPMOVUSQD FCML_TEXT("vpmovusqd") +#define M_VPMOVUSQW FCML_TEXT("vpmovusqw") +#define M_VPMOVUSWB FCML_TEXT("vpmovuswb") +#define M_VPMOVW2M FCML_TEXT("vpmovw2m") +#define M_VPMOVWB FCML_TEXT("vpmovwb") +#define M_VPMOVZXBD FCML_TEXT("vpmovzxbd") +#define M_VPMOVZXBQ FCML_TEXT("vpmovzxbq") +#define M_VPMOVZXBW FCML_TEXT("vpmovzxbw") +#define M_VPMOVZXDQ FCML_TEXT("vpmovzxdq") +#define M_VPMOVZXWD FCML_TEXT("vpmovzxwd") +#define M_VPMOVZXWQ FCML_TEXT("vpmovzxwq") +#define M_VPMULDQ FCML_TEXT("vpmuldq") +#define M_VPMULHRSW FCML_TEXT("vpmulhrsw") +#define M_VPMULHUW FCML_TEXT("vpmulhuw") +#define M_VPMULHW FCML_TEXT("vpmulhw") +#define M_VPMULLD FCML_TEXT("vpmulld") +#define M_VPMULLQ FCML_TEXT("vpmullq") +#define M_VPMULLW FCML_TEXT("vpmullw") +#define M_VPMULTISHIFTQB FCML_TEXT("vpmultishiftqb") +#define M_VPMULUDQ FCML_TEXT("vpmuludq") +#define M_VPOR FCML_TEXT("vpor") +#define M_VPORD FCML_TEXT("vpord") +#define M_VPORQ FCML_TEXT("vporq") +#define M_VPPERM FCML_TEXT("vpperm") +#define M_VPROLD FCML_TEXT("vprold") +#define M_VPROLQ FCML_TEXT("vprolq") +#define M_VPROLVD FCML_TEXT("vprolvd") +#define M_VPROLVQ FCML_TEXT("vprolvq") +#define M_VPRORD FCML_TEXT("vprord") +#define M_VPRORQ FCML_TEXT("vprorq") +#define M_VPRORVD FCML_TEXT("vprorvd") +#define M_VPRORVQ FCML_TEXT("vprorvq") +#define M_VPROTB FCML_TEXT("vprotb") +#define M_VPROTD FCML_TEXT("vprotd") +#define M_VPROTQ FCML_TEXT("vprotq") +#define M_VPROTW FCML_TEXT("vprotw") +#define M_VPSADBW FCML_TEXT("vpsadbw") +#define M_VPSCATTERDD FCML_TEXT("vpscatterdd") +#define M_VPSCATTERDQ FCML_TEXT("vpscatterdq") +#define M_VPSCATTERQD FCML_TEXT("vpscatterqd") +#define M_VPSCATTERQQ FCML_TEXT("vpscatterqq") +#define M_VPSHAB FCML_TEXT("vpshab") +#define M_VPSHAD FCML_TEXT("vpshad") +#define M_VPSHAQ FCML_TEXT("vpshaq") +#define M_VPSHAW FCML_TEXT("vpshaw") +#define M_VPSHLB FCML_TEXT("vpshlb") +#define M_VPSHLD FCML_TEXT("vpshld") +#define M_VPSHLQ FCML_TEXT("vpshlq") +#define M_VPSHLW FCML_TEXT("vpshlw") +#define M_VPSHUFB FCML_TEXT("vpshufb") +#define M_VPSHUFD FCML_TEXT("vpshufd") +#define M_VPSHUFHW FCML_TEXT("vpshufhw") +#define M_VPSHUFLW FCML_TEXT("vpshuflw") +#define M_VPSIGNB FCML_TEXT("vpsignb") +#define M_VPSIGND FCML_TEXT("vpsignd") +#define M_VPSIGNW FCML_TEXT("vpsignw") +#define M_VPSLLD FCML_TEXT("vpslld") +#define M_VPSLLDQ FCML_TEXT("vpslldq") +#define M_VPSLLQ FCML_TEXT("vpsllq") +#define M_VPSLLVD FCML_TEXT("vpsllvd") +#define M_VPSLLVQ FCML_TEXT("vpsllvq") +#define M_VPSLLVW FCML_TEXT("vpsllvw") +#define M_VPSLLW FCML_TEXT("vpsllw") +#define M_VPSRAD FCML_TEXT("vpsrad") +#define M_VPSRAQ FCML_TEXT("vpsraq") +#define M_VPSRAVD FCML_TEXT("vpsravd") +#define M_VPSRAVQ FCML_TEXT("vpsravq") +#define M_VPSRAVW FCML_TEXT("vpsravw") +#define M_VPSRAW FCML_TEXT("vpsraw") +#define M_VPSRLD FCML_TEXT("vpsrld") +#define M_VPSRLDQ FCML_TEXT("vpsrldq") +#define M_VPSRLQ FCML_TEXT("vpsrlq") +#define M_VPSRLVD FCML_TEXT("vpsrlvd") +#define M_VPSRLVQ FCML_TEXT("vpsrlvq") +#define M_VPSRLVW FCML_TEXT("vpsrlvw") +#define M_VPSRLW FCML_TEXT("vpsrlw") +#define M_VPSUBB FCML_TEXT("vpsubb") +#define M_VPSUBD FCML_TEXT("vpsubd") +#define M_VPSUBQ FCML_TEXT("vpsubq") +#define M_VPSUBSB FCML_TEXT("vpsubsb") +#define M_VPSUBSW FCML_TEXT("vpsubsw") +#define M_VPSUBUSB FCML_TEXT("vpsubusb") +#define M_VPSUBUSW FCML_TEXT("vpsubusw") +#define M_VPSUBW FCML_TEXT("vpsubw") +#define M_VPTERNLOGD FCML_TEXT("vpternlogd") +#define M_VPTERNLOGQ FCML_TEXT("vpternlogq") +#define M_VPTEST FCML_TEXT("vptest") +#define M_VPTESTMB FCML_TEXT("vptestmb") +#define M_VPTESTMD FCML_TEXT("vptestmd") +#define M_VPTESTMQ FCML_TEXT("vptestmq") +#define M_VPTESTMW FCML_TEXT("vptestmw") +#define M_VPTESTNMB FCML_TEXT("vptestnmb") +#define M_VPTESTNMD FCML_TEXT("vptestnmd") +#define M_VPTESTNMQ FCML_TEXT("vptestnmq") +#define M_VPTESTNMW FCML_TEXT("vptestnmw") +#define M_VPUNPCKHBW FCML_TEXT("vpunpckhbw") +#define M_VPUNPCKHDQ FCML_TEXT("vpunpckhdq") +#define M_VPUNPCKHQDQ FCML_TEXT("vpunpckhqdq") +#define M_VPUNPCKHWD FCML_TEXT("vpunpckhwd") +#define M_VPUNPCKLBW FCML_TEXT("vpunpcklbw") +#define M_VPUNPCKLDQ FCML_TEXT("vpunpckldq") +#define M_VPUNPCKLQDQ FCML_TEXT("vpunpcklqdq") +#define M_VPUNPCKLWD FCML_TEXT("vpunpcklwd") +#define M_VPXOR FCML_TEXT("vpxor") +#define M_VPXORD FCML_TEXT("vpxord") +#define M_VPXORQ FCML_TEXT("vpxorq") +#define M_VRANGEPD FCML_TEXT("vrangepd") +#define M_VRANGEPS FCML_TEXT("vrangeps") +#define M_VRANGESD FCML_TEXT("vrangesd") +#define M_VRANGESS FCML_TEXT("vrangess") +#define M_VRCP14PD FCML_TEXT("vrcp14pd") +#define M_VRCP14PS FCML_TEXT("vrcp14ps") +#define M_VRCP14SD FCML_TEXT("vrcp14sd") +#define M_VRCP14SS FCML_TEXT("vrcp14ss") +#define M_VRCP28PD FCML_TEXT("vrcp28pd") +#define M_VRCP28PS FCML_TEXT("vrcp28ps") +#define M_VRCP28SD FCML_TEXT("vrcp28sd") +#define M_VRCP28SS FCML_TEXT("vrcp28ss") +#define M_VRCPPS FCML_TEXT("vrcpps") +#define M_VRCPSS FCML_TEXT("vrcpss") +#define M_VREDUCEPD FCML_TEXT("vreducepd") +#define M_VREDUCEPS FCML_TEXT("vreduceps") +#define M_VREDUCESD FCML_TEXT("vreducesd") +#define M_VREDUCESS FCML_TEXT("vreducess") +#define M_VRNDSCALEPD FCML_TEXT("vrndscalepd") +#define M_VRNDSCALEPS FCML_TEXT("vrndscaleps") +#define M_VRNDSCALESD FCML_TEXT("vrndscalesd") +#define M_VRNDSCALESS FCML_TEXT("vrndscaless") +#define M_VROUNDPD FCML_TEXT("vroundpd") +#define M_VROUNDPS FCML_TEXT("vroundps") +#define M_VROUNDSD FCML_TEXT("vroundsd") +#define M_VROUNDSS FCML_TEXT("vroundss") +#define M_VRSQRT14PD FCML_TEXT("vrsqrt14pd") +#define M_VRSQRT14PS FCML_TEXT("vrsqrt14ps") +#define M_VRSQRT14SD FCML_TEXT("vrsqrt14sd") +#define M_VRSQRT14SS FCML_TEXT("vrsqrt14ss") +#define M_VRSQRT28PD FCML_TEXT("vrsqrt28pd") +#define M_VRSQRT28PS FCML_TEXT("vrsqrt28ps") +#define M_VRSQRT28SD FCML_TEXT("vrsqrt28sd") +#define M_VRSQRT28SS FCML_TEXT("vrsqrt28ss") +#define M_VRSQRTPS FCML_TEXT("vrsqrtps") +#define M_VRSQRTSS FCML_TEXT("vrsqrtss") +#define M_VSCALEFPD FCML_TEXT("vscalefpd") +#define M_VSCALEFPS FCML_TEXT("vscalefps") +#define M_VSCALEFSD FCML_TEXT("vscalefsd") +#define M_VSCALEFSS FCML_TEXT("vscalefss") +#define M_VSCATTERDPD FCML_TEXT("vscatterdpd") +#define M_VSCATTERDPS FCML_TEXT("vscatterdps") +#define M_VSCATTERPF0DPD FCML_TEXT("vscatterpf0dpd") +#define M_VSCATTERPF0DPS FCML_TEXT("vscatterpf0dps") +#define M_VSCATTERPF0QPD FCML_TEXT("vscatterpf0qpd") +#define M_VSCATTERPF0QPS FCML_TEXT("vscatterpf0qps") +#define M_VSCATTERPF1DPD FCML_TEXT("vscatterpf1dpd") +#define M_VSCATTERPF1DPS FCML_TEXT("vscatterpf1dps") +#define M_VSCATTERPF1QPD FCML_TEXT("vscatterpf1qpd") +#define M_VSCATTERPF1QPS FCML_TEXT("vscatterpf1qps") +#define M_VSCATTERQPD FCML_TEXT("vscatterqpd") +#define M_VSCATTERQPS FCML_TEXT("vscatterqps") +#define M_VSHUFF32X4 FCML_TEXT("vshuff32x4") +#define M_VSHUFF64X2 FCML_TEXT("vshuff64x2") +#define M_VSHUFI32X4 FCML_TEXT("vshufi32x4") +#define M_VSHUFI64X2 FCML_TEXT("vshufi64x2") +#define M_VSHUFPD FCML_TEXT("vshufpd") +#define M_VSHUFPS FCML_TEXT("vshufps") +#define M_VSQRTPD FCML_TEXT("vsqrtpd") +#define M_VSQRTPS FCML_TEXT("vsqrtps") +#define M_VSQRTSD FCML_TEXT("vsqrtsd") +#define M_VSQRTSS FCML_TEXT("vsqrtss") +#define M_VSTMXCSR FCML_TEXT("vstmxcsr") +#define M_VSUBPD FCML_TEXT("vsubpd") +#define M_VSUBPS FCML_TEXT("vsubps") +#define M_VSUBSD FCML_TEXT("vsubsd") +#define M_VSUBSS FCML_TEXT("vsubss") +#define M_VTESTPD FCML_TEXT("vtestpd") +#define M_VTESTPS FCML_TEXT("vtestps") +#define M_VUCOMISD FCML_TEXT("vucomisd") +#define M_VUCOMISS FCML_TEXT("vucomiss") +#define M_VUNPCKHPD FCML_TEXT("vunpckhpd") +#define M_VUNPCKHPS FCML_TEXT("vunpckhps") +#define M_VUNPCKLPD FCML_TEXT("vunpcklpd") +#define M_VUNPCKLPS FCML_TEXT("vunpcklps") +#define M_VXORPD FCML_TEXT("vxorpd") +#define M_VXORPS FCML_TEXT("vxorps") +#define M_VZEROALL FCML_TEXT("vzeroall") +#define M_VZEROUPPER FCML_TEXT("vzeroupper") +#define M_WAIT FCML_TEXT("wait") +#define M_WBINVD FCML_TEXT("wbinvd") +#define M_WRFSBASE FCML_TEXT("wrfsbase") +#define M_WRGSBASE FCML_TEXT("wrgsbase") +#define M_WRMSR FCML_TEXT("wrmsr") +#define M_XABORT FCML_TEXT("xabort") +#define M_XADD FCML_TEXT("xadd") +#define M_XBEGIN FCML_TEXT("xbegin") +#define M_XCHG FCML_TEXT("xchg") +#define M_XEND FCML_TEXT("xend") +#define M_XGETBV FCML_TEXT("xgetbv") +#define M_XLAT FCML_TEXT("xlat") +#define M_XLATB FCML_TEXT("xlatb") +#define M_XOR FCML_TEXT("xor") +#define M_XORB FCML_TEXT("xorb") +#define M_XORL FCML_TEXT("xorl") +#define M_XORPD FCML_TEXT("xorpd") +#define M_XORPS FCML_TEXT("xorps") +#define M_XORQ FCML_TEXT("xorq") +#define M_XORW FCML_TEXT("xorw") +#define M_XRSTOR FCML_TEXT("xrstor") +#define M_XRSTOR64 FCML_TEXT("xrstor64") +#define M_XSAVE FCML_TEXT("xsave") +#define M_XSAVE64 FCML_TEXT("xsave64") +#define M_XSAVEOPT FCML_TEXT("xsaveopt") +#define M_XSAVEOPT64 FCML_TEXT("xsaveopt64") +#define M_XSETBV FCML_TEXT("xsetbv") +#define M_XTEST FCML_TEXT("xtest") + +#endif /* FCML_GAS_MNEMONICS_H_ */ diff --git a/dependencies/fcml/include/fcml_gas_mnemonics.hpp b/dependencies/fcml/include/fcml_gas_mnemonics.hpp new file mode 100644 index 0000000..4c11198 --- /dev/null +++ b/dependencies/fcml/include/fcml_gas_mnemonics.hpp @@ -0,0 +1,1938 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_gas_mnemonics.hpp + * Declarations of AT&T mnemonics for C++. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_GAS_MNEMONICS_HPP_ +#define FCML_GAS_MNEMONICS_HPP_ + +#include "fcml_types.h" +#include + +namespace fcml { +namespace gas { + +extern const fcml_cstring M_AAA; +extern const fcml_cstring M_AAD; +extern const fcml_cstring M_AAM; +extern const fcml_cstring M_AAS; +extern const fcml_cstring M_ADC; +extern const fcml_cstring M_ADCB; +extern const fcml_cstring M_ADCL; +extern const fcml_cstring M_ADCQ; +extern const fcml_cstring M_ADCW; +extern const fcml_cstring M_ADCX; +extern const fcml_cstring M_ADD; +extern const fcml_cstring M_ADDB; +extern const fcml_cstring M_ADDL; +extern const fcml_cstring M_ADDPD; +extern const fcml_cstring M_ADDPS; +extern const fcml_cstring M_ADDQ; +extern const fcml_cstring M_ADDSD; +extern const fcml_cstring M_ADDSS; +extern const fcml_cstring M_ADDSUBPD; +extern const fcml_cstring M_ADDSUBPS; +extern const fcml_cstring M_ADDW; +extern const fcml_cstring M_ADOX; +extern const fcml_cstring M_AESDEC; +extern const fcml_cstring M_AESDECLAST; +extern const fcml_cstring M_AESENC; +extern const fcml_cstring M_AESENCLAST; +extern const fcml_cstring M_AESIMC; +extern const fcml_cstring M_AESKEYGENASSIST; +extern const fcml_cstring M_AND; +extern const fcml_cstring M_ANDB; +extern const fcml_cstring M_ANDL; +extern const fcml_cstring M_ANDN; +extern const fcml_cstring M_ANDNPD; +extern const fcml_cstring M_ANDNPS; +extern const fcml_cstring M_ANDPD; +extern const fcml_cstring M_ANDPS; +extern const fcml_cstring M_ANDQ; +extern const fcml_cstring M_ANDW; +extern const fcml_cstring M_ARPL; +extern const fcml_cstring M_BEXR; +extern const fcml_cstring M_BEXTR; +extern const fcml_cstring M_BLCFILL; +extern const fcml_cstring M_BLCI; +extern const fcml_cstring M_BLCIC; +extern const fcml_cstring M_BLCMSK; +extern const fcml_cstring M_BLCS; +extern const fcml_cstring M_BLENDPD; +extern const fcml_cstring M_BLENDPS; +extern const fcml_cstring M_BLENDVPD; +extern const fcml_cstring M_BLENDVPS; +extern const fcml_cstring M_BLSFILL; +extern const fcml_cstring M_BLSI; +extern const fcml_cstring M_BLSIC; +extern const fcml_cstring M_BLSMSK; +extern const fcml_cstring M_BLSR; +extern const fcml_cstring M_BOUND; +extern const fcml_cstring M_BSF; +extern const fcml_cstring M_BSR; +extern const fcml_cstring M_BSWAP; +extern const fcml_cstring M_BT; +extern const fcml_cstring M_BTC; +extern const fcml_cstring M_BTCL; +extern const fcml_cstring M_BTCQ; +extern const fcml_cstring M_BTCW; +extern const fcml_cstring M_BTL; +extern const fcml_cstring M_BTQ; +extern const fcml_cstring M_BTR; +extern const fcml_cstring M_BTRL; +extern const fcml_cstring M_BTRQ; +extern const fcml_cstring M_BTRW; +extern const fcml_cstring M_BTS; +extern const fcml_cstring M_BTSL; +extern const fcml_cstring M_BTSQ; +extern const fcml_cstring M_BTSW; +extern const fcml_cstring M_BTW; +extern const fcml_cstring M_BZHI; +extern const fcml_cstring M_CALL; +extern const fcml_cstring M_CALLQ; +extern const fcml_cstring M_CALLW; +extern const fcml_cstring M_CBTW; +extern const fcml_cstring M_CLAC; +extern const fcml_cstring M_CLC; +extern const fcml_cstring M_CLD; +extern const fcml_cstring M_CLFLUSH; +extern const fcml_cstring M_CLGI; +extern const fcml_cstring M_CLI; +extern const fcml_cstring M_CLTD; +extern const fcml_cstring M_CLTQ; +extern const fcml_cstring M_CLTS; +extern const fcml_cstring M_CMC; +extern const fcml_cstring M_CMOVA; +extern const fcml_cstring M_CMOVAE; +extern const fcml_cstring M_CMOVB; +extern const fcml_cstring M_CMOVBE; +extern const fcml_cstring M_CMOVC; +extern const fcml_cstring M_CMOVENE; +extern const fcml_cstring M_CMOVG; +extern const fcml_cstring M_CMOVGE; +extern const fcml_cstring M_CMOVL; +extern const fcml_cstring M_CMOVLE; +extern const fcml_cstring M_CMOVNA; +extern const fcml_cstring M_CMOVNAE; +extern const fcml_cstring M_CMOVNB; +extern const fcml_cstring M_CMOVNBE; +extern const fcml_cstring M_CMOVNC; +extern const fcml_cstring M_CMOVNG; +extern const fcml_cstring M_CMOVNGE; +extern const fcml_cstring M_CMOVNL; +extern const fcml_cstring M_CMOVNLE; +extern const fcml_cstring M_CMOVNO; +extern const fcml_cstring M_CMOVNP; +extern const fcml_cstring M_CMOVNS; +extern const fcml_cstring M_CMOVNZ; +extern const fcml_cstring M_CMOVO; +extern const fcml_cstring M_CMOVP; +extern const fcml_cstring M_CMOVPE; +extern const fcml_cstring M_CMOVPO; +extern const fcml_cstring M_CMOVS; +extern const fcml_cstring M_CMOVZ; +extern const fcml_cstring M_CMP; +extern const fcml_cstring M_CMPB; +extern const fcml_cstring M_CMPEQPD; +extern const fcml_cstring M_CMPEQPS; +extern const fcml_cstring M_CMPEQSD; +extern const fcml_cstring M_CMPEQSS; +extern const fcml_cstring M_CMPL; +extern const fcml_cstring M_CMPLEPD; +extern const fcml_cstring M_CMPLEPS; +extern const fcml_cstring M_CMPLESD; +extern const fcml_cstring M_CMPLESS; +extern const fcml_cstring M_CMPLTPD; +extern const fcml_cstring M_CMPLTPS; +extern const fcml_cstring M_CMPLTSD; +extern const fcml_cstring M_CMPLTSS; +extern const fcml_cstring M_CMPNEQPD; +extern const fcml_cstring M_CMPNEQPS; +extern const fcml_cstring M_CMPNEQSD; +extern const fcml_cstring M_CMPNEQSS; +extern const fcml_cstring M_CMPNLEPD; +extern const fcml_cstring M_CMPNLEPS; +extern const fcml_cstring M_CMPNLESD; +extern const fcml_cstring M_CMPNLESS; +extern const fcml_cstring M_CMPNLTPD; +extern const fcml_cstring M_CMPNLTPS; +extern const fcml_cstring M_CMPNLTSD; +extern const fcml_cstring M_CMPNLTSS; +extern const fcml_cstring M_CMPORDPD; +extern const fcml_cstring M_CMPORDPS; +extern const fcml_cstring M_CMPORDSD; +extern const fcml_cstring M_CMPORDSS; +extern const fcml_cstring M_CMPPD; +extern const fcml_cstring M_CMPPS; +extern const fcml_cstring M_CMPQ; +extern const fcml_cstring M_CMPSB; +extern const fcml_cstring M_CMPSD; +extern const fcml_cstring M_CMPSL; +extern const fcml_cstring M_CMPSQ; +extern const fcml_cstring M_CMPSS; +extern const fcml_cstring M_CMPSW; +extern const fcml_cstring M_CMPUNORDPD; +extern const fcml_cstring M_CMPUNORDPS; +extern const fcml_cstring M_CMPUNORDSD; +extern const fcml_cstring M_CMPUNORDSS; +extern const fcml_cstring M_CMPW; +extern const fcml_cstring M_CMPXCHG; +extern const fcml_cstring M_CMPXCHG16B; +extern const fcml_cstring M_CMPXCHG8B; +extern const fcml_cstring M_COMISD; +extern const fcml_cstring M_COMISS; +extern const fcml_cstring M_CPUID; +extern const fcml_cstring M_CQTO; +extern const fcml_cstring M_CRC32B; +extern const fcml_cstring M_CRC32L; +extern const fcml_cstring M_CRC32Q; +extern const fcml_cstring M_CRC32W; +extern const fcml_cstring M_CVTDQ2PD; +extern const fcml_cstring M_CVTDQ2PS; +extern const fcml_cstring M_CVTPD2DQ; +extern const fcml_cstring M_CVTPD2PI; +extern const fcml_cstring M_CVTPD2PS; +extern const fcml_cstring M_CVTPI2PD; +extern const fcml_cstring M_CVTPI2PS; +extern const fcml_cstring M_CVTPS2DQ; +extern const fcml_cstring M_CVTPS2PD; +extern const fcml_cstring M_CVTPS2PI; +extern const fcml_cstring M_CVTSD2SI; +extern const fcml_cstring M_CVTSD2SS; +extern const fcml_cstring M_CVTSI2SDL; +extern const fcml_cstring M_CVTSI2SDQ; +extern const fcml_cstring M_CVTSI2SSL; +extern const fcml_cstring M_CVTSI2SSQ; +extern const fcml_cstring M_CVTSS2SD; +extern const fcml_cstring M_CVTSS2SI; +extern const fcml_cstring M_CVTTPD2DQ; +extern const fcml_cstring M_CVTTPD2PI; +extern const fcml_cstring M_CVTTPS2DQ; +extern const fcml_cstring M_CVTTPS2PI; +extern const fcml_cstring M_CVTTSD2SI; +extern const fcml_cstring M_CVTTSS2SI; +extern const fcml_cstring M_CWTD; +extern const fcml_cstring M_CWTL; +extern const fcml_cstring M_DAA; +extern const fcml_cstring M_DAS; +extern const fcml_cstring M_DEC; +extern const fcml_cstring M_DECB; +extern const fcml_cstring M_DECL; +extern const fcml_cstring M_DECQ; +extern const fcml_cstring M_DECW; +extern const fcml_cstring M_DIV; +extern const fcml_cstring M_DIVB; +extern const fcml_cstring M_DIVL; +extern const fcml_cstring M_DIVPD; +extern const fcml_cstring M_DIVPS; +extern const fcml_cstring M_DIVQ; +extern const fcml_cstring M_DIVSD; +extern const fcml_cstring M_DIVSS; +extern const fcml_cstring M_DIVW; +extern const fcml_cstring M_DPPD; +extern const fcml_cstring M_DPPS; +extern const fcml_cstring M_EMMS; +extern const fcml_cstring M_ENTER; +extern const fcml_cstring M_ENTERQ; +extern const fcml_cstring M_EXTRACTPS; +extern const fcml_cstring M_EXTRQ; +extern const fcml_cstring M_F2XM1; +extern const fcml_cstring M_FABS; +extern const fcml_cstring M_FADD; +extern const fcml_cstring M_FADDL; +extern const fcml_cstring M_FADDP; +extern const fcml_cstring M_FADDS; +extern const fcml_cstring M_FBLD; +extern const fcml_cstring M_FBSTP; +extern const fcml_cstring M_FCHS; +extern const fcml_cstring M_FCLEX; +extern const fcml_cstring M_FCMOVB; +extern const fcml_cstring M_FCMOVBE; +extern const fcml_cstring M_FCMOVE; +extern const fcml_cstring M_FCMOVNB; +extern const fcml_cstring M_FCMOVNBE; +extern const fcml_cstring M_FCMOVNE; +extern const fcml_cstring M_FCMOVNU; +extern const fcml_cstring M_FCMOVU; +extern const fcml_cstring M_FCOM; +extern const fcml_cstring M_FCOMI; +extern const fcml_cstring M_FCOMIP; +extern const fcml_cstring M_FCOML; +extern const fcml_cstring M_FCOMP; +extern const fcml_cstring M_FCOMPL; +extern const fcml_cstring M_FCOMPP; +extern const fcml_cstring M_FCOMPS; +extern const fcml_cstring M_FCOMS; +extern const fcml_cstring M_FCOS; +extern const fcml_cstring M_FDECSTP; +extern const fcml_cstring M_FDIV; +extern const fcml_cstring M_FDIVL; +extern const fcml_cstring M_FDIVP; +extern const fcml_cstring M_FDIVR; +extern const fcml_cstring M_FDIVRL; +extern const fcml_cstring M_FDIVRP; +extern const fcml_cstring M_FDIVRS; +extern const fcml_cstring M_FDIVS; +extern const fcml_cstring M_FEMMS; +extern const fcml_cstring M_FFREE; +extern const fcml_cstring M_FIADD; +extern const fcml_cstring M_FIADDL; +extern const fcml_cstring M_FICOM; +extern const fcml_cstring M_FICOML; +extern const fcml_cstring M_FICOMP; +extern const fcml_cstring M_FICOMPL; +extern const fcml_cstring M_FIDIV; +extern const fcml_cstring M_FIDIVL; +extern const fcml_cstring M_FIDIVR; +extern const fcml_cstring M_FIDIVRL; +extern const fcml_cstring M_FILD; +extern const fcml_cstring M_FILDL; +extern const fcml_cstring M_FILDLL; +extern const fcml_cstring M_FIMUL; +extern const fcml_cstring M_FIMULL; +extern const fcml_cstring M_FINCSTP; +extern const fcml_cstring M_FINIT; +extern const fcml_cstring M_FIST; +extern const fcml_cstring M_FISTL; +extern const fcml_cstring M_FISTP; +extern const fcml_cstring M_FISTPL; +extern const fcml_cstring M_FISTPLL; +extern const fcml_cstring M_FISTTP; +extern const fcml_cstring M_FISTTPL; +extern const fcml_cstring M_FISTTPLL; +extern const fcml_cstring M_FISUB; +extern const fcml_cstring M_FISUBL; +extern const fcml_cstring M_FISUBR; +extern const fcml_cstring M_FISUBRL; +extern const fcml_cstring M_FLD; +extern const fcml_cstring M_FLD1; +extern const fcml_cstring M_FLDCW; +extern const fcml_cstring M_FLDENV; +extern const fcml_cstring M_FLDENVS; +extern const fcml_cstring M_FLDL; +extern const fcml_cstring M_FLDL2E; +extern const fcml_cstring M_FLDL2T; +extern const fcml_cstring M_FLDLG2; +extern const fcml_cstring M_FLDLN2; +extern const fcml_cstring M_FLDPI; +extern const fcml_cstring M_FLDS; +extern const fcml_cstring M_FLDT; +extern const fcml_cstring M_FLDZ; +extern const fcml_cstring M_FMUL; +extern const fcml_cstring M_FMULL; +extern const fcml_cstring M_FMULP; +extern const fcml_cstring M_FMULS; +extern const fcml_cstring M_FNCLEX; +extern const fcml_cstring M_FNINIT; +extern const fcml_cstring M_FNOP; +extern const fcml_cstring M_FNSAVE; +extern const fcml_cstring M_FNSAVES; +extern const fcml_cstring M_FNSTCW; +extern const fcml_cstring M_FNSTENV; +extern const fcml_cstring M_FNSTENVS; +extern const fcml_cstring M_FNSTSW; +extern const fcml_cstring M_FPATAN; +extern const fcml_cstring M_FPREM; +extern const fcml_cstring M_FPREM1; +extern const fcml_cstring M_FPTAN; +extern const fcml_cstring M_FRNDINT; +extern const fcml_cstring M_FRSTOR; +extern const fcml_cstring M_FRSTORS; +extern const fcml_cstring M_FSAVE; +extern const fcml_cstring M_FSAVES; +extern const fcml_cstring M_FSCALE; +extern const fcml_cstring M_FSIN; +extern const fcml_cstring M_FSINCOS; +extern const fcml_cstring M_FSQRT; +extern const fcml_cstring M_FST; +extern const fcml_cstring M_FSTCW; +extern const fcml_cstring M_FSTENV; +extern const fcml_cstring M_FSTENVS; +extern const fcml_cstring M_FSTL; +extern const fcml_cstring M_FSTP; +extern const fcml_cstring M_FSTPL; +extern const fcml_cstring M_FSTPS; +extern const fcml_cstring M_FSTPT; +extern const fcml_cstring M_FSTS; +extern const fcml_cstring M_FSTSW; +extern const fcml_cstring M_FSUB; +extern const fcml_cstring M_FSUBL; +extern const fcml_cstring M_FSUBP; +extern const fcml_cstring M_FSUBR; +extern const fcml_cstring M_FSUBRL; +extern const fcml_cstring M_FSUBRP; +extern const fcml_cstring M_FSUBRS; +extern const fcml_cstring M_FSUBS; +extern const fcml_cstring M_FTST; +extern const fcml_cstring M_FUCOM; +extern const fcml_cstring M_FUCOMI; +extern const fcml_cstring M_FUCOMIP; +extern const fcml_cstring M_FUCOMP; +extern const fcml_cstring M_FUCOMPP; +extern const fcml_cstring M_FWAIT; +extern const fcml_cstring M_FXAM; +extern const fcml_cstring M_FXCH; +extern const fcml_cstring M_FXRSTOR; +extern const fcml_cstring M_FXRSTOR64; +extern const fcml_cstring M_FXSAVE; +extern const fcml_cstring M_FXSAVE64; +extern const fcml_cstring M_FXTRACT; +extern const fcml_cstring M_FYL2X; +extern const fcml_cstring M_FYL2XP1; +extern const fcml_cstring M_GETSEC; +extern const fcml_cstring M_HADDPD; +extern const fcml_cstring M_HADDPS; +extern const fcml_cstring M_HLT; +extern const fcml_cstring M_HSUBPD; +extern const fcml_cstring M_HSUBPS; +extern const fcml_cstring M_IDIV; +extern const fcml_cstring M_IDIVB; +extern const fcml_cstring M_IDIVL; +extern const fcml_cstring M_IDIVQ; +extern const fcml_cstring M_IDIVW; +extern const fcml_cstring M_IMUL; +extern const fcml_cstring M_IMULB; +extern const fcml_cstring M_IMULL; +extern const fcml_cstring M_IMULQ; +extern const fcml_cstring M_IMULW; +extern const fcml_cstring M_IN; +extern const fcml_cstring M_INC; +extern const fcml_cstring M_INCB; +extern const fcml_cstring M_INCL; +extern const fcml_cstring M_INCQ; +extern const fcml_cstring M_INCW; +extern const fcml_cstring M_INSB; +extern const fcml_cstring M_INSERTPS; +extern const fcml_cstring M_INSERTQ; +extern const fcml_cstring M_INSL; +extern const fcml_cstring M_INSW; +extern const fcml_cstring M_INT; +extern const fcml_cstring M_INT3; +extern const fcml_cstring M_INTO; +extern const fcml_cstring M_INVD; +extern const fcml_cstring M_INVEPT; +extern const fcml_cstring M_INVLPG; +extern const fcml_cstring M_INVLPGA; +extern const fcml_cstring M_INVPCID; +extern const fcml_cstring M_INVVPID; +extern const fcml_cstring M_IRET; +extern const fcml_cstring M_IRETQ; +extern const fcml_cstring M_IRETW; +extern const fcml_cstring M_JA; +extern const fcml_cstring M_JAE; +extern const fcml_cstring M_JB; +extern const fcml_cstring M_JBE; +extern const fcml_cstring M_JC; +extern const fcml_cstring M_JCXZ; +extern const fcml_cstring M_JECXZ; +extern const fcml_cstring M_JENE; +extern const fcml_cstring M_JG; +extern const fcml_cstring M_JGE; +extern const fcml_cstring M_JL; +extern const fcml_cstring M_JLE; +extern const fcml_cstring M_JMP; +extern const fcml_cstring M_JMPQ; +extern const fcml_cstring M_JMPW; +extern const fcml_cstring M_JNA; +extern const fcml_cstring M_JNAE; +extern const fcml_cstring M_JNB; +extern const fcml_cstring M_JNBE; +extern const fcml_cstring M_JNC; +extern const fcml_cstring M_JNG; +extern const fcml_cstring M_JNGE; +extern const fcml_cstring M_JNL; +extern const fcml_cstring M_JNLE; +extern const fcml_cstring M_JNO; +extern const fcml_cstring M_JNP; +extern const fcml_cstring M_JNS; +extern const fcml_cstring M_JNZ; +extern const fcml_cstring M_JO; +extern const fcml_cstring M_JP; +extern const fcml_cstring M_JPE; +extern const fcml_cstring M_JPO; +extern const fcml_cstring M_JRCXZ; +extern const fcml_cstring M_JS; +extern const fcml_cstring M_JZ; +extern const fcml_cstring M_KADDB; +extern const fcml_cstring M_KADDD; +extern const fcml_cstring M_KADDQ; +extern const fcml_cstring M_KADDW; +extern const fcml_cstring M_KANDB; +extern const fcml_cstring M_KANDD; +extern const fcml_cstring M_KANDNB; +extern const fcml_cstring M_KANDND; +extern const fcml_cstring M_KANDNQ; +extern const fcml_cstring M_KANDNW; +extern const fcml_cstring M_KANDQ; +extern const fcml_cstring M_KANDW; +extern const fcml_cstring M_KMOVB; +extern const fcml_cstring M_KMOVD; +extern const fcml_cstring M_KMOVQ; +extern const fcml_cstring M_KMOVW; +extern const fcml_cstring M_KNOTB; +extern const fcml_cstring M_KNOTD; +extern const fcml_cstring M_KNOTQ; +extern const fcml_cstring M_KNOTW; +extern const fcml_cstring M_KORB; +extern const fcml_cstring M_KORD; +extern const fcml_cstring M_KORQ; +extern const fcml_cstring M_KORTESTB; +extern const fcml_cstring M_KORTESTD; +extern const fcml_cstring M_KORTESTQ; +extern const fcml_cstring M_KORTESTW; +extern const fcml_cstring M_KORW; +extern const fcml_cstring M_KSHIFTLB; +extern const fcml_cstring M_KSHIFTLD; +extern const fcml_cstring M_KSHIFTLQ; +extern const fcml_cstring M_KSHIFTLW; +extern const fcml_cstring M_KSHIFTRB; +extern const fcml_cstring M_KSHIFTRD; +extern const fcml_cstring M_KSHIFTRQ; +extern const fcml_cstring M_KSHIFTRW; +extern const fcml_cstring M_KTESTB; +extern const fcml_cstring M_KTESTD; +extern const fcml_cstring M_KTESTQ; +extern const fcml_cstring M_KTESTW; +extern const fcml_cstring M_KXNORB; +extern const fcml_cstring M_KXNORD; +extern const fcml_cstring M_KXNORQ; +extern const fcml_cstring M_KXNORW; +extern const fcml_cstring M_KXORB; +extern const fcml_cstring M_KXORD; +extern const fcml_cstring M_KXORQ; +extern const fcml_cstring M_KXORW; +extern const fcml_cstring M_LAHF; +extern const fcml_cstring M_LAR; +extern const fcml_cstring M_LCALL; +extern const fcml_cstring M_LCALLQ; +extern const fcml_cstring M_LCALLW; +extern const fcml_cstring M_LDDQU; +extern const fcml_cstring M_LDMXCSR; +extern const fcml_cstring M_LDS; +extern const fcml_cstring M_LEA; +extern const fcml_cstring M_LEAVE; +extern const fcml_cstring M_LES; +extern const fcml_cstring M_LFENCE; +extern const fcml_cstring M_LFS; +extern const fcml_cstring M_LGDT; +extern const fcml_cstring M_LGS; +extern const fcml_cstring M_LIDT; +extern const fcml_cstring M_LJMP; +extern const fcml_cstring M_LJMPL; +extern const fcml_cstring M_LJMPQ; +extern const fcml_cstring M_LJMPW; +extern const fcml_cstring M_LLDT; +extern const fcml_cstring M_LLWPCB; +extern const fcml_cstring M_LMSW; +extern const fcml_cstring M_LODS; +extern const fcml_cstring M_LODSB; +extern const fcml_cstring M_LODSL; +extern const fcml_cstring M_LODSQ; +extern const fcml_cstring M_LODSW; +extern const fcml_cstring M_LOOP; +extern const fcml_cstring M_LOOPE; +extern const fcml_cstring M_LOOPNE; +extern const fcml_cstring M_LOOPNZ; +extern const fcml_cstring M_LOOPZ; +extern const fcml_cstring M_LRET; +extern const fcml_cstring M_LRETQ; +extern const fcml_cstring M_LRETW; +extern const fcml_cstring M_LSL; +extern const fcml_cstring M_LSS; +extern const fcml_cstring M_LTR; +extern const fcml_cstring M_LWPINS; +extern const fcml_cstring M_LWPVAL; +extern const fcml_cstring M_LZCNT; +extern const fcml_cstring M_MASKMOVDQU; +extern const fcml_cstring M_MASKMOVQ; +extern const fcml_cstring M_MAXPD; +extern const fcml_cstring M_MAXPS; +extern const fcml_cstring M_MAXSD; +extern const fcml_cstring M_MAXSS; +extern const fcml_cstring M_MFENCE; +extern const fcml_cstring M_MINPD; +extern const fcml_cstring M_MINPS; +extern const fcml_cstring M_MINSD; +extern const fcml_cstring M_MINSS; +extern const fcml_cstring M_MONITOR; +extern const fcml_cstring M_MOV; +extern const fcml_cstring M_MOVABS; +extern const fcml_cstring M_MOVAPD; +extern const fcml_cstring M_MOVAPS; +extern const fcml_cstring M_MOVB; +extern const fcml_cstring M_MOVBE; +extern const fcml_cstring M_MOVD; +extern const fcml_cstring M_MOVDDUP; +extern const fcml_cstring M_MOVDQ2Q; +extern const fcml_cstring M_MOVDQA; +extern const fcml_cstring M_MOVDQU; +extern const fcml_cstring M_MOVHLPS; +extern const fcml_cstring M_MOVHPD; +extern const fcml_cstring M_MOVHPS; +extern const fcml_cstring M_MOVL; +extern const fcml_cstring M_MOVLHPS; +extern const fcml_cstring M_MOVLPD; +extern const fcml_cstring M_MOVLPS; +extern const fcml_cstring M_MOVMSKPD; +extern const fcml_cstring M_MOVMSKPS; +extern const fcml_cstring M_MOVNTDQ; +extern const fcml_cstring M_MOVNTDQA; +extern const fcml_cstring M_MOVNTI; +extern const fcml_cstring M_MOVNTPD; +extern const fcml_cstring M_MOVNTPS; +extern const fcml_cstring M_MOVNTQ; +extern const fcml_cstring M_MOVNTSD; +extern const fcml_cstring M_MOVNTSS; +extern const fcml_cstring M_MOVQ; +extern const fcml_cstring M_MOVQ2DQ; +extern const fcml_cstring M_MOVS; +extern const fcml_cstring M_MOVSB; +extern const fcml_cstring M_MOVSBL; +extern const fcml_cstring M_MOVSBQ; +extern const fcml_cstring M_MOVSBW; +extern const fcml_cstring M_MOVSD; +extern const fcml_cstring M_MOVSHDUP; +extern const fcml_cstring M_MOVSL; +extern const fcml_cstring M_MOVSLDUP; +extern const fcml_cstring M_MOVSQ; +extern const fcml_cstring M_MOVSS; +extern const fcml_cstring M_MOVSW; +extern const fcml_cstring M_MOVSWL; +extern const fcml_cstring M_MOVSWQ; +extern const fcml_cstring M_MOVSWW; +extern const fcml_cstring M_MOVSXD; +extern const fcml_cstring M_MOVUPD; +extern const fcml_cstring M_MOVUPS; +extern const fcml_cstring M_MOVW; +extern const fcml_cstring M_MOVZBL; +extern const fcml_cstring M_MOVZBQ; +extern const fcml_cstring M_MOVZBW; +extern const fcml_cstring M_MOVZWL; +extern const fcml_cstring M_MOVZWQ; +extern const fcml_cstring M_MOVZWW; +extern const fcml_cstring M_MPSADBW; +extern const fcml_cstring M_MUL; +extern const fcml_cstring M_MULB; +extern const fcml_cstring M_MULL; +extern const fcml_cstring M_MULPD; +extern const fcml_cstring M_MULPS; +extern const fcml_cstring M_MULQ; +extern const fcml_cstring M_MULSD; +extern const fcml_cstring M_MULSS; +extern const fcml_cstring M_MULW; +extern const fcml_cstring M_MULX; +extern const fcml_cstring M_MWAIT; +extern const fcml_cstring M_NEG; +extern const fcml_cstring M_NEGB; +extern const fcml_cstring M_NEGL; +extern const fcml_cstring M_NEGQ; +extern const fcml_cstring M_NEGW; +extern const fcml_cstring M_NOP; +extern const fcml_cstring M_NOPL; +extern const fcml_cstring M_NOPQ; +extern const fcml_cstring M_NOPW; +extern const fcml_cstring M_NOT; +extern const fcml_cstring M_NOTB; +extern const fcml_cstring M_NOTL; +extern const fcml_cstring M_NOTQ; +extern const fcml_cstring M_NOTW; +extern const fcml_cstring M_OR; +extern const fcml_cstring M_ORB; +extern const fcml_cstring M_ORL; +extern const fcml_cstring M_ORPD; +extern const fcml_cstring M_ORPS; +extern const fcml_cstring M_ORQ; +extern const fcml_cstring M_ORW; +extern const fcml_cstring M_OUT; +extern const fcml_cstring M_OUTSB; +extern const fcml_cstring M_OUTSL; +extern const fcml_cstring M_OUTSW; +extern const fcml_cstring M_PABSB; +extern const fcml_cstring M_PABSD; +extern const fcml_cstring M_PABSW; +extern const fcml_cstring M_PACKSSDW; +extern const fcml_cstring M_PACKSSWB; +extern const fcml_cstring M_PACKUSDW; +extern const fcml_cstring M_PACKUSWB; +extern const fcml_cstring M_PADDB; +extern const fcml_cstring M_PADDD; +extern const fcml_cstring M_PADDQ; +extern const fcml_cstring M_PADDSB; +extern const fcml_cstring M_PADDSW; +extern const fcml_cstring M_PADDUSB; +extern const fcml_cstring M_PADDUSW; +extern const fcml_cstring M_PADDW; +extern const fcml_cstring M_PALIGNR; +extern const fcml_cstring M_PAND; +extern const fcml_cstring M_PANDN; +extern const fcml_cstring M_PAUSE; +extern const fcml_cstring M_PAVGB; +extern const fcml_cstring M_PAVGUSB; +extern const fcml_cstring M_PAVGW; +extern const fcml_cstring M_PBLENDVB; +extern const fcml_cstring M_PBLENDW; +extern const fcml_cstring M_PCLMULQDQ; +extern const fcml_cstring M_PCMPEQB; +extern const fcml_cstring M_PCMPEQD; +extern const fcml_cstring M_PCMPEQQ; +extern const fcml_cstring M_PCMPEQW; +extern const fcml_cstring M_PCMPESTRI; +extern const fcml_cstring M_PCMPESTRM; +extern const fcml_cstring M_PCMPGTB; +extern const fcml_cstring M_PCMPGTD; +extern const fcml_cstring M_PCMPGTQ; +extern const fcml_cstring M_PCMPGTW; +extern const fcml_cstring M_PCMPISTRI; +extern const fcml_cstring M_PCMPISTRM; +extern const fcml_cstring M_PDEP; +extern const fcml_cstring M_PEXT; +extern const fcml_cstring M_PEXTRB; +extern const fcml_cstring M_PEXTRD; +extern const fcml_cstring M_PEXTRQ; +extern const fcml_cstring M_PEXTRW; +extern const fcml_cstring M_PF2ID; +extern const fcml_cstring M_PF2IW; +extern const fcml_cstring M_PFACC; +extern const fcml_cstring M_PFADD; +extern const fcml_cstring M_PFCMPEQ; +extern const fcml_cstring M_PFCMPGE; +extern const fcml_cstring M_PFCMPGT; +extern const fcml_cstring M_PFMAX; +extern const fcml_cstring M_PFMIN; +extern const fcml_cstring M_PFMUL; +extern const fcml_cstring M_PFNACC; +extern const fcml_cstring M_PFPNACC; +extern const fcml_cstring M_PFRCP; +extern const fcml_cstring M_PFRCPIT1; +extern const fcml_cstring M_PFRCPIT2; +extern const fcml_cstring M_PFRSQIT1; +extern const fcml_cstring M_PFRSQRT; +extern const fcml_cstring M_PFSUB; +extern const fcml_cstring M_PFSUBR; +extern const fcml_cstring M_PHADDD; +extern const fcml_cstring M_PHADDSW; +extern const fcml_cstring M_PHADDW; +extern const fcml_cstring M_PHMINPOSUW; +extern const fcml_cstring M_PHSUBD; +extern const fcml_cstring M_PHSUBSW; +extern const fcml_cstring M_PHSUBW; +extern const fcml_cstring M_PI2FD; +extern const fcml_cstring M_PI2FW; +extern const fcml_cstring M_PINSRB; +extern const fcml_cstring M_PINSRD; +extern const fcml_cstring M_PINSRQ; +extern const fcml_cstring M_PINSRW; +extern const fcml_cstring M_PMADDUBSW; +extern const fcml_cstring M_PMADDWD; +extern const fcml_cstring M_PMAXSB; +extern const fcml_cstring M_PMAXSD; +extern const fcml_cstring M_PMAXSW; +extern const fcml_cstring M_PMAXUB; +extern const fcml_cstring M_PMAXUD; +extern const fcml_cstring M_PMAXUW; +extern const fcml_cstring M_PMINSB; +extern const fcml_cstring M_PMINSD; +extern const fcml_cstring M_PMINSW; +extern const fcml_cstring M_PMINUB; +extern const fcml_cstring M_PMINUD; +extern const fcml_cstring M_PMINUW; +extern const fcml_cstring M_PMOVMSKB; +extern const fcml_cstring M_PMOVSXBD; +extern const fcml_cstring M_PMOVSXBQ; +extern const fcml_cstring M_PMOVSXBW; +extern const fcml_cstring M_PMOVSXDQ; +extern const fcml_cstring M_PMOVSXWD; +extern const fcml_cstring M_PMOVSXWQ; +extern const fcml_cstring M_PMOVZXBD; +extern const fcml_cstring M_PMOVZXBQ; +extern const fcml_cstring M_PMOVZXBW; +extern const fcml_cstring M_PMOVZXDQ; +extern const fcml_cstring M_PMOVZXWD; +extern const fcml_cstring M_PMOVZXWQ; +extern const fcml_cstring M_PMULDQ; +extern const fcml_cstring M_PMULHRSW; +extern const fcml_cstring M_PMULHRW; +extern const fcml_cstring M_PMULHUW; +extern const fcml_cstring M_PMULHW; +extern const fcml_cstring M_PMULLD; +extern const fcml_cstring M_PMULLW; +extern const fcml_cstring M_PMULUDQ; +extern const fcml_cstring M_POP; +extern const fcml_cstring M_POPA; +extern const fcml_cstring M_POPAW; +extern const fcml_cstring M_POPCNT; +extern const fcml_cstring M_POPF; +extern const fcml_cstring M_POPFQ; +extern const fcml_cstring M_POPFW; +extern const fcml_cstring M_POPL; +extern const fcml_cstring M_POPQ; +extern const fcml_cstring M_POPW; +extern const fcml_cstring M_POR; +extern const fcml_cstring M_PREFETCH; +extern const fcml_cstring M_PREFETCHNTA; +extern const fcml_cstring M_PREFETCHT0; +extern const fcml_cstring M_PREFETCHT1; +extern const fcml_cstring M_PREFETCHT2; +extern const fcml_cstring M_PREFETCHW; +extern const fcml_cstring M_PREFETCHWT1; +extern const fcml_cstring M_PSADBW; +extern const fcml_cstring M_PSHUFB; +extern const fcml_cstring M_PSHUFD; +extern const fcml_cstring M_PSHUFHW; +extern const fcml_cstring M_PSHUFLW; +extern const fcml_cstring M_PSHUFW; +extern const fcml_cstring M_PSIGNB; +extern const fcml_cstring M_PSIGND; +extern const fcml_cstring M_PSIGNW; +extern const fcml_cstring M_PSLLD; +extern const fcml_cstring M_PSLLDQ; +extern const fcml_cstring M_PSLLQ; +extern const fcml_cstring M_PSLLW; +extern const fcml_cstring M_PSRAD; +extern const fcml_cstring M_PSRAW; +extern const fcml_cstring M_PSRLD; +extern const fcml_cstring M_PSRLDQ; +extern const fcml_cstring M_PSRLQ; +extern const fcml_cstring M_PSRLW; +extern const fcml_cstring M_PSUBB; +extern const fcml_cstring M_PSUBD; +extern const fcml_cstring M_PSUBQ; +extern const fcml_cstring M_PSUBSB; +extern const fcml_cstring M_PSUBSW; +extern const fcml_cstring M_PSUBUSB; +extern const fcml_cstring M_PSUBUSW; +extern const fcml_cstring M_PSUBW; +extern const fcml_cstring M_PSWAPD; +extern const fcml_cstring M_PTEST; +extern const fcml_cstring M_PUNPCKHBW; +extern const fcml_cstring M_PUNPCKHDQ; +extern const fcml_cstring M_PUNPCKHQDQ; +extern const fcml_cstring M_PUNPCKHWD; +extern const fcml_cstring M_PUNPCKLBW; +extern const fcml_cstring M_PUNPCKLDQ; +extern const fcml_cstring M_PUNPCKLQDQ; +extern const fcml_cstring M_PUNPCKLWD; +extern const fcml_cstring M_PUSH; +extern const fcml_cstring M_PUSHA; +extern const fcml_cstring M_PUSHAW; +extern const fcml_cstring M_PUSHB; +extern const fcml_cstring M_PUSHF; +extern const fcml_cstring M_PUSHFQ; +extern const fcml_cstring M_PUSHFW; +extern const fcml_cstring M_PUSHL; +extern const fcml_cstring M_PUSHQ; +extern const fcml_cstring M_PUSHW; +extern const fcml_cstring M_PXOR; +extern const fcml_cstring M_RCL; +extern const fcml_cstring M_RCLB; +extern const fcml_cstring M_RCLL; +extern const fcml_cstring M_RCLQ; +extern const fcml_cstring M_RCLW; +extern const fcml_cstring M_RCPPS; +extern const fcml_cstring M_RCPSS; +extern const fcml_cstring M_RCR; +extern const fcml_cstring M_RCRB; +extern const fcml_cstring M_RCRL; +extern const fcml_cstring M_RCRQ; +extern const fcml_cstring M_RCRW; +extern const fcml_cstring M_RDFSBASE; +extern const fcml_cstring M_RDGSBASE; +extern const fcml_cstring M_RDMSR; +extern const fcml_cstring M_RDPMC; +extern const fcml_cstring M_RDRAND; +extern const fcml_cstring M_RDSEED; +extern const fcml_cstring M_RDTSC; +extern const fcml_cstring M_RDTSCP; +extern const fcml_cstring M_RET; +extern const fcml_cstring M_RETQ; +extern const fcml_cstring M_RETW; +extern const fcml_cstring M_ROL; +extern const fcml_cstring M_ROLB; +extern const fcml_cstring M_ROLL; +extern const fcml_cstring M_ROLQ; +extern const fcml_cstring M_ROLW; +extern const fcml_cstring M_ROR; +extern const fcml_cstring M_RORB; +extern const fcml_cstring M_RORL; +extern const fcml_cstring M_RORQ; +extern const fcml_cstring M_RORW; +extern const fcml_cstring M_RORX; +extern const fcml_cstring M_ROUNDPD; +extern const fcml_cstring M_ROUNDPS; +extern const fcml_cstring M_ROUNDSD; +extern const fcml_cstring M_ROUNDSS; +extern const fcml_cstring M_RSM; +extern const fcml_cstring M_RSQRTPS; +extern const fcml_cstring M_RSQRTSS; +extern const fcml_cstring M_SAHF; +extern const fcml_cstring M_SAL; +extern const fcml_cstring M_SALB; +extern const fcml_cstring M_SALL; +extern const fcml_cstring M_SALQ; +extern const fcml_cstring M_SALW; +extern const fcml_cstring M_SAR; +extern const fcml_cstring M_SARB; +extern const fcml_cstring M_SARL; +extern const fcml_cstring M_SARQ; +extern const fcml_cstring M_SARW; +extern const fcml_cstring M_SARX; +extern const fcml_cstring M_SBB; +extern const fcml_cstring M_SBBB; +extern const fcml_cstring M_SBBL; +extern const fcml_cstring M_SBBQ; +extern const fcml_cstring M_SBBW; +extern const fcml_cstring M_SCAS; +extern const fcml_cstring M_SCASB; +extern const fcml_cstring M_SCASL; +extern const fcml_cstring M_SCASQ; +extern const fcml_cstring M_SCASW; +extern const fcml_cstring M_SETA; +extern const fcml_cstring M_SETAE; +extern const fcml_cstring M_SETB; +extern const fcml_cstring M_SETBE; +extern const fcml_cstring M_SETC; +extern const fcml_cstring M_SETENE; +extern const fcml_cstring M_SETG; +extern const fcml_cstring M_SETGE; +extern const fcml_cstring M_SETL; +extern const fcml_cstring M_SETLE; +extern const fcml_cstring M_SETNA; +extern const fcml_cstring M_SETNAE; +extern const fcml_cstring M_SETNB; +extern const fcml_cstring M_SETNBE; +extern const fcml_cstring M_SETNC; +extern const fcml_cstring M_SETNG; +extern const fcml_cstring M_SETNGE; +extern const fcml_cstring M_SETNL; +extern const fcml_cstring M_SETNLE; +extern const fcml_cstring M_SETNO; +extern const fcml_cstring M_SETNP; +extern const fcml_cstring M_SETNS; +extern const fcml_cstring M_SETNZ; +extern const fcml_cstring M_SETO; +extern const fcml_cstring M_SETP; +extern const fcml_cstring M_SETPE; +extern const fcml_cstring M_SETPO; +extern const fcml_cstring M_SETS; +extern const fcml_cstring M_SETZ; +extern const fcml_cstring M_SFENCE; +extern const fcml_cstring M_SGDT; +extern const fcml_cstring M_SHL; +extern const fcml_cstring M_SHLB; +extern const fcml_cstring M_SHLD; +extern const fcml_cstring M_SHLL; +extern const fcml_cstring M_SHLQ; +extern const fcml_cstring M_SHLW; +extern const fcml_cstring M_SHLX; +extern const fcml_cstring M_SHR; +extern const fcml_cstring M_SHRB; +extern const fcml_cstring M_SHRD; +extern const fcml_cstring M_SHRL; +extern const fcml_cstring M_SHRQ; +extern const fcml_cstring M_SHRW; +extern const fcml_cstring M_SHRX; +extern const fcml_cstring M_SHUFPD; +extern const fcml_cstring M_SHUFPS; +extern const fcml_cstring M_SIDT; +extern const fcml_cstring M_SKINIT; +extern const fcml_cstring M_SLDT; +extern const fcml_cstring M_SLWPCB; +extern const fcml_cstring M_SMSW; +extern const fcml_cstring M_SQRTPD; +extern const fcml_cstring M_SQRTPS; +extern const fcml_cstring M_SQRTSD; +extern const fcml_cstring M_SQRTSS; +extern const fcml_cstring M_STAC; +extern const fcml_cstring M_STC; +extern const fcml_cstring M_STD; +extern const fcml_cstring M_STGI; +extern const fcml_cstring M_STI; +extern const fcml_cstring M_STMXCSR; +extern const fcml_cstring M_STOS; +extern const fcml_cstring M_STOSB; +extern const fcml_cstring M_STOSL; +extern const fcml_cstring M_STOSQ; +extern const fcml_cstring M_STOSW; +extern const fcml_cstring M_STR; +extern const fcml_cstring M_SUB; +extern const fcml_cstring M_SUBB; +extern const fcml_cstring M_SUBL; +extern const fcml_cstring M_SUBPD; +extern const fcml_cstring M_SUBPS; +extern const fcml_cstring M_SUBQ; +extern const fcml_cstring M_SUBSD; +extern const fcml_cstring M_SUBSS; +extern const fcml_cstring M_SUBW; +extern const fcml_cstring M_SWAPGS; +extern const fcml_cstring M_SYSCALL; +extern const fcml_cstring M_SYSENTER; +extern const fcml_cstring M_SYSEXIT; +extern const fcml_cstring M_SYSRET; +extern const fcml_cstring M_T1MSKC; +extern const fcml_cstring M_TEST; +extern const fcml_cstring M_TESTB; +extern const fcml_cstring M_TESTL; +extern const fcml_cstring M_TESTQ; +extern const fcml_cstring M_TESTW; +extern const fcml_cstring M_TZCNT; +extern const fcml_cstring M_TZMSK; +extern const fcml_cstring M_UCOMISD; +extern const fcml_cstring M_UCOMISS; +extern const fcml_cstring M_UD2; +extern const fcml_cstring M_UNPCKHPD; +extern const fcml_cstring M_UNPCKHPS; +extern const fcml_cstring M_UNPCKLPD; +extern const fcml_cstring M_UNPCKLPS; +extern const fcml_cstring M_V4FMADDPS; +extern const fcml_cstring M_V4FMADDSS; +extern const fcml_cstring M_V4FNMADDPS; +extern const fcml_cstring M_V4FNMADDSS; +extern const fcml_cstring M_VADDPD; +extern const fcml_cstring M_VADDPS; +extern const fcml_cstring M_VADDSD; +extern const fcml_cstring M_VADDSS; +extern const fcml_cstring M_VADDSUBPD; +extern const fcml_cstring M_VADDSUBPS; +extern const fcml_cstring M_VAESDEC; +extern const fcml_cstring M_VAESDECLAST; +extern const fcml_cstring M_VAESENC; +extern const fcml_cstring M_VAESENCLAST; +extern const fcml_cstring M_VAESIMC; +extern const fcml_cstring M_VAESKEYGENASSIST; +extern const fcml_cstring M_VALIGND; +extern const fcml_cstring M_VALIGNQ; +extern const fcml_cstring M_VANDNPD; +extern const fcml_cstring M_VANDNPS; +extern const fcml_cstring M_VANDPD; +extern const fcml_cstring M_VANDPS; +extern const fcml_cstring M_VBLENDMPD; +extern const fcml_cstring M_VBLENDMPS; +extern const fcml_cstring M_VBLENDPD; +extern const fcml_cstring M_VBLENDPS; +extern const fcml_cstring M_VBLENDVPD; +extern const fcml_cstring M_VBLENDVPS; +extern const fcml_cstring M_VBROADCASTF128; +extern const fcml_cstring M_VBROADCASTF32X2; +extern const fcml_cstring M_VBROADCASTF32X4; +extern const fcml_cstring M_VBROADCASTF32X8; +extern const fcml_cstring M_VBROADCASTF64X2; +extern const fcml_cstring M_VBROADCASTF64X4; +extern const fcml_cstring M_VBROADCASTI128; +extern const fcml_cstring M_VBROADCASTI32X2; +extern const fcml_cstring M_VBROADCASTI32X4; +extern const fcml_cstring M_VBROADCASTI32X8; +extern const fcml_cstring M_VBROADCASTI64X2; +extern const fcml_cstring M_VBROADCASTI64X4; +extern const fcml_cstring M_VBROADCASTSD; +extern const fcml_cstring M_VBROADCASTSS; +extern const fcml_cstring M_VCMPEQ_OSPD; +extern const fcml_cstring M_VCMPEQ_OSPS; +extern const fcml_cstring M_VCMPEQ_OSSD; +extern const fcml_cstring M_VCMPEQ_OSSS; +extern const fcml_cstring M_VCMPEQ_UQPD; +extern const fcml_cstring M_VCMPEQ_UQPS; +extern const fcml_cstring M_VCMPEQ_UQSD; +extern const fcml_cstring M_VCMPEQ_UQSS; +extern const fcml_cstring M_VCMPEQ_USPD; +extern const fcml_cstring M_VCMPEQ_USPS; +extern const fcml_cstring M_VCMPEQ_USSD; +extern const fcml_cstring M_VCMPEQ_USSS; +extern const fcml_cstring M_VCMPEQPD; +extern const fcml_cstring M_VCMPEQPS; +extern const fcml_cstring M_VCMPEQSD; +extern const fcml_cstring M_VCMPEQSS; +extern const fcml_cstring M_VCMPFALSE_OSPD; +extern const fcml_cstring M_VCMPFALSE_OSPS; +extern const fcml_cstring M_VCMPFALSE_OSSD; +extern const fcml_cstring M_VCMPFALSE_OSSS; +extern const fcml_cstring M_VCMPFALSEPD; +extern const fcml_cstring M_VCMPFALSEPS; +extern const fcml_cstring M_VCMPFALSESD; +extern const fcml_cstring M_VCMPFALSESS; +extern const fcml_cstring M_VCMPGE_OQPD; +extern const fcml_cstring M_VCMPGE_OQPS; +extern const fcml_cstring M_VCMPGE_OQSD; +extern const fcml_cstring M_VCMPGE_OQSS; +extern const fcml_cstring M_VCMPGEPD; +extern const fcml_cstring M_VCMPGEPS; +extern const fcml_cstring M_VCMPGESD; +extern const fcml_cstring M_VCMPGESS; +extern const fcml_cstring M_VCMPGT_OQPD; +extern const fcml_cstring M_VCMPGT_OQPS; +extern const fcml_cstring M_VCMPGT_OQSD; +extern const fcml_cstring M_VCMPGT_OQSS; +extern const fcml_cstring M_VCMPGTPD; +extern const fcml_cstring M_VCMPGTPS; +extern const fcml_cstring M_VCMPGTSD; +extern const fcml_cstring M_VCMPGTSS; +extern const fcml_cstring M_VCMPLE_OQPD; +extern const fcml_cstring M_VCMPLE_OQPS; +extern const fcml_cstring M_VCMPLE_OQSD; +extern const fcml_cstring M_VCMPLE_OQSS; +extern const fcml_cstring M_VCMPLEPD; +extern const fcml_cstring M_VCMPLEPS; +extern const fcml_cstring M_VCMPLESD; +extern const fcml_cstring M_VCMPLESS; +extern const fcml_cstring M_VCMPLT_OQPD; +extern const fcml_cstring M_VCMPLT_OQPS; +extern const fcml_cstring M_VCMPLT_OQSD; +extern const fcml_cstring M_VCMPLT_OQSS; +extern const fcml_cstring M_VCMPLTPD; +extern const fcml_cstring M_VCMPLTPS; +extern const fcml_cstring M_VCMPLTSD; +extern const fcml_cstring M_VCMPLTSS; +extern const fcml_cstring M_VCMPNEQ_OQPD; +extern const fcml_cstring M_VCMPNEQ_OQPS; +extern const fcml_cstring M_VCMPNEQ_OQSD; +extern const fcml_cstring M_VCMPNEQ_OQSS; +extern const fcml_cstring M_VCMPNEQ_OSPD; +extern const fcml_cstring M_VCMPNEQ_OSPS; +extern const fcml_cstring M_VCMPNEQ_OSSD; +extern const fcml_cstring M_VCMPNEQ_OSSS; +extern const fcml_cstring M_VCMPNEQ_USPD; +extern const fcml_cstring M_VCMPNEQ_USPS; +extern const fcml_cstring M_VCMPNEQ_USSD; +extern const fcml_cstring M_VCMPNEQ_USSS; +extern const fcml_cstring M_VCMPNEQPD; +extern const fcml_cstring M_VCMPNEQPS; +extern const fcml_cstring M_VCMPNEQSD; +extern const fcml_cstring M_VCMPNEQSS; +extern const fcml_cstring M_VCMPNGE_UQPD; +extern const fcml_cstring M_VCMPNGE_UQPS; +extern const fcml_cstring M_VCMPNGE_UQSD; +extern const fcml_cstring M_VCMPNGE_UQSS; +extern const fcml_cstring M_VCMPNGEPD; +extern const fcml_cstring M_VCMPNGEPS; +extern const fcml_cstring M_VCMPNGESD; +extern const fcml_cstring M_VCMPNGESS; +extern const fcml_cstring M_VCMPNGT_UQPD; +extern const fcml_cstring M_VCMPNGT_UQPS; +extern const fcml_cstring M_VCMPNGT_UQSD; +extern const fcml_cstring M_VCMPNGT_UQSS; +extern const fcml_cstring M_VCMPNGTPD; +extern const fcml_cstring M_VCMPNGTPS; +extern const fcml_cstring M_VCMPNGTSD; +extern const fcml_cstring M_VCMPNGTSS; +extern const fcml_cstring M_VCMPNLE_UQPD; +extern const fcml_cstring M_VCMPNLE_UQPS; +extern const fcml_cstring M_VCMPNLE_UQSD; +extern const fcml_cstring M_VCMPNLE_UQSS; +extern const fcml_cstring M_VCMPNLEPD; +extern const fcml_cstring M_VCMPNLEPS; +extern const fcml_cstring M_VCMPNLESD; +extern const fcml_cstring M_VCMPNLESS; +extern const fcml_cstring M_VCMPNLT_UQPD; +extern const fcml_cstring M_VCMPNLT_UQPS; +extern const fcml_cstring M_VCMPNLT_UQSD; +extern const fcml_cstring M_VCMPNLT_UQSS; +extern const fcml_cstring M_VCMPNLTPD; +extern const fcml_cstring M_VCMPNLTPS; +extern const fcml_cstring M_VCMPNLTSD; +extern const fcml_cstring M_VCMPNLTSS; +extern const fcml_cstring M_VCMPORD_SPD; +extern const fcml_cstring M_VCMPORD_SPS; +extern const fcml_cstring M_VCMPORD_SSD; +extern const fcml_cstring M_VCMPORD_SSS; +extern const fcml_cstring M_VCMPORDPD; +extern const fcml_cstring M_VCMPORDPS; +extern const fcml_cstring M_VCMPORDSD; +extern const fcml_cstring M_VCMPORDSS; +extern const fcml_cstring M_VCMPPD; +extern const fcml_cstring M_VCMPPS; +extern const fcml_cstring M_VCMPSD; +extern const fcml_cstring M_VCMPSS; +extern const fcml_cstring M_VCMPTRUE_USPD; +extern const fcml_cstring M_VCMPTRUE_USPS; +extern const fcml_cstring M_VCMPTRUE_USSD; +extern const fcml_cstring M_VCMPTRUE_USSS; +extern const fcml_cstring M_VCMPTRUEPD; +extern const fcml_cstring M_VCMPTRUEPS; +extern const fcml_cstring M_VCMPTRUESD; +extern const fcml_cstring M_VCMPTRUESS; +extern const fcml_cstring M_VCMPUNORD_SPD; +extern const fcml_cstring M_VCMPUNORD_SPS; +extern const fcml_cstring M_VCMPUNORD_SSD; +extern const fcml_cstring M_VCMPUNORD_SSS; +extern const fcml_cstring M_VCMPUNORDPD; +extern const fcml_cstring M_VCMPUNORDPS; +extern const fcml_cstring M_VCMPUNORDSD; +extern const fcml_cstring M_VCMPUNORDSS; +extern const fcml_cstring M_VCOMISD; +extern const fcml_cstring M_VCOMISS; +extern const fcml_cstring M_VCOMPRESSPD; +extern const fcml_cstring M_VCOMPRESSPS; +extern const fcml_cstring M_VCVTDQ2PD; +extern const fcml_cstring M_VCVTDQ2PS; +extern const fcml_cstring M_VCVTPD2DQ; +extern const fcml_cstring M_VCVTPD2DQX; +extern const fcml_cstring M_VCVTPD2DQY; +extern const fcml_cstring M_VCVTPD2PS; +extern const fcml_cstring M_VCVTPD2PSX; +extern const fcml_cstring M_VCVTPD2PSY; +extern const fcml_cstring M_VCVTPD2QQ; +extern const fcml_cstring M_VCVTPD2UDQ; +extern const fcml_cstring M_VCVTPD2UDQX; +extern const fcml_cstring M_VCVTPD2UDQY; +extern const fcml_cstring M_VCVTPD2UQQ; +extern const fcml_cstring M_VCVTPH2PS; +extern const fcml_cstring M_VCVTPS2DQ; +extern const fcml_cstring M_VCVTPS2PD; +extern const fcml_cstring M_VCVTPS2PH; +extern const fcml_cstring M_VCVTPS2QQ; +extern const fcml_cstring M_VCVTPS2UDQ; +extern const fcml_cstring M_VCVTPS2UQQ; +extern const fcml_cstring M_VCVTQQ2PD; +extern const fcml_cstring M_VCVTQQ2PS; +extern const fcml_cstring M_VCVTQQ2PSX; +extern const fcml_cstring M_VCVTQQ2PSY; +extern const fcml_cstring M_VCVTSD2SI; +extern const fcml_cstring M_VCVTSD2SS; +extern const fcml_cstring M_VCVTSD2USI; +extern const fcml_cstring M_VCVTSI2SDL; +extern const fcml_cstring M_VCVTSI2SDQ; +extern const fcml_cstring M_VCVTSI2SSL; +extern const fcml_cstring M_VCVTSI2SSQ; +extern const fcml_cstring M_VCVTSS2SD; +extern const fcml_cstring M_VCVTSS2SI; +extern const fcml_cstring M_VCVTSS2USI; +extern const fcml_cstring M_VCVTTPD2DQ; +extern const fcml_cstring M_VCVTTPD2DQX; +extern const fcml_cstring M_VCVTTPD2DQY; +extern const fcml_cstring M_VCVTTPD2QQ; +extern const fcml_cstring M_VCVTTPD2UDQ; +extern const fcml_cstring M_VCVTTPD2UDQX; +extern const fcml_cstring M_VCVTTPD2UDQY; +extern const fcml_cstring M_VCVTTPD2UQQ; +extern const fcml_cstring M_VCVTTPS2DQ; +extern const fcml_cstring M_VCVTTPS2QQ; +extern const fcml_cstring M_VCVTTPS2UDQ; +extern const fcml_cstring M_VCVTTPS2UQQ; +extern const fcml_cstring M_VCVTTSD2SI; +extern const fcml_cstring M_VCVTTSD2USI; +extern const fcml_cstring M_VCVTTSS2SI; +extern const fcml_cstring M_VCVTTSS2USI; +extern const fcml_cstring M_VCVTUDQ2PD; +extern const fcml_cstring M_VCVTUDQ2PS; +extern const fcml_cstring M_VCVTUQQ2PD; +extern const fcml_cstring M_VCVTUQQ2PS; +extern const fcml_cstring M_VCVTUQQ2PSX; +extern const fcml_cstring M_VCVTUQQ2PSY; +extern const fcml_cstring M_VCVTUSI2SD; +extern const fcml_cstring M_VCVTUSI2SS; +extern const fcml_cstring M_VDBPSADBW; +extern const fcml_cstring M_VDIVPD; +extern const fcml_cstring M_VDIVPS; +extern const fcml_cstring M_VDIVSD; +extern const fcml_cstring M_VDIVSS; +extern const fcml_cstring M_VDPPD; +extern const fcml_cstring M_VDPPS; +extern const fcml_cstring M_VERR; +extern const fcml_cstring M_VERW; +extern const fcml_cstring M_VEXP2PD; +extern const fcml_cstring M_VEXP2PS; +extern const fcml_cstring M_VEXPANDPD; +extern const fcml_cstring M_VEXPANDPS; +extern const fcml_cstring M_VEXTRACTF128; +extern const fcml_cstring M_VEXTRACTF32X4; +extern const fcml_cstring M_VEXTRACTF32X8; +extern const fcml_cstring M_VEXTRACTF64X2; +extern const fcml_cstring M_VEXTRACTF64X4; +extern const fcml_cstring M_VEXTRACTI128; +extern const fcml_cstring M_VEXTRACTI32X4; +extern const fcml_cstring M_VEXTRACTI32X8; +extern const fcml_cstring M_VEXTRACTI64X2; +extern const fcml_cstring M_VEXTRACTI64X4; +extern const fcml_cstring M_VEXTRACTPS; +extern const fcml_cstring M_VFIXUPIMMPD; +extern const fcml_cstring M_VFIXUPIMMPS; +extern const fcml_cstring M_VFIXUPIMMSD; +extern const fcml_cstring M_VFIXUPIMMSS; +extern const fcml_cstring M_VFMADD132PD; +extern const fcml_cstring M_VFMADD132PS; +extern const fcml_cstring M_VFMADD132SD; +extern const fcml_cstring M_VFMADD132SS; +extern const fcml_cstring M_VFMADD213PD; +extern const fcml_cstring M_VFMADD213PS; +extern const fcml_cstring M_VFMADD213SD; +extern const fcml_cstring M_VFMADD213SS; +extern const fcml_cstring M_VFMADD231PD; +extern const fcml_cstring M_VFMADD231PS; +extern const fcml_cstring M_VFMADD231SD; +extern const fcml_cstring M_VFMADD231SS; +extern const fcml_cstring M_VFMADDPD; +extern const fcml_cstring M_VFMADDPS; +extern const fcml_cstring M_VFMADDSD; +extern const fcml_cstring M_VFMADDSS; +extern const fcml_cstring M_VFMADDSUB132PD; +extern const fcml_cstring M_VFMADDSUB132PS; +extern const fcml_cstring M_VFMADDSUB213PD; +extern const fcml_cstring M_VFMADDSUB213PS; +extern const fcml_cstring M_VFMADDSUB231PD; +extern const fcml_cstring M_VFMADDSUB231PS; +extern const fcml_cstring M_VFMADDSUBPD; +extern const fcml_cstring M_VFMADDSUBPS; +extern const fcml_cstring M_VFMSUB132PD; +extern const fcml_cstring M_VFMSUB132PS; +extern const fcml_cstring M_VFMSUB132SD; +extern const fcml_cstring M_VFMSUB132SS; +extern const fcml_cstring M_VFMSUB213PD; +extern const fcml_cstring M_VFMSUB213PS; +extern const fcml_cstring M_VFMSUB213SD; +extern const fcml_cstring M_VFMSUB213SS; +extern const fcml_cstring M_VFMSUB231PD; +extern const fcml_cstring M_VFMSUB231PS; +extern const fcml_cstring M_VFMSUB231SD; +extern const fcml_cstring M_VFMSUB231SS; +extern const fcml_cstring M_VFMSUBADD132PD; +extern const fcml_cstring M_VFMSUBADD132PS; +extern const fcml_cstring M_VFMSUBADD213PD; +extern const fcml_cstring M_VFMSUBADD213PS; +extern const fcml_cstring M_VFMSUBADD231PD; +extern const fcml_cstring M_VFMSUBADD231PS; +extern const fcml_cstring M_VFMSUBADDPD; +extern const fcml_cstring M_VFMSUBADDPS; +extern const fcml_cstring M_VFMSUBPD; +extern const fcml_cstring M_VFMSUBPS; +extern const fcml_cstring M_VFMSUBSD; +extern const fcml_cstring M_VFMSUBSS; +extern const fcml_cstring M_VFNMADD132PD; +extern const fcml_cstring M_VFNMADD132PS; +extern const fcml_cstring M_VFNMADD132SD; +extern const fcml_cstring M_VFNMADD132SS; +extern const fcml_cstring M_VFNMADD213PD; +extern const fcml_cstring M_VFNMADD213PS; +extern const fcml_cstring M_VFNMADD213SD; +extern const fcml_cstring M_VFNMADD213SS; +extern const fcml_cstring M_VFNMADD231PD; +extern const fcml_cstring M_VFNMADD231PS; +extern const fcml_cstring M_VFNMADD231SD; +extern const fcml_cstring M_VFNMADD231SS; +extern const fcml_cstring M_VFNMADDPD; +extern const fcml_cstring M_VFNMADDPS; +extern const fcml_cstring M_VFNMADDSD; +extern const fcml_cstring M_VFNMADDSS; +extern const fcml_cstring M_VFNMSUB132PD; +extern const fcml_cstring M_VFNMSUB132PS; +extern const fcml_cstring M_VFNMSUB132SD; +extern const fcml_cstring M_VFNMSUB132SS; +extern const fcml_cstring M_VFNMSUB213PD; +extern const fcml_cstring M_VFNMSUB213PS; +extern const fcml_cstring M_VFNMSUB213SD; +extern const fcml_cstring M_VFNMSUB213SS; +extern const fcml_cstring M_VFNMSUB231PD; +extern const fcml_cstring M_VFNMSUB231PS; +extern const fcml_cstring M_VFNMSUB231SD; +extern const fcml_cstring M_VFNMSUB231SS; +extern const fcml_cstring M_VFNMSUBPD; +extern const fcml_cstring M_VFNMSUBPS; +extern const fcml_cstring M_VFNMSUBSD; +extern const fcml_cstring M_VFNMSUBSS; +extern const fcml_cstring M_VFPCLASSPD; +extern const fcml_cstring M_VFPCLASSPS; +extern const fcml_cstring M_VFPCLASSSD; +extern const fcml_cstring M_VFPCLASSSS; +extern const fcml_cstring M_VFRCZPD; +extern const fcml_cstring M_VFRCZPS; +extern const fcml_cstring M_VFRCZSD; +extern const fcml_cstring M_VFRCZSS; +extern const fcml_cstring M_VGATHERDPD; +extern const fcml_cstring M_VGATHERDPS; +extern const fcml_cstring M_VGATHERPF0DPD; +extern const fcml_cstring M_VGATHERPF0DPS; +extern const fcml_cstring M_VGATHERPF0QPD; +extern const fcml_cstring M_VGATHERPF0QPS; +extern const fcml_cstring M_VGATHERPF1DPD; +extern const fcml_cstring M_VGATHERPF1DPS; +extern const fcml_cstring M_VGATHERPF1QPD; +extern const fcml_cstring M_VGATHERPF1QPS; +extern const fcml_cstring M_VGATHERQPD; +extern const fcml_cstring M_VGATHERQPS; +extern const fcml_cstring M_VGETEXPPD; +extern const fcml_cstring M_VGETEXPPS; +extern const fcml_cstring M_VGETEXPSD; +extern const fcml_cstring M_VGETEXPSS; +extern const fcml_cstring M_VGETMANTPD; +extern const fcml_cstring M_VGETMANTPS; +extern const fcml_cstring M_VGETMANTSD; +extern const fcml_cstring M_VGETMANTSS; +extern const fcml_cstring M_VHADDPD; +extern const fcml_cstring M_VHADDPS; +extern const fcml_cstring M_VHSUBPD; +extern const fcml_cstring M_VHSUBPS; +extern const fcml_cstring M_VINSERTF128; +extern const fcml_cstring M_VINSERTF32X4; +extern const fcml_cstring M_VINSERTF32X8; +extern const fcml_cstring M_VINSERTF64X2; +extern const fcml_cstring M_VINSERTF64X4; +extern const fcml_cstring M_VINSERTI128; +extern const fcml_cstring M_VINSERTI32X4; +extern const fcml_cstring M_VINSERTI32X8; +extern const fcml_cstring M_VINSERTI64X2; +extern const fcml_cstring M_VINSERTI64X4; +extern const fcml_cstring M_VINSERTPS; +extern const fcml_cstring M_VLDDQU; +extern const fcml_cstring M_VLDMXCSR; +extern const fcml_cstring M_VMASKMOVDQU; +extern const fcml_cstring M_VMASKMOVPD; +extern const fcml_cstring M_VMASKMOVPS; +extern const fcml_cstring M_VMAXPD; +extern const fcml_cstring M_VMAXPS; +extern const fcml_cstring M_VMAXSD; +extern const fcml_cstring M_VMAXSS; +extern const fcml_cstring M_VMCALL; +extern const fcml_cstring M_VMCLEAR; +extern const fcml_cstring M_VMFUNC; +extern const fcml_cstring M_VMINPD; +extern const fcml_cstring M_VMINPS; +extern const fcml_cstring M_VMINSD; +extern const fcml_cstring M_VMINSS; +extern const fcml_cstring M_VMLAUNCH; +extern const fcml_cstring M_VMLOAD; +extern const fcml_cstring M_VMMCALL; +extern const fcml_cstring M_VMOVAPD; +extern const fcml_cstring M_VMOVAPS; +extern const fcml_cstring M_VMOVD; +extern const fcml_cstring M_VMOVDDUP; +extern const fcml_cstring M_VMOVDQA; +extern const fcml_cstring M_VMOVDQA32; +extern const fcml_cstring M_VMOVDQA64; +extern const fcml_cstring M_VMOVDQU; +extern const fcml_cstring M_VMOVDQU16; +extern const fcml_cstring M_VMOVDQU32; +extern const fcml_cstring M_VMOVDQU64; +extern const fcml_cstring M_VMOVDQU8; +extern const fcml_cstring M_VMOVHLPS; +extern const fcml_cstring M_VMOVHPD; +extern const fcml_cstring M_VMOVHPS; +extern const fcml_cstring M_VMOVLHPS; +extern const fcml_cstring M_VMOVLPD; +extern const fcml_cstring M_VMOVLPS; +extern const fcml_cstring M_VMOVMSKPD; +extern const fcml_cstring M_VMOVMSKPS; +extern const fcml_cstring M_VMOVNTDQ; +extern const fcml_cstring M_VMOVNTDQA; +extern const fcml_cstring M_VMOVNTPD; +extern const fcml_cstring M_VMOVNTPS; +extern const fcml_cstring M_VMOVQ; +extern const fcml_cstring M_VMOVSD; +extern const fcml_cstring M_VMOVSHDUP; +extern const fcml_cstring M_VMOVSLDUP; +extern const fcml_cstring M_VMOVSS; +extern const fcml_cstring M_VMOVUPD; +extern const fcml_cstring M_VMOVUPS; +extern const fcml_cstring M_VMPSADBW; +extern const fcml_cstring M_VMPTRLD; +extern const fcml_cstring M_VMPTRST; +extern const fcml_cstring M_VMREAD; +extern const fcml_cstring M_VMRESUME; +extern const fcml_cstring M_VMRUN; +extern const fcml_cstring M_VMSAVE; +extern const fcml_cstring M_VMULPD; +extern const fcml_cstring M_VMULPS; +extern const fcml_cstring M_VMULSD; +extern const fcml_cstring M_VMULSS; +extern const fcml_cstring M_VMWRITE; +extern const fcml_cstring M_VMXOFF; +extern const fcml_cstring M_VMXON; +extern const fcml_cstring M_VORPD; +extern const fcml_cstring M_VORPS; +extern const fcml_cstring M_VP4DPWSSD; +extern const fcml_cstring M_VP4DPWSSDS; +extern const fcml_cstring M_VPABSB; +extern const fcml_cstring M_VPABSD; +extern const fcml_cstring M_VPABSQ; +extern const fcml_cstring M_VPABSW; +extern const fcml_cstring M_VPACKSSDW; +extern const fcml_cstring M_VPACKSSWB; +extern const fcml_cstring M_VPACKUSDW; +extern const fcml_cstring M_VPACKUSWB; +extern const fcml_cstring M_VPADDB; +extern const fcml_cstring M_VPADDD; +extern const fcml_cstring M_VPADDQ; +extern const fcml_cstring M_VPADDSB; +extern const fcml_cstring M_VPADDSW; +extern const fcml_cstring M_VPADDUSB; +extern const fcml_cstring M_VPADDUSW; +extern const fcml_cstring M_VPADDW; +extern const fcml_cstring M_VPALIGNR; +extern const fcml_cstring M_VPAND; +extern const fcml_cstring M_VPANDD; +extern const fcml_cstring M_VPANDN; +extern const fcml_cstring M_VPANDND; +extern const fcml_cstring M_VPANDNQ; +extern const fcml_cstring M_VPANDQ; +extern const fcml_cstring M_VPAVGB; +extern const fcml_cstring M_VPAVGW; +extern const fcml_cstring M_VPBLENDD; +extern const fcml_cstring M_VPBLENDMB; +extern const fcml_cstring M_VPBLENDMD; +extern const fcml_cstring M_VPBLENDMQ; +extern const fcml_cstring M_VPBLENDMW; +extern const fcml_cstring M_VPBLENDVB; +extern const fcml_cstring M_VPBLENDW; +extern const fcml_cstring M_VPBROADCASTB; +extern const fcml_cstring M_VPBROADCASTD; +extern const fcml_cstring M_VPBROADCASTMB2Q; +extern const fcml_cstring M_VPBROADCASTMW2D; +extern const fcml_cstring M_VPBROADCASTQ; +extern const fcml_cstring M_VPBROADCASTW; +extern const fcml_cstring M_VPCLMULQDQ; +extern const fcml_cstring M_VPCMOV; +extern const fcml_cstring M_VPCMPB; +extern const fcml_cstring M_VPCMPD; +extern const fcml_cstring M_VPCMPEQB; +extern const fcml_cstring M_VPCMPEQD; +extern const fcml_cstring M_VPCMPEQQ; +extern const fcml_cstring M_VPCMPEQW; +extern const fcml_cstring M_VPCMPESTRI; +extern const fcml_cstring M_VPCMPESTRM; +extern const fcml_cstring M_VPCMPGTB; +extern const fcml_cstring M_VPCMPGTD; +extern const fcml_cstring M_VPCMPGTQ; +extern const fcml_cstring M_VPCMPGTW; +extern const fcml_cstring M_VPCMPISTRI; +extern const fcml_cstring M_VPCMPISTRM; +extern const fcml_cstring M_VPCMPQ; +extern const fcml_cstring M_VPCMPUB; +extern const fcml_cstring M_VPCMPUD; +extern const fcml_cstring M_VPCMPUQ; +extern const fcml_cstring M_VPCMPUW; +extern const fcml_cstring M_VPCMPW; +extern const fcml_cstring M_VPCOMB; +extern const fcml_cstring M_VPCOMD; +extern const fcml_cstring M_VPCOMEQB; +extern const fcml_cstring M_VPCOMEQD; +extern const fcml_cstring M_VPCOMEQQ; +extern const fcml_cstring M_VPCOMEQUB; +extern const fcml_cstring M_VPCOMEQUD; +extern const fcml_cstring M_VPCOMEQUQ; +extern const fcml_cstring M_VPCOMEQUW; +extern const fcml_cstring M_VPCOMEQW; +extern const fcml_cstring M_VPCOMFALSEB; +extern const fcml_cstring M_VPCOMFALSED; +extern const fcml_cstring M_VPCOMFALSEQ; +extern const fcml_cstring M_VPCOMFALSEUB; +extern const fcml_cstring M_VPCOMFALSEUD; +extern const fcml_cstring M_VPCOMFALSEUQ; +extern const fcml_cstring M_VPCOMFALSEUW; +extern const fcml_cstring M_VPCOMFALSEW; +extern const fcml_cstring M_VPCOMGEB; +extern const fcml_cstring M_VPCOMGED; +extern const fcml_cstring M_VPCOMGEQ; +extern const fcml_cstring M_VPCOMGEUB; +extern const fcml_cstring M_VPCOMGEUD; +extern const fcml_cstring M_VPCOMGEUQ; +extern const fcml_cstring M_VPCOMGEUW; +extern const fcml_cstring M_VPCOMGEW; +extern const fcml_cstring M_VPCOMGTB; +extern const fcml_cstring M_VPCOMGTD; +extern const fcml_cstring M_VPCOMGTQ; +extern const fcml_cstring M_VPCOMGTUB; +extern const fcml_cstring M_VPCOMGTUD; +extern const fcml_cstring M_VPCOMGTUQ; +extern const fcml_cstring M_VPCOMGTUW; +extern const fcml_cstring M_VPCOMGTW; +extern const fcml_cstring M_VPCOMLEB; +extern const fcml_cstring M_VPCOMLED; +extern const fcml_cstring M_VPCOMLEQ; +extern const fcml_cstring M_VPCOMLEUB; +extern const fcml_cstring M_VPCOMLEUD; +extern const fcml_cstring M_VPCOMLEUQ; +extern const fcml_cstring M_VPCOMLEUW; +extern const fcml_cstring M_VPCOMLEW; +extern const fcml_cstring M_VPCOMLTB; +extern const fcml_cstring M_VPCOMLTD; +extern const fcml_cstring M_VPCOMLTQ; +extern const fcml_cstring M_VPCOMLTUB; +extern const fcml_cstring M_VPCOMLTUD; +extern const fcml_cstring M_VPCOMLTUQ; +extern const fcml_cstring M_VPCOMLTUW; +extern const fcml_cstring M_VPCOMLTW; +extern const fcml_cstring M_VPCOMNEQB; +extern const fcml_cstring M_VPCOMNEQD; +extern const fcml_cstring M_VPCOMNEQQ; +extern const fcml_cstring M_VPCOMNEQUB; +extern const fcml_cstring M_VPCOMNEQUD; +extern const fcml_cstring M_VPCOMNEQUQ; +extern const fcml_cstring M_VPCOMNEQUW; +extern const fcml_cstring M_VPCOMNEQW; +extern const fcml_cstring M_VPCOMPRESSD; +extern const fcml_cstring M_VPCOMPRESSQ; +extern const fcml_cstring M_VPCOMQ; +extern const fcml_cstring M_VPCOMTRUEB; +extern const fcml_cstring M_VPCOMTRUED; +extern const fcml_cstring M_VPCOMTRUEQ; +extern const fcml_cstring M_VPCOMTRUEUB; +extern const fcml_cstring M_VPCOMTRUEUD; +extern const fcml_cstring M_VPCOMTRUEUQ; +extern const fcml_cstring M_VPCOMTRUEUW; +extern const fcml_cstring M_VPCOMTRUEW; +extern const fcml_cstring M_VPCOMUB; +extern const fcml_cstring M_VPCOMUD; +extern const fcml_cstring M_VPCOMUQ; +extern const fcml_cstring M_VPCOMUW; +extern const fcml_cstring M_VPCOMW; +extern const fcml_cstring M_VPERM2F128; +extern const fcml_cstring M_VPERM2I128; +extern const fcml_cstring M_VPERMB; +extern const fcml_cstring M_VPERMD; +extern const fcml_cstring M_VPERMI2B; +extern const fcml_cstring M_VPERMI2D; +extern const fcml_cstring M_VPERMI2PD; +extern const fcml_cstring M_VPERMI2PS; +extern const fcml_cstring M_VPERMI2Q; +extern const fcml_cstring M_VPERMI2W; +extern const fcml_cstring M_VPERMIL2PD; +extern const fcml_cstring M_VPERMIL2PS; +extern const fcml_cstring M_VPERMILPD; +extern const fcml_cstring M_VPERMILPS; +extern const fcml_cstring M_VPERMPD; +extern const fcml_cstring M_VPERMPS; +extern const fcml_cstring M_VPERMQ; +extern const fcml_cstring M_VPERMT2B; +extern const fcml_cstring M_VPERMT2D; +extern const fcml_cstring M_VPERMT2PD; +extern const fcml_cstring M_VPERMT2PS; +extern const fcml_cstring M_VPERMT2Q; +extern const fcml_cstring M_VPERMT2W; +extern const fcml_cstring M_VPERMW; +extern const fcml_cstring M_VPEXPANDD; +extern const fcml_cstring M_VPEXPANDQ; +extern const fcml_cstring M_VPEXTRB; +extern const fcml_cstring M_VPEXTRD; +extern const fcml_cstring M_VPEXTRQ; +extern const fcml_cstring M_VPEXTRW; +extern const fcml_cstring M_VPGATHERDD; +extern const fcml_cstring M_VPGATHERDQ; +extern const fcml_cstring M_VPGATHERQD; +extern const fcml_cstring M_VPGATHERQQ; +extern const fcml_cstring M_VPHADDBD; +extern const fcml_cstring M_VPHADDBQ; +extern const fcml_cstring M_VPHADDBW; +extern const fcml_cstring M_VPHADDD; +extern const fcml_cstring M_VPHADDDQ; +extern const fcml_cstring M_VPHADDSW; +extern const fcml_cstring M_VPHADDUBD; +extern const fcml_cstring M_VPHADDUBQ; +extern const fcml_cstring M_VPHADDUBW; +extern const fcml_cstring M_VPHADDUDQ; +extern const fcml_cstring M_VPHADDUWD; +extern const fcml_cstring M_VPHADDUWQ; +extern const fcml_cstring M_VPHADDW; +extern const fcml_cstring M_VPHADDWD; +extern const fcml_cstring M_VPHADDWQ; +extern const fcml_cstring M_VPHMINPOSUW; +extern const fcml_cstring M_VPHSUBBW; +extern const fcml_cstring M_VPHSUBD; +extern const fcml_cstring M_VPHSUBDQ; +extern const fcml_cstring M_VPHSUBSW; +extern const fcml_cstring M_VPHSUBW; +extern const fcml_cstring M_VPHSUBWD; +extern const fcml_cstring M_VPINSRB; +extern const fcml_cstring M_VPINSRD; +extern const fcml_cstring M_VPINSRQ; +extern const fcml_cstring M_VPINSRW; +extern const fcml_cstring M_VPLZCNTD; +extern const fcml_cstring M_VPLZCNTQ; +extern const fcml_cstring M_VPMACSDD; +extern const fcml_cstring M_VPMACSDQH; +extern const fcml_cstring M_VPMACSDQL; +extern const fcml_cstring M_VPMACSSDD; +extern const fcml_cstring M_VPMACSSDQH; +extern const fcml_cstring M_VPMACSSDQL; +extern const fcml_cstring M_VPMACSSWD; +extern const fcml_cstring M_VPMACSSWW; +extern const fcml_cstring M_VPMACSWD; +extern const fcml_cstring M_VPMACSWW; +extern const fcml_cstring M_VPMADCSSWD; +extern const fcml_cstring M_VPMADCSWD; +extern const fcml_cstring M_VPMADD52HUQ; +extern const fcml_cstring M_VPMADD52LUQ; +extern const fcml_cstring M_VPMADDUBSW; +extern const fcml_cstring M_VPMADDWD; +extern const fcml_cstring M_VPMASKMOV; +extern const fcml_cstring M_VPMASKMOVD; +extern const fcml_cstring M_VPMASKMOVQ; +extern const fcml_cstring M_VPMAXSB; +extern const fcml_cstring M_VPMAXSD; +extern const fcml_cstring M_VPMAXSQ; +extern const fcml_cstring M_VPMAXSW; +extern const fcml_cstring M_VPMAXUB; +extern const fcml_cstring M_VPMAXUD; +extern const fcml_cstring M_VPMAXUQ; +extern const fcml_cstring M_VPMAXUW; +extern const fcml_cstring M_VPMINSB; +extern const fcml_cstring M_VPMINSD; +extern const fcml_cstring M_VPMINSQ; +extern const fcml_cstring M_VPMINSW; +extern const fcml_cstring M_VPMINUB; +extern const fcml_cstring M_VPMINUD; +extern const fcml_cstring M_VPMINUQ; +extern const fcml_cstring M_VPMINUW; +extern const fcml_cstring M_VPMOVB2M; +extern const fcml_cstring M_VPMOVD2M; +extern const fcml_cstring M_VPMOVDB; +extern const fcml_cstring M_VPMOVDW; +extern const fcml_cstring M_VPMOVM2B; +extern const fcml_cstring M_VPMOVM2D; +extern const fcml_cstring M_VPMOVM2Q; +extern const fcml_cstring M_VPMOVM2W; +extern const fcml_cstring M_VPMOVMSKB; +extern const fcml_cstring M_VPMOVQ2M; +extern const fcml_cstring M_VPMOVQB; +extern const fcml_cstring M_VPMOVQD; +extern const fcml_cstring M_VPMOVQW; +extern const fcml_cstring M_VPMOVSDB; +extern const fcml_cstring M_VPMOVSDW; +extern const fcml_cstring M_VPMOVSQB; +extern const fcml_cstring M_VPMOVSQD; +extern const fcml_cstring M_VPMOVSQW; +extern const fcml_cstring M_VPMOVSWB; +extern const fcml_cstring M_VPMOVSXBD; +extern const fcml_cstring M_VPMOVSXBQ; +extern const fcml_cstring M_VPMOVSXBW; +extern const fcml_cstring M_VPMOVSXDQ; +extern const fcml_cstring M_VPMOVSXWD; +extern const fcml_cstring M_VPMOVSXWQ; +extern const fcml_cstring M_VPMOVUSDB; +extern const fcml_cstring M_VPMOVUSDW; +extern const fcml_cstring M_VPMOVUSQB; +extern const fcml_cstring M_VPMOVUSQD; +extern const fcml_cstring M_VPMOVUSQW; +extern const fcml_cstring M_VPMOVUSWB; +extern const fcml_cstring M_VPMOVW2M; +extern const fcml_cstring M_VPMOVWB; +extern const fcml_cstring M_VPMOVZXBD; +extern const fcml_cstring M_VPMOVZXBQ; +extern const fcml_cstring M_VPMOVZXBW; +extern const fcml_cstring M_VPMOVZXDQ; +extern const fcml_cstring M_VPMOVZXWD; +extern const fcml_cstring M_VPMOVZXWQ; +extern const fcml_cstring M_VPMULDQ; +extern const fcml_cstring M_VPMULHRSW; +extern const fcml_cstring M_VPMULHUW; +extern const fcml_cstring M_VPMULHW; +extern const fcml_cstring M_VPMULLD; +extern const fcml_cstring M_VPMULLQ; +extern const fcml_cstring M_VPMULLW; +extern const fcml_cstring M_VPMULTISHIFTQB; +extern const fcml_cstring M_VPMULUDQ; +extern const fcml_cstring M_VPOR; +extern const fcml_cstring M_VPORD; +extern const fcml_cstring M_VPORQ; +extern const fcml_cstring M_VPPERM; +extern const fcml_cstring M_VPROLD; +extern const fcml_cstring M_VPROLQ; +extern const fcml_cstring M_VPROLVD; +extern const fcml_cstring M_VPROLVQ; +extern const fcml_cstring M_VPRORD; +extern const fcml_cstring M_VPRORQ; +extern const fcml_cstring M_VPRORVD; +extern const fcml_cstring M_VPRORVQ; +extern const fcml_cstring M_VPROTB; +extern const fcml_cstring M_VPROTD; +extern const fcml_cstring M_VPROTQ; +extern const fcml_cstring M_VPROTW; +extern const fcml_cstring M_VPSADBW; +extern const fcml_cstring M_VPSCATTERDD; +extern const fcml_cstring M_VPSCATTERDQ; +extern const fcml_cstring M_VPSCATTERQD; +extern const fcml_cstring M_VPSCATTERQQ; +extern const fcml_cstring M_VPSHAB; +extern const fcml_cstring M_VPSHAD; +extern const fcml_cstring M_VPSHAQ; +extern const fcml_cstring M_VPSHAW; +extern const fcml_cstring M_VPSHLB; +extern const fcml_cstring M_VPSHLD; +extern const fcml_cstring M_VPSHLQ; +extern const fcml_cstring M_VPSHLW; +extern const fcml_cstring M_VPSHUFB; +extern const fcml_cstring M_VPSHUFD; +extern const fcml_cstring M_VPSHUFHW; +extern const fcml_cstring M_VPSHUFLW; +extern const fcml_cstring M_VPSIGNB; +extern const fcml_cstring M_VPSIGND; +extern const fcml_cstring M_VPSIGNW; +extern const fcml_cstring M_VPSLLD; +extern const fcml_cstring M_VPSLLDQ; +extern const fcml_cstring M_VPSLLQ; +extern const fcml_cstring M_VPSLLVD; +extern const fcml_cstring M_VPSLLVQ; +extern const fcml_cstring M_VPSLLVW; +extern const fcml_cstring M_VPSLLW; +extern const fcml_cstring M_VPSRAD; +extern const fcml_cstring M_VPSRAQ; +extern const fcml_cstring M_VPSRAVD; +extern const fcml_cstring M_VPSRAVQ; +extern const fcml_cstring M_VPSRAVW; +extern const fcml_cstring M_VPSRAW; +extern const fcml_cstring M_VPSRLD; +extern const fcml_cstring M_VPSRLDQ; +extern const fcml_cstring M_VPSRLQ; +extern const fcml_cstring M_VPSRLVD; +extern const fcml_cstring M_VPSRLVQ; +extern const fcml_cstring M_VPSRLVW; +extern const fcml_cstring M_VPSRLW; +extern const fcml_cstring M_VPSUBB; +extern const fcml_cstring M_VPSUBD; +extern const fcml_cstring M_VPSUBQ; +extern const fcml_cstring M_VPSUBSB; +extern const fcml_cstring M_VPSUBSW; +extern const fcml_cstring M_VPSUBUSB; +extern const fcml_cstring M_VPSUBUSW; +extern const fcml_cstring M_VPSUBW; +extern const fcml_cstring M_VPTERNLOGD; +extern const fcml_cstring M_VPTERNLOGQ; +extern const fcml_cstring M_VPTEST; +extern const fcml_cstring M_VPTESTMB; +extern const fcml_cstring M_VPTESTMD; +extern const fcml_cstring M_VPTESTMQ; +extern const fcml_cstring M_VPTESTMW; +extern const fcml_cstring M_VPTESTNMB; +extern const fcml_cstring M_VPTESTNMD; +extern const fcml_cstring M_VPTESTNMQ; +extern const fcml_cstring M_VPTESTNMW; +extern const fcml_cstring M_VPUNPCKHBW; +extern const fcml_cstring M_VPUNPCKHDQ; +extern const fcml_cstring M_VPUNPCKHQDQ; +extern const fcml_cstring M_VPUNPCKHWD; +extern const fcml_cstring M_VPUNPCKLBW; +extern const fcml_cstring M_VPUNPCKLDQ; +extern const fcml_cstring M_VPUNPCKLQDQ; +extern const fcml_cstring M_VPUNPCKLWD; +extern const fcml_cstring M_VPXOR; +extern const fcml_cstring M_VPXORD; +extern const fcml_cstring M_VPXORQ; +extern const fcml_cstring M_VRANGEPD; +extern const fcml_cstring M_VRANGEPS; +extern const fcml_cstring M_VRANGESD; +extern const fcml_cstring M_VRANGESS; +extern const fcml_cstring M_VRCP14PD; +extern const fcml_cstring M_VRCP14PS; +extern const fcml_cstring M_VRCP14SD; +extern const fcml_cstring M_VRCP14SS; +extern const fcml_cstring M_VRCP28PD; +extern const fcml_cstring M_VRCP28PS; +extern const fcml_cstring M_VRCP28SD; +extern const fcml_cstring M_VRCP28SS; +extern const fcml_cstring M_VRCPPS; +extern const fcml_cstring M_VRCPSS; +extern const fcml_cstring M_VREDUCEPD; +extern const fcml_cstring M_VREDUCEPS; +extern const fcml_cstring M_VREDUCESD; +extern const fcml_cstring M_VREDUCESS; +extern const fcml_cstring M_VRNDSCALEPD; +extern const fcml_cstring M_VRNDSCALEPS; +extern const fcml_cstring M_VRNDSCALESD; +extern const fcml_cstring M_VRNDSCALESS; +extern const fcml_cstring M_VROUNDPD; +extern const fcml_cstring M_VROUNDPS; +extern const fcml_cstring M_VROUNDSD; +extern const fcml_cstring M_VROUNDSS; +extern const fcml_cstring M_VRSQRT14PD; +extern const fcml_cstring M_VRSQRT14PS; +extern const fcml_cstring M_VRSQRT14SD; +extern const fcml_cstring M_VRSQRT14SS; +extern const fcml_cstring M_VRSQRT28PD; +extern const fcml_cstring M_VRSQRT28PS; +extern const fcml_cstring M_VRSQRT28SD; +extern const fcml_cstring M_VRSQRT28SS; +extern const fcml_cstring M_VRSQRTPS; +extern const fcml_cstring M_VRSQRTSS; +extern const fcml_cstring M_VSCALEFPD; +extern const fcml_cstring M_VSCALEFPS; +extern const fcml_cstring M_VSCALEFSD; +extern const fcml_cstring M_VSCALEFSS; +extern const fcml_cstring M_VSCATTERDPD; +extern const fcml_cstring M_VSCATTERDPS; +extern const fcml_cstring M_VSCATTERPF0DPD; +extern const fcml_cstring M_VSCATTERPF0DPS; +extern const fcml_cstring M_VSCATTERPF0QPD; +extern const fcml_cstring M_VSCATTERPF0QPS; +extern const fcml_cstring M_VSCATTERPF1DPD; +extern const fcml_cstring M_VSCATTERPF1DPS; +extern const fcml_cstring M_VSCATTERPF1QPD; +extern const fcml_cstring M_VSCATTERPF1QPS; +extern const fcml_cstring M_VSCATTERQPD; +extern const fcml_cstring M_VSCATTERQPS; +extern const fcml_cstring M_VSHUFF32X4; +extern const fcml_cstring M_VSHUFF64X2; +extern const fcml_cstring M_VSHUFI32X4; +extern const fcml_cstring M_VSHUFI64X2; +extern const fcml_cstring M_VSHUFPD; +extern const fcml_cstring M_VSHUFPS; +extern const fcml_cstring M_VSQRTPD; +extern const fcml_cstring M_VSQRTPS; +extern const fcml_cstring M_VSQRTSD; +extern const fcml_cstring M_VSQRTSS; +extern const fcml_cstring M_VSTMXCSR; +extern const fcml_cstring M_VSUBPD; +extern const fcml_cstring M_VSUBPS; +extern const fcml_cstring M_VSUBSD; +extern const fcml_cstring M_VSUBSS; +extern const fcml_cstring M_VTESTPD; +extern const fcml_cstring M_VTESTPS; +extern const fcml_cstring M_VUCOMISD; +extern const fcml_cstring M_VUCOMISS; +extern const fcml_cstring M_VUNPCKHPD; +extern const fcml_cstring M_VUNPCKHPS; +extern const fcml_cstring M_VUNPCKLPD; +extern const fcml_cstring M_VUNPCKLPS; +extern const fcml_cstring M_VXORPD; +extern const fcml_cstring M_VXORPS; +extern const fcml_cstring M_VZEROALL; +extern const fcml_cstring M_VZEROUPPER; +extern const fcml_cstring M_WAIT; +extern const fcml_cstring M_WBINVD; +extern const fcml_cstring M_WRFSBASE; +extern const fcml_cstring M_WRGSBASE; +extern const fcml_cstring M_WRMSR; +extern const fcml_cstring M_XABORT; +extern const fcml_cstring M_XADD; +extern const fcml_cstring M_XBEGIN; +extern const fcml_cstring M_XCHG; +extern const fcml_cstring M_XEND; +extern const fcml_cstring M_XGETBV; +extern const fcml_cstring M_XLAT; +extern const fcml_cstring M_XLATB; +extern const fcml_cstring M_XOR; +extern const fcml_cstring M_XORB; +extern const fcml_cstring M_XORL; +extern const fcml_cstring M_XORPD; +extern const fcml_cstring M_XORPS; +extern const fcml_cstring M_XORQ; +extern const fcml_cstring M_XORW; +extern const fcml_cstring M_XRSTOR; +extern const fcml_cstring M_XRSTOR64; +extern const fcml_cstring M_XSAVE; +extern const fcml_cstring M_XSAVE64; +extern const fcml_cstring M_XSAVEOPT; +extern const fcml_cstring M_XSAVEOPT64; +extern const fcml_cstring M_XSETBV; +extern const fcml_cstring M_XTEST; + +} +} + +#endif /* FCML_GAS_MNEMONICS_HPP_ */ diff --git a/dependencies/fcml/include/fcml_instructions.h b/dependencies/fcml/include/fcml_instructions.h new file mode 100644 index 0000000..b919567 --- /dev/null +++ b/dependencies/fcml/include/fcml_instructions.h @@ -0,0 +1,1548 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_instructions.h + * Instruction codes and addressing modes/instruction forms. + * @copyright Copyright (C) 2010-2017 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_INSTRUCTIONS_H_ +#define FCML_INSTRUCTIONS_H_ + +/** + * @defgroup INSTRUCTION_TYPES_GROUP Instructions types. + * Instructions types. + * @{ + */ + +#define FCML_AMT_UNDEF 0x0000000000000000UL +/* Grouping. */ +#define FCML_AMT_SSEx 0x0000000000000001UL +#define FCML_AMT_VEXx 0x0000000000000002UL +#define FCML_AMT_SIMD 0x0000000000000004UL +/* CPUID. */ +#define FCML_AMT_GPI 0x0000000000000008UL +#define FCML_AMT_FPU 0x0000000000000010UL +#define FCML_AMT_MMX 0x0000000000000020UL | FCML_AMT_SSEx +#define FCML_AMT_SSE 0x0000000000000040UL | FCML_AMT_SSEx +#define FCML_AMT_SSE2 0x0000000000000080UL | FCML_AMT_SSEx +#define FCML_AMT_SSE3 0x0000000000000100UL | FCML_AMT_SSEx +#define FCML_AMT_SSSE3 0x0000000000000200UL | FCML_AMT_SSEx +#define FCML_AMT_SSE41 0x0000000000000400UL | FCML_AMT_SSEx +#define FCML_AMT_SSE42 0x0000000000000800UL | FCML_AMT_SSEx +#define FCML_AMT_SSE4A 0x0000000000001000UL | FCML_AMT_SSEx +#define FCML_AMT_AVX 0x0000000000002000UL | FCML_AMT_VEXx +#define FCML_AMT_AVX2 0x0000000000004000UL | FCML_AMT_VEXx +#define FCML_AMT_AES 0x0000000000008000UL +#define FCML_AMT_SYSTEM 0x0000000000010000UL +#define FCML_AMT_3DNOW 0x0000000000020000UL | FCML_AMT_MMX +#define FCML_AMT_TBM 0x0000000000040000UL | FCML_AMT_VEXx +#define FCML_AMT_BMI1 0x0000000000080000UL +#define FCML_AMT_BMI2 0x0000000000100000UL +#define FCML_AMT_HLE 0x0000000000200000UL +#define FCML_AMT_ADX 0x0000000000400000UL +#define FCML_AMT_CLMUL 0x0000000000800000UL +#define FCML_AMT_F16C 0x0000000001000000UL | FCML_AMT_VEXx +#define FCML_AMT_RDRAND 0x0000000002000000UL +#define FCML_AMT_RDSEED 0x0000000004000000UL +#define FCML_AMT_PRFCHW 0x0000000008000000UL +#define FCML_AMT_LWP 0x0000000010000000UL | FCML_AMT_SIMD +#define FCML_AMT_SVM 0x0000000020000000UL +#define FCML_AMT_FSGSBASE 0x0000000040000000UL +#define FCML_AMT_FMA 0x0000000080000000UL | FCML_AMT_SIMD +#define FCML_AMT_FMA4 0x0000000100000000UL | FCML_AMT_SIMD +#define FCML_AMT_XOP 0x0000000200000000UL | FCML_AMT_SIMD +#define FCML_AMT_EDX 0x0000000400000000UL +#define FCML_AMT_ABM 0x0000000800000000UL +#define FCML_AMT_VMX 0x0000001000000000UL +#define FCML_AMT_SMX 0x0000002000000000UL +#define FCML_AMT_POPCNT 0x0000004000000000UL +#define FCML_AMT_RTM 0x0000008000000000UL +/* Control transfer instructions. */ +#define FCML_AMT_CTI 0x0000010000000000UL +#define FCML_AMT_BRANCH 0x0000020000000000UL +/* End of control transfer instructions. */ +#define FCML_AMT_AVX512 0x0000040000000000UL +/* Shortcuts. */ +#define FCML_AMT_MMX_SIMD FCML_AMT_MMX | FCML_AMT_SIMD +#define FCML_AMT_SSE_SIMD FCML_AMT_SSE | FCML_AMT_SIMD +#define FCML_AMT_SSE2_SIMD FCML_AMT_SSE2 | FCML_AMT_SIMD +#define FCML_AMT_SSE3_SIMD FCML_AMT_SSE3 | FCML_AMT_SIMD +#define FCML_AMT_SSSE3_SIMD FCML_AMT_SSSE3 | FCML_AMT_SIMD +#define FCML_AMT_SSE41_SIMD FCML_AMT_SSE41 | FCML_AMT_SIMD +#define FCML_AMT_SSE42_SIMD FCML_AMT_SSE42 | FCML_AMT_SIMD +#define FCML_AMT_AVX_SIMD FCML_AMT_AVX | FCML_AMT_SIMD +#define FCML_AMT_AVX2_SIMD FCML_AMT_AVX2 | FCML_AMT_SIMD +#define FCML_AMT_3DNOW_SIMD FCML_AMT_3DNOW | FCML_AMT_SIMD +#define FCML_AMT_AVX512_SIMD FCML_AMT_AVX512 | FCML_AMT_SIMD + +/** @} */ + +/** Instruction forms. */ +enum fcml_en_instruction_addr_mode_codes { + FCML_AM_UNKNOWN, + FCML_AM_NO_OPERANS, + FCML_AM_IMM8, + FCML_AM_IMMO, + FCML_AM_ER8_IMM8, + FCML_AM_R8_IMM8, + FCML_AM_ERO_IMMO, + FCML_AM_RM8_IMM8, + FCML_AM_RMO_IMMO, + FCML_AM_R0_IMM0, + FCML_AM_RMO_IMM8, + FCML_AM_RM8_R8, + FCML_AM_R8_RM8, + FCML_AM_R8_MOFF8, + FCML_AM_MOFF8_R8, + FCML_AM_R16_RM8, + FCML_AM_RO_RM16, + FCML_AM_RMO_RO, + FCML_AM_RO_RMO, + FCML_AM_RO_MOFFO, + FCML_AM_RO_MO, + FCML_AM_MOFFO_RO, + FCML_AM_MO_RO, + FCML_AM_RO_RM8, + FCML_AM_RM_SR, + FCML_AM_SR_RM, + FCML_AM_R32_DR, + FCML_AM_R64_DR, + FCML_AM_DR_R32, + FCML_AM_DR_R64, + FCML_AM_R32_CR, + FCML_AM_R64_CR, + FCML_AM_CR_R32, + FCML_AM_CR_R64, + FCML_AM_RO_RMO_IMM8, + FCML_AM_RO_RMO_IMMO, + FCML_AM_R32A_RM32_R32B, + FCML_AM_R64A_RM64_R64B, + FCML_AM_R32_RM32, + FCML_AM_R64_RM64, + FCML_AM_R32_RM32_R32, + FCML_AM_R64_RM64_R64, + FCML_AM_REL16, + FCML_AM_PTR16_O, + FCML_AM_M16_O, + FCML_AM_M8_M8, + FCML_AM_MO_MO, + FCML_AM_M8, + FCML_AM_M16, + FCML_AM_M32, + FCML_AM_M64, + FCML_AM_M80, + FCML_AM_M128, + FCML_AM_RX_RM32, + FCML_AM_RX_RM64, + FCML_AM_RX_RX_RM32, + FCML_AM_RX_RX_RM64, + FCML_AM_R32_RXM64, + FCML_AM_R64_RXM64, + FCML_AM_RM8, + FCML_AM_RMO, + FCML_AM_RO, + FCML_AM_SRO, + FCML_AM_SR_FSGSO, + FCML_AM_ST0_ST, + FCML_AM_ST_ST0, + FCML_AM_ST, + FCML_AM_M2BYTE, + FCML_AM_AX, + FCML_AM_R64_M128, + FCML_AM_R32_M128, + FCML_AM_RX_RX_I8_I8, + FCML_AM_RX_RX, + FCML_AM_REL8, + FCML_AM_REL0 +}; + +/** + * @defgroup INSTRUCTION_GROUP Supported instructions codes. + * Set of all supported instructions. Names are based on Intel syntax. + * @{ + */ + +/** Instruction codes. */ +typedef enum fcml_en_instruction { + F_UNKNOWN, + F_AAA, + F_JCC, + F_AAD, + F_AAM, + F_AAS, + F_ADC, + F_ADD, + F_ADDPD, + F_VADDPD, + F_ADDPS, + F_VADDPS, + F_ADDSD, + F_VADDSD, + F_ADDSS, + F_VADDSS, + F_ADDSUBPD, + F_VADDSUBPD, + F_ADDSUBPS, + F_VADDSUBPS, + F_AESDEC, + F_VAESDEC, + F_AESDECLAST, + F_VAESDECLAST, + F_AESENC, + F_VAESENC, + F_AESENCLAST, + F_VAESENCLAST, + F_AESIMC, + F_VAESIMC, + F_AESKEYGENASSIST, + F_VAESKEYGENASSIST, + F_AND, + F_ANDPD, + F_VANDPD, + F_ANDPS, + F_VANDPS, + F_ANDNPD, + F_VANDNPD, + F_ANDNPS, + F_VANDNPS, + F_ARPL, + F_ANDN, + F_ADCX, + F_ADOX, + F_BLENDPD, + F_VBLENDPD, + F_BLENDPS, + F_VBLENDPS, + F_BLENDVPD, + F_VBLENDVPD, + F_BLENDVPS, + F_VBLENDVPS, + F_BOUND, + F_BSF, + F_BSR, + F_BSWAP, + F_BT, + F_BTC, + F_BTR, + F_BTS, + F_BEXR, + F_BLCFILL, + F_BLCI, + F_BLCIC, + F_BLCMSK, + F_BLCS, + F_BLSFILL, + F_BLSI, + F_BLSIC, + F_BLSMSK, + F_BLSR, + F_BZHI, + F_CALL, + F_CBW, + F_CWDE = F_CBW, + F_CDQE = F_CBW, + F_CLC, + F_CLD, + F_CLFLUSH, + F_CLI, + F_CLGI, + F_CLTS, + F_CMC, + F_CMOV, + F_CMP, + F_CMPPD, + F_VCMPPD, + F_CMPPS, + F_VCMPPS, + F_CMPS, + F_CMPSD, + F_VCMPSD, + F_CMPSS, + F_VCMPSS, + F_CMPXCHG, + F_CMPXCHGxB, + F_CPUID, + F_CRC32, + F_CVTDQ2PD, + F_VCVTDQ2PD, + F_CVTDQ2PS, + F_VCVTDQ2PS, + F_CVTPD2DQ, + F_VCVTPD2DQ, + F_CVTPD2PI, + F_CVTPD2PS, + F_VCVTPD2PS, + F_CVTPI2PD, + F_CVTPI2PS, + F_CVTPS2DQ, + F_VCVTPS2DQ, + F_CVTPS2PD, + F_VCVTPS2PD, + F_CVTPS2PI, + F_CVTSD2SI, + F_VCVTSD2SI, + F_CVTSD2SS, + F_VCVTSD2SS, + F_CVTSI2SD, + F_VCVTSI2SD, + F_CVTSI2SS, + F_VCVTSI2SS, + F_CVTSS2SD, + F_VCVTSS2SD, + F_CVTSS2SI, + F_VCVTSS2SI, + F_CVTTPD2DQ, + F_VCVTTPD2DQ, + F_CVTTPD2PI, + F_CVTTPS2DQ, + F_VCVTTPS2DQ, + F_CVTTPS2PI, + F_CVTTSD2SI, + F_VCVTTSD2SI, + F_CVTTSS2SI, + F_VCVTTSS2SI, + F_CWD, + F_CDQ = F_CWD, + F_CQO = F_CWD, + F_COMISD, + F_VCOMISD, + F_COMISS, + F_VCOMISS, + F_DAA, + F_DAS, + F_DEC, + F_DIV, + F_DIVPD, + F_VDIVPD, + F_DIVPS, + F_VDIVPS, + F_DIVSD, + F_VDIVSD, + F_DIVSS, + F_VDIVSS, + F_DPPD, + F_VDPPD, + F_DPPS, + F_VDPPS, + F_EMMS, + F_ENTER, + F_EXTRACTPS, + F_VEXTRACTPS, + F_EXTRQ, + F_F2XM1, + F_FABS, + F_FADD, + F_FIADD, + F_FADDP, + F_FBLD, + F_FBSTP, + F_FCHS, + F_FCLEX, + F_FNCLEX, + F_FCMOVB, + F_FCMOVE, + F_FCMOVBE, + F_FCMOVU, + F_FCMOVNB, + F_FCMOVNE, + F_FCMOVNBE, + F_FCMOVNU, + F_FCOS, + F_FCOM, + F_FCOMP, + F_FCOMPP, + F_FCOMI, + F_FCOMIP, + F_FUCOMI, + F_FUCOMIP, + F_FDECSTP, + F_FDIV, + F_FDIVP, + F_FIDIV, + F_FDIVR, + F_FDIVRP, + F_FIDIVR, + F_FFREE, + F_FICOM, + F_FICOMP, + F_FILD, + F_FINCSTP, + F_FINIT, + F_FNINIT, + F_FIST, + F_FISTP, + F_FLD, + F_FLD1, + F_FLDL2T, + F_FLDL2E, + F_FLDPI, + F_FLDLG2, + F_FLDLN2, + F_FLDZ, + F_FLDCW, + F_FLDENV, + F_FMUL, + F_FMULP, + F_FIMUL, + F_FNOP, + F_FPATAN, + F_FPREM, + F_FPREM1, + F_FPTAN, + F_FRNDINT, + F_FRSTOR, + F_FSAVE, + F_FNSAVE, + F_FSCALE, + F_FSIN, + F_FSINCOS, + F_FSQRT, + F_FST, + F_FSTP, + F_FSTCW, + F_FNSTCW, + F_FSTENV, + F_FNSTENV, + F_FSTSW, + F_FNSTSW, + F_FSUB, + F_FSUBP, + F_FISUB, + F_FSUBR, + F_FSUBRP, + F_FISUBR, + F_FTST, + F_FUCOM, + F_FUCOMP, + F_FUCOMPP, + F_FXAM, + F_FXCH, + F_FXRSTOR, + F_FXRSTOR64, + F_FXSAVE, + F_FXSAVE64, + F_FXTRACT, + F_FYL2X, + F_FYL2XP1, + F_FEMMS, + F_FISTTP, + F_GETSEC, + F_HADDPD, + F_VHADDPD, + F_HADDPS, + F_VHADDPS, + F_HLT, + F_HSUBPD, + F_VHSUBPD, + F_HSUBPS, + F_VHSUBPS, + F_INVEPT, + F_INVVPID, + F_IDIV, + F_IMUL, + F_IN, + F_INC, + F_INS, + F_INSERTPS, + F_VINSERTPS, + F_VEXTRACTF128, + F_VEXTRACTF32X4, + F_VEXTRACTF64X2, + F_VEXTRACTF32X8, + F_VEXTRACTF64X4, + F_VEXTRACTI32X4, + F_VEXTRACTI64X2, + F_VEXTRACTI32X8, + F_VEXTRACTI64X4, + F_VINSERTF128, + F_VFIXUPIMMPD, + F_VFIXUPIMMPS, + F_VFIXUPIMMSD, + F_VFIXUPIMMSS, + F_INSERTQ, + F_INT3, + F_INT, + F_INTO, + F_INVD, + F_INVLPG, + F_INVLPGA, + F_INVPCID, + F_IRET, + F_JCXZ, + F_JECXZ = F_JCXZ, + F_JRCXZ = F_JCXZ, + F_JMP, + F_KADDB, + F_KADDD, + F_KADDW, + F_KADDQ, + F_KANDB, + F_KANDD, + F_KANDW, + F_KANDQ, + F_KANDNB, + F_KANDND, + F_KANDNW, + F_KANDNQ, + F_KMOVB, + F_KMOVW, + F_KMOVD, + F_KMOVQ, + F_KNOTB, + F_KNOTW, + F_KNOTD, + F_KNOTQ, + F_KORB, + F_KORW, + F_KORD, + F_KORQ, + F_KORTESTB, + F_KORTESTW, + F_KORTESTD, + F_KORTESTQ, + F_KSHIFTLW, + F_KSHIFTLB, + F_KSHIFTLQ, + F_KSHIFTLD, + F_KSHIFTRW, + F_KSHIFTRB, + F_KSHIFTRQ, + F_KSHIFTRD, + F_KTESTB, + F_KTESTW, + F_KTESTD, + F_KTESTQ, + F_KXNORB, + F_KXNORD, + F_KXNORW, + F_KXNORQ, + F_KXORB, + F_KXORD, + F_KXORW, + F_KXORQ, + F_LAR, + F_LAHF, + F_LDDQU, + F_VLDDQU, + F_LDMXCSR, + F_VLDMXCSR, + F_LDS, + F_LSS, + F_LES, + F_LFS, + F_LGS, + F_LEA, + F_LEAVE, + F_LFENCE, + F_LLWPCB, + F_LGDT, + F_LIDT, + F_LLDT, + F_LMSW, + F_LODS, + F_LOOP, + F_LOOPE, + F_LOOPNE, + F_LWPINS, + F_LWPVAL, + F_LSL, + F_LTR, + F_LZCNT, + F_MASKMOVDQU, + F_VMASKMOVDQU, + F_MASKMOVQ, + F_VMASKMOVPS, + F_VMASKMOVPD, + F_VPMASKMOVD, + F_VPMASKMOV, + F_VPMASKMOVQ, + F_MAXPD, + F_VMAXPD, + F_MAXPS, + F_VMAXPS, + F_MAXSD, + F_VMAXSD, + F_MAXSS, + F_VMAXSS, + F_MFENCE, + F_MINPD, + F_VMINPD, + F_MINPS, + F_VMINPS, + F_MINSD, + F_VMINSD, + F_MINSS, + F_VMINSS, + F_MONITOR, + F_MOVAPD, + F_VMOVAPD, + F_MOVAPS, + F_VMOVAPS, + F_MOVBE, + F_MOV, + F_MOVD, + F_VMOVD, + F_MOVQ, + F_VMOVQ, + F_MOVDDUP, + F_VMOVDDUP, + F_MOVDQA, + F_VMOVDQA, + F_VMOVDQA32, + F_VMOVDQA64, + F_MOVDQU, + F_VMOVDQU, + F_VMOVDQU8, + F_VMOVDQU16, + F_VMOVDQU32, + F_VMOVDQU64, + F_MOVDQ2Q, + F_MOVHLPS, + F_VMOVHLPS, + F_MOVHPD, + F_VMOVHPD, + F_MOVHPS, + F_VMOVHPS, + F_MOVLHPS, + F_VMOVLHPS, + F_MOVLPD, + F_VMOVLPD, + F_MOVLPS, + F_VMOVLPS, + F_MOVMSKPD, + F_VMOVMSKPD, + F_MOVMSKPS, + F_VMOVMSKPS, + F_MOVNTDQA, + F_VMOVNTDQA, + F_MOVNTDQ, + F_VMOVNTDQ, + F_MOVS, + F_MOVNTI, + F_MOVNTPD, + F_VMOVNTPD, + F_MOVNTPS, + F_VMOVNTPS, + F_MOVNTSD, + F_MOVNTSS, + F_MOVNTQ, + F_MOVQ2DQ, + F_MOVSD, + F_VMOVSD, + F_MOVSHDUP, + F_VMOVSHDUP, + F_MOVSLDUP, + F_VMOVSLDUP, + F_MOVSS, + F_VMOVSS, + F_MOVSX, + F_MOVSXD, + F_MOVUPD, + F_VMOVUPD, + F_MOVUPS, + F_VMOVUPS, + F_MOVZX, + F_MPSADBW, + F_VMPSADBW, + F_MUL, + F_MULPD, + F_VMULPD, + F_MULPS, + F_VMULPS, + F_MULSD, + F_VMULSD, + F_MULSS, + F_VMULSS, + F_MWAIT, + F_NEG, + F_NOP, + F_NOT, + F_OR, + F_ORPD, + F_VORPD, + F_ORPS, + F_VORPS, + F_OUT, + F_OUTS, + F_PABSW, + F_PABSB, + F_PABSD, + F_VPABSB, + F_VPABSW, + F_VPABSD, + F_VPABSQ, + F_VPACKSSWB, + F_PACKSSWB, + F_VPACKSSDW, + F_PACKSSDW, + F_PACKUSDW, + F_VPACKUSDW, + F_PACKUSWB, + F_VPACKUSWB, + F_VPADDW, + F_PADDW, + F_VPADDB, + F_VPADDD, + F_PADDB, + F_PADDD, + F_VPADDSW, + F_PADDSB, + F_PADDSW, + F_VPADDSB, + F_PADDUSW, + F_PADDUSB, + F_VPADDUSW, + F_PADDQ, + F_VPADDUSB, + F_VPADDQ, + F_POP, + F_PUSH, + F_POPA, + F_POPAD, + F_POPF, + F_POPFQ, + F_POPFD, + F_PUSHA, + F_PUSHF, + F_PUSHAD, + F_PUSHFQ, + F_PUSHFD, + F_PAVGUSB, + F_PF2ID, + F_PFACC, + F_PFADD, + F_PFCMPEQ, + F_PFCMPGE, + F_PFCMPGT, + F_PFMAX, + F_PFMIN, + F_PFMUL, + F_PFRCP, + F_PFRCPIT1, + F_PFRCPIT2, + F_PFRSQIT1, + F_PFRSQRT, + F_PFSUB, + F_PFSUBR, + F_PI2FD, + F_PMULHRW, + F_PF2IW, + F_PFNACC, + F_PFPNACC, + F_PI2FW, + F_PSWAPD, + F_PALIGNR, + F_VPALIGNR, + F_PAND, + F_VPAND, + F_VPANDD, + F_VPANDQ, + F_PANDN, + F_VPANDN, + F_VPANDND, + F_VPANDNQ, + F_PAUSE, + F_PAVGW, + F_PAVGB, + F_VPAVGW, + F_VPAVGB, + F_PBLENDVB, + F_VPBLENDVB, + F_PBLENDW, + F_VPBLENDW, + F_VPBLENDD, + F_PCLMULQDQ, + F_VPCLMULQDQ, + F_PCMPEQW, + F_PCMPEQB, + F_PCMPEQD, + F_VPCMPEQD, + F_VPCMPEQW, + F_VPCMPEQB, + F_PCMPEQQ, + F_VPCMPEQQ, + F_PCMPESTRI, + F_VPCMPESTRI, + F_PCMPESTRM, + F_VPCMPESTRM, + F_PCMPGTW, + F_PCMPGTD, + F_PCMPGTB, + F_VPCMPGTW, + F_VPCMPGTD, + F_VPCMPGTB, + F_PCMPGTQ, + F_VPCMPGTQ, + F_PCMPISTRI, + F_VPCMPISTRI, + F_PCMPISTRM, + F_VPCMPISTRM, + F_VPEXTRB, + F_VPEXTRQ, + F_PEXTRQ, + F_PEXTRB, + F_PEXTRD, + F_VPEXTRD, + F_PEXTRW, + F_VPEXTRW, + F_VPHADDW, + F_VPHADDD, + F_PHADDD, + F_PHADDW, + F_PHADDSW, + F_VPHADDSW, + F_PHMINPOSUW, + F_VPHMINPOSUW, + F_PHSUBD, + F_PHSUBW, + F_VPHSUBD, + F_VPHSUBW, + F_PHSUBSW, + F_VPHSUBSW, + F_PINSRD, + F_VPINSRQ, + F_PINSRQ, + F_PINSRB, + F_VPINSRD, + F_VPINSRB, + F_PINSRW, + F_VPINSRW, + F_PMADDUBSW, + F_VPMADDUBSW, + F_PMADDWD, + F_VPMADDWD, + F_PMAXSB, + F_VPMAXSB, + F_PMAXSD, + F_VPMAXSD, + F_VPMAXSQ, + F_PMAXSW, + F_VPMAXSW, + F_PMAXUB, + F_VPMAXUB, + F_PMAXUD, + F_VPMAXUD, + F_VPMAXUQ, + F_PMAXUW, + F_VPMAXUW, + F_PMINSB, + F_VPMINSB, + F_PMINSD, + F_VPMINSD, + F_VPMINSQ, + F_PMINSW, + F_VPMINSW, + F_PMINUW, + F_VPMINUW, + F_PMINUB, + F_VPMINUB, + F_PMINUD, + F_VPMINUD, + F_VPMINUQ, + F_PMOVMSKB, + F_VPMOVMSKB, + F_VPMOVSXBQ, + F_PMOVSXBW, + F_PMOVSXWQ, + F_VPMOVSXWQ, + F_PMOVSXWD, + F_PMOVSXBD, + F_VPMOVSXDQ, + F_VPMOVSXWD, + F_PMOVSXBQ, + F_VPMOVSXBW, + F_PMOVSXDQ, + F_VPMOVSXBD, + F_PMOVZXWD, + F_PMOVZXDQ, + F_VPMOVZXDQ, + F_PMOVZXWQ, + F_VPMOVZXBQ, + F_PMOVZXBQ, + F_VPMOVZXWD, + F_VPMOVZXBD, + F_VPMOVZXWQ, + F_PMOVZXBD, + F_VPMOVZXBW, + F_PMOVZXBW, + F_PMULDQ, + F_PMULHRSW, + F_PMULHUW, + F_VPMULDQ, + F_VPMULHRSW, + F_VPMULHUW, + F_PMULHW, + F_VPMULHW, + F_PMULUDQ, + F_VPMULUDQ, + F_PMULLW, + F_PMULLD, + F_VPMULLD, + F_VPMULLQ, + F_VPMULLW, + F_POPCNT, + F_POR, + F_VPOR, + F_VPORD, + F_VPORQ, + F_PREFETCHT2, + F_PREFETCHW, + F_PREFETCHT1, + F_PREFETCHNTA, + F_PREFETCHT0, + F_PREFETCHWT1, + F_PSADBW, + F_VPSADBW, + F_PSHUFB, + F_PSHUFD, + F_PSHUFHW, + F_VPSHUFD, + F_VPSHUFB, + F_PSHUFLW, + F_PSHUFW, + F_VPSHUFLW, + F_VPSHUFHW, + F_VPSIGNB, + F_VPSIGND, + F_PSIGNW, + F_PSIGNB, + F_VPSIGNW, + F_PSIGND, + F_PSLLDQ, + F_VPSLLDQ, + F_PSLLQ, + F_PSLLD, + F_VPSLLW, + F_VPSLLQ, + F_PSLLW, + F_VPSLLD, + F_VPSRAW, + F_PSRAD, + F_PSRAW, + F_VPSRAD, + F_VPSRAQ, + F_PSRLDQ, + F_VPSRLDQ, + F_VPSRLQ, + F_PSRLQ, + F_PSRLD, + F_PSRLW, + F_VPSRLD, + F_VPSRLW, + F_VPSUBD, + F_PSUBD, + F_PSUBW, + F_VPSUBB, + F_VPSUBQ, + F_PSUBB, + F_VPSUBW, + F_PSUBQ, + F_PSUBSB, + F_VPSUBSW, + F_VPSUBSB, + F_PSUBSW, + F_VPSUBUSW, + F_VPSUBUSB, + F_PSUBUSB, + F_PSUBUSW, + F_VPTEST, + F_PTEST, + F_PUNPCKLBW, + F_PUNPCKLQDQ, + F_VPUNPCKLWD, + F_VPUNPCKLQDQ, + F_VPUNPCKLBW, + F_PUNPCKLWD, + F_PUNPCKLDQ, + F_VPUNPCKLDQ, + F_VPUNPCKHWD, + F_PUNPCKHDQ, + F_PUNPCKHWD, + F_PUNPCKHQDQ, + F_VPUNPCKHQDQ, + F_VPUNPCKHBW, + F_PUNPCKHBW, + F_VPUNPCKHDQ, + F_PXOR, + F_VPXOR, + F_VPXORD, + F_VPXORQ, + F_PREFETCH, + F_RCL, + F_RCR, + F_ROL, + F_ROR, + F_RET, + F_RETF, + F_RCPPS, + F_VRCPPS, + F_RCPSS, + F_VRCPSS, + F_RDFSBASE, + F_RDGSBASE, + F_RDRAND, + F_RDTSCP, + F_RDTSC, + F_RDPMC, + F_RDMSR, + F_ROUNDPD, + F_VROUNDPD, + F_ROUNDPS, + F_VROUNDPS, + F_ROUNDSD, + F_VROUNDSD, + F_ROUNDSS, + F_VROUNDSS, + F_RSM, + F_RSQRTPS, + F_VRSQRTPS, + F_RSQRTSS, + F_VRSQRTSS, + F_SAHF, + F_SAR, + F_SAL, + F_SHL = F_SAL, + F_SHR, + F_SBB, + F_SCAS, + F_SET, + F_STOS, + F_SUB, + F_SFENCE, + F_SGDT, + F_SHLD, + F_SHRD, + F_SKINIT, + F_SLWPCB, + F_SHUFPD, + F_VSHUFPD, + F_SHUFPS, + F_VSHUFPS, + F_SIDT, + F_SLDT, + F_SMSW, + F_SQRTPD, + F_VSQRTPD, + F_SQRTPS, + F_VSQRTPS, + F_SQRTSD, + F_VSQRTSD, + F_SQRTSS, + F_VSQRTSS, + F_STC, + F_STD, + F_STGI, + F_STI, + F_STMXCSR, + F_VSTMXCSR, + F_STR, + F_SUBPD, + F_VSUBPD, + F_SUBPS, + F_VSUBPS, + F_SUBSD, + F_VSUBSD, + F_SUBSS, + F_VSUBSS, + F_SWAPGS, + F_SYSCALL, + F_SYSENTER, + F_SYSEXIT, + F_SYSRET, + F_TEST, + F_T1MSKC, + F_UCOMISD, + F_VUCOMISD, + F_UCOMISS, + F_VUCOMISS, + F_UD2, + F_UNPCKHPD, + F_VUNPCKHPD, + F_UNPCKHPS, + F_VUNPCKHPS, + F_UNPCKLPD, + F_VUNPCKLPD, + F_UNPCKLPS, + F_VUNPCKLPS, + F_VMLOAD, + F_VMRUN, + F_VMSAVE, + F_VFRCZPD, + F_VFRCZPS, + F_VFRCZSD, + F_VFRCZSS, + F_VPCMOV, + F_VPERMIL2PD, + F_VPERMIL2PS, + F_VPHADDBD, + F_VPHADDBW, + F_VPHADDBQ, + F_VPHADDDQ, + F_VPHADDUBD, + F_VPHADDUBQ, + F_VPHADDUBW, + F_VPHADDUDQ, + F_VPHADDUWD, + F_VPHADDUWQ, + F_VPHADDWD, + F_VPHADDWQ, + F_VPHSUBBW, + F_VPHSUBDQ, + F_VPHSUBWD, + F_VPMACSDD, + F_VPMACSDQH, + F_VPMACSDQL, + F_VPMACSSDD, + F_VPMACSSDQH, + F_VPMACSSDQL, + F_VPMACSSWD, + F_VPMACSSWW, + F_VPMACSWD, + F_VPMACSWW, + F_VPMADCSSWD, + F_VPMADCSWD, + F_VPPERM, + F_VPROTD, + F_VPROTB, + F_VPROTQ, + F_VPROTW, + F_VPSHAB, + F_VPSHAD, + F_VPSHAQ, + F_VPSHAW, + F_VPSHLB, + F_VPSHLD, + F_VPSHLQ, + F_VPSHLW, + F_VFMADD213PD, + F_VFMADDPD, + F_VFMADD132PD, + F_VFMADD231PD, + F_VFMADDPS, + F_VFMADD231PS, + F_VFMADD132PS, + F_VFMADD213PS, + F_VFMADD132SD, + F_VFMADD213SD, + F_VFMADDSD, + F_VFMADD231SD, + F_VFMADD132SS, + F_VFMADD213SS, + F_VFMADDSS, + F_VFMADD231SS, + F_VFMADDSUB132PD, + F_VFMADDSUB213PD, + F_VFMADDSUBPD, + F_VFMADDSUB231PD, + F_VFMADDSUB231PS, + F_VFMADDSUBPS, + F_VFMADDSUB132PS, + F_VFMADDSUB213PS, + F_VFMSUBADDPD, + F_VFMSUBADD213PD, + F_VFMSUBADD132PD, + F_VFMSUBADD231PD, + F_VFMSUBADDPS, + F_VFMSUBADD213PS, + F_VFMSUBADD132PS, + F_VFMSUBADD231PS, + F_VFMSUB213PD, + F_VFMSUBPD, + F_VFMSUB132PD, + F_VFMSUB231PD, + F_VFMSUB213PS, + F_VFMSUBPS, + F_VFMSUB132PS, + F_VFMSUB231PS, + F_VFMSUBSD, + F_VFMSUB231SD, + F_VFMSUB132SD, + F_VFMSUB213SD, + F_VFMSUB231SS, + F_VFMSUB213SS, + F_VFMSUB132SS, + F_VFMSUBSS, + F_VFNMADD231PD, + F_VFNMADDPD, + F_VFNMADD132PD, + F_VFNMADD213PD, + F_VFNMADD231PS, + F_VFNMADD132PS, + F_VFNMADD213PS, + F_VFNMADDPS, + F_VFNMADD213SD, + F_VFNMADDSD, + F_VFNMADD231SD, + F_VFNMADD132SD, + F_VFNMADD213SS, + F_VFNMADDSS, + F_VFNMADD231SS, + F_VFNMADD132SS, + F_VFNMSUB132PD, + F_VFNMSUB213PD, + F_VFNMSUB231PD, + F_VFNMSUBPD, + F_VFNMSUBPS, + F_VFNMSUB213PS, + F_VFNMSUB132PS, + F_VFNMSUB231PS, + F_VFNMSUBSD, + F_VFNMSUB231SD, + F_VFNMSUB213SD, + F_VFNMSUB132SD, + F_VFNMSUBSS, + F_VFNMSUB132SS, + F_VFNMSUB213SS, + F_VFNMSUB231SS, + F_VFPCLASSPD, + F_VFPCLASSPS, + F_VFPCLASSSD, + F_VFPCLASSSS, + F_BEXTR, + F_VPBROADCASTW, + F_VPBROADCASTB, + F_VPBROADCASTD, + F_VPBROADCASTQ, + F_VBROADCASTI32X2, + F_VBROADCASTI32X4, + F_VBROADCASTI64X2, + F_VBROADCASTI32X8, + F_VBROADCASTI64X4, + F_VPBROADCASTMB2Q, + F_VPBROADCASTMW2D, + F_VPCMPB, + F_VPCMPUB, + F_VPCMPW, + F_VPCMPUW, + F_VPCMPD, + F_VPCMPUD, + F_VPCMPQ, + F_VPCMPUQ, + F_VCOMPRESSPD, + F_VCOMPRESSPS, + F_VPCOMPRESSD, + F_VPCOMPRESSQ, + F_VCVTPD2QQ, + F_VCVTTPS2UQQ, + F_VCVTTPS2QQ, + F_VCVTPD2UDQ, + F_VCVTTPD2UQQ, + F_VCVTTPS2UDQ, + F_VMPTRLD, + F_VCVTPD2UQQ, + F_VMPTRST, + F_VMCLEAR, + F_VMREAD, + F_VMWRITE, + F_VMLAUNCH, + F_VMRESUME, + F_VMXOFF, + F_VMXON, + F_VMCALL, + F_VMFUNC, + F_VALIGND, + F_VALIGNQ, + F_VBLENDMPD, + F_VBLENDMPS, + F_VBROADCASTSD, + F_VBROADCASTSS, + F_VBROADCASTI128, + F_VBROADCASTF128, + F_VBROADCASTF32X2, + F_VBROADCASTF32X4, + F_VBROADCASTF32X8, + F_VBROADCASTF64X2, + F_VBROADCASTF64X4, + F_VCVTPH2PS, + F_VCVTPS2PH, + F_VCVTPS2QQ, + F_VCVTPS2UDQ, + F_VCVTPS2UQQ, + F_VCVTQQ2PD, + F_VCVTQQ2PS, + F_VCVTSD2USI, + F_VCVTSS2USI, + F_VCVTTSD2USI, + F_VCVTTSS2USI, + F_VCVTTPD2QQ, + F_VCVTUDQ2PS, + F_VCVTUQQ2PD, + F_VCVTUSI2SD, + F_VCVTUSI2SS, + F_VCVTUQQ2PS, + F_VCVTUDQ2PD, + F_VCVTTPD2UDQ, + F_VDBPSADBW, + F_VEXPANDPD, + F_VEXPANDPS, + F_VERR, + F_VERW, + F_VMMCALL, + F_VPERMILPD, + F_VPERMILPS, + F_VPERM2F128, + F_VPERM2I128, + F_VPERMI2W, + F_VPERMI2D, + F_VPERMI2Q, + F_VPERMI2PS, + F_VPERMI2PD, + F_VPERMT2B, + F_VPERMT2W, + F_VPERMT2D, + F_VPERMT2Q, + F_VPERMT2PS, + F_VPERMT2PD, + F_VPEXPANDD, + F_VPEXPANDQ, + F_VPLZCNTD, + F_VPLZCNTQ, + F_VPMOVB2M, + F_VPMOVW2M, + F_VPMOVD2M, + F_VPMOVQ2M, + F_VPMOVM2B, + F_VPMOVM2W, + F_VPMOVM2D, + F_VPMOVM2Q, + F_VPMOVDB, + F_VPMOVSDB, + F_VPMOVUSDB, + F_VPMOVDW, + F_VPMOVSDW, + F_VPMOVUSDW, + F_VPMOVQB, + F_VPMOVSQB, + F_VPMOVUSQB, + F_VPMOVQD, + F_VPMOVSQD, + F_VPMOVUSQD, + F_VPMOVQW, + F_VPMOVSQW, + F_VPMOVUSQW, + F_VPMOVWB, + F_VPMOVSWB, + F_VPMOVUSWB, + F_VPMULTISHIFTQB, + F_VPROLVD, + F_VPROLVQ, + F_VPROLD, + F_VPROLQ, + F_VPRORVD, + F_VPRORVQ, + F_VPRORD, + F_VPRORQ, + F_VPSCATTERDD, + F_VPSCATTERDQ, + F_VPSCATTERQD, + F_VPSCATTERQQ, + F_VPSLLVW, + F_VPSLLVD, + F_VPSLLVQ, + F_VPMADD52HUQ, + F_VPMADD52LUQ, + F_VEXTRACTI128, + F_VINSERTI128, + F_VPSRAVW, + F_VPSRAVD, + F_VPSRAVQ, + F_VPERMD, + F_VPERMW, + F_VPERMI2B, + F_VPERMB, + F_VPSRLVW, + F_VPSRLVD, + F_VPSRLVQ, + F_VPTERNLOGD, + F_VPTERNLOGQ, + F_VPTESTMB, + F_VPTESTMW, + F_VPTESTMD, + F_VPTESTMQ, + F_VPTESTNMB, + F_VPTESTNMW, + F_VPTESTNMD, + F_VPTESTNMQ, + F_VRANGEPD, + F_VRANGEPS, + F_VRANGESD, + F_VRANGESS, + F_VRCP14PD, + F_VRCP14PS, + F_VRCP14SD, + F_VRCP14SS, + F_VREDUCEPD, + F_VREDUCEPS, + F_VREDUCESD, + F_VREDUCESS, + F_VRNDSCALEPD, + F_VRNDSCALEPS, + F_VRNDSCALESD, + F_VRNDSCALESS, + F_VRSQRT14PD, + F_VRSQRT14PS, + F_VRSQRT14SD, + F_VRSQRT14SS, + F_VSCALEFPD, + F_VSCALEFPS, + F_VSCALEFSD, + F_VSCALEFSS, + F_VSCATTERDPS, + F_VSCATTERDPD, + F_VSCATTERQPS, + F_VSCATTERQPD, + F_VSHUFF32X4, + F_VSHUFF64X2, + F_VSHUFI32X4, + F_VSHUFI64X2, + F_VPERMPD, + F_VPERMQ, + F_VPERMPS, + F_VTESTPS, + F_VTESTPD, + F_VGATHERDPD, + F_VGATHERQPD, + F_VGATHERDPS, + F_VGATHERQPS, + F_VPGATHERDD, + F_VPGATHERQD, + F_VPGATHERDQ, + F_VPGATHERQQ, + F_VGETEXPPD, + F_VGETEXPPS, + F_VGETEXPSD, + F_VGETEXPSS, + F_VGETMANTPD, + F_VGETMANTPS, + F_VGETMANTSD, + F_VGETMANTSS, + F_VINSERTF32X4, + F_VINSERTF64X2, + F_VINSERTF32X8, + F_VINSERTF64X4, + F_VINSERTI32X4, + F_VINSERTI64X2, + F_VINSERTI32X8, + F_VINSERTI64X4, + F_VPBLENDMB, + F_VPBLENDMW, + F_VPBLENDMD, + F_VPBLENDMQ, + F_VZEROALL, + F_VZEROUPPER, + F_VPCOMB, + F_VPCOMW, + F_VPCOMD, + F_VPCOMQ, + F_VPCOMUB, + F_VPCOMUW, + F_VPCOMUD, + F_VPCOMUQ, + F_WAIT, + F_FWAIT = F_WAIT, + F_WBINVD, + F_WRFSBASE, + F_WRGSBASE, + F_WRMSR, + F_XLAT, + F_XOR, + F_XADD, + F_XCHG, + F_XGETBV, + F_XORPD, + F_VXORPD, + F_XORPS, + F_VXORPS, + F_XRSTOR, + F_XRSTOR64, + F_XSAVE, + F_XSAVE64, + F_XSAVEOPT, + F_XSAVEOPT64, + F_XSETBV, + F_MULX, + F_PDEP, + F_PEXT, + F_RORX, + F_SHLX, + F_SHRX, + F_SARX, + F_TZCNT, + F_TZMSK, + F_XABORT, + F_XBEGIN, + F_XEND, + F_XTEST, + F_RDSEED, + F_CLAC, + F_STAC, + F_V4FMADDPS, + F_V4FNMADDPS, + F_V4FMADDSS, + F_V4FNMADDSS, + F_VEXP2PD, + F_VEXP2PS, + F_VGATHERPF0DPS, + F_VGATHERPF0QPS, + F_VGATHERPF0DPD, + F_VGATHERPF0QPD, + F_VGATHERPF1DPS, + F_VGATHERPF1QPS, + F_VGATHERPF1DPD, + F_VGATHERPF1QPD, + F_VP4DPWSSDS, + F_VP4DPWSSD, + F_VRCP28PD, + F_VRCP28SD, + F_VRCP28PS, + F_VRCP28SS, + F_VRSQRT28PD, + F_VRSQRT28SD, + F_VRSQRT28PS, + F_VRSQRT28SS, + F_VSCATTERPF0DPS, + F_VSCATTERPF0QPS, + F_VSCATTERPF0DPD, + F_VSCATTERPF0QPD, + F_VSCATTERPF1DPS, + F_VSCATTERPF1QPS, + F_VSCATTERPF1DPD, + F_VSCATTERPF1QPD +} fcml_en_instruction; + +/** @} */ + +/** + * @defgroup PSEUDO_OPERATIONS_GROUP Supported pseudo operations. + * @{ + */ + +/** Pseudo operations. */ +typedef enum fcml_en_pseudo_operations { + /** Set if there is no pseudo operation. */ + FP_NO_PSEUDO_OP, + /** db / .byte */ + FP_DB +} fcml_en_pseudo_operations; + +/** @} */ + +#endif /* FCML_INSTRUCTIONS_H_ */ diff --git a/dependencies/fcml/include/fcml_intel_dialect.h b/dependencies/fcml/include/fcml_intel_dialect.h new file mode 100644 index 0000000..f8073b7 --- /dev/null +++ b/dependencies/fcml/include/fcml_intel_dialect.h @@ -0,0 +1,58 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_intel_dialect.h + * Intel dialect implementation. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_ASM_DIALECT_INTEL_H_ +#define FCML_ASM_DIALECT_INTEL_H_ + +#include "fcml_lib_export.h" + +#include "fcml_errors.h" +#include "fcml_dialect.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Default combination of the configuration flags.*/ +#define FCML_INTEL_DIALECT_CF_DEFAULT 0 + +/** + * Initializes Intel dialect. + * Prepares new instance of Intel dialect for given set of configuration flags. + * Every dialect has to be freed using fcml_fn_dialect_free() function. + * + * @param config_flags Configuration flags dedicated to the dialect. + * @param[out] dialect Prepared dialect instance. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @see fcml_fn_dialect_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_dialect_init_intel( + fcml_uint32_t config_flags, fcml_st_dialect **dialect); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_ASM_DIALECT_INTEL_H_ */ diff --git a/dependencies/fcml/include/fcml_intel_dialect.hpp b/dependencies/fcml/include/fcml_intel_dialect.hpp new file mode 100644 index 0000000..65693c5 --- /dev/null +++ b/dependencies/fcml/include/fcml_intel_dialect.hpp @@ -0,0 +1,66 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_intel_dialect.hpp + * C++ wrapper for the Intel dialect. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_INTEL_DIALECT_HPP_ +#define FCML_INTEL_DIALECT_HPP_ + +#include "fcml_dialect.hpp" + +#include "fcml_intel_dialect.h" + +namespace fcml { + +/** Wraps the Intel dialect. + * @since 1.1.0 + */ +class IntelDialect: public Dialect { +public: + /** + * Creates the Intel dialect. + * + * @param flags Optional flags. + * @since 1.1.0 + */ + IntelDialect(fcml_uint32_t flags = FCML_INTEL_DIALECT_CF_DEFAULT) { + fcml_st_dialect *dialect; + fcml_ceh_error error = ::fcml_fn_dialect_init_intel(flags, &dialect); + if (error) { + throw InitException( + FCML_TEXT("Can not initialize the Intel dialect."), error); + } + Dialect::setDialect(dialect); + } + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~IntelDialect() { + } +}; + +} + +#endif /* FCML_INTEL_DIALECT_HPP_ */ diff --git a/dependencies/fcml/include/fcml_intel_mnemonics.cpp b/dependencies/fcml/include/fcml_intel_mnemonics.cpp new file mode 100644 index 0000000..223bfe2 --- /dev/null +++ b/dependencies/fcml/include/fcml_intel_mnemonics.cpp @@ -0,0 +1,1716 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_intel_mnemonics.cpp + * Definitions of Intel mnemonics for C++. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#include "fcml_intel_mnemonics.hpp" + +namespace fcml { +namespace intel { + +extern const fcml_cstring M_AAA = _FT("aaa"); +extern const fcml_cstring M_AAD = _FT("aad"); +extern const fcml_cstring M_AAM = _FT("aam"); +extern const fcml_cstring M_AAS = _FT("aas"); +extern const fcml_cstring M_ADC = _FT("adc"); +extern const fcml_cstring M_ADCX = _FT("adcx"); +extern const fcml_cstring M_ADD = _FT("add"); +extern const fcml_cstring M_ADDPD = _FT("addpd"); +extern const fcml_cstring M_ADDPS = _FT("addps"); +extern const fcml_cstring M_ADDSD = _FT("addsd"); +extern const fcml_cstring M_ADDSS = _FT("addss"); +extern const fcml_cstring M_ADDSUBPD = _FT("addsubpd"); +extern const fcml_cstring M_ADDSUBPS = _FT("addsubps"); +extern const fcml_cstring M_ADOX = _FT("adox"); +extern const fcml_cstring M_AESDEC = _FT("aesdec"); +extern const fcml_cstring M_AESDECLAST = _FT("aesdeclast"); +extern const fcml_cstring M_AESENC = _FT("aesenc"); +extern const fcml_cstring M_AESENCLAST = _FT("aesenclast"); +extern const fcml_cstring M_AESIMC = _FT("aesimc"); +extern const fcml_cstring M_AESKEYGENASSIST = _FT("aeskeygenassist"); +extern const fcml_cstring M_AND = _FT("and"); +extern const fcml_cstring M_ANDN = _FT("andn"); +extern const fcml_cstring M_ANDNPD = _FT("andnpd"); +extern const fcml_cstring M_ANDNPS = _FT("andnps"); +extern const fcml_cstring M_ANDPD = _FT("andpd"); +extern const fcml_cstring M_ANDPS = _FT("andps"); +extern const fcml_cstring M_ARPL = _FT("arpl"); +extern const fcml_cstring M_BEXR = _FT("bexr"); +extern const fcml_cstring M_BEXTR = _FT("bextr"); +extern const fcml_cstring M_BLCFILL = _FT("blcfill"); +extern const fcml_cstring M_BLCI = _FT("blci"); +extern const fcml_cstring M_BLCIC = _FT("blcic"); +extern const fcml_cstring M_BLCMSK = _FT("blcmsk"); +extern const fcml_cstring M_BLCS = _FT("blcs"); +extern const fcml_cstring M_BLENDPD = _FT("blendpd"); +extern const fcml_cstring M_BLENDPS = _FT("blendps"); +extern const fcml_cstring M_BLENDVPD = _FT("blendvpd"); +extern const fcml_cstring M_BLENDVPS = _FT("blendvps"); +extern const fcml_cstring M_BLSFILL = _FT("blsfill"); +extern const fcml_cstring M_BLSI = _FT("blsi"); +extern const fcml_cstring M_BLSIC = _FT("blsic"); +extern const fcml_cstring M_BLSMSK = _FT("blsmsk"); +extern const fcml_cstring M_BLSR = _FT("blsr"); +extern const fcml_cstring M_BOUND = _FT("bound"); +extern const fcml_cstring M_BSF = _FT("bsf"); +extern const fcml_cstring M_BSR = _FT("bsr"); +extern const fcml_cstring M_BSWAP = _FT("bswap"); +extern const fcml_cstring M_BT = _FT("bt"); +extern const fcml_cstring M_BTC = _FT("btc"); +extern const fcml_cstring M_BTR = _FT("btr"); +extern const fcml_cstring M_BTS = _FT("bts"); +extern const fcml_cstring M_BZHI = _FT("bzhi"); +extern const fcml_cstring M_CALL = _FT("call"); +extern const fcml_cstring M_CBW = _FT("cbw"); +extern const fcml_cstring M_CDQ = _FT("cdq"); +extern const fcml_cstring M_CDQE = _FT("cdqe"); +extern const fcml_cstring M_CLAC = _FT("clac"); +extern const fcml_cstring M_CLC = _FT("clc"); +extern const fcml_cstring M_CLD = _FT("cld"); +extern const fcml_cstring M_CLFLUSH = _FT("clflush"); +extern const fcml_cstring M_CLGI = _FT("clgi"); +extern const fcml_cstring M_CLI = _FT("cli"); +extern const fcml_cstring M_CLTS = _FT("clts"); +extern const fcml_cstring M_CMC = _FT("cmc"); +extern const fcml_cstring M_CMOVA = _FT("cmova"); +extern const fcml_cstring M_CMOVAE = _FT("cmovae"); +extern const fcml_cstring M_CMOVB = _FT("cmovb"); +extern const fcml_cstring M_CMOVBE = _FT("cmovbe"); +extern const fcml_cstring M_CMOVC = _FT("cmovc"); +extern const fcml_cstring M_CMOVENE = _FT("cmovene"); +extern const fcml_cstring M_CMOVG = _FT("cmovg"); +extern const fcml_cstring M_CMOVGE = _FT("cmovge"); +extern const fcml_cstring M_CMOVL = _FT("cmovl"); +extern const fcml_cstring M_CMOVLE = _FT("cmovle"); +extern const fcml_cstring M_CMOVNA = _FT("cmovna"); +extern const fcml_cstring M_CMOVNAE = _FT("cmovnae"); +extern const fcml_cstring M_CMOVNB = _FT("cmovnb"); +extern const fcml_cstring M_CMOVNBE = _FT("cmovnbe"); +extern const fcml_cstring M_CMOVNC = _FT("cmovnc"); +extern const fcml_cstring M_CMOVNG = _FT("cmovng"); +extern const fcml_cstring M_CMOVNGE = _FT("cmovnge"); +extern const fcml_cstring M_CMOVNL = _FT("cmovnl"); +extern const fcml_cstring M_CMOVNLE = _FT("cmovnle"); +extern const fcml_cstring M_CMOVNO = _FT("cmovno"); +extern const fcml_cstring M_CMOVNP = _FT("cmovnp"); +extern const fcml_cstring M_CMOVNS = _FT("cmovns"); +extern const fcml_cstring M_CMOVNZ = _FT("cmovnz"); +extern const fcml_cstring M_CMOVO = _FT("cmovo"); +extern const fcml_cstring M_CMOVP = _FT("cmovp"); +extern const fcml_cstring M_CMOVPE = _FT("cmovpe"); +extern const fcml_cstring M_CMOVPO = _FT("cmovpo"); +extern const fcml_cstring M_CMOVS = _FT("cmovs"); +extern const fcml_cstring M_CMOVZ = _FT("cmovz"); +extern const fcml_cstring M_CMP = _FT("cmp"); +extern const fcml_cstring M_CMPEQPD = _FT("cmpeqpd"); +extern const fcml_cstring M_CMPEQPS = _FT("cmpeqps"); +extern const fcml_cstring M_CMPEQSD = _FT("cmpeqsd"); +extern const fcml_cstring M_CMPEQSS = _FT("cmpeqss"); +extern const fcml_cstring M_CMPLEPD = _FT("cmplepd"); +extern const fcml_cstring M_CMPLEPS = _FT("cmpleps"); +extern const fcml_cstring M_CMPLESD = _FT("cmplesd"); +extern const fcml_cstring M_CMPLESS = _FT("cmpless"); +extern const fcml_cstring M_CMPLTPD = _FT("cmpltpd"); +extern const fcml_cstring M_CMPLTPS = _FT("cmpltps"); +extern const fcml_cstring M_CMPLTSD = _FT("cmpltsd"); +extern const fcml_cstring M_CMPLTSS = _FT("cmpltss"); +extern const fcml_cstring M_CMPNEQPD = _FT("cmpneqpd"); +extern const fcml_cstring M_CMPNEQPS = _FT("cmpneqps"); +extern const fcml_cstring M_CMPNEQSD = _FT("cmpneqsd"); +extern const fcml_cstring M_CMPNEQSS = _FT("cmpneqss"); +extern const fcml_cstring M_CMPNLEPD = _FT("cmpnlepd"); +extern const fcml_cstring M_CMPNLEPS = _FT("cmpnleps"); +extern const fcml_cstring M_CMPNLESD = _FT("cmpnlesd"); +extern const fcml_cstring M_CMPNLESS = _FT("cmpnless"); +extern const fcml_cstring M_CMPNLTPD = _FT("cmpnltpd"); +extern const fcml_cstring M_CMPNLTPS = _FT("cmpnltps"); +extern const fcml_cstring M_CMPNLTSD = _FT("cmpnltsd"); +extern const fcml_cstring M_CMPNLTSS = _FT("cmpnltss"); +extern const fcml_cstring M_CMPORDPD = _FT("cmpordpd"); +extern const fcml_cstring M_CMPORDPS = _FT("cmpordps"); +extern const fcml_cstring M_CMPORDSD = _FT("cmpordsd"); +extern const fcml_cstring M_CMPORDSS = _FT("cmpordss"); +extern const fcml_cstring M_CMPPD = _FT("cmppd"); +extern const fcml_cstring M_CMPPS = _FT("cmpps"); +extern const fcml_cstring M_CMPS = _FT("cmps"); +extern const fcml_cstring M_CMPSB = _FT("cmpsb"); +extern const fcml_cstring M_CMPSD = _FT("cmpsd"); +extern const fcml_cstring M_CMPSQ = _FT("cmpsq"); +extern const fcml_cstring M_CMPSS = _FT("cmpss"); +extern const fcml_cstring M_CMPSW = _FT("cmpsw"); +extern const fcml_cstring M_CMPUNORDPD = _FT("cmpunordpd"); +extern const fcml_cstring M_CMPUNORDPS = _FT("cmpunordps"); +extern const fcml_cstring M_CMPUNORDSD = _FT("cmpunordsd"); +extern const fcml_cstring M_CMPUNORDSS = _FT("cmpunordss"); +extern const fcml_cstring M_CMPXCHG = _FT("cmpxchg"); +extern const fcml_cstring M_CMPXCHG16B = _FT("cmpxchg16b"); +extern const fcml_cstring M_CMPXCHG8B = _FT("cmpxchg8b"); +extern const fcml_cstring M_COMISD = _FT("comisd"); +extern const fcml_cstring M_COMISS = _FT("comiss"); +extern const fcml_cstring M_CPUID = _FT("cpuid"); +extern const fcml_cstring M_CQO = _FT("cqo"); +extern const fcml_cstring M_CRC32 = _FT("crc32"); +extern const fcml_cstring M_CVTDQ2PD = _FT("cvtdq2pd"); +extern const fcml_cstring M_CVTDQ2PS = _FT("cvtdq2ps"); +extern const fcml_cstring M_CVTPD2DQ = _FT("cvtpd2dq"); +extern const fcml_cstring M_CVTPD2PI = _FT("cvtpd2pi"); +extern const fcml_cstring M_CVTPD2PS = _FT("cvtpd2ps"); +extern const fcml_cstring M_CVTPI2PD = _FT("cvtpi2pd"); +extern const fcml_cstring M_CVTPI2PS = _FT("cvtpi2ps"); +extern const fcml_cstring M_CVTPS2DQ = _FT("cvtps2dq"); +extern const fcml_cstring M_CVTPS2PD = _FT("cvtps2pd"); +extern const fcml_cstring M_CVTPS2PI = _FT("cvtps2pi"); +extern const fcml_cstring M_CVTSD2SI = _FT("cvtsd2si"); +extern const fcml_cstring M_CVTSD2SS = _FT("cvtsd2ss"); +extern const fcml_cstring M_CVTSI2SD = _FT("cvtsi2sd"); +extern const fcml_cstring M_CVTSI2SS = _FT("cvtsi2ss"); +extern const fcml_cstring M_CVTSS2SD = _FT("cvtss2sd"); +extern const fcml_cstring M_CVTSS2SI = _FT("cvtss2si"); +extern const fcml_cstring M_CVTTPD2DQ = _FT("cvttpd2dq"); +extern const fcml_cstring M_CVTTPD2PI = _FT("cvttpd2pi"); +extern const fcml_cstring M_CVTTPS2DQ = _FT("cvttps2dq"); +extern const fcml_cstring M_CVTTPS2PI = _FT("cvttps2pi"); +extern const fcml_cstring M_CVTTSD2SI = _FT("cvttsd2si"); +extern const fcml_cstring M_CVTTSS2SI = _FT("cvttss2si"); +extern const fcml_cstring M_CWD = _FT("cwd"); +extern const fcml_cstring M_CWDE = _FT("cwde"); +extern const fcml_cstring M_DAA = _FT("daa"); +extern const fcml_cstring M_DAS = _FT("das"); +extern const fcml_cstring M_DEC = _FT("dec"); +extern const fcml_cstring M_DIV = _FT("div"); +extern const fcml_cstring M_DIVPD = _FT("divpd"); +extern const fcml_cstring M_DIVPS = _FT("divps"); +extern const fcml_cstring M_DIVSD = _FT("divsd"); +extern const fcml_cstring M_DIVSS = _FT("divss"); +extern const fcml_cstring M_DPPD = _FT("dppd"); +extern const fcml_cstring M_DPPS = _FT("dpps"); +extern const fcml_cstring M_EMMS = _FT("emms"); +extern const fcml_cstring M_ENTER = _FT("enter"); +extern const fcml_cstring M_EXTRACTPS = _FT("extractps"); +extern const fcml_cstring M_EXTRQ = _FT("extrq"); +extern const fcml_cstring M_F2XM1 = _FT("f2xm1"); +extern const fcml_cstring M_FABS = _FT("fabs"); +extern const fcml_cstring M_FADD = _FT("fadd"); +extern const fcml_cstring M_FADDP = _FT("faddp"); +extern const fcml_cstring M_FBLD = _FT("fbld"); +extern const fcml_cstring M_FBSTP = _FT("fbstp"); +extern const fcml_cstring M_FCHS = _FT("fchs"); +extern const fcml_cstring M_FCLEX = _FT("fclex"); +extern const fcml_cstring M_FCMOVB = _FT("fcmovb"); +extern const fcml_cstring M_FCMOVBE = _FT("fcmovbe"); +extern const fcml_cstring M_FCMOVE = _FT("fcmove"); +extern const fcml_cstring M_FCMOVNB = _FT("fcmovnb"); +extern const fcml_cstring M_FCMOVNBE = _FT("fcmovnbe"); +extern const fcml_cstring M_FCMOVNE = _FT("fcmovne"); +extern const fcml_cstring M_FCMOVNU = _FT("fcmovnu"); +extern const fcml_cstring M_FCMOVU = _FT("fcmovu"); +extern const fcml_cstring M_FCOM = _FT("fcom"); +extern const fcml_cstring M_FCOMI = _FT("fcomi"); +extern const fcml_cstring M_FCOMIP = _FT("fcomip"); +extern const fcml_cstring M_FCOMP = _FT("fcomp"); +extern const fcml_cstring M_FCOMPP = _FT("fcompp"); +extern const fcml_cstring M_FCOS = _FT("fcos"); +extern const fcml_cstring M_FDECSTP = _FT("fdecstp"); +extern const fcml_cstring M_FDIV = _FT("fdiv"); +extern const fcml_cstring M_FDIVP = _FT("fdivp"); +extern const fcml_cstring M_FDIVR = _FT("fdivr"); +extern const fcml_cstring M_FDIVRP = _FT("fdivrp"); +extern const fcml_cstring M_FEMMS = _FT("femms"); +extern const fcml_cstring M_FFREE = _FT("ffree"); +extern const fcml_cstring M_FIADD = _FT("fiadd"); +extern const fcml_cstring M_FICOM = _FT("ficom"); +extern const fcml_cstring M_FICOMP = _FT("ficomp"); +extern const fcml_cstring M_FIDIV = _FT("fidiv"); +extern const fcml_cstring M_FIDIVR = _FT("fidivr"); +extern const fcml_cstring M_FILD = _FT("fild"); +extern const fcml_cstring M_FIMUL = _FT("fimul"); +extern const fcml_cstring M_FINCSTP = _FT("fincstp"); +extern const fcml_cstring M_FINIT = _FT("finit"); +extern const fcml_cstring M_FIST = _FT("fist"); +extern const fcml_cstring M_FISTP = _FT("fistp"); +extern const fcml_cstring M_FISTTP = _FT("fisttp"); +extern const fcml_cstring M_FISUB = _FT("fisub"); +extern const fcml_cstring M_FISUBR = _FT("fisubr"); +extern const fcml_cstring M_FLD = _FT("fld"); +extern const fcml_cstring M_FLD1 = _FT("fld1"); +extern const fcml_cstring M_FLDCW = _FT("fldcw"); +extern const fcml_cstring M_FLDENV = _FT("fldenv"); +extern const fcml_cstring M_FLDL2E = _FT("fldl2e"); +extern const fcml_cstring M_FLDL2T = _FT("fldl2t"); +extern const fcml_cstring M_FLDLG2 = _FT("fldlg2"); +extern const fcml_cstring M_FLDLN2 = _FT("fldln2"); +extern const fcml_cstring M_FLDPI = _FT("fldpi"); +extern const fcml_cstring M_FLDZ = _FT("fldz"); +extern const fcml_cstring M_FMUL = _FT("fmul"); +extern const fcml_cstring M_FMULP = _FT("fmulp"); +extern const fcml_cstring M_FNCLEX = _FT("fnclex"); +extern const fcml_cstring M_FNINIT = _FT("fninit"); +extern const fcml_cstring M_FNOP = _FT("fnop"); +extern const fcml_cstring M_FNSAVE = _FT("fnsave"); +extern const fcml_cstring M_FNSTCW = _FT("fnstcw"); +extern const fcml_cstring M_FNSTENV = _FT("fnstenv"); +extern const fcml_cstring M_FNSTSW = _FT("fnstsw"); +extern const fcml_cstring M_FPATAN = _FT("fpatan"); +extern const fcml_cstring M_FPREM = _FT("fprem"); +extern const fcml_cstring M_FPREM1 = _FT("fprem1"); +extern const fcml_cstring M_FPTAN = _FT("fptan"); +extern const fcml_cstring M_FRNDINT = _FT("frndint"); +extern const fcml_cstring M_FRSTOR = _FT("frstor"); +extern const fcml_cstring M_FSAVE = _FT("fsave"); +extern const fcml_cstring M_FSCALE = _FT("fscale"); +extern const fcml_cstring M_FSIN = _FT("fsin"); +extern const fcml_cstring M_FSINCOS = _FT("fsincos"); +extern const fcml_cstring M_FSQRT = _FT("fsqrt"); +extern const fcml_cstring M_FST = _FT("fst"); +extern const fcml_cstring M_FSTCW = _FT("fstcw"); +extern const fcml_cstring M_FSTENV = _FT("fstenv"); +extern const fcml_cstring M_FSTP = _FT("fstp"); +extern const fcml_cstring M_FSTSW = _FT("fstsw"); +extern const fcml_cstring M_FSUB = _FT("fsub"); +extern const fcml_cstring M_FSUBP = _FT("fsubp"); +extern const fcml_cstring M_FSUBR = _FT("fsubr"); +extern const fcml_cstring M_FSUBRP = _FT("fsubrp"); +extern const fcml_cstring M_FTST = _FT("ftst"); +extern const fcml_cstring M_FUCOM = _FT("fucom"); +extern const fcml_cstring M_FUCOMI = _FT("fucomi"); +extern const fcml_cstring M_FUCOMIP = _FT("fucomip"); +extern const fcml_cstring M_FUCOMP = _FT("fucomp"); +extern const fcml_cstring M_FUCOMPP = _FT("fucompp"); +extern const fcml_cstring M_FWAIT = _FT("fwait"); +extern const fcml_cstring M_FXAM = _FT("fxam"); +extern const fcml_cstring M_FXCH = _FT("fxch"); +extern const fcml_cstring M_FXRSTOR = _FT("fxrstor"); +extern const fcml_cstring M_FXRSTOR64 = _FT("fxrstor64"); +extern const fcml_cstring M_FXSAVE = _FT("fxsave"); +extern const fcml_cstring M_FXSAVE64 = _FT("fxsave64"); +extern const fcml_cstring M_FXTRACT = _FT("fxtract"); +extern const fcml_cstring M_FYL2X = _FT("fyl2x"); +extern const fcml_cstring M_FYL2XP1 = _FT("fyl2xp1"); +extern const fcml_cstring M_GETSEC = _FT("getsec"); +extern const fcml_cstring M_HADDPD = _FT("haddpd"); +extern const fcml_cstring M_HADDPS = _FT("haddps"); +extern const fcml_cstring M_HLT = _FT("hlt"); +extern const fcml_cstring M_HSUBPD = _FT("hsubpd"); +extern const fcml_cstring M_HSUBPS = _FT("hsubps"); +extern const fcml_cstring M_IDIV = _FT("idiv"); +extern const fcml_cstring M_IMUL = _FT("imul"); +extern const fcml_cstring M_IN = _FT("in"); +extern const fcml_cstring M_INC = _FT("inc"); +extern const fcml_cstring M_INS = _FT("ins"); +extern const fcml_cstring M_INSB = _FT("insb"); +extern const fcml_cstring M_INSD = _FT("insd"); +extern const fcml_cstring M_INSERTPS = _FT("insertps"); +extern const fcml_cstring M_INSERTQ = _FT("insertq"); +extern const fcml_cstring M_INSW = _FT("insw"); +extern const fcml_cstring M_INT = _FT("int"); +extern const fcml_cstring M_INT3 = _FT("int3"); +extern const fcml_cstring M_INTO = _FT("into"); +extern const fcml_cstring M_INVD = _FT("invd"); +extern const fcml_cstring M_INVEPT = _FT("invept"); +extern const fcml_cstring M_INVLPG = _FT("invlpg"); +extern const fcml_cstring M_INVLPGA = _FT("invlpga"); +extern const fcml_cstring M_INVPCID = _FT("invpcid"); +extern const fcml_cstring M_INVVPID = _FT("invvpid"); +extern const fcml_cstring M_IRET = _FT("iret"); +extern const fcml_cstring M_IRETD = _FT("iretd"); +extern const fcml_cstring M_IRETQ = _FT("iretq"); +extern const fcml_cstring M_JA = _FT("ja"); +extern const fcml_cstring M_JAE = _FT("jae"); +extern const fcml_cstring M_JB = _FT("jb"); +extern const fcml_cstring M_JBE = _FT("jbe"); +extern const fcml_cstring M_JC = _FT("jc"); +extern const fcml_cstring M_JCXZ = _FT("jcxz"); +extern const fcml_cstring M_JECXZ = _FT("jecxz"); +extern const fcml_cstring M_JENE = _FT("jene"); +extern const fcml_cstring M_JG = _FT("jg"); +extern const fcml_cstring M_JGE = _FT("jge"); +extern const fcml_cstring M_JL = _FT("jl"); +extern const fcml_cstring M_JLE = _FT("jle"); +extern const fcml_cstring M_JMP = _FT("jmp"); +extern const fcml_cstring M_JNA = _FT("jna"); +extern const fcml_cstring M_JNAE = _FT("jnae"); +extern const fcml_cstring M_JNB = _FT("jnb"); +extern const fcml_cstring M_JNBE = _FT("jnbe"); +extern const fcml_cstring M_JNC = _FT("jnc"); +extern const fcml_cstring M_JNG = _FT("jng"); +extern const fcml_cstring M_JNGE = _FT("jnge"); +extern const fcml_cstring M_JNL = _FT("jnl"); +extern const fcml_cstring M_JNLE = _FT("jnle"); +extern const fcml_cstring M_JNO = _FT("jno"); +extern const fcml_cstring M_JNP = _FT("jnp"); +extern const fcml_cstring M_JNS = _FT("jns"); +extern const fcml_cstring M_JNZ = _FT("jnz"); +extern const fcml_cstring M_JO = _FT("jo"); +extern const fcml_cstring M_JP = _FT("jp"); +extern const fcml_cstring M_JPE = _FT("jpe"); +extern const fcml_cstring M_JPO = _FT("jpo"); +extern const fcml_cstring M_JRCXZ = _FT("jrcxz"); +extern const fcml_cstring M_JS = _FT("js"); +extern const fcml_cstring M_JZ = _FT("jz"); +extern const fcml_cstring M_KADDB = _FT("kaddb"); +extern const fcml_cstring M_KADDD = _FT("kaddd"); +extern const fcml_cstring M_KADDQ = _FT("kaddq"); +extern const fcml_cstring M_KADDW = _FT("kaddw"); +extern const fcml_cstring M_KANDB = _FT("kandb"); +extern const fcml_cstring M_KANDD = _FT("kandd"); +extern const fcml_cstring M_KANDNB = _FT("kandnb"); +extern const fcml_cstring M_KANDND = _FT("kandnd"); +extern const fcml_cstring M_KANDNQ = _FT("kandnq"); +extern const fcml_cstring M_KANDNW = _FT("kandnw"); +extern const fcml_cstring M_KANDQ = _FT("kandq"); +extern const fcml_cstring M_KANDW = _FT("kandw"); +extern const fcml_cstring M_KMOVB = _FT("kmovb"); +extern const fcml_cstring M_KMOVD = _FT("kmovd"); +extern const fcml_cstring M_KMOVQ = _FT("kmovq"); +extern const fcml_cstring M_KMOVW = _FT("kmovw"); +extern const fcml_cstring M_KNOTB = _FT("knotb"); +extern const fcml_cstring M_KNOTD = _FT("knotd"); +extern const fcml_cstring M_KNOTQ = _FT("knotq"); +extern const fcml_cstring M_KNOTW = _FT("knotw"); +extern const fcml_cstring M_KORB = _FT("korb"); +extern const fcml_cstring M_KORD = _FT("kord"); +extern const fcml_cstring M_KORQ = _FT("korq"); +extern const fcml_cstring M_KORTESTB = _FT("kortestb"); +extern const fcml_cstring M_KORTESTD = _FT("kortestd"); +extern const fcml_cstring M_KORTESTQ = _FT("kortestq"); +extern const fcml_cstring M_KORTESTW = _FT("kortestw"); +extern const fcml_cstring M_KORW = _FT("korw"); +extern const fcml_cstring M_KSHIFTLB = _FT("kshiftlb"); +extern const fcml_cstring M_KSHIFTLD = _FT("kshiftld"); +extern const fcml_cstring M_KSHIFTLQ = _FT("kshiftlq"); +extern const fcml_cstring M_KSHIFTLW = _FT("kshiftlw"); +extern const fcml_cstring M_KSHIFTRB = _FT("kshiftrb"); +extern const fcml_cstring M_KSHIFTRD = _FT("kshiftrd"); +extern const fcml_cstring M_KSHIFTRQ = _FT("kshiftrq"); +extern const fcml_cstring M_KSHIFTRW = _FT("kshiftrw"); +extern const fcml_cstring M_KTESTB = _FT("ktestb"); +extern const fcml_cstring M_KTESTD = _FT("ktestd"); +extern const fcml_cstring M_KTESTQ = _FT("ktestq"); +extern const fcml_cstring M_KTESTW = _FT("ktestw"); +extern const fcml_cstring M_KXNORB = _FT("kxnorb"); +extern const fcml_cstring M_KXNORD = _FT("kxnord"); +extern const fcml_cstring M_KXNORQ = _FT("kxnorq"); +extern const fcml_cstring M_KXNORW = _FT("kxnorw"); +extern const fcml_cstring M_KXORB = _FT("kxorb"); +extern const fcml_cstring M_KXORD = _FT("kxord"); +extern const fcml_cstring M_KXORQ = _FT("kxorq"); +extern const fcml_cstring M_KXORW = _FT("kxorw"); +extern const fcml_cstring M_LAHF = _FT("lahf"); +extern const fcml_cstring M_LAR = _FT("lar"); +extern const fcml_cstring M_LDDQU = _FT("lddqu"); +extern const fcml_cstring M_LDMXCSR = _FT("ldmxcsr"); +extern const fcml_cstring M_LDS = _FT("lds"); +extern const fcml_cstring M_LEA = _FT("lea"); +extern const fcml_cstring M_LEAVE = _FT("leave"); +extern const fcml_cstring M_LES = _FT("les"); +extern const fcml_cstring M_LFENCE = _FT("lfence"); +extern const fcml_cstring M_LFS = _FT("lfs"); +extern const fcml_cstring M_LGDT = _FT("lgdt"); +extern const fcml_cstring M_LGS = _FT("lgs"); +extern const fcml_cstring M_LIDT = _FT("lidt"); +extern const fcml_cstring M_LLDT = _FT("lldt"); +extern const fcml_cstring M_LLWPCB = _FT("llwpcb"); +extern const fcml_cstring M_LMSW = _FT("lmsw"); +extern const fcml_cstring M_LODS = _FT("lods"); +extern const fcml_cstring M_LODSB = _FT("lodsb"); +extern const fcml_cstring M_LODSD = _FT("lodsd"); +extern const fcml_cstring M_LODSQ = _FT("lodsq"); +extern const fcml_cstring M_LODSW = _FT("lodsw"); +extern const fcml_cstring M_LOOP = _FT("loop"); +extern const fcml_cstring M_LOOPE = _FT("loope"); +extern const fcml_cstring M_LOOPNE = _FT("loopne"); +extern const fcml_cstring M_LOOPNZ = _FT("loopnz"); +extern const fcml_cstring M_LOOPZ = _FT("loopz"); +extern const fcml_cstring M_LSL = _FT("lsl"); +extern const fcml_cstring M_LSS = _FT("lss"); +extern const fcml_cstring M_LTR = _FT("ltr"); +extern const fcml_cstring M_LWPINS = _FT("lwpins"); +extern const fcml_cstring M_LWPVAL = _FT("lwpval"); +extern const fcml_cstring M_LZCNT = _FT("lzcnt"); +extern const fcml_cstring M_MASKMOVDQU = _FT("maskmovdqu"); +extern const fcml_cstring M_MASKMOVQ = _FT("maskmovq"); +extern const fcml_cstring M_MAXPD = _FT("maxpd"); +extern const fcml_cstring M_MAXPS = _FT("maxps"); +extern const fcml_cstring M_MAXSD = _FT("maxsd"); +extern const fcml_cstring M_MAXSS = _FT("maxss"); +extern const fcml_cstring M_MFENCE = _FT("mfence"); +extern const fcml_cstring M_MINPD = _FT("minpd"); +extern const fcml_cstring M_MINPS = _FT("minps"); +extern const fcml_cstring M_MINSD = _FT("minsd"); +extern const fcml_cstring M_MINSS = _FT("minss"); +extern const fcml_cstring M_MONITOR = _FT("monitor"); +extern const fcml_cstring M_MOV = _FT("mov"); +extern const fcml_cstring M_MOVAPD = _FT("movapd"); +extern const fcml_cstring M_MOVAPS = _FT("movaps"); +extern const fcml_cstring M_MOVBE = _FT("movbe"); +extern const fcml_cstring M_MOVD = _FT("movd"); +extern const fcml_cstring M_MOVDDUP = _FT("movddup"); +extern const fcml_cstring M_MOVDQ2Q = _FT("movdq2q"); +extern const fcml_cstring M_MOVDQA = _FT("movdqa"); +extern const fcml_cstring M_MOVDQU = _FT("movdqu"); +extern const fcml_cstring M_MOVHLPS = _FT("movhlps"); +extern const fcml_cstring M_MOVHPD = _FT("movhpd"); +extern const fcml_cstring M_MOVHPS = _FT("movhps"); +extern const fcml_cstring M_MOVLHPS = _FT("movlhps"); +extern const fcml_cstring M_MOVLPD = _FT("movlpd"); +extern const fcml_cstring M_MOVLPS = _FT("movlps"); +extern const fcml_cstring M_MOVMSKPD = _FT("movmskpd"); +extern const fcml_cstring M_MOVMSKPS = _FT("movmskps"); +extern const fcml_cstring M_MOVNTDQ = _FT("movntdq"); +extern const fcml_cstring M_MOVNTDQA = _FT("movntdqa"); +extern const fcml_cstring M_MOVNTI = _FT("movnti"); +extern const fcml_cstring M_MOVNTPD = _FT("movntpd"); +extern const fcml_cstring M_MOVNTPS = _FT("movntps"); +extern const fcml_cstring M_MOVNTQ = _FT("movntq"); +extern const fcml_cstring M_MOVNTSD = _FT("movntsd"); +extern const fcml_cstring M_MOVNTSS = _FT("movntss"); +extern const fcml_cstring M_MOVQ = _FT("movq"); +extern const fcml_cstring M_MOVQ2DQ = _FT("movq2dq"); +extern const fcml_cstring M_MOVS = _FT("movs"); +extern const fcml_cstring M_MOVSB = _FT("movsb"); +extern const fcml_cstring M_MOVSD = _FT("movsd"); +extern const fcml_cstring M_MOVSHDUP = _FT("movshdup"); +extern const fcml_cstring M_MOVSLDUP = _FT("movsldup"); +extern const fcml_cstring M_MOVSQ = _FT("movsq"); +extern const fcml_cstring M_MOVSS = _FT("movss"); +extern const fcml_cstring M_MOVSW = _FT("movsw"); +extern const fcml_cstring M_MOVSX = _FT("movsx"); +extern const fcml_cstring M_MOVSXD = _FT("movsxd"); +extern const fcml_cstring M_MOVUPD = _FT("movupd"); +extern const fcml_cstring M_MOVUPS = _FT("movups"); +extern const fcml_cstring M_MOVZX = _FT("movzx"); +extern const fcml_cstring M_MPSADBW = _FT("mpsadbw"); +extern const fcml_cstring M_MUL = _FT("mul"); +extern const fcml_cstring M_MULPD = _FT("mulpd"); +extern const fcml_cstring M_MULPS = _FT("mulps"); +extern const fcml_cstring M_MULSD = _FT("mulsd"); +extern const fcml_cstring M_MULSS = _FT("mulss"); +extern const fcml_cstring M_MULX = _FT("mulx"); +extern const fcml_cstring M_MWAIT = _FT("mwait"); +extern const fcml_cstring M_NEG = _FT("neg"); +extern const fcml_cstring M_NOP = _FT("nop"); +extern const fcml_cstring M_NOT = _FT("not"); +extern const fcml_cstring M_OR = _FT("or"); +extern const fcml_cstring M_ORPD = _FT("orpd"); +extern const fcml_cstring M_ORPS = _FT("orps"); +extern const fcml_cstring M_OUT = _FT("out"); +extern const fcml_cstring M_OUTS = _FT("outs"); +extern const fcml_cstring M_OUTSB = _FT("outsb"); +extern const fcml_cstring M_OUTSD = _FT("outsd"); +extern const fcml_cstring M_OUTSW = _FT("outsw"); +extern const fcml_cstring M_PABSB = _FT("pabsb"); +extern const fcml_cstring M_PABSD = _FT("pabsd"); +extern const fcml_cstring M_PABSW = _FT("pabsw"); +extern const fcml_cstring M_PACKSSDW = _FT("packssdw"); +extern const fcml_cstring M_PACKSSWB = _FT("packsswb"); +extern const fcml_cstring M_PACKUSDW = _FT("packusdw"); +extern const fcml_cstring M_PACKUSWB = _FT("packuswb"); +extern const fcml_cstring M_PADDB = _FT("paddb"); +extern const fcml_cstring M_PADDD = _FT("paddd"); +extern const fcml_cstring M_PADDQ = _FT("paddq"); +extern const fcml_cstring M_PADDSB = _FT("paddsb"); +extern const fcml_cstring M_PADDSW = _FT("paddsw"); +extern const fcml_cstring M_PADDUSB = _FT("paddusb"); +extern const fcml_cstring M_PADDUSW = _FT("paddusw"); +extern const fcml_cstring M_PADDW = _FT("paddw"); +extern const fcml_cstring M_PALIGNR = _FT("palignr"); +extern const fcml_cstring M_PAND = _FT("pand"); +extern const fcml_cstring M_PANDN = _FT("pandn"); +extern const fcml_cstring M_PAUSE = _FT("pause"); +extern const fcml_cstring M_PAVGB = _FT("pavgb"); +extern const fcml_cstring M_PAVGUSB = _FT("pavgusb"); +extern const fcml_cstring M_PAVGW = _FT("pavgw"); +extern const fcml_cstring M_PBLENDVB = _FT("pblendvb"); +extern const fcml_cstring M_PBLENDW = _FT("pblendw"); +extern const fcml_cstring M_PCLMULQDQ = _FT("pclmulqdq"); +extern const fcml_cstring M_PCMPEQB = _FT("pcmpeqb"); +extern const fcml_cstring M_PCMPEQD = _FT("pcmpeqd"); +extern const fcml_cstring M_PCMPEQQ = _FT("pcmpeqq"); +extern const fcml_cstring M_PCMPEQW = _FT("pcmpeqw"); +extern const fcml_cstring M_PCMPESTRI = _FT("pcmpestri"); +extern const fcml_cstring M_PCMPESTRM = _FT("pcmpestrm"); +extern const fcml_cstring M_PCMPGTB = _FT("pcmpgtb"); +extern const fcml_cstring M_PCMPGTD = _FT("pcmpgtd"); +extern const fcml_cstring M_PCMPGTQ = _FT("pcmpgtq"); +extern const fcml_cstring M_PCMPGTW = _FT("pcmpgtw"); +extern const fcml_cstring M_PCMPISTRI = _FT("pcmpistri"); +extern const fcml_cstring M_PCMPISTRM = _FT("pcmpistrm"); +extern const fcml_cstring M_PDEP = _FT("pdep"); +extern const fcml_cstring M_PEXT = _FT("pext"); +extern const fcml_cstring M_PEXTRB = _FT("pextrb"); +extern const fcml_cstring M_PEXTRD = _FT("pextrd"); +extern const fcml_cstring M_PEXTRQ = _FT("pextrq"); +extern const fcml_cstring M_PEXTRW = _FT("pextrw"); +extern const fcml_cstring M_PF2ID = _FT("pf2id"); +extern const fcml_cstring M_PF2IW = _FT("pf2iw"); +extern const fcml_cstring M_PFACC = _FT("pfacc"); +extern const fcml_cstring M_PFADD = _FT("pfadd"); +extern const fcml_cstring M_PFCMPEQ = _FT("pfcmpeq"); +extern const fcml_cstring M_PFCMPGE = _FT("pfcmpge"); +extern const fcml_cstring M_PFCMPGT = _FT("pfcmpgt"); +extern const fcml_cstring M_PFMAX = _FT("pfmax"); +extern const fcml_cstring M_PFMIN = _FT("pfmin"); +extern const fcml_cstring M_PFMUL = _FT("pfmul"); +extern const fcml_cstring M_PFNACC = _FT("pfnacc"); +extern const fcml_cstring M_PFPNACC = _FT("pfpnacc"); +extern const fcml_cstring M_PFRCP = _FT("pfrcp"); +extern const fcml_cstring M_PFRCPIT1 = _FT("pfrcpit1"); +extern const fcml_cstring M_PFRCPIT2 = _FT("pfrcpit2"); +extern const fcml_cstring M_PFRSQIT1 = _FT("pfrsqit1"); +extern const fcml_cstring M_PFRSQRT = _FT("pfrsqrt"); +extern const fcml_cstring M_PFSUB = _FT("pfsub"); +extern const fcml_cstring M_PFSUBR = _FT("pfsubr"); +extern const fcml_cstring M_PHADDD = _FT("phaddd"); +extern const fcml_cstring M_PHADDSW = _FT("phaddsw"); +extern const fcml_cstring M_PHADDW = _FT("phaddw"); +extern const fcml_cstring M_PHMINPOSUW = _FT("phminposuw"); +extern const fcml_cstring M_PHSUBD = _FT("phsubd"); +extern const fcml_cstring M_PHSUBSW = _FT("phsubsw"); +extern const fcml_cstring M_PHSUBW = _FT("phsubw"); +extern const fcml_cstring M_PI2FD = _FT("pi2fd"); +extern const fcml_cstring M_PI2FW = _FT("pi2fw"); +extern const fcml_cstring M_PINSRB = _FT("pinsrb"); +extern const fcml_cstring M_PINSRD = _FT("pinsrd"); +extern const fcml_cstring M_PINSRQ = _FT("pinsrq"); +extern const fcml_cstring M_PINSRW = _FT("pinsrw"); +extern const fcml_cstring M_PMADDUBSW = _FT("pmaddubsw"); +extern const fcml_cstring M_PMADDWD = _FT("pmaddwd"); +extern const fcml_cstring M_PMAXSB = _FT("pmaxsb"); +extern const fcml_cstring M_PMAXSD = _FT("pmaxsd"); +extern const fcml_cstring M_PMAXSW = _FT("pmaxsw"); +extern const fcml_cstring M_PMAXUB = _FT("pmaxub"); +extern const fcml_cstring M_PMAXUD = _FT("pmaxud"); +extern const fcml_cstring M_PMAXUW = _FT("pmaxuw"); +extern const fcml_cstring M_PMINSB = _FT("pminsb"); +extern const fcml_cstring M_PMINSD = _FT("pminsd"); +extern const fcml_cstring M_PMINSW = _FT("pminsw"); +extern const fcml_cstring M_PMINUB = _FT("pminub"); +extern const fcml_cstring M_PMINUD = _FT("pminud"); +extern const fcml_cstring M_PMINUW = _FT("pminuw"); +extern const fcml_cstring M_PMOVMSKB = _FT("pmovmskb"); +extern const fcml_cstring M_PMOVSXBD = _FT("pmovsxbd"); +extern const fcml_cstring M_PMOVSXBQ = _FT("pmovsxbq"); +extern const fcml_cstring M_PMOVSXBW = _FT("pmovsxbw"); +extern const fcml_cstring M_PMOVSXDQ = _FT("pmovsxdq"); +extern const fcml_cstring M_PMOVSXWD = _FT("pmovsxwd"); +extern const fcml_cstring M_PMOVSXWQ = _FT("pmovsxwq"); +extern const fcml_cstring M_PMOVZXBD = _FT("pmovzxbd"); +extern const fcml_cstring M_PMOVZXBQ = _FT("pmovzxbq"); +extern const fcml_cstring M_PMOVZXBW = _FT("pmovzxbw"); +extern const fcml_cstring M_PMOVZXDQ = _FT("pmovzxdq"); +extern const fcml_cstring M_PMOVZXWD = _FT("pmovzxwd"); +extern const fcml_cstring M_PMOVZXWQ = _FT("pmovzxwq"); +extern const fcml_cstring M_PMULDQ = _FT("pmuldq"); +extern const fcml_cstring M_PMULHRSW = _FT("pmulhrsw"); +extern const fcml_cstring M_PMULHRW = _FT("pmulhrw"); +extern const fcml_cstring M_PMULHUW = _FT("pmulhuw"); +extern const fcml_cstring M_PMULHW = _FT("pmulhw"); +extern const fcml_cstring M_PMULLD = _FT("pmulld"); +extern const fcml_cstring M_PMULLW = _FT("pmullw"); +extern const fcml_cstring M_PMULUDQ = _FT("pmuludq"); +extern const fcml_cstring M_POP = _FT("pop"); +extern const fcml_cstring M_POPA = _FT("popa"); +extern const fcml_cstring M_POPAD = _FT("popad"); +extern const fcml_cstring M_POPCNT = _FT("popcnt"); +extern const fcml_cstring M_POPF = _FT("popf"); +extern const fcml_cstring M_POPFD = _FT("popfd"); +extern const fcml_cstring M_POPFQ = _FT("popfq"); +extern const fcml_cstring M_POR = _FT("por"); +extern const fcml_cstring M_PREFETCH = _FT("prefetch"); +extern const fcml_cstring M_PREFETCHNTA = _FT("prefetchnta"); +extern const fcml_cstring M_PREFETCHT0 = _FT("prefetcht0"); +extern const fcml_cstring M_PREFETCHT1 = _FT("prefetcht1"); +extern const fcml_cstring M_PREFETCHT2 = _FT("prefetcht2"); +extern const fcml_cstring M_PREFETCHW = _FT("prefetchw"); +extern const fcml_cstring M_PREFETCHWT1 = _FT("prefetchwt1"); +extern const fcml_cstring M_PSADBW = _FT("psadbw"); +extern const fcml_cstring M_PSHUFB = _FT("pshufb"); +extern const fcml_cstring M_PSHUFD = _FT("pshufd"); +extern const fcml_cstring M_PSHUFHW = _FT("pshufhw"); +extern const fcml_cstring M_PSHUFLW = _FT("pshuflw"); +extern const fcml_cstring M_PSHUFW = _FT("pshufw"); +extern const fcml_cstring M_PSIGNB = _FT("psignb"); +extern const fcml_cstring M_PSIGND = _FT("psignd"); +extern const fcml_cstring M_PSIGNW = _FT("psignw"); +extern const fcml_cstring M_PSLLD = _FT("pslld"); +extern const fcml_cstring M_PSLLDQ = _FT("pslldq"); +extern const fcml_cstring M_PSLLQ = _FT("psllq"); +extern const fcml_cstring M_PSLLW = _FT("psllw"); +extern const fcml_cstring M_PSRAD = _FT("psrad"); +extern const fcml_cstring M_PSRAW = _FT("psraw"); +extern const fcml_cstring M_PSRLD = _FT("psrld"); +extern const fcml_cstring M_PSRLDQ = _FT("psrldq"); +extern const fcml_cstring M_PSRLQ = _FT("psrlq"); +extern const fcml_cstring M_PSRLW = _FT("psrlw"); +extern const fcml_cstring M_PSUBB = _FT("psubb"); +extern const fcml_cstring M_PSUBD = _FT("psubd"); +extern const fcml_cstring M_PSUBQ = _FT("psubq"); +extern const fcml_cstring M_PSUBSB = _FT("psubsb"); +extern const fcml_cstring M_PSUBSW = _FT("psubsw"); +extern const fcml_cstring M_PSUBUSB = _FT("psubusb"); +extern const fcml_cstring M_PSUBUSW = _FT("psubusw"); +extern const fcml_cstring M_PSUBW = _FT("psubw"); +extern const fcml_cstring M_PSWAPD = _FT("pswapd"); +extern const fcml_cstring M_PTEST = _FT("ptest"); +extern const fcml_cstring M_PUNPCKHBW = _FT("punpckhbw"); +extern const fcml_cstring M_PUNPCKHDQ = _FT("punpckhdq"); +extern const fcml_cstring M_PUNPCKHQDQ = _FT("punpckhqdq"); +extern const fcml_cstring M_PUNPCKHWD = _FT("punpckhwd"); +extern const fcml_cstring M_PUNPCKLBW = _FT("punpcklbw"); +extern const fcml_cstring M_PUNPCKLDQ = _FT("punpckldq"); +extern const fcml_cstring M_PUNPCKLQDQ = _FT("punpcklqdq"); +extern const fcml_cstring M_PUNPCKLWD = _FT("punpcklwd"); +extern const fcml_cstring M_PUSH = _FT("push"); +extern const fcml_cstring M_PUSHA = _FT("pusha"); +extern const fcml_cstring M_PUSHAD = _FT("pushad"); +extern const fcml_cstring M_PUSHF = _FT("pushf"); +extern const fcml_cstring M_PUSHFD = _FT("pushfd"); +extern const fcml_cstring M_PUSHFQ = _FT("pushfq"); +extern const fcml_cstring M_PXOR = _FT("pxor"); +extern const fcml_cstring M_RCL = _FT("rcl"); +extern const fcml_cstring M_RCPPS = _FT("rcpps"); +extern const fcml_cstring M_RCPSS = _FT("rcpss"); +extern const fcml_cstring M_RCR = _FT("rcr"); +extern const fcml_cstring M_RDFSBASE = _FT("rdfsbase"); +extern const fcml_cstring M_RDGSBASE = _FT("rdgsbase"); +extern const fcml_cstring M_RDMSR = _FT("rdmsr"); +extern const fcml_cstring M_RDPMC = _FT("rdpmc"); +extern const fcml_cstring M_RDRAND = _FT("rdrand"); +extern const fcml_cstring M_RDSEED = _FT("rdseed"); +extern const fcml_cstring M_RDTSC = _FT("rdtsc"); +extern const fcml_cstring M_RDTSCP = _FT("rdtscp"); +extern const fcml_cstring M_RET = _FT("ret"); +extern const fcml_cstring M_RETF = _FT("retf"); +extern const fcml_cstring M_ROL = _FT("rol"); +extern const fcml_cstring M_ROR = _FT("ror"); +extern const fcml_cstring M_RORX = _FT("rorx"); +extern const fcml_cstring M_ROUNDPD = _FT("roundpd"); +extern const fcml_cstring M_ROUNDPS = _FT("roundps"); +extern const fcml_cstring M_ROUNDSD = _FT("roundsd"); +extern const fcml_cstring M_ROUNDSS = _FT("roundss"); +extern const fcml_cstring M_RSM = _FT("rsm"); +extern const fcml_cstring M_RSQRTPS = _FT("rsqrtps"); +extern const fcml_cstring M_RSQRTSS = _FT("rsqrtss"); +extern const fcml_cstring M_SAHF = _FT("sahf"); +extern const fcml_cstring M_SAL = _FT("sal"); +extern const fcml_cstring M_SAR = _FT("sar"); +extern const fcml_cstring M_SARX = _FT("sarx"); +extern const fcml_cstring M_SBB = _FT("sbb"); +extern const fcml_cstring M_SCAS = _FT("scas"); +extern const fcml_cstring M_SCASB = _FT("scasb"); +extern const fcml_cstring M_SCASD = _FT("scasd"); +extern const fcml_cstring M_SCASQ = _FT("scasq"); +extern const fcml_cstring M_SCASW = _FT("scasw"); +extern const fcml_cstring M_SETA = _FT("seta"); +extern const fcml_cstring M_SETAE = _FT("setae"); +extern const fcml_cstring M_SETB = _FT("setb"); +extern const fcml_cstring M_SETBE = _FT("setbe"); +extern const fcml_cstring M_SETC = _FT("setc"); +extern const fcml_cstring M_SETENE = _FT("setene"); +extern const fcml_cstring M_SETG = _FT("setg"); +extern const fcml_cstring M_SETGE = _FT("setge"); +extern const fcml_cstring M_SETL = _FT("setl"); +extern const fcml_cstring M_SETLE = _FT("setle"); +extern const fcml_cstring M_SETNA = _FT("setna"); +extern const fcml_cstring M_SETNAE = _FT("setnae"); +extern const fcml_cstring M_SETNB = _FT("setnb"); +extern const fcml_cstring M_SETNBE = _FT("setnbe"); +extern const fcml_cstring M_SETNC = _FT("setnc"); +extern const fcml_cstring M_SETNG = _FT("setng"); +extern const fcml_cstring M_SETNGE = _FT("setnge"); +extern const fcml_cstring M_SETNL = _FT("setnl"); +extern const fcml_cstring M_SETNLE = _FT("setnle"); +extern const fcml_cstring M_SETNO = _FT("setno"); +extern const fcml_cstring M_SETNP = _FT("setnp"); +extern const fcml_cstring M_SETNS = _FT("setns"); +extern const fcml_cstring M_SETNZ = _FT("setnz"); +extern const fcml_cstring M_SETO = _FT("seto"); +extern const fcml_cstring M_SETP = _FT("setp"); +extern const fcml_cstring M_SETPE = _FT("setpe"); +extern const fcml_cstring M_SETPO = _FT("setpo"); +extern const fcml_cstring M_SETS = _FT("sets"); +extern const fcml_cstring M_SETZ = _FT("setz"); +extern const fcml_cstring M_SFENCE = _FT("sfence"); +extern const fcml_cstring M_SGDT = _FT("sgdt"); +extern const fcml_cstring M_SHL = _FT("shl"); +extern const fcml_cstring M_SHLD = _FT("shld"); +extern const fcml_cstring M_SHLX = _FT("shlx"); +extern const fcml_cstring M_SHR = _FT("shr"); +extern const fcml_cstring M_SHRD = _FT("shrd"); +extern const fcml_cstring M_SHRX = _FT("shrx"); +extern const fcml_cstring M_SHUFPD = _FT("shufpd"); +extern const fcml_cstring M_SHUFPS = _FT("shufps"); +extern const fcml_cstring M_SIDT = _FT("sidt"); +extern const fcml_cstring M_SKINIT = _FT("skinit"); +extern const fcml_cstring M_SLDT = _FT("sldt"); +extern const fcml_cstring M_SLWPCB = _FT("slwpcb"); +extern const fcml_cstring M_SMSW = _FT("smsw"); +extern const fcml_cstring M_SQRTPD = _FT("sqrtpd"); +extern const fcml_cstring M_SQRTPS = _FT("sqrtps"); +extern const fcml_cstring M_SQRTSD = _FT("sqrtsd"); +extern const fcml_cstring M_SQRTSS = _FT("sqrtss"); +extern const fcml_cstring M_STAC = _FT("stac"); +extern const fcml_cstring M_STC = _FT("stc"); +extern const fcml_cstring M_STD = _FT("std"); +extern const fcml_cstring M_STGI = _FT("stgi"); +extern const fcml_cstring M_STI = _FT("sti"); +extern const fcml_cstring M_STMXCSR = _FT("stmxcsr"); +extern const fcml_cstring M_STOS = _FT("stos"); +extern const fcml_cstring M_STOSB = _FT("stosb"); +extern const fcml_cstring M_STOSD = _FT("stosd"); +extern const fcml_cstring M_STOSQ = _FT("stosq"); +extern const fcml_cstring M_STOSW = _FT("stosw"); +extern const fcml_cstring M_STR = _FT("str"); +extern const fcml_cstring M_SUB = _FT("sub"); +extern const fcml_cstring M_SUBPD = _FT("subpd"); +extern const fcml_cstring M_SUBPS = _FT("subps"); +extern const fcml_cstring M_SUBSD = _FT("subsd"); +extern const fcml_cstring M_SUBSS = _FT("subss"); +extern const fcml_cstring M_SWAPGS = _FT("swapgs"); +extern const fcml_cstring M_SYSCALL = _FT("syscall"); +extern const fcml_cstring M_SYSENTER = _FT("sysenter"); +extern const fcml_cstring M_SYSEXIT = _FT("sysexit"); +extern const fcml_cstring M_SYSRET = _FT("sysret"); +extern const fcml_cstring M_T1MSKC = _FT("t1mskc"); +extern const fcml_cstring M_TEST = _FT("test"); +extern const fcml_cstring M_TZCNT = _FT("tzcnt"); +extern const fcml_cstring M_TZMSK = _FT("tzmsk"); +extern const fcml_cstring M_UCOMISD = _FT("ucomisd"); +extern const fcml_cstring M_UCOMISS = _FT("ucomiss"); +extern const fcml_cstring M_UD2 = _FT("ud2"); +extern const fcml_cstring M_UNPCKHPD = _FT("unpckhpd"); +extern const fcml_cstring M_UNPCKHPS = _FT("unpckhps"); +extern const fcml_cstring M_UNPCKLPD = _FT("unpcklpd"); +extern const fcml_cstring M_UNPCKLPS = _FT("unpcklps"); +extern const fcml_cstring M_V4FMADDPS = _FT("v4fmaddps"); +extern const fcml_cstring M_V4FMADDSS = _FT("v4fmaddss"); +extern const fcml_cstring M_V4FNMADDPS = _FT("v4fnmaddps"); +extern const fcml_cstring M_V4FNMADDSS = _FT("v4fnmaddss"); +extern const fcml_cstring M_VADDPD = _FT("vaddpd"); +extern const fcml_cstring M_VADDPS = _FT("vaddps"); +extern const fcml_cstring M_VADDSD = _FT("vaddsd"); +extern const fcml_cstring M_VADDSS = _FT("vaddss"); +extern const fcml_cstring M_VADDSUBPD = _FT("vaddsubpd"); +extern const fcml_cstring M_VADDSUBPS = _FT("vaddsubps"); +extern const fcml_cstring M_VAESDEC = _FT("vaesdec"); +extern const fcml_cstring M_VAESDECLAST = _FT("vaesdeclast"); +extern const fcml_cstring M_VAESENC = _FT("vaesenc"); +extern const fcml_cstring M_VAESENCLAST = _FT("vaesenclast"); +extern const fcml_cstring M_VAESIMC = _FT("vaesimc"); +extern const fcml_cstring M_VAESKEYGENASSIST = _FT("vaeskeygenassist"); +extern const fcml_cstring M_VALIGND = _FT("valignd"); +extern const fcml_cstring M_VALIGNQ = _FT("valignq"); +extern const fcml_cstring M_VANDNPD = _FT("vandnpd"); +extern const fcml_cstring M_VANDNPS = _FT("vandnps"); +extern const fcml_cstring M_VANDPD = _FT("vandpd"); +extern const fcml_cstring M_VANDPS = _FT("vandps"); +extern const fcml_cstring M_VBLENDMPD = _FT("vblendmpd"); +extern const fcml_cstring M_VBLENDMPS = _FT("vblendmps"); +extern const fcml_cstring M_VBLENDPD = _FT("vblendpd"); +extern const fcml_cstring M_VBLENDPS = _FT("vblendps"); +extern const fcml_cstring M_VBLENDVPD = _FT("vblendvpd"); +extern const fcml_cstring M_VBLENDVPS = _FT("vblendvps"); +extern const fcml_cstring M_VBROADCASTF128 = _FT("vbroadcastf128"); +extern const fcml_cstring M_VBROADCASTF32X2 = _FT("vbroadcastf32x2"); +extern const fcml_cstring M_VBROADCASTF32X4 = _FT("vbroadcastf32x4"); +extern const fcml_cstring M_VBROADCASTF32X8 = _FT("vbroadcastf32x8"); +extern const fcml_cstring M_VBROADCASTF64X2 = _FT("vbroadcastf64x2"); +extern const fcml_cstring M_VBROADCASTF64X4 = _FT("vbroadcastf64x4"); +extern const fcml_cstring M_VBROADCASTI128 = _FT("vbroadcasti128"); +extern const fcml_cstring M_VBROADCASTI32X2 = _FT("vbroadcasti32x2"); +extern const fcml_cstring M_VBROADCASTI32X4 = _FT("vbroadcasti32x4"); +extern const fcml_cstring M_VBROADCASTI32X8 = _FT("vbroadcasti32x8"); +extern const fcml_cstring M_VBROADCASTI64X2 = _FT("vbroadcasti64x2"); +extern const fcml_cstring M_VBROADCASTI64X4 = _FT("vbroadcasti64x4"); +extern const fcml_cstring M_VBROADCASTSD = _FT("vbroadcastsd"); +extern const fcml_cstring M_VBROADCASTSS = _FT("vbroadcastss"); +extern const fcml_cstring M_VCMPEQ_OSPD = _FT("vcmpeq_ospd"); +extern const fcml_cstring M_VCMPEQ_OSPS = _FT("vcmpeq_osps"); +extern const fcml_cstring M_VCMPEQ_OSSD = _FT("vcmpeq_ossd"); +extern const fcml_cstring M_VCMPEQ_OSSS = _FT("vcmpeq_osss"); +extern const fcml_cstring M_VCMPEQ_UQPD = _FT("vcmpeq_uqpd"); +extern const fcml_cstring M_VCMPEQ_UQPS = _FT("vcmpeq_uqps"); +extern const fcml_cstring M_VCMPEQ_UQSD = _FT("vcmpeq_uqsd"); +extern const fcml_cstring M_VCMPEQ_UQSS = _FT("vcmpeq_uqss"); +extern const fcml_cstring M_VCMPEQ_USPD = _FT("vcmpeq_uspd"); +extern const fcml_cstring M_VCMPEQ_USPS = _FT("vcmpeq_usps"); +extern const fcml_cstring M_VCMPEQ_USSD = _FT("vcmpeq_ussd"); +extern const fcml_cstring M_VCMPEQ_USSS = _FT("vcmpeq_usss"); +extern const fcml_cstring M_VCMPEQPD = _FT("vcmpeqpd"); +extern const fcml_cstring M_VCMPEQPS = _FT("vcmpeqps"); +extern const fcml_cstring M_VCMPEQSD = _FT("vcmpeqsd"); +extern const fcml_cstring M_VCMPEQSS = _FT("vcmpeqss"); +extern const fcml_cstring M_VCMPFALSE_OSPD = _FT("vcmpfalse_ospd"); +extern const fcml_cstring M_VCMPFALSE_OSPS = _FT("vcmpfalse_osps"); +extern const fcml_cstring M_VCMPFALSE_OSSD = _FT("vcmpfalse_ossd"); +extern const fcml_cstring M_VCMPFALSE_OSSS = _FT("vcmpfalse_osss"); +extern const fcml_cstring M_VCMPFALSEPD = _FT("vcmpfalsepd"); +extern const fcml_cstring M_VCMPFALSEPS = _FT("vcmpfalseps"); +extern const fcml_cstring M_VCMPFALSESD = _FT("vcmpfalsesd"); +extern const fcml_cstring M_VCMPFALSESS = _FT("vcmpfalsess"); +extern const fcml_cstring M_VCMPGE_OQPD = _FT("vcmpge_oqpd"); +extern const fcml_cstring M_VCMPGE_OQPS = _FT("vcmpge_oqps"); +extern const fcml_cstring M_VCMPGE_OQSD = _FT("vcmpge_oqsd"); +extern const fcml_cstring M_VCMPGE_OQSS = _FT("vcmpge_oqss"); +extern const fcml_cstring M_VCMPGEPD = _FT("vcmpgepd"); +extern const fcml_cstring M_VCMPGEPS = _FT("vcmpgeps"); +extern const fcml_cstring M_VCMPGESD = _FT("vcmpgesd"); +extern const fcml_cstring M_VCMPGESS = _FT("vcmpgess"); +extern const fcml_cstring M_VCMPGT_OQPD = _FT("vcmpgt_oqpd"); +extern const fcml_cstring M_VCMPGT_OQPS = _FT("vcmpgt_oqps"); +extern const fcml_cstring M_VCMPGT_OQSD = _FT("vcmpgt_oqsd"); +extern const fcml_cstring M_VCMPGT_OQSS = _FT("vcmpgt_oqss"); +extern const fcml_cstring M_VCMPGTPD = _FT("vcmpgtpd"); +extern const fcml_cstring M_VCMPGTPS = _FT("vcmpgtps"); +extern const fcml_cstring M_VCMPGTSD = _FT("vcmpgtsd"); +extern const fcml_cstring M_VCMPGTSS = _FT("vcmpgtss"); +extern const fcml_cstring M_VCMPLE_OQPD = _FT("vcmple_oqpd"); +extern const fcml_cstring M_VCMPLE_OQPS = _FT("vcmple_oqps"); +extern const fcml_cstring M_VCMPLE_OQSD = _FT("vcmple_oqsd"); +extern const fcml_cstring M_VCMPLE_OQSS = _FT("vcmple_oqss"); +extern const fcml_cstring M_VCMPLEPD = _FT("vcmplepd"); +extern const fcml_cstring M_VCMPLEPS = _FT("vcmpleps"); +extern const fcml_cstring M_VCMPLESD = _FT("vcmplesd"); +extern const fcml_cstring M_VCMPLESS = _FT("vcmpless"); +extern const fcml_cstring M_VCMPLT_OQPD = _FT("vcmplt_oqpd"); +extern const fcml_cstring M_VCMPLT_OQPS = _FT("vcmplt_oqps"); +extern const fcml_cstring M_VCMPLT_OQSD = _FT("vcmplt_oqsd"); +extern const fcml_cstring M_VCMPLT_OQSS = _FT("vcmplt_oqss"); +extern const fcml_cstring M_VCMPLTPD = _FT("vcmpltpd"); +extern const fcml_cstring M_VCMPLTPS = _FT("vcmpltps"); +extern const fcml_cstring M_VCMPLTSD = _FT("vcmpltsd"); +extern const fcml_cstring M_VCMPLTSS = _FT("vcmpltss"); +extern const fcml_cstring M_VCMPNEQ_OQPD = _FT("vcmpneq_oqpd"); +extern const fcml_cstring M_VCMPNEQ_OQPS = _FT("vcmpneq_oqps"); +extern const fcml_cstring M_VCMPNEQ_OQSD = _FT("vcmpneq_oqsd"); +extern const fcml_cstring M_VCMPNEQ_OQSS = _FT("vcmpneq_oqss"); +extern const fcml_cstring M_VCMPNEQ_OSPD = _FT("vcmpneq_ospd"); +extern const fcml_cstring M_VCMPNEQ_OSPS = _FT("vcmpneq_osps"); +extern const fcml_cstring M_VCMPNEQ_OSSD = _FT("vcmpneq_ossd"); +extern const fcml_cstring M_VCMPNEQ_OSSS = _FT("vcmpneq_osss"); +extern const fcml_cstring M_VCMPNEQ_USPD = _FT("vcmpneq_uspd"); +extern const fcml_cstring M_VCMPNEQ_USPS = _FT("vcmpneq_usps"); +extern const fcml_cstring M_VCMPNEQ_USSD = _FT("vcmpneq_ussd"); +extern const fcml_cstring M_VCMPNEQ_USSS = _FT("vcmpneq_usss"); +extern const fcml_cstring M_VCMPNEQPD = _FT("vcmpneqpd"); +extern const fcml_cstring M_VCMPNEQPS = _FT("vcmpneqps"); +extern const fcml_cstring M_VCMPNEQSD = _FT("vcmpneqsd"); +extern const fcml_cstring M_VCMPNEQSS = _FT("vcmpneqss"); +extern const fcml_cstring M_VCMPNGE_UQPD = _FT("vcmpnge_uqpd"); +extern const fcml_cstring M_VCMPNGE_UQPS = _FT("vcmpnge_uqps"); +extern const fcml_cstring M_VCMPNGE_UQSD = _FT("vcmpnge_uqsd"); +extern const fcml_cstring M_VCMPNGE_UQSS = _FT("vcmpnge_uqss"); +extern const fcml_cstring M_VCMPNGEPD = _FT("vcmpngepd"); +extern const fcml_cstring M_VCMPNGEPS = _FT("vcmpngeps"); +extern const fcml_cstring M_VCMPNGESD = _FT("vcmpngesd"); +extern const fcml_cstring M_VCMPNGESS = _FT("vcmpngess"); +extern const fcml_cstring M_VCMPNGT_UQPD = _FT("vcmpngt_uqpd"); +extern const fcml_cstring M_VCMPNGT_UQPS = _FT("vcmpngt_uqps"); +extern const fcml_cstring M_VCMPNGT_UQSD = _FT("vcmpngt_uqsd"); +extern const fcml_cstring M_VCMPNGT_UQSS = _FT("vcmpngt_uqss"); +extern const fcml_cstring M_VCMPNGTPD = _FT("vcmpngtpd"); +extern const fcml_cstring M_VCMPNGTPS = _FT("vcmpngtps"); +extern const fcml_cstring M_VCMPNGTSD = _FT("vcmpngtsd"); +extern const fcml_cstring M_VCMPNGTSS = _FT("vcmpngtss"); +extern const fcml_cstring M_VCMPNLE_UQPD = _FT("vcmpnle_uqpd"); +extern const fcml_cstring M_VCMPNLE_UQPS = _FT("vcmpnle_uqps"); +extern const fcml_cstring M_VCMPNLE_UQSD = _FT("vcmpnle_uqsd"); +extern const fcml_cstring M_VCMPNLE_UQSS = _FT("vcmpnle_uqss"); +extern const fcml_cstring M_VCMPNLEPD = _FT("vcmpnlepd"); +extern const fcml_cstring M_VCMPNLEPS = _FT("vcmpnleps"); +extern const fcml_cstring M_VCMPNLESD = _FT("vcmpnlesd"); +extern const fcml_cstring M_VCMPNLESS = _FT("vcmpnless"); +extern const fcml_cstring M_VCMPNLT_UQPD = _FT("vcmpnlt_uqpd"); +extern const fcml_cstring M_VCMPNLT_UQPS = _FT("vcmpnlt_uqps"); +extern const fcml_cstring M_VCMPNLT_UQSD = _FT("vcmpnlt_uqsd"); +extern const fcml_cstring M_VCMPNLT_UQSS = _FT("vcmpnlt_uqss"); +extern const fcml_cstring M_VCMPNLTPD = _FT("vcmpnltpd"); +extern const fcml_cstring M_VCMPNLTPS = _FT("vcmpnltps"); +extern const fcml_cstring M_VCMPNLTSD = _FT("vcmpnltsd"); +extern const fcml_cstring M_VCMPNLTSS = _FT("vcmpnltss"); +extern const fcml_cstring M_VCMPORD_SPD = _FT("vcmpord_spd"); +extern const fcml_cstring M_VCMPORD_SPS = _FT("vcmpord_sps"); +extern const fcml_cstring M_VCMPORD_SSD = _FT("vcmpord_ssd"); +extern const fcml_cstring M_VCMPORD_SSS = _FT("vcmpord_sss"); +extern const fcml_cstring M_VCMPORDPD = _FT("vcmpordpd"); +extern const fcml_cstring M_VCMPORDPS = _FT("vcmpordps"); +extern const fcml_cstring M_VCMPORDSD = _FT("vcmpordsd"); +extern const fcml_cstring M_VCMPORDSS = _FT("vcmpordss"); +extern const fcml_cstring M_VCMPPD = _FT("vcmppd"); +extern const fcml_cstring M_VCMPPS = _FT("vcmpps"); +extern const fcml_cstring M_VCMPSD = _FT("vcmpsd"); +extern const fcml_cstring M_VCMPSS = _FT("vcmpss"); +extern const fcml_cstring M_VCMPTRUE_USPD = _FT("vcmptrue_uspd"); +extern const fcml_cstring M_VCMPTRUE_USPS = _FT("vcmptrue_usps"); +extern const fcml_cstring M_VCMPTRUE_USSD = _FT("vcmptrue_ussd"); +extern const fcml_cstring M_VCMPTRUE_USSS = _FT("vcmptrue_usss"); +extern const fcml_cstring M_VCMPTRUEPD = _FT("vcmptruepd"); +extern const fcml_cstring M_VCMPTRUEPS = _FT("vcmptrueps"); +extern const fcml_cstring M_VCMPTRUESD = _FT("vcmptruesd"); +extern const fcml_cstring M_VCMPTRUESS = _FT("vcmptruess"); +extern const fcml_cstring M_VCMPUNORD_SPD = _FT("vcmpunord_spd"); +extern const fcml_cstring M_VCMPUNORD_SPS = _FT("vcmpunord_sps"); +extern const fcml_cstring M_VCMPUNORD_SSD = _FT("vcmpunord_ssd"); +extern const fcml_cstring M_VCMPUNORD_SSS = _FT("vcmpunord_sss"); +extern const fcml_cstring M_VCMPUNORDPD = _FT("vcmpunordpd"); +extern const fcml_cstring M_VCMPUNORDPS = _FT("vcmpunordps"); +extern const fcml_cstring M_VCMPUNORDSD = _FT("vcmpunordsd"); +extern const fcml_cstring M_VCMPUNORDSS = _FT("vcmpunordss"); +extern const fcml_cstring M_VCOMISD = _FT("vcomisd"); +extern const fcml_cstring M_VCOMISS = _FT("vcomiss"); +extern const fcml_cstring M_VCOMPRESSPD = _FT("vcompresspd"); +extern const fcml_cstring M_VCOMPRESSPS = _FT("vcompressps"); +extern const fcml_cstring M_VCVTDQ2PD = _FT("vcvtdq2pd"); +extern const fcml_cstring M_VCVTDQ2PS = _FT("vcvtdq2ps"); +extern const fcml_cstring M_VCVTPD2DQ = _FT("vcvtpd2dq"); +extern const fcml_cstring M_VCVTPD2PS = _FT("vcvtpd2ps"); +extern const fcml_cstring M_VCVTPD2QQ = _FT("vcvtpd2qq"); +extern const fcml_cstring M_VCVTPD2UDQ = _FT("vcvtpd2udq"); +extern const fcml_cstring M_VCVTPD2UQQ = _FT("vcvtpd2uqq"); +extern const fcml_cstring M_VCVTPH2PS = _FT("vcvtph2ps"); +extern const fcml_cstring M_VCVTPS2DQ = _FT("vcvtps2dq"); +extern const fcml_cstring M_VCVTPS2PD = _FT("vcvtps2pd"); +extern const fcml_cstring M_VCVTPS2PH = _FT("vcvtps2ph"); +extern const fcml_cstring M_VCVTPS2QQ = _FT("vcvtps2qq"); +extern const fcml_cstring M_VCVTPS2UDQ = _FT("vcvtps2udq"); +extern const fcml_cstring M_VCVTPS2UQQ = _FT("vcvtps2uqq"); +extern const fcml_cstring M_VCVTQQ2PD = _FT("vcvtqq2pd"); +extern const fcml_cstring M_VCVTQQ2PS = _FT("vcvtqq2ps"); +extern const fcml_cstring M_VCVTSD2SI = _FT("vcvtsd2si"); +extern const fcml_cstring M_VCVTSD2SS = _FT("vcvtsd2ss"); +extern const fcml_cstring M_VCVTSD2USI = _FT("vcvtsd2usi"); +extern const fcml_cstring M_VCVTSI2SD = _FT("vcvtsi2sd"); +extern const fcml_cstring M_VCVTSI2SS = _FT("vcvtsi2ss"); +extern const fcml_cstring M_VCVTSS2SD = _FT("vcvtss2sd"); +extern const fcml_cstring M_VCVTSS2SI = _FT("vcvtss2si"); +extern const fcml_cstring M_VCVTSS2USI = _FT("vcvtss2usi"); +extern const fcml_cstring M_VCVTTPD2DQ = _FT("vcvttpd2dq"); +extern const fcml_cstring M_VCVTTPD2QQ = _FT("vcvttpd2qq"); +extern const fcml_cstring M_VCVTTPD2UDQ = _FT("vcvttpd2udq"); +extern const fcml_cstring M_VCVTTPD2UQQ = _FT("vcvttpd2uqq"); +extern const fcml_cstring M_VCVTTPS2DQ = _FT("vcvttps2dq"); +extern const fcml_cstring M_VCVTTPS2QQ = _FT("vcvttps2qq"); +extern const fcml_cstring M_VCVTTPS2UDQ = _FT("vcvttps2udq"); +extern const fcml_cstring M_VCVTTPS2UQQ = _FT("vcvttps2uqq"); +extern const fcml_cstring M_VCVTTSD2SI = _FT("vcvttsd2si"); +extern const fcml_cstring M_VCVTTSD2USI = _FT("vcvttsd2usi"); +extern const fcml_cstring M_VCVTTSS2SI = _FT("vcvttss2si"); +extern const fcml_cstring M_VCVTTSS2USI = _FT("vcvttss2usi"); +extern const fcml_cstring M_VCVTUDQ2PD = _FT("vcvtudq2pd"); +extern const fcml_cstring M_VCVTUDQ2PS = _FT("vcvtudq2ps"); +extern const fcml_cstring M_VCVTUQQ2PD = _FT("vcvtuqq2pd"); +extern const fcml_cstring M_VCVTUQQ2PS = _FT("vcvtuqq2ps"); +extern const fcml_cstring M_VCVTUSI2SD = _FT("vcvtusi2sd"); +extern const fcml_cstring M_VCVTUSI2SS = _FT("vcvtusi2ss"); +extern const fcml_cstring M_VDBPSADBW = _FT("vdbpsadbw"); +extern const fcml_cstring M_VDIVPD = _FT("vdivpd"); +extern const fcml_cstring M_VDIVPS = _FT("vdivps"); +extern const fcml_cstring M_VDIVSD = _FT("vdivsd"); +extern const fcml_cstring M_VDIVSS = _FT("vdivss"); +extern const fcml_cstring M_VDPPD = _FT("vdppd"); +extern const fcml_cstring M_VDPPS = _FT("vdpps"); +extern const fcml_cstring M_VERR = _FT("verr"); +extern const fcml_cstring M_VERW = _FT("verw"); +extern const fcml_cstring M_VEXP2PD = _FT("vexp2pd"); +extern const fcml_cstring M_VEXP2PS = _FT("vexp2ps"); +extern const fcml_cstring M_VEXPANDPD = _FT("vexpandpd"); +extern const fcml_cstring M_VEXPANDPS = _FT("vexpandps"); +extern const fcml_cstring M_VEXTRACTF128 = _FT("vextractf128"); +extern const fcml_cstring M_VEXTRACTF32X4 = _FT("vextractf32x4"); +extern const fcml_cstring M_VEXTRACTF32X8 = _FT("vextractf32x8"); +extern const fcml_cstring M_VEXTRACTF64X2 = _FT("vextractf64x2"); +extern const fcml_cstring M_VEXTRACTF64X4 = _FT("vextractf64x4"); +extern const fcml_cstring M_VEXTRACTI128 = _FT("vextracti128"); +extern const fcml_cstring M_VEXTRACTI32X4 = _FT("vextracti32x4"); +extern const fcml_cstring M_VEXTRACTI32X8 = _FT("vextracti32x8"); +extern const fcml_cstring M_VEXTRACTI64X2 = _FT("vextracti64x2"); +extern const fcml_cstring M_VEXTRACTI64X4 = _FT("vextracti64x4"); +extern const fcml_cstring M_VEXTRACTPS = _FT("vextractps"); +extern const fcml_cstring M_VFIXUPIMMPD = _FT("vfixupimmpd"); +extern const fcml_cstring M_VFIXUPIMMPS = _FT("vfixupimmps"); +extern const fcml_cstring M_VFIXUPIMMSD = _FT("vfixupimmsd"); +extern const fcml_cstring M_VFIXUPIMMSS = _FT("vfixupimmss"); +extern const fcml_cstring M_VFMADD132PD = _FT("vfmadd132pd"); +extern const fcml_cstring M_VFMADD132PS = _FT("vfmadd132ps"); +extern const fcml_cstring M_VFMADD132SD = _FT("vfmadd132sd"); +extern const fcml_cstring M_VFMADD132SS = _FT("vfmadd132ss"); +extern const fcml_cstring M_VFMADD213PD = _FT("vfmadd213pd"); +extern const fcml_cstring M_VFMADD213PS = _FT("vfmadd213ps"); +extern const fcml_cstring M_VFMADD213SD = _FT("vfmadd213sd"); +extern const fcml_cstring M_VFMADD213SS = _FT("vfmadd213ss"); +extern const fcml_cstring M_VFMADD231PD = _FT("vfmadd231pd"); +extern const fcml_cstring M_VFMADD231PS = _FT("vfmadd231ps"); +extern const fcml_cstring M_VFMADD231SD = _FT("vfmadd231sd"); +extern const fcml_cstring M_VFMADD231SS = _FT("vfmadd231ss"); +extern const fcml_cstring M_VFMADDPD = _FT("vfmaddpd"); +extern const fcml_cstring M_VFMADDPS = _FT("vfmaddps"); +extern const fcml_cstring M_VFMADDSD = _FT("vfmaddsd"); +extern const fcml_cstring M_VFMADDSS = _FT("vfmaddss"); +extern const fcml_cstring M_VFMADDSUB132PD = _FT("vfmaddsub132pd"); +extern const fcml_cstring M_VFMADDSUB132PS = _FT("vfmaddsub132ps"); +extern const fcml_cstring M_VFMADDSUB213PD = _FT("vfmaddsub213pd"); +extern const fcml_cstring M_VFMADDSUB213PS = _FT("vfmaddsub213ps"); +extern const fcml_cstring M_VFMADDSUB231PD = _FT("vfmaddsub231pd"); +extern const fcml_cstring M_VFMADDSUB231PS = _FT("vfmaddsub231ps"); +extern const fcml_cstring M_VFMADDSUBPD = _FT("vfmaddsubpd"); +extern const fcml_cstring M_VFMADDSUBPS = _FT("vfmaddsubps"); +extern const fcml_cstring M_VFMSUB132PD = _FT("vfmsub132pd"); +extern const fcml_cstring M_VFMSUB132PS = _FT("vfmsub132ps"); +extern const fcml_cstring M_VFMSUB132SD = _FT("vfmsub132sd"); +extern const fcml_cstring M_VFMSUB132SS = _FT("vfmsub132ss"); +extern const fcml_cstring M_VFMSUB213PD = _FT("vfmsub213pd"); +extern const fcml_cstring M_VFMSUB213PS = _FT("vfmsub213ps"); +extern const fcml_cstring M_VFMSUB213SD = _FT("vfmsub213sd"); +extern const fcml_cstring M_VFMSUB213SS = _FT("vfmsub213ss"); +extern const fcml_cstring M_VFMSUB231PD = _FT("vfmsub231pd"); +extern const fcml_cstring M_VFMSUB231PS = _FT("vfmsub231ps"); +extern const fcml_cstring M_VFMSUB231SD = _FT("vfmsub231sd"); +extern const fcml_cstring M_VFMSUB231SS = _FT("vfmsub231ss"); +extern const fcml_cstring M_VFMSUBADD132PD = _FT("vfmsubadd132pd"); +extern const fcml_cstring M_VFMSUBADD132PS = _FT("vfmsubadd132ps"); +extern const fcml_cstring M_VFMSUBADD213PD = _FT("vfmsubadd213pd"); +extern const fcml_cstring M_VFMSUBADD213PS = _FT("vfmsubadd213ps"); +extern const fcml_cstring M_VFMSUBADD231PD = _FT("vfmsubadd231pd"); +extern const fcml_cstring M_VFMSUBADD231PS = _FT("vfmsubadd231ps"); +extern const fcml_cstring M_VFMSUBADDPD = _FT("vfmsubaddpd"); +extern const fcml_cstring M_VFMSUBADDPS = _FT("vfmsubaddps"); +extern const fcml_cstring M_VFMSUBPD = _FT("vfmsubpd"); +extern const fcml_cstring M_VFMSUBPS = _FT("vfmsubps"); +extern const fcml_cstring M_VFMSUBSD = _FT("vfmsubsd"); +extern const fcml_cstring M_VFMSUBSS = _FT("vfmsubss"); +extern const fcml_cstring M_VFNMADD132PD = _FT("vfnmadd132pd"); +extern const fcml_cstring M_VFNMADD132PS = _FT("vfnmadd132ps"); +extern const fcml_cstring M_VFNMADD132SD = _FT("vfnmadd132sd"); +extern const fcml_cstring M_VFNMADD132SS = _FT("vfnmadd132ss"); +extern const fcml_cstring M_VFNMADD213PD = _FT("vfnmadd213pd"); +extern const fcml_cstring M_VFNMADD213PS = _FT("vfnmadd213ps"); +extern const fcml_cstring M_VFNMADD213SD = _FT("vfnmadd213sd"); +extern const fcml_cstring M_VFNMADD213SS = _FT("vfnmadd213ss"); +extern const fcml_cstring M_VFNMADD231PD = _FT("vfnmadd231pd"); +extern const fcml_cstring M_VFNMADD231PS = _FT("vfnmadd231ps"); +extern const fcml_cstring M_VFNMADD231SD = _FT("vfnmadd231sd"); +extern const fcml_cstring M_VFNMADD231SS = _FT("vfnmadd231ss"); +extern const fcml_cstring M_VFNMADDPD = _FT("vfnmaddpd"); +extern const fcml_cstring M_VFNMADDPS = _FT("vfnmaddps"); +extern const fcml_cstring M_VFNMADDSD = _FT("vfnmaddsd"); +extern const fcml_cstring M_VFNMADDSS = _FT("vfnmaddss"); +extern const fcml_cstring M_VFNMSUB132PD = _FT("vfnmsub132pd"); +extern const fcml_cstring M_VFNMSUB132PS = _FT("vfnmsub132ps"); +extern const fcml_cstring M_VFNMSUB132SD = _FT("vfnmsub132sd"); +extern const fcml_cstring M_VFNMSUB132SS = _FT("vfnmsub132ss"); +extern const fcml_cstring M_VFNMSUB213PD = _FT("vfnmsub213pd"); +extern const fcml_cstring M_VFNMSUB213PS = _FT("vfnmsub213ps"); +extern const fcml_cstring M_VFNMSUB213SD = _FT("vfnmsub213sd"); +extern const fcml_cstring M_VFNMSUB213SS = _FT("vfnmsub213ss"); +extern const fcml_cstring M_VFNMSUB231PD = _FT("vfnmsub231pd"); +extern const fcml_cstring M_VFNMSUB231PS = _FT("vfnmsub231ps"); +extern const fcml_cstring M_VFNMSUB231SD = _FT("vfnmsub231sd"); +extern const fcml_cstring M_VFNMSUB231SS = _FT("vfnmsub231ss"); +extern const fcml_cstring M_VFNMSUBPD = _FT("vfnmsubpd"); +extern const fcml_cstring M_VFNMSUBPS = _FT("vfnmsubps"); +extern const fcml_cstring M_VFNMSUBSD = _FT("vfnmsubsd"); +extern const fcml_cstring M_VFNMSUBSS = _FT("vfnmsubss"); +extern const fcml_cstring M_VFPCLASSPD = _FT("vfpclasspd"); +extern const fcml_cstring M_VFPCLASSPS = _FT("vfpclassps"); +extern const fcml_cstring M_VFPCLASSSD = _FT("vfpclasssd"); +extern const fcml_cstring M_VFPCLASSSS = _FT("vfpclassss"); +extern const fcml_cstring M_VFRCZPD = _FT("vfrczpd"); +extern const fcml_cstring M_VFRCZPS = _FT("vfrczps"); +extern const fcml_cstring M_VFRCZSD = _FT("vfrczsd"); +extern const fcml_cstring M_VFRCZSS = _FT("vfrczss"); +extern const fcml_cstring M_VGATHERDPD = _FT("vgatherdpd"); +extern const fcml_cstring M_VGATHERDPS = _FT("vgatherdps"); +extern const fcml_cstring M_VGATHERPF0DPD = _FT("vgatherpf0dpd"); +extern const fcml_cstring M_VGATHERPF0DPS = _FT("vgatherpf0dps"); +extern const fcml_cstring M_VGATHERPF0QPD = _FT("vgatherpf0qpd"); +extern const fcml_cstring M_VGATHERPF0QPS = _FT("vgatherpf0qps"); +extern const fcml_cstring M_VGATHERPF1DPD = _FT("vgatherpf1dpd"); +extern const fcml_cstring M_VGATHERPF1DPS = _FT("vgatherpf1dps"); +extern const fcml_cstring M_VGATHERPF1QPD = _FT("vgatherpf1qpd"); +extern const fcml_cstring M_VGATHERPF1QPS = _FT("vgatherpf1qps"); +extern const fcml_cstring M_VGATHERQPD = _FT("vgatherqpd"); +extern const fcml_cstring M_VGATHERQPS = _FT("vgatherqps"); +extern const fcml_cstring M_VGETEXPPD = _FT("vgetexppd"); +extern const fcml_cstring M_VGETEXPPS = _FT("vgetexpps"); +extern const fcml_cstring M_VGETEXPSD = _FT("vgetexpsd"); +extern const fcml_cstring M_VGETEXPSS = _FT("vgetexpss"); +extern const fcml_cstring M_VGETMANTPD = _FT("vgetmantpd"); +extern const fcml_cstring M_VGETMANTPS = _FT("vgetmantps"); +extern const fcml_cstring M_VGETMANTSD = _FT("vgetmantsd"); +extern const fcml_cstring M_VGETMANTSS = _FT("vgetmantss"); +extern const fcml_cstring M_VHADDPD = _FT("vhaddpd"); +extern const fcml_cstring M_VHADDPS = _FT("vhaddps"); +extern const fcml_cstring M_VHSUBPD = _FT("vhsubpd"); +extern const fcml_cstring M_VHSUBPS = _FT("vhsubps"); +extern const fcml_cstring M_VINSERTF128 = _FT("vinsertf128"); +extern const fcml_cstring M_VINSERTF32X4 = _FT("vinsertf32x4"); +extern const fcml_cstring M_VINSERTF32X8 = _FT("vinsertf32x8"); +extern const fcml_cstring M_VINSERTF64X2 = _FT("vinsertf64x2"); +extern const fcml_cstring M_VINSERTF64X4 = _FT("vinsertf64x4"); +extern const fcml_cstring M_VINSERTI128 = _FT("vinserti128"); +extern const fcml_cstring M_VINSERTI32X4 = _FT("vinserti32x4"); +extern const fcml_cstring M_VINSERTI32X8 = _FT("vinserti32x8"); +extern const fcml_cstring M_VINSERTI64X2 = _FT("vinserti64x2"); +extern const fcml_cstring M_VINSERTI64X4 = _FT("vinserti64x4"); +extern const fcml_cstring M_VINSERTPS = _FT("vinsertps"); +extern const fcml_cstring M_VLDDQU = _FT("vlddqu"); +extern const fcml_cstring M_VLDMXCSR = _FT("vldmxcsr"); +extern const fcml_cstring M_VMASKMOVDQU = _FT("vmaskmovdqu"); +extern const fcml_cstring M_VMASKMOVPD = _FT("vmaskmovpd"); +extern const fcml_cstring M_VMASKMOVPS = _FT("vmaskmovps"); +extern const fcml_cstring M_VMAXPD = _FT("vmaxpd"); +extern const fcml_cstring M_VMAXPS = _FT("vmaxps"); +extern const fcml_cstring M_VMAXSD = _FT("vmaxsd"); +extern const fcml_cstring M_VMAXSS = _FT("vmaxss"); +extern const fcml_cstring M_VMCALL = _FT("vmcall"); +extern const fcml_cstring M_VMCLEAR = _FT("vmclear"); +extern const fcml_cstring M_VMFUNC = _FT("vmfunc"); +extern const fcml_cstring M_VMINPD = _FT("vminpd"); +extern const fcml_cstring M_VMINPS = _FT("vminps"); +extern const fcml_cstring M_VMINSD = _FT("vminsd"); +extern const fcml_cstring M_VMINSS = _FT("vminss"); +extern const fcml_cstring M_VMLAUNCH = _FT("vmlaunch"); +extern const fcml_cstring M_VMLOAD = _FT("vmload"); +extern const fcml_cstring M_VMMCALL = _FT("vmmcall"); +extern const fcml_cstring M_VMOVAPD = _FT("vmovapd"); +extern const fcml_cstring M_VMOVAPS = _FT("vmovaps"); +extern const fcml_cstring M_VMOVD = _FT("vmovd"); +extern const fcml_cstring M_VMOVDDUP = _FT("vmovddup"); +extern const fcml_cstring M_VMOVDQA = _FT("vmovdqa"); +extern const fcml_cstring M_VMOVDQA32 = _FT("vmovdqa32"); +extern const fcml_cstring M_VMOVDQA64 = _FT("vmovdqa64"); +extern const fcml_cstring M_VMOVDQU = _FT("vmovdqu"); +extern const fcml_cstring M_VMOVDQU16 = _FT("vmovdqu16"); +extern const fcml_cstring M_VMOVDQU32 = _FT("vmovdqu32"); +extern const fcml_cstring M_VMOVDQU64 = _FT("vmovdqu64"); +extern const fcml_cstring M_VMOVDQU8 = _FT("vmovdqu8"); +extern const fcml_cstring M_VMOVHLPS = _FT("vmovhlps"); +extern const fcml_cstring M_VMOVHPD = _FT("vmovhpd"); +extern const fcml_cstring M_VMOVHPS = _FT("vmovhps"); +extern const fcml_cstring M_VMOVLHPS = _FT("vmovlhps"); +extern const fcml_cstring M_VMOVLPD = _FT("vmovlpd"); +extern const fcml_cstring M_VMOVLPS = _FT("vmovlps"); +extern const fcml_cstring M_VMOVMSKPD = _FT("vmovmskpd"); +extern const fcml_cstring M_VMOVMSKPS = _FT("vmovmskps"); +extern const fcml_cstring M_VMOVNTDQ = _FT("vmovntdq"); +extern const fcml_cstring M_VMOVNTDQA = _FT("vmovntdqa"); +extern const fcml_cstring M_VMOVNTPD = _FT("vmovntpd"); +extern const fcml_cstring M_VMOVNTPS = _FT("vmovntps"); +extern const fcml_cstring M_VMOVQ = _FT("vmovq"); +extern const fcml_cstring M_VMOVSD = _FT("vmovsd"); +extern const fcml_cstring M_VMOVSHDUP = _FT("vmovshdup"); +extern const fcml_cstring M_VMOVSLDUP = _FT("vmovsldup"); +extern const fcml_cstring M_VMOVSS = _FT("vmovss"); +extern const fcml_cstring M_VMOVUPD = _FT("vmovupd"); +extern const fcml_cstring M_VMOVUPS = _FT("vmovups"); +extern const fcml_cstring M_VMPSADBW = _FT("vmpsadbw"); +extern const fcml_cstring M_VMPTRLD = _FT("vmptrld"); +extern const fcml_cstring M_VMPTRST = _FT("vmptrst"); +extern const fcml_cstring M_VMREAD = _FT("vmread"); +extern const fcml_cstring M_VMRESUME = _FT("vmresume"); +extern const fcml_cstring M_VMRUN = _FT("vmrun"); +extern const fcml_cstring M_VMSAVE = _FT("vmsave"); +extern const fcml_cstring M_VMULPD = _FT("vmulpd"); +extern const fcml_cstring M_VMULPS = _FT("vmulps"); +extern const fcml_cstring M_VMULSD = _FT("vmulsd"); +extern const fcml_cstring M_VMULSS = _FT("vmulss"); +extern const fcml_cstring M_VMWRITE = _FT("vmwrite"); +extern const fcml_cstring M_VMXOFF = _FT("vmxoff"); +extern const fcml_cstring M_VMXON = _FT("vmxon"); +extern const fcml_cstring M_VORPD = _FT("vorpd"); +extern const fcml_cstring M_VORPS = _FT("vorps"); +extern const fcml_cstring M_VP4DPWSSD = _FT("vp4dpwssd"); +extern const fcml_cstring M_VP4DPWSSDS = _FT("vp4dpwssds"); +extern const fcml_cstring M_VPABSB = _FT("vpabsb"); +extern const fcml_cstring M_VPABSD = _FT("vpabsd"); +extern const fcml_cstring M_VPABSQ = _FT("vpabsq"); +extern const fcml_cstring M_VPABSW = _FT("vpabsw"); +extern const fcml_cstring M_VPACKSSDW = _FT("vpackssdw"); +extern const fcml_cstring M_VPACKSSWB = _FT("vpacksswb"); +extern const fcml_cstring M_VPACKUSDW = _FT("vpackusdw"); +extern const fcml_cstring M_VPACKUSWB = _FT("vpackuswb"); +extern const fcml_cstring M_VPADDB = _FT("vpaddb"); +extern const fcml_cstring M_VPADDD = _FT("vpaddd"); +extern const fcml_cstring M_VPADDQ = _FT("vpaddq"); +extern const fcml_cstring M_VPADDSB = _FT("vpaddsb"); +extern const fcml_cstring M_VPADDSW = _FT("vpaddsw"); +extern const fcml_cstring M_VPADDUSB = _FT("vpaddusb"); +extern const fcml_cstring M_VPADDUSW = _FT("vpaddusw"); +extern const fcml_cstring M_VPADDW = _FT("vpaddw"); +extern const fcml_cstring M_VPALIGNR = _FT("vpalignr"); +extern const fcml_cstring M_VPAND = _FT("vpand"); +extern const fcml_cstring M_VPANDD = _FT("vpandd"); +extern const fcml_cstring M_VPANDN = _FT("vpandn"); +extern const fcml_cstring M_VPANDND = _FT("vpandnd"); +extern const fcml_cstring M_VPANDNQ = _FT("vpandnq"); +extern const fcml_cstring M_VPANDQ = _FT("vpandq"); +extern const fcml_cstring M_VPAVGB = _FT("vpavgb"); +extern const fcml_cstring M_VPAVGW = _FT("vpavgw"); +extern const fcml_cstring M_VPBLENDD = _FT("vpblendd"); +extern const fcml_cstring M_VPBLENDMB = _FT("vpblendmb"); +extern const fcml_cstring M_VPBLENDMD = _FT("vpblendmd"); +extern const fcml_cstring M_VPBLENDMQ = _FT("vpblendmq"); +extern const fcml_cstring M_VPBLENDMW = _FT("vpblendmw"); +extern const fcml_cstring M_VPBLENDVB = _FT("vpblendvb"); +extern const fcml_cstring M_VPBLENDW = _FT("vpblendw"); +extern const fcml_cstring M_VPBROADCASTB = _FT("vpbroadcastb"); +extern const fcml_cstring M_VPBROADCASTD = _FT("vpbroadcastd"); +extern const fcml_cstring M_VPBROADCASTMB2Q = _FT("vpbroadcastmb2q"); +extern const fcml_cstring M_VPBROADCASTMW2D = _FT("vpbroadcastmw2d"); +extern const fcml_cstring M_VPBROADCASTQ = _FT("vpbroadcastq"); +extern const fcml_cstring M_VPBROADCASTW = _FT("vpbroadcastw"); +extern const fcml_cstring M_VPCLMULQDQ = _FT("vpclmulqdq"); +extern const fcml_cstring M_VPCMOV = _FT("vpcmov"); +extern const fcml_cstring M_VPCMPB = _FT("vpcmpb"); +extern const fcml_cstring M_VPCMPD = _FT("vpcmpd"); +extern const fcml_cstring M_VPCMPEQB = _FT("vpcmpeqb"); +extern const fcml_cstring M_VPCMPEQD = _FT("vpcmpeqd"); +extern const fcml_cstring M_VPCMPEQQ = _FT("vpcmpeqq"); +extern const fcml_cstring M_VPCMPEQW = _FT("vpcmpeqw"); +extern const fcml_cstring M_VPCMPESTRI = _FT("vpcmpestri"); +extern const fcml_cstring M_VPCMPESTRM = _FT("vpcmpestrm"); +extern const fcml_cstring M_VPCMPGTB = _FT("vpcmpgtb"); +extern const fcml_cstring M_VPCMPGTD = _FT("vpcmpgtd"); +extern const fcml_cstring M_VPCMPGTQ = _FT("vpcmpgtq"); +extern const fcml_cstring M_VPCMPGTW = _FT("vpcmpgtw"); +extern const fcml_cstring M_VPCMPISTRI = _FT("vpcmpistri"); +extern const fcml_cstring M_VPCMPISTRM = _FT("vpcmpistrm"); +extern const fcml_cstring M_VPCMPQ = _FT("vpcmpq"); +extern const fcml_cstring M_VPCMPUB = _FT("vpcmpub"); +extern const fcml_cstring M_VPCMPUD = _FT("vpcmpud"); +extern const fcml_cstring M_VPCMPUQ = _FT("vpcmpuq"); +extern const fcml_cstring M_VPCMPUW = _FT("vpcmpuw"); +extern const fcml_cstring M_VPCMPW = _FT("vpcmpw"); +extern const fcml_cstring M_VPCOMB = _FT("vpcomb"); +extern const fcml_cstring M_VPCOMD = _FT("vpcomd"); +extern const fcml_cstring M_VPCOMEQB = _FT("vpcomeqb"); +extern const fcml_cstring M_VPCOMEQD = _FT("vpcomeqd"); +extern const fcml_cstring M_VPCOMEQQ = _FT("vpcomeqq"); +extern const fcml_cstring M_VPCOMEQUB = _FT("vpcomequb"); +extern const fcml_cstring M_VPCOMEQUD = _FT("vpcomequd"); +extern const fcml_cstring M_VPCOMEQUQ = _FT("vpcomequq"); +extern const fcml_cstring M_VPCOMEQUW = _FT("vpcomequw"); +extern const fcml_cstring M_VPCOMEQW = _FT("vpcomeqw"); +extern const fcml_cstring M_VPCOMFALSEB = _FT("vpcomfalseb"); +extern const fcml_cstring M_VPCOMFALSED = _FT("vpcomfalsed"); +extern const fcml_cstring M_VPCOMFALSEQ = _FT("vpcomfalseq"); +extern const fcml_cstring M_VPCOMFALSEUB = _FT("vpcomfalseub"); +extern const fcml_cstring M_VPCOMFALSEUD = _FT("vpcomfalseud"); +extern const fcml_cstring M_VPCOMFALSEUQ = _FT("vpcomfalseuq"); +extern const fcml_cstring M_VPCOMFALSEUW = _FT("vpcomfalseuw"); +extern const fcml_cstring M_VPCOMFALSEW = _FT("vpcomfalsew"); +extern const fcml_cstring M_VPCOMGEB = _FT("vpcomgeb"); +extern const fcml_cstring M_VPCOMGED = _FT("vpcomged"); +extern const fcml_cstring M_VPCOMGEQ = _FT("vpcomgeq"); +extern const fcml_cstring M_VPCOMGEUB = _FT("vpcomgeub"); +extern const fcml_cstring M_VPCOMGEUD = _FT("vpcomgeud"); +extern const fcml_cstring M_VPCOMGEUQ = _FT("vpcomgeuq"); +extern const fcml_cstring M_VPCOMGEUW = _FT("vpcomgeuw"); +extern const fcml_cstring M_VPCOMGEW = _FT("vpcomgew"); +extern const fcml_cstring M_VPCOMGTB = _FT("vpcomgtb"); +extern const fcml_cstring M_VPCOMGTD = _FT("vpcomgtd"); +extern const fcml_cstring M_VPCOMGTQ = _FT("vpcomgtq"); +extern const fcml_cstring M_VPCOMGTUB = _FT("vpcomgtub"); +extern const fcml_cstring M_VPCOMGTUD = _FT("vpcomgtud"); +extern const fcml_cstring M_VPCOMGTUQ = _FT("vpcomgtuq"); +extern const fcml_cstring M_VPCOMGTUW = _FT("vpcomgtuw"); +extern const fcml_cstring M_VPCOMGTW = _FT("vpcomgtw"); +extern const fcml_cstring M_VPCOMLEB = _FT("vpcomleb"); +extern const fcml_cstring M_VPCOMLED = _FT("vpcomled"); +extern const fcml_cstring M_VPCOMLEQ = _FT("vpcomleq"); +extern const fcml_cstring M_VPCOMLEUB = _FT("vpcomleub"); +extern const fcml_cstring M_VPCOMLEUD = _FT("vpcomleud"); +extern const fcml_cstring M_VPCOMLEUQ = _FT("vpcomleuq"); +extern const fcml_cstring M_VPCOMLEUW = _FT("vpcomleuw"); +extern const fcml_cstring M_VPCOMLEW = _FT("vpcomlew"); +extern const fcml_cstring M_VPCOMLTB = _FT("vpcomltb"); +extern const fcml_cstring M_VPCOMLTD = _FT("vpcomltd"); +extern const fcml_cstring M_VPCOMLTQ = _FT("vpcomltq"); +extern const fcml_cstring M_VPCOMLTUB = _FT("vpcomltub"); +extern const fcml_cstring M_VPCOMLTUD = _FT("vpcomltud"); +extern const fcml_cstring M_VPCOMLTUQ = _FT("vpcomltuq"); +extern const fcml_cstring M_VPCOMLTUW = _FT("vpcomltuw"); +extern const fcml_cstring M_VPCOMLTW = _FT("vpcomltw"); +extern const fcml_cstring M_VPCOMNEQB = _FT("vpcomneqb"); +extern const fcml_cstring M_VPCOMNEQD = _FT("vpcomneqd"); +extern const fcml_cstring M_VPCOMNEQQ = _FT("vpcomneqq"); +extern const fcml_cstring M_VPCOMNEQUB = _FT("vpcomnequb"); +extern const fcml_cstring M_VPCOMNEQUD = _FT("vpcomnequd"); +extern const fcml_cstring M_VPCOMNEQUQ = _FT("vpcomnequq"); +extern const fcml_cstring M_VPCOMNEQUW = _FT("vpcomnequw"); +extern const fcml_cstring M_VPCOMNEQW = _FT("vpcomneqw"); +extern const fcml_cstring M_VPCOMPRESSD = _FT("vpcompressd"); +extern const fcml_cstring M_VPCOMPRESSQ = _FT("vpcompressq"); +extern const fcml_cstring M_VPCOMQ = _FT("vpcomq"); +extern const fcml_cstring M_VPCOMTRUEB = _FT("vpcomtrueb"); +extern const fcml_cstring M_VPCOMTRUED = _FT("vpcomtrued"); +extern const fcml_cstring M_VPCOMTRUEQ = _FT("vpcomtrueq"); +extern const fcml_cstring M_VPCOMTRUEUB = _FT("vpcomtrueub"); +extern const fcml_cstring M_VPCOMTRUEUD = _FT("vpcomtrueud"); +extern const fcml_cstring M_VPCOMTRUEUQ = _FT("vpcomtrueuq"); +extern const fcml_cstring M_VPCOMTRUEUW = _FT("vpcomtrueuw"); +extern const fcml_cstring M_VPCOMTRUEW = _FT("vpcomtruew"); +extern const fcml_cstring M_VPCOMUB = _FT("vpcomub"); +extern const fcml_cstring M_VPCOMUD = _FT("vpcomud"); +extern const fcml_cstring M_VPCOMUQ = _FT("vpcomuq"); +extern const fcml_cstring M_VPCOMUW = _FT("vpcomuw"); +extern const fcml_cstring M_VPCOMW = _FT("vpcomw"); +extern const fcml_cstring M_VPERM2F128 = _FT("vperm2f128"); +extern const fcml_cstring M_VPERM2I128 = _FT("vperm2i128"); +extern const fcml_cstring M_VPERMB = _FT("vpermb"); +extern const fcml_cstring M_VPERMD = _FT("vpermd"); +extern const fcml_cstring M_VPERMI2B = _FT("vpermi2b"); +extern const fcml_cstring M_VPERMI2D = _FT("vpermi2d"); +extern const fcml_cstring M_VPERMI2PD = _FT("vpermi2pd"); +extern const fcml_cstring M_VPERMI2PS = _FT("vpermi2ps"); +extern const fcml_cstring M_VPERMI2Q = _FT("vpermi2q"); +extern const fcml_cstring M_VPERMI2W = _FT("vpermi2w"); +extern const fcml_cstring M_VPERMIL2PD = _FT("vpermil2pd"); +extern const fcml_cstring M_VPERMIL2PS = _FT("vpermil2ps"); +extern const fcml_cstring M_VPERMILPD = _FT("vpermilpd"); +extern const fcml_cstring M_VPERMILPS = _FT("vpermilps"); +extern const fcml_cstring M_VPERMPD = _FT("vpermpd"); +extern const fcml_cstring M_VPERMPS = _FT("vpermps"); +extern const fcml_cstring M_VPERMQ = _FT("vpermq"); +extern const fcml_cstring M_VPERMT2B = _FT("vpermt2b"); +extern const fcml_cstring M_VPERMT2D = _FT("vpermt2d"); +extern const fcml_cstring M_VPERMT2PD = _FT("vpermt2pd"); +extern const fcml_cstring M_VPERMT2PS = _FT("vpermt2ps"); +extern const fcml_cstring M_VPERMT2Q = _FT("vpermt2q"); +extern const fcml_cstring M_VPERMT2W = _FT("vpermt2w"); +extern const fcml_cstring M_VPERMW = _FT("vpermw"); +extern const fcml_cstring M_VPEXPANDD = _FT("vpexpandd"); +extern const fcml_cstring M_VPEXPANDQ = _FT("vpexpandq"); +extern const fcml_cstring M_VPEXTRB = _FT("vpextrb"); +extern const fcml_cstring M_VPEXTRD = _FT("vpextrd"); +extern const fcml_cstring M_VPEXTRQ = _FT("vpextrq"); +extern const fcml_cstring M_VPEXTRW = _FT("vpextrw"); +extern const fcml_cstring M_VPGATHERDD = _FT("vpgatherdd"); +extern const fcml_cstring M_VPGATHERDQ = _FT("vpgatherdq"); +extern const fcml_cstring M_VPGATHERQD = _FT("vpgatherqd"); +extern const fcml_cstring M_VPGATHERQQ = _FT("vpgatherqq"); +extern const fcml_cstring M_VPHADDBD = _FT("vphaddbd"); +extern const fcml_cstring M_VPHADDBQ = _FT("vphaddbq"); +extern const fcml_cstring M_VPHADDBW = _FT("vphaddbw"); +extern const fcml_cstring M_VPHADDD = _FT("vphaddd"); +extern const fcml_cstring M_VPHADDDQ = _FT("vphadddq"); +extern const fcml_cstring M_VPHADDSW = _FT("vphaddsw"); +extern const fcml_cstring M_VPHADDUBD = _FT("vphaddubd"); +extern const fcml_cstring M_VPHADDUBQ = _FT("vphaddubq"); +extern const fcml_cstring M_VPHADDUBW = _FT("vphaddubw"); +extern const fcml_cstring M_VPHADDUDQ = _FT("vphaddudq"); +extern const fcml_cstring M_VPHADDUWD = _FT("vphadduwd"); +extern const fcml_cstring M_VPHADDUWQ = _FT("vphadduwq"); +extern const fcml_cstring M_VPHADDW = _FT("vphaddw"); +extern const fcml_cstring M_VPHADDWD = _FT("vphaddwd"); +extern const fcml_cstring M_VPHADDWQ = _FT("vphaddwq"); +extern const fcml_cstring M_VPHMINPOSUW = _FT("vphminposuw"); +extern const fcml_cstring M_VPHSUBBW = _FT("vphsubbw"); +extern const fcml_cstring M_VPHSUBD = _FT("vphsubd"); +extern const fcml_cstring M_VPHSUBDQ = _FT("vphsubdq"); +extern const fcml_cstring M_VPHSUBSW = _FT("vphsubsw"); +extern const fcml_cstring M_VPHSUBW = _FT("vphsubw"); +extern const fcml_cstring M_VPHSUBWD = _FT("vphsubwd"); +extern const fcml_cstring M_VPINSRB = _FT("vpinsrb"); +extern const fcml_cstring M_VPINSRD = _FT("vpinsrd"); +extern const fcml_cstring M_VPINSRQ = _FT("vpinsrq"); +extern const fcml_cstring M_VPINSRW = _FT("vpinsrw"); +extern const fcml_cstring M_VPLZCNTD = _FT("vplzcntd"); +extern const fcml_cstring M_VPLZCNTQ = _FT("vplzcntq"); +extern const fcml_cstring M_VPMACSDD = _FT("vpmacsdd"); +extern const fcml_cstring M_VPMACSDQH = _FT("vpmacsdqh"); +extern const fcml_cstring M_VPMACSDQL = _FT("vpmacsdql"); +extern const fcml_cstring M_VPMACSSDD = _FT("vpmacssdd"); +extern const fcml_cstring M_VPMACSSDQH = _FT("vpmacssdqh"); +extern const fcml_cstring M_VPMACSSDQL = _FT("vpmacssdql"); +extern const fcml_cstring M_VPMACSSWD = _FT("vpmacsswd"); +extern const fcml_cstring M_VPMACSSWW = _FT("vpmacssww"); +extern const fcml_cstring M_VPMACSWD = _FT("vpmacswd"); +extern const fcml_cstring M_VPMACSWW = _FT("vpmacsww"); +extern const fcml_cstring M_VPMADCSSWD = _FT("vpmadcsswd"); +extern const fcml_cstring M_VPMADCSWD = _FT("vpmadcswd"); +extern const fcml_cstring M_VPMADD52HUQ = _FT("vpmadd52huq"); +extern const fcml_cstring M_VPMADD52LUQ = _FT("vpmadd52luq"); +extern const fcml_cstring M_VPMADDUBSW = _FT("vpmaddubsw"); +extern const fcml_cstring M_VPMADDWD = _FT("vpmaddwd"); +extern const fcml_cstring M_VPMASKMOV = _FT("vpmaskmov"); +extern const fcml_cstring M_VPMASKMOVD = _FT("vpmaskmovd"); +extern const fcml_cstring M_VPMASKMOVQ = _FT("vpmaskmovq"); +extern const fcml_cstring M_VPMAXSB = _FT("vpmaxsb"); +extern const fcml_cstring M_VPMAXSD = _FT("vpmaxsd"); +extern const fcml_cstring M_VPMAXSQ = _FT("vpmaxsq"); +extern const fcml_cstring M_VPMAXSW = _FT("vpmaxsw"); +extern const fcml_cstring M_VPMAXUB = _FT("vpmaxub"); +extern const fcml_cstring M_VPMAXUD = _FT("vpmaxud"); +extern const fcml_cstring M_VPMAXUQ = _FT("vpmaxuq"); +extern const fcml_cstring M_VPMAXUW = _FT("vpmaxuw"); +extern const fcml_cstring M_VPMINSB = _FT("vpminsb"); +extern const fcml_cstring M_VPMINSD = _FT("vpminsd"); +extern const fcml_cstring M_VPMINSQ = _FT("vpminsq"); +extern const fcml_cstring M_VPMINSW = _FT("vpminsw"); +extern const fcml_cstring M_VPMINUB = _FT("vpminub"); +extern const fcml_cstring M_VPMINUD = _FT("vpminud"); +extern const fcml_cstring M_VPMINUQ = _FT("vpminuq"); +extern const fcml_cstring M_VPMINUW = _FT("vpminuw"); +extern const fcml_cstring M_VPMOVB2M = _FT("vpmovb2m"); +extern const fcml_cstring M_VPMOVD2M = _FT("vpmovd2m"); +extern const fcml_cstring M_VPMOVDB = _FT("vpmovdb"); +extern const fcml_cstring M_VPMOVDW = _FT("vpmovdw"); +extern const fcml_cstring M_VPMOVM2B = _FT("vpmovm2b"); +extern const fcml_cstring M_VPMOVM2D = _FT("vpmovm2d"); +extern const fcml_cstring M_VPMOVM2Q = _FT("vpmovm2q"); +extern const fcml_cstring M_VPMOVM2W = _FT("vpmovm2w"); +extern const fcml_cstring M_VPMOVMSKB = _FT("vpmovmskb"); +extern const fcml_cstring M_VPMOVQ2M = _FT("vpmovq2m"); +extern const fcml_cstring M_VPMOVQB = _FT("vpmovqb"); +extern const fcml_cstring M_VPMOVQD = _FT("vpmovqd"); +extern const fcml_cstring M_VPMOVQW = _FT("vpmovqw"); +extern const fcml_cstring M_VPMOVSDB = _FT("vpmovsdb"); +extern const fcml_cstring M_VPMOVSDW = _FT("vpmovsdw"); +extern const fcml_cstring M_VPMOVSQB = _FT("vpmovsqb"); +extern const fcml_cstring M_VPMOVSQD = _FT("vpmovsqd"); +extern const fcml_cstring M_VPMOVSQW = _FT("vpmovsqw"); +extern const fcml_cstring M_VPMOVSWB = _FT("vpmovswb"); +extern const fcml_cstring M_VPMOVSXBD = _FT("vpmovsxbd"); +extern const fcml_cstring M_VPMOVSXBQ = _FT("vpmovsxbq"); +extern const fcml_cstring M_VPMOVSXBW = _FT("vpmovsxbw"); +extern const fcml_cstring M_VPMOVSXDQ = _FT("vpmovsxdq"); +extern const fcml_cstring M_VPMOVSXWD = _FT("vpmovsxwd"); +extern const fcml_cstring M_VPMOVSXWQ = _FT("vpmovsxwq"); +extern const fcml_cstring M_VPMOVUSDB = _FT("vpmovusdb"); +extern const fcml_cstring M_VPMOVUSDW = _FT("vpmovusdw"); +extern const fcml_cstring M_VPMOVUSQB = _FT("vpmovusqb"); +extern const fcml_cstring M_VPMOVUSQD = _FT("vpmovusqd"); +extern const fcml_cstring M_VPMOVUSQW = _FT("vpmovusqw"); +extern const fcml_cstring M_VPMOVUSWB = _FT("vpmovuswb"); +extern const fcml_cstring M_VPMOVW2M = _FT("vpmovw2m"); +extern const fcml_cstring M_VPMOVWB = _FT("vpmovwb"); +extern const fcml_cstring M_VPMOVZXBD = _FT("vpmovzxbd"); +extern const fcml_cstring M_VPMOVZXBQ = _FT("vpmovzxbq"); +extern const fcml_cstring M_VPMOVZXBW = _FT("vpmovzxbw"); +extern const fcml_cstring M_VPMOVZXDQ = _FT("vpmovzxdq"); +extern const fcml_cstring M_VPMOVZXWD = _FT("vpmovzxwd"); +extern const fcml_cstring M_VPMOVZXWQ = _FT("vpmovzxwq"); +extern const fcml_cstring M_VPMULDQ = _FT("vpmuldq"); +extern const fcml_cstring M_VPMULHRSW = _FT("vpmulhrsw"); +extern const fcml_cstring M_VPMULHUW = _FT("vpmulhuw"); +extern const fcml_cstring M_VPMULHW = _FT("vpmulhw"); +extern const fcml_cstring M_VPMULLD = _FT("vpmulld"); +extern const fcml_cstring M_VPMULLQ = _FT("vpmullq"); +extern const fcml_cstring M_VPMULLW = _FT("vpmullw"); +extern const fcml_cstring M_VPMULTISHIFTQB = _FT("vpmultishiftqb"); +extern const fcml_cstring M_VPMULUDQ = _FT("vpmuludq"); +extern const fcml_cstring M_VPOR = _FT("vpor"); +extern const fcml_cstring M_VPORD = _FT("vpord"); +extern const fcml_cstring M_VPORQ = _FT("vporq"); +extern const fcml_cstring M_VPPERM = _FT("vpperm"); +extern const fcml_cstring M_VPROLD = _FT("vprold"); +extern const fcml_cstring M_VPROLQ = _FT("vprolq"); +extern const fcml_cstring M_VPROLVD = _FT("vprolvd"); +extern const fcml_cstring M_VPROLVQ = _FT("vprolvq"); +extern const fcml_cstring M_VPRORD = _FT("vprord"); +extern const fcml_cstring M_VPRORQ = _FT("vprorq"); +extern const fcml_cstring M_VPRORVD = _FT("vprorvd"); +extern const fcml_cstring M_VPRORVQ = _FT("vprorvq"); +extern const fcml_cstring M_VPROTB = _FT("vprotb"); +extern const fcml_cstring M_VPROTD = _FT("vprotd"); +extern const fcml_cstring M_VPROTQ = _FT("vprotq"); +extern const fcml_cstring M_VPROTW = _FT("vprotw"); +extern const fcml_cstring M_VPSADBW = _FT("vpsadbw"); +extern const fcml_cstring M_VPSCATTERDD = _FT("vpscatterdd"); +extern const fcml_cstring M_VPSCATTERDQ = _FT("vpscatterdq"); +extern const fcml_cstring M_VPSCATTERQD = _FT("vpscatterqd"); +extern const fcml_cstring M_VPSCATTERQQ = _FT("vpscatterqq"); +extern const fcml_cstring M_VPSHAB = _FT("vpshab"); +extern const fcml_cstring M_VPSHAD = _FT("vpshad"); +extern const fcml_cstring M_VPSHAQ = _FT("vpshaq"); +extern const fcml_cstring M_VPSHAW = _FT("vpshaw"); +extern const fcml_cstring M_VPSHLB = _FT("vpshlb"); +extern const fcml_cstring M_VPSHLD = _FT("vpshld"); +extern const fcml_cstring M_VPSHLQ = _FT("vpshlq"); +extern const fcml_cstring M_VPSHLW = _FT("vpshlw"); +extern const fcml_cstring M_VPSHUFB = _FT("vpshufb"); +extern const fcml_cstring M_VPSHUFD = _FT("vpshufd"); +extern const fcml_cstring M_VPSHUFHW = _FT("vpshufhw"); +extern const fcml_cstring M_VPSHUFLW = _FT("vpshuflw"); +extern const fcml_cstring M_VPSIGNB = _FT("vpsignb"); +extern const fcml_cstring M_VPSIGND = _FT("vpsignd"); +extern const fcml_cstring M_VPSIGNW = _FT("vpsignw"); +extern const fcml_cstring M_VPSLLD = _FT("vpslld"); +extern const fcml_cstring M_VPSLLDQ = _FT("vpslldq"); +extern const fcml_cstring M_VPSLLQ = _FT("vpsllq"); +extern const fcml_cstring M_VPSLLVD = _FT("vpsllvd"); +extern const fcml_cstring M_VPSLLVQ = _FT("vpsllvq"); +extern const fcml_cstring M_VPSLLVW = _FT("vpsllvw"); +extern const fcml_cstring M_VPSLLW = _FT("vpsllw"); +extern const fcml_cstring M_VPSRAD = _FT("vpsrad"); +extern const fcml_cstring M_VPSRAQ = _FT("vpsraq"); +extern const fcml_cstring M_VPSRAVD = _FT("vpsravd"); +extern const fcml_cstring M_VPSRAVQ = _FT("vpsravq"); +extern const fcml_cstring M_VPSRAVW = _FT("vpsravw"); +extern const fcml_cstring M_VPSRAW = _FT("vpsraw"); +extern const fcml_cstring M_VPSRLD = _FT("vpsrld"); +extern const fcml_cstring M_VPSRLDQ = _FT("vpsrldq"); +extern const fcml_cstring M_VPSRLQ = _FT("vpsrlq"); +extern const fcml_cstring M_VPSRLVD = _FT("vpsrlvd"); +extern const fcml_cstring M_VPSRLVQ = _FT("vpsrlvq"); +extern const fcml_cstring M_VPSRLVW = _FT("vpsrlvw"); +extern const fcml_cstring M_VPSRLW = _FT("vpsrlw"); +extern const fcml_cstring M_VPSUBB = _FT("vpsubb"); +extern const fcml_cstring M_VPSUBD = _FT("vpsubd"); +extern const fcml_cstring M_VPSUBQ = _FT("vpsubq"); +extern const fcml_cstring M_VPSUBSB = _FT("vpsubsb"); +extern const fcml_cstring M_VPSUBSW = _FT("vpsubsw"); +extern const fcml_cstring M_VPSUBUSB = _FT("vpsubusb"); +extern const fcml_cstring M_VPSUBUSW = _FT("vpsubusw"); +extern const fcml_cstring M_VPSUBW = _FT("vpsubw"); +extern const fcml_cstring M_VPTERNLOGD = _FT("vpternlogd"); +extern const fcml_cstring M_VPTERNLOGQ = _FT("vpternlogq"); +extern const fcml_cstring M_VPTEST = _FT("vptest"); +extern const fcml_cstring M_VPTESTMB = _FT("vptestmb"); +extern const fcml_cstring M_VPTESTMD = _FT("vptestmd"); +extern const fcml_cstring M_VPTESTMQ = _FT("vptestmq"); +extern const fcml_cstring M_VPTESTMW = _FT("vptestmw"); +extern const fcml_cstring M_VPTESTNMB = _FT("vptestnmb"); +extern const fcml_cstring M_VPTESTNMD = _FT("vptestnmd"); +extern const fcml_cstring M_VPTESTNMQ = _FT("vptestnmq"); +extern const fcml_cstring M_VPTESTNMW = _FT("vptestnmw"); +extern const fcml_cstring M_VPUNPCKHBW = _FT("vpunpckhbw"); +extern const fcml_cstring M_VPUNPCKHDQ = _FT("vpunpckhdq"); +extern const fcml_cstring M_VPUNPCKHQDQ = _FT("vpunpckhqdq"); +extern const fcml_cstring M_VPUNPCKHWD = _FT("vpunpckhwd"); +extern const fcml_cstring M_VPUNPCKLBW = _FT("vpunpcklbw"); +extern const fcml_cstring M_VPUNPCKLDQ = _FT("vpunpckldq"); +extern const fcml_cstring M_VPUNPCKLQDQ = _FT("vpunpcklqdq"); +extern const fcml_cstring M_VPUNPCKLWD = _FT("vpunpcklwd"); +extern const fcml_cstring M_VPXOR = _FT("vpxor"); +extern const fcml_cstring M_VPXORD = _FT("vpxord"); +extern const fcml_cstring M_VPXORQ = _FT("vpxorq"); +extern const fcml_cstring M_VRANGEPD = _FT("vrangepd"); +extern const fcml_cstring M_VRANGEPS = _FT("vrangeps"); +extern const fcml_cstring M_VRANGESD = _FT("vrangesd"); +extern const fcml_cstring M_VRANGESS = _FT("vrangess"); +extern const fcml_cstring M_VRCP14PD = _FT("vrcp14pd"); +extern const fcml_cstring M_VRCP14PS = _FT("vrcp14ps"); +extern const fcml_cstring M_VRCP14SD = _FT("vrcp14sd"); +extern const fcml_cstring M_VRCP14SS = _FT("vrcp14ss"); +extern const fcml_cstring M_VRCP28PD = _FT("vrcp28pd"); +extern const fcml_cstring M_VRCP28PS = _FT("vrcp28ps"); +extern const fcml_cstring M_VRCP28SD = _FT("vrcp28sd"); +extern const fcml_cstring M_VRCP28SS = _FT("vrcp28ss"); +extern const fcml_cstring M_VRCPPS = _FT("vrcpps"); +extern const fcml_cstring M_VRCPSS = _FT("vrcpss"); +extern const fcml_cstring M_VREDUCEPD = _FT("vreducepd"); +extern const fcml_cstring M_VREDUCEPS = _FT("vreduceps"); +extern const fcml_cstring M_VREDUCESD = _FT("vreducesd"); +extern const fcml_cstring M_VREDUCESS = _FT("vreducess"); +extern const fcml_cstring M_VRNDSCALEPD = _FT("vrndscalepd"); +extern const fcml_cstring M_VRNDSCALEPS = _FT("vrndscaleps"); +extern const fcml_cstring M_VRNDSCALESD = _FT("vrndscalesd"); +extern const fcml_cstring M_VRNDSCALESS = _FT("vrndscaless"); +extern const fcml_cstring M_VROUNDPD = _FT("vroundpd"); +extern const fcml_cstring M_VROUNDPS = _FT("vroundps"); +extern const fcml_cstring M_VROUNDSD = _FT("vroundsd"); +extern const fcml_cstring M_VROUNDSS = _FT("vroundss"); +extern const fcml_cstring M_VRSQRT14PD = _FT("vrsqrt14pd"); +extern const fcml_cstring M_VRSQRT14PS = _FT("vrsqrt14ps"); +extern const fcml_cstring M_VRSQRT14SD = _FT("vrsqrt14sd"); +extern const fcml_cstring M_VRSQRT14SS = _FT("vrsqrt14ss"); +extern const fcml_cstring M_VRSQRT28PD = _FT("vrsqrt28pd"); +extern const fcml_cstring M_VRSQRT28PS = _FT("vrsqrt28ps"); +extern const fcml_cstring M_VRSQRT28SD = _FT("vrsqrt28sd"); +extern const fcml_cstring M_VRSQRT28SS = _FT("vrsqrt28ss"); +extern const fcml_cstring M_VRSQRTPS = _FT("vrsqrtps"); +extern const fcml_cstring M_VRSQRTSS = _FT("vrsqrtss"); +extern const fcml_cstring M_VSCALEFPD = _FT("vscalefpd"); +extern const fcml_cstring M_VSCALEFPS = _FT("vscalefps"); +extern const fcml_cstring M_VSCALEFSD = _FT("vscalefsd"); +extern const fcml_cstring M_VSCALEFSS = _FT("vscalefss"); +extern const fcml_cstring M_VSCATTERDPD = _FT("vscatterdpd"); +extern const fcml_cstring M_VSCATTERDPS = _FT("vscatterdps"); +extern const fcml_cstring M_VSCATTERPF0DPD = _FT("vscatterpf0dpd"); +extern const fcml_cstring M_VSCATTERPF0DPS = _FT("vscatterpf0dps"); +extern const fcml_cstring M_VSCATTERPF0QPD = _FT("vscatterpf0qpd"); +extern const fcml_cstring M_VSCATTERPF0QPS = _FT("vscatterpf0qps"); +extern const fcml_cstring M_VSCATTERPF1DPD = _FT("vscatterpf1dpd"); +extern const fcml_cstring M_VSCATTERPF1DPS = _FT("vscatterpf1dps"); +extern const fcml_cstring M_VSCATTERPF1QPD = _FT("vscatterpf1qpd"); +extern const fcml_cstring M_VSCATTERPF1QPS = _FT("vscatterpf1qps"); +extern const fcml_cstring M_VSCATTERQPD = _FT("vscatterqpd"); +extern const fcml_cstring M_VSCATTERQPS = _FT("vscatterqps"); +extern const fcml_cstring M_VSHUFF32X4 = _FT("vshuff32x4"); +extern const fcml_cstring M_VSHUFF64X2 = _FT("vshuff64x2"); +extern const fcml_cstring M_VSHUFI32X4 = _FT("vshufi32x4"); +extern const fcml_cstring M_VSHUFI64X2 = _FT("vshufi64x2"); +extern const fcml_cstring M_VSHUFPD = _FT("vshufpd"); +extern const fcml_cstring M_VSHUFPS = _FT("vshufps"); +extern const fcml_cstring M_VSQRTPD = _FT("vsqrtpd"); +extern const fcml_cstring M_VSQRTPS = _FT("vsqrtps"); +extern const fcml_cstring M_VSQRTSD = _FT("vsqrtsd"); +extern const fcml_cstring M_VSQRTSS = _FT("vsqrtss"); +extern const fcml_cstring M_VSTMXCSR = _FT("vstmxcsr"); +extern const fcml_cstring M_VSUBPD = _FT("vsubpd"); +extern const fcml_cstring M_VSUBPS = _FT("vsubps"); +extern const fcml_cstring M_VSUBSD = _FT("vsubsd"); +extern const fcml_cstring M_VSUBSS = _FT("vsubss"); +extern const fcml_cstring M_VTESTPD = _FT("vtestpd"); +extern const fcml_cstring M_VTESTPS = _FT("vtestps"); +extern const fcml_cstring M_VUCOMISD = _FT("vucomisd"); +extern const fcml_cstring M_VUCOMISS = _FT("vucomiss"); +extern const fcml_cstring M_VUNPCKHPD = _FT("vunpckhpd"); +extern const fcml_cstring M_VUNPCKHPS = _FT("vunpckhps"); +extern const fcml_cstring M_VUNPCKLPD = _FT("vunpcklpd"); +extern const fcml_cstring M_VUNPCKLPS = _FT("vunpcklps"); +extern const fcml_cstring M_VXORPD = _FT("vxorpd"); +extern const fcml_cstring M_VXORPS = _FT("vxorps"); +extern const fcml_cstring M_VZEROALL = _FT("vzeroall"); +extern const fcml_cstring M_VZEROUPPER = _FT("vzeroupper"); +extern const fcml_cstring M_WAIT = _FT("wait"); +extern const fcml_cstring M_WBINVD = _FT("wbinvd"); +extern const fcml_cstring M_WRFSBASE = _FT("wrfsbase"); +extern const fcml_cstring M_WRGSBASE = _FT("wrgsbase"); +extern const fcml_cstring M_WRMSR = _FT("wrmsr"); +extern const fcml_cstring M_XABORT = _FT("xabort"); +extern const fcml_cstring M_XADD = _FT("xadd"); +extern const fcml_cstring M_XBEGIN = _FT("xbegin"); +extern const fcml_cstring M_XCHG = _FT("xchg"); +extern const fcml_cstring M_XEND = _FT("xend"); +extern const fcml_cstring M_XGETBV = _FT("xgetbv"); +extern const fcml_cstring M_XLAT = _FT("xlat"); +extern const fcml_cstring M_XLATB = _FT("xlatb"); +extern const fcml_cstring M_XOR = _FT("xor"); +extern const fcml_cstring M_XORPD = _FT("xorpd"); +extern const fcml_cstring M_XORPS = _FT("xorps"); +extern const fcml_cstring M_XRSTOR = _FT("xrstor"); +extern const fcml_cstring M_XRSTOR64 = _FT("xrstor64"); +extern const fcml_cstring M_XSAVE = _FT("xsave"); +extern const fcml_cstring M_XSAVE64 = _FT("xsave64"); +extern const fcml_cstring M_XSAVEOPT = _FT("xsaveopt"); +extern const fcml_cstring M_XSAVEOPT64 = _FT("xsaveopt64"); +extern const fcml_cstring M_XSETBV = _FT("xsetbv"); +extern const fcml_cstring M_XTEST = _FT("xtest"); + +} +} + diff --git a/dependencies/fcml/include/fcml_intel_mnemonics.h b/dependencies/fcml/include/fcml_intel_mnemonics.h new file mode 100644 index 0000000..44fdc6a --- /dev/null +++ b/dependencies/fcml/include/fcml_intel_mnemonics.h @@ -0,0 +1,1715 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_intel_mnemonics.h + * Declarations of Intel mnemonics for C. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_INTEL_MNEMONICS_H_ +#define FCML_INTEL_MNEMONICS_H_ + +#include "fcml_types.h" + +#define M_AAA FCML_TEXT("aaa") +#define M_AAD FCML_TEXT("aad") +#define M_AAM FCML_TEXT("aam") +#define M_AAS FCML_TEXT("aas") +#define M_ADC FCML_TEXT("adc") +#define M_ADCX FCML_TEXT("adcx") +#define M_ADD FCML_TEXT("add") +#define M_ADDPD FCML_TEXT("addpd") +#define M_ADDPS FCML_TEXT("addps") +#define M_ADDSD FCML_TEXT("addsd") +#define M_ADDSS FCML_TEXT("addss") +#define M_ADDSUBPD FCML_TEXT("addsubpd") +#define M_ADDSUBPS FCML_TEXT("addsubps") +#define M_ADOX FCML_TEXT("adox") +#define M_AESDEC FCML_TEXT("aesdec") +#define M_AESDECLAST FCML_TEXT("aesdeclast") +#define M_AESENC FCML_TEXT("aesenc") +#define M_AESENCLAST FCML_TEXT("aesenclast") +#define M_AESIMC FCML_TEXT("aesimc") +#define M_AESKEYGENASSIST FCML_TEXT("aeskeygenassist") +#define M_AND FCML_TEXT("and") +#define M_ANDN FCML_TEXT("andn") +#define M_ANDNPD FCML_TEXT("andnpd") +#define M_ANDNPS FCML_TEXT("andnps") +#define M_ANDPD FCML_TEXT("andpd") +#define M_ANDPS FCML_TEXT("andps") +#define M_ARPL FCML_TEXT("arpl") +#define M_BEXR FCML_TEXT("bexr") +#define M_BEXTR FCML_TEXT("bextr") +#define M_BLCFILL FCML_TEXT("blcfill") +#define M_BLCI FCML_TEXT("blci") +#define M_BLCIC FCML_TEXT("blcic") +#define M_BLCMSK FCML_TEXT("blcmsk") +#define M_BLCS FCML_TEXT("blcs") +#define M_BLENDPD FCML_TEXT("blendpd") +#define M_BLENDPS FCML_TEXT("blendps") +#define M_BLENDVPD FCML_TEXT("blendvpd") +#define M_BLENDVPS FCML_TEXT("blendvps") +#define M_BLSFILL FCML_TEXT("blsfill") +#define M_BLSI FCML_TEXT("blsi") +#define M_BLSIC FCML_TEXT("blsic") +#define M_BLSMSK FCML_TEXT("blsmsk") +#define M_BLSR FCML_TEXT("blsr") +#define M_BOUND FCML_TEXT("bound") +#define M_BSF FCML_TEXT("bsf") +#define M_BSR FCML_TEXT("bsr") +#define M_BSWAP FCML_TEXT("bswap") +#define M_BT FCML_TEXT("bt") +#define M_BTC FCML_TEXT("btc") +#define M_BTR FCML_TEXT("btr") +#define M_BTS FCML_TEXT("bts") +#define M_BZHI FCML_TEXT("bzhi") +#define M_CALL FCML_TEXT("call") +#define M_CBW FCML_TEXT("cbw") +#define M_CDQ FCML_TEXT("cdq") +#define M_CDQE FCML_TEXT("cdqe") +#define M_CLAC FCML_TEXT("clac") +#define M_CLC FCML_TEXT("clc") +#define M_CLD FCML_TEXT("cld") +#define M_CLFLUSH FCML_TEXT("clflush") +#define M_CLGI FCML_TEXT("clgi") +#define M_CLI FCML_TEXT("cli") +#define M_CLTS FCML_TEXT("clts") +#define M_CMC FCML_TEXT("cmc") +#define M_CMOVA FCML_TEXT("cmova") +#define M_CMOVAE FCML_TEXT("cmovae") +#define M_CMOVB FCML_TEXT("cmovb") +#define M_CMOVBE FCML_TEXT("cmovbe") +#define M_CMOVC FCML_TEXT("cmovc") +#define M_CMOVENE FCML_TEXT("cmovene") +#define M_CMOVG FCML_TEXT("cmovg") +#define M_CMOVGE FCML_TEXT("cmovge") +#define M_CMOVL FCML_TEXT("cmovl") +#define M_CMOVLE FCML_TEXT("cmovle") +#define M_CMOVNA FCML_TEXT("cmovna") +#define M_CMOVNAE FCML_TEXT("cmovnae") +#define M_CMOVNB FCML_TEXT("cmovnb") +#define M_CMOVNBE FCML_TEXT("cmovnbe") +#define M_CMOVNC FCML_TEXT("cmovnc") +#define M_CMOVNG FCML_TEXT("cmovng") +#define M_CMOVNGE FCML_TEXT("cmovnge") +#define M_CMOVNL FCML_TEXT("cmovnl") +#define M_CMOVNLE FCML_TEXT("cmovnle") +#define M_CMOVNO FCML_TEXT("cmovno") +#define M_CMOVNP FCML_TEXT("cmovnp") +#define M_CMOVNS FCML_TEXT("cmovns") +#define M_CMOVNZ FCML_TEXT("cmovnz") +#define M_CMOVO FCML_TEXT("cmovo") +#define M_CMOVP FCML_TEXT("cmovp") +#define M_CMOVPE FCML_TEXT("cmovpe") +#define M_CMOVPO FCML_TEXT("cmovpo") +#define M_CMOVS FCML_TEXT("cmovs") +#define M_CMOVZ FCML_TEXT("cmovz") +#define M_CMP FCML_TEXT("cmp") +#define M_CMPEQPD FCML_TEXT("cmpeqpd") +#define M_CMPEQPS FCML_TEXT("cmpeqps") +#define M_CMPEQSD FCML_TEXT("cmpeqsd") +#define M_CMPEQSS FCML_TEXT("cmpeqss") +#define M_CMPLEPD FCML_TEXT("cmplepd") +#define M_CMPLEPS FCML_TEXT("cmpleps") +#define M_CMPLESD FCML_TEXT("cmplesd") +#define M_CMPLESS FCML_TEXT("cmpless") +#define M_CMPLTPD FCML_TEXT("cmpltpd") +#define M_CMPLTPS FCML_TEXT("cmpltps") +#define M_CMPLTSD FCML_TEXT("cmpltsd") +#define M_CMPLTSS FCML_TEXT("cmpltss") +#define M_CMPNEQPD FCML_TEXT("cmpneqpd") +#define M_CMPNEQPS FCML_TEXT("cmpneqps") +#define M_CMPNEQSD FCML_TEXT("cmpneqsd") +#define M_CMPNEQSS FCML_TEXT("cmpneqss") +#define M_CMPNLEPD FCML_TEXT("cmpnlepd") +#define M_CMPNLEPS FCML_TEXT("cmpnleps") +#define M_CMPNLESD FCML_TEXT("cmpnlesd") +#define M_CMPNLESS FCML_TEXT("cmpnless") +#define M_CMPNLTPD FCML_TEXT("cmpnltpd") +#define M_CMPNLTPS FCML_TEXT("cmpnltps") +#define M_CMPNLTSD FCML_TEXT("cmpnltsd") +#define M_CMPNLTSS FCML_TEXT("cmpnltss") +#define M_CMPORDPD FCML_TEXT("cmpordpd") +#define M_CMPORDPS FCML_TEXT("cmpordps") +#define M_CMPORDSD FCML_TEXT("cmpordsd") +#define M_CMPORDSS FCML_TEXT("cmpordss") +#define M_CMPPD FCML_TEXT("cmppd") +#define M_CMPPS FCML_TEXT("cmpps") +#define M_CMPS FCML_TEXT("cmps") +#define M_CMPSB FCML_TEXT("cmpsb") +#define M_CMPSD FCML_TEXT("cmpsd") +#define M_CMPSQ FCML_TEXT("cmpsq") +#define M_CMPSS FCML_TEXT("cmpss") +#define M_CMPSW FCML_TEXT("cmpsw") +#define M_CMPUNORDPD FCML_TEXT("cmpunordpd") +#define M_CMPUNORDPS FCML_TEXT("cmpunordps") +#define M_CMPUNORDSD FCML_TEXT("cmpunordsd") +#define M_CMPUNORDSS FCML_TEXT("cmpunordss") +#define M_CMPXCHG FCML_TEXT("cmpxchg") +#define M_CMPXCHG16B FCML_TEXT("cmpxchg16b") +#define M_CMPXCHG8B FCML_TEXT("cmpxchg8b") +#define M_COMISD FCML_TEXT("comisd") +#define M_COMISS FCML_TEXT("comiss") +#define M_CPUID FCML_TEXT("cpuid") +#define M_CQO FCML_TEXT("cqo") +#define M_CRC32 FCML_TEXT("crc32") +#define M_CVTDQ2PD FCML_TEXT("cvtdq2pd") +#define M_CVTDQ2PS FCML_TEXT("cvtdq2ps") +#define M_CVTPD2DQ FCML_TEXT("cvtpd2dq") +#define M_CVTPD2PI FCML_TEXT("cvtpd2pi") +#define M_CVTPD2PS FCML_TEXT("cvtpd2ps") +#define M_CVTPI2PD FCML_TEXT("cvtpi2pd") +#define M_CVTPI2PS FCML_TEXT("cvtpi2ps") +#define M_CVTPS2DQ FCML_TEXT("cvtps2dq") +#define M_CVTPS2PD FCML_TEXT("cvtps2pd") +#define M_CVTPS2PI FCML_TEXT("cvtps2pi") +#define M_CVTSD2SI FCML_TEXT("cvtsd2si") +#define M_CVTSD2SS FCML_TEXT("cvtsd2ss") +#define M_CVTSI2SD FCML_TEXT("cvtsi2sd") +#define M_CVTSI2SS FCML_TEXT("cvtsi2ss") +#define M_CVTSS2SD FCML_TEXT("cvtss2sd") +#define M_CVTSS2SI FCML_TEXT("cvtss2si") +#define M_CVTTPD2DQ FCML_TEXT("cvttpd2dq") +#define M_CVTTPD2PI FCML_TEXT("cvttpd2pi") +#define M_CVTTPS2DQ FCML_TEXT("cvttps2dq") +#define M_CVTTPS2PI FCML_TEXT("cvttps2pi") +#define M_CVTTSD2SI FCML_TEXT("cvttsd2si") +#define M_CVTTSS2SI FCML_TEXT("cvttss2si") +#define M_CWD FCML_TEXT("cwd") +#define M_CWDE FCML_TEXT("cwde") +#define M_DAA FCML_TEXT("daa") +#define M_DAS FCML_TEXT("das") +#define M_DEC FCML_TEXT("dec") +#define M_DIV FCML_TEXT("div") +#define M_DIVPD FCML_TEXT("divpd") +#define M_DIVPS FCML_TEXT("divps") +#define M_DIVSD FCML_TEXT("divsd") +#define M_DIVSS FCML_TEXT("divss") +#define M_DPPD FCML_TEXT("dppd") +#define M_DPPS FCML_TEXT("dpps") +#define M_EMMS FCML_TEXT("emms") +#define M_ENTER FCML_TEXT("enter") +#define M_EXTRACTPS FCML_TEXT("extractps") +#define M_EXTRQ FCML_TEXT("extrq") +#define M_F2XM1 FCML_TEXT("f2xm1") +#define M_FABS FCML_TEXT("fabs") +#define M_FADD FCML_TEXT("fadd") +#define M_FADDP FCML_TEXT("faddp") +#define M_FBLD FCML_TEXT("fbld") +#define M_FBSTP FCML_TEXT("fbstp") +#define M_FCHS FCML_TEXT("fchs") +#define M_FCLEX FCML_TEXT("fclex") +#define M_FCMOVB FCML_TEXT("fcmovb") +#define M_FCMOVBE FCML_TEXT("fcmovbe") +#define M_FCMOVE FCML_TEXT("fcmove") +#define M_FCMOVNB FCML_TEXT("fcmovnb") +#define M_FCMOVNBE FCML_TEXT("fcmovnbe") +#define M_FCMOVNE FCML_TEXT("fcmovne") +#define M_FCMOVNU FCML_TEXT("fcmovnu") +#define M_FCMOVU FCML_TEXT("fcmovu") +#define M_FCOM FCML_TEXT("fcom") +#define M_FCOMI FCML_TEXT("fcomi") +#define M_FCOMIP FCML_TEXT("fcomip") +#define M_FCOMP FCML_TEXT("fcomp") +#define M_FCOMPP FCML_TEXT("fcompp") +#define M_FCOS FCML_TEXT("fcos") +#define M_FDECSTP FCML_TEXT("fdecstp") +#define M_FDIV FCML_TEXT("fdiv") +#define M_FDIVP FCML_TEXT("fdivp") +#define M_FDIVR FCML_TEXT("fdivr") +#define M_FDIVRP FCML_TEXT("fdivrp") +#define M_FEMMS FCML_TEXT("femms") +#define M_FFREE FCML_TEXT("ffree") +#define M_FIADD FCML_TEXT("fiadd") +#define M_FICOM FCML_TEXT("ficom") +#define M_FICOMP FCML_TEXT("ficomp") +#define M_FIDIV FCML_TEXT("fidiv") +#define M_FIDIVR FCML_TEXT("fidivr") +#define M_FILD FCML_TEXT("fild") +#define M_FIMUL FCML_TEXT("fimul") +#define M_FINCSTP FCML_TEXT("fincstp") +#define M_FINIT FCML_TEXT("finit") +#define M_FIST FCML_TEXT("fist") +#define M_FISTP FCML_TEXT("fistp") +#define M_FISTTP FCML_TEXT("fisttp") +#define M_FISUB FCML_TEXT("fisub") +#define M_FISUBR FCML_TEXT("fisubr") +#define M_FLD FCML_TEXT("fld") +#define M_FLD1 FCML_TEXT("fld1") +#define M_FLDCW FCML_TEXT("fldcw") +#define M_FLDENV FCML_TEXT("fldenv") +#define M_FLDL2E FCML_TEXT("fldl2e") +#define M_FLDL2T FCML_TEXT("fldl2t") +#define M_FLDLG2 FCML_TEXT("fldlg2") +#define M_FLDLN2 FCML_TEXT("fldln2") +#define M_FLDPI FCML_TEXT("fldpi") +#define M_FLDZ FCML_TEXT("fldz") +#define M_FMUL FCML_TEXT("fmul") +#define M_FMULP FCML_TEXT("fmulp") +#define M_FNCLEX FCML_TEXT("fnclex") +#define M_FNINIT FCML_TEXT("fninit") +#define M_FNOP FCML_TEXT("fnop") +#define M_FNSAVE FCML_TEXT("fnsave") +#define M_FNSTCW FCML_TEXT("fnstcw") +#define M_FNSTENV FCML_TEXT("fnstenv") +#define M_FNSTSW FCML_TEXT("fnstsw") +#define M_FPATAN FCML_TEXT("fpatan") +#define M_FPREM FCML_TEXT("fprem") +#define M_FPREM1 FCML_TEXT("fprem1") +#define M_FPTAN FCML_TEXT("fptan") +#define M_FRNDINT FCML_TEXT("frndint") +#define M_FRSTOR FCML_TEXT("frstor") +#define M_FSAVE FCML_TEXT("fsave") +#define M_FSCALE FCML_TEXT("fscale") +#define M_FSIN FCML_TEXT("fsin") +#define M_FSINCOS FCML_TEXT("fsincos") +#define M_FSQRT FCML_TEXT("fsqrt") +#define M_FST FCML_TEXT("fst") +#define M_FSTCW FCML_TEXT("fstcw") +#define M_FSTENV FCML_TEXT("fstenv") +#define M_FSTP FCML_TEXT("fstp") +#define M_FSTSW FCML_TEXT("fstsw") +#define M_FSUB FCML_TEXT("fsub") +#define M_FSUBP FCML_TEXT("fsubp") +#define M_FSUBR FCML_TEXT("fsubr") +#define M_FSUBRP FCML_TEXT("fsubrp") +#define M_FTST FCML_TEXT("ftst") +#define M_FUCOM FCML_TEXT("fucom") +#define M_FUCOMI FCML_TEXT("fucomi") +#define M_FUCOMIP FCML_TEXT("fucomip") +#define M_FUCOMP FCML_TEXT("fucomp") +#define M_FUCOMPP FCML_TEXT("fucompp") +#define M_FWAIT FCML_TEXT("fwait") +#define M_FXAM FCML_TEXT("fxam") +#define M_FXCH FCML_TEXT("fxch") +#define M_FXRSTOR FCML_TEXT("fxrstor") +#define M_FXRSTOR64 FCML_TEXT("fxrstor64") +#define M_FXSAVE FCML_TEXT("fxsave") +#define M_FXSAVE64 FCML_TEXT("fxsave64") +#define M_FXTRACT FCML_TEXT("fxtract") +#define M_FYL2X FCML_TEXT("fyl2x") +#define M_FYL2XP1 FCML_TEXT("fyl2xp1") +#define M_GETSEC FCML_TEXT("getsec") +#define M_HADDPD FCML_TEXT("haddpd") +#define M_HADDPS FCML_TEXT("haddps") +#define M_HLT FCML_TEXT("hlt") +#define M_HSUBPD FCML_TEXT("hsubpd") +#define M_HSUBPS FCML_TEXT("hsubps") +#define M_IDIV FCML_TEXT("idiv") +#define M_IMUL FCML_TEXT("imul") +#define M_IN FCML_TEXT("in") +#define M_INC FCML_TEXT("inc") +#define M_INS FCML_TEXT("ins") +#define M_INSB FCML_TEXT("insb") +#define M_INSD FCML_TEXT("insd") +#define M_INSERTPS FCML_TEXT("insertps") +#define M_INSERTQ FCML_TEXT("insertq") +#define M_INSW FCML_TEXT("insw") +#define M_INT FCML_TEXT("int") +#define M_INT3 FCML_TEXT("int3") +#define M_INTO FCML_TEXT("into") +#define M_INVD FCML_TEXT("invd") +#define M_INVEPT FCML_TEXT("invept") +#define M_INVLPG FCML_TEXT("invlpg") +#define M_INVLPGA FCML_TEXT("invlpga") +#define M_INVPCID FCML_TEXT("invpcid") +#define M_INVVPID FCML_TEXT("invvpid") +#define M_IRET FCML_TEXT("iret") +#define M_IRETD FCML_TEXT("iretd") +#define M_IRETQ FCML_TEXT("iretq") +#define M_JA FCML_TEXT("ja") +#define M_JAE FCML_TEXT("jae") +#define M_JB FCML_TEXT("jb") +#define M_JBE FCML_TEXT("jbe") +#define M_JC FCML_TEXT("jc") +#define M_JCXZ FCML_TEXT("jcxz") +#define M_JECXZ FCML_TEXT("jecxz") +#define M_JENE FCML_TEXT("jene") +#define M_JG FCML_TEXT("jg") +#define M_JGE FCML_TEXT("jge") +#define M_JL FCML_TEXT("jl") +#define M_JLE FCML_TEXT("jle") +#define M_JMP FCML_TEXT("jmp") +#define M_JNA FCML_TEXT("jna") +#define M_JNAE FCML_TEXT("jnae") +#define M_JNB FCML_TEXT("jnb") +#define M_JNBE FCML_TEXT("jnbe") +#define M_JNC FCML_TEXT("jnc") +#define M_JNG FCML_TEXT("jng") +#define M_JNGE FCML_TEXT("jnge") +#define M_JNL FCML_TEXT("jnl") +#define M_JNLE FCML_TEXT("jnle") +#define M_JNO FCML_TEXT("jno") +#define M_JNP FCML_TEXT("jnp") +#define M_JNS FCML_TEXT("jns") +#define M_JNZ FCML_TEXT("jnz") +#define M_JO FCML_TEXT("jo") +#define M_JP FCML_TEXT("jp") +#define M_JPE FCML_TEXT("jpe") +#define M_JPO FCML_TEXT("jpo") +#define M_JRCXZ FCML_TEXT("jrcxz") +#define M_JS FCML_TEXT("js") +#define M_JZ FCML_TEXT("jz") +#define M_KADDB FCML_TEXT("kaddb") +#define M_KADDD FCML_TEXT("kaddd") +#define M_KADDQ FCML_TEXT("kaddq") +#define M_KADDW FCML_TEXT("kaddw") +#define M_KANDB FCML_TEXT("kandb") +#define M_KANDD FCML_TEXT("kandd") +#define M_KANDNB FCML_TEXT("kandnb") +#define M_KANDND FCML_TEXT("kandnd") +#define M_KANDNQ FCML_TEXT("kandnq") +#define M_KANDNW FCML_TEXT("kandnw") +#define M_KANDQ FCML_TEXT("kandq") +#define M_KANDW FCML_TEXT("kandw") +#define M_KMOVB FCML_TEXT("kmovb") +#define M_KMOVD FCML_TEXT("kmovd") +#define M_KMOVQ FCML_TEXT("kmovq") +#define M_KMOVW FCML_TEXT("kmovw") +#define M_KNOTB FCML_TEXT("knotb") +#define M_KNOTD FCML_TEXT("knotd") +#define M_KNOTQ FCML_TEXT("knotq") +#define M_KNOTW FCML_TEXT("knotw") +#define M_KORB FCML_TEXT("korb") +#define M_KORD FCML_TEXT("kord") +#define M_KORQ FCML_TEXT("korq") +#define M_KORTESTB FCML_TEXT("kortestb") +#define M_KORTESTD FCML_TEXT("kortestd") +#define M_KORTESTQ FCML_TEXT("kortestq") +#define M_KORTESTW FCML_TEXT("kortestw") +#define M_KORW FCML_TEXT("korw") +#define M_KSHIFTLB FCML_TEXT("kshiftlb") +#define M_KSHIFTLD FCML_TEXT("kshiftld") +#define M_KSHIFTLQ FCML_TEXT("kshiftlq") +#define M_KSHIFTLW FCML_TEXT("kshiftlw") +#define M_KSHIFTRB FCML_TEXT("kshiftrb") +#define M_KSHIFTRD FCML_TEXT("kshiftrd") +#define M_KSHIFTRQ FCML_TEXT("kshiftrq") +#define M_KSHIFTRW FCML_TEXT("kshiftrw") +#define M_KTESTB FCML_TEXT("ktestb") +#define M_KTESTD FCML_TEXT("ktestd") +#define M_KTESTQ FCML_TEXT("ktestq") +#define M_KTESTW FCML_TEXT("ktestw") +#define M_KXNORB FCML_TEXT("kxnorb") +#define M_KXNORD FCML_TEXT("kxnord") +#define M_KXNORQ FCML_TEXT("kxnorq") +#define M_KXNORW FCML_TEXT("kxnorw") +#define M_KXORB FCML_TEXT("kxorb") +#define M_KXORD FCML_TEXT("kxord") +#define M_KXORQ FCML_TEXT("kxorq") +#define M_KXORW FCML_TEXT("kxorw") +#define M_LAHF FCML_TEXT("lahf") +#define M_LAR FCML_TEXT("lar") +#define M_LDDQU FCML_TEXT("lddqu") +#define M_LDMXCSR FCML_TEXT("ldmxcsr") +#define M_LDS FCML_TEXT("lds") +#define M_LEA FCML_TEXT("lea") +#define M_LEAVE FCML_TEXT("leave") +#define M_LES FCML_TEXT("les") +#define M_LFENCE FCML_TEXT("lfence") +#define M_LFS FCML_TEXT("lfs") +#define M_LGDT FCML_TEXT("lgdt") +#define M_LGS FCML_TEXT("lgs") +#define M_LIDT FCML_TEXT("lidt") +#define M_LLDT FCML_TEXT("lldt") +#define M_LLWPCB FCML_TEXT("llwpcb") +#define M_LMSW FCML_TEXT("lmsw") +#define M_LODS FCML_TEXT("lods") +#define M_LODSB FCML_TEXT("lodsb") +#define M_LODSD FCML_TEXT("lodsd") +#define M_LODSQ FCML_TEXT("lodsq") +#define M_LODSW FCML_TEXT("lodsw") +#define M_LOOP FCML_TEXT("loop") +#define M_LOOPE FCML_TEXT("loope") +#define M_LOOPNE FCML_TEXT("loopne") +#define M_LOOPNZ FCML_TEXT("loopnz") +#define M_LOOPZ FCML_TEXT("loopz") +#define M_LSL FCML_TEXT("lsl") +#define M_LSS FCML_TEXT("lss") +#define M_LTR FCML_TEXT("ltr") +#define M_LWPINS FCML_TEXT("lwpins") +#define M_LWPVAL FCML_TEXT("lwpval") +#define M_LZCNT FCML_TEXT("lzcnt") +#define M_MASKMOVDQU FCML_TEXT("maskmovdqu") +#define M_MASKMOVQ FCML_TEXT("maskmovq") +#define M_MAXPD FCML_TEXT("maxpd") +#define M_MAXPS FCML_TEXT("maxps") +#define M_MAXSD FCML_TEXT("maxsd") +#define M_MAXSS FCML_TEXT("maxss") +#define M_MFENCE FCML_TEXT("mfence") +#define M_MINPD FCML_TEXT("minpd") +#define M_MINPS FCML_TEXT("minps") +#define M_MINSD FCML_TEXT("minsd") +#define M_MINSS FCML_TEXT("minss") +#define M_MONITOR FCML_TEXT("monitor") +#define M_MOV FCML_TEXT("mov") +#define M_MOVAPD FCML_TEXT("movapd") +#define M_MOVAPS FCML_TEXT("movaps") +#define M_MOVBE FCML_TEXT("movbe") +#define M_MOVD FCML_TEXT("movd") +#define M_MOVDDUP FCML_TEXT("movddup") +#define M_MOVDQ2Q FCML_TEXT("movdq2q") +#define M_MOVDQA FCML_TEXT("movdqa") +#define M_MOVDQU FCML_TEXT("movdqu") +#define M_MOVHLPS FCML_TEXT("movhlps") +#define M_MOVHPD FCML_TEXT("movhpd") +#define M_MOVHPS FCML_TEXT("movhps") +#define M_MOVLHPS FCML_TEXT("movlhps") +#define M_MOVLPD FCML_TEXT("movlpd") +#define M_MOVLPS FCML_TEXT("movlps") +#define M_MOVMSKPD FCML_TEXT("movmskpd") +#define M_MOVMSKPS FCML_TEXT("movmskps") +#define M_MOVNTDQ FCML_TEXT("movntdq") +#define M_MOVNTDQA FCML_TEXT("movntdqa") +#define M_MOVNTI FCML_TEXT("movnti") +#define M_MOVNTPD FCML_TEXT("movntpd") +#define M_MOVNTPS FCML_TEXT("movntps") +#define M_MOVNTQ FCML_TEXT("movntq") +#define M_MOVNTSD FCML_TEXT("movntsd") +#define M_MOVNTSS FCML_TEXT("movntss") +#define M_MOVQ FCML_TEXT("movq") +#define M_MOVQ2DQ FCML_TEXT("movq2dq") +#define M_MOVS FCML_TEXT("movs") +#define M_MOVSB FCML_TEXT("movsb") +#define M_MOVSD FCML_TEXT("movsd") +#define M_MOVSHDUP FCML_TEXT("movshdup") +#define M_MOVSLDUP FCML_TEXT("movsldup") +#define M_MOVSQ FCML_TEXT("movsq") +#define M_MOVSS FCML_TEXT("movss") +#define M_MOVSW FCML_TEXT("movsw") +#define M_MOVSX FCML_TEXT("movsx") +#define M_MOVSXD FCML_TEXT("movsxd") +#define M_MOVUPD FCML_TEXT("movupd") +#define M_MOVUPS FCML_TEXT("movups") +#define M_MOVZX FCML_TEXT("movzx") +#define M_MPSADBW FCML_TEXT("mpsadbw") +#define M_MUL FCML_TEXT("mul") +#define M_MULPD FCML_TEXT("mulpd") +#define M_MULPS FCML_TEXT("mulps") +#define M_MULSD FCML_TEXT("mulsd") +#define M_MULSS FCML_TEXT("mulss") +#define M_MULX FCML_TEXT("mulx") +#define M_MWAIT FCML_TEXT("mwait") +#define M_NEG FCML_TEXT("neg") +#define M_NOP FCML_TEXT("nop") +#define M_NOT FCML_TEXT("not") +#define M_OR FCML_TEXT("or") +#define M_ORPD FCML_TEXT("orpd") +#define M_ORPS FCML_TEXT("orps") +#define M_OUT FCML_TEXT("out") +#define M_OUTS FCML_TEXT("outs") +#define M_OUTSB FCML_TEXT("outsb") +#define M_OUTSD FCML_TEXT("outsd") +#define M_OUTSW FCML_TEXT("outsw") +#define M_PABSB FCML_TEXT("pabsb") +#define M_PABSD FCML_TEXT("pabsd") +#define M_PABSW FCML_TEXT("pabsw") +#define M_PACKSSDW FCML_TEXT("packssdw") +#define M_PACKSSWB FCML_TEXT("packsswb") +#define M_PACKUSDW FCML_TEXT("packusdw") +#define M_PACKUSWB FCML_TEXT("packuswb") +#define M_PADDB FCML_TEXT("paddb") +#define M_PADDD FCML_TEXT("paddd") +#define M_PADDQ FCML_TEXT("paddq") +#define M_PADDSB FCML_TEXT("paddsb") +#define M_PADDSW FCML_TEXT("paddsw") +#define M_PADDUSB FCML_TEXT("paddusb") +#define M_PADDUSW FCML_TEXT("paddusw") +#define M_PADDW FCML_TEXT("paddw") +#define M_PALIGNR FCML_TEXT("palignr") +#define M_PAND FCML_TEXT("pand") +#define M_PANDN FCML_TEXT("pandn") +#define M_PAUSE FCML_TEXT("pause") +#define M_PAVGB FCML_TEXT("pavgb") +#define M_PAVGUSB FCML_TEXT("pavgusb") +#define M_PAVGW FCML_TEXT("pavgw") +#define M_PBLENDVB FCML_TEXT("pblendvb") +#define M_PBLENDW FCML_TEXT("pblendw") +#define M_PCLMULQDQ FCML_TEXT("pclmulqdq") +#define M_PCMPEQB FCML_TEXT("pcmpeqb") +#define M_PCMPEQD FCML_TEXT("pcmpeqd") +#define M_PCMPEQQ FCML_TEXT("pcmpeqq") +#define M_PCMPEQW FCML_TEXT("pcmpeqw") +#define M_PCMPESTRI FCML_TEXT("pcmpestri") +#define M_PCMPESTRM FCML_TEXT("pcmpestrm") +#define M_PCMPGTB FCML_TEXT("pcmpgtb") +#define M_PCMPGTD FCML_TEXT("pcmpgtd") +#define M_PCMPGTQ FCML_TEXT("pcmpgtq") +#define M_PCMPGTW FCML_TEXT("pcmpgtw") +#define M_PCMPISTRI FCML_TEXT("pcmpistri") +#define M_PCMPISTRM FCML_TEXT("pcmpistrm") +#define M_PDEP FCML_TEXT("pdep") +#define M_PEXT FCML_TEXT("pext") +#define M_PEXTRB FCML_TEXT("pextrb") +#define M_PEXTRD FCML_TEXT("pextrd") +#define M_PEXTRQ FCML_TEXT("pextrq") +#define M_PEXTRW FCML_TEXT("pextrw") +#define M_PF2ID FCML_TEXT("pf2id") +#define M_PF2IW FCML_TEXT("pf2iw") +#define M_PFACC FCML_TEXT("pfacc") +#define M_PFADD FCML_TEXT("pfadd") +#define M_PFCMPEQ FCML_TEXT("pfcmpeq") +#define M_PFCMPGE FCML_TEXT("pfcmpge") +#define M_PFCMPGT FCML_TEXT("pfcmpgt") +#define M_PFMAX FCML_TEXT("pfmax") +#define M_PFMIN FCML_TEXT("pfmin") +#define M_PFMUL FCML_TEXT("pfmul") +#define M_PFNACC FCML_TEXT("pfnacc") +#define M_PFPNACC FCML_TEXT("pfpnacc") +#define M_PFRCP FCML_TEXT("pfrcp") +#define M_PFRCPIT1 FCML_TEXT("pfrcpit1") +#define M_PFRCPIT2 FCML_TEXT("pfrcpit2") +#define M_PFRSQIT1 FCML_TEXT("pfrsqit1") +#define M_PFRSQRT FCML_TEXT("pfrsqrt") +#define M_PFSUB FCML_TEXT("pfsub") +#define M_PFSUBR FCML_TEXT("pfsubr") +#define M_PHADDD FCML_TEXT("phaddd") +#define M_PHADDSW FCML_TEXT("phaddsw") +#define M_PHADDW FCML_TEXT("phaddw") +#define M_PHMINPOSUW FCML_TEXT("phminposuw") +#define M_PHSUBD FCML_TEXT("phsubd") +#define M_PHSUBSW FCML_TEXT("phsubsw") +#define M_PHSUBW FCML_TEXT("phsubw") +#define M_PI2FD FCML_TEXT("pi2fd") +#define M_PI2FW FCML_TEXT("pi2fw") +#define M_PINSRB FCML_TEXT("pinsrb") +#define M_PINSRD FCML_TEXT("pinsrd") +#define M_PINSRQ FCML_TEXT("pinsrq") +#define M_PINSRW FCML_TEXT("pinsrw") +#define M_PMADDUBSW FCML_TEXT("pmaddubsw") +#define M_PMADDWD FCML_TEXT("pmaddwd") +#define M_PMAXSB FCML_TEXT("pmaxsb") +#define M_PMAXSD FCML_TEXT("pmaxsd") +#define M_PMAXSW FCML_TEXT("pmaxsw") +#define M_PMAXUB FCML_TEXT("pmaxub") +#define M_PMAXUD FCML_TEXT("pmaxud") +#define M_PMAXUW FCML_TEXT("pmaxuw") +#define M_PMINSB FCML_TEXT("pminsb") +#define M_PMINSD FCML_TEXT("pminsd") +#define M_PMINSW FCML_TEXT("pminsw") +#define M_PMINUB FCML_TEXT("pminub") +#define M_PMINUD FCML_TEXT("pminud") +#define M_PMINUW FCML_TEXT("pminuw") +#define M_PMOVMSKB FCML_TEXT("pmovmskb") +#define M_PMOVSXBD FCML_TEXT("pmovsxbd") +#define M_PMOVSXBQ FCML_TEXT("pmovsxbq") +#define M_PMOVSXBW FCML_TEXT("pmovsxbw") +#define M_PMOVSXDQ FCML_TEXT("pmovsxdq") +#define M_PMOVSXWD FCML_TEXT("pmovsxwd") +#define M_PMOVSXWQ FCML_TEXT("pmovsxwq") +#define M_PMOVZXBD FCML_TEXT("pmovzxbd") +#define M_PMOVZXBQ FCML_TEXT("pmovzxbq") +#define M_PMOVZXBW FCML_TEXT("pmovzxbw") +#define M_PMOVZXDQ FCML_TEXT("pmovzxdq") +#define M_PMOVZXWD FCML_TEXT("pmovzxwd") +#define M_PMOVZXWQ FCML_TEXT("pmovzxwq") +#define M_PMULDQ FCML_TEXT("pmuldq") +#define M_PMULHRSW FCML_TEXT("pmulhrsw") +#define M_PMULHRW FCML_TEXT("pmulhrw") +#define M_PMULHUW FCML_TEXT("pmulhuw") +#define M_PMULHW FCML_TEXT("pmulhw") +#define M_PMULLD FCML_TEXT("pmulld") +#define M_PMULLW FCML_TEXT("pmullw") +#define M_PMULUDQ FCML_TEXT("pmuludq") +#define M_POP FCML_TEXT("pop") +#define M_POPA FCML_TEXT("popa") +#define M_POPAD FCML_TEXT("popad") +#define M_POPCNT FCML_TEXT("popcnt") +#define M_POPF FCML_TEXT("popf") +#define M_POPFD FCML_TEXT("popfd") +#define M_POPFQ FCML_TEXT("popfq") +#define M_POR FCML_TEXT("por") +#define M_PREFETCH FCML_TEXT("prefetch") +#define M_PREFETCHNTA FCML_TEXT("prefetchnta") +#define M_PREFETCHT0 FCML_TEXT("prefetcht0") +#define M_PREFETCHT1 FCML_TEXT("prefetcht1") +#define M_PREFETCHT2 FCML_TEXT("prefetcht2") +#define M_PREFETCHW FCML_TEXT("prefetchw") +#define M_PREFETCHWT1 FCML_TEXT("prefetchwt1") +#define M_PSADBW FCML_TEXT("psadbw") +#define M_PSHUFB FCML_TEXT("pshufb") +#define M_PSHUFD FCML_TEXT("pshufd") +#define M_PSHUFHW FCML_TEXT("pshufhw") +#define M_PSHUFLW FCML_TEXT("pshuflw") +#define M_PSHUFW FCML_TEXT("pshufw") +#define M_PSIGNB FCML_TEXT("psignb") +#define M_PSIGND FCML_TEXT("psignd") +#define M_PSIGNW FCML_TEXT("psignw") +#define M_PSLLD FCML_TEXT("pslld") +#define M_PSLLDQ FCML_TEXT("pslldq") +#define M_PSLLQ FCML_TEXT("psllq") +#define M_PSLLW FCML_TEXT("psllw") +#define M_PSRAD FCML_TEXT("psrad") +#define M_PSRAW FCML_TEXT("psraw") +#define M_PSRLD FCML_TEXT("psrld") +#define M_PSRLDQ FCML_TEXT("psrldq") +#define M_PSRLQ FCML_TEXT("psrlq") +#define M_PSRLW FCML_TEXT("psrlw") +#define M_PSUBB FCML_TEXT("psubb") +#define M_PSUBD FCML_TEXT("psubd") +#define M_PSUBQ FCML_TEXT("psubq") +#define M_PSUBSB FCML_TEXT("psubsb") +#define M_PSUBSW FCML_TEXT("psubsw") +#define M_PSUBUSB FCML_TEXT("psubusb") +#define M_PSUBUSW FCML_TEXT("psubusw") +#define M_PSUBW FCML_TEXT("psubw") +#define M_PSWAPD FCML_TEXT("pswapd") +#define M_PTEST FCML_TEXT("ptest") +#define M_PUNPCKHBW FCML_TEXT("punpckhbw") +#define M_PUNPCKHDQ FCML_TEXT("punpckhdq") +#define M_PUNPCKHQDQ FCML_TEXT("punpckhqdq") +#define M_PUNPCKHWD FCML_TEXT("punpckhwd") +#define M_PUNPCKLBW FCML_TEXT("punpcklbw") +#define M_PUNPCKLDQ FCML_TEXT("punpckldq") +#define M_PUNPCKLQDQ FCML_TEXT("punpcklqdq") +#define M_PUNPCKLWD FCML_TEXT("punpcklwd") +#define M_PUSH FCML_TEXT("push") +#define M_PUSHA FCML_TEXT("pusha") +#define M_PUSHAD FCML_TEXT("pushad") +#define M_PUSHF FCML_TEXT("pushf") +#define M_PUSHFD FCML_TEXT("pushfd") +#define M_PUSHFQ FCML_TEXT("pushfq") +#define M_PXOR FCML_TEXT("pxor") +#define M_RCL FCML_TEXT("rcl") +#define M_RCPPS FCML_TEXT("rcpps") +#define M_RCPSS FCML_TEXT("rcpss") +#define M_RCR FCML_TEXT("rcr") +#define M_RDFSBASE FCML_TEXT("rdfsbase") +#define M_RDGSBASE FCML_TEXT("rdgsbase") +#define M_RDMSR FCML_TEXT("rdmsr") +#define M_RDPMC FCML_TEXT("rdpmc") +#define M_RDRAND FCML_TEXT("rdrand") +#define M_RDSEED FCML_TEXT("rdseed") +#define M_RDTSC FCML_TEXT("rdtsc") +#define M_RDTSCP FCML_TEXT("rdtscp") +#define M_RET FCML_TEXT("ret") +#define M_RETF FCML_TEXT("retf") +#define M_ROL FCML_TEXT("rol") +#define M_ROR FCML_TEXT("ror") +#define M_RORX FCML_TEXT("rorx") +#define M_ROUNDPD FCML_TEXT("roundpd") +#define M_ROUNDPS FCML_TEXT("roundps") +#define M_ROUNDSD FCML_TEXT("roundsd") +#define M_ROUNDSS FCML_TEXT("roundss") +#define M_RSM FCML_TEXT("rsm") +#define M_RSQRTPS FCML_TEXT("rsqrtps") +#define M_RSQRTSS FCML_TEXT("rsqrtss") +#define M_SAHF FCML_TEXT("sahf") +#define M_SAL FCML_TEXT("sal") +#define M_SAR FCML_TEXT("sar") +#define M_SARX FCML_TEXT("sarx") +#define M_SBB FCML_TEXT("sbb") +#define M_SCAS FCML_TEXT("scas") +#define M_SCASB FCML_TEXT("scasb") +#define M_SCASD FCML_TEXT("scasd") +#define M_SCASQ FCML_TEXT("scasq") +#define M_SCASW FCML_TEXT("scasw") +#define M_SETA FCML_TEXT("seta") +#define M_SETAE FCML_TEXT("setae") +#define M_SETB FCML_TEXT("setb") +#define M_SETBE FCML_TEXT("setbe") +#define M_SETC FCML_TEXT("setc") +#define M_SETENE FCML_TEXT("setene") +#define M_SETG FCML_TEXT("setg") +#define M_SETGE FCML_TEXT("setge") +#define M_SETL FCML_TEXT("setl") +#define M_SETLE FCML_TEXT("setle") +#define M_SETNA FCML_TEXT("setna") +#define M_SETNAE FCML_TEXT("setnae") +#define M_SETNB FCML_TEXT("setnb") +#define M_SETNBE FCML_TEXT("setnbe") +#define M_SETNC FCML_TEXT("setnc") +#define M_SETNG FCML_TEXT("setng") +#define M_SETNGE FCML_TEXT("setnge") +#define M_SETNL FCML_TEXT("setnl") +#define M_SETNLE FCML_TEXT("setnle") +#define M_SETNO FCML_TEXT("setno") +#define M_SETNP FCML_TEXT("setnp") +#define M_SETNS FCML_TEXT("setns") +#define M_SETNZ FCML_TEXT("setnz") +#define M_SETO FCML_TEXT("seto") +#define M_SETP FCML_TEXT("setp") +#define M_SETPE FCML_TEXT("setpe") +#define M_SETPO FCML_TEXT("setpo") +#define M_SETS FCML_TEXT("sets") +#define M_SETZ FCML_TEXT("setz") +#define M_SFENCE FCML_TEXT("sfence") +#define M_SGDT FCML_TEXT("sgdt") +#define M_SHL FCML_TEXT("shl") +#define M_SHLD FCML_TEXT("shld") +#define M_SHLX FCML_TEXT("shlx") +#define M_SHR FCML_TEXT("shr") +#define M_SHRD FCML_TEXT("shrd") +#define M_SHRX FCML_TEXT("shrx") +#define M_SHUFPD FCML_TEXT("shufpd") +#define M_SHUFPS FCML_TEXT("shufps") +#define M_SIDT FCML_TEXT("sidt") +#define M_SKINIT FCML_TEXT("skinit") +#define M_SLDT FCML_TEXT("sldt") +#define M_SLWPCB FCML_TEXT("slwpcb") +#define M_SMSW FCML_TEXT("smsw") +#define M_SQRTPD FCML_TEXT("sqrtpd") +#define M_SQRTPS FCML_TEXT("sqrtps") +#define M_SQRTSD FCML_TEXT("sqrtsd") +#define M_SQRTSS FCML_TEXT("sqrtss") +#define M_STAC FCML_TEXT("stac") +#define M_STC FCML_TEXT("stc") +#define M_STD FCML_TEXT("std") +#define M_STGI FCML_TEXT("stgi") +#define M_STI FCML_TEXT("sti") +#define M_STMXCSR FCML_TEXT("stmxcsr") +#define M_STOS FCML_TEXT("stos") +#define M_STOSB FCML_TEXT("stosb") +#define M_STOSD FCML_TEXT("stosd") +#define M_STOSQ FCML_TEXT("stosq") +#define M_STOSW FCML_TEXT("stosw") +#define M_STR FCML_TEXT("str") +#define M_SUB FCML_TEXT("sub") +#define M_SUBPD FCML_TEXT("subpd") +#define M_SUBPS FCML_TEXT("subps") +#define M_SUBSD FCML_TEXT("subsd") +#define M_SUBSS FCML_TEXT("subss") +#define M_SWAPGS FCML_TEXT("swapgs") +#define M_SYSCALL FCML_TEXT("syscall") +#define M_SYSENTER FCML_TEXT("sysenter") +#define M_SYSEXIT FCML_TEXT("sysexit") +#define M_SYSRET FCML_TEXT("sysret") +#define M_T1MSKC FCML_TEXT("t1mskc") +#define M_TEST FCML_TEXT("test") +#define M_TZCNT FCML_TEXT("tzcnt") +#define M_TZMSK FCML_TEXT("tzmsk") +#define M_UCOMISD FCML_TEXT("ucomisd") +#define M_UCOMISS FCML_TEXT("ucomiss") +#define M_UD2 FCML_TEXT("ud2") +#define M_UNPCKHPD FCML_TEXT("unpckhpd") +#define M_UNPCKHPS FCML_TEXT("unpckhps") +#define M_UNPCKLPD FCML_TEXT("unpcklpd") +#define M_UNPCKLPS FCML_TEXT("unpcklps") +#define M_V4FMADDPS FCML_TEXT("v4fmaddps") +#define M_V4FMADDSS FCML_TEXT("v4fmaddss") +#define M_V4FNMADDPS FCML_TEXT("v4fnmaddps") +#define M_V4FNMADDSS FCML_TEXT("v4fnmaddss") +#define M_VADDPD FCML_TEXT("vaddpd") +#define M_VADDPS FCML_TEXT("vaddps") +#define M_VADDSD FCML_TEXT("vaddsd") +#define M_VADDSS FCML_TEXT("vaddss") +#define M_VADDSUBPD FCML_TEXT("vaddsubpd") +#define M_VADDSUBPS FCML_TEXT("vaddsubps") +#define M_VAESDEC FCML_TEXT("vaesdec") +#define M_VAESDECLAST FCML_TEXT("vaesdeclast") +#define M_VAESENC FCML_TEXT("vaesenc") +#define M_VAESENCLAST FCML_TEXT("vaesenclast") +#define M_VAESIMC FCML_TEXT("vaesimc") +#define M_VAESKEYGENASSIST FCML_TEXT("vaeskeygenassist") +#define M_VALIGND FCML_TEXT("valignd") +#define M_VALIGNQ FCML_TEXT("valignq") +#define M_VANDNPD FCML_TEXT("vandnpd") +#define M_VANDNPS FCML_TEXT("vandnps") +#define M_VANDPD FCML_TEXT("vandpd") +#define M_VANDPS FCML_TEXT("vandps") +#define M_VBLENDMPD FCML_TEXT("vblendmpd") +#define M_VBLENDMPS FCML_TEXT("vblendmps") +#define M_VBLENDPD FCML_TEXT("vblendpd") +#define M_VBLENDPS FCML_TEXT("vblendps") +#define M_VBLENDVPD FCML_TEXT("vblendvpd") +#define M_VBLENDVPS FCML_TEXT("vblendvps") +#define M_VBROADCASTF128 FCML_TEXT("vbroadcastf128") +#define M_VBROADCASTF32X2 FCML_TEXT("vbroadcastf32x2") +#define M_VBROADCASTF32X4 FCML_TEXT("vbroadcastf32x4") +#define M_VBROADCASTF32X8 FCML_TEXT("vbroadcastf32x8") +#define M_VBROADCASTF64X2 FCML_TEXT("vbroadcastf64x2") +#define M_VBROADCASTF64X4 FCML_TEXT("vbroadcastf64x4") +#define M_VBROADCASTI128 FCML_TEXT("vbroadcasti128") +#define M_VBROADCASTI32X2 FCML_TEXT("vbroadcasti32x2") +#define M_VBROADCASTI32X4 FCML_TEXT("vbroadcasti32x4") +#define M_VBROADCASTI32X8 FCML_TEXT("vbroadcasti32x8") +#define M_VBROADCASTI64X2 FCML_TEXT("vbroadcasti64x2") +#define M_VBROADCASTI64X4 FCML_TEXT("vbroadcasti64x4") +#define M_VBROADCASTSD FCML_TEXT("vbroadcastsd") +#define M_VBROADCASTSS FCML_TEXT("vbroadcastss") +#define M_VCMPEQ_OSPD FCML_TEXT("vcmpeq_ospd") +#define M_VCMPEQ_OSPS FCML_TEXT("vcmpeq_osps") +#define M_VCMPEQ_OSSD FCML_TEXT("vcmpeq_ossd") +#define M_VCMPEQ_OSSS FCML_TEXT("vcmpeq_osss") +#define M_VCMPEQ_UQPD FCML_TEXT("vcmpeq_uqpd") +#define M_VCMPEQ_UQPS FCML_TEXT("vcmpeq_uqps") +#define M_VCMPEQ_UQSD FCML_TEXT("vcmpeq_uqsd") +#define M_VCMPEQ_UQSS FCML_TEXT("vcmpeq_uqss") +#define M_VCMPEQ_USPD FCML_TEXT("vcmpeq_uspd") +#define M_VCMPEQ_USPS FCML_TEXT("vcmpeq_usps") +#define M_VCMPEQ_USSD FCML_TEXT("vcmpeq_ussd") +#define M_VCMPEQ_USSS FCML_TEXT("vcmpeq_usss") +#define M_VCMPEQPD FCML_TEXT("vcmpeqpd") +#define M_VCMPEQPS FCML_TEXT("vcmpeqps") +#define M_VCMPEQSD FCML_TEXT("vcmpeqsd") +#define M_VCMPEQSS FCML_TEXT("vcmpeqss") +#define M_VCMPFALSE_OSPD FCML_TEXT("vcmpfalse_ospd") +#define M_VCMPFALSE_OSPS FCML_TEXT("vcmpfalse_osps") +#define M_VCMPFALSE_OSSD FCML_TEXT("vcmpfalse_ossd") +#define M_VCMPFALSE_OSSS FCML_TEXT("vcmpfalse_osss") +#define M_VCMPFALSEPD FCML_TEXT("vcmpfalsepd") +#define M_VCMPFALSEPS FCML_TEXT("vcmpfalseps") +#define M_VCMPFALSESD FCML_TEXT("vcmpfalsesd") +#define M_VCMPFALSESS FCML_TEXT("vcmpfalsess") +#define M_VCMPGE_OQPD FCML_TEXT("vcmpge_oqpd") +#define M_VCMPGE_OQPS FCML_TEXT("vcmpge_oqps") +#define M_VCMPGE_OQSD FCML_TEXT("vcmpge_oqsd") +#define M_VCMPGE_OQSS FCML_TEXT("vcmpge_oqss") +#define M_VCMPGEPD FCML_TEXT("vcmpgepd") +#define M_VCMPGEPS FCML_TEXT("vcmpgeps") +#define M_VCMPGESD FCML_TEXT("vcmpgesd") +#define M_VCMPGESS FCML_TEXT("vcmpgess") +#define M_VCMPGT_OQPD FCML_TEXT("vcmpgt_oqpd") +#define M_VCMPGT_OQPS FCML_TEXT("vcmpgt_oqps") +#define M_VCMPGT_OQSD FCML_TEXT("vcmpgt_oqsd") +#define M_VCMPGT_OQSS FCML_TEXT("vcmpgt_oqss") +#define M_VCMPGTPD FCML_TEXT("vcmpgtpd") +#define M_VCMPGTPS FCML_TEXT("vcmpgtps") +#define M_VCMPGTSD FCML_TEXT("vcmpgtsd") +#define M_VCMPGTSS FCML_TEXT("vcmpgtss") +#define M_VCMPLE_OQPD FCML_TEXT("vcmple_oqpd") +#define M_VCMPLE_OQPS FCML_TEXT("vcmple_oqps") +#define M_VCMPLE_OQSD FCML_TEXT("vcmple_oqsd") +#define M_VCMPLE_OQSS FCML_TEXT("vcmple_oqss") +#define M_VCMPLEPD FCML_TEXT("vcmplepd") +#define M_VCMPLEPS FCML_TEXT("vcmpleps") +#define M_VCMPLESD FCML_TEXT("vcmplesd") +#define M_VCMPLESS FCML_TEXT("vcmpless") +#define M_VCMPLT_OQPD FCML_TEXT("vcmplt_oqpd") +#define M_VCMPLT_OQPS FCML_TEXT("vcmplt_oqps") +#define M_VCMPLT_OQSD FCML_TEXT("vcmplt_oqsd") +#define M_VCMPLT_OQSS FCML_TEXT("vcmplt_oqss") +#define M_VCMPLTPD FCML_TEXT("vcmpltpd") +#define M_VCMPLTPS FCML_TEXT("vcmpltps") +#define M_VCMPLTSD FCML_TEXT("vcmpltsd") +#define M_VCMPLTSS FCML_TEXT("vcmpltss") +#define M_VCMPNEQ_OQPD FCML_TEXT("vcmpneq_oqpd") +#define M_VCMPNEQ_OQPS FCML_TEXT("vcmpneq_oqps") +#define M_VCMPNEQ_OQSD FCML_TEXT("vcmpneq_oqsd") +#define M_VCMPNEQ_OQSS FCML_TEXT("vcmpneq_oqss") +#define M_VCMPNEQ_OSPD FCML_TEXT("vcmpneq_ospd") +#define M_VCMPNEQ_OSPS FCML_TEXT("vcmpneq_osps") +#define M_VCMPNEQ_OSSD FCML_TEXT("vcmpneq_ossd") +#define M_VCMPNEQ_OSSS FCML_TEXT("vcmpneq_osss") +#define M_VCMPNEQ_USPD FCML_TEXT("vcmpneq_uspd") +#define M_VCMPNEQ_USPS FCML_TEXT("vcmpneq_usps") +#define M_VCMPNEQ_USSD FCML_TEXT("vcmpneq_ussd") +#define M_VCMPNEQ_USSS FCML_TEXT("vcmpneq_usss") +#define M_VCMPNEQPD FCML_TEXT("vcmpneqpd") +#define M_VCMPNEQPS FCML_TEXT("vcmpneqps") +#define M_VCMPNEQSD FCML_TEXT("vcmpneqsd") +#define M_VCMPNEQSS FCML_TEXT("vcmpneqss") +#define M_VCMPNGE_UQPD FCML_TEXT("vcmpnge_uqpd") +#define M_VCMPNGE_UQPS FCML_TEXT("vcmpnge_uqps") +#define M_VCMPNGE_UQSD FCML_TEXT("vcmpnge_uqsd") +#define M_VCMPNGE_UQSS FCML_TEXT("vcmpnge_uqss") +#define M_VCMPNGEPD FCML_TEXT("vcmpngepd") +#define M_VCMPNGEPS FCML_TEXT("vcmpngeps") +#define M_VCMPNGESD FCML_TEXT("vcmpngesd") +#define M_VCMPNGESS FCML_TEXT("vcmpngess") +#define M_VCMPNGT_UQPD FCML_TEXT("vcmpngt_uqpd") +#define M_VCMPNGT_UQPS FCML_TEXT("vcmpngt_uqps") +#define M_VCMPNGT_UQSD FCML_TEXT("vcmpngt_uqsd") +#define M_VCMPNGT_UQSS FCML_TEXT("vcmpngt_uqss") +#define M_VCMPNGTPD FCML_TEXT("vcmpngtpd") +#define M_VCMPNGTPS FCML_TEXT("vcmpngtps") +#define M_VCMPNGTSD FCML_TEXT("vcmpngtsd") +#define M_VCMPNGTSS FCML_TEXT("vcmpngtss") +#define M_VCMPNLE_UQPD FCML_TEXT("vcmpnle_uqpd") +#define M_VCMPNLE_UQPS FCML_TEXT("vcmpnle_uqps") +#define M_VCMPNLE_UQSD FCML_TEXT("vcmpnle_uqsd") +#define M_VCMPNLE_UQSS FCML_TEXT("vcmpnle_uqss") +#define M_VCMPNLEPD FCML_TEXT("vcmpnlepd") +#define M_VCMPNLEPS FCML_TEXT("vcmpnleps") +#define M_VCMPNLESD FCML_TEXT("vcmpnlesd") +#define M_VCMPNLESS FCML_TEXT("vcmpnless") +#define M_VCMPNLT_UQPD FCML_TEXT("vcmpnlt_uqpd") +#define M_VCMPNLT_UQPS FCML_TEXT("vcmpnlt_uqps") +#define M_VCMPNLT_UQSD FCML_TEXT("vcmpnlt_uqsd") +#define M_VCMPNLT_UQSS FCML_TEXT("vcmpnlt_uqss") +#define M_VCMPNLTPD FCML_TEXT("vcmpnltpd") +#define M_VCMPNLTPS FCML_TEXT("vcmpnltps") +#define M_VCMPNLTSD FCML_TEXT("vcmpnltsd") +#define M_VCMPNLTSS FCML_TEXT("vcmpnltss") +#define M_VCMPORD_SPD FCML_TEXT("vcmpord_spd") +#define M_VCMPORD_SPS FCML_TEXT("vcmpord_sps") +#define M_VCMPORD_SSD FCML_TEXT("vcmpord_ssd") +#define M_VCMPORD_SSS FCML_TEXT("vcmpord_sss") +#define M_VCMPORDPD FCML_TEXT("vcmpordpd") +#define M_VCMPORDPS FCML_TEXT("vcmpordps") +#define M_VCMPORDSD FCML_TEXT("vcmpordsd") +#define M_VCMPORDSS FCML_TEXT("vcmpordss") +#define M_VCMPPD FCML_TEXT("vcmppd") +#define M_VCMPPS FCML_TEXT("vcmpps") +#define M_VCMPSD FCML_TEXT("vcmpsd") +#define M_VCMPSS FCML_TEXT("vcmpss") +#define M_VCMPTRUE_USPD FCML_TEXT("vcmptrue_uspd") +#define M_VCMPTRUE_USPS FCML_TEXT("vcmptrue_usps") +#define M_VCMPTRUE_USSD FCML_TEXT("vcmptrue_ussd") +#define M_VCMPTRUE_USSS FCML_TEXT("vcmptrue_usss") +#define M_VCMPTRUEPD FCML_TEXT("vcmptruepd") +#define M_VCMPTRUEPS FCML_TEXT("vcmptrueps") +#define M_VCMPTRUESD FCML_TEXT("vcmptruesd") +#define M_VCMPTRUESS FCML_TEXT("vcmptruess") +#define M_VCMPUNORD_SPD FCML_TEXT("vcmpunord_spd") +#define M_VCMPUNORD_SPS FCML_TEXT("vcmpunord_sps") +#define M_VCMPUNORD_SSD FCML_TEXT("vcmpunord_ssd") +#define M_VCMPUNORD_SSS FCML_TEXT("vcmpunord_sss") +#define M_VCMPUNORDPD FCML_TEXT("vcmpunordpd") +#define M_VCMPUNORDPS FCML_TEXT("vcmpunordps") +#define M_VCMPUNORDSD FCML_TEXT("vcmpunordsd") +#define M_VCMPUNORDSS FCML_TEXT("vcmpunordss") +#define M_VCOMISD FCML_TEXT("vcomisd") +#define M_VCOMISS FCML_TEXT("vcomiss") +#define M_VCOMPRESSPD FCML_TEXT("vcompresspd") +#define M_VCOMPRESSPS FCML_TEXT("vcompressps") +#define M_VCVTDQ2PD FCML_TEXT("vcvtdq2pd") +#define M_VCVTDQ2PS FCML_TEXT("vcvtdq2ps") +#define M_VCVTPD2DQ FCML_TEXT("vcvtpd2dq") +#define M_VCVTPD2PS FCML_TEXT("vcvtpd2ps") +#define M_VCVTPD2QQ FCML_TEXT("vcvtpd2qq") +#define M_VCVTPD2UDQ FCML_TEXT("vcvtpd2udq") +#define M_VCVTPD2UQQ FCML_TEXT("vcvtpd2uqq") +#define M_VCVTPH2PS FCML_TEXT("vcvtph2ps") +#define M_VCVTPS2DQ FCML_TEXT("vcvtps2dq") +#define M_VCVTPS2PD FCML_TEXT("vcvtps2pd") +#define M_VCVTPS2PH FCML_TEXT("vcvtps2ph") +#define M_VCVTPS2QQ FCML_TEXT("vcvtps2qq") +#define M_VCVTPS2UDQ FCML_TEXT("vcvtps2udq") +#define M_VCVTPS2UQQ FCML_TEXT("vcvtps2uqq") +#define M_VCVTQQ2PD FCML_TEXT("vcvtqq2pd") +#define M_VCVTQQ2PS FCML_TEXT("vcvtqq2ps") +#define M_VCVTSD2SI FCML_TEXT("vcvtsd2si") +#define M_VCVTSD2SS FCML_TEXT("vcvtsd2ss") +#define M_VCVTSD2USI FCML_TEXT("vcvtsd2usi") +#define M_VCVTSI2SD FCML_TEXT("vcvtsi2sd") +#define M_VCVTSI2SS FCML_TEXT("vcvtsi2ss") +#define M_VCVTSS2SD FCML_TEXT("vcvtss2sd") +#define M_VCVTSS2SI FCML_TEXT("vcvtss2si") +#define M_VCVTSS2USI FCML_TEXT("vcvtss2usi") +#define M_VCVTTPD2DQ FCML_TEXT("vcvttpd2dq") +#define M_VCVTTPD2QQ FCML_TEXT("vcvttpd2qq") +#define M_VCVTTPD2UDQ FCML_TEXT("vcvttpd2udq") +#define M_VCVTTPD2UQQ FCML_TEXT("vcvttpd2uqq") +#define M_VCVTTPS2DQ FCML_TEXT("vcvttps2dq") +#define M_VCVTTPS2QQ FCML_TEXT("vcvttps2qq") +#define M_VCVTTPS2UDQ FCML_TEXT("vcvttps2udq") +#define M_VCVTTPS2UQQ FCML_TEXT("vcvttps2uqq") +#define M_VCVTTSD2SI FCML_TEXT("vcvttsd2si") +#define M_VCVTTSD2USI FCML_TEXT("vcvttsd2usi") +#define M_VCVTTSS2SI FCML_TEXT("vcvttss2si") +#define M_VCVTTSS2USI FCML_TEXT("vcvttss2usi") +#define M_VCVTUDQ2PD FCML_TEXT("vcvtudq2pd") +#define M_VCVTUDQ2PS FCML_TEXT("vcvtudq2ps") +#define M_VCVTUQQ2PD FCML_TEXT("vcvtuqq2pd") +#define M_VCVTUQQ2PS FCML_TEXT("vcvtuqq2ps") +#define M_VCVTUSI2SD FCML_TEXT("vcvtusi2sd") +#define M_VCVTUSI2SS FCML_TEXT("vcvtusi2ss") +#define M_VDBPSADBW FCML_TEXT("vdbpsadbw") +#define M_VDIVPD FCML_TEXT("vdivpd") +#define M_VDIVPS FCML_TEXT("vdivps") +#define M_VDIVSD FCML_TEXT("vdivsd") +#define M_VDIVSS FCML_TEXT("vdivss") +#define M_VDPPD FCML_TEXT("vdppd") +#define M_VDPPS FCML_TEXT("vdpps") +#define M_VERR FCML_TEXT("verr") +#define M_VERW FCML_TEXT("verw") +#define M_VEXP2PD FCML_TEXT("vexp2pd") +#define M_VEXP2PS FCML_TEXT("vexp2ps") +#define M_VEXPANDPD FCML_TEXT("vexpandpd") +#define M_VEXPANDPS FCML_TEXT("vexpandps") +#define M_VEXTRACTF128 FCML_TEXT("vextractf128") +#define M_VEXTRACTF32X4 FCML_TEXT("vextractf32x4") +#define M_VEXTRACTF32X8 FCML_TEXT("vextractf32x8") +#define M_VEXTRACTF64X2 FCML_TEXT("vextractf64x2") +#define M_VEXTRACTF64X4 FCML_TEXT("vextractf64x4") +#define M_VEXTRACTI128 FCML_TEXT("vextracti128") +#define M_VEXTRACTI32X4 FCML_TEXT("vextracti32x4") +#define M_VEXTRACTI32X8 FCML_TEXT("vextracti32x8") +#define M_VEXTRACTI64X2 FCML_TEXT("vextracti64x2") +#define M_VEXTRACTI64X4 FCML_TEXT("vextracti64x4") +#define M_VEXTRACTPS FCML_TEXT("vextractps") +#define M_VFIXUPIMMPD FCML_TEXT("vfixupimmpd") +#define M_VFIXUPIMMPS FCML_TEXT("vfixupimmps") +#define M_VFIXUPIMMSD FCML_TEXT("vfixupimmsd") +#define M_VFIXUPIMMSS FCML_TEXT("vfixupimmss") +#define M_VFMADD132PD FCML_TEXT("vfmadd132pd") +#define M_VFMADD132PS FCML_TEXT("vfmadd132ps") +#define M_VFMADD132SD FCML_TEXT("vfmadd132sd") +#define M_VFMADD132SS FCML_TEXT("vfmadd132ss") +#define M_VFMADD213PD FCML_TEXT("vfmadd213pd") +#define M_VFMADD213PS FCML_TEXT("vfmadd213ps") +#define M_VFMADD213SD FCML_TEXT("vfmadd213sd") +#define M_VFMADD213SS FCML_TEXT("vfmadd213ss") +#define M_VFMADD231PD FCML_TEXT("vfmadd231pd") +#define M_VFMADD231PS FCML_TEXT("vfmadd231ps") +#define M_VFMADD231SD FCML_TEXT("vfmadd231sd") +#define M_VFMADD231SS FCML_TEXT("vfmadd231ss") +#define M_VFMADDPD FCML_TEXT("vfmaddpd") +#define M_VFMADDPS FCML_TEXT("vfmaddps") +#define M_VFMADDSD FCML_TEXT("vfmaddsd") +#define M_VFMADDSS FCML_TEXT("vfmaddss") +#define M_VFMADDSUB132PD FCML_TEXT("vfmaddsub132pd") +#define M_VFMADDSUB132PS FCML_TEXT("vfmaddsub132ps") +#define M_VFMADDSUB213PD FCML_TEXT("vfmaddsub213pd") +#define M_VFMADDSUB213PS FCML_TEXT("vfmaddsub213ps") +#define M_VFMADDSUB231PD FCML_TEXT("vfmaddsub231pd") +#define M_VFMADDSUB231PS FCML_TEXT("vfmaddsub231ps") +#define M_VFMADDSUBPD FCML_TEXT("vfmaddsubpd") +#define M_VFMADDSUBPS FCML_TEXT("vfmaddsubps") +#define M_VFMSUB132PD FCML_TEXT("vfmsub132pd") +#define M_VFMSUB132PS FCML_TEXT("vfmsub132ps") +#define M_VFMSUB132SD FCML_TEXT("vfmsub132sd") +#define M_VFMSUB132SS FCML_TEXT("vfmsub132ss") +#define M_VFMSUB213PD FCML_TEXT("vfmsub213pd") +#define M_VFMSUB213PS FCML_TEXT("vfmsub213ps") +#define M_VFMSUB213SD FCML_TEXT("vfmsub213sd") +#define M_VFMSUB213SS FCML_TEXT("vfmsub213ss") +#define M_VFMSUB231PD FCML_TEXT("vfmsub231pd") +#define M_VFMSUB231PS FCML_TEXT("vfmsub231ps") +#define M_VFMSUB231SD FCML_TEXT("vfmsub231sd") +#define M_VFMSUB231SS FCML_TEXT("vfmsub231ss") +#define M_VFMSUBADD132PD FCML_TEXT("vfmsubadd132pd") +#define M_VFMSUBADD132PS FCML_TEXT("vfmsubadd132ps") +#define M_VFMSUBADD213PD FCML_TEXT("vfmsubadd213pd") +#define M_VFMSUBADD213PS FCML_TEXT("vfmsubadd213ps") +#define M_VFMSUBADD231PD FCML_TEXT("vfmsubadd231pd") +#define M_VFMSUBADD231PS FCML_TEXT("vfmsubadd231ps") +#define M_VFMSUBADDPD FCML_TEXT("vfmsubaddpd") +#define M_VFMSUBADDPS FCML_TEXT("vfmsubaddps") +#define M_VFMSUBPD FCML_TEXT("vfmsubpd") +#define M_VFMSUBPS FCML_TEXT("vfmsubps") +#define M_VFMSUBSD FCML_TEXT("vfmsubsd") +#define M_VFMSUBSS FCML_TEXT("vfmsubss") +#define M_VFNMADD132PD FCML_TEXT("vfnmadd132pd") +#define M_VFNMADD132PS FCML_TEXT("vfnmadd132ps") +#define M_VFNMADD132SD FCML_TEXT("vfnmadd132sd") +#define M_VFNMADD132SS FCML_TEXT("vfnmadd132ss") +#define M_VFNMADD213PD FCML_TEXT("vfnmadd213pd") +#define M_VFNMADD213PS FCML_TEXT("vfnmadd213ps") +#define M_VFNMADD213SD FCML_TEXT("vfnmadd213sd") +#define M_VFNMADD213SS FCML_TEXT("vfnmadd213ss") +#define M_VFNMADD231PD FCML_TEXT("vfnmadd231pd") +#define M_VFNMADD231PS FCML_TEXT("vfnmadd231ps") +#define M_VFNMADD231SD FCML_TEXT("vfnmadd231sd") +#define M_VFNMADD231SS FCML_TEXT("vfnmadd231ss") +#define M_VFNMADDPD FCML_TEXT("vfnmaddpd") +#define M_VFNMADDPS FCML_TEXT("vfnmaddps") +#define M_VFNMADDSD FCML_TEXT("vfnmaddsd") +#define M_VFNMADDSS FCML_TEXT("vfnmaddss") +#define M_VFNMSUB132PD FCML_TEXT("vfnmsub132pd") +#define M_VFNMSUB132PS FCML_TEXT("vfnmsub132ps") +#define M_VFNMSUB132SD FCML_TEXT("vfnmsub132sd") +#define M_VFNMSUB132SS FCML_TEXT("vfnmsub132ss") +#define M_VFNMSUB213PD FCML_TEXT("vfnmsub213pd") +#define M_VFNMSUB213PS FCML_TEXT("vfnmsub213ps") +#define M_VFNMSUB213SD FCML_TEXT("vfnmsub213sd") +#define M_VFNMSUB213SS FCML_TEXT("vfnmsub213ss") +#define M_VFNMSUB231PD FCML_TEXT("vfnmsub231pd") +#define M_VFNMSUB231PS FCML_TEXT("vfnmsub231ps") +#define M_VFNMSUB231SD FCML_TEXT("vfnmsub231sd") +#define M_VFNMSUB231SS FCML_TEXT("vfnmsub231ss") +#define M_VFNMSUBPD FCML_TEXT("vfnmsubpd") +#define M_VFNMSUBPS FCML_TEXT("vfnmsubps") +#define M_VFNMSUBSD FCML_TEXT("vfnmsubsd") +#define M_VFNMSUBSS FCML_TEXT("vfnmsubss") +#define M_VFPCLASSPD FCML_TEXT("vfpclasspd") +#define M_VFPCLASSPS FCML_TEXT("vfpclassps") +#define M_VFPCLASSSD FCML_TEXT("vfpclasssd") +#define M_VFPCLASSSS FCML_TEXT("vfpclassss") +#define M_VFRCZPD FCML_TEXT("vfrczpd") +#define M_VFRCZPS FCML_TEXT("vfrczps") +#define M_VFRCZSD FCML_TEXT("vfrczsd") +#define M_VFRCZSS FCML_TEXT("vfrczss") +#define M_VGATHERDPD FCML_TEXT("vgatherdpd") +#define M_VGATHERDPS FCML_TEXT("vgatherdps") +#define M_VGATHERPF0DPD FCML_TEXT("vgatherpf0dpd") +#define M_VGATHERPF0DPS FCML_TEXT("vgatherpf0dps") +#define M_VGATHERPF0QPD FCML_TEXT("vgatherpf0qpd") +#define M_VGATHERPF0QPS FCML_TEXT("vgatherpf0qps") +#define M_VGATHERPF1DPD FCML_TEXT("vgatherpf1dpd") +#define M_VGATHERPF1DPS FCML_TEXT("vgatherpf1dps") +#define M_VGATHERPF1QPD FCML_TEXT("vgatherpf1qpd") +#define M_VGATHERPF1QPS FCML_TEXT("vgatherpf1qps") +#define M_VGATHERQPD FCML_TEXT("vgatherqpd") +#define M_VGATHERQPS FCML_TEXT("vgatherqps") +#define M_VGETEXPPD FCML_TEXT("vgetexppd") +#define M_VGETEXPPS FCML_TEXT("vgetexpps") +#define M_VGETEXPSD FCML_TEXT("vgetexpsd") +#define M_VGETEXPSS FCML_TEXT("vgetexpss") +#define M_VGETMANTPD FCML_TEXT("vgetmantpd") +#define M_VGETMANTPS FCML_TEXT("vgetmantps") +#define M_VGETMANTSD FCML_TEXT("vgetmantsd") +#define M_VGETMANTSS FCML_TEXT("vgetmantss") +#define M_VHADDPD FCML_TEXT("vhaddpd") +#define M_VHADDPS FCML_TEXT("vhaddps") +#define M_VHSUBPD FCML_TEXT("vhsubpd") +#define M_VHSUBPS FCML_TEXT("vhsubps") +#define M_VINSERTF128 FCML_TEXT("vinsertf128") +#define M_VINSERTF32X4 FCML_TEXT("vinsertf32x4") +#define M_VINSERTF32X8 FCML_TEXT("vinsertf32x8") +#define M_VINSERTF64X2 FCML_TEXT("vinsertf64x2") +#define M_VINSERTF64X4 FCML_TEXT("vinsertf64x4") +#define M_VINSERTI128 FCML_TEXT("vinserti128") +#define M_VINSERTI32X4 FCML_TEXT("vinserti32x4") +#define M_VINSERTI32X8 FCML_TEXT("vinserti32x8") +#define M_VINSERTI64X2 FCML_TEXT("vinserti64x2") +#define M_VINSERTI64X4 FCML_TEXT("vinserti64x4") +#define M_VINSERTPS FCML_TEXT("vinsertps") +#define M_VLDDQU FCML_TEXT("vlddqu") +#define M_VLDMXCSR FCML_TEXT("vldmxcsr") +#define M_VMASKMOVDQU FCML_TEXT("vmaskmovdqu") +#define M_VMASKMOVPD FCML_TEXT("vmaskmovpd") +#define M_VMASKMOVPS FCML_TEXT("vmaskmovps") +#define M_VMAXPD FCML_TEXT("vmaxpd") +#define M_VMAXPS FCML_TEXT("vmaxps") +#define M_VMAXSD FCML_TEXT("vmaxsd") +#define M_VMAXSS FCML_TEXT("vmaxss") +#define M_VMCALL FCML_TEXT("vmcall") +#define M_VMCLEAR FCML_TEXT("vmclear") +#define M_VMFUNC FCML_TEXT("vmfunc") +#define M_VMINPD FCML_TEXT("vminpd") +#define M_VMINPS FCML_TEXT("vminps") +#define M_VMINSD FCML_TEXT("vminsd") +#define M_VMINSS FCML_TEXT("vminss") +#define M_VMLAUNCH FCML_TEXT("vmlaunch") +#define M_VMLOAD FCML_TEXT("vmload") +#define M_VMMCALL FCML_TEXT("vmmcall") +#define M_VMOVAPD FCML_TEXT("vmovapd") +#define M_VMOVAPS FCML_TEXT("vmovaps") +#define M_VMOVD FCML_TEXT("vmovd") +#define M_VMOVDDUP FCML_TEXT("vmovddup") +#define M_VMOVDQA FCML_TEXT("vmovdqa") +#define M_VMOVDQA32 FCML_TEXT("vmovdqa32") +#define M_VMOVDQA64 FCML_TEXT("vmovdqa64") +#define M_VMOVDQU FCML_TEXT("vmovdqu") +#define M_VMOVDQU16 FCML_TEXT("vmovdqu16") +#define M_VMOVDQU32 FCML_TEXT("vmovdqu32") +#define M_VMOVDQU64 FCML_TEXT("vmovdqu64") +#define M_VMOVDQU8 FCML_TEXT("vmovdqu8") +#define M_VMOVHLPS FCML_TEXT("vmovhlps") +#define M_VMOVHPD FCML_TEXT("vmovhpd") +#define M_VMOVHPS FCML_TEXT("vmovhps") +#define M_VMOVLHPS FCML_TEXT("vmovlhps") +#define M_VMOVLPD FCML_TEXT("vmovlpd") +#define M_VMOVLPS FCML_TEXT("vmovlps") +#define M_VMOVMSKPD FCML_TEXT("vmovmskpd") +#define M_VMOVMSKPS FCML_TEXT("vmovmskps") +#define M_VMOVNTDQ FCML_TEXT("vmovntdq") +#define M_VMOVNTDQA FCML_TEXT("vmovntdqa") +#define M_VMOVNTPD FCML_TEXT("vmovntpd") +#define M_VMOVNTPS FCML_TEXT("vmovntps") +#define M_VMOVQ FCML_TEXT("vmovq") +#define M_VMOVSD FCML_TEXT("vmovsd") +#define M_VMOVSHDUP FCML_TEXT("vmovshdup") +#define M_VMOVSLDUP FCML_TEXT("vmovsldup") +#define M_VMOVSS FCML_TEXT("vmovss") +#define M_VMOVUPD FCML_TEXT("vmovupd") +#define M_VMOVUPS FCML_TEXT("vmovups") +#define M_VMPSADBW FCML_TEXT("vmpsadbw") +#define M_VMPTRLD FCML_TEXT("vmptrld") +#define M_VMPTRST FCML_TEXT("vmptrst") +#define M_VMREAD FCML_TEXT("vmread") +#define M_VMRESUME FCML_TEXT("vmresume") +#define M_VMRUN FCML_TEXT("vmrun") +#define M_VMSAVE FCML_TEXT("vmsave") +#define M_VMULPD FCML_TEXT("vmulpd") +#define M_VMULPS FCML_TEXT("vmulps") +#define M_VMULSD FCML_TEXT("vmulsd") +#define M_VMULSS FCML_TEXT("vmulss") +#define M_VMWRITE FCML_TEXT("vmwrite") +#define M_VMXOFF FCML_TEXT("vmxoff") +#define M_VMXON FCML_TEXT("vmxon") +#define M_VORPD FCML_TEXT("vorpd") +#define M_VORPS FCML_TEXT("vorps") +#define M_VP4DPWSSD FCML_TEXT("vp4dpwssd") +#define M_VP4DPWSSDS FCML_TEXT("vp4dpwssds") +#define M_VPABSB FCML_TEXT("vpabsb") +#define M_VPABSD FCML_TEXT("vpabsd") +#define M_VPABSQ FCML_TEXT("vpabsq") +#define M_VPABSW FCML_TEXT("vpabsw") +#define M_VPACKSSDW FCML_TEXT("vpackssdw") +#define M_VPACKSSWB FCML_TEXT("vpacksswb") +#define M_VPACKUSDW FCML_TEXT("vpackusdw") +#define M_VPACKUSWB FCML_TEXT("vpackuswb") +#define M_VPADDB FCML_TEXT("vpaddb") +#define M_VPADDD FCML_TEXT("vpaddd") +#define M_VPADDQ FCML_TEXT("vpaddq") +#define M_VPADDSB FCML_TEXT("vpaddsb") +#define M_VPADDSW FCML_TEXT("vpaddsw") +#define M_VPADDUSB FCML_TEXT("vpaddusb") +#define M_VPADDUSW FCML_TEXT("vpaddusw") +#define M_VPADDW FCML_TEXT("vpaddw") +#define M_VPALIGNR FCML_TEXT("vpalignr") +#define M_VPAND FCML_TEXT("vpand") +#define M_VPANDD FCML_TEXT("vpandd") +#define M_VPANDN FCML_TEXT("vpandn") +#define M_VPANDND FCML_TEXT("vpandnd") +#define M_VPANDNQ FCML_TEXT("vpandnq") +#define M_VPANDQ FCML_TEXT("vpandq") +#define M_VPAVGB FCML_TEXT("vpavgb") +#define M_VPAVGW FCML_TEXT("vpavgw") +#define M_VPBLENDD FCML_TEXT("vpblendd") +#define M_VPBLENDMB FCML_TEXT("vpblendmb") +#define M_VPBLENDMD FCML_TEXT("vpblendmd") +#define M_VPBLENDMQ FCML_TEXT("vpblendmq") +#define M_VPBLENDMW FCML_TEXT("vpblendmw") +#define M_VPBLENDVB FCML_TEXT("vpblendvb") +#define M_VPBLENDW FCML_TEXT("vpblendw") +#define M_VPBROADCASTB FCML_TEXT("vpbroadcastb") +#define M_VPBROADCASTD FCML_TEXT("vpbroadcastd") +#define M_VPBROADCASTMB2Q FCML_TEXT("vpbroadcastmb2q") +#define M_VPBROADCASTMW2D FCML_TEXT("vpbroadcastmw2d") +#define M_VPBROADCASTQ FCML_TEXT("vpbroadcastq") +#define M_VPBROADCASTW FCML_TEXT("vpbroadcastw") +#define M_VPCLMULQDQ FCML_TEXT("vpclmulqdq") +#define M_VPCMOV FCML_TEXT("vpcmov") +#define M_VPCMPB FCML_TEXT("vpcmpb") +#define M_VPCMPD FCML_TEXT("vpcmpd") +#define M_VPCMPEQB FCML_TEXT("vpcmpeqb") +#define M_VPCMPEQD FCML_TEXT("vpcmpeqd") +#define M_VPCMPEQQ FCML_TEXT("vpcmpeqq") +#define M_VPCMPEQW FCML_TEXT("vpcmpeqw") +#define M_VPCMPESTRI FCML_TEXT("vpcmpestri") +#define M_VPCMPESTRM FCML_TEXT("vpcmpestrm") +#define M_VPCMPGTB FCML_TEXT("vpcmpgtb") +#define M_VPCMPGTD FCML_TEXT("vpcmpgtd") +#define M_VPCMPGTQ FCML_TEXT("vpcmpgtq") +#define M_VPCMPGTW FCML_TEXT("vpcmpgtw") +#define M_VPCMPISTRI FCML_TEXT("vpcmpistri") +#define M_VPCMPISTRM FCML_TEXT("vpcmpistrm") +#define M_VPCMPQ FCML_TEXT("vpcmpq") +#define M_VPCMPUB FCML_TEXT("vpcmpub") +#define M_VPCMPUD FCML_TEXT("vpcmpud") +#define M_VPCMPUQ FCML_TEXT("vpcmpuq") +#define M_VPCMPUW FCML_TEXT("vpcmpuw") +#define M_VPCMPW FCML_TEXT("vpcmpw") +#define M_VPCOMB FCML_TEXT("vpcomb") +#define M_VPCOMD FCML_TEXT("vpcomd") +#define M_VPCOMEQB FCML_TEXT("vpcomeqb") +#define M_VPCOMEQD FCML_TEXT("vpcomeqd") +#define M_VPCOMEQQ FCML_TEXT("vpcomeqq") +#define M_VPCOMEQUB FCML_TEXT("vpcomequb") +#define M_VPCOMEQUD FCML_TEXT("vpcomequd") +#define M_VPCOMEQUQ FCML_TEXT("vpcomequq") +#define M_VPCOMEQUW FCML_TEXT("vpcomequw") +#define M_VPCOMEQW FCML_TEXT("vpcomeqw") +#define M_VPCOMFALSEB FCML_TEXT("vpcomfalseb") +#define M_VPCOMFALSED FCML_TEXT("vpcomfalsed") +#define M_VPCOMFALSEQ FCML_TEXT("vpcomfalseq") +#define M_VPCOMFALSEUB FCML_TEXT("vpcomfalseub") +#define M_VPCOMFALSEUD FCML_TEXT("vpcomfalseud") +#define M_VPCOMFALSEUQ FCML_TEXT("vpcomfalseuq") +#define M_VPCOMFALSEUW FCML_TEXT("vpcomfalseuw") +#define M_VPCOMFALSEW FCML_TEXT("vpcomfalsew") +#define M_VPCOMGEB FCML_TEXT("vpcomgeb") +#define M_VPCOMGED FCML_TEXT("vpcomged") +#define M_VPCOMGEQ FCML_TEXT("vpcomgeq") +#define M_VPCOMGEUB FCML_TEXT("vpcomgeub") +#define M_VPCOMGEUD FCML_TEXT("vpcomgeud") +#define M_VPCOMGEUQ FCML_TEXT("vpcomgeuq") +#define M_VPCOMGEUW FCML_TEXT("vpcomgeuw") +#define M_VPCOMGEW FCML_TEXT("vpcomgew") +#define M_VPCOMGTB FCML_TEXT("vpcomgtb") +#define M_VPCOMGTD FCML_TEXT("vpcomgtd") +#define M_VPCOMGTQ FCML_TEXT("vpcomgtq") +#define M_VPCOMGTUB FCML_TEXT("vpcomgtub") +#define M_VPCOMGTUD FCML_TEXT("vpcomgtud") +#define M_VPCOMGTUQ FCML_TEXT("vpcomgtuq") +#define M_VPCOMGTUW FCML_TEXT("vpcomgtuw") +#define M_VPCOMGTW FCML_TEXT("vpcomgtw") +#define M_VPCOMLEB FCML_TEXT("vpcomleb") +#define M_VPCOMLED FCML_TEXT("vpcomled") +#define M_VPCOMLEQ FCML_TEXT("vpcomleq") +#define M_VPCOMLEUB FCML_TEXT("vpcomleub") +#define M_VPCOMLEUD FCML_TEXT("vpcomleud") +#define M_VPCOMLEUQ FCML_TEXT("vpcomleuq") +#define M_VPCOMLEUW FCML_TEXT("vpcomleuw") +#define M_VPCOMLEW FCML_TEXT("vpcomlew") +#define M_VPCOMLTB FCML_TEXT("vpcomltb") +#define M_VPCOMLTD FCML_TEXT("vpcomltd") +#define M_VPCOMLTQ FCML_TEXT("vpcomltq") +#define M_VPCOMLTUB FCML_TEXT("vpcomltub") +#define M_VPCOMLTUD FCML_TEXT("vpcomltud") +#define M_VPCOMLTUQ FCML_TEXT("vpcomltuq") +#define M_VPCOMLTUW FCML_TEXT("vpcomltuw") +#define M_VPCOMLTW FCML_TEXT("vpcomltw") +#define M_VPCOMNEQB FCML_TEXT("vpcomneqb") +#define M_VPCOMNEQD FCML_TEXT("vpcomneqd") +#define M_VPCOMNEQQ FCML_TEXT("vpcomneqq") +#define M_VPCOMNEQUB FCML_TEXT("vpcomnequb") +#define M_VPCOMNEQUD FCML_TEXT("vpcomnequd") +#define M_VPCOMNEQUQ FCML_TEXT("vpcomnequq") +#define M_VPCOMNEQUW FCML_TEXT("vpcomnequw") +#define M_VPCOMNEQW FCML_TEXT("vpcomneqw") +#define M_VPCOMPRESSD FCML_TEXT("vpcompressd") +#define M_VPCOMPRESSQ FCML_TEXT("vpcompressq") +#define M_VPCOMQ FCML_TEXT("vpcomq") +#define M_VPCOMTRUEB FCML_TEXT("vpcomtrueb") +#define M_VPCOMTRUED FCML_TEXT("vpcomtrued") +#define M_VPCOMTRUEQ FCML_TEXT("vpcomtrueq") +#define M_VPCOMTRUEUB FCML_TEXT("vpcomtrueub") +#define M_VPCOMTRUEUD FCML_TEXT("vpcomtrueud") +#define M_VPCOMTRUEUQ FCML_TEXT("vpcomtrueuq") +#define M_VPCOMTRUEUW FCML_TEXT("vpcomtrueuw") +#define M_VPCOMTRUEW FCML_TEXT("vpcomtruew") +#define M_VPCOMUB FCML_TEXT("vpcomub") +#define M_VPCOMUD FCML_TEXT("vpcomud") +#define M_VPCOMUQ FCML_TEXT("vpcomuq") +#define M_VPCOMUW FCML_TEXT("vpcomuw") +#define M_VPCOMW FCML_TEXT("vpcomw") +#define M_VPERM2F128 FCML_TEXT("vperm2f128") +#define M_VPERM2I128 FCML_TEXT("vperm2i128") +#define M_VPERMB FCML_TEXT("vpermb") +#define M_VPERMD FCML_TEXT("vpermd") +#define M_VPERMI2B FCML_TEXT("vpermi2b") +#define M_VPERMI2D FCML_TEXT("vpermi2d") +#define M_VPERMI2PD FCML_TEXT("vpermi2pd") +#define M_VPERMI2PS FCML_TEXT("vpermi2ps") +#define M_VPERMI2Q FCML_TEXT("vpermi2q") +#define M_VPERMI2W FCML_TEXT("vpermi2w") +#define M_VPERMIL2PD FCML_TEXT("vpermil2pd") +#define M_VPERMIL2PS FCML_TEXT("vpermil2ps") +#define M_VPERMILPD FCML_TEXT("vpermilpd") +#define M_VPERMILPS FCML_TEXT("vpermilps") +#define M_VPERMPD FCML_TEXT("vpermpd") +#define M_VPERMPS FCML_TEXT("vpermps") +#define M_VPERMQ FCML_TEXT("vpermq") +#define M_VPERMT2B FCML_TEXT("vpermt2b") +#define M_VPERMT2D FCML_TEXT("vpermt2d") +#define M_VPERMT2PD FCML_TEXT("vpermt2pd") +#define M_VPERMT2PS FCML_TEXT("vpermt2ps") +#define M_VPERMT2Q FCML_TEXT("vpermt2q") +#define M_VPERMT2W FCML_TEXT("vpermt2w") +#define M_VPERMW FCML_TEXT("vpermw") +#define M_VPEXPANDD FCML_TEXT("vpexpandd") +#define M_VPEXPANDQ FCML_TEXT("vpexpandq") +#define M_VPEXTRB FCML_TEXT("vpextrb") +#define M_VPEXTRD FCML_TEXT("vpextrd") +#define M_VPEXTRQ FCML_TEXT("vpextrq") +#define M_VPEXTRW FCML_TEXT("vpextrw") +#define M_VPGATHERDD FCML_TEXT("vpgatherdd") +#define M_VPGATHERDQ FCML_TEXT("vpgatherdq") +#define M_VPGATHERQD FCML_TEXT("vpgatherqd") +#define M_VPGATHERQQ FCML_TEXT("vpgatherqq") +#define M_VPHADDBD FCML_TEXT("vphaddbd") +#define M_VPHADDBQ FCML_TEXT("vphaddbq") +#define M_VPHADDBW FCML_TEXT("vphaddbw") +#define M_VPHADDD FCML_TEXT("vphaddd") +#define M_VPHADDDQ FCML_TEXT("vphadddq") +#define M_VPHADDSW FCML_TEXT("vphaddsw") +#define M_VPHADDUBD FCML_TEXT("vphaddubd") +#define M_VPHADDUBQ FCML_TEXT("vphaddubq") +#define M_VPHADDUBW FCML_TEXT("vphaddubw") +#define M_VPHADDUDQ FCML_TEXT("vphaddudq") +#define M_VPHADDUWD FCML_TEXT("vphadduwd") +#define M_VPHADDUWQ FCML_TEXT("vphadduwq") +#define M_VPHADDW FCML_TEXT("vphaddw") +#define M_VPHADDWD FCML_TEXT("vphaddwd") +#define M_VPHADDWQ FCML_TEXT("vphaddwq") +#define M_VPHMINPOSUW FCML_TEXT("vphminposuw") +#define M_VPHSUBBW FCML_TEXT("vphsubbw") +#define M_VPHSUBD FCML_TEXT("vphsubd") +#define M_VPHSUBDQ FCML_TEXT("vphsubdq") +#define M_VPHSUBSW FCML_TEXT("vphsubsw") +#define M_VPHSUBW FCML_TEXT("vphsubw") +#define M_VPHSUBWD FCML_TEXT("vphsubwd") +#define M_VPINSRB FCML_TEXT("vpinsrb") +#define M_VPINSRD FCML_TEXT("vpinsrd") +#define M_VPINSRQ FCML_TEXT("vpinsrq") +#define M_VPINSRW FCML_TEXT("vpinsrw") +#define M_VPLZCNTD FCML_TEXT("vplzcntd") +#define M_VPLZCNTQ FCML_TEXT("vplzcntq") +#define M_VPMACSDD FCML_TEXT("vpmacsdd") +#define M_VPMACSDQH FCML_TEXT("vpmacsdqh") +#define M_VPMACSDQL FCML_TEXT("vpmacsdql") +#define M_VPMACSSDD FCML_TEXT("vpmacssdd") +#define M_VPMACSSDQH FCML_TEXT("vpmacssdqh") +#define M_VPMACSSDQL FCML_TEXT("vpmacssdql") +#define M_VPMACSSWD FCML_TEXT("vpmacsswd") +#define M_VPMACSSWW FCML_TEXT("vpmacssww") +#define M_VPMACSWD FCML_TEXT("vpmacswd") +#define M_VPMACSWW FCML_TEXT("vpmacsww") +#define M_VPMADCSSWD FCML_TEXT("vpmadcsswd") +#define M_VPMADCSWD FCML_TEXT("vpmadcswd") +#define M_VPMADD52HUQ FCML_TEXT("vpmadd52huq") +#define M_VPMADD52LUQ FCML_TEXT("vpmadd52luq") +#define M_VPMADDUBSW FCML_TEXT("vpmaddubsw") +#define M_VPMADDWD FCML_TEXT("vpmaddwd") +#define M_VPMASKMOV FCML_TEXT("vpmaskmov") +#define M_VPMASKMOVD FCML_TEXT("vpmaskmovd") +#define M_VPMASKMOVQ FCML_TEXT("vpmaskmovq") +#define M_VPMAXSB FCML_TEXT("vpmaxsb") +#define M_VPMAXSD FCML_TEXT("vpmaxsd") +#define M_VPMAXSQ FCML_TEXT("vpmaxsq") +#define M_VPMAXSW FCML_TEXT("vpmaxsw") +#define M_VPMAXUB FCML_TEXT("vpmaxub") +#define M_VPMAXUD FCML_TEXT("vpmaxud") +#define M_VPMAXUQ FCML_TEXT("vpmaxuq") +#define M_VPMAXUW FCML_TEXT("vpmaxuw") +#define M_VPMINSB FCML_TEXT("vpminsb") +#define M_VPMINSD FCML_TEXT("vpminsd") +#define M_VPMINSQ FCML_TEXT("vpminsq") +#define M_VPMINSW FCML_TEXT("vpminsw") +#define M_VPMINUB FCML_TEXT("vpminub") +#define M_VPMINUD FCML_TEXT("vpminud") +#define M_VPMINUQ FCML_TEXT("vpminuq") +#define M_VPMINUW FCML_TEXT("vpminuw") +#define M_VPMOVB2M FCML_TEXT("vpmovb2m") +#define M_VPMOVD2M FCML_TEXT("vpmovd2m") +#define M_VPMOVDB FCML_TEXT("vpmovdb") +#define M_VPMOVDW FCML_TEXT("vpmovdw") +#define M_VPMOVM2B FCML_TEXT("vpmovm2b") +#define M_VPMOVM2D FCML_TEXT("vpmovm2d") +#define M_VPMOVM2Q FCML_TEXT("vpmovm2q") +#define M_VPMOVM2W FCML_TEXT("vpmovm2w") +#define M_VPMOVMSKB FCML_TEXT("vpmovmskb") +#define M_VPMOVQ2M FCML_TEXT("vpmovq2m") +#define M_VPMOVQB FCML_TEXT("vpmovqb") +#define M_VPMOVQD FCML_TEXT("vpmovqd") +#define M_VPMOVQW FCML_TEXT("vpmovqw") +#define M_VPMOVSDB FCML_TEXT("vpmovsdb") +#define M_VPMOVSDW FCML_TEXT("vpmovsdw") +#define M_VPMOVSQB FCML_TEXT("vpmovsqb") +#define M_VPMOVSQD FCML_TEXT("vpmovsqd") +#define M_VPMOVSQW FCML_TEXT("vpmovsqw") +#define M_VPMOVSWB FCML_TEXT("vpmovswb") +#define M_VPMOVSXBD FCML_TEXT("vpmovsxbd") +#define M_VPMOVSXBQ FCML_TEXT("vpmovsxbq") +#define M_VPMOVSXBW FCML_TEXT("vpmovsxbw") +#define M_VPMOVSXDQ FCML_TEXT("vpmovsxdq") +#define M_VPMOVSXWD FCML_TEXT("vpmovsxwd") +#define M_VPMOVSXWQ FCML_TEXT("vpmovsxwq") +#define M_VPMOVUSDB FCML_TEXT("vpmovusdb") +#define M_VPMOVUSDW FCML_TEXT("vpmovusdw") +#define M_VPMOVUSQB FCML_TEXT("vpmovusqb") +#define M_VPMOVUSQD FCML_TEXT("vpmovusqd") +#define M_VPMOVUSQW FCML_TEXT("vpmovusqw") +#define M_VPMOVUSWB FCML_TEXT("vpmovuswb") +#define M_VPMOVW2M FCML_TEXT("vpmovw2m") +#define M_VPMOVWB FCML_TEXT("vpmovwb") +#define M_VPMOVZXBD FCML_TEXT("vpmovzxbd") +#define M_VPMOVZXBQ FCML_TEXT("vpmovzxbq") +#define M_VPMOVZXBW FCML_TEXT("vpmovzxbw") +#define M_VPMOVZXDQ FCML_TEXT("vpmovzxdq") +#define M_VPMOVZXWD FCML_TEXT("vpmovzxwd") +#define M_VPMOVZXWQ FCML_TEXT("vpmovzxwq") +#define M_VPMULDQ FCML_TEXT("vpmuldq") +#define M_VPMULHRSW FCML_TEXT("vpmulhrsw") +#define M_VPMULHUW FCML_TEXT("vpmulhuw") +#define M_VPMULHW FCML_TEXT("vpmulhw") +#define M_VPMULLD FCML_TEXT("vpmulld") +#define M_VPMULLQ FCML_TEXT("vpmullq") +#define M_VPMULLW FCML_TEXT("vpmullw") +#define M_VPMULTISHIFTQB FCML_TEXT("vpmultishiftqb") +#define M_VPMULUDQ FCML_TEXT("vpmuludq") +#define M_VPOR FCML_TEXT("vpor") +#define M_VPORD FCML_TEXT("vpord") +#define M_VPORQ FCML_TEXT("vporq") +#define M_VPPERM FCML_TEXT("vpperm") +#define M_VPROLD FCML_TEXT("vprold") +#define M_VPROLQ FCML_TEXT("vprolq") +#define M_VPROLVD FCML_TEXT("vprolvd") +#define M_VPROLVQ FCML_TEXT("vprolvq") +#define M_VPRORD FCML_TEXT("vprord") +#define M_VPRORQ FCML_TEXT("vprorq") +#define M_VPRORVD FCML_TEXT("vprorvd") +#define M_VPRORVQ FCML_TEXT("vprorvq") +#define M_VPROTB FCML_TEXT("vprotb") +#define M_VPROTD FCML_TEXT("vprotd") +#define M_VPROTQ FCML_TEXT("vprotq") +#define M_VPROTW FCML_TEXT("vprotw") +#define M_VPSADBW FCML_TEXT("vpsadbw") +#define M_VPSCATTERDD FCML_TEXT("vpscatterdd") +#define M_VPSCATTERDQ FCML_TEXT("vpscatterdq") +#define M_VPSCATTERQD FCML_TEXT("vpscatterqd") +#define M_VPSCATTERQQ FCML_TEXT("vpscatterqq") +#define M_VPSHAB FCML_TEXT("vpshab") +#define M_VPSHAD FCML_TEXT("vpshad") +#define M_VPSHAQ FCML_TEXT("vpshaq") +#define M_VPSHAW FCML_TEXT("vpshaw") +#define M_VPSHLB FCML_TEXT("vpshlb") +#define M_VPSHLD FCML_TEXT("vpshld") +#define M_VPSHLQ FCML_TEXT("vpshlq") +#define M_VPSHLW FCML_TEXT("vpshlw") +#define M_VPSHUFB FCML_TEXT("vpshufb") +#define M_VPSHUFD FCML_TEXT("vpshufd") +#define M_VPSHUFHW FCML_TEXT("vpshufhw") +#define M_VPSHUFLW FCML_TEXT("vpshuflw") +#define M_VPSIGNB FCML_TEXT("vpsignb") +#define M_VPSIGND FCML_TEXT("vpsignd") +#define M_VPSIGNW FCML_TEXT("vpsignw") +#define M_VPSLLD FCML_TEXT("vpslld") +#define M_VPSLLDQ FCML_TEXT("vpslldq") +#define M_VPSLLQ FCML_TEXT("vpsllq") +#define M_VPSLLVD FCML_TEXT("vpsllvd") +#define M_VPSLLVQ FCML_TEXT("vpsllvq") +#define M_VPSLLVW FCML_TEXT("vpsllvw") +#define M_VPSLLW FCML_TEXT("vpsllw") +#define M_VPSRAD FCML_TEXT("vpsrad") +#define M_VPSRAQ FCML_TEXT("vpsraq") +#define M_VPSRAVD FCML_TEXT("vpsravd") +#define M_VPSRAVQ FCML_TEXT("vpsravq") +#define M_VPSRAVW FCML_TEXT("vpsravw") +#define M_VPSRAW FCML_TEXT("vpsraw") +#define M_VPSRLD FCML_TEXT("vpsrld") +#define M_VPSRLDQ FCML_TEXT("vpsrldq") +#define M_VPSRLQ FCML_TEXT("vpsrlq") +#define M_VPSRLVD FCML_TEXT("vpsrlvd") +#define M_VPSRLVQ FCML_TEXT("vpsrlvq") +#define M_VPSRLVW FCML_TEXT("vpsrlvw") +#define M_VPSRLW FCML_TEXT("vpsrlw") +#define M_VPSUBB FCML_TEXT("vpsubb") +#define M_VPSUBD FCML_TEXT("vpsubd") +#define M_VPSUBQ FCML_TEXT("vpsubq") +#define M_VPSUBSB FCML_TEXT("vpsubsb") +#define M_VPSUBSW FCML_TEXT("vpsubsw") +#define M_VPSUBUSB FCML_TEXT("vpsubusb") +#define M_VPSUBUSW FCML_TEXT("vpsubusw") +#define M_VPSUBW FCML_TEXT("vpsubw") +#define M_VPTERNLOGD FCML_TEXT("vpternlogd") +#define M_VPTERNLOGQ FCML_TEXT("vpternlogq") +#define M_VPTEST FCML_TEXT("vptest") +#define M_VPTESTMB FCML_TEXT("vptestmb") +#define M_VPTESTMD FCML_TEXT("vptestmd") +#define M_VPTESTMQ FCML_TEXT("vptestmq") +#define M_VPTESTMW FCML_TEXT("vptestmw") +#define M_VPTESTNMB FCML_TEXT("vptestnmb") +#define M_VPTESTNMD FCML_TEXT("vptestnmd") +#define M_VPTESTNMQ FCML_TEXT("vptestnmq") +#define M_VPTESTNMW FCML_TEXT("vptestnmw") +#define M_VPUNPCKHBW FCML_TEXT("vpunpckhbw") +#define M_VPUNPCKHDQ FCML_TEXT("vpunpckhdq") +#define M_VPUNPCKHQDQ FCML_TEXT("vpunpckhqdq") +#define M_VPUNPCKHWD FCML_TEXT("vpunpckhwd") +#define M_VPUNPCKLBW FCML_TEXT("vpunpcklbw") +#define M_VPUNPCKLDQ FCML_TEXT("vpunpckldq") +#define M_VPUNPCKLQDQ FCML_TEXT("vpunpcklqdq") +#define M_VPUNPCKLWD FCML_TEXT("vpunpcklwd") +#define M_VPXOR FCML_TEXT("vpxor") +#define M_VPXORD FCML_TEXT("vpxord") +#define M_VPXORQ FCML_TEXT("vpxorq") +#define M_VRANGEPD FCML_TEXT("vrangepd") +#define M_VRANGEPS FCML_TEXT("vrangeps") +#define M_VRANGESD FCML_TEXT("vrangesd") +#define M_VRANGESS FCML_TEXT("vrangess") +#define M_VRCP14PD FCML_TEXT("vrcp14pd") +#define M_VRCP14PS FCML_TEXT("vrcp14ps") +#define M_VRCP14SD FCML_TEXT("vrcp14sd") +#define M_VRCP14SS FCML_TEXT("vrcp14ss") +#define M_VRCP28PD FCML_TEXT("vrcp28pd") +#define M_VRCP28PS FCML_TEXT("vrcp28ps") +#define M_VRCP28SD FCML_TEXT("vrcp28sd") +#define M_VRCP28SS FCML_TEXT("vrcp28ss") +#define M_VRCPPS FCML_TEXT("vrcpps") +#define M_VRCPSS FCML_TEXT("vrcpss") +#define M_VREDUCEPD FCML_TEXT("vreducepd") +#define M_VREDUCEPS FCML_TEXT("vreduceps") +#define M_VREDUCESD FCML_TEXT("vreducesd") +#define M_VREDUCESS FCML_TEXT("vreducess") +#define M_VRNDSCALEPD FCML_TEXT("vrndscalepd") +#define M_VRNDSCALEPS FCML_TEXT("vrndscaleps") +#define M_VRNDSCALESD FCML_TEXT("vrndscalesd") +#define M_VRNDSCALESS FCML_TEXT("vrndscaless") +#define M_VROUNDPD FCML_TEXT("vroundpd") +#define M_VROUNDPS FCML_TEXT("vroundps") +#define M_VROUNDSD FCML_TEXT("vroundsd") +#define M_VROUNDSS FCML_TEXT("vroundss") +#define M_VRSQRT14PD FCML_TEXT("vrsqrt14pd") +#define M_VRSQRT14PS FCML_TEXT("vrsqrt14ps") +#define M_VRSQRT14SD FCML_TEXT("vrsqrt14sd") +#define M_VRSQRT14SS FCML_TEXT("vrsqrt14ss") +#define M_VRSQRT28PD FCML_TEXT("vrsqrt28pd") +#define M_VRSQRT28PS FCML_TEXT("vrsqrt28ps") +#define M_VRSQRT28SD FCML_TEXT("vrsqrt28sd") +#define M_VRSQRT28SS FCML_TEXT("vrsqrt28ss") +#define M_VRSQRTPS FCML_TEXT("vrsqrtps") +#define M_VRSQRTSS FCML_TEXT("vrsqrtss") +#define M_VSCALEFPD FCML_TEXT("vscalefpd") +#define M_VSCALEFPS FCML_TEXT("vscalefps") +#define M_VSCALEFSD FCML_TEXT("vscalefsd") +#define M_VSCALEFSS FCML_TEXT("vscalefss") +#define M_VSCATTERDPD FCML_TEXT("vscatterdpd") +#define M_VSCATTERDPS FCML_TEXT("vscatterdps") +#define M_VSCATTERPF0DPD FCML_TEXT("vscatterpf0dpd") +#define M_VSCATTERPF0DPS FCML_TEXT("vscatterpf0dps") +#define M_VSCATTERPF0QPD FCML_TEXT("vscatterpf0qpd") +#define M_VSCATTERPF0QPS FCML_TEXT("vscatterpf0qps") +#define M_VSCATTERPF1DPD FCML_TEXT("vscatterpf1dpd") +#define M_VSCATTERPF1DPS FCML_TEXT("vscatterpf1dps") +#define M_VSCATTERPF1QPD FCML_TEXT("vscatterpf1qpd") +#define M_VSCATTERPF1QPS FCML_TEXT("vscatterpf1qps") +#define M_VSCATTERQPD FCML_TEXT("vscatterqpd") +#define M_VSCATTERQPS FCML_TEXT("vscatterqps") +#define M_VSHUFF32X4 FCML_TEXT("vshuff32x4") +#define M_VSHUFF64X2 FCML_TEXT("vshuff64x2") +#define M_VSHUFI32X4 FCML_TEXT("vshufi32x4") +#define M_VSHUFI64X2 FCML_TEXT("vshufi64x2") +#define M_VSHUFPD FCML_TEXT("vshufpd") +#define M_VSHUFPS FCML_TEXT("vshufps") +#define M_VSQRTPD FCML_TEXT("vsqrtpd") +#define M_VSQRTPS FCML_TEXT("vsqrtps") +#define M_VSQRTSD FCML_TEXT("vsqrtsd") +#define M_VSQRTSS FCML_TEXT("vsqrtss") +#define M_VSTMXCSR FCML_TEXT("vstmxcsr") +#define M_VSUBPD FCML_TEXT("vsubpd") +#define M_VSUBPS FCML_TEXT("vsubps") +#define M_VSUBSD FCML_TEXT("vsubsd") +#define M_VSUBSS FCML_TEXT("vsubss") +#define M_VTESTPD FCML_TEXT("vtestpd") +#define M_VTESTPS FCML_TEXT("vtestps") +#define M_VUCOMISD FCML_TEXT("vucomisd") +#define M_VUCOMISS FCML_TEXT("vucomiss") +#define M_VUNPCKHPD FCML_TEXT("vunpckhpd") +#define M_VUNPCKHPS FCML_TEXT("vunpckhps") +#define M_VUNPCKLPD FCML_TEXT("vunpcklpd") +#define M_VUNPCKLPS FCML_TEXT("vunpcklps") +#define M_VXORPD FCML_TEXT("vxorpd") +#define M_VXORPS FCML_TEXT("vxorps") +#define M_VZEROALL FCML_TEXT("vzeroall") +#define M_VZEROUPPER FCML_TEXT("vzeroupper") +#define M_WAIT FCML_TEXT("wait") +#define M_WBINVD FCML_TEXT("wbinvd") +#define M_WRFSBASE FCML_TEXT("wrfsbase") +#define M_WRGSBASE FCML_TEXT("wrgsbase") +#define M_WRMSR FCML_TEXT("wrmsr") +#define M_XABORT FCML_TEXT("xabort") +#define M_XADD FCML_TEXT("xadd") +#define M_XBEGIN FCML_TEXT("xbegin") +#define M_XCHG FCML_TEXT("xchg") +#define M_XEND FCML_TEXT("xend") +#define M_XGETBV FCML_TEXT("xgetbv") +#define M_XLAT FCML_TEXT("xlat") +#define M_XLATB FCML_TEXT("xlatb") +#define M_XOR FCML_TEXT("xor") +#define M_XORPD FCML_TEXT("xorpd") +#define M_XORPS FCML_TEXT("xorps") +#define M_XRSTOR FCML_TEXT("xrstor") +#define M_XRSTOR64 FCML_TEXT("xrstor64") +#define M_XSAVE FCML_TEXT("xsave") +#define M_XSAVE64 FCML_TEXT("xsave64") +#define M_XSAVEOPT FCML_TEXT("xsaveopt") +#define M_XSAVEOPT64 FCML_TEXT("xsaveopt64") +#define M_XSETBV FCML_TEXT("xsetbv") +#define M_XTEST FCML_TEXT("xtest") + +#endif /* FCML_INTEL_MNEMONICS_H_ */ diff --git a/dependencies/fcml/include/fcml_intel_mnemonics.hpp b/dependencies/fcml/include/fcml_intel_mnemonics.hpp new file mode 100644 index 0000000..c3930e2 --- /dev/null +++ b/dependencies/fcml/include/fcml_intel_mnemonics.hpp @@ -0,0 +1,1724 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_intel_mnemonics.hpp + * Declarations of Intel mnemonics. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_INTEL_MNEMONICS_HPP_ +#define FCML_INTEL_MNEMONICS_HPP_ + +#include "fcml_types.h" + +#include "fcml_intel_mnemonics.hpp" +#include + +namespace fcml { +namespace intel { + +extern const fcml_cstring M_AAA; +extern const fcml_cstring M_AAD; +extern const fcml_cstring M_AAM; +extern const fcml_cstring M_AAS; +extern const fcml_cstring M_ADC; +extern const fcml_cstring M_ADCX; +extern const fcml_cstring M_ADD; +extern const fcml_cstring M_ADDPD; +extern const fcml_cstring M_ADDPS; +extern const fcml_cstring M_ADDSD; +extern const fcml_cstring M_ADDSS; +extern const fcml_cstring M_ADDSUBPD; +extern const fcml_cstring M_ADDSUBPS; +extern const fcml_cstring M_ADOX; +extern const fcml_cstring M_AESDEC; +extern const fcml_cstring M_AESDECLAST; +extern const fcml_cstring M_AESENC; +extern const fcml_cstring M_AESENCLAST; +extern const fcml_cstring M_AESIMC; +extern const fcml_cstring M_AESKEYGENASSIST; +extern const fcml_cstring M_AND; +extern const fcml_cstring M_ANDN; +extern const fcml_cstring M_ANDNPD; +extern const fcml_cstring M_ANDNPS; +extern const fcml_cstring M_ANDPD; +extern const fcml_cstring M_ANDPS; +extern const fcml_cstring M_ARPL; +extern const fcml_cstring M_BEXR; +extern const fcml_cstring M_BEXTR; +extern const fcml_cstring M_BLCFILL; +extern const fcml_cstring M_BLCI; +extern const fcml_cstring M_BLCIC; +extern const fcml_cstring M_BLCMSK; +extern const fcml_cstring M_BLCS; +extern const fcml_cstring M_BLENDPD; +extern const fcml_cstring M_BLENDPS; +extern const fcml_cstring M_BLENDVPD; +extern const fcml_cstring M_BLENDVPS; +extern const fcml_cstring M_BLSFILL; +extern const fcml_cstring M_BLSI; +extern const fcml_cstring M_BLSIC; +extern const fcml_cstring M_BLSMSK; +extern const fcml_cstring M_BLSR; +extern const fcml_cstring M_BOUND; +extern const fcml_cstring M_BSF; +extern const fcml_cstring M_BSR; +extern const fcml_cstring M_BSWAP; +extern const fcml_cstring M_BT; +extern const fcml_cstring M_BTC; +extern const fcml_cstring M_BTR; +extern const fcml_cstring M_BTS; +extern const fcml_cstring M_BZHI; +extern const fcml_cstring M_CALL; +extern const fcml_cstring M_CBW; +extern const fcml_cstring M_CDQ; +extern const fcml_cstring M_CDQE; +extern const fcml_cstring M_CLAC; +extern const fcml_cstring M_CLC; +extern const fcml_cstring M_CLD; +extern const fcml_cstring M_CLFLUSH; +extern const fcml_cstring M_CLGI; +extern const fcml_cstring M_CLI; +extern const fcml_cstring M_CLTS; +extern const fcml_cstring M_CMC; +extern const fcml_cstring M_CMOVA; +extern const fcml_cstring M_CMOVAE; +extern const fcml_cstring M_CMOVB; +extern const fcml_cstring M_CMOVBE; +extern const fcml_cstring M_CMOVC; +extern const fcml_cstring M_CMOVENE; +extern const fcml_cstring M_CMOVG; +extern const fcml_cstring M_CMOVGE; +extern const fcml_cstring M_CMOVL; +extern const fcml_cstring M_CMOVLE; +extern const fcml_cstring M_CMOVNA; +extern const fcml_cstring M_CMOVNAE; +extern const fcml_cstring M_CMOVNB; +extern const fcml_cstring M_CMOVNBE; +extern const fcml_cstring M_CMOVNC; +extern const fcml_cstring M_CMOVNG; +extern const fcml_cstring M_CMOVNGE; +extern const fcml_cstring M_CMOVNL; +extern const fcml_cstring M_CMOVNLE; +extern const fcml_cstring M_CMOVNO; +extern const fcml_cstring M_CMOVNP; +extern const fcml_cstring M_CMOVNS; +extern const fcml_cstring M_CMOVNZ; +extern const fcml_cstring M_CMOVO; +extern const fcml_cstring M_CMOVP; +extern const fcml_cstring M_CMOVPE; +extern const fcml_cstring M_CMOVPO; +extern const fcml_cstring M_CMOVS; +extern const fcml_cstring M_CMOVZ; +extern const fcml_cstring M_CMP; +extern const fcml_cstring M_CMPEQPD; +extern const fcml_cstring M_CMPEQPS; +extern const fcml_cstring M_CMPEQSD; +extern const fcml_cstring M_CMPEQSS; +extern const fcml_cstring M_CMPLEPD; +extern const fcml_cstring M_CMPLEPS; +extern const fcml_cstring M_CMPLESD; +extern const fcml_cstring M_CMPLESS; +extern const fcml_cstring M_CMPLTPD; +extern const fcml_cstring M_CMPLTPS; +extern const fcml_cstring M_CMPLTSD; +extern const fcml_cstring M_CMPLTSS; +extern const fcml_cstring M_CMPNEQPD; +extern const fcml_cstring M_CMPNEQPS; +extern const fcml_cstring M_CMPNEQSD; +extern const fcml_cstring M_CMPNEQSS; +extern const fcml_cstring M_CMPNLEPD; +extern const fcml_cstring M_CMPNLEPS; +extern const fcml_cstring M_CMPNLESD; +extern const fcml_cstring M_CMPNLESS; +extern const fcml_cstring M_CMPNLTPD; +extern const fcml_cstring M_CMPNLTPS; +extern const fcml_cstring M_CMPNLTSD; +extern const fcml_cstring M_CMPNLTSS; +extern const fcml_cstring M_CMPORDPD; +extern const fcml_cstring M_CMPORDPS; +extern const fcml_cstring M_CMPORDSD; +extern const fcml_cstring M_CMPORDSS; +extern const fcml_cstring M_CMPPD; +extern const fcml_cstring M_CMPPS; +extern const fcml_cstring M_CMPS; +extern const fcml_cstring M_CMPSB; +extern const fcml_cstring M_CMPSD; +extern const fcml_cstring M_CMPSQ; +extern const fcml_cstring M_CMPSS; +extern const fcml_cstring M_CMPSW; +extern const fcml_cstring M_CMPUNORDPD; +extern const fcml_cstring M_CMPUNORDPS; +extern const fcml_cstring M_CMPUNORDSD; +extern const fcml_cstring M_CMPUNORDSS; +extern const fcml_cstring M_CMPXCHG; +extern const fcml_cstring M_CMPXCHG16B; +extern const fcml_cstring M_CMPXCHG8B; +extern const fcml_cstring M_COMISD; +extern const fcml_cstring M_COMISS; +extern const fcml_cstring M_CPUID; +extern const fcml_cstring M_CQO; +extern const fcml_cstring M_CRC32; +extern const fcml_cstring M_CVTDQ2PD; +extern const fcml_cstring M_CVTDQ2PS; +extern const fcml_cstring M_CVTPD2DQ; +extern const fcml_cstring M_CVTPD2PI; +extern const fcml_cstring M_CVTPD2PS; +extern const fcml_cstring M_CVTPI2PD; +extern const fcml_cstring M_CVTPI2PS; +extern const fcml_cstring M_CVTPS2DQ; +extern const fcml_cstring M_CVTPS2PD; +extern const fcml_cstring M_CVTPS2PI; +extern const fcml_cstring M_CVTSD2SI; +extern const fcml_cstring M_CVTSD2SS; +extern const fcml_cstring M_CVTSI2SD; +extern const fcml_cstring M_CVTSI2SS; +extern const fcml_cstring M_CVTSS2SD; +extern const fcml_cstring M_CVTSS2SI; +extern const fcml_cstring M_CVTTPD2DQ; +extern const fcml_cstring M_CVTTPD2PI; +extern const fcml_cstring M_CVTTPS2DQ; +extern const fcml_cstring M_CVTTPS2PI; +extern const fcml_cstring M_CVTTSD2SI; +extern const fcml_cstring M_CVTTSS2SI; +extern const fcml_cstring M_CWD; +extern const fcml_cstring M_CWDE; +extern const fcml_cstring M_DAA; +extern const fcml_cstring M_DAS; +extern const fcml_cstring M_DEC; +extern const fcml_cstring M_DIV; +extern const fcml_cstring M_DIVPD; +extern const fcml_cstring M_DIVPS; +extern const fcml_cstring M_DIVSD; +extern const fcml_cstring M_DIVSS; +extern const fcml_cstring M_DPPD; +extern const fcml_cstring M_DPPS; +extern const fcml_cstring M_EMMS; +extern const fcml_cstring M_ENTER; +extern const fcml_cstring M_EXTRACTPS; +extern const fcml_cstring M_EXTRQ; +extern const fcml_cstring M_F2XM1; +extern const fcml_cstring M_FABS; +extern const fcml_cstring M_FADD; +extern const fcml_cstring M_FADDP; +extern const fcml_cstring M_FBLD; +extern const fcml_cstring M_FBSTP; +extern const fcml_cstring M_FCHS; +extern const fcml_cstring M_FCLEX; +extern const fcml_cstring M_FCMOVB; +extern const fcml_cstring M_FCMOVBE; +extern const fcml_cstring M_FCMOVE; +extern const fcml_cstring M_FCMOVNB; +extern const fcml_cstring M_FCMOVNBE; +extern const fcml_cstring M_FCMOVNE; +extern const fcml_cstring M_FCMOVNU; +extern const fcml_cstring M_FCMOVU; +extern const fcml_cstring M_FCOM; +extern const fcml_cstring M_FCOMI; +extern const fcml_cstring M_FCOMIP; +extern const fcml_cstring M_FCOMP; +extern const fcml_cstring M_FCOMPP; +extern const fcml_cstring M_FCOS; +extern const fcml_cstring M_FDECSTP; +extern const fcml_cstring M_FDIV; +extern const fcml_cstring M_FDIVP; +extern const fcml_cstring M_FDIVR; +extern const fcml_cstring M_FDIVRP; +extern const fcml_cstring M_FEMMS; +extern const fcml_cstring M_FFREE; +extern const fcml_cstring M_FIADD; +extern const fcml_cstring M_FICOM; +extern const fcml_cstring M_FICOMP; +extern const fcml_cstring M_FIDIV; +extern const fcml_cstring M_FIDIVR; +extern const fcml_cstring M_FILD; +extern const fcml_cstring M_FIMUL; +extern const fcml_cstring M_FINCSTP; +extern const fcml_cstring M_FINIT; +extern const fcml_cstring M_FIST; +extern const fcml_cstring M_FISTP; +extern const fcml_cstring M_FISTTP; +extern const fcml_cstring M_FISUB; +extern const fcml_cstring M_FISUBR; +extern const fcml_cstring M_FLD; +extern const fcml_cstring M_FLD1; +extern const fcml_cstring M_FLDCW; +extern const fcml_cstring M_FLDENV; +extern const fcml_cstring M_FLDL2E; +extern const fcml_cstring M_FLDL2T; +extern const fcml_cstring M_FLDLG2; +extern const fcml_cstring M_FLDLN2; +extern const fcml_cstring M_FLDPI; +extern const fcml_cstring M_FLDZ; +extern const fcml_cstring M_FMUL; +extern const fcml_cstring M_FMULP; +extern const fcml_cstring M_FNCLEX; +extern const fcml_cstring M_FNINIT; +extern const fcml_cstring M_FNOP; +extern const fcml_cstring M_FNSAVE; +extern const fcml_cstring M_FNSTCW; +extern const fcml_cstring M_FNSTENV; +extern const fcml_cstring M_FNSTSW; +extern const fcml_cstring M_FPATAN; +extern const fcml_cstring M_FPREM; +extern const fcml_cstring M_FPREM1; +extern const fcml_cstring M_FPTAN; +extern const fcml_cstring M_FRNDINT; +extern const fcml_cstring M_FRSTOR; +extern const fcml_cstring M_FSAVE; +extern const fcml_cstring M_FSCALE; +extern const fcml_cstring M_FSIN; +extern const fcml_cstring M_FSINCOS; +extern const fcml_cstring M_FSQRT; +extern const fcml_cstring M_FST; +extern const fcml_cstring M_FSTCW; +extern const fcml_cstring M_FSTENV; +extern const fcml_cstring M_FSTP; +extern const fcml_cstring M_FSTSW; +extern const fcml_cstring M_FSUB; +extern const fcml_cstring M_FSUBP; +extern const fcml_cstring M_FSUBR; +extern const fcml_cstring M_FSUBRP; +extern const fcml_cstring M_FTST; +extern const fcml_cstring M_FUCOM; +extern const fcml_cstring M_FUCOMI; +extern const fcml_cstring M_FUCOMIP; +extern const fcml_cstring M_FUCOMP; +extern const fcml_cstring M_FUCOMPP; +extern const fcml_cstring M_FWAIT; +extern const fcml_cstring M_FXAM; +extern const fcml_cstring M_FXCH; +extern const fcml_cstring M_FXRSTOR; +extern const fcml_cstring M_FXRSTOR64; +extern const fcml_cstring M_FXSAVE; +extern const fcml_cstring M_FXSAVE64; +extern const fcml_cstring M_FXTRACT; +extern const fcml_cstring M_FYL2X; +extern const fcml_cstring M_FYL2XP1; +extern const fcml_cstring M_GETSEC; +extern const fcml_cstring M_HADDPD; +extern const fcml_cstring M_HADDPS; +extern const fcml_cstring M_HLT; +extern const fcml_cstring M_HSUBPD; +extern const fcml_cstring M_HSUBPS; +extern const fcml_cstring M_IDIV; +extern const fcml_cstring M_IMUL; +extern const fcml_cstring M_IN; +extern const fcml_cstring M_INC; +extern const fcml_cstring M_INS; +extern const fcml_cstring M_INSB; +extern const fcml_cstring M_INSD; +extern const fcml_cstring M_INSERTPS; +extern const fcml_cstring M_INSERTQ; +extern const fcml_cstring M_INSW; +extern const fcml_cstring M_INT; +extern const fcml_cstring M_INT3; +extern const fcml_cstring M_INTO; +extern const fcml_cstring M_INVD; +extern const fcml_cstring M_INVEPT; +extern const fcml_cstring M_INVLPG; +extern const fcml_cstring M_INVLPGA; +extern const fcml_cstring M_INVPCID; +extern const fcml_cstring M_INVVPID; +extern const fcml_cstring M_IRET; +extern const fcml_cstring M_IRETD; +extern const fcml_cstring M_IRETQ; +extern const fcml_cstring M_JA; +extern const fcml_cstring M_JAE; +extern const fcml_cstring M_JB; +extern const fcml_cstring M_JBE; +extern const fcml_cstring M_JC; +extern const fcml_cstring M_JCXZ; +extern const fcml_cstring M_JECXZ; +extern const fcml_cstring M_JENE; +extern const fcml_cstring M_JG; +extern const fcml_cstring M_JGE; +extern const fcml_cstring M_JL; +extern const fcml_cstring M_JLE; +extern const fcml_cstring M_JMP; +extern const fcml_cstring M_JNA; +extern const fcml_cstring M_JNAE; +extern const fcml_cstring M_JNB; +extern const fcml_cstring M_JNBE; +extern const fcml_cstring M_JNC; +extern const fcml_cstring M_JNG; +extern const fcml_cstring M_JNGE; +extern const fcml_cstring M_JNL; +extern const fcml_cstring M_JNLE; +extern const fcml_cstring M_JNO; +extern const fcml_cstring M_JNP; +extern const fcml_cstring M_JNS; +extern const fcml_cstring M_JNZ; +extern const fcml_cstring M_JO; +extern const fcml_cstring M_JP; +extern const fcml_cstring M_JPE; +extern const fcml_cstring M_JPO; +extern const fcml_cstring M_JRCXZ; +extern const fcml_cstring M_JS; +extern const fcml_cstring M_JZ; +extern const fcml_cstring M_KADDB; +extern const fcml_cstring M_KADDD; +extern const fcml_cstring M_KADDQ; +extern const fcml_cstring M_KADDW; +extern const fcml_cstring M_KANDB; +extern const fcml_cstring M_KANDD; +extern const fcml_cstring M_KANDNB; +extern const fcml_cstring M_KANDND; +extern const fcml_cstring M_KANDNQ; +extern const fcml_cstring M_KANDNW; +extern const fcml_cstring M_KANDQ; +extern const fcml_cstring M_KANDW; +extern const fcml_cstring M_KMOVB; +extern const fcml_cstring M_KMOVD; +extern const fcml_cstring M_KMOVQ; +extern const fcml_cstring M_KMOVW; +extern const fcml_cstring M_KNOTB; +extern const fcml_cstring M_KNOTD; +extern const fcml_cstring M_KNOTQ; +extern const fcml_cstring M_KNOTW; +extern const fcml_cstring M_KORB; +extern const fcml_cstring M_KORD; +extern const fcml_cstring M_KORQ; +extern const fcml_cstring M_KORTESTB; +extern const fcml_cstring M_KORTESTD; +extern const fcml_cstring M_KORTESTQ; +extern const fcml_cstring M_KORTESTW; +extern const fcml_cstring M_KORW; +extern const fcml_cstring M_KSHIFTLB; +extern const fcml_cstring M_KSHIFTLD; +extern const fcml_cstring M_KSHIFTLQ; +extern const fcml_cstring M_KSHIFTLW; +extern const fcml_cstring M_KSHIFTRB; +extern const fcml_cstring M_KSHIFTRD; +extern const fcml_cstring M_KSHIFTRQ; +extern const fcml_cstring M_KSHIFTRW; +extern const fcml_cstring M_KTESTB; +extern const fcml_cstring M_KTESTD; +extern const fcml_cstring M_KTESTQ; +extern const fcml_cstring M_KTESTW; +extern const fcml_cstring M_KXNORB; +extern const fcml_cstring M_KXNORD; +extern const fcml_cstring M_KXNORQ; +extern const fcml_cstring M_KXNORW; +extern const fcml_cstring M_KXORB; +extern const fcml_cstring M_KXORD; +extern const fcml_cstring M_KXORQ; +extern const fcml_cstring M_KXORW; +extern const fcml_cstring M_LAHF; +extern const fcml_cstring M_LAR; +extern const fcml_cstring M_LDDQU; +extern const fcml_cstring M_LDMXCSR; +extern const fcml_cstring M_LDS; +extern const fcml_cstring M_LEA; +extern const fcml_cstring M_LEAVE; +extern const fcml_cstring M_LES; +extern const fcml_cstring M_LFENCE; +extern const fcml_cstring M_LFS; +extern const fcml_cstring M_LGDT; +extern const fcml_cstring M_LGS; +extern const fcml_cstring M_LIDT; +extern const fcml_cstring M_LLDT; +extern const fcml_cstring M_LLWPCB; +extern const fcml_cstring M_LMSW; +extern const fcml_cstring M_LODS; +extern const fcml_cstring M_LODSB; +extern const fcml_cstring M_LODSD; +extern const fcml_cstring M_LODSQ; +extern const fcml_cstring M_LODSW; +extern const fcml_cstring M_LOOP; +extern const fcml_cstring M_LOOPE; +extern const fcml_cstring M_LOOPNE; +extern const fcml_cstring M_LOOPNZ; +extern const fcml_cstring M_LOOPZ; +extern const fcml_cstring M_LSL; +extern const fcml_cstring M_LSS; +extern const fcml_cstring M_LTR; +extern const fcml_cstring M_LWPINS; +extern const fcml_cstring M_LWPVAL; +extern const fcml_cstring M_LZCNT; +extern const fcml_cstring M_MASKMOVDQU; +extern const fcml_cstring M_MASKMOVQ; +extern const fcml_cstring M_MAXPD; +extern const fcml_cstring M_MAXPS; +extern const fcml_cstring M_MAXSD; +extern const fcml_cstring M_MAXSS; +extern const fcml_cstring M_MFENCE; +extern const fcml_cstring M_MINPD; +extern const fcml_cstring M_MINPS; +extern const fcml_cstring M_MINSD; +extern const fcml_cstring M_MINSS; +extern const fcml_cstring M_MONITOR; +extern const fcml_cstring M_MOV; +extern const fcml_cstring M_MOVAPD; +extern const fcml_cstring M_MOVAPS; +extern const fcml_cstring M_MOVBE; +extern const fcml_cstring M_MOVD; +extern const fcml_cstring M_MOVDDUP; +extern const fcml_cstring M_MOVDQ2Q; +extern const fcml_cstring M_MOVDQA; +extern const fcml_cstring M_MOVDQU; +extern const fcml_cstring M_MOVHLPS; +extern const fcml_cstring M_MOVHPD; +extern const fcml_cstring M_MOVHPS; +extern const fcml_cstring M_MOVLHPS; +extern const fcml_cstring M_MOVLPD; +extern const fcml_cstring M_MOVLPS; +extern const fcml_cstring M_MOVMSKPD; +extern const fcml_cstring M_MOVMSKPS; +extern const fcml_cstring M_MOVNTDQ; +extern const fcml_cstring M_MOVNTDQA; +extern const fcml_cstring M_MOVNTI; +extern const fcml_cstring M_MOVNTPD; +extern const fcml_cstring M_MOVNTPS; +extern const fcml_cstring M_MOVNTQ; +extern const fcml_cstring M_MOVNTSD; +extern const fcml_cstring M_MOVNTSS; +extern const fcml_cstring M_MOVQ; +extern const fcml_cstring M_MOVQ2DQ; +extern const fcml_cstring M_MOVS; +extern const fcml_cstring M_MOVSB; +extern const fcml_cstring M_MOVSD; +extern const fcml_cstring M_MOVSHDUP; +extern const fcml_cstring M_MOVSLDUP; +extern const fcml_cstring M_MOVSQ; +extern const fcml_cstring M_MOVSS; +extern const fcml_cstring M_MOVSW; +extern const fcml_cstring M_MOVSX; +extern const fcml_cstring M_MOVSXD; +extern const fcml_cstring M_MOVUPD; +extern const fcml_cstring M_MOVUPS; +extern const fcml_cstring M_MOVZX; +extern const fcml_cstring M_MPSADBW; +extern const fcml_cstring M_MUL; +extern const fcml_cstring M_MULPD; +extern const fcml_cstring M_MULPS; +extern const fcml_cstring M_MULSD; +extern const fcml_cstring M_MULSS; +extern const fcml_cstring M_MULX; +extern const fcml_cstring M_MWAIT; +extern const fcml_cstring M_NEG; +extern const fcml_cstring M_NOP; +extern const fcml_cstring M_NOT; +extern const fcml_cstring M_OR; +extern const fcml_cstring M_ORPD; +extern const fcml_cstring M_ORPS; +extern const fcml_cstring M_OUT; +extern const fcml_cstring M_OUTS; +extern const fcml_cstring M_OUTSB; +extern const fcml_cstring M_OUTSD; +extern const fcml_cstring M_OUTSW; +extern const fcml_cstring M_PABSB; +extern const fcml_cstring M_PABSD; +extern const fcml_cstring M_PABSW; +extern const fcml_cstring M_PACKSSDW; +extern const fcml_cstring M_PACKSSWB; +extern const fcml_cstring M_PACKUSDW; +extern const fcml_cstring M_PACKUSWB; +extern const fcml_cstring M_PADDB; +extern const fcml_cstring M_PADDD; +extern const fcml_cstring M_PADDQ; +extern const fcml_cstring M_PADDSB; +extern const fcml_cstring M_PADDSW; +extern const fcml_cstring M_PADDUSB; +extern const fcml_cstring M_PADDUSW; +extern const fcml_cstring M_PADDW; +extern const fcml_cstring M_PALIGNR; +extern const fcml_cstring M_PAND; +extern const fcml_cstring M_PANDN; +extern const fcml_cstring M_PAUSE; +extern const fcml_cstring M_PAVGB; +extern const fcml_cstring M_PAVGUSB; +extern const fcml_cstring M_PAVGW; +extern const fcml_cstring M_PBLENDVB; +extern const fcml_cstring M_PBLENDW; +extern const fcml_cstring M_PCLMULQDQ; +extern const fcml_cstring M_PCMPEQB; +extern const fcml_cstring M_PCMPEQD; +extern const fcml_cstring M_PCMPEQQ; +extern const fcml_cstring M_PCMPEQW; +extern const fcml_cstring M_PCMPESTRI; +extern const fcml_cstring M_PCMPESTRM; +extern const fcml_cstring M_PCMPGTB; +extern const fcml_cstring M_PCMPGTD; +extern const fcml_cstring M_PCMPGTQ; +extern const fcml_cstring M_PCMPGTW; +extern const fcml_cstring M_PCMPISTRI; +extern const fcml_cstring M_PCMPISTRM; +extern const fcml_cstring M_PDEP; +extern const fcml_cstring M_PEXT; +extern const fcml_cstring M_PEXTRB; +extern const fcml_cstring M_PEXTRD; +extern const fcml_cstring M_PEXTRQ; +extern const fcml_cstring M_PEXTRW; +extern const fcml_cstring M_PF2ID; +extern const fcml_cstring M_PF2IW; +extern const fcml_cstring M_PFACC; +extern const fcml_cstring M_PFADD; +extern const fcml_cstring M_PFCMPEQ; +extern const fcml_cstring M_PFCMPGE; +extern const fcml_cstring M_PFCMPGT; +extern const fcml_cstring M_PFMAX; +extern const fcml_cstring M_PFMIN; +extern const fcml_cstring M_PFMUL; +extern const fcml_cstring M_PFNACC; +extern const fcml_cstring M_PFPNACC; +extern const fcml_cstring M_PFRCP; +extern const fcml_cstring M_PFRCPIT1; +extern const fcml_cstring M_PFRCPIT2; +extern const fcml_cstring M_PFRSQIT1; +extern const fcml_cstring M_PFRSQRT; +extern const fcml_cstring M_PFSUB; +extern const fcml_cstring M_PFSUBR; +extern const fcml_cstring M_PHADDD; +extern const fcml_cstring M_PHADDSW; +extern const fcml_cstring M_PHADDW; +extern const fcml_cstring M_PHMINPOSUW; +extern const fcml_cstring M_PHSUBD; +extern const fcml_cstring M_PHSUBSW; +extern const fcml_cstring M_PHSUBW; +extern const fcml_cstring M_PI2FD; +extern const fcml_cstring M_PI2FW; +extern const fcml_cstring M_PINSRB; +extern const fcml_cstring M_PINSRD; +extern const fcml_cstring M_PINSRQ; +extern const fcml_cstring M_PINSRW; +extern const fcml_cstring M_PMADDUBSW; +extern const fcml_cstring M_PMADDWD; +extern const fcml_cstring M_PMAXSB; +extern const fcml_cstring M_PMAXSD; +extern const fcml_cstring M_PMAXSW; +extern const fcml_cstring M_PMAXUB; +extern const fcml_cstring M_PMAXUD; +extern const fcml_cstring M_PMAXUW; +extern const fcml_cstring M_PMINSB; +extern const fcml_cstring M_PMINSD; +extern const fcml_cstring M_PMINSW; +extern const fcml_cstring M_PMINUB; +extern const fcml_cstring M_PMINUD; +extern const fcml_cstring M_PMINUW; +extern const fcml_cstring M_PMOVMSKB; +extern const fcml_cstring M_PMOVSXBD; +extern const fcml_cstring M_PMOVSXBQ; +extern const fcml_cstring M_PMOVSXBW; +extern const fcml_cstring M_PMOVSXDQ; +extern const fcml_cstring M_PMOVSXWD; +extern const fcml_cstring M_PMOVSXWQ; +extern const fcml_cstring M_PMOVZXBD; +extern const fcml_cstring M_PMOVZXBQ; +extern const fcml_cstring M_PMOVZXBW; +extern const fcml_cstring M_PMOVZXDQ; +extern const fcml_cstring M_PMOVZXWD; +extern const fcml_cstring M_PMOVZXWQ; +extern const fcml_cstring M_PMULDQ; +extern const fcml_cstring M_PMULHRSW; +extern const fcml_cstring M_PMULHRW; +extern const fcml_cstring M_PMULHUW; +extern const fcml_cstring M_PMULHW; +extern const fcml_cstring M_PMULLD; +extern const fcml_cstring M_PMULLW; +extern const fcml_cstring M_PMULUDQ; +extern const fcml_cstring M_POP; +extern const fcml_cstring M_POPA; +extern const fcml_cstring M_POPAD; +extern const fcml_cstring M_POPCNT; +extern const fcml_cstring M_POPF; +extern const fcml_cstring M_POPFD; +extern const fcml_cstring M_POPFQ; +extern const fcml_cstring M_POR; +extern const fcml_cstring M_PREFETCH; +extern const fcml_cstring M_PREFETCHNTA; +extern const fcml_cstring M_PREFETCHT0; +extern const fcml_cstring M_PREFETCHT1; +extern const fcml_cstring M_PREFETCHT2; +extern const fcml_cstring M_PREFETCHW; +extern const fcml_cstring M_PREFETCHWT1; +extern const fcml_cstring M_PSADBW; +extern const fcml_cstring M_PSHUFB; +extern const fcml_cstring M_PSHUFD; +extern const fcml_cstring M_PSHUFHW; +extern const fcml_cstring M_PSHUFLW; +extern const fcml_cstring M_PSHUFW; +extern const fcml_cstring M_PSIGNB; +extern const fcml_cstring M_PSIGND; +extern const fcml_cstring M_PSIGNW; +extern const fcml_cstring M_PSLLD; +extern const fcml_cstring M_PSLLDQ; +extern const fcml_cstring M_PSLLQ; +extern const fcml_cstring M_PSLLW; +extern const fcml_cstring M_PSRAD; +extern const fcml_cstring M_PSRAW; +extern const fcml_cstring M_PSRLD; +extern const fcml_cstring M_PSRLDQ; +extern const fcml_cstring M_PSRLQ; +extern const fcml_cstring M_PSRLW; +extern const fcml_cstring M_PSUBB; +extern const fcml_cstring M_PSUBD; +extern const fcml_cstring M_PSUBQ; +extern const fcml_cstring M_PSUBSB; +extern const fcml_cstring M_PSUBSW; +extern const fcml_cstring M_PSUBUSB; +extern const fcml_cstring M_PSUBUSW; +extern const fcml_cstring M_PSUBW; +extern const fcml_cstring M_PSWAPD; +extern const fcml_cstring M_PTEST; +extern const fcml_cstring M_PUNPCKHBW; +extern const fcml_cstring M_PUNPCKHDQ; +extern const fcml_cstring M_PUNPCKHQDQ; +extern const fcml_cstring M_PUNPCKHWD; +extern const fcml_cstring M_PUNPCKLBW; +extern const fcml_cstring M_PUNPCKLDQ; +extern const fcml_cstring M_PUNPCKLQDQ; +extern const fcml_cstring M_PUNPCKLWD; +extern const fcml_cstring M_PUSH; +extern const fcml_cstring M_PUSHA; +extern const fcml_cstring M_PUSHAD; +extern const fcml_cstring M_PUSHF; +extern const fcml_cstring M_PUSHFD; +extern const fcml_cstring M_PUSHFQ; +extern const fcml_cstring M_PXOR; +extern const fcml_cstring M_RCL; +extern const fcml_cstring M_RCPPS; +extern const fcml_cstring M_RCPSS; +extern const fcml_cstring M_RCR; +extern const fcml_cstring M_RDFSBASE; +extern const fcml_cstring M_RDGSBASE; +extern const fcml_cstring M_RDMSR; +extern const fcml_cstring M_RDPMC; +extern const fcml_cstring M_RDRAND; +extern const fcml_cstring M_RDSEED; +extern const fcml_cstring M_RDTSC; +extern const fcml_cstring M_RDTSCP; +extern const fcml_cstring M_RET; +extern const fcml_cstring M_RETF; +extern const fcml_cstring M_ROL; +extern const fcml_cstring M_ROR; +extern const fcml_cstring M_RORX; +extern const fcml_cstring M_ROUNDPD; +extern const fcml_cstring M_ROUNDPS; +extern const fcml_cstring M_ROUNDSD; +extern const fcml_cstring M_ROUNDSS; +extern const fcml_cstring M_RSM; +extern const fcml_cstring M_RSQRTPS; +extern const fcml_cstring M_RSQRTSS; +extern const fcml_cstring M_SAHF; +extern const fcml_cstring M_SAL; +extern const fcml_cstring M_SAR; +extern const fcml_cstring M_SARX; +extern const fcml_cstring M_SBB; +extern const fcml_cstring M_SCAS; +extern const fcml_cstring M_SCASB; +extern const fcml_cstring M_SCASD; +extern const fcml_cstring M_SCASQ; +extern const fcml_cstring M_SCASW; +extern const fcml_cstring M_SETA; +extern const fcml_cstring M_SETAE; +extern const fcml_cstring M_SETB; +extern const fcml_cstring M_SETBE; +extern const fcml_cstring M_SETC; +extern const fcml_cstring M_SETENE; +extern const fcml_cstring M_SETG; +extern const fcml_cstring M_SETGE; +extern const fcml_cstring M_SETL; +extern const fcml_cstring M_SETLE; +extern const fcml_cstring M_SETNA; +extern const fcml_cstring M_SETNAE; +extern const fcml_cstring M_SETNB; +extern const fcml_cstring M_SETNBE; +extern const fcml_cstring M_SETNC; +extern const fcml_cstring M_SETNG; +extern const fcml_cstring M_SETNGE; +extern const fcml_cstring M_SETNL; +extern const fcml_cstring M_SETNLE; +extern const fcml_cstring M_SETNO; +extern const fcml_cstring M_SETNP; +extern const fcml_cstring M_SETNS; +extern const fcml_cstring M_SETNZ; +extern const fcml_cstring M_SETO; +extern const fcml_cstring M_SETP; +extern const fcml_cstring M_SETPE; +extern const fcml_cstring M_SETPO; +extern const fcml_cstring M_SETS; +extern const fcml_cstring M_SETZ; +extern const fcml_cstring M_SFENCE; +extern const fcml_cstring M_SGDT; +extern const fcml_cstring M_SHL; +extern const fcml_cstring M_SHLD; +extern const fcml_cstring M_SHLX; +extern const fcml_cstring M_SHR; +extern const fcml_cstring M_SHRD; +extern const fcml_cstring M_SHRX; +extern const fcml_cstring M_SHUFPD; +extern const fcml_cstring M_SHUFPS; +extern const fcml_cstring M_SIDT; +extern const fcml_cstring M_SKINIT; +extern const fcml_cstring M_SLDT; +extern const fcml_cstring M_SLWPCB; +extern const fcml_cstring M_SMSW; +extern const fcml_cstring M_SQRTPD; +extern const fcml_cstring M_SQRTPS; +extern const fcml_cstring M_SQRTSD; +extern const fcml_cstring M_SQRTSS; +extern const fcml_cstring M_STAC; +extern const fcml_cstring M_STC; +extern const fcml_cstring M_STD; +extern const fcml_cstring M_STGI; +extern const fcml_cstring M_STI; +extern const fcml_cstring M_STMXCSR; +extern const fcml_cstring M_STOS; +extern const fcml_cstring M_STOSB; +extern const fcml_cstring M_STOSD; +extern const fcml_cstring M_STOSQ; +extern const fcml_cstring M_STOSW; +extern const fcml_cstring M_STR; +extern const fcml_cstring M_SUB; +extern const fcml_cstring M_SUBPD; +extern const fcml_cstring M_SUBPS; +extern const fcml_cstring M_SUBSD; +extern const fcml_cstring M_SUBSS; +extern const fcml_cstring M_SWAPGS; +extern const fcml_cstring M_SYSCALL; +extern const fcml_cstring M_SYSENTER; +extern const fcml_cstring M_SYSEXIT; +extern const fcml_cstring M_SYSRET; +extern const fcml_cstring M_T1MSKC; +extern const fcml_cstring M_TEST; +extern const fcml_cstring M_TZCNT; +extern const fcml_cstring M_TZMSK; +extern const fcml_cstring M_UCOMISD; +extern const fcml_cstring M_UCOMISS; +extern const fcml_cstring M_UD2; +extern const fcml_cstring M_UNPCKHPD; +extern const fcml_cstring M_UNPCKHPS; +extern const fcml_cstring M_UNPCKLPD; +extern const fcml_cstring M_UNPCKLPS; +extern const fcml_cstring M_V4FMADDPS; +extern const fcml_cstring M_V4FMADDSS; +extern const fcml_cstring M_V4FNMADDPS; +extern const fcml_cstring M_V4FNMADDSS; +extern const fcml_cstring M_VADDPD; +extern const fcml_cstring M_VADDPS; +extern const fcml_cstring M_VADDSD; +extern const fcml_cstring M_VADDSS; +extern const fcml_cstring M_VADDSUBPD; +extern const fcml_cstring M_VADDSUBPS; +extern const fcml_cstring M_VAESDEC; +extern const fcml_cstring M_VAESDECLAST; +extern const fcml_cstring M_VAESENC; +extern const fcml_cstring M_VAESENCLAST; +extern const fcml_cstring M_VAESIMC; +extern const fcml_cstring M_VAESKEYGENASSIST; +extern const fcml_cstring M_VALIGND; +extern const fcml_cstring M_VALIGNQ; +extern const fcml_cstring M_VANDNPD; +extern const fcml_cstring M_VANDNPS; +extern const fcml_cstring M_VANDPD; +extern const fcml_cstring M_VANDPS; +extern const fcml_cstring M_VBLENDMPD; +extern const fcml_cstring M_VBLENDMPS; +extern const fcml_cstring M_VBLENDPD; +extern const fcml_cstring M_VBLENDPS; +extern const fcml_cstring M_VBLENDVPD; +extern const fcml_cstring M_VBLENDVPS; +extern const fcml_cstring M_VBROADCASTF128; +extern const fcml_cstring M_VBROADCASTF32X2; +extern const fcml_cstring M_VBROADCASTF32X4; +extern const fcml_cstring M_VBROADCASTF32X8; +extern const fcml_cstring M_VBROADCASTF64X2; +extern const fcml_cstring M_VBROADCASTF64X4; +extern const fcml_cstring M_VBROADCASTI128; +extern const fcml_cstring M_VBROADCASTI32X2; +extern const fcml_cstring M_VBROADCASTI32X4; +extern const fcml_cstring M_VBROADCASTI32X8; +extern const fcml_cstring M_VBROADCASTI64X2; +extern const fcml_cstring M_VBROADCASTI64X4; +extern const fcml_cstring M_VBROADCASTSD; +extern const fcml_cstring M_VBROADCASTSS; +extern const fcml_cstring M_VCMPEQ_OSPD; +extern const fcml_cstring M_VCMPEQ_OSPS; +extern const fcml_cstring M_VCMPEQ_OSSD; +extern const fcml_cstring M_VCMPEQ_OSSS; +extern const fcml_cstring M_VCMPEQ_UQPD; +extern const fcml_cstring M_VCMPEQ_UQPS; +extern const fcml_cstring M_VCMPEQ_UQSD; +extern const fcml_cstring M_VCMPEQ_UQSS; +extern const fcml_cstring M_VCMPEQ_USPD; +extern const fcml_cstring M_VCMPEQ_USPS; +extern const fcml_cstring M_VCMPEQ_USSD; +extern const fcml_cstring M_VCMPEQ_USSS; +extern const fcml_cstring M_VCMPEQPD; +extern const fcml_cstring M_VCMPEQPS; +extern const fcml_cstring M_VCMPEQSD; +extern const fcml_cstring M_VCMPEQSS; +extern const fcml_cstring M_VCMPFALSE_OSPD; +extern const fcml_cstring M_VCMPFALSE_OSPS; +extern const fcml_cstring M_VCMPFALSE_OSSD; +extern const fcml_cstring M_VCMPFALSE_OSSS; +extern const fcml_cstring M_VCMPFALSEPD; +extern const fcml_cstring M_VCMPFALSEPS; +extern const fcml_cstring M_VCMPFALSESD; +extern const fcml_cstring M_VCMPFALSESS; +extern const fcml_cstring M_VCMPGE_OQPD; +extern const fcml_cstring M_VCMPGE_OQPS; +extern const fcml_cstring M_VCMPGE_OQSD; +extern const fcml_cstring M_VCMPGE_OQSS; +extern const fcml_cstring M_VCMPGEPD; +extern const fcml_cstring M_VCMPGEPS; +extern const fcml_cstring M_VCMPGESD; +extern const fcml_cstring M_VCMPGESS; +extern const fcml_cstring M_VCMPGT_OQPD; +extern const fcml_cstring M_VCMPGT_OQPS; +extern const fcml_cstring M_VCMPGT_OQSD; +extern const fcml_cstring M_VCMPGT_OQSS; +extern const fcml_cstring M_VCMPGTPD; +extern const fcml_cstring M_VCMPGTPS; +extern const fcml_cstring M_VCMPGTSD; +extern const fcml_cstring M_VCMPGTSS; +extern const fcml_cstring M_VCMPLE_OQPD; +extern const fcml_cstring M_VCMPLE_OQPS; +extern const fcml_cstring M_VCMPLE_OQSD; +extern const fcml_cstring M_VCMPLE_OQSS; +extern const fcml_cstring M_VCMPLEPD; +extern const fcml_cstring M_VCMPLEPS; +extern const fcml_cstring M_VCMPLESD; +extern const fcml_cstring M_VCMPLESS; +extern const fcml_cstring M_VCMPLT_OQPD; +extern const fcml_cstring M_VCMPLT_OQPS; +extern const fcml_cstring M_VCMPLT_OQSD; +extern const fcml_cstring M_VCMPLT_OQSS; +extern const fcml_cstring M_VCMPLTPD; +extern const fcml_cstring M_VCMPLTPS; +extern const fcml_cstring M_VCMPLTSD; +extern const fcml_cstring M_VCMPLTSS; +extern const fcml_cstring M_VCMPNEQ_OQPD; +extern const fcml_cstring M_VCMPNEQ_OQPS; +extern const fcml_cstring M_VCMPNEQ_OQSD; +extern const fcml_cstring M_VCMPNEQ_OQSS; +extern const fcml_cstring M_VCMPNEQ_OSPD; +extern const fcml_cstring M_VCMPNEQ_OSPS; +extern const fcml_cstring M_VCMPNEQ_OSSD; +extern const fcml_cstring M_VCMPNEQ_OSSS; +extern const fcml_cstring M_VCMPNEQ_USPD; +extern const fcml_cstring M_VCMPNEQ_USPS; +extern const fcml_cstring M_VCMPNEQ_USSD; +extern const fcml_cstring M_VCMPNEQ_USSS; +extern const fcml_cstring M_VCMPNEQPD; +extern const fcml_cstring M_VCMPNEQPS; +extern const fcml_cstring M_VCMPNEQSD; +extern const fcml_cstring M_VCMPNEQSS; +extern const fcml_cstring M_VCMPNGE_UQPD; +extern const fcml_cstring M_VCMPNGE_UQPS; +extern const fcml_cstring M_VCMPNGE_UQSD; +extern const fcml_cstring M_VCMPNGE_UQSS; +extern const fcml_cstring M_VCMPNGEPD; +extern const fcml_cstring M_VCMPNGEPS; +extern const fcml_cstring M_VCMPNGESD; +extern const fcml_cstring M_VCMPNGESS; +extern const fcml_cstring M_VCMPNGT_UQPD; +extern const fcml_cstring M_VCMPNGT_UQPS; +extern const fcml_cstring M_VCMPNGT_UQSD; +extern const fcml_cstring M_VCMPNGT_UQSS; +extern const fcml_cstring M_VCMPNGTPD; +extern const fcml_cstring M_VCMPNGTPS; +extern const fcml_cstring M_VCMPNGTSD; +extern const fcml_cstring M_VCMPNGTSS; +extern const fcml_cstring M_VCMPNLE_UQPD; +extern const fcml_cstring M_VCMPNLE_UQPS; +extern const fcml_cstring M_VCMPNLE_UQSD; +extern const fcml_cstring M_VCMPNLE_UQSS; +extern const fcml_cstring M_VCMPNLEPD; +extern const fcml_cstring M_VCMPNLEPS; +extern const fcml_cstring M_VCMPNLESD; +extern const fcml_cstring M_VCMPNLESS; +extern const fcml_cstring M_VCMPNLT_UQPD; +extern const fcml_cstring M_VCMPNLT_UQPS; +extern const fcml_cstring M_VCMPNLT_UQSD; +extern const fcml_cstring M_VCMPNLT_UQSS; +extern const fcml_cstring M_VCMPNLTPD; +extern const fcml_cstring M_VCMPNLTPS; +extern const fcml_cstring M_VCMPNLTSD; +extern const fcml_cstring M_VCMPNLTSS; +extern const fcml_cstring M_VCMPORD_SPD; +extern const fcml_cstring M_VCMPORD_SPS; +extern const fcml_cstring M_VCMPORD_SSD; +extern const fcml_cstring M_VCMPORD_SSS; +extern const fcml_cstring M_VCMPORDPD; +extern const fcml_cstring M_VCMPORDPS; +extern const fcml_cstring M_VCMPORDSD; +extern const fcml_cstring M_VCMPORDSS; +extern const fcml_cstring M_VCMPPD; +extern const fcml_cstring M_VCMPPS; +extern const fcml_cstring M_VCMPSD; +extern const fcml_cstring M_VCMPSS; +extern const fcml_cstring M_VCMPTRUE_USPD; +extern const fcml_cstring M_VCMPTRUE_USPS; +extern const fcml_cstring M_VCMPTRUE_USSD; +extern const fcml_cstring M_VCMPTRUE_USSS; +extern const fcml_cstring M_VCMPTRUEPD; +extern const fcml_cstring M_VCMPTRUEPS; +extern const fcml_cstring M_VCMPTRUESD; +extern const fcml_cstring M_VCMPTRUESS; +extern const fcml_cstring M_VCMPUNORD_SPD; +extern const fcml_cstring M_VCMPUNORD_SPS; +extern const fcml_cstring M_VCMPUNORD_SSD; +extern const fcml_cstring M_VCMPUNORD_SSS; +extern const fcml_cstring M_VCMPUNORDPD; +extern const fcml_cstring M_VCMPUNORDPS; +extern const fcml_cstring M_VCMPUNORDSD; +extern const fcml_cstring M_VCMPUNORDSS; +extern const fcml_cstring M_VCOMISD; +extern const fcml_cstring M_VCOMISS; +extern const fcml_cstring M_VCOMPRESSPD; +extern const fcml_cstring M_VCOMPRESSPS; +extern const fcml_cstring M_VCVTDQ2PD; +extern const fcml_cstring M_VCVTDQ2PS; +extern const fcml_cstring M_VCVTPD2DQ; +extern const fcml_cstring M_VCVTPD2PS; +extern const fcml_cstring M_VCVTPD2QQ; +extern const fcml_cstring M_VCVTPD2UDQ; +extern const fcml_cstring M_VCVTPD2UQQ; +extern const fcml_cstring M_VCVTPH2PS; +extern const fcml_cstring M_VCVTPS2DQ; +extern const fcml_cstring M_VCVTPS2PD; +extern const fcml_cstring M_VCVTPS2PH; +extern const fcml_cstring M_VCVTPS2QQ; +extern const fcml_cstring M_VCVTPS2UDQ; +extern const fcml_cstring M_VCVTPS2UQQ; +extern const fcml_cstring M_VCVTQQ2PD; +extern const fcml_cstring M_VCVTQQ2PS; +extern const fcml_cstring M_VCVTSD2SI; +extern const fcml_cstring M_VCVTSD2SS; +extern const fcml_cstring M_VCVTSD2USI; +extern const fcml_cstring M_VCVTSI2SD; +extern const fcml_cstring M_VCVTSI2SS; +extern const fcml_cstring M_VCVTSS2SD; +extern const fcml_cstring M_VCVTSS2SI; +extern const fcml_cstring M_VCVTSS2USI; +extern const fcml_cstring M_VCVTTPD2DQ; +extern const fcml_cstring M_VCVTTPD2QQ; +extern const fcml_cstring M_VCVTTPD2UDQ; +extern const fcml_cstring M_VCVTTPD2UQQ; +extern const fcml_cstring M_VCVTTPS2DQ; +extern const fcml_cstring M_VCVTTPS2QQ; +extern const fcml_cstring M_VCVTTPS2UDQ; +extern const fcml_cstring M_VCVTTPS2UQQ; +extern const fcml_cstring M_VCVTTSD2SI; +extern const fcml_cstring M_VCVTTSD2USI; +extern const fcml_cstring M_VCVTTSS2SI; +extern const fcml_cstring M_VCVTTSS2USI; +extern const fcml_cstring M_VCVTUDQ2PD; +extern const fcml_cstring M_VCVTUDQ2PS; +extern const fcml_cstring M_VCVTUQQ2PD; +extern const fcml_cstring M_VCVTUQQ2PS; +extern const fcml_cstring M_VCVTUSI2SD; +extern const fcml_cstring M_VCVTUSI2SS; +extern const fcml_cstring M_VDBPSADBW; +extern const fcml_cstring M_VDIVPD; +extern const fcml_cstring M_VDIVPS; +extern const fcml_cstring M_VDIVSD; +extern const fcml_cstring M_VDIVSS; +extern const fcml_cstring M_VDPPD; +extern const fcml_cstring M_VDPPS; +extern const fcml_cstring M_VERR; +extern const fcml_cstring M_VERW; +extern const fcml_cstring M_VEXP2PD; +extern const fcml_cstring M_VEXP2PS; +extern const fcml_cstring M_VEXPANDPD; +extern const fcml_cstring M_VEXPANDPS; +extern const fcml_cstring M_VEXTRACTF128; +extern const fcml_cstring M_VEXTRACTF32X4; +extern const fcml_cstring M_VEXTRACTF32X8; +extern const fcml_cstring M_VEXTRACTF64X2; +extern const fcml_cstring M_VEXTRACTF64X4; +extern const fcml_cstring M_VEXTRACTI128; +extern const fcml_cstring M_VEXTRACTI32X4; +extern const fcml_cstring M_VEXTRACTI32X8; +extern const fcml_cstring M_VEXTRACTI64X2; +extern const fcml_cstring M_VEXTRACTI64X4; +extern const fcml_cstring M_VEXTRACTPS; +extern const fcml_cstring M_VFIXUPIMMPD; +extern const fcml_cstring M_VFIXUPIMMPS; +extern const fcml_cstring M_VFIXUPIMMSD; +extern const fcml_cstring M_VFIXUPIMMSS; +extern const fcml_cstring M_VFMADD132PD; +extern const fcml_cstring M_VFMADD132PS; +extern const fcml_cstring M_VFMADD132SD; +extern const fcml_cstring M_VFMADD132SS; +extern const fcml_cstring M_VFMADD213PD; +extern const fcml_cstring M_VFMADD213PS; +extern const fcml_cstring M_VFMADD213SD; +extern const fcml_cstring M_VFMADD213SS; +extern const fcml_cstring M_VFMADD231PD; +extern const fcml_cstring M_VFMADD231PS; +extern const fcml_cstring M_VFMADD231SD; +extern const fcml_cstring M_VFMADD231SS; +extern const fcml_cstring M_VFMADDPD; +extern const fcml_cstring M_VFMADDPS; +extern const fcml_cstring M_VFMADDSD; +extern const fcml_cstring M_VFMADDSS; +extern const fcml_cstring M_VFMADDSUB132PD; +extern const fcml_cstring M_VFMADDSUB132PS; +extern const fcml_cstring M_VFMADDSUB213PD; +extern const fcml_cstring M_VFMADDSUB213PS; +extern const fcml_cstring M_VFMADDSUB231PD; +extern const fcml_cstring M_VFMADDSUB231PS; +extern const fcml_cstring M_VFMADDSUBPD; +extern const fcml_cstring M_VFMADDSUBPS; +extern const fcml_cstring M_VFMSUB132PD; +extern const fcml_cstring M_VFMSUB132PS; +extern const fcml_cstring M_VFMSUB132SD; +extern const fcml_cstring M_VFMSUB132SS; +extern const fcml_cstring M_VFMSUB213PD; +extern const fcml_cstring M_VFMSUB213PS; +extern const fcml_cstring M_VFMSUB213SD; +extern const fcml_cstring M_VFMSUB213SS; +extern const fcml_cstring M_VFMSUB231PD; +extern const fcml_cstring M_VFMSUB231PS; +extern const fcml_cstring M_VFMSUB231SD; +extern const fcml_cstring M_VFMSUB231SS; +extern const fcml_cstring M_VFMSUBADD132PD; +extern const fcml_cstring M_VFMSUBADD132PS; +extern const fcml_cstring M_VFMSUBADD213PD; +extern const fcml_cstring M_VFMSUBADD213PS; +extern const fcml_cstring M_VFMSUBADD231PD; +extern const fcml_cstring M_VFMSUBADD231PS; +extern const fcml_cstring M_VFMSUBADDPD; +extern const fcml_cstring M_VFMSUBADDPS; +extern const fcml_cstring M_VFMSUBPD; +extern const fcml_cstring M_VFMSUBPS; +extern const fcml_cstring M_VFMSUBSD; +extern const fcml_cstring M_VFMSUBSS; +extern const fcml_cstring M_VFNMADD132PD; +extern const fcml_cstring M_VFNMADD132PS; +extern const fcml_cstring M_VFNMADD132SD; +extern const fcml_cstring M_VFNMADD132SS; +extern const fcml_cstring M_VFNMADD213PD; +extern const fcml_cstring M_VFNMADD213PS; +extern const fcml_cstring M_VFNMADD213SD; +extern const fcml_cstring M_VFNMADD213SS; +extern const fcml_cstring M_VFNMADD231PD; +extern const fcml_cstring M_VFNMADD231PS; +extern const fcml_cstring M_VFNMADD231SD; +extern const fcml_cstring M_VFNMADD231SS; +extern const fcml_cstring M_VFNMADDPD; +extern const fcml_cstring M_VFNMADDPS; +extern const fcml_cstring M_VFNMADDSD; +extern const fcml_cstring M_VFNMADDSS; +extern const fcml_cstring M_VFNMSUB132PD; +extern const fcml_cstring M_VFNMSUB132PS; +extern const fcml_cstring M_VFNMSUB132SD; +extern const fcml_cstring M_VFNMSUB132SS; +extern const fcml_cstring M_VFNMSUB213PD; +extern const fcml_cstring M_VFNMSUB213PS; +extern const fcml_cstring M_VFNMSUB213SD; +extern const fcml_cstring M_VFNMSUB213SS; +extern const fcml_cstring M_VFNMSUB231PD; +extern const fcml_cstring M_VFNMSUB231PS; +extern const fcml_cstring M_VFNMSUB231SD; +extern const fcml_cstring M_VFNMSUB231SS; +extern const fcml_cstring M_VFNMSUBPD; +extern const fcml_cstring M_VFNMSUBPS; +extern const fcml_cstring M_VFNMSUBSD; +extern const fcml_cstring M_VFNMSUBSS; +extern const fcml_cstring M_VFPCLASSPD; +extern const fcml_cstring M_VFPCLASSPS; +extern const fcml_cstring M_VFPCLASSSD; +extern const fcml_cstring M_VFPCLASSSS; +extern const fcml_cstring M_VFRCZPD; +extern const fcml_cstring M_VFRCZPS; +extern const fcml_cstring M_VFRCZSD; +extern const fcml_cstring M_VFRCZSS; +extern const fcml_cstring M_VGATHERDPD; +extern const fcml_cstring M_VGATHERDPS; +extern const fcml_cstring M_VGATHERPF0DPD; +extern const fcml_cstring M_VGATHERPF0DPS; +extern const fcml_cstring M_VGATHERPF0QPD; +extern const fcml_cstring M_VGATHERPF0QPS; +extern const fcml_cstring M_VGATHERPF1DPD; +extern const fcml_cstring M_VGATHERPF1DPS; +extern const fcml_cstring M_VGATHERPF1QPD; +extern const fcml_cstring M_VGATHERPF1QPS; +extern const fcml_cstring M_VGATHERQPD; +extern const fcml_cstring M_VGATHERQPS; +extern const fcml_cstring M_VGETEXPPD; +extern const fcml_cstring M_VGETEXPPS; +extern const fcml_cstring M_VGETEXPSD; +extern const fcml_cstring M_VGETEXPSS; +extern const fcml_cstring M_VGETMANTPD; +extern const fcml_cstring M_VGETMANTPS; +extern const fcml_cstring M_VGETMANTSD; +extern const fcml_cstring M_VGETMANTSS; +extern const fcml_cstring M_VHADDPD; +extern const fcml_cstring M_VHADDPS; +extern const fcml_cstring M_VHSUBPD; +extern const fcml_cstring M_VHSUBPS; +extern const fcml_cstring M_VINSERTF128; +extern const fcml_cstring M_VINSERTF32X4; +extern const fcml_cstring M_VINSERTF32X8; +extern const fcml_cstring M_VINSERTF64X2; +extern const fcml_cstring M_VINSERTF64X4; +extern const fcml_cstring M_VINSERTI128; +extern const fcml_cstring M_VINSERTI32X4; +extern const fcml_cstring M_VINSERTI32X8; +extern const fcml_cstring M_VINSERTI64X2; +extern const fcml_cstring M_VINSERTI64X4; +extern const fcml_cstring M_VINSERTPS; +extern const fcml_cstring M_VLDDQU; +extern const fcml_cstring M_VLDMXCSR; +extern const fcml_cstring M_VMASKMOVDQU; +extern const fcml_cstring M_VMASKMOVPD; +extern const fcml_cstring M_VMASKMOVPS; +extern const fcml_cstring M_VMAXPD; +extern const fcml_cstring M_VMAXPS; +extern const fcml_cstring M_VMAXSD; +extern const fcml_cstring M_VMAXSS; +extern const fcml_cstring M_VMCALL; +extern const fcml_cstring M_VMCLEAR; +extern const fcml_cstring M_VMFUNC; +extern const fcml_cstring M_VMINPD; +extern const fcml_cstring M_VMINPS; +extern const fcml_cstring M_VMINSD; +extern const fcml_cstring M_VMINSS; +extern const fcml_cstring M_VMLAUNCH; +extern const fcml_cstring M_VMLOAD; +extern const fcml_cstring M_VMMCALL; +extern const fcml_cstring M_VMOVAPD; +extern const fcml_cstring M_VMOVAPS; +extern const fcml_cstring M_VMOVD; +extern const fcml_cstring M_VMOVDDUP; +extern const fcml_cstring M_VMOVDQA; +extern const fcml_cstring M_VMOVDQA32; +extern const fcml_cstring M_VMOVDQA64; +extern const fcml_cstring M_VMOVDQU; +extern const fcml_cstring M_VMOVDQU16; +extern const fcml_cstring M_VMOVDQU32; +extern const fcml_cstring M_VMOVDQU64; +extern const fcml_cstring M_VMOVDQU8; +extern const fcml_cstring M_VMOVHLPS; +extern const fcml_cstring M_VMOVHPD; +extern const fcml_cstring M_VMOVHPS; +extern const fcml_cstring M_VMOVLHPS; +extern const fcml_cstring M_VMOVLPD; +extern const fcml_cstring M_VMOVLPS; +extern const fcml_cstring M_VMOVMSKPD; +extern const fcml_cstring M_VMOVMSKPS; +extern const fcml_cstring M_VMOVNTDQ; +extern const fcml_cstring M_VMOVNTDQA; +extern const fcml_cstring M_VMOVNTPD; +extern const fcml_cstring M_VMOVNTPS; +extern const fcml_cstring M_VMOVQ; +extern const fcml_cstring M_VMOVSD; +extern const fcml_cstring M_VMOVSHDUP; +extern const fcml_cstring M_VMOVSLDUP; +extern const fcml_cstring M_VMOVSS; +extern const fcml_cstring M_VMOVUPD; +extern const fcml_cstring M_VMOVUPS; +extern const fcml_cstring M_VMPSADBW; +extern const fcml_cstring M_VMPTRLD; +extern const fcml_cstring M_VMPTRST; +extern const fcml_cstring M_VMREAD; +extern const fcml_cstring M_VMRESUME; +extern const fcml_cstring M_VMRUN; +extern const fcml_cstring M_VMSAVE; +extern const fcml_cstring M_VMULPD; +extern const fcml_cstring M_VMULPS; +extern const fcml_cstring M_VMULSD; +extern const fcml_cstring M_VMULSS; +extern const fcml_cstring M_VMWRITE; +extern const fcml_cstring M_VMXOFF; +extern const fcml_cstring M_VMXON; +extern const fcml_cstring M_VORPD; +extern const fcml_cstring M_VORPS; +extern const fcml_cstring M_VP4DPWSSD; +extern const fcml_cstring M_VP4DPWSSDS; +extern const fcml_cstring M_VPABSB; +extern const fcml_cstring M_VPABSD; +extern const fcml_cstring M_VPABSQ; +extern const fcml_cstring M_VPABSW; +extern const fcml_cstring M_VPACKSSDW; +extern const fcml_cstring M_VPACKSSWB; +extern const fcml_cstring M_VPACKUSDW; +extern const fcml_cstring M_VPACKUSWB; +extern const fcml_cstring M_VPADDB; +extern const fcml_cstring M_VPADDD; +extern const fcml_cstring M_VPADDQ; +extern const fcml_cstring M_VPADDSB; +extern const fcml_cstring M_VPADDSW; +extern const fcml_cstring M_VPADDUSB; +extern const fcml_cstring M_VPADDUSW; +extern const fcml_cstring M_VPADDW; +extern const fcml_cstring M_VPALIGNR; +extern const fcml_cstring M_VPAND; +extern const fcml_cstring M_VPANDD; +extern const fcml_cstring M_VPANDN; +extern const fcml_cstring M_VPANDND; +extern const fcml_cstring M_VPANDNQ; +extern const fcml_cstring M_VPANDQ; +extern const fcml_cstring M_VPAVGB; +extern const fcml_cstring M_VPAVGW; +extern const fcml_cstring M_VPBLENDD; +extern const fcml_cstring M_VPBLENDMB; +extern const fcml_cstring M_VPBLENDMD; +extern const fcml_cstring M_VPBLENDMQ; +extern const fcml_cstring M_VPBLENDMW; +extern const fcml_cstring M_VPBLENDVB; +extern const fcml_cstring M_VPBLENDW; +extern const fcml_cstring M_VPBROADCASTB; +extern const fcml_cstring M_VPBROADCASTD; +extern const fcml_cstring M_VPBROADCASTMB2Q; +extern const fcml_cstring M_VPBROADCASTMW2D; +extern const fcml_cstring M_VPBROADCASTQ; +extern const fcml_cstring M_VPBROADCASTW; +extern const fcml_cstring M_VPCLMULQDQ; +extern const fcml_cstring M_VPCMOV; +extern const fcml_cstring M_VPCMPB; +extern const fcml_cstring M_VPCMPD; +extern const fcml_cstring M_VPCMPEQB; +extern const fcml_cstring M_VPCMPEQD; +extern const fcml_cstring M_VPCMPEQQ; +extern const fcml_cstring M_VPCMPEQW; +extern const fcml_cstring M_VPCMPESTRI; +extern const fcml_cstring M_VPCMPESTRM; +extern const fcml_cstring M_VPCMPGTB; +extern const fcml_cstring M_VPCMPGTD; +extern const fcml_cstring M_VPCMPGTQ; +extern const fcml_cstring M_VPCMPGTW; +extern const fcml_cstring M_VPCMPISTRI; +extern const fcml_cstring M_VPCMPISTRM; +extern const fcml_cstring M_VPCMPQ; +extern const fcml_cstring M_VPCMPUB; +extern const fcml_cstring M_VPCMPUD; +extern const fcml_cstring M_VPCMPUQ; +extern const fcml_cstring M_VPCMPUW; +extern const fcml_cstring M_VPCMPW; +extern const fcml_cstring M_VPCOMB; +extern const fcml_cstring M_VPCOMD; +extern const fcml_cstring M_VPCOMEQB; +extern const fcml_cstring M_VPCOMEQD; +extern const fcml_cstring M_VPCOMEQQ; +extern const fcml_cstring M_VPCOMEQUB; +extern const fcml_cstring M_VPCOMEQUD; +extern const fcml_cstring M_VPCOMEQUQ; +extern const fcml_cstring M_VPCOMEQUW; +extern const fcml_cstring M_VPCOMEQW; +extern const fcml_cstring M_VPCOMFALSEB; +extern const fcml_cstring M_VPCOMFALSED; +extern const fcml_cstring M_VPCOMFALSEQ; +extern const fcml_cstring M_VPCOMFALSEUB; +extern const fcml_cstring M_VPCOMFALSEUD; +extern const fcml_cstring M_VPCOMFALSEUQ; +extern const fcml_cstring M_VPCOMFALSEUW; +extern const fcml_cstring M_VPCOMFALSEW; +extern const fcml_cstring M_VPCOMGEB; +extern const fcml_cstring M_VPCOMGED; +extern const fcml_cstring M_VPCOMGEQ; +extern const fcml_cstring M_VPCOMGEUB; +extern const fcml_cstring M_VPCOMGEUD; +extern const fcml_cstring M_VPCOMGEUQ; +extern const fcml_cstring M_VPCOMGEUW; +extern const fcml_cstring M_VPCOMGEW; +extern const fcml_cstring M_VPCOMGTB; +extern const fcml_cstring M_VPCOMGTD; +extern const fcml_cstring M_VPCOMGTQ; +extern const fcml_cstring M_VPCOMGTUB; +extern const fcml_cstring M_VPCOMGTUD; +extern const fcml_cstring M_VPCOMGTUQ; +extern const fcml_cstring M_VPCOMGTUW; +extern const fcml_cstring M_VPCOMGTW; +extern const fcml_cstring M_VPCOMLEB; +extern const fcml_cstring M_VPCOMLED; +extern const fcml_cstring M_VPCOMLEQ; +extern const fcml_cstring M_VPCOMLEUB; +extern const fcml_cstring M_VPCOMLEUD; +extern const fcml_cstring M_VPCOMLEUQ; +extern const fcml_cstring M_VPCOMLEUW; +extern const fcml_cstring M_VPCOMLEW; +extern const fcml_cstring M_VPCOMLTB; +extern const fcml_cstring M_VPCOMLTD; +extern const fcml_cstring M_VPCOMLTQ; +extern const fcml_cstring M_VPCOMLTUB; +extern const fcml_cstring M_VPCOMLTUD; +extern const fcml_cstring M_VPCOMLTUQ; +extern const fcml_cstring M_VPCOMLTUW; +extern const fcml_cstring M_VPCOMLTW; +extern const fcml_cstring M_VPCOMNEQB; +extern const fcml_cstring M_VPCOMNEQD; +extern const fcml_cstring M_VPCOMNEQQ; +extern const fcml_cstring M_VPCOMNEQUB; +extern const fcml_cstring M_VPCOMNEQUD; +extern const fcml_cstring M_VPCOMNEQUQ; +extern const fcml_cstring M_VPCOMNEQUW; +extern const fcml_cstring M_VPCOMNEQW; +extern const fcml_cstring M_VPCOMPRESSD; +extern const fcml_cstring M_VPCOMPRESSQ; +extern const fcml_cstring M_VPCOMQ; +extern const fcml_cstring M_VPCOMTRUEB; +extern const fcml_cstring M_VPCOMTRUED; +extern const fcml_cstring M_VPCOMTRUEQ; +extern const fcml_cstring M_VPCOMTRUEUB; +extern const fcml_cstring M_VPCOMTRUEUD; +extern const fcml_cstring M_VPCOMTRUEUQ; +extern const fcml_cstring M_VPCOMTRUEUW; +extern const fcml_cstring M_VPCOMTRUEW; +extern const fcml_cstring M_VPCOMUB; +extern const fcml_cstring M_VPCOMUD; +extern const fcml_cstring M_VPCOMUQ; +extern const fcml_cstring M_VPCOMUW; +extern const fcml_cstring M_VPCOMW; +extern const fcml_cstring M_VPERM2F128; +extern const fcml_cstring M_VPERM2I128; +extern const fcml_cstring M_VPERMB; +extern const fcml_cstring M_VPERMD; +extern const fcml_cstring M_VPERMI2B; +extern const fcml_cstring M_VPERMI2D; +extern const fcml_cstring M_VPERMI2PD; +extern const fcml_cstring M_VPERMI2PS; +extern const fcml_cstring M_VPERMI2Q; +extern const fcml_cstring M_VPERMI2W; +extern const fcml_cstring M_VPERMIL2PD; +extern const fcml_cstring M_VPERMIL2PS; +extern const fcml_cstring M_VPERMILPD; +extern const fcml_cstring M_VPERMILPS; +extern const fcml_cstring M_VPERMPD; +extern const fcml_cstring M_VPERMPS; +extern const fcml_cstring M_VPERMQ; +extern const fcml_cstring M_VPERMT2B; +extern const fcml_cstring M_VPERMT2D; +extern const fcml_cstring M_VPERMT2PD; +extern const fcml_cstring M_VPERMT2PS; +extern const fcml_cstring M_VPERMT2Q; +extern const fcml_cstring M_VPERMT2W; +extern const fcml_cstring M_VPERMW; +extern const fcml_cstring M_VPEXPANDD; +extern const fcml_cstring M_VPEXPANDQ; +extern const fcml_cstring M_VPEXTRB; +extern const fcml_cstring M_VPEXTRD; +extern const fcml_cstring M_VPEXTRQ; +extern const fcml_cstring M_VPEXTRW; +extern const fcml_cstring M_VPGATHERDD; +extern const fcml_cstring M_VPGATHERDQ; +extern const fcml_cstring M_VPGATHERQD; +extern const fcml_cstring M_VPGATHERQQ; +extern const fcml_cstring M_VPHADDBD; +extern const fcml_cstring M_VPHADDBQ; +extern const fcml_cstring M_VPHADDBW; +extern const fcml_cstring M_VPHADDD; +extern const fcml_cstring M_VPHADDDQ; +extern const fcml_cstring M_VPHADDSW; +extern const fcml_cstring M_VPHADDUBD; +extern const fcml_cstring M_VPHADDUBQ; +extern const fcml_cstring M_VPHADDUBW; +extern const fcml_cstring M_VPHADDUDQ; +extern const fcml_cstring M_VPHADDUWD; +extern const fcml_cstring M_VPHADDUWQ; +extern const fcml_cstring M_VPHADDW; +extern const fcml_cstring M_VPHADDWD; +extern const fcml_cstring M_VPHADDWQ; +extern const fcml_cstring M_VPHMINPOSUW; +extern const fcml_cstring M_VPHSUBBW; +extern const fcml_cstring M_VPHSUBD; +extern const fcml_cstring M_VPHSUBDQ; +extern const fcml_cstring M_VPHSUBSW; +extern const fcml_cstring M_VPHSUBW; +extern const fcml_cstring M_VPHSUBWD; +extern const fcml_cstring M_VPINSRB; +extern const fcml_cstring M_VPINSRD; +extern const fcml_cstring M_VPINSRQ; +extern const fcml_cstring M_VPINSRW; +extern const fcml_cstring M_VPLZCNTD; +extern const fcml_cstring M_VPLZCNTQ; +extern const fcml_cstring M_VPMACSDD; +extern const fcml_cstring M_VPMACSDQH; +extern const fcml_cstring M_VPMACSDQL; +extern const fcml_cstring M_VPMACSSDD; +extern const fcml_cstring M_VPMACSSDQH; +extern const fcml_cstring M_VPMACSSDQL; +extern const fcml_cstring M_VPMACSSWD; +extern const fcml_cstring M_VPMACSSWW; +extern const fcml_cstring M_VPMACSWD; +extern const fcml_cstring M_VPMACSWW; +extern const fcml_cstring M_VPMADCSSWD; +extern const fcml_cstring M_VPMADCSWD; +extern const fcml_cstring M_VPMADD52HUQ; +extern const fcml_cstring M_VPMADD52LUQ; +extern const fcml_cstring M_VPMADDUBSW; +extern const fcml_cstring M_VPMADDWD; +extern const fcml_cstring M_VPMASKMOV; +extern const fcml_cstring M_VPMASKMOVD; +extern const fcml_cstring M_VPMASKMOVQ; +extern const fcml_cstring M_VPMAXSB; +extern const fcml_cstring M_VPMAXSD; +extern const fcml_cstring M_VPMAXSQ; +extern const fcml_cstring M_VPMAXSW; +extern const fcml_cstring M_VPMAXUB; +extern const fcml_cstring M_VPMAXUD; +extern const fcml_cstring M_VPMAXUQ; +extern const fcml_cstring M_VPMAXUW; +extern const fcml_cstring M_VPMINSB; +extern const fcml_cstring M_VPMINSD; +extern const fcml_cstring M_VPMINSQ; +extern const fcml_cstring M_VPMINSW; +extern const fcml_cstring M_VPMINUB; +extern const fcml_cstring M_VPMINUD; +extern const fcml_cstring M_VPMINUQ; +extern const fcml_cstring M_VPMINUW; +extern const fcml_cstring M_VPMOVB2M; +extern const fcml_cstring M_VPMOVD2M; +extern const fcml_cstring M_VPMOVDB; +extern const fcml_cstring M_VPMOVDW; +extern const fcml_cstring M_VPMOVM2B; +extern const fcml_cstring M_VPMOVM2D; +extern const fcml_cstring M_VPMOVM2Q; +extern const fcml_cstring M_VPMOVM2W; +extern const fcml_cstring M_VPMOVMSKB; +extern const fcml_cstring M_VPMOVQ2M; +extern const fcml_cstring M_VPMOVQB; +extern const fcml_cstring M_VPMOVQD; +extern const fcml_cstring M_VPMOVQW; +extern const fcml_cstring M_VPMOVSDB; +extern const fcml_cstring M_VPMOVSDW; +extern const fcml_cstring M_VPMOVSQB; +extern const fcml_cstring M_VPMOVSQD; +extern const fcml_cstring M_VPMOVSQW; +extern const fcml_cstring M_VPMOVSWB; +extern const fcml_cstring M_VPMOVSXBD; +extern const fcml_cstring M_VPMOVSXBQ; +extern const fcml_cstring M_VPMOVSXBW; +extern const fcml_cstring M_VPMOVSXDQ; +extern const fcml_cstring M_VPMOVSXWD; +extern const fcml_cstring M_VPMOVSXWQ; +extern const fcml_cstring M_VPMOVUSDB; +extern const fcml_cstring M_VPMOVUSDW; +extern const fcml_cstring M_VPMOVUSQB; +extern const fcml_cstring M_VPMOVUSQD; +extern const fcml_cstring M_VPMOVUSQW; +extern const fcml_cstring M_VPMOVUSWB; +extern const fcml_cstring M_VPMOVW2M; +extern const fcml_cstring M_VPMOVWB; +extern const fcml_cstring M_VPMOVZXBD; +extern const fcml_cstring M_VPMOVZXBQ; +extern const fcml_cstring M_VPMOVZXBW; +extern const fcml_cstring M_VPMOVZXDQ; +extern const fcml_cstring M_VPMOVZXWD; +extern const fcml_cstring M_VPMOVZXWQ; +extern const fcml_cstring M_VPMULDQ; +extern const fcml_cstring M_VPMULHRSW; +extern const fcml_cstring M_VPMULHUW; +extern const fcml_cstring M_VPMULHW; +extern const fcml_cstring M_VPMULLD; +extern const fcml_cstring M_VPMULLQ; +extern const fcml_cstring M_VPMULLW; +extern const fcml_cstring M_VPMULTISHIFTQB; +extern const fcml_cstring M_VPMULUDQ; +extern const fcml_cstring M_VPOR; +extern const fcml_cstring M_VPORD; +extern const fcml_cstring M_VPORQ; +extern const fcml_cstring M_VPPERM; +extern const fcml_cstring M_VPROLD; +extern const fcml_cstring M_VPROLQ; +extern const fcml_cstring M_VPROLVD; +extern const fcml_cstring M_VPROLVQ; +extern const fcml_cstring M_VPRORD; +extern const fcml_cstring M_VPRORQ; +extern const fcml_cstring M_VPRORVD; +extern const fcml_cstring M_VPRORVQ; +extern const fcml_cstring M_VPROTB; +extern const fcml_cstring M_VPROTD; +extern const fcml_cstring M_VPROTQ; +extern const fcml_cstring M_VPROTW; +extern const fcml_cstring M_VPSADBW; +extern const fcml_cstring M_VPSCATTERDD; +extern const fcml_cstring M_VPSCATTERDQ; +extern const fcml_cstring M_VPSCATTERQD; +extern const fcml_cstring M_VPSCATTERQQ; +extern const fcml_cstring M_VPSHAB; +extern const fcml_cstring M_VPSHAD; +extern const fcml_cstring M_VPSHAQ; +extern const fcml_cstring M_VPSHAW; +extern const fcml_cstring M_VPSHLB; +extern const fcml_cstring M_VPSHLD; +extern const fcml_cstring M_VPSHLQ; +extern const fcml_cstring M_VPSHLW; +extern const fcml_cstring M_VPSHUFB; +extern const fcml_cstring M_VPSHUFD; +extern const fcml_cstring M_VPSHUFHW; +extern const fcml_cstring M_VPSHUFLW; +extern const fcml_cstring M_VPSIGNB; +extern const fcml_cstring M_VPSIGND; +extern const fcml_cstring M_VPSIGNW; +extern const fcml_cstring M_VPSLLD; +extern const fcml_cstring M_VPSLLDQ; +extern const fcml_cstring M_VPSLLQ; +extern const fcml_cstring M_VPSLLVD; +extern const fcml_cstring M_VPSLLVQ; +extern const fcml_cstring M_VPSLLVW; +extern const fcml_cstring M_VPSLLW; +extern const fcml_cstring M_VPSRAD; +extern const fcml_cstring M_VPSRAQ; +extern const fcml_cstring M_VPSRAVD; +extern const fcml_cstring M_VPSRAVQ; +extern const fcml_cstring M_VPSRAVW; +extern const fcml_cstring M_VPSRAW; +extern const fcml_cstring M_VPSRLD; +extern const fcml_cstring M_VPSRLDQ; +extern const fcml_cstring M_VPSRLQ; +extern const fcml_cstring M_VPSRLVD; +extern const fcml_cstring M_VPSRLVQ; +extern const fcml_cstring M_VPSRLVW; +extern const fcml_cstring M_VPSRLW; +extern const fcml_cstring M_VPSUBB; +extern const fcml_cstring M_VPSUBD; +extern const fcml_cstring M_VPSUBQ; +extern const fcml_cstring M_VPSUBSB; +extern const fcml_cstring M_VPSUBSW; +extern const fcml_cstring M_VPSUBUSB; +extern const fcml_cstring M_VPSUBUSW; +extern const fcml_cstring M_VPSUBW; +extern const fcml_cstring M_VPTERNLOGD; +extern const fcml_cstring M_VPTERNLOGQ; +extern const fcml_cstring M_VPTEST; +extern const fcml_cstring M_VPTESTMB; +extern const fcml_cstring M_VPTESTMD; +extern const fcml_cstring M_VPTESTMQ; +extern const fcml_cstring M_VPTESTMW; +extern const fcml_cstring M_VPTESTNMB; +extern const fcml_cstring M_VPTESTNMD; +extern const fcml_cstring M_VPTESTNMQ; +extern const fcml_cstring M_VPTESTNMW; +extern const fcml_cstring M_VPUNPCKHBW; +extern const fcml_cstring M_VPUNPCKHDQ; +extern const fcml_cstring M_VPUNPCKHQDQ; +extern const fcml_cstring M_VPUNPCKHWD; +extern const fcml_cstring M_VPUNPCKLBW; +extern const fcml_cstring M_VPUNPCKLDQ; +extern const fcml_cstring M_VPUNPCKLQDQ; +extern const fcml_cstring M_VPUNPCKLWD; +extern const fcml_cstring M_VPXOR; +extern const fcml_cstring M_VPXORD; +extern const fcml_cstring M_VPXORQ; +extern const fcml_cstring M_VRANGEPD; +extern const fcml_cstring M_VRANGEPS; +extern const fcml_cstring M_VRANGESD; +extern const fcml_cstring M_VRANGESS; +extern const fcml_cstring M_VRCP14PD; +extern const fcml_cstring M_VRCP14PS; +extern const fcml_cstring M_VRCP14SD; +extern const fcml_cstring M_VRCP14SS; +extern const fcml_cstring M_VRCP28PD; +extern const fcml_cstring M_VRCP28PS; +extern const fcml_cstring M_VRCP28SD; +extern const fcml_cstring M_VRCP28SS; +extern const fcml_cstring M_VRCPPS; +extern const fcml_cstring M_VRCPSS; +extern const fcml_cstring M_VREDUCEPD; +extern const fcml_cstring M_VREDUCEPS; +extern const fcml_cstring M_VREDUCESD; +extern const fcml_cstring M_VREDUCESS; +extern const fcml_cstring M_VRNDSCALEPD; +extern const fcml_cstring M_VRNDSCALEPS; +extern const fcml_cstring M_VRNDSCALESD; +extern const fcml_cstring M_VRNDSCALESS; +extern const fcml_cstring M_VROUNDPD; +extern const fcml_cstring M_VROUNDPS; +extern const fcml_cstring M_VROUNDSD; +extern const fcml_cstring M_VROUNDSS; +extern const fcml_cstring M_VRSQRT14PD; +extern const fcml_cstring M_VRSQRT14PS; +extern const fcml_cstring M_VRSQRT14SD; +extern const fcml_cstring M_VRSQRT14SS; +extern const fcml_cstring M_VRSQRT28PD; +extern const fcml_cstring M_VRSQRT28PS; +extern const fcml_cstring M_VRSQRT28SD; +extern const fcml_cstring M_VRSQRT28SS; +extern const fcml_cstring M_VRSQRTPS; +extern const fcml_cstring M_VRSQRTSS; +extern const fcml_cstring M_VSCALEFPD; +extern const fcml_cstring M_VSCALEFPS; +extern const fcml_cstring M_VSCALEFSD; +extern const fcml_cstring M_VSCALEFSS; +extern const fcml_cstring M_VSCATTERDPD; +extern const fcml_cstring M_VSCATTERDPS; +extern const fcml_cstring M_VSCATTERPF0DPD; +extern const fcml_cstring M_VSCATTERPF0DPS; +extern const fcml_cstring M_VSCATTERPF0QPD; +extern const fcml_cstring M_VSCATTERPF0QPS; +extern const fcml_cstring M_VSCATTERPF1DPD; +extern const fcml_cstring M_VSCATTERPF1DPS; +extern const fcml_cstring M_VSCATTERPF1QPD; +extern const fcml_cstring M_VSCATTERPF1QPS; +extern const fcml_cstring M_VSCATTERQPD; +extern const fcml_cstring M_VSCATTERQPS; +extern const fcml_cstring M_VSHUFF32X4; +extern const fcml_cstring M_VSHUFF64X2; +extern const fcml_cstring M_VSHUFI32X4; +extern const fcml_cstring M_VSHUFI64X2; +extern const fcml_cstring M_VSHUFPD; +extern const fcml_cstring M_VSHUFPS; +extern const fcml_cstring M_VSQRTPD; +extern const fcml_cstring M_VSQRTPS; +extern const fcml_cstring M_VSQRTSD; +extern const fcml_cstring M_VSQRTSS; +extern const fcml_cstring M_VSTMXCSR; +extern const fcml_cstring M_VSUBPD; +extern const fcml_cstring M_VSUBPS; +extern const fcml_cstring M_VSUBSD; +extern const fcml_cstring M_VSUBSS; +extern const fcml_cstring M_VTESTPD; +extern const fcml_cstring M_VTESTPS; +extern const fcml_cstring M_VUCOMISD; +extern const fcml_cstring M_VUCOMISS; +extern const fcml_cstring M_VUNPCKHPD; +extern const fcml_cstring M_VUNPCKHPS; +extern const fcml_cstring M_VUNPCKLPD; +extern const fcml_cstring M_VUNPCKLPS; +extern const fcml_cstring M_VXORPD; +extern const fcml_cstring M_VXORPS; +extern const fcml_cstring M_VZEROALL; +extern const fcml_cstring M_VZEROUPPER; +extern const fcml_cstring M_WAIT; +extern const fcml_cstring M_WBINVD; +extern const fcml_cstring M_WRFSBASE; +extern const fcml_cstring M_WRGSBASE; +extern const fcml_cstring M_WRMSR; +extern const fcml_cstring M_XABORT; +extern const fcml_cstring M_XADD; +extern const fcml_cstring M_XBEGIN; +extern const fcml_cstring M_XCHG; +extern const fcml_cstring M_XEND; +extern const fcml_cstring M_XGETBV; +extern const fcml_cstring M_XLAT; +extern const fcml_cstring M_XLATB; +extern const fcml_cstring M_XOR; +extern const fcml_cstring M_XORPD; +extern const fcml_cstring M_XORPS; +extern const fcml_cstring M_XRSTOR; +extern const fcml_cstring M_XRSTOR64; +extern const fcml_cstring M_XSAVE; +extern const fcml_cstring M_XSAVE64; +extern const fcml_cstring M_XSAVEOPT; +extern const fcml_cstring M_XSAVEOPT64; +extern const fcml_cstring M_XSETBV; +extern const fcml_cstring M_XTEST; + +} +} + +#endif /* FCML_INTEL_MNEMONICS_HPP_ */ + diff --git a/dependencies/fcml/include/fcml_lag_assembler.h b/dependencies/fcml/include/fcml_lag_assembler.h new file mode 100644 index 0000000..760347a --- /dev/null +++ b/dependencies/fcml/include/fcml_lag_assembler.h @@ -0,0 +1,121 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_lag_assembler.h + * Experimental multiline load-and-go assembler implementation. + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_LAG_ASSEMBLER_H_ +#define FCML_LAG_ASSEMBLER_H_ + +#include "fcml_symbols.h" +#include "fcml_assembler.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Result holder for load-and-go assembler. */ +typedef struct fcml_st_lag_assembler_result { + /** Error and warning messages from one-line assembler. */ + fcml_st_ceh_error_container errors; + /** Number of line where assembler failed. */ + fcml_int error_line; + /** Chain of assembled instructions.*/ + fcml_st_assembled_instruction *instructions; +} fcml_st_lag_assembler_result; + +/** Load-and-go assembler runtime context. */ +typedef struct fcml_st_lag_assembler_context { + /** Assembler instance that should be used to assemble instructions. */ + fcml_st_assembler *assembler; + /** Assembler behavior can be configured here.*/ + fcml_st_assembler_conf configuration; + /** Instruction entry point configuration. */ + fcml_st_entry_point entry_point; + /** Symbols table. */ + fcml_st_symbol_table symbol_table; +} fcml_st_lag_assembler_context; + +/** + * Multipass load-and-go assembler. + * Assembles all instructions given in the NULL terminated source_code + * array of strings. Every instruction has to be represented as one string + * in the source array. Like every multipass assembler implementation it + * passes through the source code multiple times in order to generate optimal + * code. Assembler also supports symbols that can be provided using symbol + * table available in the context. Context should be initialized the same way + * as in case of one line assembler. The only difference here is the symbol + * table itself which can be initialized using fcml_fn_symbol_table_alloc() + * function. Symbols can be also declared directly in the source code and + * accessed through the same symbols table when processing is done (Only if + * you provide valid symbol table through the context). Reusable result holder + * has to be prepared using fcml_fn_lag_assembler_result_prepare() function. + * As long as the context and the result holder are not shared across multiple + * calls function is thread safe. + * + * @param context Assembler context. + * @param source_code NULL terminated array of the instructions. + * @param result Reusable result holder. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * @warning This is an experimental implementation and it still needs + * some testing. + * @see fcml_fn_lag_assembler_result_prepare + * @see fcml_fn_symbol_table_alloc + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_lag_assemble( + fcml_st_lag_assembler_context *context, const fcml_string *source_code, + fcml_st_lag_assembler_result *result); + +/** + * Prepares reusable result holder for assembler. + * Every instance of fcml_st_lag_assembler_result structure is reusable from + * the assembler's point of view, so it has to be prepared in the right way in + * order to allow assembler to reuse it correctly. It is up to the library user + * to allocate space for the holder itself. This function is only responsible + * for cleaning the structure correctly and preparing it for first assembling + * process. Notice that assembler has to clean the result holder at the + * beginning so you can not pass an uninitialized memory block because it can + * even cause a crash due to illegal memory access. + * + * @param result Result holder instance to be prepared. + */ +LIB_EXPORT void LIB_CALL fcml_fn_lag_assembler_result_prepare( + fcml_st_lag_assembler_result *result); + +/** + * Cleans result holder. + * Frees all memory blocks allocated by the assembler and held inside the + * result holder (Instructions, errors etc.). Notice that result holder itself + * is not freed and can be even safety reused after call to this function. In + * fact this function is also called internally by assembler in order to clean + * result holder before + * reusing it. + * @param result Result holder to clean. + */ +LIB_EXPORT void LIB_CALL fcml_fn_lag_assembler_result_free( + fcml_st_lag_assembler_result *result); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_LAG_ASSEMBLER_H_ */ diff --git a/dependencies/fcml/include/fcml_lag_assembler.hpp b/dependencies/fcml/include/fcml_lag_assembler.hpp new file mode 100644 index 0000000..62a03fe --- /dev/null +++ b/dependencies/fcml/include/fcml_lag_assembler.hpp @@ -0,0 +1,479 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_lag_assembler.hpp + * C++ wrapper for the Multi-pass FCML assembler. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_LAG_ASSEMBLER_HPP_ +#define FCML_LAG_ASSEMBLER_HPP_ + +#include "fcml_assembler.hpp" +#include "fcml_symbols.hpp" + +#include "fcml_lag_assembler.h" + +namespace fcml { + +/** Assembler result which contains all assembled instructions. */ +class MultiPassAssemblerResult { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + MultiPassAssemblerResult() { + } + + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~MultiPassAssemblerResult() { + } + +public: + + /** + * Gets error container. + * + * @return Error container. + * @since 1.1.0 + */ + const ErrorContainer& getErrorContainer() const { + return _errorContainer; + } + + /** + * Gets number of assembled instructions. + * @return Number of assembled instructions. + * @since 1.1.0 + */ + fcml_usize getSize() const { + return static_cast(_assembledInstructions.size()); + } + + /** + * Gets one assembled instruction by its index. + * + * @param index The index of the assembled instruction. + * @return One assembled instruction at given index. + * @throw BadArgumentException + * @since 1.1.0 + */ + const AssembledInstruction& operator[](fcml_usize index) const { + if (index > _assembledInstructions.size()) { + throw BadArgumentException(FCML_TEXT("Array index out of bound."), + FCML_CEH_GEC_VALUE_OUT_OF_RANGE); + } + return _assembledInstructions[index]; + } + + /** + * Gets constant vector of all assembled instructions. + * + * @return Assembled instructions. + * @since 1.1.0 + */ + const std::vector& getAssembledInstructions() const { + return _assembledInstructions; + } + + /** + * Gets iterator which allows to iterate through the whole machine code + * byte by byte. + * + * @return Iterator instance. + * @since 1.1.0 + */ + CodeIterator getCodeIterator() { + return CodeIterator(_assembledInstructions); + } + + /** + * Clears the result. Remember not to use the CodeIterator after the + * result is cleared up. + * @since 1.1.0 + */ + void clear() { + _errorContainer.clean(); + _assembledInstructions.clear(); + } + +protected: + + /** Only the assembler can modify these objects. */ + friend class MultiPassAssembler; + + /** + * Gets vector of all assembled instructions. + * + * @return Assembled instructions. + * @since 1.1.0 + */ + std::vector& getAssembledInstructions() { + return _assembledInstructions; + } + + /** + * Sets new error container for the result. + * + * @param errorContainer The new error container to be set. + * @since 1.1.0 + */ + void setErrorContainer(const ErrorContainer &errorContainer) { + _errorContainer = errorContainer; + } + +private: + + /** Errors container. */ + ErrorContainer _errorContainer; + /** Vector of all assembled instructions. */ + std::vector _assembledInstructions; + +}; + +/** Assembler context. + * @since 1.1.0 + */ +class MultiPassAssemblerContext { + +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + MultiPassAssemblerContext() : + _symbolTable( NULL) { + } + + /** + * Creates assembler context for given operating mode and instruction pointer. + * @param operatingMode The operating mode. + * @param ip The instruction pointer. + * @since 1.1.0 + */ + MultiPassAssemblerContext(EntryPoint::OperatingMode operatingMode, + fcml_ip ip = 0) : + _entryPoint(operatingMode, ip), _symbolTable( NULL) { + } + +public: + + /** + * Gets constant reference to assembler configuration. + * + * @return Assembler configuration. + * @since 1.1.0 + */ + const AssemblerConf& getConfig() const { + return _config; + } + + /** + * Gets reference to the assembler configuration. + * + * @return Assembler configuration. + * @since 1.1.0 + */ + AssemblerConf& getConfig() { + return _config; + } + + /** + * Sets a new assembler configuration. + * + * @return Assembler configuration. + * @since 1.1.0 + */ + void setConfig(const AssemblerConf &config) { + _config = config; + } + + /** + * Gets constant reference to the entry point. + * + * @return Entry point. + * @since 1.1.0 + */ + const EntryPoint& getEntryPoint() const { + return _entryPoint; + } + + /** + * Gets reference to the entry point. + * + * @return Entry point. + * @since 1.1.0 + */ + EntryPoint& getEntryPoint() { + return _entryPoint; + } + + /** + * Sets a new entry point. + * + * @param entryPoint Entry point to be set. + * @since 1.1.0 + */ + void setEntryPoint(const EntryPoint &entryPoint) { + _entryPoint = entryPoint; + } + + /** + * Sets a new instruction pointer. + * + * @param ip A new instruction pointer. + * @since 1.1.0 + */ + void setIP(fcml_ip ip) { + _entryPoint.setIP(ip); + } + + /** + * Increments the instruction pointer by given number of bytes. + * + * @param ip The number of bytes the instruction pointer should + * be incremented by. + * @since 1.1.0 + */ + void incrementIP(fcml_ip ip) { + _entryPoint.incrementIP(ip); + } + + /** + * Sets a new processor operating mode for the entry point. + * + * @param operatingMode The new operating mode. + * @since 1.1.0 + */ + void setOperatingMode(EntryPoint::OperatingMode operatingMode) { + _entryPoint.setOpMode(operatingMode); + } + + /** + * Sets a new address size attribute for the entry point. + * + * @param addressSizeAttribute The address size attribute. + * @since 1.1.0 + */ + void setAddressSizeAttribute(fcml_usize addressSizeAttribute) { + _entryPoint.setAddressSizeAttribute(addressSizeAttribute); + } + + /** + * Sets a new operand size attribute for the entry point. + * + * @param operandSizeAttribute The operand size attribute. + * @since 1.1.0 + */ + void setOperandSizeAttribute(fcml_usize operandSizeAttribute) { + _entryPoint.setOperandSizeAttribute(operandSizeAttribute); + } + + /** + * Gets a pointer to the constant symbol table stored in the context. + * + * @return The pointer to the symbol table. + * @since 1.1.0 + */ + const SymbolTable* getSymbolTable() const { + return _symbolTable; + } + + /** + * Gets a pointer to the symbol table stored in the context. + * + * @return The pointer to the symbol table. + * @since 1.1.0 + */ + SymbolTable* getSymbolTable() { + return _symbolTable; + } + + /** + * Sets a new symbol table for the context. + * + * @param symbolTable The new symbol table to be set. + * @since 1.1.0 + */ + void setSymbolTable(SymbolTable *symbolTable) { + _symbolTable = symbolTable; + } + +private: + /** The entry point. */ + EntryPoint _entryPoint; + /** The assembler configuration. */ + AssemblerConf _config; + /** The symbol table assigned to the context. */ + SymbolTable *_symbolTable; +}; + +/** + * An assembler wrapper, as you can see the assembler context is + * managed internally and + * is not exposed outside. + */ +class MultiPassAssembler: public NonCopyable, + protected DialectAware, + protected SymbolTableAware { +public: + + /** + * Creates multi-pass assembler for a dialect. + * @param dialect The dialect for the assembler. + * @throw InitException Cannot initialize the assembler. + * @since 1.1.0 + */ + MultiPassAssembler(Dialect &dialect) : + _dialect(dialect) { + fcml_ceh_error error = ::fcml_fn_assembler_init(extractDialect(dialect), + &_assembler); + if (error) { + throw InitException(FCML_TEXT("Cannot initialize the assembler."), + error); + } + } + + /** + * Virtual destructor. + * @since 1.1.0 + */ + virtual ~MultiPassAssembler() { + if (_assembler) { + ::fcml_fn_assembler_free(_assembler); + _assembler = NULL; + } + } + +public: + + /** + * Assembles given instruction model. + * + * @param ctx Assembler context. + * @param instructions A pointer to the NULL terminated array of + * the instructions. + * @param[out] result Assembler result. + * @throw AssemblingFailedException Assembler failed. + * @return Error code. + * @since 1.1.0 + */ + fcml_ceh_error assemble(MultiPassAssemblerContext &ctx, + const fcml_string *instructions, MultiPassAssemblerResult &result) { + + /* Prepare assembler context. */ + fcml_st_lag_assembler_context context = { 0 }; + + AssemblerTypeConverter::convert(ctx.getConfig(), context.configuration); + TypeConverter::convert(ctx.getEntryPoint(), context.entry_point); + + SymbolTable *symbolTable = ctx.getSymbolTable(); + context.symbol_table = + symbolTable ? extractSymbolTable(*symbolTable) : NULL; + context.assembler = _assembler; + + /* Prepare assembler result. */ + fcml_st_lag_assembler_result res; + ::fcml_fn_lag_assembler_result_prepare(&res); + + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR; + + try { + + result.clear(); + + error = ::fcml_fn_lag_assemble(&context, instructions, &res); + + /* Failed or not, convert assembler errors. */ + + ErrorContainer errorContainer; + ErrorTypeConverter::convert(res.errors, errorContainer); + + /* Prepares assembler result. */ + + result.setErrorContainer(errorContainer); + + if (error && ctx.getConfig().isThrowExceptionOnError()) { + ::fcml_fn_lag_assembler_result_free(&res); + throw AssemblingFailedException( + errorContainer.prepareErrorMessage( + FCML_TEXT("Assembling failed")), errorContainer, + error); + } + + if (!error) { + + std::vector &assembledInstructions = + result.getAssembledInstructions(); + + assembledInstructions.clear(); + + ErrorContainer instructionWarnings; + fcml_st_assembled_instruction *next_instruction = + res.instructions; + while (next_instruction) { + fcml_st_ceh_error_container &instruction_warnings = + next_instruction->warnings; + ErrorTypeConverter::convert(instruction_warnings, + instructionWarnings); + const AssembledInstruction assembledInstruction( + next_instruction->code, + next_instruction->code_length, instructionWarnings); + assembledInstructions.push_back(assembledInstruction); + next_instruction = next_instruction->next; + } + + // Convert it back to the context because it might have been + // modified during assembling process (IP incrementation etc). + TypeConverter::convert(context.entry_point, + ctx.getEntryPoint()); + + } + + ::fcml_fn_lag_assembler_result_free(&res); + + } catch (std::exception &exc) { + // If anything failed, free assembler results. + ::fcml_fn_lag_assembler_result_free(&res); + throw exc; + } + + return error; + } + +private: + + // The dialect used by the assembler. + Dialect &_dialect; + // The initialized assembler instance used by the wrapper. + fcml_st_assembler *_assembler; + +}; + +} + +#endif /* FCML_LAG_ASSEMBLER_HPP_ */ diff --git a/dependencies/fcml/include/fcml_lib_export.h b/dependencies/fcml/include/fcml_lib_export.h new file mode 100644 index 0000000..3390cda --- /dev/null +++ b/dependencies/fcml/include/fcml_lib_export.h @@ -0,0 +1,63 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_lib_export.h + * Handles Win32 DLL symbols importing/exporting. + * The only interesting thing here is the LIBFCML_DLL_IMPORT symbol which has to + * be always defined in order to use dynamic DLL under Windows. You can achieve it + * by declaring the symbol before this header file is included. For example: + * @code + * #define LIBFCML_DLL_IMPORT + * #include + * @endcode + * Take into account that this header file is included by every FCML public header, so + * in fact you should define the symbol before including anything from the FCML library. + * This declaration can be omitted as long as you use undecorated symbol names. + * + * @copyright Copyright (C) 2010-2019 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_LIB_EXPORT_H_ +#define FCML_LIB_EXPORT_H_ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#if _WIN32 || __CYGWIN__ +#define LIB_CALL __stdcall +#ifdef DLL_EXPORT +#define LIB_EXPORT __declspec(dllexport) +#else +#ifdef LIBFCML_DLL_IMPORT +#define LIB_EXPORT __declspec(dllimport) +#endif +#endif +#endif + +#ifndef LIB_EXPORT +#define LIB_EXPORT +#endif + +#ifndef LIB_CALL +#define LIB_CALL +#endif + +#endif /* FCML_LIB_EXPORT_H_ */ diff --git a/dependencies/fcml/include/fcml_optimizers.h b/dependencies/fcml/include/fcml_optimizers.h new file mode 100644 index 0000000..9c3dbfd --- /dev/null +++ b/dependencies/fcml/include/fcml_optimizers.h @@ -0,0 +1,144 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_optimizers.h + * API for assembler optimizers. For more details about optimizers see + * FCML manual. + * + * @copyright Copyright (C) 2010-2020 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ +#ifndef FCML_OPTIMIZERS_H_ +#define FCML_OPTIMIZERS_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Optimizer context used as a connector with the environment. */ +typedef struct fcml_st_asm_optimizer_context { + /** Optimizer flags passed through the assembler context. + * @see fcml_st_assembler_conf + */ + fcml_uint16_t optimizer_flags; + /** Processor operating mode 16/32/64-bit. */ + fcml_en_operating_mode op_mode; + /** Default address size attribute not modified by prefixes yet. + * (See 'D' flag of segment descriptor.) + */ + fcml_usize asa; + /** Default operand size attribute not modified by prefixes yet. + * (See 'D' flag of segment descriptor.) + */ + fcml_usize osa; +} fcml_st_asm_optimizer_context; + +/** Processing details for optimizers. */ +typedef struct fcml_st_asm_optimizer_processing_details { + /** Allowed values of the operand size attribute calculated by the + * assembler engine. + * It is the optimizer who decides which one should be finally used. + */ + fcml_st_nullable_size_flags allowed_eosa; + /** Allowed values of the address size attribute calculated by the + * assembler engine. + * It is optimizer who decides which one should be finally used. + */ + fcml_st_nullable_size_flags allowed_easa; + /** Effective address size attribute chosen for currently processed + * instruction form. + * If it is set it can not be changed anymore. It has + * higher priority than flags above. Take into account that it is + * effective attribute size attribute so it can be forced using instruction + * prefixes to override the default attribute size. + */ + fcml_usize easa; + /** Effective operand size attribute chosen for currently processed + * instruction form. + * If it is set it can not be changed anymore. It has higher priority than + * flags above. Take into account that it is effective operand size + * attribute so it can be forced using instruction prefixes to override + * the default attribute size. + */ + fcml_usize eosa; + /** Vector length of AVX instructions. Set to FCML_DS_UNDEF if not used. */ + fcml_usize vector_length; + /** Set to true in order to break optimization process immediately. */ + fcml_bool break_optimization; +} fcml_st_asm_optimizer_processing_details; + +/** + * Callback used to invoke encoding process for given processing details + * configuration. + * @param args Arguments from optimizer. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + */ +typedef fcml_ceh_error (*fcml_fnp_asm_optimizer_callback)(fcml_ptr args); + +/** + * Function pointer declaration for optimizers. + * @param context Optimizer context. + * @param ds_flags Current instruction processing details. + * @param callback Callback used to continue processing for configuration + * prepared by optimizer. + * @param args Arguments that should be passed to the callback. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + */ +typedef fcml_ceh_error (LIB_CALL *fcml_fnp_asm_optimizer)( + fcml_st_asm_optimizer_context *context, + fcml_st_asm_optimizer_processing_details *ds_flags, + fcml_fnp_asm_optimizer_callback callback, fcml_ptr args); + +/* Optimizers flags that can be used to configure optimization process. */ +#define FCML_OPTF_ASA_16 0x01 +#define FCML_OPTF_ASA_32 0x02 +#define FCML_OPTF_ASA_64 0x03 +#define FCML_OPTF_OSA_16 0x10 +#define FCML_OPTF_OSA_32 0x20 +#define FCML_OPTF_OSA_64 0x30 +/* Do not choose the optimal form, but return all possibilities. */ +#define FCML_OPTF_ALL_FORMS 0xFF + +/** + * Default optimizer implementation. + * This implementation chooses the best combination of attributes for + * current processor operating mode. + * @param context Optimizer context. + * @param ds_flags Current instruction processing details. + * @param callback Callback used to continue processing for configuration + * prepared by optimizer. + * @param callback_args Arguments that should be passed to the callback. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_asm_default_optimizer( + fcml_st_asm_optimizer_context *context, + fcml_st_asm_optimizer_processing_details *ds_flags, + fcml_fnp_asm_optimizer_callback callback, fcml_ptr callback_args); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_OPTIMIZERS_H_ */ diff --git a/dependencies/fcml/include/fcml_parser.h b/dependencies/fcml/include/fcml_parser.h new file mode 100644 index 0000000..450a966 --- /dev/null +++ b/dependencies/fcml/include/fcml_parser.h @@ -0,0 +1,166 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_parser.h + * Structures and functions declarations related to FCML parsers + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_PARSER_H_ +#define FCML_PARSER_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_common.h" +#include "fcml_dialect.h" +#include "fcml_symbols.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Maximal number of character for parsed instruction. */ +#define FCML_PARSER_MAX_INSTRUCTION_LEN 1024 + +/** Parser configuration. */ +typedef struct fcml_st_parser_config { + /** Set to true in order to ignore all undefined symbols. + * In such a case every unknown symbol is treated as 0. + */ + fcml_bool ignore_undefined_symbols; + /** Disables symbols support. + * It set to true every defined label will cause an error. + */ + fcml_bool disable_symbols_declaration; + /** Set to true in order to allow overriding existing labels. + * If set to false parser returns "Symbol already exists" error when + * symbol already exists. + */ + fcml_bool override_labels; + /** By default parser ignores all symbol declarations + * if there is no symbol table provided in the parser + * context. By setting this value to true you can force + * the parser to allocate new symbol table when needed. + * Remember that you are then responsible for freeing it, + * so this functionality can be a bit dangerous because + * you have to check the existence of the symbol table + * every time it should be deallocated. + */ + fcml_bool alloc_symbol_table_if_needed; + // TODO: Support has to be implemented yet. + /** Enables textual error messages. */ + fcml_bool enable_error_messages; +} fcml_st_parser_config; + +/** Parser runtime context. */ +typedef struct fcml_st_parser_context { + /** Dialect to be used by parser. Defines supported instructions syntax. */ + fcml_st_dialect *dialect; + /** Parser configuration. */ + fcml_st_parser_config configuration; + /** Instruction pointer. RIP/EIP register value used as a value for + * newly declared symbols. + * This value is never changed by the parser. + */ + fcml_ip ip; + /** Symbol table. It holds symbols added by the user as + * well as symbols allocated by the parsers (labels). It is + * very important to free this container on your own + * because even if it is not allocated by the user it can be + * set by the parser when the first symbol definition is found. + * So the most safe way to manage it is to always use + * "fcml_fn_symbol_table_free" function as soon as context + * if going to be freed. + */ + fcml_st_symbol_table symbol_table; +} fcml_st_parser_context; + +/** Reusable result holder */ +typedef struct fcml_st_parser_result { + /** Parsing errors and warnings going here. */ + fcml_st_ceh_error_container errors; + /** Defined symbol if there is any. + * Remember that this symbol is also stored in the context's symbol table. + * It is the symbol table that is the owner and that is responsible + * for freeing it. + */ + fcml_st_symbol *symbol; + /** Parsed instruction as generic instruction model. */ + fcml_st_instruction *instruction; +} fcml_st_parser_result; + +/** + * Parses given instruction into the generic instruction model. + * Parses the textual representation of the instruction using dialect and + * configuration provided by the parser context. Parsed instruction is returned in the + * reusable result holder. Result holder has to be allocated by the + * user and appropriately prepared using fcml_fn_parser_result_prepare() + * function. As long as the instruction context and the result holder + * are not shared across multiple function calls parsing process is + * thread safe. + * + * Remember that textual representation of the instruction has to be written + * using syntax supported by the dialect parser is going to use. + * + * @param context Parser runtime context. + * @param instruction textual representation of the instruction to be parsed. + * @param result Reusable result holder. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_parse( + fcml_st_parser_context *context, const fcml_string instruction, + fcml_st_parser_result *result); + +/** + * Prepares reusable result holder for parser. + * Every instance of fcml_st_parser_result structure is reusable from the + * parser's point of view, so it has to be prepared in the right way in order + * to allow parser to reuse it correctly. It is up to the library user to + * allocate space for the holder itself. This function is only responsible + * for cleaning the structure correctly and preparing it for the first parsing + * process. Notice that parser has to clean the result holder at the beginning + * so you can not pass an uninitialized memory block because it can even cause + * a crash due to illegal memory access. + * + * @param result Result holder instance to be prepared. + */ +LIB_EXPORT void LIB_CALL fcml_fn_parser_result_prepare( + fcml_st_parser_result *result); + +/** + * Cleans result holder. + * Frees all memory blocks allocated by the parser and held inside the result + * holder (Instructions, errors etc.). Notice that result holder itself is + * not freed and can be even safety reused after call to this function. In fact + * this function is also called internally by the parser in order to clean + * result holder before reusing it. + * @param result Result holder to clean. + */ +LIB_EXPORT void LIB_CALL fcml_fn_parser_result_free( + fcml_st_parser_result *result); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_PARSER_H_ */ diff --git a/dependencies/fcml/include/fcml_parser.hpp b/dependencies/fcml/include/fcml_parser.hpp new file mode 100644 index 0000000..f8d8e15 --- /dev/null +++ b/dependencies/fcml/include/fcml_parser.hpp @@ -0,0 +1,486 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_parser.hpp + * C++ wrapper for instruction parser. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_PARSER_HPP_ +#define FCML_PARSER_HPP_ + +#include "fcml_common.hpp" +#include "fcml_symbols.hpp" +#include "fcml_errors.hpp" +#include "fcml_dialect.hpp" + +#include "fcml_parser.h" + +namespace fcml { + +/** + * Something failed while parsing. + * @since 1.1.0 + */ +class ParsingFailedException: public ErrorContainerAwareException { +public: + ParsingFailedException(const fcml_cstring msg, + ErrorContainer &errorContainer, + fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR) : + ErrorContainerAwareException(msg, errorContainer, error) { + } +}; + +/** Parser configuration. + * @since 1.1.0 + */ +class ParserConfig { +public: + + /** + * Default constructor. + * @since 1.1.0 + */ + ParserConfig() : + _throwExceptionOnError(true), + _ignoreUndefinedSymbols(false), + _disableSymbolsDeclaration(true), + _overrideLabels(false), + _allocSymbolTableIfNeeded(false), + _enableErrorMessages(true) { + } + + /** @since 1.1.0 */ + bool isAllocSymbolTableIfNeeded() const { + return _allocSymbolTableIfNeeded; + } + + /** @since 1.1.0 */ + void setAllocSymbolTableIfNeeded(bool allocSymbolTableIfNeeded) { + _allocSymbolTableIfNeeded = allocSymbolTableIfNeeded; + } + + /** @since 1.1.0 */ + bool isDisableSymbolsDeclaration() const { + return _disableSymbolsDeclaration; + } + + /** @since 1.1.0 */ + void setDisableSymbolsDeclaration(bool disableSymbolsDeclaration) { + _disableSymbolsDeclaration = disableSymbolsDeclaration; + } + + /** @since 1.1.0 */ + bool isEnableErrorMessages() const { + return _enableErrorMessages; + } + + /** @since 1.1.0 */ + void setEnableErrorMessages(bool enableErrorMessages) { + _enableErrorMessages = enableErrorMessages; + } + + /** @since 1.1.0 */ + bool isIgnoreUndefinedSymbols() const { + return _ignoreUndefinedSymbols; + } + + /** @since 1.1.0 */ + void setIgnoreUndefinedSymbols(bool ignoreUndefinedSymbols) { + _ignoreUndefinedSymbols = ignoreUndefinedSymbols; + } + + /** @since 1.1.0 */ + bool isOverrideLabels() const { + return _overrideLabels; + } + + /** @since 1.1.0 */ + void setOverrideLabels(bool overrideLabels) { + _overrideLabels = overrideLabels; + } + + /** + * Gets true if exception should be thrown in case of error. + * @return True if exception should be thrown in case of error. + * @since 1.1.0 + */ + bool isThrowExceptionOnError() const { + return _throwExceptionOnError; + } + + /** + * Sets exception on error flag. Has to be set to true if exception + * should be thrown in case of error. + * @param throwExceptionOnError True if exception should be thrown + * in case of error. + * @since 1.1.0 + */ + void setThrowExceptionOnError(bool throwExceptionOnError) { + _throwExceptionOnError = throwExceptionOnError; + } + +private: + bool _throwExceptionOnError; + bool _ignoreUndefinedSymbols; + bool _disableSymbolsDeclaration; + bool _overrideLabels; + bool _allocSymbolTableIfNeeded; + bool _enableErrorMessages; +}; + +/** Parser context. + * @since 1.1.0 + */ +class ParserContext { +public: + + /** + * Creates a parser context instance for optional instruction pointer. + * + * @param ip The instruction pointer. + * @since 1.1.0 + */ + ParserContext(fcml_ip ip = 0) : + _ip(ip), _symbolTable(NULL) { + } + + /** + * Creates a parser context for given symbol table and optional + * instruction pointer. + * + * @param symbolTable The symbol table. + * @param ip The instruction pointer. + * @since 1.1.0 + */ + ParserContext(SymbolTable *symbolTable, fcml_ip ip = 0) : + _ip(ip), _symbolTable(symbolTable) { + } + +public: + + /** + * Gets the parser configuration associated with the context. + * + * @return The parser configuration associated with the context. + * @since 1.1.0 + */ + const ParserConfig& getConfig() const { + return _config; + } + + /** + * Gets the parser configuration associated with the context. + * + * @return The parser configuration associated with the context. + * @since 1.1.0 + */ + ParserConfig& getConfig() { + return _config; + } + + /** + * Gets the instruction pointer. + * + * @return The instruction pointer. + * @since 1.1.0 + */ + fcml_ip getIp() const { + return _ip; + } + + /** + * Gets a new instruction pointer. + * + * @param ip The new instruction pointer. + * @since 1.1.0 + */ + void setIp(fcml_ip ip) { + _ip = ip; + } + + /** + * Increments instruction pointer by given number of bytes. + * + * @param ip The number of bytes the instruction pointer has + * to be incremented by. + * @since 1.1.0 + */ + void incrementIP(fcml_ip ip) { + _ip += ip; + } + + /** + * Gets the symbol table associated with the context. + * + * @return The symbol table. + * @since 1.1.0 + */ + const SymbolTable* getSymbolTable() const { + return _symbolTable; + } + + /** + * Gets the symbol table associated with the context. + * + * @return The symbol table. + * @since 1.1.0 + */ + SymbolTable* getSymbolTable() { + return _symbolTable; + } + + /** + * Sets a symbol table for the instruction. + * + * @param symbolTable The symbol table for the parser context. + * @since 1.1.0 + */ + void setSymbolTable(SymbolTable *symbolTable) { + _symbolTable = symbolTable; + } + +private: + + /** The instruction pointer used by declared labels. */ + fcml_ip _ip; + /** The parser configuration. */ + ParserConfig _config; + /** The symbol table. */ + SymbolTable *_symbolTable; + +}; + +/** Parser result. + * @since 1.1.0 + */ +class ParserResult { +public: + + /** + * Creates an empty parser result. + * @since 1.1.0 + */ + ParserResult() { + } + + /** + * Gets errors container with parsing errors. + * + * @return Errors container. + * @since 1.1.0 + */ + const ErrorContainer& getErrors() const { + return _errors; + } + + /** + * Gets the parsed instruction. + * + * @return The parsed instruction. + * @since 1.1.0 + */ + const Instruction& getInstruction() const { + return _instruction; + } + + /** + * Gets declared symbol is there is any. + * @return Gets symbol if there is any. + * @since 1.1.0 + */ + const Nullable& getSymbol() const { + return _symbol; + } + + /** + * Cleans the parser result. + * @since 1.1.0 + */ + void clean() { + _errors.clean(); + _symbol.setNotNull(false); + _symbol.setValue(Symbol()); + } + +protected: + + friend class Parser; + + /** + * Sets error container for the context. + * @param errors A new error container. + * @since 1.1.0 + */ + void setErrors(const ErrorContainer &errors) { + _errors = errors; + } + + /** + * Sets an instruction for the container. + * @param instruction The instruction. + * @since 1.1.0 + */ + void setInstruction(const Instruction &instruction) { + _instruction = instruction; + } + + /** + * Sets symbol. + * @param symbol The symbol. + * @since 1.1.0 + */ + void setSymbol(const Nullable &symbol) { + _symbol = symbol; + } + +private: + + /** Errors container. */ + ErrorContainer _errors; + /** Gets declared symbol. Take into account that it can be 'empty'. */ + Nullable _symbol; + /** The parsed instruction. */ + Instruction _instruction; + +}; + +/** + * Converts objects to their structures counterparts. + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class ParserTypeConverter { +public: + + static void convert(ParserConfig &src, fcml_st_parser_config &dest) { + dest.alloc_symbol_table_if_needed = src.isAllocSymbolTableIfNeeded(); + dest.disable_symbols_declaration = src.isDisableSymbolsDeclaration(); + dest.enable_error_messages = src.isEnableErrorMessages(); + dest.ignore_undefined_symbols = src.isIgnoreUndefinedSymbols(); + dest.override_labels = src.isOverrideLabels(); + } + +}; + +/** Parser wrapper. + * @since 1.1.0 + */ +class Parser: protected DialectAware, protected SymbolTableAware { +public: + + /** + * Creates a parser instance for the given dialect. + * + * @param dialect The dialect instance. + * @since 1.1.0 + */ + Parser(const Dialect &dialect) : + _dialect(dialect) { + } + + /** + * Parses instruction given in the parameters. + * + * @param ctx Parser context. + * @param instruction Instruction mnemonic. + * @param[out] parserResult Instruction result. + * @return Error code. + * @throw ParsingFailedException Parsing failed. + * @since 1.1.0 + */ + fcml_ceh_error parse(ParserContext &ctx, const fcml_cstring &instruction, + ParserResult &parserResult) { + + // Prepare parser context. + fcml_st_parser_context context = { 0 }; + ParserTypeConverter::convert(ctx.getConfig(), context.configuration); + context.ip = ctx.getIp(); + SymbolTable *symbolTable = ctx.getSymbolTable(); + context.symbol_table = + (symbolTable) ? extractSymbolTable(*symbolTable) : NULL; + context.dialect = extractDialect(_dialect); + + fcml_st_parser_result parser_result; + ::fcml_fn_parser_result_prepare(&parser_result); + + try { + + parserResult.clean(); + + // Prepare instruction. + fcml_ceh_error error = ::fcml_fn_parse(&context, + instruction.c_str(), &parser_result); + + ErrorContainer errorContainer; + ErrorTypeConverter::convert(parser_result.errors, errorContainer); + + parserResult.setErrors(errorContainer); + + if (!error && !parser_result.instruction) { + // Just in case, it should never happen. + error = FCML_CEH_GEC_INTERNAL_ERROR; + } + + if (error && ctx.getConfig().isThrowExceptionOnError()) { + ::fcml_fn_parser_result_free(&parser_result); + throw ParsingFailedException( + errorContainer.prepareErrorMessage( + FCML_TEXT("Parsing failed")), errorContainer, + error); + } + + if (!error) { + + Instruction parsedInstruction; + TypeConverter::convert(*(parser_result.instruction), + parsedInstruction); + + parserResult.setInstruction(parsedInstruction); + parserResult.setSymbol( + parser_result.symbol ? + Symbol(parser_result.symbol->symbol, + parser_result.symbol->value) : + Symbol()); + + } + + ::fcml_fn_parser_result_free(&parser_result); + + } catch (std::exception &exc) { + // If anything failed, free assembler results. + ::fcml_fn_parser_result_free(&parser_result); + throw exc; + } + + return FCML_CEH_GEC_NO_ERROR; + } + +private: + + /** The dialect for the parser. */ + const Dialect &_dialect; + +}; + +} + +#endif /* FCML_PARSER_HPP_ */ diff --git a/dependencies/fcml/include/fcml_registers.cpp b/dependencies/fcml/include/fcml_registers.cpp new file mode 100644 index 0000000..c9c25e6 --- /dev/null +++ b/dependencies/fcml/include/fcml_registers.cpp @@ -0,0 +1,288 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2015 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_registers.cpp + * C++ registers definitions. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + * + * @since 1.1.0 + */ + +#ifndef _FCML_CPP_REGISTERS +#define _FCML_CPP_REGISTERS + +#include "fcml_registers.hpp" + +namespace fcml { + + const Register UNDEF( 0, 0, Register::REG_UNDEFINED, FCML_FALSE ); + + const Register AL( ::fcml_reg_AL ); + const Register AX( ::fcml_reg_AX ); + const Register EAX( ::fcml_reg_EAX ); + const Register RAX( ::fcml_reg_RAX ); + const Register MM0( ::fcml_reg_MM0 ); + const Register XMM0( ::fcml_reg_XMM0 ); + const Register YMM0( ::fcml_reg_YMM0 ); + const Register ZMM0( ::fcml_reg_ZMM0 ); + + const Register CL( ::fcml_reg_CL ); + const Register CX( ::fcml_reg_CX ); + const Register ECX( ::fcml_reg_ECX ); + const Register RCX( ::fcml_reg_RCX ); + const Register MM1( ::fcml_reg_MM1 ); + const Register XMM1( ::fcml_reg_XMM1 ); + const Register YMM1( ::fcml_reg_YMM1 ); + const Register ZMM1( ::fcml_reg_ZMM1 ); + + const Register DL( ::fcml_reg_DL ); + const Register DX( ::fcml_reg_DX ); + const Register EDX( ::fcml_reg_EDX ); + const Register RDX( ::fcml_reg_RDX ); + const Register MM2( ::fcml_reg_MM2 ); + const Register XMM2( ::fcml_reg_XMM2 ); + const Register YMM2( ::fcml_reg_YMM2 ); + const Register ZMM2( ::fcml_reg_ZMM2 ); + + const Register BL( ::fcml_reg_BL ); + const Register BX( ::fcml_reg_BX ); + const Register EBX( ::fcml_reg_EBX ); + const Register RBX( ::fcml_reg_RBX ); + const Register MM3( ::fcml_reg_MM3 ); + const Register XMM3( ::fcml_reg_XMM3 ); + const Register YMM3( ::fcml_reg_YMM3 ); + const Register ZMM3( ::fcml_reg_ZMM3 ); + + const Register AH( ::fcml_reg_AH ); + const Register SPL( ::fcml_reg_SPL ); + const Register SP( ::fcml_reg_SP ); + const Register ESP( ::fcml_reg_ESP ); + const Register RSP( ::fcml_reg_RSP ); + const Register MM4( ::fcml_reg_MM4 ); + const Register XMM4( ::fcml_reg_XMM4 ); + const Register YMM4( ::fcml_reg_YMM4 ); + const Register ZMM4( ::fcml_reg_ZMM4 ); + + const Register CH( ::fcml_reg_CH ); + const Register BPL( ::fcml_reg_BPL ); + const Register BP( ::fcml_reg_BP ); + const Register EBP( ::fcml_reg_EBP ); + const Register RBP( ::fcml_reg_RBP ); + const Register MM5( ::fcml_reg_MM5 ); + const Register XMM5( ::fcml_reg_XMM5 ); + const Register YMM5( ::fcml_reg_YMM5 ); + const Register ZMM5( ::fcml_reg_ZMM5 ); + + const Register DH( ::fcml_reg_DH ); + const Register SIL( ::fcml_reg_SIL ); + const Register SI( ::fcml_reg_SI ); + const Register ESI( ::fcml_reg_ESI ); + const Register RSI( ::fcml_reg_RSI ); + const Register MM6( ::fcml_reg_MM6 ); + const Register XMM6( ::fcml_reg_XMM6 ); + const Register YMM6( ::fcml_reg_YMM6 ); + const Register ZMM6( ::fcml_reg_ZMM6 ); + + const Register BH( ::fcml_reg_BH ); + const Register DIL( ::fcml_reg_DIL ); + const Register DI( ::fcml_reg_DI ); + const Register EDI( ::fcml_reg_EDI ); + const Register RDI( ::fcml_reg_RDI ); + const Register MM7( ::fcml_reg_MM7 ); + const Register XMM7( ::fcml_reg_XMM7 ); + const Register YMM7( ::fcml_reg_YMM7 ); + const Register ZMM7( ::fcml_reg_ZMM7 ); + + const Register R8L( ::fcml_reg_R8L ); + const Register R8W( ::fcml_reg_R8W ); + const Register R8D( ::fcml_reg_R8D ); + const Register R8( ::fcml_reg_R8 ); + const Register XMM8( ::fcml_reg_XMM8 ); + const Register YMM8( ::fcml_reg_YMM8 ); + const Register ZMM8( ::fcml_reg_ZMM8 ); + + const Register R9L( ::fcml_reg_R9L ); + const Register R9W( ::fcml_reg_R9W ); + const Register R9D( ::fcml_reg_R9D ); + const Register R9( ::fcml_reg_R9 ); + const Register XMM9( ::fcml_reg_XMM9 ); + const Register YMM9( ::fcml_reg_YMM9 ); + const Register ZMM9( ::fcml_reg_ZMM9 ); + + const Register R10L( ::fcml_reg_R10L ); + const Register R10W( ::fcml_reg_R10W ); + const Register R10D( ::fcml_reg_R10D ); + const Register R10( ::fcml_reg_R10 ); + const Register XMM10( ::fcml_reg_XMM10 ); + const Register YMM10( ::fcml_reg_YMM10 ); + const Register ZMM10( ::fcml_reg_ZMM10 ); + + const Register R11L( ::fcml_reg_R11L ); + const Register R11W( ::fcml_reg_R11W ); + const Register R11D( ::fcml_reg_R11D ); + const Register R11( ::fcml_reg_R11 ); + const Register XMM11( ::fcml_reg_XMM11 ); + const Register YMM11( ::fcml_reg_YMM11 ); + const Register ZMM11( ::fcml_reg_ZMM11 ); + + const Register R12L( ::fcml_reg_R12L ); + const Register R12W( ::fcml_reg_R12W ); + const Register R12D( ::fcml_reg_R12D ); + const Register R12( ::fcml_reg_R12 ); + const Register XMM12( ::fcml_reg_XMM12 ); + const Register YMM12( ::fcml_reg_YMM12 ); + const Register ZMM12( ::fcml_reg_ZMM12 ); + + const Register R13L( ::fcml_reg_R13L ); + const Register R13W( ::fcml_reg_R13W ); + const Register R13D( ::fcml_reg_R13D ); + const Register R13( ::fcml_reg_R13 ); + const Register XMM13( ::fcml_reg_XMM13 ); + const Register YMM13( ::fcml_reg_YMM13 ); + const Register ZMM13( ::fcml_reg_ZMM13 ); + + const Register R14L( ::fcml_reg_R14L ); + const Register R14W( ::fcml_reg_R14W ); + const Register R14D( ::fcml_reg_R14D ); + const Register R14( ::fcml_reg_R14 ); + const Register XMM14( ::fcml_reg_XMM14 ); + const Register YMM14( ::fcml_reg_YMM14 ); + const Register ZMM14( ::fcml_reg_ZMM14 ); + + const Register R15L( ::fcml_reg_R15L ); + const Register R15W( ::fcml_reg_R15W ); + const Register R15D( ::fcml_reg_R15D ); + const Register R15( ::fcml_reg_R15 ); + const Register XMM15( ::fcml_reg_XMM15 ); + const Register YMM15( ::fcml_reg_YMM15 ); + const Register ZMM15( ::fcml_reg_ZMM15 ); + + const Register XMM16( ::fcml_reg_XMM16 ); + const Register YMM16( ::fcml_reg_YMM16 ); + const Register ZMM16( ::fcml_reg_ZMM16 ); + + const Register XMM17( ::fcml_reg_XMM17 ); + const Register YMM17( ::fcml_reg_YMM17 ); + const Register ZMM17( ::fcml_reg_ZMM17 ); + + const Register XMM18( ::fcml_reg_XMM18 ); + const Register YMM18( ::fcml_reg_YMM18 ); + const Register ZMM18( ::fcml_reg_ZMM18 ); + + const Register XMM19( ::fcml_reg_XMM19 ); + const Register YMM19( ::fcml_reg_YMM19 ); + const Register ZMM19( ::fcml_reg_ZMM19 ); + + const Register XMM20( ::fcml_reg_XMM20 ); + const Register YMM20( ::fcml_reg_YMM20 ); + const Register ZMM20( ::fcml_reg_ZMM20 ); + + const Register XMM21( ::fcml_reg_XMM21 ); + const Register YMM21( ::fcml_reg_YMM21 ); + const Register ZMM21( ::fcml_reg_ZMM21 ); + + const Register XMM22( ::fcml_reg_XMM22 ); + const Register YMM22( ::fcml_reg_YMM22 ); + const Register ZMM22( ::fcml_reg_ZMM22 ); + + const Register XMM23( ::fcml_reg_XMM23 ); + const Register YMM23( ::fcml_reg_YMM23 ); + const Register ZMM23( ::fcml_reg_ZMM23 ); + + const Register XMM24( ::fcml_reg_XMM24 ); + const Register YMM24( ::fcml_reg_YMM24 ); + const Register ZMM24( ::fcml_reg_ZMM24 ); + + const Register XMM25( ::fcml_reg_XMM25 ); + const Register YMM25( ::fcml_reg_YMM25 ); + const Register ZMM25( ::fcml_reg_ZMM25 ); + + const Register XMM26( ::fcml_reg_XMM26 ); + const Register YMM26( ::fcml_reg_YMM26 ); + const Register ZMM26( ::fcml_reg_ZMM26 ); + + const Register XMM27( ::fcml_reg_XMM27 ); + const Register YMM27( ::fcml_reg_YMM27 ); + const Register ZMM27( ::fcml_reg_ZMM27 ); + + const Register XMM28( ::fcml_reg_XMM28 ); + const Register YMM28( ::fcml_reg_YMM28 ); + const Register ZMM28( ::fcml_reg_ZMM28 ); + + const Register XMM29( ::fcml_reg_XMM29 ); + const Register YMM29( ::fcml_reg_YMM29 ); + const Register ZMM29( ::fcml_reg_ZMM29 ); + + const Register XMM30( ::fcml_reg_XMM30 ); + const Register YMM30( ::fcml_reg_YMM30 ); + const Register ZMM30( ::fcml_reg_ZMM30 ); + + const Register XMM31( ::fcml_reg_XMM31 ); + const Register YMM31( ::fcml_reg_YMM31 ); + const Register ZMM31( ::fcml_reg_ZMM31 ); + + const Register ES( ::fcml_reg_ES ); + const Register CS( ::fcml_reg_CS ); + const Register SS( ::fcml_reg_SS ); + const Register DS( ::fcml_reg_DS ); + const Register FS( ::fcml_reg_FS ); + const Register GS( ::fcml_reg_GS ); + + const Register ST0( ::fcml_reg_ST0 ); + const Register ST1( ::fcml_reg_ST1 ); + const Register ST2( ::fcml_reg_ST2 ); + const Register ST3( ::fcml_reg_ST3 ); + const Register ST4( ::fcml_reg_ST4 ); + const Register ST5( ::fcml_reg_ST5 ); + const Register ST6( ::fcml_reg_ST6 ); + const Register ST7( ::fcml_reg_ST7 ); + + const Register CR0( ::fcml_reg_CR0 ); + const Register CR2( ::fcml_reg_CR2 ); + const Register CR3( ::fcml_reg_CR3 ); + const Register CR4( ::fcml_reg_CR4 ); + const Register CR8( ::fcml_reg_CR8 ); + + const Register DR0( ::fcml_reg_DR0 ); + const Register DR1( ::fcml_reg_DR1 ); + const Register DR2( ::fcml_reg_DR2 ); + const Register DR3( ::fcml_reg_DR3 ); + const Register DR4( ::fcml_reg_DR4 ); + const Register DR5( ::fcml_reg_DR5 ); + const Register DR6( ::fcml_reg_DR6 ); + const Register DR7( ::fcml_reg_DR7 ); + + const Register K0( ::fcml_reg_K0 ); + const Register K1( ::fcml_reg_K1 ); + const Register K2( ::fcml_reg_K2 ); + const Register K3( ::fcml_reg_K3 ); + const Register K4( ::fcml_reg_K4 ); + const Register K5( ::fcml_reg_K5 ); + const Register K6( ::fcml_reg_K6 ); + const Register K7( ::fcml_reg_K7 ); + + const Register IP( ::fcml_reg_IP ); + const Register EIP( ::fcml_reg_EIP ); + const Register RIP( ::fcml_reg_RIP ); + +} + +#endif diff --git a/dependencies/fcml/include/fcml_registers.hpp b/dependencies/fcml/include/fcml_registers.hpp new file mode 100644 index 0000000..4bc76b2 --- /dev/null +++ b/dependencies/fcml/include/fcml_registers.hpp @@ -0,0 +1,288 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_registers.hpp + * C++ registers declarations. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + * + * @since 1.1.0 + */ + +#ifndef FCML_REGISTERS_HPP_ +#define FCML_REGISTERS_HPP_ + +#include "fcml_common.hpp" + +namespace fcml { + + extern const Register UNDEF; + + extern const Register AL; + extern const Register AX; + extern const Register EAX; + extern const Register RAX; + extern const Register MM0; + extern const Register XMM0; + extern const Register YMM0; + extern const Register ZMM0; + + extern const Register CL; + extern const Register CX; + extern const Register ECX; + extern const Register RCX; + extern const Register MM1; + extern const Register XMM1; + extern const Register YMM1; + extern const Register ZMM1; + + extern const Register DL; + extern const Register DX; + extern const Register EDX; + extern const Register RDX; + extern const Register MM2; + extern const Register XMM2; + extern const Register YMM2; + extern const Register ZMM2; + + extern const Register BL; + extern const Register BX; + extern const Register EBX; + extern const Register RBX; + extern const Register MM3; + extern const Register XMM3; + extern const Register YMM3; + extern const Register ZMM3; + + extern const Register AH; + extern const Register SPL; + extern const Register SP; + extern const Register ESP; + extern const Register RSP; + extern const Register MM4; + extern const Register XMM4; + extern const Register YMM4; + extern const Register ZMM4; + + extern const Register CH; + extern const Register BPL; + extern const Register BP; + extern const Register EBP; + extern const Register RBP; + extern const Register MM5; + extern const Register XMM5; + extern const Register YMM5; + extern const Register ZMM5; + + extern const Register DH; + extern const Register SIL; + extern const Register SI; + extern const Register ESI; + extern const Register RSI; + extern const Register MM6; + extern const Register XMM6; + extern const Register YMM5; + extern const Register ZMM5; + + extern const Register BH; + extern const Register DIL; + extern const Register DI; + extern const Register EDI; + extern const Register RDI; + extern const Register MM7; + extern const Register XMM7; + extern const Register YMM7; + extern const Register ZMM7; + + extern const Register R8L; + extern const Register R8W; + extern const Register R8D; + extern const Register R8; + extern const Register XMM8; + extern const Register YMM8; + extern const Register ZMM8; + + extern const Register R9L; + extern const Register R9W; + extern const Register R9D; + extern const Register R9; + extern const Register XMM9; + extern const Register YMM9; + extern const Register ZMM9; + + extern const Register R10L; + extern const Register R10W; + extern const Register R10D; + extern const Register R10; + extern const Register XMM10; + extern const Register YMM10; + extern const Register ZMM10; + + extern const Register R11L; + extern const Register R11W; + extern const Register R11D; + extern const Register R11; + extern const Register XMM11; + extern const Register YMM10; + extern const Register ZMM10; + + extern const Register R12L; + extern const Register R12W; + extern const Register R12D; + extern const Register R12; + extern const Register XMM12; + extern const Register YMM12; + extern const Register ZMM12; + + extern const Register R13L; + extern const Register R13W; + extern const Register R13D; + extern const Register R13; + extern const Register XMM13; + extern const Register YMM13; + extern const Register ZMM13; + + extern const Register R14L; + extern const Register R14W; + extern const Register R14D; + extern const Register R14; + extern const Register XMM14; + extern const Register YMM14; + extern const Register ZMM14; + + extern const Register R15L; + extern const Register R15W; + extern const Register R15D; + extern const Register R15; + extern const Register XMM15; + extern const Register YMM15; + extern const Register ZMM15; + + extern const Register XMM16; + extern const Register YMM16; + extern const Register ZMM16; + + extern const Register XMM17; + extern const Register YMM17; + extern const Register ZMM17; + + extern const Register XMM18; + extern const Register YMM18; + extern const Register ZMM18; + + extern const Register XMM19; + extern const Register YMM19; + extern const Register ZMM19; + + extern const Register XMM20; + extern const Register YMM20; + extern const Register ZMM20; + + extern const Register XMM21; + extern const Register YMM21; + extern const Register ZMM21; + + extern const Register XMM22; + extern const Register YMM22; + extern const Register ZMM22; + + extern const Register XMM23; + extern const Register YMM23; + extern const Register ZMM23; + + extern const Register XMM24; + extern const Register YMM24; + extern const Register ZMM24; + + extern const Register XMM25; + extern const Register YMM25; + extern const Register ZMM25; + + extern const Register XMM26; + extern const Register YMM26; + extern const Register ZMM26; + + extern const Register XMM27; + extern const Register YMM27; + extern const Register ZMM27; + + extern const Register XMM28; + extern const Register YMM28; + extern const Register ZMM28; + + extern const Register XMM29; + extern const Register YMM29; + extern const Register ZMM29; + + extern const Register XMM30; + extern const Register YMM30; + extern const Register ZMM30; + + extern const Register XMM31; + extern const Register YMM31; + extern const Register ZMM31; + + extern const Register ES; + extern const Register CS; + extern const Register SS; + extern const Register DS; + extern const Register FS; + extern const Register GS; + + extern const Register ST0; + extern const Register ST1; + extern const Register ST2; + extern const Register ST3; + extern const Register ST4; + extern const Register ST5; + extern const Register ST6; + extern const Register ST7; + + extern const Register CR0; + extern const Register CR2; + extern const Register CR3; + extern const Register CR4; + extern const Register CR8; + + extern const Register DR0; + extern const Register DR1; + extern const Register DR2; + extern const Register DR3; + extern const Register DR4; + extern const Register DR5; + extern const Register DR6; + extern const Register DR7; + + extern const Register K0; + extern const Register K1; + extern const Register K2; + extern const Register K3; + extern const Register K4; + extern const Register K5; + extern const Register K6; + extern const Register K7; + + extern const Register IP; + extern const Register EIP; + extern const Register RIP; + +} + +#endif /* FCML_REGISTERS_HPP_ */ diff --git a/dependencies/fcml/include/fcml_renderer.h b/dependencies/fcml/include/fcml_renderer.h new file mode 100644 index 0000000..bb5a124 --- /dev/null +++ b/dependencies/fcml/include/fcml_renderer.h @@ -0,0 +1,124 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_renderer.h + * Structures and functions declarations related to FCML renderers + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_REND_H_ +#define FCML_REND_H_ + +#include "fcml_lib_export.h" + +#include "fcml_types.h" +#include "fcml_errors.h" +#include "fcml_dialect.h" +#include "fcml_disassembler.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** The rendered instruction size can not exceed this value. */ +#define FCML_REND_MAX_BUFF_LEN 512 + +/** + * @defgroup RENDERER_FLAGS_GROUP Flags configuring rendering process. + * @{ + */ + +/** Render the instruction code as HEX string. */ +#define FCML_REND_FLAG_RENDER_CODE 0x00000001 +/** Render the immediate operand as HEX integer. */ +#define FCML_REND_FLAG_HEX_IMM 0x00000002 +/** Render the segment code register even if it is a default one. */ +#define FCML_REND_FLAG_RENDER_DEFAULT_SEG 0x00000004 +/** Render the displacement value as HEX integer. */ +#define FCML_REND_FLAG_HEX_DISPLACEMENT 0x00000008 +/** Render the conditional mnemonics using suffixes from first group. */ +#define FCML_REND_FLAG_COND_GROUP_1 0x00000010 +/** Render the conditional mnemonics using suffixes from second group. */ +#define FCML_REND_FLAG_COND_GROUP_2 0x00000020 +/** Render the conditional mnemonics using suffixes for 'carry'. */ +#define FCML_REND_FLAG_COND_SHOW_CARRY 0x00000040 +/** Render SIB operand hints. */ +#define FCML_REND_FLAG_RENDER_SIB_HINT 0x00000080 +/** Render ABS (Absolute offset) operand hints. */ +#define FCML_REND_FLAG_RENDER_ABS_HINT 0x00000100 +/** Render REL (Relative offset) operand hints. */ +#define FCML_REND_FLAG_RENDER_REL_HINT 0x00000200 +/** Render hints for absolute addressing. */ +#define FCML_REND_FLAG_RENDER_INDIRECT_HINT 0x00000400 +/** Renders repetition prefixes using the first group (repe,repne). */ +#define FCML_REND_FLAG_REP_PREFIX_GROUP_1 0x00000800 +/** Renders repetition prefixes using the second group (repz,repnz). */ +#define FCML_REND_FLAG_REP_PREFIX_GROUP_2 0x00001000 +/** Renders the code padding between the instruction code and the mnemonic. */ +#define FCML_REND_FLAG_CODE_PADDING 0x00002000 +/** Renders the mnemonic padding between the mnemonic and the operands. */ +#define FCML_REND_FLAG_MNEMONIC_PADDING 0x00004000 +/** Should be used only with FCML_REND_FLAG_HEX_IMM and FCML_REND_FLAG_ + * HEX_DISPLACEMENT flags. */ +#define FCML_REND_FLAG_REMOVE_LEADING_ZEROS 0x00008000 + +/** Default set of the rendering flags. */ +#define FCML_REND_DEFAULT_FLAGS 0 +/** Default number of characters used as code padding. */ +#define FCML_REND_DEFAULT_CODE_PADDING 8 +/** Default number of characters used as mnemonic padding. */ +#define FCML_REND_DEFAULT_MNEMONIC_PADDING 8 + +/** @} */ + +/** Renderer configuration. */ +typedef struct fcml_st_render_config { + /** Flags which allows to control rendering process. */ + fcml_uint32_t render_flags; + /** Preferred mnemonic padding in characters. */ + fcml_uint16_t prefered_mnemonic_padding; + /** Preferred code padding in HEX bytes (2 characters on one byte.). */ + fcml_uint16_t prefered_code_padding; +} fcml_st_render_config; + +/** + * Renders the disassembled instruction into its textual representation. + * Prepares textual representation of the disassembled code using syntax + * based on the provided dialect. + * + * @param dialect Dialect instance. + * @param config Renderer configuration. + * @param[out] buffer Destination buffer for the generated instruction. + * @param buffer_len Size of the destination buffer. + * @param result Disassembled instruction. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + * + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_render( + const fcml_st_dialect *dialect, const fcml_st_render_config *config, + fcml_char *buffer, fcml_usize buffer_len, + const fcml_st_disassembler_result *result); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_REND_H_ */ diff --git a/dependencies/fcml/include/fcml_renderer.hpp b/dependencies/fcml/include/fcml_renderer.hpp new file mode 100644 index 0000000..962b966 --- /dev/null +++ b/dependencies/fcml/include/fcml_renderer.hpp @@ -0,0 +1,226 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_renderer.hpp + * C++ wrapper for FCML renderer. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_RENDERER_HPP_ +#define FCML_RENDERER_HPP_ + +#include "fcml_common.hpp" +#include "fcml_disassembler.hpp" +#include "fcml_renderer.h" + +namespace fcml { + +/** + * Component can not be initialized correctly. + */ +class RenderingFailedException: public BaseException { +public: + RenderingFailedException(const fcml_cstring &msg, fcml_ceh_error error = + FCML_CEH_GEC_NO_ERROR) : + BaseException(msg, error) { + } +}; + +/** Renderer configuration. + * + * It's a counterpart to the fcml_st_render_config structure. + * @since 1.1.0 + */ +class RenderConfig { +public: + + /** + * Creates an empty renderer configuration. + * @since 1.1.0 + */ + RenderConfig() : + _throwExceptionOnError(true), + _renderFlags(0), + _preferedMnemonicPadding(FCML_REND_DEFAULT_MNEMONIC_PADDING), + _preferedCodePadding(FCML_REND_DEFAULT_CODE_PADDING) { + } + + /** + * Creates a renderer configuration for given renderer flags. + * + * @param renderFlags The renderer flags. + * @since 1.1.0 + */ + RenderConfig(fcml_uint32_t renderFlags) : + _throwExceptionOnError(true), + _renderFlags(renderFlags), + _preferedMnemonicPadding(0), + _preferedCodePadding(0) { + } + + /** @since 1.1.0 */ + fcml_uint16_t getPreferedCodePadding() const { + return _preferedCodePadding; + } + + /** @since 1.1.0 */ + void setPreferedCodePadding(fcml_uint16_t preferedCodePadding) { + _preferedCodePadding = preferedCodePadding; + } + + /** @since 1.1.0 */ + fcml_uint16_t getPreferedMnemonicPadding() const { + return _preferedMnemonicPadding; + } + + /** @since 1.1.0 */ + void setPreferedMnemonicPadding(fcml_uint16_t preferedMnemonicPadding) { + _preferedMnemonicPadding = preferedMnemonicPadding; + } + + /** @since 1.1.0 */ + fcml_uint32_t getRenderFlags() const { + return _renderFlags; + } + + /** @since 1.1.0 */ + void setRenderFlags(fcml_uint32_t renderFlags) { + _renderFlags = renderFlags; + } + + /** + * Returns true if exception should be thrown when disassembling fails. + * + * @return True if exception is the preferred way of error handling + * in case of failure. + * @since 1.1.0 + */ + bool isThrowExceptionOnError() const { + return _throwExceptionOnError; + } + + /** + * Sets the way how the error handling is done. + * + * @param throwExceptionOnError True if exception should be thrown + * in case of failure. + * @since 1.1.0 + */ + void setThrowExceptionOnError(bool throwExceptionOnError) { + _throwExceptionOnError = throwExceptionOnError; + } + +private: + + /** Throws exception in case of error. */ + bool _throwExceptionOnError; + /** Flags which allows to control rendering process. */ + fcml_uint32_t _renderFlags; + /** Preferred mnemonic padding in characters. */ + fcml_uint16_t _preferedMnemonicPadding; + /** Preferred code padding in HEX bytes (2 characters on one byte.). */ + fcml_uint16_t _preferedCodePadding; + +}; + +/** + * Converts objects to their structures counterparts. + * @since 1.1.0 + * @remarks Internal API, not intended to be used outside. + */ +class RenderTypeConverter { +public: + + static void convert(const RenderConfig &src, fcml_st_render_config &dest) { + dest.prefered_code_padding = src.getPreferedCodePadding(); + dest.prefered_mnemonic_padding = src.getPreferedMnemonicPadding(); + dest.render_flags = src.getRenderFlags(); + } + +}; + +/** Renderer wrapper. + * @since 1.1.0 + */ +class Renderer: protected DialectAware { +public: + + /** + * Creates a renderer instance for the given dialect. + * + * @param dialect The dialect instance. + * @since 1.1.0 + */ + Renderer(Dialect &dialect) : + _dialect(dialect) { + } + + /** + * Renders a disassembled instruction. + * + * @param renderConfig A renderer configuration. + * @param assemblerResult The disassembler result. + * @param[out] result The rendered instruction. + * @throw RenderingFailedException Rendering failed. + * @return The error code. + */ + fcml_ceh_error render(const RenderConfig &renderConfig, + DisassemblerResult &assemblerResult, fcml_cstring &result) { + + result.clear(); + + fcml_st_render_config render_config; + RenderTypeConverter::convert(renderConfig, render_config); + + fcml_st_disassembler_result disassembler_result; + fcml_fn_disassembler_result_prepare(&disassembler_result); + + DisassemblerTypeConverter::convert(assemblerResult, + disassembler_result); + + fcml_char buffer[FCML_REND_MAX_BUFF_LEN]; + + fcml_ceh_error error = ::fcml_fn_render(extractDialect(_dialect), + &render_config, buffer, FCML_REND_MAX_BUFF_LEN, + &disassembler_result); + + DisassemblerTypeConverter::free(disassembler_result); + + if (error && renderConfig.isThrowExceptionOnError()) { + throw RenderingFailedException( + FCML_TEXT("Can not render instruction."), error); + } + + result = buffer; + + return error; + } + +private: + + /** The dialect instance associated with the renderer. */ + Dialect &_dialect; + +}; + +} + +#endif /* FCML_RENDERER_HPP_ */ diff --git a/dependencies/fcml/include/fcml_stateful_assembler.hpp b/dependencies/fcml/include/fcml_stateful_assembler.hpp new file mode 100644 index 0000000..b87cc00 --- /dev/null +++ b/dependencies/fcml/include/fcml_stateful_assembler.hpp @@ -0,0 +1,554 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_stateful_assembler.hpp + * Stateful FCML assembler implementation. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_STATEFUL_ASSEMBLER_HPP_ +#define FCML_STATEFUL_ASSEMBLER_HPP_ + +#include + +#include "fcml_assembler.hpp" +#include "fcml_parser.hpp" + +namespace fcml { + +/** + * It's a stateful assembler which can be used to assemble instructions one by + * one on the fly. By default is works with the general instruction models as + * well as with instruction builders, but it can be also configured to parse + * whole statements using internally managed parser. It holds it's own state, + * so it's not necessary to update instruction pointer etc while it's working. + * Assembled instructions are placed inside a dedicated vector, but generated + * machine code is accessing + * directly by the dedicated CodeIterator. + * + * @since 1.1.0 + * @remarks This class isn't thread-safe. + */ +class StatefulAssembler { +public: + + /** Used only to indicate the need of the flush operation. */ + class SAFlush { + }; + + /** + * Creates a stateful assembler for the given assembler and assembler + * context. Bear in mind that assembler and context are not copied in + * any way and have to be valid as long as the stateful assembler in in + * use. Parsing support can be enabled optionally using the third parameter. + * + * @param assembler The assembled that will be used to assemble the code. + * @param context The assembler context. + * @param enableParser Enables parsing support. + * @since 1.1.0 + */ + StatefulAssembler(Assembler &assembler, AssemblerContext &context, + bool enableParser = false) : + _instructionBuilder(IB(FCML_TEXT("")), false), + _assembler(assembler), + _context(context), + _codeLength(0) { + // Create parser if needed. + _parser = enableParser ? new Parser(assembler.getDialect()) : NULL; + } + + /** Destructor. + * @since 1.1.0 + */ + virtual ~StatefulAssembler() { + if (_parser) { + delete _parser; + } + } + + /** + * Adds instruction builder to the stateful assembler. Such a instruction + * builder will be used then to assemble an instruction it represents. + * Before any operation is performed, pending instruction is flushed if + * there is any available. + * + * @param ib The instruction builder to be flushed. + * @return The stateful assembler itself. + * @throw AssemblingFailedException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const IB &ib) { + return add(ib); + } + + /** + * Adds instruction builder to the stateful assembler. Such a instruction + * builder will be used then to assemble an instruction it represents. + * Before any operation is performed, pending instruction is flushed if + * there is any available. + * + * @param ib The instruction builder to be flushed. + * @return The stateful assembler itself. + * @throw AssemblingFailedException + * @since 1.1.0 + */ + StatefulAssembler& add(const IB &ib) { + flush(); + _instructionBuilder.setNotNull(true); + _instructionBuilder.setValue(ib); + return *this; + } + + /** + * Creates an instruction builder for the given mnemonic. + * + * @param mnemonic The instruction mnemonic. + * @return The stateful assembler itself. + * @throw AssemblingFailedException, ParsingFailedException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const fcml_cstring &mnemonic) { + return inst(mnemonic); + } + + /** + * Creates an instruction builder for the given mnemonic. + * + * @param mnemonic The instruction mnemonic. + * @return The stateful assembler itself. + * @throw AssemblingFailedException, ParsingFailedException + * @since 1.1.0 + */ + StatefulAssembler& inst(const fcml_cstring &mnemonic) { + flush(); + if (_parser) { + // Parse instruction and then pass it to the assembler. + _parserContext.setIp(_context.getEntryPoint().getIP()); + ParserConfig &config = _parserContext.getConfig(); + config.setThrowExceptionOnError(true); + _parser->parse(_parserContext, mnemonic, _parserResult); + *this << _parserResult.getInstruction(); + } else { + // Parser is not available, so treat this string as a full + // instruction which have to be parsed. + _instructionBuilder.setNotNull(true); + _instructionBuilder.setValue(IB(mnemonic)); + } + return *this; + } + + /** + * Adds the new register operand to the instruction builder associated + * with the buffer. + * + * @param reg The register. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const Register ®) { + return op(Operand(reg)); + } + + /** + * Adds the new immediate operand to the instruction builder associated + * with the buffer. + * + * @param imm The immediate value. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const Integer &imm) { + return op(Operand(imm)); + } + + /** + * Adds the new address operand to the instruction builder associated + * with the buffer. + * + * @param address The address. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const Address &address) { + return op(Operand(address)); + } + + /** + * Adds the new far pointer operand to the instruction builder associated + * with the buffer. + * + * @param pointer The far pointer. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const FarPointer &pointer) { + return op(Operand(pointer)); + } + + /** + * Adds an operand to the instruction builder associated with the buffer. + * + * @param operand The operand to be added. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const Operand &operand) { + return op(operand); + } + + /** + * Adds an operand to the instruction builder associated with the buffer. + * + * @param operand The operand to be added.. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& op(const Operand &operand) { + if (!_instructionBuilder.isNotNull()) { + throw IllegalStateException( + FCML_TEXT("No instruction builder available.")); + } + IB &ib = _instructionBuilder.getValue(); + ib.op(operand); + return *this; + } + + /** + * Adds the new register operand to the instruction builder associated + * with the buffer. + * + * @param reg The register. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& op(const Register ®) { + return op(Operand(reg)); + } + + /** + * Adds the new immediate operand to the instruction builder associated + * with the buffer. + * + * @param imm The immediate value. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& op(const Integer &imm) { + return op(Operand(imm)); + } + + /** + * Adds the new address operand to the instruction builder associated + * with the buffer. + * + * @param address The address. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& op(const Address &address) { + return op(Operand(address)); + } + + /** + * Adds the new far pointer operand to the instruction builder associated + * with the buffer. + * + * @param pointer The far pointer. + * @return The stateful assembler itself. + * @throw IllegalStateException + * @since 1.1.0 + */ + StatefulAssembler& op(const FarPointer &pointer) { + return op(Operand(pointer)); + } + + /** + * Flushes the instruction builder. + * @param indic Flush indicator. + * @return The stateful assembler itself. + * @throw AssemblingFailedException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const SAFlush &indic) { + flush(); + return *this; + } + + /** + * Assembles an instruction in the given instruction builder. + * + * @param instruction Instruction to be assembled. + * @return Stateful assembler. + * @throw AssemblingFailedException + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const Instruction &instruction) { + return inst(instruction); + } + + /** + * Adds a prefix to the instruction being built. + * @param prefix The prefix to be added. + * @return The instruction builder with the new prefix set for it. + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const InstructionPrefix &prefix) { + return set(prefix); + } + + /** + * Adds an instruction level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const InstructionHint &hint) { + return set(hint); + } + + /** + * Adds an operand level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + StatefulAssembler& operator <<(const OperandHint &hint) { + return set(hint); + } + + /** + * Adds a prefix to the instruction being built. + * @param prefix The prefix to be added. + * @return The instruction builder with the new prefix set for it. + * @since 1.1.0 + */ + StatefulAssembler& set(const InstructionPrefix &prefix) { + if (!_instructionBuilder.isNotNull()) { + throw IllegalStateException( + FCML_TEXT("No instruction builder available.")); + } + _instructionBuilder.getValue() << prefix; + return *this; + } + + /** + * Adds an instruction level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + StatefulAssembler& set(const InstructionHint &hint) { + if (!_instructionBuilder.isNotNull()) { + throw IllegalStateException( + FCML_TEXT("No instruction builder available.")); + } + _instructionBuilder.getValue() << hint; + return *this; + } + + /** + * Adds an operand level hint to the instruction being built. + * @param hint The hint to be added. + * @return The instruction builder with the new hint added to it. + * @since 1.1.0 + */ + StatefulAssembler& set(const OperandHint &hint) { + if (!_instructionBuilder.isNotNull()) { + throw IllegalStateException( + FCML_TEXT("No instruction builder available.")); + } + _instructionBuilder.getValue() << hint; + return *this; + } + + /** + * Assembles an instruction in the given instruction builder. + * + * @param instruction Instruction to be assembled. + * @return Stateful assembler. + * @throw AssemblingFailedException + * @since 1.1.0 + */ + StatefulAssembler& inst(const Instruction &instruction) { + + // Flush pending instruction if there is any. + flush(); + + // Just in case. + AssemblerConf &config = _context.getConfig(); + config.setIncrementIp(true); + config.setThrowExceptionOnError(true); + + // Assembler the instruction. + _assembler.assemble(_context, instruction, _result); + + // Store the chosen assembled instruction for future use. + const AssembledInstruction *assembledInstruction = + _result.getChosenInstruction(); + if (assembledInstruction) { + _assembledInstructions.push_back(*assembledInstruction); + _codeLength += assembledInstruction->getCodeLength(); + } else { + throw AssemblingFailedException( + FCML_TEXT("Chosen instruction hasn't been set. It seems " + "that the instruction chooser isn't working " + "correctly.")); + } + + return *this; + } + + /** + * Gets iterator which allows to iterate through the whole machine + * code byte by byte. + * + * @return Iterator instance. + * @since 1.1.0 + */ + CodeIterator getCodeIterator() { + flush(); + return CodeIterator(_assembledInstructions); + } + + /** + * Gets all chosen assembled instructions. + * + * @return All assembled instructions available in the buffer. + * @since 1.1.0 + */ + std::vector& getAssembledInstructions() { + flush(); + return _assembledInstructions; + } + + /** + * Gets the code length of all assembled instructions available. + * + * @return The code length. + * @since 1.1.0 + */ + fcml_usize getCodeLength() { + flush(); + return _codeLength; + } + + /** + * Assembles all pending instructions. + * @since 1.1.0 + * @throw AssemblingFailedException + */ + void flush() { + if (_instructionBuilder.isNotNull()) { + // Build an instruction using the instruction builder. + Instruction instruction = _instructionBuilder.getValue().build(); + // And clean the builder, is everything succeed. + _instructionBuilder.setNotNull(false); + // Assemble the instruction. + *this << instruction; + } + } + + /** + * Creates flush indicated for "shift" operators. + * @return Flush indicator. + * @since 1.1.0 + */ + static SAFlush FLUSH() { + return SAFlush(); + } + + /** Gets configuration used by parser if parsing is supported. + * @return Parser configuration. + */ + const ParserConfig& getParserConfig() const { + return _parserContext.getConfig(); + } + + /** Gets configuration used by parser if parsing is supported. + * @return Parser configuration. + * @since 1.1.0 + */ + ParserConfig& getParserConfig() { + return _parserContext.getConfig(); + } + + /** + * Gets symbol table used together with the parser. + * @return The symbol table used by the parser. + * @since 1.1.0 + */ + const SymbolTable* getSymbolTable() const { + return _parserContext.getSymbolTable(); + } + + /** + * Gets symbol table used together with the parser. + * @return The symbol table used by the parser. + * @since 1.1.0 + */ + SymbolTable* getSymbolTable() { + return _parserContext.getSymbolTable(); + } + + /** + * Sets a new symbol table for the parser. + * @param symbolTable The new symbol table. + * @since 1.1.0 + */ + void setSymbolTable(SymbolTable *symbolTable) { + _parserContext.setSymbolTable(symbolTable); + } + +private: + + /** An instruction parser. */ + Parser *_parser; + /** Parser result used when parsing is supported. */ + ParserResult _parserResult; + /** Parser context. */ + ParserContext _parserContext; + /** A disassembled result used by the assembler when needed. */ + AssemblerResult _result; + /** Currently used instruction builder. */ + Nullable _instructionBuilder; + /* Assembler used to assemble code. */ + Assembler &_assembler; + /** Assembler context. */ + AssemblerContext &_context; + // Assembled instructions. + std::vector _assembledInstructions; + /** Length of the code assembled so far. */ + fcml_usize _codeLength; + +}; + +} + +#endif /* FCML_STATEFUL_ASSEMBLER_HPP_ */ diff --git a/dependencies/fcml/include/fcml_stateful_disassembler.hpp b/dependencies/fcml/include/fcml_stateful_disassembler.hpp new file mode 100644 index 0000000..83c6e54 --- /dev/null +++ b/dependencies/fcml/include/fcml_stateful_disassembler.hpp @@ -0,0 +1,210 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_stateful_disassembler.hpp + * Stateful FCML disassembler implementation. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_STATEFUL_DISASSEMBLER_HPP_ +#define FCML_STATEFUL_DISASSEMBLER_HPP_ + +#include "fcml_disassembler.hpp" +#include "fcml_renderer.hpp" + +namespace fcml { + +/** Stateful disassembler can be used when you have to disassemble a larger + * piece of code one instruction by one. + * It also supports rendering directly using internally managed renderer. + * + * @since 1.1.0 + * @remarks This class isn't thread-safe. + */ +class StatefulDisassembler { +public: + + /** Creates a stateful disassembler for given FCML disassembler and context. + * Rendering support can be enabled optionally. + * @param disassembler The classic FCML disassembler used to + * disassemble instructions. + * @param context The disassembler context. + * @param enableRendering Enables instruction rendering, which is + * disabled by default. + */ + StatefulDisassembler(Disassembler &disassembler, + DisassemblerContext &context, bool enableRendering = false) : + _disassembler(disassembler), + _disassemblerContext(context) { + _renderer = enableRendering ? + new Renderer(disassembler.getDialect()) : NULL; + // End of line characters to be used when instructions are + // rendered directly to the output stream. +#if defined(_WIN32) + _endOfLine = FCML_TEXT( "\r\n" ); +#else + _endOfLine = FCML_TEXT("\n"); +#endif + } + + /** Destructor. */ + virtual ~StatefulDisassembler() { + if (_renderer) { + delete _renderer; + } + } + + /** + * Disassembles the next instruction pointed by the disassembler state. + * @param[out] instruction The destination instruction model. + * @return A reference to the stateful disassembler. + * @throws DisassemblingFailedException + * @since 1.1.0 + */ + StatefulDisassembler& operator >>(Instruction &instruction) { + + // IP has to be incremented automatically, instruction by instruction. + DisassemblerConf &config = _disassemblerContext.getDisassemblerConf(); + config.setIncrementIp(true); + config.setThrowExceptionOnError(true); + + // We don't care about error handling here, because it's disassembler + // who is responsible for correctly handling it. + _disassembler.disassemble(_disassemblerContext, _disassemblerResult); + + instruction = _disassemblerResult.getInstruction(); + + return *this; + + } + + /** + * Disassembles the next instruction from the buffer and renders it. + * @param[out] instruction Destination string for the instruction. + * @return A reference to the stateful disassembler. + * @throws DisassemblingFailedException, + * IllegalStateException, + * RenderingFailedException + * @since 1.1.0 + */ + StatefulDisassembler& operator >>(fcml_cstring &instruction) { + + if (!_renderer) { + throw IllegalStateException(FCML_TEXT("Rendering is disabled.")); + } + + // IP has to be incremented automatically, instruction by instruction. + DisassemblerConf &config = _disassemblerContext.getDisassemblerConf(); + config.setIncrementIp(true); + config.setThrowExceptionOnError(true); + + _disassembler.disassemble(_disassemblerContext, _disassemblerResult); + + _rendererConfig.setThrowExceptionOnError(true); + _renderer->render(_rendererConfig, _disassemblerResult, instruction); + + return *this; + + } + + /** + * Disassembles the next instruction from the buffer and renders it + * directly into the output stream. + * @param[out] ostream The output stream. + * @return A reference to the stateful disassembler. + * @throws DisassemblingFailedException, + * IllegalStateException, + * RenderingFailedException + * @since 1.1.0 + */ + StatefulDisassembler& operator >>(fcml_costream &ostream) { + + fcml_cstring instruction; + + // Render the next instruction into a string. + *this >> instruction; + + // Appends the instruction into an output stream. + ostream << instruction << _endOfLine; + + return *this; + + } + + /** + * Gets renderer configuration used by the instruction buffer. + * @return The renderer configuration. + * @since 1.1.0 + */ + RenderConfig& getRendererConfig() { + return _rendererConfig; + } + + /** + * Gets renderer configuration used by the internally managed + * instruction renderer. + * @return The renderer configuration. + * @since 1.1.0 + */ + const RenderConfig& getRendererConfig() const { + return _rendererConfig; + } + + /** + * Gets end of line characters sequence used by the renderer. + * + * @return End of line characters sequence used by the renderer. + * @since 1.1.0 + */ + const fcml_cstring& getEndOfLine() const { + return _endOfLine; + } + + /** + * Sets dedicated end of line characters. + * + * @param endOfLine A sequence of characters used as line ending. + * @since 1.1.0 + */ + void setEndOfLine(const fcml_cstring &endOfLine) { + _endOfLine = endOfLine; + } + +private: + + /** End of line character sequence. */ + fcml_cstring _endOfLine; + /** Disassembler result used when disassembling instructions. */ + DisassemblerResult _disassemblerResult; + /** The disassembler used to disassemble the code. */ + Disassembler &_disassembler; + /** Disassembler context pointing to the machine code. */ + DisassemblerContext &_disassemblerContext; + /** Renderer configuration used when instructions have to be rendered. */ + RenderConfig _rendererConfig; + /** Optional renderer used only when instructions are rendered. */ + Renderer *_renderer; + +}; + +} + +#endif /* FCML_STATEFUL_DISASSEMBLER_HPP_ */ diff --git a/dependencies/fcml/include/fcml_symbols.h b/dependencies/fcml/include/fcml_symbols.h new file mode 100644 index 0000000..68fa5a6 --- /dev/null +++ b/dependencies/fcml/include/fcml_symbols.h @@ -0,0 +1,149 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_symbols.h + * API for symbols handling. Currently used only by parsers. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_SYMBOLS_H_ +#define FCML_SYMBOLS_H_ + +#include "fcml_lib_export.h" +#include "fcml_common.h" +#include "fcml_errors.h" + +/** Type for symbol tables. */ +typedef fcml_ptr fcml_st_symbol_table; + +/********************************* + * Symbols. + *********************************/ + +/** Represents one named symbol with associated value. */ +typedef struct fcml_st_symbol { + /* The symbol name. */ + fcml_string symbol; + /* The symbol value. */ + fcml_int64_t value; +} fcml_st_symbol; + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Allocates new symbol on FCML library heap. + * This function should be always used when symbols + * are added using fcml_fn_symbol_add() function. + * @return Allocated symbol or NULL if allocation failed. + */ +LIB_EXPORT fcml_st_symbol* LIB_CALL fcml_fn_symbol_alloc( + const fcml_string symbol, fcml_int64_t value); + +/** + * Frees symbol allocated by FCML library. + * @param symbol The symbol to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_symbol_free(fcml_st_symbol *symbol); + +/** + * Allocates new symbol table. + * @return The allocated symbol table or NULL if something failed. + */ +LIB_EXPORT fcml_st_symbol_table LIB_CALL fcml_fn_symbol_table_alloc(); + +/** + * Adds new symbol to the symbol table. + * This function is more secure than fcml_fn_symbol_add() because it + * always allocates new symbol instance internally, so you do not have + * to pay attention not to pass the symbol allocated on the different heap + * to the symbol table. After the symbol has been properly added you can + * safely free the name because this function duplicates the name + * to the symbol needs. Of course the symbol as well as the duplicated name + * are freed by fcml_fn_symbol_table_free() function. You can also + * free it on your own if the symbol is not managed by symbol table + * using fcml_fn_symbol_free() function. + * @param symbol_table The symbol table. + * @param symbol The symbol name. + * @param value The symbol value. + * @see fcml_fn_symbol_table_free + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_symbol_add_raw( + fcml_st_symbol_table symbol_table, const fcml_string symbol, + fcml_int64_t value); + +/** + * Adds existing symbol to the symbol table. + * Remember that only symbols allocated on FCML heap should be + * added there. Of course in some cases heaps are shared so + * it will works without any problems but even if they are you + * should use fcml_fn_symbol_table_alloc() function to allocate + * every symbol. + * + * @param symbol_table The symbol table where new symbol should be placed. + * @param symbol The symbol to be added. + * @return Error code or FCML_CEH_GEC_NO_ERROR. + */ +LIB_EXPORT fcml_ceh_error LIB_CALL fcml_fn_symbol_add( + fcml_st_symbol_table symbol_table, const fcml_st_symbol *symbol); + +/** + * Removes the symbol from the symbol table. + * The removed symbol is automatically freed. + * @param symbol_table The symbol table. + * @param symbol The name of the symbol to remove. + */ +LIB_EXPORT void LIB_CALL fcml_fn_symbol_remove( + fcml_st_symbol_table symbol_table, const fcml_string symbol); + +/** + * Gets the symbol with the given name from the symbol table. + * @param symbol_table The symbol table. + * @param symbol The name of the symbol to get from the table. + * @return The pointer to the symbol or NULL if there is no such symbol + * in the symbol table. + */ +LIB_EXPORT fcml_st_symbol* LIB_CALL fcml_fn_symbol_get( + fcml_st_symbol_table symbol_table, const fcml_string symbol); + +/** + * Removes all symbols from the symbol table. + * Removes and frees all symbols from the given symbol table + * but does not free the symbol table itself. + * @param symbol_table The symbol table to be cleared. + */ +LIB_EXPORT void LIB_CALL fcml_fn_symbol_remove_all( + fcml_st_symbol_table symbol_table); + +/** + * Frees a symbol table. + * Frees all symbols as well as the symbol table itself. + * @param symbol_table A symbol table to be freed. + */ +LIB_EXPORT void LIB_CALL fcml_fn_symbol_table_free( + fcml_st_symbol_table symbol_table); + +#ifdef __cplusplus +} +#endif + +#endif /* FCML_SYMBOLS_H_ */ diff --git a/dependencies/fcml/include/fcml_symbols.hpp b/dependencies/fcml/include/fcml_symbols.hpp new file mode 100644 index 0000000..2ec3049 --- /dev/null +++ b/dependencies/fcml/include/fcml_symbols.hpp @@ -0,0 +1,265 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2019 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_symbols.hpp + * C++ API for symbols handling. Currently used only by parsers. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_SYMBOLS_HPP_ +#define FCML_SYMBOLS_HPP_ + +#include + +#include "fcml_common.hpp" +#include "fcml_symbols.h" + +namespace fcml { + +/** + * Represents one named symbol with associated value. + * @since 1.1.0 + */ +class Symbol { +public: + + /** + * Creates an empty symbol. + * @since 1.1.0 + */ + Symbol() : + _value(0) { + } + + /** + * Creates a symbol instance for the given name and value. + * + * @param name The symbol name. + * @param value The symbol value. + * @since 1.1.0 + */ + Symbol(const fcml_cstring &name, fcml_int64_t value) : + _name(name), _value(value) { + } + + /** + * Gets symbol value. + * @since 1.1.0 + */ + operator fcml_uint64_t() const { + return _value; + } + + /** + * Gets symbol value. + * @since 1.1.0 + */ + operator fcml_int64_t() const { + return static_cast(_value); + } + + /** + * Gets true if symbol is empty. + * + * @return True if symbol is empty. + * @since 1.1.0 + */ + bool isEmpty() const { + return _name.empty(); + } + + /** + * Gets the symbol name. + * + * @return The symbol name. + * @since 1.1.0 + */ + const fcml_cstring& getName() const { + return _name; + } + + /** + * Gets the symbol value. + * + * @return The symbol value. + * @since 1.1.0 + */ + fcml_uint64_t getValue() const { + return _value; + } + + /** + * Sets a new symbol name. + * + * @param name The symbol name. + * @since 1.1.0 + */ + void setName(const fcml_cstring &name) { + _name = name; + } + + /** + * Sets a new symbol value. + * + * @param value The symbol value. + * @since 1.1.0 + */ + void setValue(fcml_uint64_t value) { + _value = value; + } + +private: + + // Symbol name. + fcml_cstring _name; + // Symbol value. + fcml_uint64_t _value; + +}; + +/* Due to the performance purposes and the way symbol table is managed + * internally, it has to be wrapped directly without doing any conversions + * when needed. + * @since 1.1.0 + */ +class SymbolTable: public NonCopyable { +public: + + /** + * Creates an empty symbol table. + * @throw InitException The symbol table can't be allocated. + * @since 1.1.0 + */ + SymbolTable() : + _symbolTable(NULL) { + _symbolTable = ::fcml_fn_symbol_table_alloc(); + if (!_symbolTable) { + throw InitException( + FCML_TEXT( + "Symbol table can not be initialized correctly.")); + } + } + + /** + * Destructor. + * @since 1.1.0 + */ + virtual ~SymbolTable() { + if (_symbolTable) { + ::fcml_fn_symbol_table_free(_symbolTable); + _symbolTable = NULL; + } + } + +protected: + + friend class SymbolTableAware; + + /** + * Gets native FCML symbol table. + * @return The native symbol table. + * @since 1.1.0 + */ + fcml_st_symbol_table& getSymbolTable() { + return _symbolTable; + } + +public: + + /** + * Adds a new symbol to the table. + * + * @param symbolName The symbol name. + * @param value The symbol value. + * @since 1.1.0 + */ + void add(const fcml_cstring &symbolName, fcml_int64_t value) { + if (::fcml_fn_symbol_add_raw(_symbolTable, symbolName.c_str(), value) + == FCML_CEH_GEC_OUT_OF_MEMORY) { + throw std::bad_alloc(); + } + } + + /** + * Removes symbol from the table. + * + * @param symbolName The symbol name. + * @since 1.1.0 + */ + void remove(const fcml_cstring &symbolName) { + const fcml_string key = symbolName.c_str(); + ::fcml_fn_symbol_remove(_symbolTable, key); + } + + /** + * Gets true if there is a symbol for the given name in the table. + * + * @param symbolName The symbol name. + * @return true If symbol of the name exists in the table. + * @since 1.1.0 + */ + bool contains(const fcml_cstring &symbolName) const { + return ::fcml_fn_symbol_get(_symbolTable, symbolName.c_str()) != NULL; + } + + /** + * Gets the symbol of the given name. Checks Symbol.isEmpty method of the + * returned symbol to check if there is such a symbol. + * + * @param symbolName The symbol name. + * @return The found symbol. + * @since 1.1.0 + */ + Symbol get(const fcml_cstring &symbolName) const { + Symbol symbol; + fcml_st_symbol *found_symbol = ::fcml_fn_symbol_get(_symbolTable, + symbolName.c_str()); + if (found_symbol) { + symbol.setName(found_symbol->symbol); + symbol.setValue(found_symbol->value); + } + return symbol; + } + +private: + /** The native FCML symbol table. */ + fcml_st_symbol_table _symbolTable; +}; + +/** + * Derive from this class if you really need access to the native symbol table. + * @since 1.1.0 + */ +class SymbolTableAware { +public: + + /** + * Extracts the native symbol table for the given symbol table wrapper. + * @param symbolTable The symbol table wrapper. + * @since 1.1.0 + */ + fcml_st_symbol_table& extractSymbolTable(SymbolTable &symbolTable) { + return symbolTable.getSymbolTable(); + } +}; + +} +#endif /* FCML_SYMBOLS_HPP_ */ diff --git a/dependencies/fcml/include/fcml_types.h b/dependencies/fcml/include/fcml_types.h new file mode 100644 index 0000000..fe9ecd8 --- /dev/null +++ b/dependencies/fcml/include/fcml_types.h @@ -0,0 +1,271 @@ +/* + * FCML - Free Code Manipulation Library. + * Copyright (C) 2010-2015 Slawomir Wojtasiak + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** @file fcml_types.h + * Types declarations. + * + * @copyright Copyright (C) 2010-2015 Slawomir Wojtasiak. All rights reserved. + * This project is released under the GNU Lesser General Public License. + */ + +#ifndef FCML_TYPES_H_ +#define FCML_TYPES_H_ + +/* If config.h is available, we depend on it; otherwise we give + * the responsibility to handle headers appropriately to the compiler runtime. + **/ +#ifdef HAVE_CONFIG_H +#include +#ifdef HAVE_STDDEF_H +#include +#endif +#if HAVE_STDINT_H +#include +#endif +#if HAVE_INTTYPES_H +#include +#endif +#else +#if defined(_MSC_VER) && defined(_WIN32) +#include +#define FCML_MSCC +/* Disable unit specific lexer features. */ +#define YY_NO_INPUT 1 +#define YY_NO_UNISTD_H 1 +#else +#include +#include +#include +#endif +#endif + +#include "fcml_lib_export.h" + +/** Used to code literal strings. It will be useful if FCML supports UNICODE in the future. */ +#define FCML_TEXT(x) x +#define _FT(x) FCML_TEXT(x) + +#ifdef FCML_MSCC + +#define FCML_PRI_INT8_DEC "%d" +#define FCML_PRI_INT16_DEC "%d" +#define FCML_PRI_INT32_DEC "%d" +#define FCML_PRI_INT64_DEC "%lld" + +#define FCML_PRI_UINT8_DEC "%u" +#define FCML_PRI_UINT16_DEC "%u" +#define FCML_PRI_UINT32_DEC "%u" +#define FCML_PRI_UINT64_DEC "%llu" + +#define FCML_PRI_INT8_HEX "%02x" +#define FCML_PRI_INT16_HEX "%04x" +#define FCML_PRI_INT32_HEX "%08x" +#define FCML_PRI_INT64_HEX "%016llx" + +#define FCML_PRI_INT8_HEX_NO_ZEROS "%x" +#define FCML_PRI_INT16_HEX_NO_ZEROS "%x" +#define FCML_PRI_INT32_HEX_NO_ZEROS "%x" +#define FCML_PRI_INT64_HEX_NO_ZEROS "%llx" + +typedef int fcml_int; +typedef int fcml_bool; +typedef __int8 fcml_int8_t; +typedef unsigned __int8 fcml_uint8_t; +typedef __int16 fcml_int16_t; +typedef unsigned __int16 fcml_uint16_t; +typedef __int32 fcml_int32_t; +typedef unsigned __int32 fcml_uint32_t; +typedef __int64 fcml_int64_t; +typedef unsigned __int64 fcml_uint64_t; + +/* Signed integers. */ +#define FCML_INT64_MAX _I64_MAX +#define FCML_INT64_MIN _I64_MIN +#define FCML_INT32_MAX INT_MAX +#define FCML_INT32_MIN INT_MIN +#define FCML_INT16_MAX SHRT_MAX +#define FCML_INT16_MIN SHRT_MIN +#define FCML_INT8_MAX SCHAR_MAX +#define FCML_INT8_MIN SCHAR_MIN + +/* Unsigned integers. */ +#define FCML_UINT8_MAX UCHAR_MAX +#define FCML_UINT16_MAX USHRT_MAX +#define FCML_UINT32_MAX UINT_MAX +#define FCML_UINT64_MAX _UI64_MAX + +#else + +#ifdef PRId8 +#define FCML_PRI_INT8_DEC "%" PRId8 +#endif +#ifdef PRId16 +#define FCML_PRI_INT16_DEC "%" PRId16 +#endif +#ifdef PRId32 +#define FCML_PRI_INT32_DEC "%" PRId32 +#endif +#ifdef PRId64 +#define FCML_PRI_INT64_DEC "%" PRId64 +#endif + +#ifdef PRIu8 +#define FCML_PRI_UINT8_DEC "%" PRIu8 +#endif +#ifdef PRIu16 +#define FCML_PRI_UINT16_DEC "%" PRIu16 +#endif +#ifdef PRIu32 +#define FCML_PRI_UINT32_DEC "%" PRIu32 +#endif +#ifdef PRIu64 +#define FCML_PRI_UINT64_DEC "%" PRIu64 +#endif + +#ifdef PRIx8 +#define FCML_PRI_INT8_HEX "%02" PRIx8 +#endif +#ifdef PRIx16 +#define FCML_PRI_INT16_HEX "%04" PRIx16 +#endif +#ifdef PRIx32 +#define FCML_PRI_INT32_HEX "%08" PRIx32 +#endif +#ifdef PRIx64 +#define FCML_PRI_INT64_HEX "%016" PRIx64 +#endif + +#ifdef PRIx8 +#define FCML_PRI_INT8_HEX_NO_ZEROS "%" PRIx8 +#endif +#ifdef PRIx16 +#define FCML_PRI_INT16_HEX_NO_ZEROS "%" PRIx16 +#endif +#ifdef PRIx32 +#define FCML_PRI_INT32_HEX_NO_ZEROS "%" PRIx32 +#endif +#ifdef PRIx64 +#define FCML_PRI_INT64_HEX_NO_ZEROS "%" PRIx64 +#endif + +typedef int fcml_int; +typedef unsigned int fcml_uint; +typedef int fcml_bool; +typedef int8_t fcml_int8_t; +typedef uint8_t fcml_uint8_t; +typedef int16_t fcml_int16_t; +typedef uint16_t fcml_uint16_t; +typedef int32_t fcml_int32_t; +typedef uint32_t fcml_uint32_t; +typedef int64_t fcml_int64_t; +typedef uint64_t fcml_uint64_t; + +/* Signed integers. */ +#define FCML_INT64_MAX INT64_MAX +#define FCML_INT64_MIN INT64_MIN +#define FCML_INT32_MAX INT32_MAX +#define FCML_INT32_MIN INT32_MIN +#define FCML_INT16_MAX INT16_MAX +#define FCML_INT16_MIN INT16_MIN +#define FCML_INT8_MAX INT8_MAX +#define FCML_INT8_MIN INT8_MIN + +/* Unsigned integers. */ +#define FCML_UINT8_MAX UINT8_MAX +#define FCML_UINT16_MAX UINT16_MAX +#define FCML_UINT32_MAX UINT32_MAX +#define FCML_UINT64_MAX UINT64_MAX + +#endif + +typedef char fcml_char; +#define fcml_string char* +typedef float fcml_float; +typedef void* fcml_ptr; +typedef fcml_uint32_t fcml_flags; + +typedef fcml_uint32_t fcml_usize; +typedef fcml_int32_t fcml_size; + +#define FCML_TRUE 1 +#define FCML_FALSE 0 + +/* Macro for bit manipulations. */ + +#define FCML_TP_SET_BIT(x,y) ( ( x ) | ( 0x01 << ( y ) ) ) +#define FCML_TP_GET_BIT(x,y) ( ( x >> y ) & 0x01 ) +#define FCML_TP_CLEAR_BIT(x,y) ( ( x ) &= ~( 1 << ( y ) ) ) + +/* Nulleable types. */ + +typedef struct fcml_nuint8_t { + fcml_uint8_t value; + fcml_bool is_not_null; +} fcml_nuint8_t; + +typedef struct fcml_nuint16_t { + fcml_uint16_t value; + fcml_bool is_not_null; +} fcml_nuint16_t; + +typedef struct fcml_nuint32_t { + fcml_uint32_t value; + fcml_bool is_not_null; +} fcml_nuint32_t; + +typedef struct fcml_nuint64_t { + fcml_uint64_t value; + fcml_bool is_not_null; +} fcml_nuint64_t; + +typedef struct fcml_nint8_t { + fcml_int8_t value; + fcml_bool is_not_null; +} fcml_nint8_t; + +typedef struct fcml_nint16_t { + fcml_int16_t value; + fcml_bool is_not_null; +} fcml_nint16_t; + +typedef struct fcml_nint32_t { + fcml_int32_t value; + fcml_bool is_not_null; +} fcml_nint32_t; + +typedef struct fcml_nint64_t { + fcml_int64_t value; + fcml_bool is_not_null; +} fcml_nint64_t; + +typedef struct fcml_st_integer { + fcml_usize size; + fcml_bool is_signed; + // Data fields. + fcml_int8_t int8; + fcml_int16_t int16; + fcml_int32_t int32; + fcml_int64_t int64; +} fcml_st_integer; + +#define FCML_SET_VALUE(x, y) x.value = y; x.is_not_null = FCML_TRUE; +#define FCML_SET_NULL(x) x.value = 0; x.is_not_null = FCML_FALSE; +#define FCML_IS_NULL(x) ((x).is_not_null == FCML_FALSE) + +#endif /* FCML_TYPES_H_ */ diff --git a/include/llodctor_pe.hpp b/include/llodctor_pe.hpp index 6501d5f..18bd51d 100644 --- a/include/llodctor_pe.hpp +++ b/include/llodctor_pe.hpp @@ -1,5 +1,5 @@ #pragma once -#include "llodctor_base.hpp" +#include namespace llo::s1 { diff --git a/include/lloiff.hpp b/include/lloiff.hpp index 5d40296..a412e12 100644 --- a/include/lloiff.hpp +++ b/include/lloiff.hpp @@ -37,11 +37,6 @@ namespace llo std::vector< std::uint8_t > section_raw; }; - static std::shared_ptr< lloiff_t > begin( std::string &file_name ) - { - return std::make_shared< lloiff_t >( file_name ); - } - llo::utils::hash_t< std::string > get_name() const { return file_name; diff --git a/llo-s1.vcxproj b/llo-s1.vcxproj index 85ff895..f963414 100644 --- a/llo-s1.vcxproj +++ b/llo-s1.vcxproj @@ -11,6 +11,42 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -20,6 +56,9 @@ + + + @@ -58,9 +97,11 @@ true + $(ProjectDir)include;$(IncludePath);$(ProjectDir)include;$(ProjectDir)dependencies\fcml\include\ false + $(VC_IncludePath);$(WindowsSDK_IncludePath);;$(ProjectDir)include;$(ProjectDir)dependencies\fcml\include\ @@ -73,6 +114,7 @@ Console true + $(ProjectDir)dependencies\fcml\fcml.lib;%(AdditionalDependencies) @@ -90,6 +132,7 @@ true true true + $(ProjectDir)dependencies\fcml\fcml.lib;%(AdditionalDependencies) diff --git a/llo-s1.vcxproj.filters b/llo-s1.vcxproj.filters index 880198a..00bdcd7 100644 --- a/llo-s1.vcxproj.filters +++ b/llo-s1.vcxproj.filters @@ -12,6 +12,9 @@ {f02de5e5-e0f4-4244-a05f-45e095918bff} + + {2d5f480f-e425-4a2c-a285-81d679b2250d} + @@ -26,6 +29,114 @@ Header Files + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + @@ -39,5 +150,14 @@ Source Files + + Header Files\fcml + + + Header Files\fcml + + + Header Files\fcml + \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index 7fcf1da..56f7bb2 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,7 +1,10 @@ -#include "../include/llodctor_pe.hpp" -#include "../include/lloiff.hpp" +#define NOMINMAX +#include +#include +#include +#include -int main() +int __cdecl main( int argc, const char *argv[] ) { std::string file_name = "test.exe"; std::vector< std::uint8_t > image; @@ -9,8 +12,17 @@ int main() llo::lloiff_t iff( file_name ); llo::s1::dctor_pe_t pe_dctor( image ); - std::printf( "> iff name = %s, hash = 0x%p\n", - iff.get_name().get_data().c_str(), iff.get_name().get_hash() ); + std::printf( "> iff name = %s, hash = 0x%p\n", iff.get_name().get_data().c_str(), iff.get_name().get_hash() ); + + fcml_st_dialect *dialect; + fcml_fn_dialect_init_intel( FCML_INTEL_DIALECT_CF_DEFAULT, &dialect ); + + fcml_st_disassembler *disassembler; + fcml_fn_disassembler_init( dialect, &disassembler ); + + fcml_st_disassembler_result result; + fcml_st_disassembler_context context = { 0 }; + fcml_fn_disassembler_result_prepare( &result ); if ( !pe_dctor.generate( iff ) ) {