From cc1cb78e81a62956bc56364b4bd15acfb60ece83 Mon Sep 17 00:00:00 2001 From: _xeroxz Date: Sat, 26 Jun 2021 18:06:16 -0700 Subject: [PATCH] removed fcml, going to use xed, removed clutter... --- dependencies/fcml/fcml.dll | Bin 559104 -> 0 bytes dependencies/fcml/fcml.lib | Bin 58828 -> 0 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/llodctor_base.hpp | 4 +- include/llodctor/llodctor_bin.hpp | 0 include/llodctor/llodctor_coff.hpp | 25 + include/llodctor/llodctor_elf.hpp | 0 include/llodctor/llodctor_lib.hpp | 30 +- include/llodctor/llodctor_pe.hpp | 2 +- .../llodisposition/llodisposition_types.hpp | 24 - include/lloiff.hpp | 64 +- include/llosymbol/llosymbol_base.hpp | 35 - include/llosymbol/llosymbol_data.hpp | 0 include/llosymbol/llosymbol_export.hpp | 0 include/llosymbol/llosymbol_function.hpp | 0 include/llosymbol/llosymbol_import.hpp | 0 include/llosymbol/llosymbol_opaque.hpp | 23 - .../llosymbol_loader_base.hpp | 1 - .../llosymbol_loader_coff.hpp | 0 .../llosymbol_loader/llosymbol_loader_map.hpp | 2 +- .../llosymbol_loader/llosymbol_loader_pdb.hpp | 0 llo-s1.vcxproj | 58 +- llo-s1.vcxproj.filters | 173 +- src/llodctor/llodctor_coff.cpp | 18 + src/llodctor/llodctor_lib.cpp | 28 +- src/llodctor/llodctor_pe.cpp | 18 +- src/llodisposition/llodisposition_types.cpp | 8 - src/llosymbol/llosymbol_opaque.cpp | 25 - src/llosymbol_loader/llosymbol_loader_map.cpp | 6 +- src/main.cpp | 4 - 68 files changed, 74 insertions(+), 32498 deletions(-) delete mode 100644 dependencies/fcml/fcml.dll delete mode 100644 dependencies/fcml/fcml.lib delete mode 100644 dependencies/fcml/include/fcml_assembler.h delete mode 100644 dependencies/fcml/include/fcml_assembler.hpp delete mode 100644 dependencies/fcml/include/fcml_choosers.h delete mode 100644 dependencies/fcml/include/fcml_common.h delete mode 100644 dependencies/fcml/include/fcml_common.hpp delete mode 100644 dependencies/fcml/include/fcml_common_utils.h delete mode 100644 dependencies/fcml/include/fcml_dialect.h delete mode 100644 dependencies/fcml/include/fcml_dialect.hpp delete mode 100644 dependencies/fcml/include/fcml_disassembler.h delete mode 100644 dependencies/fcml/include/fcml_disassembler.hpp delete mode 100644 dependencies/fcml/include/fcml_env.h delete mode 100644 dependencies/fcml/include/fcml_errors.h delete mode 100644 dependencies/fcml/include/fcml_errors.hpp delete mode 100644 dependencies/fcml/include/fcml_gas_dialect.h delete mode 100644 dependencies/fcml/include/fcml_gas_dialect.hpp delete mode 100644 dependencies/fcml/include/fcml_gas_mnemonics.cpp delete mode 100644 dependencies/fcml/include/fcml_gas_mnemonics.h delete mode 100644 dependencies/fcml/include/fcml_gas_mnemonics.hpp delete mode 100644 dependencies/fcml/include/fcml_instructions.h delete mode 100644 dependencies/fcml/include/fcml_intel_dialect.h delete mode 100644 dependencies/fcml/include/fcml_intel_dialect.hpp delete mode 100644 dependencies/fcml/include/fcml_intel_mnemonics.cpp delete mode 100644 dependencies/fcml/include/fcml_intel_mnemonics.h delete mode 100644 dependencies/fcml/include/fcml_intel_mnemonics.hpp delete mode 100644 dependencies/fcml/include/fcml_lag_assembler.h delete mode 100644 dependencies/fcml/include/fcml_lag_assembler.hpp delete mode 100644 dependencies/fcml/include/fcml_lib_export.h delete mode 100644 dependencies/fcml/include/fcml_optimizers.h delete mode 100644 dependencies/fcml/include/fcml_parser.h delete mode 100644 dependencies/fcml/include/fcml_parser.hpp delete mode 100644 dependencies/fcml/include/fcml_registers.cpp delete mode 100644 dependencies/fcml/include/fcml_registers.hpp delete mode 100644 dependencies/fcml/include/fcml_renderer.h delete mode 100644 dependencies/fcml/include/fcml_renderer.hpp delete mode 100644 dependencies/fcml/include/fcml_stateful_assembler.hpp delete mode 100644 dependencies/fcml/include/fcml_stateful_disassembler.hpp delete mode 100644 dependencies/fcml/include/fcml_symbols.h delete mode 100644 dependencies/fcml/include/fcml_symbols.hpp delete mode 100644 dependencies/fcml/include/fcml_types.h delete mode 100644 include/llodctor/llodctor_bin.hpp create mode 100644 include/llodctor/llodctor_coff.hpp delete mode 100644 include/llodctor/llodctor_elf.hpp delete mode 100644 include/llodisposition/llodisposition_types.hpp delete mode 100644 include/llosymbol/llosymbol_base.hpp delete mode 100644 include/llosymbol/llosymbol_data.hpp delete mode 100644 include/llosymbol/llosymbol_export.hpp delete mode 100644 include/llosymbol/llosymbol_function.hpp delete mode 100644 include/llosymbol/llosymbol_import.hpp delete mode 100644 include/llosymbol/llosymbol_opaque.hpp delete mode 100644 include/llosymbol_loader/llosymbol_loader_coff.hpp delete mode 100644 include/llosymbol_loader/llosymbol_loader_pdb.hpp create mode 100644 src/llodctor/llodctor_coff.cpp delete mode 100644 src/llodisposition/llodisposition_types.cpp delete mode 100644 src/llosymbol/llosymbol_opaque.cpp diff --git a/dependencies/fcml/fcml.dll b/dependencies/fcml/fcml.dll deleted file mode 100644 index 4f9d23de7f235f5b91bc80c612a7441358bc67e9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 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% diff --git a/dependencies/fcml/include/fcml_assembler.h b/dependencies/fcml/include/fcml_assembler.h deleted file mode 100644 index 3018c86..0000000 --- a/dependencies/fcml/include/fcml_assembler.h +++ /dev/null @@ -1,227 +0,0 @@ -/* - * 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 deleted file mode 100644 index 4fc57dd..0000000 --- a/dependencies/fcml/include/fcml_assembler.hpp +++ /dev/null @@ -1,946 +0,0 @@ -/* - * 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 deleted file mode 100644 index 24469b0..0000000 --- a/dependencies/fcml/include/fcml_choosers.h +++ /dev/null @@ -1,87 +0,0 @@ -/* - * 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 deleted file mode 100644 index bd3d6a0..0000000 --- a/dependencies/fcml/include/fcml_common.h +++ /dev/null @@ -1,832 +0,0 @@ -/* - * 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 deleted file mode 100644 index ba801a6..0000000 --- a/dependencies/fcml/include/fcml_common.hpp +++ /dev/null @@ -1,9142 +0,0 @@ -/* - * 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 deleted file mode 100644 index 29363ea..0000000 --- a/dependencies/fcml/include/fcml_common_utils.h +++ /dev/null @@ -1,660 +0,0 @@ -/* - * 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 deleted file mode 100644 index 75571c5..0000000 --- a/dependencies/fcml/include/fcml_dialect.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * 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 deleted file mode 100644 index 1bea71c..0000000 --- a/dependencies/fcml/include/fcml_dialect.hpp +++ /dev/null @@ -1,129 +0,0 @@ -/* - * 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 deleted file mode 100644 index 00da9e9..0000000 --- a/dependencies/fcml/include/fcml_disassembler.h +++ /dev/null @@ -1,356 +0,0 @@ -/* - * 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 deleted file mode 100644 index 4660e5c..0000000 --- a/dependencies/fcml/include/fcml_disassembler.hpp +++ /dev/null @@ -1,2329 +0,0 @@ -/* - * 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 deleted file mode 100644 index 7813884..0000000 --- a/dependencies/fcml/include/fcml_env.h +++ /dev/null @@ -1,96 +0,0 @@ -/* - * 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 deleted file mode 100644 index 3e5fb26..0000000 --- a/dependencies/fcml/include/fcml_errors.h +++ /dev/null @@ -1,187 +0,0 @@ -/* - * 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 deleted file mode 100644 index 2057094..0000000 --- a/dependencies/fcml/include/fcml_errors.hpp +++ /dev/null @@ -1,388 +0,0 @@ -/* - * 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 deleted file mode 100644 index a0e0697..0000000 --- a/dependencies/fcml/include/fcml_gas_dialect.h +++ /dev/null @@ -1,62 +0,0 @@ -/* - * 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 deleted file mode 100644 index 7080193..0000000 --- a/dependencies/fcml/include/fcml_gas_dialect.hpp +++ /dev/null @@ -1,66 +0,0 @@ -/* - * 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 deleted file mode 100644 index 4623b13..0000000 --- a/dependencies/fcml/include/fcml_gas_mnemonics.cpp +++ /dev/null @@ -1,1934 +0,0 @@ -/* - * 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 deleted file mode 100644 index f12e38e..0000000 --- a/dependencies/fcml/include/fcml_gas_mnemonics.h +++ /dev/null @@ -1,1931 +0,0 @@ -/* - * 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 deleted file mode 100644 index 4c11198..0000000 --- a/dependencies/fcml/include/fcml_gas_mnemonics.hpp +++ /dev/null @@ -1,1938 +0,0 @@ -/* - * 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 deleted file mode 100644 index b919567..0000000 --- a/dependencies/fcml/include/fcml_instructions.h +++ /dev/null @@ -1,1548 +0,0 @@ -/* - * 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 deleted file mode 100644 index f8073b7..0000000 --- a/dependencies/fcml/include/fcml_intel_dialect.h +++ /dev/null @@ -1,58 +0,0 @@ -/* - * 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 deleted file mode 100644 index 65693c5..0000000 --- a/dependencies/fcml/include/fcml_intel_dialect.hpp +++ /dev/null @@ -1,66 +0,0 @@ -/* - * 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 deleted file mode 100644 index 223bfe2..0000000 --- a/dependencies/fcml/include/fcml_intel_mnemonics.cpp +++ /dev/null @@ -1,1716 +0,0 @@ -/* - * 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 deleted file mode 100644 index 44fdc6a..0000000 --- a/dependencies/fcml/include/fcml_intel_mnemonics.h +++ /dev/null @@ -1,1715 +0,0 @@ -/* - * 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 deleted file mode 100644 index c3930e2..0000000 --- a/dependencies/fcml/include/fcml_intel_mnemonics.hpp +++ /dev/null @@ -1,1724 +0,0 @@ -/* - * 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 deleted file mode 100644 index 760347a..0000000 --- a/dependencies/fcml/include/fcml_lag_assembler.h +++ /dev/null @@ -1,121 +0,0 @@ -/* - * 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 deleted file mode 100644 index 62a03fe..0000000 --- a/dependencies/fcml/include/fcml_lag_assembler.hpp +++ /dev/null @@ -1,479 +0,0 @@ -/* - * 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 deleted file mode 100644 index 3390cda..0000000 --- a/dependencies/fcml/include/fcml_lib_export.h +++ /dev/null @@ -1,63 +0,0 @@ -/* - * 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 deleted file mode 100644 index 9c3dbfd..0000000 --- a/dependencies/fcml/include/fcml_optimizers.h +++ /dev/null @@ -1,144 +0,0 @@ -/* - * 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 deleted file mode 100644 index 450a966..0000000 --- a/dependencies/fcml/include/fcml_parser.h +++ /dev/null @@ -1,166 +0,0 @@ -/* - * 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 deleted file mode 100644 index f8d8e15..0000000 --- a/dependencies/fcml/include/fcml_parser.hpp +++ /dev/null @@ -1,486 +0,0 @@ -/* - * 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 deleted file mode 100644 index c9c25e6..0000000 --- a/dependencies/fcml/include/fcml_registers.cpp +++ /dev/null @@ -1,288 +0,0 @@ -/* - * 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 deleted file mode 100644 index 4bc76b2..0000000 --- a/dependencies/fcml/include/fcml_registers.hpp +++ /dev/null @@ -1,288 +0,0 @@ -/* - * 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 deleted file mode 100644 index bb5a124..0000000 --- a/dependencies/fcml/include/fcml_renderer.h +++ /dev/null @@ -1,124 +0,0 @@ -/* - * 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 deleted file mode 100644 index 962b966..0000000 --- a/dependencies/fcml/include/fcml_renderer.hpp +++ /dev/null @@ -1,226 +0,0 @@ -/* - * 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 deleted file mode 100644 index b87cc00..0000000 --- a/dependencies/fcml/include/fcml_stateful_assembler.hpp +++ /dev/null @@ -1,554 +0,0 @@ -/* - * 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 deleted file mode 100644 index 83c6e54..0000000 --- a/dependencies/fcml/include/fcml_stateful_disassembler.hpp +++ /dev/null @@ -1,210 +0,0 @@ -/* - * 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 deleted file mode 100644 index 68fa5a6..0000000 --- a/dependencies/fcml/include/fcml_symbols.h +++ /dev/null @@ -1,149 +0,0 @@ -/* - * 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 deleted file mode 100644 index 2ec3049..0000000 --- a/dependencies/fcml/include/fcml_symbols.hpp +++ /dev/null @@ -1,265 +0,0 @@ -/* - * 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 deleted file mode 100644 index fe9ecd8..0000000 --- a/dependencies/fcml/include/fcml_types.h +++ /dev/null @@ -1,271 +0,0 @@ -/* - * 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/llodctor_base.hpp b/include/llodctor/llodctor_base.hpp index fbc7959..25c5095 100644 --- a/include/llodctor/llodctor_base.hpp +++ b/include/llodctor/llodctor_base.hpp @@ -16,7 +16,7 @@ namespace llo::s1 /// /// vector of bytes containing the raw image to be deconstructed... /// - std::vector< std::uint8_t > raw_img; + std::vector< std::uint8_t > img; /// /// symbol loader used when generating iff... @@ -30,7 +30,7 @@ namespace llo::s1 /// vector of bytes containing the raw image... explicit dctor_base_t( const std::vector< std::uint8_t > &image, llo::s1::symbol_loader_base_t *symbol_loader = nullptr ) - : raw_img{ image }, symbol_loader{ symbol_loader } + : img{ image }, symbol_loader{ symbol_loader } { } diff --git a/include/llodctor/llodctor_bin.hpp b/include/llodctor/llodctor_bin.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/include/llodctor/llodctor_coff.hpp b/include/llodctor/llodctor_coff.hpp new file mode 100644 index 0000000..6d86bdb --- /dev/null +++ b/include/llodctor/llodctor_coff.hpp @@ -0,0 +1,25 @@ +#pragma once +#include +#include +#include + +namespace llo::s1 +{ + class dctor_coff_t : public dctor_base_t + { + friend class dctor_lib_t; + protected: + const coff::image_t *img_header; + const std::uint32_t num_sections; + + public: + explicit dctor_coff_t( const std::vector< std::uint8_t > &image, + llo::s1::symbol_loader_base_t *symbol_loader = nullptr ) + : dctor_base_t( image, symbol_loader ), img_header( ( coff::image_t * )img.data() ), + num_sections( img_header->file_header.num_sections ) + { + } + + void generate( lloiff_t &iff ) override; + }; +} // namespace llo::s1 \ No newline at end of file diff --git a/include/llodctor/llodctor_elf.hpp b/include/llodctor/llodctor_elf.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/include/llodctor/llodctor_lib.hpp b/include/llodctor/llodctor_lib.hpp index c3a82e2..dbf7aa5 100644 --- a/include/llodctor/llodctor_lib.hpp +++ b/include/llodctor/llodctor_lib.hpp @@ -1,23 +1,11 @@ -#include -#include -#include +#pragma once +#include namespace llo::s1 { class dctor_lib_t : public dctor_base_t { - struct obj_t - { - std::string_view name; - std::vector< std::uint8_t > raw; - - coff::image_t *operator->() - { - return reinterpret_cast< coff::image_t * >( raw.data() ); - } - }; - - std::vector< obj_t > objs; + std::vector< std::pair< std::string, std::shared_ptr< llo::s1::dctor_coff_t > > > coff_dctors; public: explicit dctor_lib_t( const std::vector< std::uint8_t > &image, @@ -25,12 +13,12 @@ namespace llo::s1 : dctor_base_t( image, symbol_loader ) { ar::view lib( image.data(), image.size() ); - - for ( auto itr = lib.begin(); itr != lib.end(); ++itr ) - { - std::vector obj_data( itr->begin(), itr->end() ); - objs.push_back( { itr->to_string( lib.string_table ), obj_data } ); - } + std::for_each( lib.begin(), lib.end(), [ & ]( const auto obj_meta ) { + const auto [ obj_name, obj_entry ] = obj_meta; + std::vector obj_data( obj_entry.begin(), obj_entry.end() ); + coff_dctors.push_back( { std::string( obj_entry.to_string( lib.string_table ) ), + std::make_shared< llo::s1::dctor_coff_t >( obj_data ) } ); + } ); } void generate( lloiff_t &iff ) override; }; diff --git a/include/llodctor/llodctor_pe.hpp b/include/llodctor/llodctor_pe.hpp index ee92895..1a7df5b 100644 --- a/include/llodctor/llodctor_pe.hpp +++ b/include/llodctor/llodctor_pe.hpp @@ -16,7 +16,7 @@ namespace llo::s1 llo::s1::symbol_loader_base_t *symbol_loader = nullptr ) : dctor_base_t( image, symbol_loader ) { - dos_header = reinterpret_cast< win::dos_header_t * >( raw_img.data() ); + dos_header = reinterpret_cast< win::dos_header_t * >( img.data() ); sections = dos_header->get_nt_headers()->get_sections(); section_count = dos_header->get_nt_headers()->file_header.num_sections; entry_point = dos_header->get_nt_headers()->optional_header.entry_point; diff --git a/include/llodisposition/llodisposition_types.hpp b/include/llodisposition/llodisposition_types.hpp deleted file mode 100644 index 99975a8..0000000 --- a/include/llodisposition/llodisposition_types.hpp +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once -#include -#include - -namespace llo -{ - class disposition_t - { - public: - explicit disposition_t( const llo::utils::hash_t< std::string > &iff_name, - const llo::utils::hash_t< std::string > §ion_name, std::uint32_t section_offset ) - : iff_name( iff_name ), section_name( section_name ), offset( section_offset ) - { - } - - static std::shared_ptr< disposition_t > make( const llo::utils::hash_t< std::string > &iff_name, - const llo::utils::hash_t< std::string > §ion_name, - std::uint32_t section_offset ); - - llo::utils::hash_t< std::string > iff_name; - llo::utils::hash_t< std::string > section_name; - std::uint32_t offset; - }; -} // namespace llo \ No newline at end of file diff --git a/include/lloiff.hpp b/include/lloiff.hpp index 9582f5b..f171260 100644 --- a/include/lloiff.hpp +++ b/include/lloiff.hpp @@ -1,12 +1,10 @@ #pragma once #include +#include #include #include #include -#include -#include - namespace llo { /// @@ -25,60 +23,6 @@ namespace llo /// llo::utils::hash_t< std::string > section_name; - /// - /// section protections... - /// - struct prot_t - { - /// - /// section protection types... - /// - enum prot_e : std::uint16_t - { - none = 0b0000, - executable = 0b0001, - writeable = 0b0010 - }; - - /// - /// IL section protections (writeable/executable)... - /// - prot_e prots; - - /// - /// opaque value containing the native characteristics... - /// - std::uint64_t native; - - /// - /// returns true if section is executable... - /// - /// - bool is_executable() - { - return ( prots & prot_e::executable ); - } - - /// - /// returns true if section is writable... - /// - /// - bool is_writable() - { - return ( prots & prot_e::writeable ); - } - }; - - /// - /// section protections and characteristics - /// - prot_t protections; - - /// - /// vector of symbols for this section... - /// - std::vector< std::shared_ptr< llo::symbol::symbol_base_t > > symbols; - /// /// vector of raw bytes containing the original bytes of this section... /// @@ -105,12 +49,6 @@ namespace llo return std::make_shared< llo::lloiff_t >( name, raw ); } - /// - /// entry point, where code execution begins.... - /// this is lifted from the underlying file format... - /// - std::shared_ptr< disposition_t > entry; - /// /// name of the iff file, hashed so there can be unique objects... /// diff --git a/include/llosymbol/llosymbol_base.hpp b/include/llosymbol/llosymbol_base.hpp deleted file mode 100644 index cc0f8bb..0000000 --- a/include/llosymbol/llosymbol_base.hpp +++ /dev/null @@ -1,35 +0,0 @@ -#pragma once -#include -#include -#include - -namespace llo::symbol -{ - enum class symbol_type_t : std::uint8_t - { - s_invalid, - s_function, - s_data, - s_import, - s_export, - s_opaque - }; - - class symbol_base_t - { - protected: - disposition_t disposition; - llo::utils::hash_t< std::string > symbol_name; - std::size_t symbol_size; - - public: - explicit symbol_base_t( const llo::utils::hash_t< std::string > &symbol_name, - const llo::disposition_t &disposition ) - : disposition( disposition ), symbol_name( symbol_name ) - { - } - - virtual symbol_type_t get_type() const = 0; - virtual std::size_t get_size() const = 0; - }; -} // namespace llo::symbol \ No newline at end of file diff --git a/include/llosymbol/llosymbol_data.hpp b/include/llosymbol/llosymbol_data.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/include/llosymbol/llosymbol_export.hpp b/include/llosymbol/llosymbol_export.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/include/llosymbol/llosymbol_function.hpp b/include/llosymbol/llosymbol_function.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/include/llosymbol/llosymbol_import.hpp b/include/llosymbol/llosymbol_import.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/include/llosymbol/llosymbol_opaque.hpp b/include/llosymbol/llosymbol_opaque.hpp deleted file mode 100644 index 7d33ccf..0000000 --- a/include/llosymbol/llosymbol_opaque.hpp +++ /dev/null @@ -1,23 +0,0 @@ -#include - -namespace llo::symbol -{ - class symbol_opaque_t : public symbol_base_t - { - symbol_type_t type = symbol_type_t::s_opaque; - - public: - explicit symbol_opaque_t( const llo::utils::hash_t< std::string > &symbol_name, - const llo::disposition_t &disposition ) - : symbol_base_t( symbol_name, disposition ) - { - } - - static std::shared_ptr< symbol_opaque_t > make( const llo::utils::hash_t< std::string > &symbol_name, - const llo::disposition_t &disposition ); - - void set_size( std::size_t size ); - symbol_type_t get_type() const override; - std::size_t get_size() const override; - }; -} // namespace llo::symbol \ No newline at end of file diff --git a/include/llosymbol_loader/llosymbol_loader_base.hpp b/include/llosymbol_loader/llosymbol_loader_base.hpp index e4411d0..5fdad1a 100644 --- a/include/llosymbol_loader/llosymbol_loader_base.hpp +++ b/include/llosymbol_loader/llosymbol_loader_base.hpp @@ -1,7 +1,6 @@ #pragma once #include #include -#include #include #include #include diff --git a/include/llosymbol_loader/llosymbol_loader_coff.hpp b/include/llosymbol_loader/llosymbol_loader_coff.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/include/llosymbol_loader/llosymbol_loader_map.hpp b/include/llosymbol_loader/llosymbol_loader_map.hpp index f0d1eb2..50b415e 100644 --- a/include/llosymbol_loader/llosymbol_loader_map.hpp +++ b/include/llosymbol_loader/llosymbol_loader_map.hpp @@ -1,4 +1,4 @@ -#include +#pragma once #include namespace llo::s1 diff --git a/include/llosymbol_loader/llosymbol_loader_pdb.hpp b/include/llosymbol_loader/llosymbol_loader_pdb.hpp deleted file mode 100644 index e69de29..0000000 diff --git a/llo-s1.vcxproj b/llo-s1.vcxproj index 1b6bf95..068ea48 100644 --- a/llo-s1.vcxproj +++ b/llo-s1.vcxproj @@ -12,42 +12,6 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -80,22 +44,12 @@ - - + - - - - - - - - - @@ -103,13 +57,9 @@ - - - + - - @@ -165,7 +115,7 @@ Console true - $(ProjectDir)dependencies\fcml\fcml.lib;%(AdditionalDependencies) + %(AdditionalDependencies) true true @@ -185,7 +135,7 @@ true true true - $(ProjectDir)dependencies\fcml\fcml.lib;%(AdditionalDependencies) + %(AdditionalDependencies) true true diff --git a/llo-s1.vcxproj.filters b/llo-s1.vcxproj.filters index 6076016..b878e66 100644 --- a/llo-s1.vcxproj.filters +++ b/llo-s1.vcxproj.filters @@ -12,21 +12,12 @@ {f02de5e5-e0f4-4244-a05f-45e095918bff} - - {2d5f480f-e425-4a2c-a285-81d679b2250d} - - - {acb72df0-efc5-4108-9db8-850ed74acd41} - {3c515f99-13ba-45a0-a80e-c7cbff3c5e85} {9e42261f-c0b7-4650-8d5d-4682ee99948e} - - {3c4da18e-ebe9-4cf0-8edc-025d26da4d13} - {6d02947c-bc11-46d5-a571-5ed1ec5c54cb} @@ -48,12 +39,6 @@ {9bd2b0b0-4ae2-4d9d-8620-4b596f84d20d} - - {4370901a-12c1-43ce-883a-6a6c3f48845a} - - - {6eecf6e2-47aa-4bf3-97ce-e34688ad8ae3} - @@ -62,156 +47,18 @@ 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 - - - Header Files\llosymbol - - - Header Files\llosymbol - - - Header Files\llosymbol - - - Header Files\llosymbol - - - Header Files\llosymbol - - - Header Files\llosymbol - Header Files\llosymbol_loader Header Files\llosymbol_loader - - Header Files\llosymbol_loader - Header Files\llodctor - - Header Files\llodctor - - - Header Files\llodctor - Header Files\llodctor - - Header Files\llodisposition - Header Files\llodctor @@ -311,8 +158,8 @@ Header Files\linux-pe\coff\auxiliaries - - Header Files\llosymbol_loader + + Header Files\llodctor @@ -327,15 +174,6 @@ Source Files - - Header Files\fcml - - - Header Files\fcml - - - Header Files\fcml - Source Files\llodctor @@ -345,11 +183,8 @@ Source Files\llodctor - - Source Files\llodisposition - - - Source Files\llosymbol + + Source Files\llodctor \ No newline at end of file diff --git a/src/llodctor/llodctor_coff.cpp b/src/llodctor/llodctor_coff.cpp new file mode 100644 index 0000000..025663e --- /dev/null +++ b/src/llodctor/llodctor_coff.cpp @@ -0,0 +1,18 @@ +#include + +namespace llo::s1 +{ + void dctor_coff_t::generate( lloiff_t &iff ) + { + std::for_each( img_header->get_sections(), img_header->get_sections() + num_sections, + [ & ]( const coff::section_header_t section_header ) { + lloiff_t::iff_section_t section{ + std::string( section_header.name.to_string( img_header->get_strings() ) ) }; + + section.raw = { img.data() + section_header.ptr_raw_data, + img.data() + section_header.ptr_raw_data + section_header.size_raw_data }; + + iff.sections.emplace_back( section ); + } ); + } +} // namespace llo::s1 \ No newline at end of file diff --git a/src/llodctor/llodctor_lib.cpp b/src/llodctor/llodctor_lib.cpp index dc4aeff..ab8ed61 100644 --- a/src/llodctor/llodctor_lib.cpp +++ b/src/llodctor/llodctor_lib.cpp @@ -2,28 +2,10 @@ void llo::s1::dctor_lib_t::generate( lloiff_t &iff ) { - // add obj as children to the IFF as the IFF passed in is simply - // the LIB... also add section information for each... - std::for_each( objs.begin(), objs.end(), [ & ]( llo::s1::dctor_lib_t::obj_t &obj ) { - // use llo::lloiff::make to make a std::shared_ptr... - iff.children.push_back( iff.make( std::string( obj.name ), obj.raw ) ); - - // add sections to last IFF... - for ( auto idx = 0u; idx < obj->file_header.num_sections; ++idx ) - { - auto obj_section = obj->get_section( idx ); - std::string section_name( obj_section->name.to_string( obj->get_strings() ) ); - llo::lloiff_t::iff_section_t section{ section_name }; - - section.protections.native = obj_section->prots.flags; - section.raw.insert( section.raw.begin(), obj_section->ptr_raw_data + obj.raw.data(), - obj_section->size_raw_data + obj_section->ptr_raw_data + obj.raw.data() ); - - iff.children.back()->sections.push_back( section ); - } + // for each obj in the lib --> make a new iff child and run dctor generation upon it... + std::for_each( coff_dctors.begin(), coff_dctors.end(), [ & ]( const auto &dctor_meta ) { + const auto [ img_name, dctor ] = dctor_meta; + auto iff_child = llo::lloiff_t::make( img_name, dctor->img ); + dctor->generate( *iff.children.emplace_back( iff_child ).get() ); } ); - - // coff symbol loader... - if ( symbol_loader ) - symbol_loader->load( iff ); } \ No newline at end of file diff --git a/src/llodctor/llodctor_pe.cpp b/src/llodctor/llodctor_pe.cpp index 7dc6dc7..f52896e 100644 --- a/src/llodctor/llodctor_pe.cpp +++ b/src/llodctor/llodctor_pe.cpp @@ -5,22 +5,10 @@ void llo::s1::dctor_pe_t::generate( lloiff_t &iff ) // lift section information to iff... for ( auto idx = 0u; idx < section_count; ++idx ) { - llo::utils::hash_t< std::string > section_name{ std::string( sections[ idx ].name.to_string() ) }; - llo::lloiff_t::iff_section_t section{ section_name }; - section.protections.native = sections[ idx ].prots.flags; + iff.sections.push_back( { std::string( sections[ idx ].name.to_string() ), + { img.data(), img.data() + sections[ idx ].ptr_raw_data } } ); - // check to see if this section contains the entry point of the module... - if ( entry_point >= sections[ idx ].virtual_address && - entry_point < sections[ idx ].virtual_address + sections[ idx ].virtual_size ) - { - // lift entry point to iff... - iff.entry = - llo::disposition_t::make( iff.name, section_name, ( entry_point - sections[ idx ].virtual_address ) ); - } - - // copy the sections raw bytes... - section.raw.insert( section.raw.begin(), raw_img.data(), raw_img.data() + sections[ idx ].ptr_raw_data ); - iff.sections.push_back( section ); + // TODO... more information probably can be lifted/added... } // run symbol loader pass... this could be pdb, map, etc... diff --git a/src/llodisposition/llodisposition_types.cpp b/src/llodisposition/llodisposition_types.cpp deleted file mode 100644 index bde7350..0000000 --- a/src/llodisposition/llodisposition_types.cpp +++ /dev/null @@ -1,8 +0,0 @@ -#include - -std::shared_ptr< llo::disposition_t > llo::disposition_t::make( const llo::utils::hash_t< std::string > &iff_name, - const llo::utils::hash_t< std::string > §ion_name, - std::uint32_t section_offset ) -{ - return std::make_shared< llo::disposition_t >( iff_name, section_name, section_offset ); -} \ No newline at end of file diff --git a/src/llosymbol/llosymbol_opaque.cpp b/src/llosymbol/llosymbol_opaque.cpp deleted file mode 100644 index 2ae2b43..0000000 --- a/src/llosymbol/llosymbol_opaque.cpp +++ /dev/null @@ -1,25 +0,0 @@ -#include - -namespace llo::symbol -{ - std::shared_ptr< symbol_opaque_t > symbol_opaque_t::make( const llo::utils::hash_t< std::string > &symbol_name, - const llo::disposition_t &disposition ) - { - return std::make_shared< symbol_opaque_t >( symbol_name, disposition ); - } - - symbol_type_t symbol_opaque_t::get_type() const - { - return type; - } - - std::size_t symbol_opaque_t::get_size() const - { - return symbol_size; - } - - void symbol_opaque_t::set_size( std::size_t size ) - { - symbol_size = size; - } -} // namespace llo::symbol \ No newline at end of file diff --git a/src/llosymbol_loader/llosymbol_loader_map.cpp b/src/llosymbol_loader/llosymbol_loader_map.cpp index 218b17c..3c50bff 100644 --- a/src/llosymbol_loader/llosymbol_loader_map.cpp +++ b/src/llosymbol_loader/llosymbol_loader_map.cpp @@ -34,11 +34,7 @@ bool llo::s1::symbol_loader_map_t::load( llo::lloiff_t &iff ) if ( !section_number ) continue; - // insert new opaque symbol into symbols list... - llo::disposition_t disposition( iff.name, iff.sections[ section_number - 1 ].section_name, section_offset ); - auto new_opaque_symbol = llo::symbol::symbol_opaque_t::make( symbol_name, disposition ); - iff.sections[ section_number - 1 ].symbols.push_back( new_opaque_symbol ); + // TODO do something with these symbols... } - return true; } \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index 2ceb500..851b131 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -95,15 +95,11 @@ int __cdecl main( int argc, const char *argv[] ) std::printf( "> iff number of children = %d\n", iff.children.size() ); for ( auto &child : iff.children ) { - if ( iff.entry.get() ) - std::printf( "> entry section name = %s, section offest = 0x%x\n", - iff.entry->section_name.get_data().c_str(), iff.entry->offset ); for ( auto §ion : child->sections ) { std::printf( "> section name = %s\n", section.section_name.get_data().c_str() ); std::printf( "> size of raw section = %d\n", section.raw.size() ); - std::printf( "> number of symbols = %d\n", section.symbols.size() ); } } } \ No newline at end of file